From d5e90c4047ee5f04492f08491e59c198ca11ef91 Mon Sep 17 00:00:00 2001
From: Cam Quilici <cjquilici@gmail.com>
Date: Thu, 17 Sep 2026 12:29:07 -0500
Subject: [PATCH 001/103] feat(powerx): digest gpu_metrics telemetry into the
 database at ingest time

PowerX read chip telemetry by downloading and parsing gpu_metrics GitHub
artifacts on every page view, and lost the data once GitHub's 90-day
artifact retention expired. This moves that work to ingest time.

- Migration 016 adds gpu_metric_series (one row per artifact CSV),
  gpu_metric_samples (full-resolution per-GPU samples), gpu_metric_gpu_stats
  (per-GPU min/max/mean/median/p95/p99/stddev digest), and
  benchmark_result_gpu_metrics (point <-> series links).
- A pure nvidia-smi/amd-smi CSV parser plus artifact discovery and an
  idempotent upsert (same CSV hash refreshes links only; a changed CSV
  replaces samples and digest in one transaction).
- CI ingest links gpu_metrics_<suffix> next to bmk_<suffix> using the same
  pairing rule as server logs.
- New backfill CLI: bun run admin:db:backfill-gpu-metrics --all --yes
  (bounded by GitHub retention; the GCS backup does not mirror gpu_metrics).
- /api/gpu-metrics serves the stored digest first and falls back to live
  GitHub artifacts for runs that are not ingested yet.
- New /api/v1/gpu-metrics-point?id=N and a PowerX tab on the per-point
  detail page showing the telemetry recorded while that point ran.
- Shared benchmark-result lookup extracted from the server-log backfill.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 AGENTS.md                                     |   1 +
 docs/data-pipeline.md                         |  40 ++
 package.json                                  |   1 +
 .../app/src/app/api/gpu-metrics/route.test.ts | 223 +++++++++-
 packages/app/src/app/api/gpu-metrics/route.ts |  96 ++++-
 .../src/app/api/v1/gpu-metrics-point/route.ts |  39 ++
 .../agentic-point/agentic-point-detail.tsx    |   6 +
 .../agentic-point/power-telemetry-view.tsx    | 255 ++++++++++++
 .../agentic-point/use-detail-view.test.tsx    |  22 +
 .../agentic-point/use-detail-view.ts          |   8 +-
 .../src/hooks/api/use-gpu-metrics-point.ts    |  18 +
 packages/constants/src/tables.ts              |   4 +
 packages/db/migrations/016_gpu_metrics.sql    |  99 +++++
 packages/db/package.json                      |   1 +
 packages/db/src/backfill-gpu-metrics.ts       | 303 ++++++++++++++
 packages/db/src/backfill-server-log-files.ts  |  97 +----
 .../db/src/etl/gpu-metrics-artifacts.test.ts  |  98 +++++
 packages/db/src/etl/gpu-metrics-artifacts.ts  | 173 ++++++++
 packages/db/src/etl/gpu-metrics-csv.test.ts   | 143 +++++++
 packages/db/src/etl/gpu-metrics-csv.ts        | 385 ++++++++++++++++++
 .../db/src/etl/gpu-metrics-ingest.test.ts     | 203 +++++++++
 packages/db/src/etl/gpu-metrics-ingest.ts     | 297 ++++++++++++++
 packages/db/src/ingest-ci-run.ts              |  35 ++
 .../db/src/lib/benchmark-result-lookup.ts     |  97 +++++
 .../db/src/lib/gpu-metrics-backfill.test.ts   |  49 +++
 packages/db/src/lib/gpu-metrics-backfill.ts   |  47 +++
 packages/db/src/queries/gpu-metrics.ts        | 342 ++++++++++++++++
 packages/db/src/verify-db.ts                  |   3 +
 28 files changed, 2987 insertions(+), 98 deletions(-)
 create mode 100644 packages/app/src/app/api/v1/gpu-metrics-point/route.ts
 create mode 100644 packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
 create mode 100644 packages/app/src/hooks/api/use-gpu-metrics-point.ts
 create mode 100644 packages/db/migrations/016_gpu_metrics.sql
 create mode 100644 packages/db/src/backfill-gpu-metrics.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-artifacts.test.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-artifacts.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-csv.test.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-csv.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-ingest.test.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-ingest.ts
 create mode 100644 packages/db/src/lib/benchmark-result-lookup.ts
 create mode 100644 packages/db/src/lib/gpu-metrics-backfill.test.ts
 create mode 100644 packages/db/src/lib/gpu-metrics-backfill.ts
 create mode 100644 packages/db/src/queries/gpu-metrics.ts

diff --git a/AGENTS.md b/AGENTS.md
index f9bd2c868..ad909b256 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -76,6 +76,7 @@ API routes (`packages/app/src/app/api/v1/`):
 - `reliability` — raw `ReliabilityRow[]`
 - `evaluations` — raw `EvalRow[]`
 - `server-log` — retrieve benchmark runtime logs
+- `gpu-metrics-point?id=N` — PowerX chip telemetry (samples + per-GPU digest) linked to one benchmark point
 - `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
diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index 89b532996..ebafd3005 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -523,6 +523,46 @@ Producers (`aggregate_power.py`) annotate every aggregate result row with two op
 
 Reads are **permanently tolerant**: `queries/benchmarks.ts` selects the columns as `to_jsonb(br) -> 'power_invalid_reasons'` (and `lb` on the matview branch) rather than bare column references. A bare reference fails during query planning until the next ingest workflow applies the migration, because migrations run in the ingest workflows rather than at Vercel deploy. The key lookup degrades to NULL while the column is missing and is byte-identical once it exists, making deploy order irrelevant.
 
+### PowerX Telemetry Digest (`gpu_metric_*`, migration 016)
+
+Every benchmark job samples `nvidia-smi` / `amd-smi` once per second for its
+whole lifetime and uploads the CSV as `gpu_metrics_<suffix>` next to
+`bmk_<suffix>` (agentic jobs: `bmk_agentic_<suffix>`, still paired by the bare
+suffix). The PowerX explorer used to download and parse those artifacts from
+GitHub on every request and lost them after GitHub's 90-day retention. CI ingest
+now digests them at ingest time, in the same step that links server logs:
+
+- `gpu_metric_series` — one row per (workflow run, artifact, CSV path): vendor,
+  CSV sha256, sample count, GPU count, recorded window, median cadence, and the
+  parsed sidecars (`gpu_metrics_context.json`, identity, amd-smi energy counters).
+- `gpu_metric_samples` — full-resolution rows, one per (GPU, sample). NVIDIA
+  fills the six common columns; AMD additionally fills edge/memory temperature,
+  voltages, FCLK/SOCCLK and multimedia activity. Timestamps are UTC; NVIDIA's
+  zone-less `YYYY/MM/DD HH:MM:SS.mmm` is interpreted with the context sidecar's
+  `timestamp_timezone` (the producer writes UTC).
+- `gpu_metric_gpu_stats` — per (series, GPU, metric) count/min/max/mean/median/
+  p95/p99/stddev computed once at ingest so readers never rescan samples.
+- `benchmark_result_gpu_metrics` — links each benchmark point to the series that
+  was recorded while it ran (several series per point for multinode artifacts).
+
+Ingest is idempotent: the same CSV hash refreshes only the point links, a changed
+CSV replaces the samples and digest inside one transaction, and repeated final
+samples (the monitor's stop-time flush) collapse on the primary key. Series are
+stored per artifact, not per point: an AgentX per-concurrency job maps to one
+point, while older fixed-sequence jobs that swept several concurrencies in one
+job share one series across points. Windowing a series to the measured serving
+interval is a reader concern; the raw series deliberately includes server
+start-up and warm-up so both phases can be inspected.
+
+`bun run admin:db:backfill-gpu-metrics --all --yes` attaches telemetry for runs
+ingested before this migration. The GCS backup only mirrors `bmk_`/`server_logs_`
+uploads, so the reachable history is bounded by GitHub's 90-day retention.
+
+Readers: `/api/gpu-metrics?runId=` serves the digest when the run is stored and
+falls back to live GitHub artifacts otherwise (in-progress runs), and
+`/api/v1/gpu-metrics-point?id=` powers the PowerX tab of the per-point detail
+page.
+
 ### PowerX publication receipts
 
 The normal CI importer writes `POWER_PUBLICATION_MANIFEST` when configured. Each
diff --git a/package.json b/package.json
index d21c65db5..45a873cea 100644
--- a/package.json
+++ b/package.json
@@ -44,6 +44,7 @@
     "admin:db:migrate:collectivex": "bun run --cwd packages/db db:migrate:collectivex",
     "admin:db:apply-overrides": "bun run --cwd packages/db db:apply-overrides",
     "admin:db:backfill-full-response-interactivity": "bun run --cwd packages/db db:backfill-full-response-interactivity",
+    "admin:db:backfill-gpu-metrics": "bun run --cwd packages/db db:backfill-gpu-metrics",
     "admin:db:backfill-server-log-files": "bun run --cwd packages/db db:backfill-server-log-files",
     "admin:db:reset": "bun run --cwd packages/db db:reset",
     "admin:db:verify": "bun run --cwd packages/db db:verify",
diff --git a/packages/app/src/app/api/gpu-metrics/route.test.ts b/packages/app/src/app/api/gpu-metrics/route.test.ts
index c34a2147f..790a0ff64 100644
--- a/packages/app/src/app/api/gpu-metrics/route.test.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.test.ts
@@ -28,6 +28,18 @@ vi.mock('@/components/gpu-power/types', () => ({
   parseCsvData: mockParseCsvData,
 }));
 
+const { mockGetGpuMetricsForRun } = vi.hoisted(() => ({
+  mockGetGpuMetricsForRun: vi.fn(),
+}));
+
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({
+  getDb: () => ({}),
+}));
+
+vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
+  getGpuMetricsForRun: mockGetGpuMetricsForRun,
+}));
+
 vi.mock('adm-zip', () => {
   const csvContent = 'timestamp,index,power\n2026-03-01T00:00:00Z,0,300';
   class MockAdmZip {
@@ -44,11 +56,12 @@ vi.mock('adm-zip', () => {
   return { default: MockAdmZip };
 });
 
-import { GET } from './route';
+import { databasePayloadToResponse, GET } from './route';
 import { NextRequest } from 'next/server';
 
 const originalFetch = globalThis.fetch;
 let origToken: string | undefined;
+let origReadonlyUrl: string | undefined;
 
 function req(url: string): NextRequest {
   return new NextRequest(new URL(url, 'http://localhost'));
@@ -57,7 +70,11 @@ function req(url: string): NextRequest {
 beforeEach(() => {
   vi.clearAllMocks();
   origToken = process.env.GITHUB_TOKEN;
+  origReadonlyUrl = process.env.DATABASE_READONLY_URL;
   process.env.GITHUB_TOKEN = 'test-gh-token';
+  // No readonly URL: the GitHub fallback is exercised unless a test opts in.
+  delete process.env.DATABASE_READONLY_URL;
+  mockGetGpuMetricsForRun.mockResolvedValue(null);
 });
 
 afterEach(() => {
@@ -67,6 +84,210 @@ afterEach(() => {
   } else {
     process.env.GITHUB_TOKEN = origToken;
   }
+  if (origReadonlyUrl === undefined) {
+    delete process.env.DATABASE_READONLY_URL;
+  } else {
+    process.env.DATABASE_READONLY_URL = origReadonlyUrl;
+  }
+});
+
+const storedRunPayload = {
+  workflowRun: {
+    id: 7,
+    githubRunId: 34557177019,
+    runAttempt: 1,
+    name: 'Run Sweep - dsr1 fp4 b200',
+    date: '2026-09-11',
+    htmlUrl: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34557177019',
+    headBranch: 'main',
+    headSha: 'deadbeef',
+    conclusion: 'success',
+    status: 'completed',
+    createdAt: '2026-09-11T04:00:00.000Z',
+  },
+  series: [
+    {
+      id: 1,
+      artifactName: 'gpu_metrics_dsr1_conc32_b200-x_0',
+      configKey: 'dsr1_conc32_b200-x_0',
+      fileName: 'gpu_metrics.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 2,
+      gpuCount: 1,
+      startedAt: '2026-09-11T04:19:41.982Z',
+      endedAt: '2026-09-11T04:19:42.990Z',
+      sidecars: {},
+      benchmarkResultIds: [10],
+      stats: [],
+      data: [
+        {
+          timestamp: '2026-09-11T04:19:41.982Z',
+          index: 0,
+          power: 187.8,
+          temperature: 33,
+          smClock: 120,
+          memClock: 3996,
+          gpuUtil: 0,
+          memUtil: 0,
+        },
+        {
+          timestamp: '2026-09-11T04:19:42.990Z',
+          index: 0,
+          power: 912.1,
+          temperature: 61,
+          smClock: 1965,
+          memClock: 3996,
+          gpuUtil: 98,
+          memUtil: 74,
+        },
+      ],
+    },
+    {
+      id: 2,
+      artifactName: 'gpu_metrics_multinode_b200-x_0',
+      configKey: 'multinode_b200-x_0',
+      fileName: 'results/gpu_metrics_rank0.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 0,
+      gpuCount: 0,
+      startedAt: '2026-09-11T04:19:41.982Z',
+      endedAt: '2026-09-11T04:19:41.982Z',
+      sidecars: {},
+      benchmarkResultIds: [11],
+      stats: [],
+      data: [],
+    },
+    {
+      id: 3,
+      artifactName: 'gpu_metrics_multinode_b200-x_0',
+      configKey: 'multinode_b200-x_0',
+      fileName: 'results/gpu_metrics_rank1.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 0,
+      gpuCount: 0,
+      startedAt: '2026-09-11T04:19:41.982Z',
+      endedAt: '2026-09-11T04:19:41.982Z',
+      sidecars: {},
+      benchmarkResultIds: [11],
+      stats: [],
+      data: [],
+    },
+  ],
+};
+
+describe('databasePayloadToResponse', () => {
+  it('shapes the stored digest like the GitHub payload and disambiguates multinode CSVs', () => {
+    const response = databasePayloadToResponse(storedRunPayload);
+    expect(response.source).toBe('database');
+    expect(response.runInfo).toEqual({
+      id: 34557177019,
+      name: 'Run Sweep - dsr1 fp4 b200',
+      branch: 'main',
+      sha: 'deadbeef',
+      createdAt: '2026-09-11T04:00:00.000Z',
+      url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34557177019',
+      conclusion: 'success',
+      status: 'completed',
+    });
+    expect(response.artifacts.map((artifact) => artifact.name)).toEqual([
+      'gpu_metrics_dsr1_conc32_b200-x_0',
+      'gpu_metrics_multinode_b200-x_0/results/gpu_metrics_rank0.csv',
+      'gpu_metrics_multinode_b200-x_0/results/gpu_metrics_rank1.csv',
+    ]);
+    expect(response.artifacts[0]!.data).toHaveLength(2);
+    expect(response.artifacts[0]!.series?.benchmarkResultIds).toEqual([10]);
+    expect(response.artifacts[0]!.series).not.toHaveProperty('data');
+  });
+
+  it('fills missing run metadata with the run date and canonical run URL', () => {
+    const response = databasePayloadToResponse({
+      ...storedRunPayload,
+      workflowRun: {
+        ...storedRunPayload.workflowRun,
+        htmlUrl: null,
+        headBranch: null,
+        headSha: null,
+        conclusion: null,
+        status: null,
+        createdAt: null,
+      },
+    });
+    expect(response.runInfo.createdAt).toBe('2026-09-11T00:00:00Z');
+    expect(response.runInfo.url).toBe(
+      'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34557177019',
+    );
+    expect(response.runInfo.branch).toBe('');
+  });
+});
+
+describe('GET /api/gpu-metrics — database first', () => {
+  it('serves the stored digest without touching GitHub when the run is ingested', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    mockGetGpuMetricsForRun.mockResolvedValueOnce(storedRunPayload);
+    globalThis.fetch = vi.fn();
+
+    const res = await GET(req('/api/gpu-metrics?runId=34557177019'));
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.source).toBe('database');
+    expect(body.artifacts).toHaveLength(3);
+    expect(mockGetGpuMetricsForRun).toHaveBeenCalledWith({}, 34557177019);
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('falls back to GitHub when the database has no series for the run', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    mockGetGpuMetricsForRun.mockResolvedValueOnce(null);
+    globalThis.fetch = vi
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            id: 99,
+            name: 'In progress',
+            head_branch: 'main',
+            head_sha: 'abc',
+            created_at: '2026-09-17T00:00:00Z',
+            html_url: 'https://github.com/TestOwner/TestRepo/actions/runs/99',
+            conclusion: null,
+            status: 'in_progress',
+          }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            artifacts: [
+              { id: 1, name: 'gpu_metrics_live', archive_download_url: 'https://example.com/dl/1' },
+            ],
+          }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers({ 'Content-Length': '1024' }),
+        arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+      });
+
+    const res = await GET(req('/api/gpu-metrics?runId=99'));
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.source).toBe('github');
+    expect(body.artifacts[0].name).toBe('gpu_metrics_live');
+  });
+
+  it('falls back to GitHub when the database lookup throws', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    mockGetGpuMetricsForRun.mockRejectedValueOnce(new Error('relation does not exist'));
+    globalThis.fetch = vi.fn().mockResolvedValueOnce({ ok: false, status: 404 });
+
+    const res = await GET(req('/api/gpu-metrics?runId=99'));
+    expect(res.status).toBe(500);
+    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe('GET /api/gpu-metrics', () => {
diff --git a/packages/app/src/app/api/gpu-metrics/route.ts b/packages/app/src/app/api/gpu-metrics/route.ts
index 59a607f35..e523ec2b8 100644
--- a/packages/app/src/app/api/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.ts
@@ -1,10 +1,29 @@
 /**
- * DO NOT ADD CACHING (blob, CDN, or unstable_cache) to this route.
- * It fetches live GitHub Actions artifacts which change while a run is in progress.
+ * PowerX explorer data for one GitHub Actions run.
+ *
+ * Reads the ingest-time telemetry digest first (migration 016: series,
+ * samples, per-GPU statistics, point links). Runs that have not been ingested
+ * yet, including runs still in progress, fall back to the live GitHub
+ * artifacts exactly as before.
+ *
+ * DO NOT ADD CACHING (blob, CDN, or unstable_cache) to this route. The
+ * fallback fetches live GitHub Actions artifacts which change while a run is
+ * in progress, and the database path is already a single indexed read.
  */
 import { type NextRequest, NextResponse } from 'next/server';
 
-import { parseCsvData } from '@/components/gpu-power/types';
+import { getDb } from '@semianalysisai/inferencex-db/connection';
+import {
+  getGpuMetricsForRun,
+  type GpuMetricSeries,
+  type GpuMetricsRunPayload,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import {
+  parseCsvData,
+  type GpuMetricRow,
+  type GpuPowerRunInfo,
+} from '@/components/gpu-power/types';
 import {
   downloadGithubArtifact,
   extractZipEntries,
@@ -17,7 +36,55 @@ import {
 
 const MAX_ARTIFACT_BYTES = 50 * 1024 * 1024;
 
-async function fetchGpuMetrics(runId: string) {
+export type GpuMetricsSource = 'database' | 'github';
+
+export interface GpuMetricsArtifactPayload {
+  name: string;
+  data: GpuMetricRow[];
+  /** Present only for database-backed artifacts. */
+  series?: Omit<GpuMetricSeries, 'data'>;
+}
+
+export interface GpuMetricsRouteResponse {
+  runInfo: GpuPowerRunInfo;
+  artifacts: GpuMetricsArtifactPayload[];
+  source: GpuMetricsSource;
+}
+
+/** Shape the stored digest like the GitHub payload so the explorer is source-agnostic. */
+export function databasePayloadToResponse(payload: GpuMetricsRunPayload): GpuMetricsRouteResponse {
+  const run = payload.workflowRun;
+  const filesPerArtifact = new Map<string, number>();
+  for (const series of payload.series) {
+    filesPerArtifact.set(series.artifactName, (filesPerArtifact.get(series.artifactName) ?? 0) + 1);
+  }
+  return {
+    source: 'database',
+    runInfo: {
+      id: run.githubRunId,
+      name: run.name,
+      branch: run.headBranch ?? '',
+      sha: run.headSha ?? '',
+      createdAt: run.createdAt ?? `${run.date}T00:00:00Z`,
+      url:
+        run.htmlUrl ??
+        `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${run.githubRunId}`,
+      conclusion: run.conclusion ?? '',
+      status: run.status ?? '',
+    },
+    artifacts: payload.series.map(({ data, ...series }) => ({
+      // Multinode uploads carry one CSV per node; keep them distinguishable.
+      name:
+        (filesPerArtifact.get(series.artifactName) ?? 1) > 1
+          ? `${series.artifactName}/${series.fileName}`
+          : series.artifactName,
+      data,
+      series,
+    })),
+  };
+}
+
+async function fetchGpuMetricsFromGithub(runId: string): Promise<GpuMetricsRouteResponse> {
   const githubToken = getGithubToken();
   if (!githubToken) throw new Error('GitHub token not configured');
 
@@ -30,7 +97,7 @@ async function fetchGpuMetrics(runId: string) {
   const gpuArtifacts = artifacts.filter((a) => a.name.startsWith('gpu_metrics'));
   if (gpuArtifacts.length === 0) throw new Error('No gpu_metrics artifacts found for this run');
 
-  const parsedArtifacts: { name: string; data: ReturnType<typeof parseCsvData> }[] = [];
+  const parsedArtifacts: GpuMetricsArtifactPayload[] = [];
   for (const artifact of gpuArtifacts) {
     const dlResp = await downloadGithubArtifact(artifact.archive_download_url, githubToken);
     if (!dlResp.ok) {
@@ -58,11 +125,25 @@ async function fetchGpuMetrics(runId: string) {
   if (parsedArtifacts.length === 0) throw new Error('No Chip metrics data found in artifacts');
 
   return {
-    runInfo: normalizeGithubRunInfo(run),
+    source: 'github',
+    runInfo: normalizeGithubRunInfo(run) as GpuPowerRunInfo,
     artifacts: parsedArtifacts,
   };
 }
 
+async function fetchGpuMetricsFromDatabase(runId: string): Promise<GpuMetricsRouteResponse | null> {
+  if (!process.env.DATABASE_READONLY_URL) return null;
+  try {
+    const payload = await getGpuMetricsForRun(getDb(), Number(runId));
+    return payload ? databasePayloadToResponse(payload) : null;
+  } catch (error) {
+    // A schema that predates migration 016 or a transient DB error must not
+    // hide the live GitHub artifacts.
+    console.warn(`gpu-metrics: database lookup failed for run ${runId}, using GitHub:`, error);
+    return null;
+  }
+}
+
 export async function GET(request: NextRequest) {
   const runId = request.nextUrl.searchParams.get('runId');
 
@@ -71,7 +152,8 @@ export async function GET(request: NextRequest) {
   }
 
   try {
-    const data = await fetchGpuMetrics(runId);
+    const data =
+      (await fetchGpuMetricsFromDatabase(runId)) ?? (await fetchGpuMetricsFromGithub(runId));
     return NextResponse.json(data);
   } catch (error) {
     console.error('Error fetching GPU power data:', error);
diff --git a/packages/app/src/app/api/v1/gpu-metrics-point/route.ts b/packages/app/src/app/api/v1/gpu-metrics-point/route.ts
new file mode 100644
index 000000000..f9d04f1df
--- /dev/null
+++ b/packages/app/src/app/api/v1/gpu-metrics-point/route.ts
@@ -0,0 +1,39 @@
+import { getDb } from '@semianalysisai/inferencex-db/connection';
+import {
+  getGpuMetricsForPoint,
+  type GpuMetricsPointPayload,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import { cachedQuery } from '@/lib/api-cache';
+
+import { idQueryRoute } from '../id-routes';
+
+export const dynamic = 'force-dynamic';
+
+/**
+ * Blob-cache namespace. Stored series are immutable per (run, artifact, CSV
+ * hash), so the payload for a point only changes when the digest schema does;
+ * bump the suffix alongside any change to the row shape in
+ * `queries/gpu-metrics.ts`.
+ */
+export const CACHE_KEY_PREFIX = 'gpu-metrics-point-v1';
+
+const getCachedGpuMetricsForPoint = cachedQuery(
+  (id: number): Promise<GpuMetricsPointPayload | null> => getGpuMetricsForPoint(getDb(), id),
+  CACHE_KEY_PREFIX,
+  { blobOnly: true },
+);
+
+/**
+ * GET /api/v1/gpu-metrics-point?id=N
+ *
+ * PowerX telemetry recorded while one benchmark point ran: every linked
+ * gpu_metrics series with full-resolution per-GPU samples and the ingest-time
+ * per-GPU statistics digest. 404 when the point has no linked series (its
+ * run predates migration 016 and the artifacts have expired, or the job
+ * uploaded no gpu_metrics artifact).
+ */
+export const GET = idQueryRoute({
+  logLabel: 'gpu metrics point',
+  fetch: getCachedGpuMetricsForPoint,
+});
diff --git a/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx b/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx
index 369078c40..f78e3b2af 100644
--- a/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx
+++ b/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx
@@ -33,6 +33,7 @@ import {
   type StagePhase,
 } from './phase-slice';
 import { PointSummary } from './point-summary';
+import { PowerTelemetryView } from './power-telemetry-view';
 import { RequestMetricOverTime, SequenceMetricCard } from './request-metric-cards';
 import { ServerLogViewer } from './server-log-viewer';
 import {
@@ -61,6 +62,7 @@ export const AGENTIC_POINT_DETAIL_STRINGS = {
     ttftOverTime: 'TTFT over time',
     perPoint: 'Per-point',
     requestTimeline: 'Request timeline',
+    powerX: 'PowerX',
     aggregatesAcrossConfigs: 'Aggregates across configs',
     logs: 'Logs',
     detailView: 'Detail view',
@@ -94,6 +96,7 @@ export const AGENTIC_POINT_DETAIL_STRINGS = {
     ttftOverTime: 'TTFT 随时间变化',
     perPoint: '单点',
     requestTimeline: '请求时间线',
+    powerX: 'PowerX',
     aggregatesAcrossConfigs: '跨配置聚合',
     logs: '日志',
     detailView: '详情视图',
@@ -149,6 +152,7 @@ export function AgenticPointDetail({ id }: Props) {
     () => [
       { value: 'point', label: t.perPoint, testId: 'detail-view-point' },
       { value: 'timeline', label: t.requestTimeline, testId: 'detail-view-timeline' },
+      { value: 'power', label: t.powerX, testId: 'detail-view-power' },
       { value: 'aggregates', label: t.aggregatesAcrossConfigs, testId: 'detail-view-aggregates' },
       { value: 'logs', label: t.logs, testId: 'detail-view-logs' },
     ],
@@ -347,6 +351,8 @@ export function AgenticPointDetail({ id }: Props) {
 
       {view === 'logs' ? (
         <ServerLogViewer id={id} enabled />
+      ) : view === 'power' ? (
+        <PowerTelemetryView id={id} enabled />
       ) : view === 'aggregates' ? (
         aggregatesQuery.isError ? (
           <RetryableQueryError
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
new file mode 100644
index 000000000..8337eedb7
--- /dev/null
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -0,0 +1,255 @@
+'use client';
+
+import { useMemo, useState } from 'react';
+
+import GpuMetricsChart from '@/components/gpu-power/GpuPowerChart';
+import GpuStatsTable from '@/components/gpu-power/GpuStatsTable';
+import {
+  type GpuMetricKey,
+  type GpuMetricRow,
+  ALL_METRIC_OPTIONS,
+  getAvailableMetrics,
+  getGpuMetricLabel,
+} from '@/components/gpu-power/types';
+import { Card } from '@/components/ui/card';
+import { Label } from '@/components/ui/label';
+import { RetryableQueryError } from '@/components/ui/retryable-query-error';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import { useGpuMetricsPoint, type GpuMetricSeries } from '@/hooks/api/use-gpu-metrics-point';
+import { track } from '@/lib/analytics';
+import { useLocale } from '@/lib/use-locale';
+
+const STRINGS = {
+  en: {
+    loading: 'Loading PowerX telemetry…',
+    error: 'Failed to load PowerX telemetry.',
+    missing:
+      'No PowerX telemetry is stored for benchmark point #{id}. The run predates telemetry ingestion and its gpu_metrics artifact has expired on GitHub, or the job uploaded no telemetry.',
+    series: 'Telemetry series',
+    metric: 'Metric',
+    vendor: 'Collector',
+    samples: 'Samples',
+    chips: 'Chips',
+    interval: 'Sample interval',
+    window: 'Recorded window',
+    sharedNote:
+      'This series covers the whole benchmark job, including server start-up and warm-up, so summary rows below span more than the measured serving window.',
+    perGpuStats: 'Per-chip statistics',
+    chip: 'Chip',
+    secondsUnit: 's',
+  },
+  zh: {
+    loading: '正在加载 PowerX 遥测数据……',
+    error: 'PowerX 遥测数据加载失败。',
+    missing:
+      '基准测试数据点 #{id} 没有存储的 PowerX 遥测数据。该运行早于遥测入库上线且 GitHub 上的 gpu_metrics 产物已过期，或该任务未上传遥测数据。',
+    series: '遥测序列',
+    metric: '指标',
+    vendor: '采集器',
+    samples: '样本数',
+    chips: '芯片数',
+    interval: '采样间隔',
+    window: '记录时间窗口',
+    sharedNote:
+      '该序列覆盖整个基准测试任务，包括服务启动与 warmup 阶段，因此下方统计范围大于实际测量的服务窗口。',
+    perGpuStats: '单芯片统计信息',
+    chip: '芯片',
+    secondsUnit: '秒',
+  },
+} as const;
+
+const VENDOR_LABEL: Record<string, string> = { nvidia: 'nvidia-smi', amd: 'amd-smi' };
+
+interface Props {
+  id: number;
+  enabled: boolean;
+}
+
+function seriesLabel(series: GpuMetricSeries, total: number): string {
+  return total > 1 ? `${series.artifactName} · ${series.fileName}` : series.artifactName;
+}
+
+/**
+ * PowerX tab of the per-point detail page: the full-resolution chip telemetry
+ * recorded while this benchmark point ran, read from the ingest-time digest
+ * (migration 016) rather than from GitHub artifacts.
+ */
+export function PowerTelemetryView({ id, enabled }: Props) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const query = useGpuMetricsPoint(id, enabled);
+  const seriesList = query.data?.series ?? [];
+
+  const [seriesSelection, setSeriesSelection] = useState<{ id: number; seriesId: number } | null>(
+    null,
+  );
+  const selectedSeries =
+    (seriesSelection?.id === id
+      ? seriesList.find((series) => series.id === seriesSelection.seriesId)
+      : undefined) ?? seriesList[0];
+  const data: GpuMetricRow[] = useMemo(() => selectedSeries?.data ?? [], [selectedSeries]);
+  const availableMetrics = useMemo(() => getAvailableMetrics(data), [data]);
+
+  const [metricSelection, setMetricSelection] = useState<GpuMetricKey>('power');
+  const metricKey: GpuMetricKey = availableMetrics.some((m) => m.key === metricSelection)
+    ? metricSelection
+    : 'power';
+  const metricConfig = ALL_METRIC_OPTIONS.find((m) => m.key === metricKey)!;
+  const visibleGpus = useMemo(() => new Set(data.map((row) => row.index)), [data]);
+
+  if (!enabled) return null;
+
+  if (query.isLoading) {
+    return (
+      <div
+        className="rounded-lg border border-border/40 bg-card/40 p-4 text-sm text-muted-foreground"
+        data-testid="power-telemetry-loading"
+      >
+        {t.loading}
+      </div>
+    );
+  }
+  if (query.isError) {
+    return (
+      <RetryableQueryError
+        message={t.error}
+        analyticsEvent="inference_agentic_power_telemetry_retry_clicked"
+        onRetry={query.refetch}
+        testId="power-telemetry-query-error"
+      />
+    );
+  }
+  if (!selectedSeries) {
+    return (
+      <div
+        className="rounded-lg border border-border/40 bg-card/40 p-4 text-sm text-muted-foreground"
+        data-testid="power-telemetry-missing"
+      >
+        {t.missing.replace('{id}', String(id))}
+      </div>
+    );
+  }
+
+  const durationS = Math.max(
+    0,
+    (new Date(selectedSeries.endedAt).getTime() - new Date(selectedSeries.startedAt).getTime()) /
+      1000,
+  );
+  const numberLocale = locale === 'zh' ? 'zh-CN' : undefined;
+
+  return (
+    <div className="flex flex-col gap-4" data-testid="power-telemetry-view">
+      <Card>
+        <dl className="mb-4 grid grid-cols-2 gap-x-4 gap-y-3 text-sm sm:grid-cols-3 lg:grid-cols-5">
+          <div className="min-w-0">
+            <dt className="text-xs text-muted-foreground">{t.vendor}</dt>
+            <dd className="font-medium">
+              {VENDOR_LABEL[selectedSeries.vendor] ?? selectedSeries.vendor}
+            </dd>
+          </div>
+          <div className="min-w-0">
+            <dt className="text-xs text-muted-foreground">{t.samples}</dt>
+            <dd className="font-medium tabular-nums" data-testid="power-telemetry-sample-count">
+              {selectedSeries.sampleCount.toLocaleString(numberLocale)}
+            </dd>
+          </div>
+          <div className="min-w-0">
+            <dt className="text-xs text-muted-foreground">{t.chips}</dt>
+            <dd className="font-medium tabular-nums">{selectedSeries.gpuCount}</dd>
+          </div>
+          <div className="min-w-0">
+            <dt className="text-xs text-muted-foreground">{t.interval}</dt>
+            <dd className="font-medium tabular-nums">
+              {selectedSeries.sampleIntervalS === null
+                ? '—'
+                : `${selectedSeries.sampleIntervalS.toFixed(2)} ${t.secondsUnit}`}
+            </dd>
+          </div>
+          <div className="min-w-0">
+            <dt className="text-xs text-muted-foreground">{t.window}</dt>
+            <dd className="font-medium tabular-nums">
+              {new Date(selectedSeries.startedAt).toLocaleTimeString(numberLocale)} ·{' '}
+              {Math.round(durationS).toLocaleString(numberLocale)} {t.secondsUnit}
+            </dd>
+          </div>
+        </dl>
+        <div className="grid grid-cols-1 sm:grid-cols-[1fr_auto] items-end gap-3">
+          {seriesList.length > 1 && (
+            <div className="space-y-1 min-w-0">
+              <Label htmlFor="power-telemetry-series-select">{t.series}</Label>
+              <Select
+                value={String(selectedSeries.id)}
+                onValueChange={(value) => {
+                  track('inference_agentic_power_series_selected', { id, seriesId: Number(value) });
+                  setSeriesSelection({ id, seriesId: Number(value) });
+                }}
+              >
+                <SelectTrigger id="power-telemetry-series-select" className="w-full truncate">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {seriesList.map((series) => (
+                    <SelectItem key={series.id} value={String(series.id)}>
+                      {seriesLabel(series, seriesList.length)}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+          )}
+          <div className="space-y-1">
+            <Label htmlFor="power-telemetry-metric-select">{t.metric}</Label>
+            <Select
+              value={metricKey}
+              onValueChange={(value) => {
+                track('inference_agentic_power_metric_changed', { id, metric: value });
+                setMetricSelection(value as GpuMetricKey);
+              }}
+            >
+              <SelectTrigger
+                id="power-telemetry-metric-select"
+                data-testid="power-telemetry-metric-select"
+                className="w-full sm:w-56"
+              >
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {availableMetrics.map((m) => (
+                  <SelectItem key={m.key} value={m.key}>
+                    {getGpuMetricLabel(m, locale)} ({m.unit})
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+        </div>
+      </Card>
+
+      <Card className="relative" data-testid="power-telemetry-chart">
+        <GpuMetricsChart
+          data={data}
+          visibleGpus={visibleGpus}
+          metricKey={metricKey}
+          artifactName={selectedSeries.artifactName}
+          maxPoints={2000}
+          caption={
+            <span className="text-xs text-muted-foreground">
+              {getGpuMetricLabel(metricConfig, locale)} · {t.sharedNote}
+            </span>
+          }
+        />
+      </Card>
+
+      <Card>
+        <h3 className="mb-2 text-sm font-medium">{t.perGpuStats}</h3>
+        <GpuStatsTable data={data} metricKey={metricKey} />
+      </Card>
+    </div>
+  );
+}
diff --git a/packages/app/src/components/inference/agentic-point/use-detail-view.test.tsx b/packages/app/src/components/inference/agentic-point/use-detail-view.test.tsx
index 4fe54b399..64874bb74 100644
--- a/packages/app/src/components/inference/agentic-point/use-detail-view.test.tsx
+++ b/packages/app/src/components/inference/agentic-point/use-detail-view.test.tsx
@@ -21,6 +21,7 @@ function DetailViewProbe() {
     createElement('button', { onClick: () => setView('point') }, 'point'),
     createElement('button', { onClick: () => setView('timeline') }, 'timeline'),
     createElement('button', { onClick: () => setView('aggregates') }, 'aggregates'),
+    createElement('button', { onClick: () => setView('power') }, 'power'),
   );
 }
 
@@ -119,4 +120,25 @@ describe('useDetailView', () => {
     });
     expect(renderedView()).toBe('aggregates');
   });
+
+  it('accepts the PowerX view from the URL and writes it back on selection', () => {
+    nativeReplace('/inference/agentic/42?view=power');
+    renderProbe();
+    expect(renderedView()).toBe('power');
+
+    click('point');
+    expect(new URLSearchParams(window.location.search).has('view')).toBe(false);
+    click('power');
+    expect(renderedView()).toBe('power');
+    expect(new URLSearchParams(window.location.search).get('view')).toBe('power');
+    expect(track).toHaveBeenLastCalledWith('inference_agentic_detail_view_changed', {
+      view: 'power',
+    });
+  });
+
+  it('falls back to the per-point view for unknown view names', () => {
+    nativeReplace('/inference/agentic/42?view=telemetry');
+    renderProbe();
+    expect(renderedView()).toBe('point');
+  });
 });
diff --git a/packages/app/src/components/inference/agentic-point/use-detail-view.ts b/packages/app/src/components/inference/agentic-point/use-detail-view.ts
index 1a97a85cc..b08b3a868 100644
--- a/packages/app/src/components/inference/agentic-point/use-detail-view.ts
+++ b/packages/app/src/components/inference/agentic-point/use-detail-view.ts
@@ -6,10 +6,14 @@ import { useClientSearchParams } from '@/hooks/useClientSearch';
 import { track } from '@/lib/analytics';
 import { replaceClientSearch } from '@/lib/client-navigation';
 
-export type DetailView = 'point' | 'timeline' | 'aggregates' | 'logs';
+export type DetailView = 'point' | 'timeline' | 'power' | 'aggregates' | 'logs';
 
 const isDetailView = (value: string | null): value is DetailView =>
-  value === 'point' || value === 'timeline' || value === 'aggregates' || value === 'logs';
+  value === 'point' ||
+  value === 'timeline' ||
+  value === 'power' ||
+  value === 'aggregates' ||
+  value === 'logs';
 
 /** URL-persisted detail view (`?view=`; per-point is the unadorned default). */
 export function useDetailView(): [DetailView, (nextView: DetailView) => void] {
diff --git a/packages/app/src/hooks/api/use-gpu-metrics-point.ts b/packages/app/src/hooks/api/use-gpu-metrics-point.ts
new file mode 100644
index 000000000..12c023331
--- /dev/null
+++ b/packages/app/src/hooks/api/use-gpu-metrics-point.ts
@@ -0,0 +1,18 @@
+import type {
+  GpuMetricsPointPayload,
+  GpuMetricSeries,
+  GpuMetricStatRow,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import { useByIdQuery } from './benchmark-id-query';
+
+export type { GpuMetricsPointPayload, GpuMetricSeries, GpuMetricStatRow };
+
+/**
+ * Lazy-fetch the PowerX telemetry linked to one benchmark point. Enabled only
+ * while the PowerX detail view is open: a series is one 1 s sample per GPU for
+ * the whole job (hundreds of KB), so it is not paid for on every page load.
+ */
+export function useGpuMetricsPoint(id: number | null, enabled = false) {
+  return useByIdQuery<GpuMetricsPointPayload>('gpu-metrics-point', id, enabled && Boolean(id));
+}
diff --git a/packages/constants/src/tables.ts b/packages/constants/src/tables.ts
index 684f310bc..d1bcd6a0b 100644
--- a/packages/constants/src/tables.ts
+++ b/packages/constants/src/tables.ts
@@ -5,6 +5,10 @@ export const TABLE_NAMES = {
   agenticTraceReplay: 'agentic_trace_replay',
   benchmarkResults: 'benchmark_results',
   serverLogs: 'server_logs',
+  gpuMetricSeries: 'gpu_metric_series',
+  gpuMetricSamples: 'gpu_metric_samples',
+  gpuMetricGpuStats: 'gpu_metric_gpu_stats',
+  benchmarkResultGpuMetrics: 'benchmark_result_gpu_metrics',
   runStats: 'run_stats',
   evalResults: 'eval_results',
   evalSamples: 'eval_samples',
diff --git a/packages/db/migrations/016_gpu_metrics.sql b/packages/db/migrations/016_gpu_metrics.sql
new file mode 100644
index 000000000..8c3f52ac5
--- /dev/null
+++ b/packages/db/migrations/016_gpu_metrics.sql
@@ -0,0 +1,99 @@
+-- PowerX telemetry digest.
+--
+-- The producer samples nvidia-smi / amd-smi once per second for the lifetime
+-- of every benchmark job and uploads the CSV as a `gpu_metrics_<suffix>`
+-- artifact next to `bmk_<suffix>`. Until now the app downloaded and parsed
+-- those artifacts from GitHub on every page view, and lost them entirely once
+-- GitHub's 90-day artifact retention expired. These tables move that work to
+-- ingest time: raw samples are kept at full resolution, per-GPU summary
+-- statistics are digested once, and each benchmark point is linked to the
+-- series that was recorded while it ran.
+
+create table gpu_metric_series (
+  id              bigserial   primary key,
+  workflow_run_id bigint      not null references workflow_runs(id) on delete cascade,
+  -- Full GitHub artifact name, including the runner-pool/attempt suffix.
+  artifact_name   text        not null,
+  -- Artifact name with the gpu_metrics_ prefix removed; pairs with bmk_<key>.
+  config_key      text        not null,
+  -- CSV path relative to the extracted artifact root (multinode uploads can
+  -- carry one CSV per serving node).
+  file_name       text        not null,
+  vendor          text        not null,
+  csv_sha256      text        not null,
+  sample_interval_s real,
+  sample_count    integer     not null,
+  gpu_count       smallint    not null,
+  started_at      timestamptz not null,
+  ended_at        timestamptz not null,
+  -- Parsed sidecars: gpu_metrics_context.json, gpu_metrics_identity.*,
+  -- gpu_metrics_energy_{start,end}.csv. Kept verbatim for provenance.
+  sidecars        jsonb       not null default '{}'::jsonb,
+  ingested_at     timestamptz not null default now(),
+
+  constraint gpu_metric_series_vendor_known check (vendor in ('nvidia', 'amd')),
+  constraint gpu_metric_series_artifact_nonempty check (artifact_name <> ''),
+  constraint gpu_metric_series_file_nonempty check (file_name <> ''),
+  constraint gpu_metric_series_sample_count_non_neg check (sample_count >= 0),
+  constraint gpu_metric_series_gpu_count_non_neg check (gpu_count >= 0),
+  constraint gpu_metric_series_window_ordered check (ended_at >= started_at),
+  constraint gpu_metric_series_unique unique (workflow_run_id, artifact_name, file_name)
+);
+
+create index gpu_metric_series_run_idx on gpu_metric_series (workflow_run_id);
+
+-- One row per (GPU, sample). Vendor-specific columns stay null when the
+-- collector does not report them. `real` keeps the row narrow; the source
+-- telemetry has at most three significant decimals.
+create table gpu_metric_samples (
+  series_id       bigint      not null references gpu_metric_series(id) on delete cascade,
+  gpu_index       smallint    not null,
+  sampled_at      timestamptz not null,
+  power_w         real,
+  temperature_c   real,
+  sm_clock_mhz    real,
+  mem_clock_mhz   real,
+  gpu_util_pct    real,
+  mem_util_pct    real,
+  edge_temp_c     real,
+  mem_temp_c      real,
+  gfx_voltage_mv  real,
+  soc_voltage_mv  real,
+  mem_voltage_mv  real,
+  fclk_mhz        real,
+  socclk_mhz      real,
+  mm_activity_pct real,
+
+  primary key (series_id, gpu_index, sampled_at)
+);
+
+-- Ingest-time digest so readers never rescan samples for summary cards.
+create table gpu_metric_gpu_stats (
+  series_id     bigint   not null references gpu_metric_series(id) on delete cascade,
+  gpu_index     smallint not null,
+  metric        text     not null,
+  sample_count  integer  not null,
+  min_value     real     not null,
+  max_value     real     not null,
+  mean_value    real     not null,
+  median_value  real     not null,
+  p95_value     real     not null,
+  p99_value     real     not null,
+  stddev_value  real     not null,
+
+  constraint gpu_metric_gpu_stats_metric_nonempty check (metric <> ''),
+  constraint gpu_metric_gpu_stats_sample_count_positive check (sample_count > 0),
+  primary key (series_id, gpu_index, metric)
+);
+
+-- Benchmark point ↔ telemetry series. A point can reference several series
+-- when a multinode artifact ships one CSV per node.
+create table benchmark_result_gpu_metrics (
+  benchmark_result_id bigint not null references benchmark_results(id) on delete cascade,
+  series_id           bigint not null references gpu_metric_series(id) on delete cascade,
+
+  primary key (benchmark_result_id, series_id)
+);
+
+create index benchmark_result_gpu_metrics_series_idx
+  on benchmark_result_gpu_metrics (series_id);
diff --git a/packages/db/package.json b/packages/db/package.json
index c6c05c57b..ade8e49b4 100644
--- a/packages/db/package.json
+++ b/packages/db/package.json
@@ -27,6 +27,7 @@
     "db:backfill-atom-kv-capacity": "bun --env-file=../../.env src/backfill-atom-kv-capacity.ts",
     "db:backfill-chart-series": "bun --env-file=../../.env src/backfill-chart-series.ts",
     "db:backfill-dataset-stats": "bun --env-file=../../.env src/backfill-dataset-stats.ts",
+    "db:backfill-gpu-metrics": "bun --env-file=../../.env src/backfill-gpu-metrics.ts",
     "db:backfill-full-response-interactivity": "bun --env-file=../../.env src/backfill-full-response-interactivity.ts",
     "db:backfill-request-timeline": "bun --env-file=../../.env src/backfill-request-timeline.ts",
     "db:backfill-runtime-metadata": "bun --env-file=../../.env src/backfill-runtime-metadata.ts",
diff --git a/packages/db/src/backfill-gpu-metrics.ts b/packages/db/src/backfill-gpu-metrics.ts
new file mode 100644
index 000000000..5cbfa640d
--- /dev/null
+++ b/packages/db/src/backfill-gpu-metrics.ts
@@ -0,0 +1,303 @@
+/**
+ * Backfill PowerX telemetry (`gpu_metrics_<suffix>` artifacts) into the
+ * migration-016 tables for runs that were ingested before the CI path
+ * digested them.
+ *
+ * GitHub keeps run artifacts for 90 days and the GCS backup only mirrors
+ * bmk_/server_logs_ uploads, so the reachable history is bounded by GitHub
+ * retention. Each gpu_metrics artifact is paired with its exact `bmk_<suffix>`
+ * (or `bmk_agentic_<suffix>`) sibling, the raw rows are mapped through the
+ * production mapper, and the series is linked to those persisted points.
+ *
+ * Usage:
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --run 34557177019 --yes
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --all --yes
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --all --since 2026-08-01 --dry-run
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --all --force --limit 20 --yes
+ *
+ * Runs that already have at least one stored series are skipped unless
+ * --force is passed. --parallel N (default 4) bounds concurrent artifact
+ * downloads within one run.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { hasNoSslFlag } from './cli-utils.js';
+import { AsyncSemaphore } from './etl/async-semaphore.js';
+import { createAdminSql } from './etl/db-utils.js';
+import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest.js';
+import { retryArtifactOperation } from './lib/artifact-retry.js';
+import { confirmProceed, parseLimitForceFlags, runBackfillMain } from './lib/backfill-runner.js';
+import { findBenchmarkResultIds, readMappedBenchmarkRows } from './lib/benchmark-result-lookup.js';
+import { downloadArtifact, listRunArtifacts } from './lib/github-artifacts.js';
+import {
+  pairGpuMetricsArtifacts,
+  type GpuMetricsArtifactPair,
+} from './lib/gpu-metrics-backfill.js';
+import { repositoryFromRunUrl } from './lib/runtime-metadata-artifacts.js';
+
+const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
+const GITHUB_RETENTION_DAYS = 90;
+const sql = createAdminSql({ noSsl: hasNoSslFlag(), max: 4, onnotice: () => {} });
+
+interface CandidateRun {
+  id: number;
+  github_run_id: number;
+  run_attempt: number;
+  html_url: string | null;
+  date: string;
+  series_count: number;
+}
+
+interface BackfillFlags {
+  all: boolean;
+  dryRun: boolean;
+  run: number | null;
+  fromRun: number | null;
+  since: string | null;
+  parallel: number;
+}
+
+function positiveIntFlag(flag: string): number | null {
+  const index = process.argv.indexOf(flag);
+  if (index === -1) return null;
+  const raw = process.argv[index + 1];
+  if (!raw || !/^\d+$/u.test(raw) || Number(raw) <= 0) {
+    throw new Error(`${flag} requires a positive integer`);
+  }
+  return Number(raw);
+}
+
+function parseFlags(): BackfillFlags {
+  const sinceIndex = process.argv.indexOf('--since');
+  const since = sinceIndex === -1 ? null : (process.argv[sinceIndex + 1] ?? null);
+  if (sinceIndex !== -1 && (!since || !/^\d{4}-\d{2}-\d{2}$/u.test(since))) {
+    throw new Error('--since requires a YYYY-MM-DD date');
+  }
+  return {
+    all: process.argv.includes('--all'),
+    dryRun: process.argv.includes('--dry-run'),
+    run: positiveIntFlag('--run'),
+    fromRun: positiveIntFlag('--from-run'),
+    since,
+    parallel: positiveIntFlag('--parallel') ?? 4,
+  };
+}
+
+function isWithinGithubRetention(date: string): boolean {
+  const ageMs = Date.now() - new Date(date).getTime();
+  return ageMs <= GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+}
+
+async function loadCandidateRuns(
+  flags: BackfillFlags,
+  limit: number | null,
+  force: boolean,
+): Promise<CandidateRun[]> {
+  const cutoff = new Date(Date.now() - GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000)
+    .toISOString()
+    .slice(0, 10);
+  const since = flags.since ?? cutoff;
+  const rows = await sql<CandidateRun[]>`
+    select wr.id, wr.github_run_id, wr.run_attempt, wr.html_url, wr.date::text as date,
+      (select count(*)::int from gpu_metric_series s where s.workflow_run_id = wr.id) as series_count
+    from latest_workflow_runs wr
+    where exists (select 1 from benchmark_results br where br.workflow_run_id = wr.id)
+      and (${flags.run}::bigint is null or wr.github_run_id = ${flags.run})
+      and (${flags.fromRun}::bigint is null or wr.github_run_id >= ${flags.fromRun})
+      and (${flags.run}::bigint is not null or wr.date >= ${since}::date)
+    order by wr.date desc, wr.github_run_id desc
+  `;
+  const candidates = rows
+    .map((row) => ({
+      ...row,
+      id: Number(row.id),
+      github_run_id: Number(row.github_run_id),
+      series_count: Number(row.series_count),
+    }))
+    .filter((row) => force || flags.run !== null || row.series_count === 0);
+  return limit === null ? candidates : candidates.slice(0, limit);
+}
+
+type PairOutcome =
+  | { kind: 'ingested'; seriesCount: number; samplesInserted: number; pointsLinked: number }
+  | { kind: 'unmatched' }
+  | { kind: 'empty' }
+  | { kind: 'failed' };
+
+/** Download one gpu_metrics/bmk pair, resolve its points, and persist the series. */
+async function processPair(
+  run: CandidateRun,
+  pair: GpuMetricsArtifactPair,
+  tempDir: string,
+): Promise<PairOutcome> {
+  let benchmarkDir: string | null = null;
+  let gpuMetricsDir: string | null = null;
+  try {
+    benchmarkDir = await retryArtifactOperation(`downloading ${pair.benchmarks.name}`, () =>
+      downloadArtifact(pair.benchmarks, tempDir),
+    );
+    const mappedRows = readMappedBenchmarkRows(benchmarkDir);
+    const resultIds = await findBenchmarkResultIds(sql, run, mappedRows);
+    if (resultIds.length === 0) {
+      console.warn(`  [WARN] ${pair.gpuMetrics.name}: no matching benchmark rows`);
+      return { kind: 'unmatched' };
+    }
+    gpuMetricsDir = await retryArtifactOperation(`downloading ${pair.gpuMetrics.name}`, () =>
+      downloadArtifact(pair.gpuMetrics, tempDir),
+    );
+    const ingested = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: run.id,
+      artifact: { artifactName: pair.gpuMetrics.name, artifactDir: gpuMetricsDir },
+      benchmarkResultIds: resultIds,
+    });
+    if (ingested.seriesIds.length === 0) {
+      console.warn(`  [WARN] ${pair.gpuMetrics.name}: no parseable gpu_metrics CSV`);
+      return { kind: 'empty' };
+    }
+    return {
+      kind: 'ingested',
+      seriesCount: ingested.seriesIds.length,
+      samplesInserted: ingested.samplesInserted,
+      pointsLinked: resultIds.length,
+    };
+  } catch (error) {
+    console.error(`  ✗ run ${run.github_run_id} artifact ${pair.gpuMetrics.name}:`, error);
+    return { kind: 'failed' };
+  } finally {
+    if (benchmarkDir) fs.rmSync(benchmarkDir, { recursive: true, force: true });
+    if (gpuMetricsDir) fs.rmSync(gpuMetricsDir, { recursive: true, force: true });
+  }
+}
+
+async function main(): Promise<void> {
+  const flags = parseFlags();
+  const { limit, force } = parseLimitForceFlags();
+  if (!flags.all && flags.run === null) {
+    throw new Error('Pass --run <github run id> or --all');
+  }
+
+  console.log('=== backfill-gpu-metrics ===');
+  const runs = await loadCandidateRuns(flags, limit, force);
+  const staleRuns = runs.filter((run) => !isWithinGithubRetention(run.date)).length;
+  const staleNote =
+    staleRuns > 0
+      ? ` (${staleRuns} older than GitHub's ${GITHUB_RETENTION_DAYS}-day retention)`
+      : '';
+  console.log(`  ${runs.length} candidate run(s)${staleNote}`);
+  if (runs.length === 0) {
+    console.log('\n  Nothing to do.');
+    return;
+  }
+
+  if (flags.dryRun) {
+    let pairedRuns = 0;
+    let pairs = 0;
+    for (const run of runs) {
+      const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
+      const artifacts = await retryArtifactOperation(
+        `listing GitHub artifacts for run ${run.github_run_id}`,
+        () => listRunArtifacts(repository, String(run.github_run_id)),
+      );
+      const runPairs = pairGpuMetricsArtifacts(artifacts);
+      if (runPairs.length > 0) pairedRuns++;
+      pairs += runPairs.length;
+      console.log(`  run ${run.github_run_id} (${run.date}): ${runPairs.length} pair(s)`);
+    }
+    console.log(
+      `\n=== dry run: ${runs.length} run(s), ${pairedRuns} with pairs, ${pairs} pair(s) ===`,
+    );
+    return;
+  }
+
+  if (!(await confirmProceed(`${runs.length} workflow run(s) will be checked for gpu_metrics.`))) {
+    return;
+  }
+
+  let artifactsProcessed = 0;
+  let seriesStored = 0;
+  let samplesStored = 0;
+  let pointsLinked = 0;
+  let unmatchedArtifacts = 0;
+  let emptyArtifacts = 0;
+  let artifactFailures = 0;
+  let runFailures = 0;
+  let missingRuns = 0;
+
+  for (const [runIndex, run] of runs.entries()) {
+    const runId = run.github_run_id;
+    const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `gpu-metrics-backfill-${runId}-`));
+    const runStart = Date.now();
+    try {
+      const artifacts = await retryArtifactOperation(
+        `listing GitHub artifacts for run ${runId}`,
+        () => listRunArtifacts(repository, String(runId)),
+      );
+      const pairs = pairGpuMetricsArtifacts(artifacts);
+      if (pairs.length === 0) {
+        missingRuns++;
+        console.log(
+          `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt}: no retained gpu_metrics pairs`,
+        );
+        continue;
+      }
+
+      const limiter = new AsyncSemaphore(flags.parallel);
+      const outcomes = await Promise.all(
+        pairs.map((pair) => limiter.run(() => processPair(run, pair, tempDir))),
+      );
+      let runSeries = 0;
+      let runSamples = 0;
+      for (const outcome of outcomes) {
+        switch (outcome.kind) {
+          case 'ingested': {
+            artifactsProcessed++;
+            runSeries += outcome.seriesCount;
+            runSamples += outcome.samplesInserted;
+            pointsLinked += outcome.pointsLinked;
+            break;
+          }
+          case 'unmatched': {
+            unmatchedArtifacts++;
+            break;
+          }
+          case 'empty': {
+            emptyArtifacts++;
+            break;
+          }
+          case 'failed': {
+            artifactFailures++;
+            break;
+          }
+        }
+      }
+      seriesStored += runSeries;
+      samplesStored += runSamples;
+      console.log(
+        `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt} (${run.date}): ` +
+          `${pairs.length} pair(s), ${runSeries} series, +${runSamples} samples ` +
+          `(${((Date.now() - runStart) / 1000).toFixed(1)}s)`,
+      );
+    } catch (error) {
+      runFailures++;
+      console.error(`  ✗ run ${runId}:`, error);
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+
+  console.log(
+    `\n=== backfill complete: ${artifactsProcessed} artifact(s), ${seriesStored} series, ` +
+      `${samplesStored} sample(s), ${pointsLinked} point link(s), ` +
+      `${unmatchedArtifacts} unmatched artifact(s), ${emptyArtifacts} empty artifact(s), ` +
+      `${missingRuns} run(s) without pairs, ${artifactFailures} failed artifact(s), ` +
+      `${runFailures} failed run(s) ===`,
+  );
+  console.log('  Invalidate API cache after the backfill: bun run admin:cache:invalidate');
+  if (artifactFailures > 0 || runFailures > 0) process.exitCode = 1;
+}
+
+runBackfillMain('backfill-gpu-metrics', sql, main);
diff --git a/packages/db/src/backfill-server-log-files.ts b/packages/db/src/backfill-server-log-files.ts
index 8047e0db5..3208194a2 100644
--- a/packages/db/src/backfill-server-log-files.ts
+++ b/packages/db/src/backfill-server-log-files.ts
@@ -19,11 +19,9 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { hasNoSslFlag } from './cli-utils.js';
-import { mapBenchmarkRow, type BenchmarkParams } from './etl/benchmark-mapper.js';
 import { insertServerLogFilePaths } from './etl/benchmark-ingest.js';
 import { createAdminSql } from './etl/db-utils.js';
 import { listServerLogFilePaths, serverLogArtifactRoot } from './etl/server-log-artifacts.js';
-import { createSkipTracker } from './etl/skip-tracker.js';
 import { downloadArtifact, listRunArtifacts } from './lib/github-artifacts.js';
 import {
   downloadGcsArtifact,
@@ -32,11 +30,9 @@ import {
 } from './lib/gcs-artifacts.js';
 import { confirmProceed, parseLimitForceFlags, runBackfillMain } from './lib/backfill-runner.js';
 import { retryArtifactOperation } from './lib/artifact-retry.js';
+import { findBenchmarkResultIds, readMappedBenchmarkRows } from './lib/benchmark-result-lookup.js';
 import { repositoryFromRunUrl } from './lib/runtime-metadata-artifacts.js';
-import {
-  pairServerLogArtifacts,
-  resolveServerLogResultCandidates,
-} from './lib/server-log-backfill.js';
+import { pairServerLogArtifacts } from './lib/server-log-backfill.js';
 
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 const RETENTION_DAYS = 90;
@@ -94,86 +90,6 @@ function parseBackfillFlags(): BackfillFlags {
   };
 }
 
-function findJsonFiles(root: string): string[] {
-  const files: string[] = [];
-  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
-    const pathname = path.join(root, entry.name);
-    if (entry.isDirectory()) files.push(...findJsonFiles(pathname));
-    else if (entry.isFile() && entry.name.endsWith('.json')) files.push(pathname);
-  }
-  return files.toSorted();
-}
-
-function readMappedRows(root: string): BenchmarkParams[] {
-  const tracker = createSkipTracker();
-  const rows: BenchmarkParams[] = [];
-  for (const file of findJsonFiles(root)) {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as unknown;
-    const rawRows = Array.isArray(parsed) ? parsed : [parsed];
-    for (const raw of rawRows) {
-      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
-      const mapped = mapBenchmarkRow(raw as Record<string, unknown>, tracker);
-      if (mapped) rows.push(mapped);
-    }
-  }
-  return rows;
-}
-
-async function findBenchmarkResultIds(
-  run: CandidateRun,
-  rows: readonly BenchmarkParams[],
-): Promise<number[]> {
-  const ids = new Set<number>();
-  for (const row of rows) {
-    const c = row.config;
-    const candidates = await sql<{ id: number; offload_mode: string }[]>`
-      select br.id, br.offload_mode
-      from benchmark_results br
-      join workflow_runs wr on wr.id = br.workflow_run_id
-      join configs cfg on cfg.id = br.config_id
-      where wr.github_run_id = ${run.github_run_id}
-        and wr.run_attempt = ${run.run_attempt}
-        and cfg.hardware = ${c.hardware}
-        and cfg.framework = ${c.framework}
-        and cfg.model = ${c.model}
-        and cfg.precision = ${c.precision}
-        and cfg.spec_method = ${c.specMethod}
-        and cfg.disagg = ${c.disagg}
-        and cfg.is_multinode = ${c.isMultinode}
-        and cfg.prefill_tp = ${c.prefillTp}
-        and cfg.prefill_ep = ${c.prefillEp}
-        and cfg.prefill_dp_attention = ${c.prefillDpAttn}
-        and cfg.prefill_num_workers = ${c.prefillNumWorkers}
-        and cfg.decode_tp = ${c.decodeTp}
-        and cfg.decode_ep = ${c.decodeEp}
-        and cfg.decode_dp_attention = ${c.decodeDpAttn}
-        and cfg.decode_num_workers = ${c.decodeNumWorkers}
-        and cfg.num_prefill_gpu = ${c.numPrefillGpu}
-        and cfg.num_decode_gpu = ${c.numDecodeGpu}
-        and br.benchmark_type = ${row.benchmarkType}
-        and br.isl is not distinct from ${row.isl}
-        and br.osl is not distinct from ${row.osl}
-        and br.conc = ${row.conc}
-        and br.recipe_fingerprint is not distinct from ${row.recipeFingerprint}
-    `;
-    const resolution = resolveServerLogResultCandidates(
-      candidates.map((candidate) => ({
-        id: Number(candidate.id),
-        offloadMode: candidate.offload_mode,
-      })),
-      row.offloadMode,
-    );
-    if (resolution.usedUniqueFallback) {
-      console.warn(
-        `  [WARN] benchmark result ${resolution.ids[0]} uses a historical offload label; ` +
-          `matched uniquely without offload_mode`,
-      );
-    }
-    for (const id of resolution.ids) ids.add(id);
-  }
-  return [...ids];
-}
-
 async function resultLogsAreComplete(resultIds: readonly number[]): Promise<boolean> {
   if (resultIds.length === 0) return false;
   const [row] = await sql<{ complete: boolean }[]>`
@@ -311,8 +227,13 @@ async function main(): Promise<void> {
               : await retryArtifactOperation(`downloading ${pair.benchmarks.name}`, () =>
                   downloadArtifact(pair.benchmarks, tempDir),
                 );
-          const mappedRows = readMappedRows(benchmarkDir);
-          const resultIds = await findBenchmarkResultIds(run, mappedRows);
+          const mappedRows = readMappedBenchmarkRows(benchmarkDir);
+          const resultIds = await findBenchmarkResultIds(sql, run, mappedRows, (id) =>
+            console.warn(
+              `  [WARN] benchmark result ${id} uses a historical offload label; ` +
+                `matched uniquely without offload_mode`,
+            ),
+          );
           if (resultIds.length === 0) {
             unmatchedArtifacts++;
             console.warn(`  [WARN] ${pair.serverLogs.name}: no matching benchmark rows`);
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.test.ts b/packages/db/src/etl/gpu-metrics-artifacts.test.ts
new file mode 100644
index 000000000..f5efe03d4
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-artifacts.test.ts
@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import {
+  contextUtcOffsetMinutes,
+  discoverGpuMetricsArtifacts,
+  gpuMetricsArtifactSuffix,
+  listGpuMetricsCsvFiles,
+  parseEnergyCsv,
+  readGpuMetricsSidecars,
+} from './gpu-metrics-artifacts.js';
+
+const roots: string[] = [];
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function tempRoot(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-artifacts-'));
+  roots.push(root);
+  return root;
+}
+
+describe('gpu_metrics artifact discovery', () => {
+  it('pairs by the bare suffix and ignores eval-only uploads', () => {
+    expect(gpuMetricsArtifactSuffix('gpu_metrics_dsr1_8k1k_conc1_b200-x_0')).toBe(
+      'dsr1_8k1k_conc1_b200-x_0',
+    );
+    expect(gpuMetricsArtifactSuffix('eval_gpu_metrics_dsr1_8k1k_conc1_b200-x_0')).toBeNull();
+    expect(gpuMetricsArtifactSuffix('bmk_dsr1')).toBeNull();
+  });
+
+  it('lists telemetry CSVs recursively but skips identity and energy sidecars', () => {
+    const root = tempRoot();
+    fs.mkdirSync(path.join(root, 'results'));
+    fs.writeFileSync(path.join(root, 'gpu_metrics.csv'), 'timestamp\n');
+    fs.writeFileSync(path.join(root, 'gpu_metrics_identity.csv'), 'index\n');
+    fs.writeFileSync(path.join(root, 'results', 'gpu_metrics_energy_start.csv'), 'gpu\n');
+    fs.writeFileSync(path.join(root, 'results', 'gpu_metrics_rank1.csv'), 'timestamp\n');
+    fs.writeFileSync(path.join(root, 'results', 'server.log'), '');
+
+    expect(listGpuMetricsCsvFiles(root).map((file) => file.fileName)).toEqual([
+      'gpu_metrics.csv',
+      'results/gpu_metrics_rank1.csv',
+    ]);
+  });
+
+  it('indexes extracted artifact directories by suffix', () => {
+    const root = tempRoot();
+    fs.mkdirSync(path.join(root, 'gpu_metrics_cfg-a_runner_0'));
+    fs.mkdirSync(path.join(root, 'bmk_cfg-a_runner_0'));
+    fs.writeFileSync(path.join(root, 'gpu_metrics_not-a-dir_0'), '');
+    const discovered = discoverGpuMetricsArtifacts(root);
+    expect([...discovered.keys()]).toEqual(['cfg-a_runner_0']);
+    expect(discovered.get('cfg-a_runner_0')?.artifactName).toBe('gpu_metrics_cfg-a_runner_0');
+  });
+});
+
+describe('sidecars', () => {
+  it('reads context, identity CSV, and energy counters next to the CSV', () => {
+    const root = tempRoot();
+    const csv = path.join(root, 'gpu_metrics.csv');
+    fs.writeFileSync(csv, 'timestamp\n');
+    fs.writeFileSync(path.join(root, 'gpu_metrics_context.json'), '{"timestamp_timezone":"UTC"}');
+    fs.writeFileSync(
+      path.join(root, 'gpu_metrics_identity.csv'),
+      'index, uuid, name\n0, GPU-abc, NVIDIA B200\n',
+    );
+    fs.writeFileSync(
+      path.join(root, 'gpu_metrics_energy_start.csv'),
+      'gpu,total_energy_consumption\n0,162815801.936\n',
+    );
+    const sidecars = readGpuMetricsSidecars(csv);
+    expect(sidecars.context).toEqual({ timestamp_timezone: 'UTC' });
+    expect(sidecars.identity).toEqual([{ index: '0', uuid: 'GPU-abc', name: 'NVIDIA B200' }]);
+    expect(sidecars.energyStart).toEqual({ '0': 162815801.936 });
+    expect(sidecars.energyEnd).toBeNull();
+  });
+
+  it('parses energy CSVs and rejects header-only files', () => {
+    expect(parseEnergyCsv('gpu,total_energy_consumption\n0,1.5\n1,2.5\n')).toEqual({
+      '0': 1.5,
+      '1': 2.5,
+    });
+    expect(parseEnergyCsv('gpu,total_energy_consumption\n')).toBeNull();
+  });
+
+  it('derives a fixed UTC offset only from ±HH:MM zones', () => {
+    expect(contextUtcOffsetMinutes({ timestamp_timezone: 'UTC' })).toBe(0);
+    expect(contextUtcOffsetMinutes({ timestamp_timezone: '-05:00' })).toBe(-300);
+    expect(contextUtcOffsetMinutes({ timestamp_timezone: '+0530' })).toBe(330);
+    expect(contextUtcOffsetMinutes(null)).toBe(0);
+  });
+});
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.ts b/packages/db/src/etl/gpu-metrics-artifacts.ts
new file mode 100644
index 000000000..885c6f0af
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-artifacts.ts
@@ -0,0 +1,173 @@
+/**
+ * Filesystem discovery for `gpu_metrics_<suffix>` artifacts.
+ *
+ * Layout uploaded by the producer (`benchmark-tmpl.yml` "Upload GPU metrics"):
+ *   gpu_metrics.csv                         fixed-sequence jobs
+ *   results/gpu_metrics.csv                 AgentX jobs (per-concurrency)
+ *   results/gpu_metrics*.csv                multinode staging, one CSV per node
+ *   gpu_metrics*_context.json               collector context (timestamp zone …)
+ *   gpu_metrics_identity.{json,csv}         SKU / UUID / driver per GPU
+ *   gpu_metrics_energy_{start,end}.csv      amd-smi energy counters
+ *
+ * `eval_gpu_metrics_<suffix>` (eval-only jobs) is deliberately ignored: those
+ * jobs produce no benchmark point to attach the telemetry to.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const GPU_METRICS_ARTIFACT_PREFIX = 'gpu_metrics_';
+
+export interface GpuMetricsArtifact {
+  artifactName: string;
+  artifactDir: string;
+}
+
+export interface GpuMetricsCsvFile {
+  /** POSIX-style path relative to the artifact root. */
+  fileName: string;
+  path: string;
+}
+
+export interface GpuMetricsSidecars {
+  context: Record<string, unknown> | null;
+  identity: unknown | null;
+  energyStart: Record<string, number> | null;
+  energyEnd: Record<string, number> | null;
+}
+
+/** Return the shared suffix that pairs a gpu_metrics artifact with bmk[_agentic]_<suffix>. */
+export function gpuMetricsArtifactSuffix(artifactName: string): string | null {
+  return artifactName.startsWith(GPU_METRICS_ARTIFACT_PREFIX)
+    ? artifactName.slice(GPU_METRICS_ARTIFACT_PREFIX.length)
+    : null;
+}
+
+function isGpuMetricsCsvName(fileName: string): boolean {
+  const lower = fileName.toLowerCase();
+  if (!lower.startsWith('gpu_metrics') || !lower.endsWith('.csv')) return false;
+  // Sidecars share the prefix but are not time series.
+  return !lower.includes('_identity') && !lower.includes('_energy_');
+}
+
+/** Recursively list every telemetry CSV under an extracted artifact root. */
+export function listGpuMetricsCsvFiles(root: string): GpuMetricsCsvFile[] {
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return [];
+  const files: GpuMetricsCsvFile[] = [];
+  const visit = (directory: string): void => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const pathname = path.join(directory, entry.name);
+      if (entry.isDirectory()) visit(pathname);
+      else if (entry.isFile() && isGpuMetricsCsvName(entry.name)) {
+        files.push({
+          fileName: path.relative(root, pathname).split(path.sep).join('/'),
+          path: pathname,
+        });
+      }
+    }
+  };
+  visit(root);
+  return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
+}
+
+function readJsonIfPresent(pathname: string): unknown | null {
+  if (!fs.existsSync(pathname)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(pathname, 'utf8')) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+/** `gpu,total_energy_consumption` two-column CSV → { "<gpu>": joules }. */
+export function parseEnergyCsv(text: string): Record<string, number> | null {
+  const lines = text
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  if (lines.length <= 1) return null;
+  const out: Record<string, number> = {};
+  for (const line of lines.slice(1)) {
+    const [gpu, value] = line.split(',');
+    const parsed = Number.parseFloat(value ?? '');
+    if (gpu !== undefined && gpu !== '' && Number.isFinite(parsed)) out[gpu.trim()] = parsed;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+
+/** Identity CSV (nvidia-smi) → array of column objects; JSON identity passes through. */
+function readIdentity(csvDir: string): unknown | null {
+  const json = readJsonIfPresent(path.join(csvDir, 'gpu_metrics_identity.json'));
+  if (json !== null) return json;
+  const csvPath = path.join(csvDir, 'gpu_metrics_identity.csv');
+  if (!fs.existsSync(csvPath)) return null;
+  const lines = fs
+    .readFileSync(csvPath, 'utf8')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  if (lines.length <= 1) return null;
+  const header = lines[0]!.split(',').map((h) => h.trim());
+  return lines.slice(1).map((line) => {
+    const cells = line.split(',').map((c) => c.trim());
+    return Object.fromEntries(header.map((key, i) => [key, cells[i] ?? '']));
+  });
+}
+
+/**
+ * Sidecars live next to the CSV they describe. The context file is either
+ * `gpu_metrics_context.json` or `<result>_gpu_metrics_context.json`.
+ */
+export function readGpuMetricsSidecars(csvPath: string): GpuMetricsSidecars {
+  const dir = path.dirname(csvPath);
+  let context: Record<string, unknown> | null = null;
+  for (const entry of fs.readdirSync(dir)) {
+    if (!entry.toLowerCase().endsWith('_context.json') || !entry.includes('gpu_metrics')) continue;
+    const parsed = readJsonIfPresent(path.join(dir, entry));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      context = parsed as Record<string, unknown>;
+      break;
+    }
+  }
+  const energyStartPath = path.join(dir, 'gpu_metrics_energy_start.csv');
+  const energyEndPath = path.join(dir, 'gpu_metrics_energy_end.csv');
+  return {
+    context,
+    identity: readIdentity(dir),
+    energyStart: fs.existsSync(energyStartPath)
+      ? parseEnergyCsv(fs.readFileSync(energyStartPath, 'utf8'))
+      : null,
+    energyEnd: fs.existsSync(energyEndPath)
+      ? parseEnergyCsv(fs.readFileSync(energyEndPath, 'utf8'))
+      : null,
+  };
+}
+
+/**
+ * Collector clock offset in minutes east of UTC, from the context sidecar.
+ * The producer writes `{"timestamp_timezone":"UTC"}`; anything else that is
+ * not a fixed `±HH:MM` offset is treated as UTC because nvidia-smi timestamps
+ * carry no zone of their own.
+ */
+export function contextUtcOffsetMinutes(context: Record<string, unknown> | null): number {
+  const zone = context?.timestamp_timezone;
+  if (typeof zone !== 'string') return 0;
+  const match = /^(?<sign>[+-])(?<h>\d{2}):?(?<m>\d{2})$/u.exec(zone.trim());
+  if (!match?.groups) return 0;
+  const minutes = Number(match.groups.h) * 60 + Number(match.groups.m);
+  return match.groups.sign === '-' ? -minutes : minutes;
+}
+
+/** Index every extracted gpu_metrics artifact by its shared suffix. */
+export function discoverGpuMetricsArtifacts(artifactsDir: string): Map<string, GpuMetricsArtifact> {
+  const discovered = new Map<string, GpuMetricsArtifact>();
+  if (!fs.existsSync(artifactsDir)) return discovered;
+  for (const artifactName of fs.readdirSync(artifactsDir)) {
+    const suffix = gpuMetricsArtifactSuffix(artifactName);
+    if (!suffix) continue;
+    const artifactDir = path.join(artifactsDir, artifactName);
+    if (!fs.statSync(artifactDir).isDirectory()) continue;
+    discovered.set(suffix, { artifactName, artifactDir });
+  }
+  return discovered;
+}
diff --git a/packages/db/src/etl/gpu-metrics-csv.test.ts b/packages/db/src/etl/gpu-metrics-csv.test.ts
new file mode 100644
index 000000000..2a2e2d0e0
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-csv.test.ts
@@ -0,0 +1,143 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  computeGpuMetricStats,
+  parseAmdTimestamp,
+  parseGpuMetricsCsv,
+  parseMetricCell,
+  parseNvidiaTimestamp,
+  summarizeGpuMetricSamples,
+} from './gpu-metrics-csv.js';
+
+const NVIDIA_CSV = [
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+  '2026/09/11 04:19:41.982, 0, 187.80 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:41.986, 1, 190.96 W, 39, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:42.990, 0, 912.10 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+  '2026/09/11 04:19:42.994, 1, [N/A], 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+  '2026/09/11 04:19:43.990, 0, 930.00 W, 63, 1965 MHz, 3996 MHz, 99 %, 75 %',
+].join('\n');
+
+const AMD_HEADER =
+  'timestamp,gpu,gfx_activity,umc_activity,mm_activity,socket_power,gfx_voltage,soc_voltage,mem_voltage,gfx_0_clk,mem_0_clk,fclk_0_clk,socclk_0_clk,edge,hotspot,mem';
+
+const AMD_CSV = [
+  AMD_HEADER,
+  `1789515524,0,0,0,N/A,288,N/A,N/A,N/A,2402,2000,1250,39,N/A,44,24`,
+  `1789515525,0,95,80,N/A,1180,850,900,1250,2100,2000,1250,39,55,78,60`,
+  `1789515524,1,0,0,N/A,290,N/A,N/A,N/A,2402,2000,1250,39,40,45,25`,
+].join('\r\n');
+
+describe('parseGpuMetricsCsv — NVIDIA', () => {
+  it('parses unit-suffixed cells into UTC epoch samples and drops rows without power', () => {
+    const parsed = parseGpuMetricsCsv(NVIDIA_CSV);
+    expect(parsed?.vendor).toBe('nvidia');
+    expect(parsed?.samples).toHaveLength(4);
+    const first = parsed!.samples[0]!;
+    expect(first.timestampMs).toBe(Date.UTC(2026, 8, 11, 4, 19, 41, 982));
+    expect(first.gpuIndex).toBe(0);
+    expect(first.powerW).toBe(187.8);
+    expect(first.temperatureC).toBe(33);
+    expect(first.smClockMhz).toBe(120);
+    expect(first.memClockMhz).toBe(3996);
+    expect(first.gpuUtilPct).toBe(0);
+    expect(first.memUtilPct).toBe(0);
+    expect(first.edgeTempC).toBeNull();
+    // The `[N/A]` power row for GPU 1 is not a usable sample.
+    expect(parsed!.samples.filter((s) => s.gpuIndex === 1)).toHaveLength(1);
+  });
+
+  it('applies a fixed collector offset when the context is not UTC', () => {
+    const parsed = parseGpuMetricsCsv(NVIDIA_CSV, { nvidiaUtcOffsetMinutes: -300 });
+    expect(parsed!.samples[0]!.timestampMs).toBe(Date.UTC(2026, 8, 11, 9, 19, 41, 982));
+  });
+
+  it('returns null for a header-only file or an unknown header', () => {
+    expect(parseGpuMetricsCsv(NVIDIA_CSV.split('\n')[0]!)).toBeNull();
+    expect(parseGpuMetricsCsv('a,b,c\n1,2,3')).toBeNull();
+  });
+});
+
+describe('parseGpuMetricsCsv — AMD', () => {
+  it('maps the amd-smi subset, preferring hotspot over edge temperature', () => {
+    const parsed = parseGpuMetricsCsv(AMD_CSV);
+    expect(parsed?.vendor).toBe('amd');
+    expect(parsed?.samples).toHaveLength(3);
+    const idle = parsed!.samples[0]!;
+    expect(idle.timestampMs).toBe(1789515524000);
+    expect(idle.powerW).toBe(288);
+    expect(idle.temperatureC).toBe(44);
+    expect(idle.edgeTempC).toBeNull();
+    expect(idle.memTempC).toBe(24);
+    expect(idle.gfxVoltageMv).toBeNull();
+    const busy = parsed!.samples[1]!;
+    expect(busy.gpuUtilPct).toBe(95);
+    expect(busy.memUtilPct).toBe(80);
+    expect(busy.gfxVoltageMv).toBe(850);
+    expect(busy.fclkMhz).toBe(1250);
+    expect(busy.socclkMhz).toBe(39);
+    expect(busy.edgeTempC).toBe(55);
+    expect(busy.temperatureC).toBe(78);
+  });
+});
+
+describe('timestamp and cell helpers', () => {
+  it('parses nvidia-smi timestamps with and without milliseconds', () => {
+    expect(parseNvidiaTimestamp('2026/01/02 03:04:05')).toBe(Date.UTC(2026, 0, 2, 3, 4, 5));
+    expect(parseNvidiaTimestamp('2026/01/02 03:04:05.5')).toBe(Date.UTC(2026, 0, 2, 3, 4, 5, 500));
+    expect(parseNvidiaTimestamp('not a date')).toBeNull();
+  });
+
+  it('accepts epoch seconds, epoch milliseconds, and ISO strings for amd-smi', () => {
+    expect(parseAmdTimestamp('1789515524')).toBe(1789515524000);
+    expect(parseAmdTimestamp('1789515524.25')).toBe(1789515524250);
+    expect(parseAmdTimestamp('1789515524000')).toBe(1789515524000);
+    expect(parseAmdTimestamp('2026-09-16T00:00:00Z')).toBe(Date.UTC(2026, 8, 16));
+    expect(parseAmdTimestamp('12')).toBeNull();
+  });
+
+  it('treats N/A and blanks as null', () => {
+    expect(parseMetricCell('N/A')).toBeNull();
+    expect(parseMetricCell('')).toBeNull();
+    expect(parseMetricCell(undefined)).toBeNull();
+    expect(parseMetricCell(' 12.5 W')).toBe(12.5);
+  });
+});
+
+describe('computeGpuMetricStats', () => {
+  it('digests every non-null metric per GPU with interpolated percentiles', () => {
+    const parsed = parseGpuMetricsCsv(NVIDIA_CSV)!;
+    const stats = computeGpuMetricStats(parsed.samples);
+    const gpu0Power = stats.find((s) => s.gpuIndex === 0 && s.metric === 'powerW')!;
+    expect(gpu0Power.count).toBe(3);
+    expect(gpu0Power.min).toBe(187.8);
+    expect(gpu0Power.max).toBe(930);
+    expect(gpu0Power.mean).toBeCloseTo((187.8 + 912.1 + 930) / 3, 6);
+    expect(gpu0Power.median).toBe(912.1);
+    expect(gpu0Power.p95).toBeCloseTo(912.1 + (930 - 912.1) * 0.9, 6);
+    expect(gpu0Power.p99).toBeCloseTo(912.1 + (930 - 912.1) * 0.98, 6);
+    expect(gpu0Power.stddev).toBeGreaterThan(0);
+    // AMD-only columns never appear for an NVIDIA series.
+    expect(stats.some((s) => s.metric === 'edgeTempC')).toBe(false);
+    expect(stats.filter((s) => s.gpuIndex === 1 && s.metric === 'powerW')[0]!.count).toBe(1);
+  });
+
+  it('returns an empty digest for no samples', () => {
+    expect(computeGpuMetricStats([])).toEqual([]);
+  });
+});
+
+describe('summarizeGpuMetricSamples', () => {
+  it('reports the window, GPU count, and median per-GPU cadence', () => {
+    const summary = summarizeGpuMetricSamples(parseGpuMetricsCsv(NVIDIA_CSV)!.samples)!;
+    expect(summary.sampleCount).toBe(4);
+    expect(summary.gpuCount).toBe(2);
+    expect(summary.startedAtMs).toBe(Date.UTC(2026, 8, 11, 4, 19, 41, 982));
+    expect(summary.endedAtMs).toBe(Date.UTC(2026, 8, 11, 4, 19, 43, 990));
+    expect(summary.sampleIntervalS).toBeCloseTo(1.004, 3);
+  });
+
+  it('returns null for an empty series', () => {
+    expect(summarizeGpuMetricSamples([])).toBeNull();
+  });
+});
diff --git a/packages/db/src/etl/gpu-metrics-csv.ts b/packages/db/src/etl/gpu-metrics-csv.ts
new file mode 100644
index 000000000..35ec33e57
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-csv.ts
@@ -0,0 +1,385 @@
+/**
+ * Parser and digest for the producer's `gpu_metrics.csv` telemetry.
+ *
+ * The InferenceX runner samples `nvidia-smi --query-gpu=…` or `amd-smi metric
+ * --csv` once per second for the lifetime of a benchmark job. This module is
+ * pure (no I/O) so the CI ingest, the historical backfill, and the app's
+ * GitHub fallback path all normalize the two vendor formats identically.
+ */
+
+export type GpuMetricsVendor = 'nvidia' | 'amd';
+
+export interface GpuMetricSample {
+  /** Sample instant in epoch milliseconds (UTC). */
+  timestampMs: number;
+  gpuIndex: number;
+  powerW: number | null;
+  temperatureC: number | null;
+  smClockMhz: number | null;
+  memClockMhz: number | null;
+  gpuUtilPct: number | null;
+  memUtilPct: number | null;
+  edgeTempC: number | null;
+  memTempC: number | null;
+  gfxVoltageMv: number | null;
+  socVoltageMv: number | null;
+  memVoltageMv: number | null;
+  fclkMhz: number | null;
+  socclkMhz: number | null;
+  mmActivityPct: number | null;
+}
+
+export interface ParsedGpuMetricsCsv {
+  vendor: GpuMetricsVendor;
+  samples: GpuMetricSample[];
+}
+
+/** Sample columns that participate in the per-GPU statistics digest. */
+export const GPU_METRIC_STAT_KEYS = [
+  'powerW',
+  'temperatureC',
+  'smClockMhz',
+  'memClockMhz',
+  'gpuUtilPct',
+  'memUtilPct',
+  'edgeTempC',
+  'memTempC',
+  'gfxVoltageMv',
+  'socVoltageMv',
+  'memVoltageMv',
+  'fclkMhz',
+  'socclkMhz',
+  'mmActivityPct',
+] as const;
+
+export type GpuMetricStatKey = (typeof GPU_METRIC_STAT_KEYS)[number];
+
+export interface GpuMetricStats {
+  gpuIndex: number;
+  metric: GpuMetricStatKey;
+  count: number;
+  min: number;
+  max: number;
+  mean: number;
+  median: number;
+  p95: number;
+  p99: number;
+  stddev: number;
+}
+
+export function splitCsvLine(line: string): string[] {
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+  for (const char of line) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === ',' && !inQuotes) {
+      result.push(current.trim());
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+
+function buildColumnMap(headerLine: string): Map<string, number> {
+  const headers = splitCsvLine(headerLine);
+  const map = new Map<string, number>();
+  for (let i = 0; i < headers.length; i++) map.set(headers[i]!.toLowerCase(), i);
+  return map;
+}
+
+/** `N/A`, empty, and unparseable cells become null; unit suffixes are ignored. */
+export function parseMetricCell(value: string | undefined): number | null {
+  if (value === undefined) return null;
+  const trimmed = value.trim();
+  if (trimmed === '' || trimmed === 'N/A' || trimmed === '[N/A]') return null;
+  const parsed = Number.parseFloat(trimmed);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+const NVIDIA_TIMESTAMP_RE =
+  /^(?<y>\d{4})\/(?<mo>\d{2})\/(?<d>\d{2}) (?<h>\d{2}):(?<mi>\d{2}):(?<s>\d{2})(?:\.(?<ms>\d{1,3}))?$/u;
+
+/**
+ * nvidia-smi prints `YYYY/MM/DD HH:MM:SS.mmm` in the collector's local zone.
+ * The producer runs its collectors with TZ=UTC; callers can pass a different
+ * fixed offset (minutes east of UTC) when a context sidecar says otherwise.
+ */
+export function parseNvidiaTimestamp(raw: string, offsetMinutes = 0): number | null {
+  const match = NVIDIA_TIMESTAMP_RE.exec(raw.trim());
+  if (!match?.groups) return null;
+  const { y, mo, d, h, mi, s, ms } = match.groups;
+  const millis = ms ? Number(ms.padEnd(3, '0')) : 0;
+  const utc = Date.UTC(
+    Number(y),
+    Number(mo) - 1,
+    Number(d),
+    Number(h),
+    Number(mi),
+    Number(s),
+    millis,
+  );
+  return utc - offsetMinutes * 60_000;
+}
+
+/** amd-smi prints Unix epoch seconds; accept fractional and millisecond forms. */
+export function parseAmdTimestamp(raw: string): number | null {
+  const trimmed = raw.trim();
+  if (/^\d+(?:\.\d+)?$/u.test(trimmed)) {
+    const numeric = Number.parseFloat(trimmed);
+    if (numeric > 1e12) return Math.round(numeric); // already milliseconds
+    if (numeric > 1e9) return Math.round(numeric * 1000);
+    return null;
+  }
+  const iso = Date.parse(trimmed);
+  return Number.isFinite(iso) ? iso : null;
+}
+
+function emptySample(timestampMs: number, gpuIndex: number): GpuMetricSample {
+  return {
+    timestampMs,
+    gpuIndex,
+    powerW: null,
+    temperatureC: null,
+    smClockMhz: null,
+    memClockMhz: null,
+    gpuUtilPct: null,
+    memUtilPct: null,
+    edgeTempC: null,
+    memTempC: null,
+    gfxVoltageMv: null,
+    socVoltageMv: null,
+    memVoltageMv: null,
+    fclkMhz: null,
+    socclkMhz: null,
+    mmActivityPct: null,
+  };
+}
+
+/**
+ * Columns: timestamp, index, power.draw [W], temperature.gpu,
+ * clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%],
+ * utilization.memory [%]. Header order is fixed by NVIDIA_GPU_MONITOR_QUERY in
+ * the producer, but we still resolve by name so a reordered query keeps working.
+ */
+function parseNvidiaCsv(lines: readonly string[], offsetMinutes: number): GpuMetricSample[] {
+  const header = splitCsvLine(lines[0]!).map((h) => h.toLowerCase().replace(/\s*\[.*\]$/u, ''));
+  const col = (name: string) => header.indexOf(name);
+  const iTimestamp = col('timestamp');
+  const iIndex = col('index');
+  const iPower = col('power.draw');
+  const iTemp = col('temperature.gpu');
+  const iSm = col('clocks.current.sm');
+  const iMem = col('clocks.current.memory');
+  const iUtil = col('utilization.gpu');
+  const iMemUtil = col('utilization.memory');
+  if (iTimestamp < 0 || iIndex < 0 || iPower < 0) return [];
+
+  const samples: GpuMetricSample[] = [];
+  for (let i = 1; i < lines.length; i++) {
+    const cols = splitCsvLine(lines[i]!);
+    if (cols.length <= Math.max(iTimestamp, iIndex, iPower)) continue;
+    const timestampMs = parseNvidiaTimestamp(cols[iTimestamp]!, offsetMinutes);
+    const gpuIndex = Number.parseInt(cols[iIndex]!, 10);
+    if (timestampMs === null || !Number.isInteger(gpuIndex) || gpuIndex < 0) continue;
+    const sample = emptySample(timestampMs, gpuIndex);
+    sample.powerW = parseMetricCell(cols[iPower]);
+    if (sample.powerW === null) continue;
+    sample.temperatureC = iTemp >= 0 ? parseMetricCell(cols[iTemp]) : null;
+    sample.smClockMhz = iSm >= 0 ? parseMetricCell(cols[iSm]) : null;
+    sample.memClockMhz = iMem >= 0 ? parseMetricCell(cols[iMem]) : null;
+    sample.gpuUtilPct = iUtil >= 0 ? parseMetricCell(cols[iUtil]) : null;
+    sample.memUtilPct = iMemUtil >= 0 ? parseMetricCell(cols[iMemUtil]) : null;
+    samples.push(sample);
+  }
+  return samples;
+}
+
+/**
+ * amd-smi `metric --csv` is a wide table. The consumed subset mirrors the
+ * dashboard: socket_power, gfx_activity, umc_activity, mm_activity, the first
+ * gfx/mem/fclk/socclk clock domains, hotspot/edge/mem temperatures and the
+ * three voltage rails.
+ */
+function parseAmdCsv(lines: readonly string[]): GpuMetricSample[] {
+  const colMap = buildColumnMap(lines[0]!);
+  const col = (name: string) => colMap.get(name) ?? -1;
+  const iTimestamp = col('timestamp');
+  const iGpu = col('gpu');
+  const iPower = col('socket_power');
+  const iGfxActivity = col('gfx_activity');
+  const iUmcActivity = col('umc_activity');
+  const iGfxClk = col('gfx_0_clk');
+  const iMemClk = col('mem_0_clk');
+  const iHotspot = col('hotspot');
+  const iEdge = col('edge');
+  const iMemTemp = col('mem');
+  const iGfxVoltage = col('gfx_voltage');
+  const iSocVoltage = col('soc_voltage');
+  const iMemVoltage = col('mem_voltage');
+  const iFclk = col('fclk_0_clk');
+  const iSocClk = col('socclk_0_clk');
+  const iMmActivity = col('mm_activity');
+  if (iTimestamp < 0 || iGpu < 0 || iPower < 0) return [];
+
+  const samples: GpuMetricSample[] = [];
+  for (let i = 1; i < lines.length; i++) {
+    const cols = splitCsvLine(lines[i]!);
+    if (cols.length <= Math.max(iTimestamp, iGpu, iPower)) continue;
+    const timestampMs = parseAmdTimestamp(cols[iTimestamp]!);
+    const gpuIndex = Number.parseInt(cols[iGpu]!, 10);
+    if (timestampMs === null || !Number.isInteger(gpuIndex) || gpuIndex < 0) continue;
+    const sample = emptySample(timestampMs, gpuIndex);
+    sample.powerW = parseMetricCell(cols[iPower]);
+    if (sample.powerW === null) continue;
+    const hotspot = iHotspot >= 0 ? parseMetricCell(cols[iHotspot]) : null;
+    const edge = iEdge >= 0 ? parseMetricCell(cols[iEdge]) : null;
+    sample.temperatureC = hotspot ?? edge;
+    sample.edgeTempC = edge;
+    sample.memTempC = iMemTemp >= 0 ? parseMetricCell(cols[iMemTemp]) : null;
+    sample.smClockMhz = iGfxClk >= 0 ? parseMetricCell(cols[iGfxClk]) : null;
+    sample.memClockMhz = iMemClk >= 0 ? parseMetricCell(cols[iMemClk]) : null;
+    sample.gpuUtilPct = iGfxActivity >= 0 ? parseMetricCell(cols[iGfxActivity]) : null;
+    sample.memUtilPct = iUmcActivity >= 0 ? parseMetricCell(cols[iUmcActivity]) : null;
+    sample.gfxVoltageMv = iGfxVoltage >= 0 ? parseMetricCell(cols[iGfxVoltage]) : null;
+    sample.socVoltageMv = iSocVoltage >= 0 ? parseMetricCell(cols[iSocVoltage]) : null;
+    sample.memVoltageMv = iMemVoltage >= 0 ? parseMetricCell(cols[iMemVoltage]) : null;
+    sample.fclkMhz = iFclk >= 0 ? parseMetricCell(cols[iFclk]) : null;
+    sample.socclkMhz = iSocClk >= 0 ? parseMetricCell(cols[iSocClk]) : null;
+    sample.mmActivityPct = iMmActivity >= 0 ? parseMetricCell(cols[iMmActivity]) : null;
+    samples.push(sample);
+  }
+  return samples;
+}
+
+export interface ParseGpuMetricsOptions {
+  /** Fixed offset of the NVIDIA collector clock, minutes east of UTC. */
+  nvidiaUtcOffsetMinutes?: number;
+}
+
+/**
+ * Parse one gpu_metrics CSV, auto-detecting the vendor from the header.
+ * Samples are returned in file order; callers sort per GPU as needed.
+ */
+export function parseGpuMetricsCsv(
+  csvText: string,
+  options: ParseGpuMetricsOptions = {},
+): ParsedGpuMetricsCsv | null {
+  const lines = csvText
+    .split('\n')
+    .map((line) => line.replace(/\r$/u, ''))
+    .filter((line) => line.trim().length > 0);
+  if (lines.length <= 1) return null;
+  const headerLower = lines[0]!.toLowerCase();
+  if (headerLower.includes('socket_power') || headerLower.includes('gfx_activity')) {
+    return { vendor: 'amd', samples: parseAmdCsv(lines) };
+  }
+  if (headerLower.includes('power.draw')) {
+    return {
+      vendor: 'nvidia',
+      samples: parseNvidiaCsv(lines, options.nvidiaUtcOffsetMinutes ?? 0),
+    };
+  }
+  return null;
+}
+
+function percentile(sorted: readonly number[], p: number): number {
+  const idx = (p / 100) * (sorted.length - 1);
+  const lo = Math.floor(idx);
+  const hi = Math.ceil(idx);
+  if (lo === hi) return sorted[lo]!;
+  return sorted[lo]! + (sorted[hi]! - sorted[lo]!) * (idx - lo);
+}
+
+/** Per-GPU, per-metric summary over every non-null sample. */
+export function computeGpuMetricStats(samples: readonly GpuMetricSample[]): GpuMetricStats[] {
+  const groups = new Map<
+    string,
+    { gpuIndex: number; metric: GpuMetricStatKey; values: number[] }
+  >();
+  for (const sample of samples) {
+    for (const metric of GPU_METRIC_STAT_KEYS) {
+      const value = sample[metric];
+      if (value === null) continue;
+      const key = `${sample.gpuIndex}|${metric}`;
+      let group = groups.get(key);
+      if (!group) {
+        group = { gpuIndex: sample.gpuIndex, metric, values: [] };
+        groups.set(key, group);
+      }
+      group.values.push(value);
+    }
+  }
+
+  const stats: GpuMetricStats[] = [];
+  for (const group of groups.values()) {
+    const sorted = group.values.toSorted((a, b) => a - b);
+    const mean = sorted.reduce((acc, v) => acc + v, 0) / sorted.length;
+    const variance = sorted.reduce((acc, v) => acc + (v - mean) ** 2, 0) / sorted.length;
+    stats.push({
+      gpuIndex: group.gpuIndex,
+      metric: group.metric,
+      count: sorted.length,
+      min: sorted[0]!,
+      max: sorted.at(-1)!,
+      mean,
+      median: percentile(sorted, 50),
+      p95: percentile(sorted, 95),
+      p99: percentile(sorted, 99),
+      stddev: Math.sqrt(variance),
+    });
+  }
+  return stats.toSorted((a, b) => a.gpuIndex - b.gpuIndex || a.metric.localeCompare(b.metric));
+}
+
+export interface GpuMetricSeriesSummary {
+  sampleCount: number;
+  gpuCount: number;
+  startedAtMs: number;
+  endedAtMs: number;
+  /** Median gap between consecutive samples of one GPU, in seconds. */
+  sampleIntervalS: number | null;
+}
+
+/** Window and cadence facts stored on the series row. */
+export function summarizeGpuMetricSamples(
+  samples: readonly GpuMetricSample[],
+): GpuMetricSeriesSummary | null {
+  if (samples.length === 0) return null;
+  let startedAtMs = Number.POSITIVE_INFINITY;
+  let endedAtMs = Number.NEGATIVE_INFINITY;
+  const byGpu = new Map<number, number[]>();
+  for (const sample of samples) {
+    if (sample.timestampMs < startedAtMs) startedAtMs = sample.timestampMs;
+    if (sample.timestampMs > endedAtMs) endedAtMs = sample.timestampMs;
+    const bucket = byGpu.get(sample.gpuIndex);
+    if (bucket) bucket.push(sample.timestampMs);
+    else byGpu.set(sample.gpuIndex, [sample.timestampMs]);
+  }
+  const gaps: number[] = [];
+  for (const timestamps of byGpu.values()) {
+    const sorted = timestamps.toSorted((a, b) => a - b);
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i]! - sorted[i - 1]!;
+      if (gap > 0) gaps.push(gap);
+    }
+  }
+  const sampleIntervalS =
+    gaps.length > 0
+      ? percentile(
+          gaps.toSorted((a, b) => a - b),
+          50,
+        ) / 1000
+      : null;
+  return {
+    sampleCount: samples.length,
+    gpuCount: byGpu.size,
+    startedAtMs,
+    endedAtMs,
+    sampleIntervalS,
+  };
+}
diff --git a/packages/db/src/etl/gpu-metrics-ingest.test.ts b/packages/db/src/etl/gpu-metrics-ingest.test.ts
new file mode 100644
index 000000000..c1d135aa5
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-ingest.test.ts
@@ -0,0 +1,203 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import { ingestGpuMetricsArtifact, prepareGpuMetricsArtifact } from './gpu-metrics-ingest';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+let sql: Sql;
+const roots: string[] = [];
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, {
+    json: JSON.stringify,
+    array: (value: unknown) => value,
+  });
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  sql = Object.assign(queryClient(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(queryClient(tx) as unknown as Sql)),
+  }) as unknown as Sql;
+}, 20_000);
+
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+    VALUES (1, 34557177019, 1, 'Run Sweep', 'completed', 'success', '2026-09-11', '2026-09-11');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 4, 4, 4, 4);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+           (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}');`);
+});
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+afterAll(async () => {
+  await db?.close();
+});
+
+const NVIDIA_CSV = [
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+  '2026/09/11 04:19:41.982, 0, 187.80 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:41.986, 1, 190.96 W, 39, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:42.990, 0, 912.10 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+  // Duplicate flush of the last sample, as emitted when the monitor stops.
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+].join('\n');
+
+function writeArtifact(csv: string, contextZone = 'UTC') {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-ingest-'));
+  roots.push(root);
+  const artifactName = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+  const artifactDir = path.join(root, artifactName);
+  fs.mkdirSync(artifactDir);
+  fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_context.json'),
+    JSON.stringify({ timestamp_timezone: contextZone }),
+  );
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_identity.csv'),
+    'index, uuid, name\n0, GPU-a, NVIDIA B200\n1, GPU-b, NVIDIA B200\n',
+  );
+  return { artifactName, artifactDir };
+}
+
+describe('prepareGpuMetricsArtifact', () => {
+  it('parses each CSV with its sidecars and digest', () => {
+    const [series] = prepareGpuMetricsArtifact(writeArtifact(NVIDIA_CSV));
+    expect(series?.fileName).toBe('gpu_metrics.csv');
+    expect(series?.vendor).toBe('nvidia');
+    expect(series?.samples).toHaveLength(5);
+    expect(series?.gpuCount).toBe(2);
+    expect(series?.sidecars.context).toEqual({ timestamp_timezone: 'UTC' });
+    expect(series?.stats.find((s) => s.gpuIndex === 0 && s.metric === 'powerW')?.max).toBe(912.1);
+  });
+});
+
+describe('ingestGpuMetricsArtifact', () => {
+  it('stores series, samples, digest, and point links; reruns are no-ops', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 10],
+    });
+    expect(first.seriesIds).toHaveLength(1);
+    // Five CSV rows, but the repeated final sample collapses on the primary key.
+    expect(first.samplesInserted).toBe(4);
+    expect(first.seriesSkipped).toBe(0);
+
+    const [series] = await sql<
+      {
+        artifact_name: string;
+        config_key: string;
+        vendor: string;
+        sample_count: number;
+        gpu_count: number;
+        started_at: Date;
+        ended_at: Date;
+        sample_interval_s: number | null;
+      }[]
+    >`select artifact_name, config_key, vendor, sample_count, gpu_count, started_at, ended_at,
+        sample_interval_s from gpu_metric_series`;
+    expect(series!.artifact_name).toBe(artifact.artifactName);
+    expect(series!.config_key).toBe('dsr1_8k1k_fp4_sglang_conc32_b200-x_0');
+    expect(series!.vendor).toBe('nvidia');
+    expect(series!.sample_count).toBe(5);
+    expect(series!.gpu_count).toBe(2);
+    expect(new Date(series!.started_at).toISOString()).toBe('2026-09-11T04:19:41.982Z');
+    expect(new Date(series!.ended_at).toISOString()).toBe('2026-09-11T04:19:42.994Z');
+    expect(series!.sample_interval_s).toBeCloseTo(1.008, 3);
+
+    const samples = await sql<{ gpu_index: number; power_w: number; sampled_at: Date }[]>`
+      select gpu_index, power_w, sampled_at from gpu_metric_samples order by sampled_at, gpu_index`;
+    expect(samples.map((s) => [s.gpu_index, s.power_w])).toEqual([
+      [0, 187.8],
+      [1, 190.96],
+      [0, 912.1],
+      [1, 905.3],
+    ]);
+
+    const stats = await sql<
+      { gpu_index: number; metric: string; sample_count: number; max_value: number }[]
+    >`
+      select gpu_index, metric, sample_count, max_value from gpu_metric_gpu_stats
+      where metric = 'power_w' order by gpu_index`;
+    expect(stats).toEqual([
+      { gpu_index: 0, metric: 'power_w', sample_count: 2, max_value: 912.1 },
+      { gpu_index: 1, metric: 'power_w', sample_count: 3, max_value: 905.3 },
+    ]);
+
+    const links = await sql<{ benchmark_result_id: number }[]>`
+      select benchmark_result_id from benchmark_result_gpu_metrics order by 1`;
+    expect(links.map((l) => Number(l.benchmark_result_id))).toEqual([10]);
+
+    const rerun = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 11],
+    });
+    expect(rerun.seriesIds).toEqual(first.seriesIds);
+    expect(rerun.samplesInserted).toBe(0);
+    expect(rerun.seriesSkipped).toBe(1);
+    const relinked = await sql<{ benchmark_result_id: number }[]>`
+      select benchmark_result_id from benchmark_result_gpu_metrics order by 1`;
+    expect(relinked.map((l) => Number(l.benchmark_result_id))).toEqual([10, 11]);
+    const [count] = await sql<{ n: number }[]>`select count(*)::int as n from gpu_metric_samples`;
+    expect(count!.n).toBe(4);
+  });
+
+  it('replaces samples and digest when the CSV content changes', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    await ingestGpuMetricsArtifact(sql, { workflowRunId: 1, artifact, benchmarkResultIds: [10] });
+
+    const longer = `${NVIDIA_CSV}\n2026/09/11 04:19:43.990, 0, 950.00 W, 65, 1965 MHz, 3996 MHz, 99 %, 75 %`;
+    fs.writeFileSync(path.join(artifact.artifactDir, 'gpu_metrics.csv'), longer);
+    const result = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(result.samplesInserted).toBe(5);
+    expect(result.seriesSkipped).toBe(0);
+    const [series] = await sql<{ n: number; sample_count: number }[]>`
+      select (select count(*)::int from gpu_metric_series) as n, sample_count from gpu_metric_series`;
+    expect(series!.n).toBe(1);
+    expect(series!.sample_count).toBe(6);
+    const [stat] = await sql<{ max_value: number }[]>`
+      select max_value from gpu_metric_gpu_stats where gpu_index = 0 and metric = 'power_w'`;
+    expect(stat!.max_value).toBe(950);
+  });
+
+  it('ignores artifacts whose CSVs cannot be parsed', async () => {
+    const artifact = writeArtifact('nonsense,header\n1,2\n');
+    const result = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(result).toEqual({ seriesIds: [], samplesInserted: 0, seriesSkipped: 0 });
+  });
+});
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
new file mode 100644
index 000000000..dc68d0e74
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -0,0 +1,297 @@
+/**
+ * Persist one gpu_metrics artifact: series metadata, full-resolution samples,
+ * the per-GPU statistics digest, and links to the benchmark points it covers.
+ *
+ * Idempotency: a series is identified by (workflow run, artifact name, CSV
+ * path). Re-ingesting an identical CSV (same sha256) only refreshes the point
+ * links; a changed CSV replaces the stored samples and digest inside one
+ * transaction so readers never observe a half-written series.
+ */
+
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+
+import type postgres from 'postgres';
+
+import type { Sql } from './db-utils.js';
+
+/** Either a pooled client or the transaction handle passed to `sql.begin` callbacks. */
+type TxLike = Sql | postgres.TransactionSql;
+import {
+  computeGpuMetricStats,
+  parseGpuMetricsCsv,
+  summarizeGpuMetricSamples,
+  type GpuMetricSample,
+  type GpuMetricStats,
+  type GpuMetricsVendor,
+} from './gpu-metrics-csv.js';
+import {
+  contextUtcOffsetMinutes,
+  gpuMetricsArtifactSuffix,
+  listGpuMetricsCsvFiles,
+  readGpuMetricsSidecars,
+  type GpuMetricsArtifact,
+  type GpuMetricsSidecars,
+} from './gpu-metrics-artifacts.js';
+
+/** Samples are streamed to Postgres in unnest batches of this many rows. */
+const SAMPLE_BATCH_SIZE = 5000;
+
+export interface PreparedGpuMetricSeries {
+  fileName: string;
+  vendor: GpuMetricsVendor;
+  csvSha256: string;
+  samples: GpuMetricSample[];
+  stats: GpuMetricStats[];
+  sampleIntervalS: number | null;
+  gpuCount: number;
+  startedAtMs: number;
+  endedAtMs: number;
+  sidecars: GpuMetricsSidecars;
+}
+
+export interface GpuMetricsIngestResult {
+  seriesIds: number[];
+  samplesInserted: number;
+  seriesSkipped: number;
+}
+
+/** Parse every CSV in an extracted artifact; unparseable files are skipped. */
+export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
+  const prepared: PreparedGpuMetricSeries[] = [];
+  for (const file of listGpuMetricsCsvFiles(artifact.artifactDir)) {
+    const csvText = fs.readFileSync(file.path, 'utf8');
+    const sidecars = readGpuMetricsSidecars(file.path);
+    const parsed = parseGpuMetricsCsv(csvText, {
+      nvidiaUtcOffsetMinutes: contextUtcOffsetMinutes(sidecars.context),
+    });
+    if (!parsed) continue;
+    const summary = summarizeGpuMetricSamples(parsed.samples);
+    if (!summary) continue;
+    prepared.push({
+      fileName: file.fileName,
+      vendor: parsed.vendor,
+      csvSha256: createHash('sha256').update(csvText).digest('hex'),
+      samples: parsed.samples,
+      stats: computeGpuMetricStats(parsed.samples),
+      sampleIntervalS: summary.sampleIntervalS,
+      gpuCount: summary.gpuCount,
+      startedAtMs: summary.startedAtMs,
+      endedAtMs: summary.endedAtMs,
+      sidecars,
+    });
+  }
+  return prepared;
+}
+
+const STAT_METRIC_COLUMN: Record<GpuMetricStats['metric'], string> = {
+  powerW: 'power_w',
+  temperatureC: 'temperature_c',
+  smClockMhz: 'sm_clock_mhz',
+  memClockMhz: 'mem_clock_mhz',
+  gpuUtilPct: 'gpu_util_pct',
+  memUtilPct: 'mem_util_pct',
+  edgeTempC: 'edge_temp_c',
+  memTempC: 'mem_temp_c',
+  gfxVoltageMv: 'gfx_voltage_mv',
+  socVoltageMv: 'soc_voltage_mv',
+  memVoltageMv: 'mem_voltage_mv',
+  fclkMhz: 'fclk_mhz',
+  socclkMhz: 'socclk_mhz',
+  mmActivityPct: 'mm_activity_pct',
+};
+
+/** Stored metric names use the column spelling so SQL readers need no mapping. */
+export function statMetricColumn(metric: GpuMetricStats['metric']): string {
+  return STAT_METRIC_COLUMN[metric];
+}
+
+function nullable(values: (number | null)[]): (number | null)[] {
+  return values;
+}
+
+async function insertSampleBatch(
+  tx: TxLike,
+  seriesId: number,
+  batch: readonly GpuMetricSample[],
+): Promise<number> {
+  const inserted = await tx<{ n: number }[]>`
+    with ins as (
+      insert into gpu_metric_samples (
+        series_id, gpu_index, sampled_at,
+        power_w, temperature_c, sm_clock_mhz, mem_clock_mhz, gpu_util_pct, mem_util_pct,
+        edge_temp_c, mem_temp_c, gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv,
+        fclk_mhz, socclk_mhz, mm_activity_pct
+      )
+      select
+        ${seriesId},
+        unnest(${tx.array(batch.map((s) => s.gpuIndex))}::smallint[]),
+        to_timestamp(unnest(${tx.array(batch.map((s) => s.timestampMs / 1000))}::double precision[])),
+        unnest(${tx.array(nullable(batch.map((s) => s.powerW)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.temperatureC)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.smClockMhz)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.memClockMhz)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.gpuUtilPct)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.memUtilPct)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.edgeTempC)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.memTempC)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.gfxVoltageMv)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.socVoltageMv)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.memVoltageMv)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.fclkMhz)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.socclkMhz)))}::real[]),
+        unnest(${tx.array(nullable(batch.map((s) => s.mmActivityPct)))}::real[])
+      -- nvidia-smi occasionally repeats the final sample when the monitor is
+      -- stopped and flushed; the primary key makes that a no-op.
+      on conflict (series_id, gpu_index, sampled_at) do nothing
+      returning 1
+    )
+    select count(*)::int as n from ins
+  `;
+  return Number(inserted[0]?.n ?? 0);
+}
+
+async function insertStats(
+  tx: TxLike,
+  seriesId: number,
+  stats: readonly GpuMetricStats[],
+): Promise<void> {
+  if (stats.length === 0) return;
+  await tx`
+    insert into gpu_metric_gpu_stats (
+      series_id, gpu_index, metric, sample_count,
+      min_value, max_value, mean_value, median_value, p95_value, p99_value, stddev_value
+    )
+    select
+      ${seriesId},
+      unnest(${tx.array(stats.map((s) => s.gpuIndex))}::smallint[]),
+      unnest(${tx.array(stats.map((s) => statMetricColumn(s.metric)))}::text[]),
+      unnest(${tx.array(stats.map((s) => s.count))}::int[]),
+      unnest(${tx.array(stats.map((s) => s.min))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.max))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.mean))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.median))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.p95))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.p99))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.stddev))}::real[])
+  `;
+}
+
+/**
+ * Upsert one prepared series and link it to `benchmarkResultIds`. Returns the
+ * series id and how many sample rows were written (0 when the CSV was already
+ * stored with the same hash).
+ */
+export function upsertGpuMetricSeries(
+  sql: Sql,
+  input: {
+    workflowRunId: number;
+    artifactName: string;
+    series: PreparedGpuMetricSeries;
+    benchmarkResultIds: readonly number[];
+  },
+): Promise<{ seriesId: number; samplesInserted: number; replaced: boolean }> {
+  const { workflowRunId, artifactName, series, benchmarkResultIds } = input;
+  const configKey = gpuMetricsArtifactSuffix(artifactName) ?? artifactName;
+  const sidecarsJson = JSON.stringify(series.sidecars);
+
+  return sql.begin(async (tx) => {
+    const existing = await tx<{ id: number; csv_sha256: string }[]>`
+      select id, csv_sha256 from gpu_metric_series
+      where workflow_run_id = ${workflowRunId}
+        and artifact_name = ${artifactName}
+        and file_name = ${series.fileName}
+      for update
+    `;
+
+    let seriesId: number;
+    let needsSamples = true;
+    let replaced = false;
+    if (existing.length > 0) {
+      seriesId = Number(existing[0]!.id);
+      if (existing[0]!.csv_sha256 === series.csvSha256) {
+        needsSamples = false;
+      } else {
+        replaced = true;
+        await tx`delete from gpu_metric_samples where series_id = ${seriesId}`;
+        await tx`delete from gpu_metric_gpu_stats where series_id = ${seriesId}`;
+        await tx`
+          update gpu_metric_series set
+            vendor = ${series.vendor},
+            csv_sha256 = ${series.csvSha256},
+            sample_interval_s = ${series.sampleIntervalS},
+            sample_count = ${series.samples.length},
+            gpu_count = ${series.gpuCount},
+            started_at = to_timestamp(${series.startedAtMs / 1000}::double precision),
+            ended_at = to_timestamp(${series.endedAtMs / 1000}::double precision),
+            sidecars = ${sidecarsJson}::jsonb,
+            ingested_at = now()
+          where id = ${seriesId}
+        `;
+      }
+    } else {
+      const [row] = await tx<{ id: number }[]>`
+        insert into gpu_metric_series (
+          workflow_run_id, artifact_name, config_key, file_name, vendor, csv_sha256,
+          sample_interval_s, sample_count, gpu_count, started_at, ended_at, sidecars
+        ) values (
+          ${workflowRunId}, ${artifactName}, ${configKey}, ${series.fileName},
+          ${series.vendor}, ${series.csvSha256}, ${series.sampleIntervalS},
+          ${series.samples.length}, ${series.gpuCount},
+          to_timestamp(${series.startedAtMs / 1000}::double precision),
+          to_timestamp(${series.endedAtMs / 1000}::double precision),
+          ${sidecarsJson}::jsonb
+        )
+        returning id
+      `;
+      seriesId = Number(row!.id);
+    }
+
+    let samplesInserted = 0;
+    if (needsSamples) {
+      for (let offset = 0; offset < series.samples.length; offset += SAMPLE_BATCH_SIZE) {
+        samplesInserted += await insertSampleBatch(
+          tx,
+          seriesId,
+          series.samples.slice(offset, offset + SAMPLE_BATCH_SIZE),
+        );
+      }
+      await insertStats(tx, seriesId, series.stats);
+    }
+
+    if (benchmarkResultIds.length > 0) {
+      await tx`
+        insert into benchmark_result_gpu_metrics (benchmark_result_id, series_id)
+        select unnest(${tx.array([...new Set(benchmarkResultIds)])}::bigint[]), ${seriesId}
+        on conflict do nothing
+      `;
+    }
+
+    return { seriesId, samplesInserted, replaced };
+  });
+}
+
+/** Read, digest, and persist every CSV of one artifact for one set of points. */
+export async function ingestGpuMetricsArtifact(
+  sql: Sql,
+  input: {
+    workflowRunId: number;
+    artifact: GpuMetricsArtifact;
+    benchmarkResultIds: readonly number[];
+  },
+): Promise<GpuMetricsIngestResult> {
+  const prepared = prepareGpuMetricsArtifact(input.artifact);
+  const result: GpuMetricsIngestResult = { seriesIds: [], samplesInserted: 0, seriesSkipped: 0 };
+  for (const series of prepared) {
+    const upserted = await upsertGpuMetricSeries(sql, {
+      workflowRunId: input.workflowRunId,
+      artifactName: input.artifact.artifactName,
+      series,
+      benchmarkResultIds: input.benchmarkResultIds,
+    });
+    result.seriesIds.push(upserted.seriesId);
+    result.samplesInserted += upserted.samplesInserted;
+    if (upserted.samplesInserted === 0 && !upserted.replaced) result.seriesSkipped++;
+  }
+  return result;
+}
diff --git a/packages/db/src/ingest-ci-run.ts b/packages/db/src/ingest-ci-run.ts
index a27225bc9..90e87c33f 100644
--- a/packages/db/src/ingest-ci-run.ts
+++ b/packages/db/src/ingest-ci-run.ts
@@ -78,6 +78,8 @@ import {
 import { AsyncSemaphore } from './etl/async-semaphore';
 import { discoverTraceReplayArtifacts } from './etl/trace-artifact-discovery';
 import { discoverServerLogArtifacts, readServerLogArtifact } from './etl/server-log-artifacts';
+import { discoverGpuMetricsArtifacts } from './etl/gpu-metrics-artifacts';
+import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest';
 import { datasetSlugFromBenchmarkRow } from './etl/dataset-provenance';
 import { mapAggEvalRow, mapEvalRow } from './etl/eval-mapper';
 import { ingestEvalRow } from './etl/eval-ingest';
@@ -452,6 +454,8 @@ async function main(): Promise<void> {
   let totalSampleFiles = 0;
   let totalChangelogs = 0;
   let totalTraceReplayLinked = 0;
+  let totalGpuMetricSeries = 0;
+  let totalGpuMetricSamples = 0;
   const datasetSlugs = new Set<string>();
   // Dataset slugs referenced by this run's agentic rows but absent from the
   // `datasets` table — timeline→dataset deep links 404 until they're ingested.
@@ -484,6 +488,13 @@ async function main(): Promise<void> {
     if (serverLogArtifacts.size > 0) {
       console.log(`  Found ${serverLogArtifacts.size} server log artifact(s)`);
     }
+    // PowerX telemetry: `gpu_metrics_<key>` is uploaded next to `bmk_<key>` by
+    // every benchmark job (see migration 016). Digested here so the dashboard
+    // never re-downloads GitHub artifacts and keeps the series past retention.
+    const gpuMetricsArtifacts = discoverGpuMetricsArtifacts(artifactsDir);
+    if (gpuMetricsArtifacts.size > 0) {
+      console.log(`  Found ${gpuMetricsArtifacts.size} gpu_metrics artifact(s)`);
+    }
 
     // Sibling aiperf artifacts: each `bmk_agentic_<suffix>` is paired with an
     // `agentic_<suffix>` dir holding `profile_export.jsonl` and
@@ -665,6 +676,30 @@ async function main(): Promise<void> {
                 tracker.recordDbError(`server_logs for ${configKey}`, error);
               }
             }
+            // Same pairing rule as server logs: `gpu_metrics_<key>` carries no
+            // `agentic_` prefix, so agentic points fall back to the bare suffix.
+            const gpuMetricsArtifact =
+              gpuMetricsArtifacts.get(configKey) ??
+              gpuMetricsArtifacts.get(stripBmkAndAgenticPrefix(parentDir));
+            if (gpuMetricsArtifact) {
+              try {
+                const gpuMetricsStart = Date.now();
+                const ingested = await ingestGpuMetricsArtifact(sql, {
+                  workflowRunId,
+                  artifact: gpuMetricsArtifact,
+                  benchmarkResultIds: insertedIds,
+                });
+                totalGpuMetricSeries += ingested.seriesIds.length;
+                totalGpuMetricSamples += ingested.samplesInserted;
+                console.log(
+                  `    gpu_metrics ${ingested.seriesIds.length} series, ` +
+                    `+${ingested.samplesInserted} sample(s), ` +
+                    `${ingested.seriesSkipped} unchanged (${elapsed(gpuMetricsStart)})`,
+                );
+              } catch (error: any) {
+                tracker.recordDbError(`gpu_metrics for ${configKey}`, error);
+              }
+            }
           }
 
           // Trace-replay sibling lookup for agentic points only. The aiperf
diff --git a/packages/db/src/lib/benchmark-result-lookup.ts b/packages/db/src/lib/benchmark-result-lookup.ts
new file mode 100644
index 000000000..37afe2acd
--- /dev/null
+++ b/packages/db/src/lib/benchmark-result-lookup.ts
@@ -0,0 +1,97 @@
+/**
+ * Resolve persisted `benchmark_results` ids for raw artifact rows that were
+ * mapped through the production mapper. Shared by the sidecar backfills
+ * (server logs, gpu_metrics) so every historical attachment uses the same
+ * natural-key match as the CI ingest path.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { mapBenchmarkRow, type BenchmarkParams } from '../etl/benchmark-mapper.js';
+import { createSkipTracker } from '../etl/skip-tracker.js';
+import type { Sql } from '../etl/db-utils.js';
+import { resolveServerLogResultCandidates } from './server-log-backfill.js';
+
+export interface BenchmarkRunSelector {
+  github_run_id: number;
+  run_attempt: number;
+}
+
+export async function findBenchmarkResultIds(
+  sql: Sql,
+  run: BenchmarkRunSelector,
+  rows: readonly BenchmarkParams[],
+  onUniqueFallback: (id: number) => void = () => {},
+): Promise<number[]> {
+  const ids = new Set<number>();
+  for (const row of rows) {
+    const c = row.config;
+    const candidates = await sql<{ id: number; offload_mode: string }[]>`
+      select br.id, br.offload_mode
+      from benchmark_results br
+      join workflow_runs wr on wr.id = br.workflow_run_id
+      join configs cfg on cfg.id = br.config_id
+      where wr.github_run_id = ${run.github_run_id}
+        and wr.run_attempt = ${run.run_attempt}
+        and cfg.hardware = ${c.hardware}
+        and cfg.framework = ${c.framework}
+        and cfg.model = ${c.model}
+        and cfg.precision = ${c.precision}
+        and cfg.spec_method = ${c.specMethod}
+        and cfg.disagg = ${c.disagg}
+        and cfg.is_multinode = ${c.isMultinode}
+        and cfg.prefill_tp = ${c.prefillTp}
+        and cfg.prefill_ep = ${c.prefillEp}
+        and cfg.prefill_dp_attention = ${c.prefillDpAttn}
+        and cfg.prefill_num_workers = ${c.prefillNumWorkers}
+        and cfg.decode_tp = ${c.decodeTp}
+        and cfg.decode_ep = ${c.decodeEp}
+        and cfg.decode_dp_attention = ${c.decodeDpAttn}
+        and cfg.decode_num_workers = ${c.decodeNumWorkers}
+        and cfg.num_prefill_gpu = ${c.numPrefillGpu}
+        and cfg.num_decode_gpu = ${c.numDecodeGpu}
+        and br.benchmark_type = ${row.benchmarkType}
+        and br.isl is not distinct from ${row.isl}
+        and br.osl is not distinct from ${row.osl}
+        and br.conc = ${row.conc}
+        and br.recipe_fingerprint is not distinct from ${row.recipeFingerprint}
+    `;
+    const resolution = resolveServerLogResultCandidates(
+      candidates.map((candidate) => ({
+        id: Number(candidate.id),
+        offloadMode: candidate.offload_mode,
+      })),
+      row.offloadMode,
+    );
+    if (resolution.usedUniqueFallback) onUniqueFallback(resolution.ids[0]!);
+    for (const id of resolution.ids) ids.add(id);
+  }
+  return [...ids];
+}
+
+function findJsonFiles(root: string): string[] {
+  const files: string[] = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const pathname = path.join(root, entry.name);
+    if (entry.isDirectory()) files.push(...findJsonFiles(pathname));
+    else if (entry.isFile() && entry.name.endsWith('.json')) files.push(pathname);
+  }
+  return files.toSorted();
+}
+
+/** Map every raw benchmark JSON under an extracted bmk artifact through the production mapper. */
+export function readMappedBenchmarkRows(root: string): BenchmarkParams[] {
+  const tracker = createSkipTracker();
+  const rows: BenchmarkParams[] = [];
+  for (const file of findJsonFiles(root)) {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as unknown;
+    const rawRows = Array.isArray(parsed) ? parsed : [parsed];
+    for (const raw of rawRows) {
+      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
+      const mapped = mapBenchmarkRow(raw as Record<string, unknown>, tracker);
+      if (mapped) rows.push(mapped);
+    }
+  }
+  return rows;
+}
diff --git a/packages/db/src/lib/gpu-metrics-backfill.test.ts b/packages/db/src/lib/gpu-metrics-backfill.test.ts
new file mode 100644
index 000000000..7ebf88d66
--- /dev/null
+++ b/packages/db/src/lib/gpu-metrics-backfill.test.ts
@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest';
+
+import type { ArtifactMeta } from './github-artifacts.js';
+import { pairGpuMetricsArtifacts } from './gpu-metrics-backfill.js';
+
+const meta = (
+  name: string,
+  id: number,
+  created_at = '2026-09-11T00:00:00Z',
+  expired = false,
+): ArtifactMeta => ({
+  id,
+  name,
+  created_at,
+  expired,
+  archive_download_url: `https://example.test/${id}`,
+});
+
+describe('pairGpuMetricsArtifacts', () => {
+  it('pairs gpu_metrics with the exact bmk sibling and prefers the agentic sibling', () => {
+    const pairs = pairGpuMetricsArtifacts([
+      meta('gpu_metrics_cfg-a_h200-cw_0', 1),
+      meta('bmk_cfg-a_h200-cw_0', 2),
+      meta('gpu_metrics_cfg-b_h200-cw_0', 3),
+      meta('bmk_agentic_cfg-b_h200-cw_0', 4),
+      meta('bmk_cfg-b_h200-cw_0', 5),
+      meta('gpu_metrics_orphan_h200-cw_0', 6),
+      meta('eval_gpu_metrics_cfg-a_h200-cw_0', 7),
+    ]);
+    expect(pairs.map((pair) => [pair.gpuMetrics.name, pair.benchmarks.name])).toEqual([
+      ['gpu_metrics_cfg-a_h200-cw_0', 'bmk_cfg-a_h200-cw_0'],
+      ['gpu_metrics_cfg-b_h200-cw_0', 'bmk_agentic_cfg-b_h200-cw_0'],
+    ]);
+  });
+
+  it('keeps only the newest retry per logical benchmark and drops expired uploads', () => {
+    const pairs = pairGpuMetricsArtifacts([
+      meta('gpu_metrics_cfg-a_h200-cw_0', 1, '2026-09-11T00:00:00Z'),
+      meta('bmk_cfg-a_h200-cw_0', 2, '2026-09-11T00:00:00Z'),
+      meta('gpu_metrics_cfg-a_h200-dgxc-slurm_1', 3, '2026-09-11T02:00:00Z'),
+      meta('bmk_cfg-a_h200-dgxc-slurm_1', 4, '2026-09-11T02:00:00Z'),
+      meta('gpu_metrics_cfg-c_h200-cw_0', 5, '2026-09-11T03:00:00Z', true),
+      meta('bmk_cfg-c_h200-cw_0', 6, '2026-09-11T03:00:00Z'),
+    ]);
+    expect(pairs.map((pair) => pair.gpuMetrics.name)).toEqual([
+      'gpu_metrics_cfg-a_h200-dgxc-slurm_1',
+    ]);
+  });
+});
diff --git a/packages/db/src/lib/gpu-metrics-backfill.ts b/packages/db/src/lib/gpu-metrics-backfill.ts
new file mode 100644
index 000000000..94a09105a
--- /dev/null
+++ b/packages/db/src/lib/gpu-metrics-backfill.ts
@@ -0,0 +1,47 @@
+/** Pairing rules for the historical gpu_metrics backfill. */
+
+import { gpuMetricsArtifactSuffix } from '../etl/gpu-metrics-artifacts.js';
+import { RUNNER_SUFFIX_RE, type ArtifactMeta } from './github-artifacts.js';
+
+export interface GpuMetricsArtifactPair {
+  gpuMetrics: ArtifactMeta;
+  benchmarks: ArtifactMeta;
+}
+
+function isNewerArtifact(candidate: ArtifactMeta, existing: ArtifactMeta): boolean {
+  return (
+    candidate.created_at > existing.created_at ||
+    (candidate.created_at === existing.created_at && (candidate.id ?? 0) > (existing.id ?? 0))
+  );
+}
+
+/**
+ * Pair every unexpired gpu_metrics artifact with its exact bmk sibling. Retried
+ * jobs upload on different runners, so the newest artifact per logical
+ * (runner-suffix-stripped) benchmark name wins, matching CI ingest.
+ */
+export function pairGpuMetricsArtifacts(
+  artifacts: readonly ArtifactMeta[],
+): GpuMetricsArtifactPair[] {
+  const byName = new Map<string, ArtifactMeta>();
+  for (const artifact of artifacts) {
+    if (artifact.expired) continue;
+    const existing = byName.get(artifact.name);
+    if (!existing || isNewerArtifact(artifact, existing)) byName.set(artifact.name, artifact);
+  }
+  const byLogicalBenchmark = new Map<string, GpuMetricsArtifactPair>();
+  for (const gpuMetrics of byName.values()) {
+    const suffix = gpuMetricsArtifactSuffix(gpuMetrics.name);
+    if (!suffix) continue;
+    const benchmarks = byName.get(`bmk_agentic_${suffix}`) ?? byName.get(`bmk_${suffix}`);
+    if (!benchmarks) continue;
+    const logicalName = benchmarks.name.replace(RUNNER_SUFFIX_RE, '');
+    const existing = byLogicalBenchmark.get(logicalName);
+    if (!existing || isNewerArtifact(benchmarks, existing.benchmarks)) {
+      byLogicalBenchmark.set(logicalName, { gpuMetrics, benchmarks });
+    }
+  }
+  return [...byLogicalBenchmark.values()].toSorted((a, b) =>
+    a.gpuMetrics.name.localeCompare(b.gpuMetrics.name),
+  );
+}
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
new file mode 100644
index 000000000..1d6bfdb64
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -0,0 +1,342 @@
+/**
+ * Read side of the PowerX telemetry digest (migration 016).
+ *
+ * Two entry points: everything recorded during one GitHub Actions run (the
+ * PowerX explorer keyed by run ID), and the series linked to one benchmark
+ * point (the per-point detail tab). Samples are returned as flat rows with
+ * ISO timestamps so the existing D3 charts consume them unchanged.
+ */
+
+import type { DbClient } from '../connection.js';
+
+export interface GpuMetricSampleRow {
+  timestamp: string;
+  index: number;
+  power: number;
+  temperature: number;
+  smClock: number;
+  memClock: number;
+  gpuUtil: number;
+  memUtil: number;
+  edgeTemp?: number;
+  memTemp?: number;
+  gfxVoltage?: number;
+  socVoltage?: number;
+  memVoltage?: number;
+  fclk?: number;
+  socClk?: number;
+  mmActivity?: number;
+}
+
+export interface GpuMetricStatRow {
+  gpuIndex: number;
+  metric: string;
+  count: number;
+  min: number;
+  max: number;
+  mean: number;
+  median: number;
+  p95: number;
+  p99: number;
+  stddev: number;
+}
+
+export interface GpuMetricSeries {
+  id: number;
+  artifactName: string;
+  configKey: string;
+  fileName: string;
+  vendor: string;
+  sampleIntervalS: number | null;
+  sampleCount: number;
+  gpuCount: number;
+  startedAt: string;
+  endedAt: string;
+  sidecars: Record<string, unknown>;
+  benchmarkResultIds: number[];
+  stats: GpuMetricStatRow[];
+  data: GpuMetricSampleRow[];
+}
+
+export interface GpuMetricsRunPayload {
+  workflowRun: {
+    id: number;
+    githubRunId: number;
+    runAttempt: number;
+    name: string;
+    date: string;
+    htmlUrl: string | null;
+    headBranch: string | null;
+    headSha: string | null;
+    conclusion: string | null;
+    status: string | null;
+    createdAt: string | null;
+  };
+  series: GpuMetricSeries[];
+}
+
+interface RawSeriesRow {
+  id: number | string;
+  workflow_run_id: number | string;
+  artifact_name: string;
+  config_key: string;
+  file_name: string;
+  vendor: string;
+  sample_interval_s: number | null;
+  sample_count: number;
+  gpu_count: number;
+  started_at: string | Date;
+  ended_at: string | Date;
+  sidecars: Record<string, unknown> | string;
+  benchmark_result_ids: (number | string)[] | null;
+}
+
+interface RawStatRow {
+  series_id: number | string;
+  gpu_index: number;
+  metric: string;
+  sample_count: number;
+  min_value: number;
+  max_value: number;
+  mean_value: number;
+  median_value: number;
+  p95_value: number;
+  p99_value: number;
+  stddev_value: number;
+}
+
+interface RawSampleRow {
+  series_id: number | string;
+  gpu_index: number;
+  sampled_at: string | Date;
+  power_w: number | null;
+  temperature_c: number | null;
+  sm_clock_mhz: number | null;
+  mem_clock_mhz: number | null;
+  gpu_util_pct: number | null;
+  mem_util_pct: number | null;
+  edge_temp_c: number | null;
+  mem_temp_c: number | null;
+  gfx_voltage_mv: number | null;
+  soc_voltage_mv: number | null;
+  mem_voltage_mv: number | null;
+  fclk_mhz: number | null;
+  socclk_mhz: number | null;
+  mm_activity_pct: number | null;
+}
+
+const isoString = (value: string | Date): string =>
+  value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+
+const optional = (value: number | null): number | undefined => (value === null ? undefined : value);
+
+function toSampleRow(raw: RawSampleRow): GpuMetricSampleRow {
+  return {
+    timestamp: isoString(raw.sampled_at),
+    index: Number(raw.gpu_index),
+    power: raw.power_w ?? 0,
+    temperature: raw.temperature_c ?? 0,
+    smClock: raw.sm_clock_mhz ?? 0,
+    memClock: raw.mem_clock_mhz ?? 0,
+    gpuUtil: raw.gpu_util_pct ?? 0,
+    memUtil: raw.mem_util_pct ?? 0,
+    edgeTemp: optional(raw.edge_temp_c),
+    memTemp: optional(raw.mem_temp_c),
+    gfxVoltage: optional(raw.gfx_voltage_mv),
+    socVoltage: optional(raw.soc_voltage_mv),
+    memVoltage: optional(raw.mem_voltage_mv),
+    fclk: optional(raw.fclk_mhz),
+    socClk: optional(raw.socclk_mhz),
+    mmActivity: optional(raw.mm_activity_pct),
+  };
+}
+
+function toStatRow(raw: RawStatRow): GpuMetricStatRow {
+  return {
+    gpuIndex: Number(raw.gpu_index),
+    metric: raw.metric,
+    count: Number(raw.sample_count),
+    min: raw.min_value,
+    max: raw.max_value,
+    mean: raw.mean_value,
+    median: raw.median_value,
+    p95: raw.p95_value,
+    p99: raw.p99_value,
+    stddev: raw.stddev_value,
+  };
+}
+
+async function loadSeriesDetails(
+  sql: DbClient,
+  seriesRows: readonly RawSeriesRow[],
+  includeSamples: boolean,
+): Promise<GpuMetricSeries[]> {
+  if (seriesRows.length === 0) return [];
+  const ids = seriesRows.map((row) => Number(row.id));
+
+  const statRows = (await sql`
+    select series_id, gpu_index, metric, sample_count, min_value, max_value, mean_value,
+      median_value, p95_value, p99_value, stddev_value
+    from gpu_metric_gpu_stats
+    where series_id = any(${ids}::bigint[])
+    order by series_id, gpu_index, metric
+  `) as unknown as RawStatRow[];
+
+  const sampleRows = includeSamples
+    ? ((await sql`
+        select series_id, gpu_index, sampled_at, power_w, temperature_c, sm_clock_mhz,
+          mem_clock_mhz, gpu_util_pct, mem_util_pct, edge_temp_c, mem_temp_c,
+          gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv, fclk_mhz, socclk_mhz, mm_activity_pct
+        from gpu_metric_samples
+        where series_id = any(${ids}::bigint[])
+        order by series_id, sampled_at, gpu_index
+      `) as unknown as RawSampleRow[])
+    : [];
+
+  const statsBySeries = new Map<number, GpuMetricStatRow[]>();
+  for (const raw of statRows) {
+    const key = Number(raw.series_id);
+    const bucket = statsBySeries.get(key);
+    if (bucket) bucket.push(toStatRow(raw));
+    else statsBySeries.set(key, [toStatRow(raw)]);
+  }
+  const samplesBySeries = new Map<number, GpuMetricSampleRow[]>();
+  for (const raw of sampleRows) {
+    const key = Number(raw.series_id);
+    const bucket = samplesBySeries.get(key);
+    if (bucket) bucket.push(toSampleRow(raw));
+    else samplesBySeries.set(key, [toSampleRow(raw)]);
+  }
+
+  return seriesRows.map((row) => {
+    const id = Number(row.id);
+    return {
+      id,
+      artifactName: row.artifact_name,
+      configKey: row.config_key,
+      fileName: row.file_name,
+      vendor: row.vendor,
+      sampleIntervalS: row.sample_interval_s,
+      sampleCount: Number(row.sample_count),
+      gpuCount: Number(row.gpu_count),
+      startedAt: isoString(row.started_at),
+      endedAt: isoString(row.ended_at),
+      sidecars:
+        typeof row.sidecars === 'string'
+          ? (JSON.parse(row.sidecars) as Record<string, unknown>)
+          : row.sidecars,
+      benchmarkResultIds: (row.benchmark_result_ids ?? []).map(Number),
+      stats: statsBySeries.get(id) ?? [],
+      data: samplesBySeries.get(id) ?? [],
+    };
+  });
+}
+
+/**
+ * Every telemetry series stored for one GitHub Actions run (latest attempt).
+ * Returns null when the run is unknown or has no stored series, so callers can
+ * fall back to the live GitHub artifacts for in-flight runs.
+ */
+export async function getGpuMetricsForRun(
+  sql: DbClient,
+  githubRunId: number,
+  options: { includeSamples?: boolean } = {},
+): Promise<GpuMetricsRunPayload | null> {
+  const runRows = (await sql`
+    select id, github_run_id, run_attempt, name, date, html_url, head_branch, head_sha,
+      conclusion, status, created_at
+    from workflow_runs
+    where github_run_id = ${githubRunId}
+    order by run_attempt desc
+    limit 1
+  `) as unknown as {
+    id: number | string;
+    github_run_id: number | string;
+    run_attempt: number;
+    name: string;
+    date: string | Date;
+    html_url: string | null;
+    head_branch: string | null;
+    head_sha: string | null;
+    conclusion: string | null;
+    status: string | null;
+    created_at: string | Date | null;
+  }[];
+  const run = runRows[0];
+  if (!run) return null;
+
+  const seriesRows = (await sql`
+    select s.id, s.workflow_run_id, s.artifact_name, s.config_key, s.file_name, s.vendor,
+      s.sample_interval_s, s.sample_count, s.gpu_count, s.started_at, s.ended_at, s.sidecars,
+      (
+        select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
+        from benchmark_result_gpu_metrics l where l.series_id = s.id
+      ) as benchmark_result_ids
+    from gpu_metric_series s
+    where s.workflow_run_id = ${Number(run.id)}
+    order by s.artifact_name, s.file_name
+  `) as unknown as RawSeriesRow[];
+  if (seriesRows.length === 0) return null;
+
+  return {
+    workflowRun: {
+      id: Number(run.id),
+      githubRunId: Number(run.github_run_id),
+      runAttempt: Number(run.run_attempt),
+      name: run.name,
+      date: isoString(run.date).slice(0, 10),
+      htmlUrl: run.html_url,
+      headBranch: run.head_branch,
+      headSha: run.head_sha,
+      conclusion: run.conclusion,
+      status: run.status,
+      createdAt: run.created_at ? isoString(run.created_at) : null,
+    },
+    series: await loadSeriesDetails(sql, seriesRows, options.includeSamples ?? true),
+  };
+}
+
+export interface GpuMetricsPointPayload {
+  benchmarkResultId: number;
+  series: GpuMetricSeries[];
+}
+
+/** Series linked to one benchmark point, with samples. Null when none is linked. */
+export async function getGpuMetricsForPoint(
+  sql: DbClient,
+  benchmarkResultId: number,
+): Promise<GpuMetricsPointPayload | null> {
+  const seriesRows = (await sql`
+    select s.id, s.workflow_run_id, s.artifact_name, s.config_key, s.file_name, s.vendor,
+      s.sample_interval_s, s.sample_count, s.gpu_count, s.started_at, s.ended_at, s.sidecars,
+      (
+        select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
+        from benchmark_result_gpu_metrics l where l.series_id = s.id
+      ) as benchmark_result_ids
+    from benchmark_result_gpu_metrics link
+    join gpu_metric_series s on s.id = link.series_id
+    where link.benchmark_result_id = ${benchmarkResultId}
+    order by s.artifact_name, s.file_name
+  `) as unknown as RawSeriesRow[];
+  if (seriesRows.length === 0) return null;
+  return {
+    benchmarkResultId,
+    series: await loadSeriesDetails(sql, seriesRows, true),
+  };
+}
+
+/** `benchmark_results.id` → true for each id that has at least one linked series. */
+export async function getGpuMetricsAvailability(
+  sql: DbClient,
+  benchmarkResultIds: readonly number[],
+): Promise<Record<number, true>> {
+  if (benchmarkResultIds.length === 0) return {};
+  const rows = (await sql`
+    select distinct benchmark_result_id
+    from benchmark_result_gpu_metrics
+    where benchmark_result_id = any(${[...benchmarkResultIds]}::bigint[])
+  `) as unknown as { benchmark_result_id: number | string }[];
+  const out: Record<number, true> = {};
+  for (const row of rows) out[Number(row.benchmark_result_id)] = true;
+  return out;
+}
diff --git a/packages/db/src/verify-db.ts b/packages/db/src/verify-db.ts
index 1f4d51edd..3ab8f805c 100644
--- a/packages/db/src/verify-db.ts
+++ b/packages/db/src/verify-db.ts
@@ -50,6 +50,9 @@ async function verify(): Promise<void> {
     TABLE_NAMES.evalResults,
     TABLE_NAMES.evalSamples,
     TABLE_NAMES.changelogEntries,
+    TABLE_NAMES.gpuMetricSeries,
+    TABLE_NAMES.gpuMetricSamples,
+    TABLE_NAMES.benchmarkResultGpuMetrics,
   ];
   for (const t of tables) {
     const [{ n }] = await sql`select count(*)::int as n from ${sql(t)}`;

From 54ae365b51acfb7d9dc112be8322b80514992e9a Mon Sep 17 00:00:00 2001
From: Cam Quilici <cjquilici@gmail.com>
Date: Thu, 17 Sep 2026 13:52:28 -0500
Subject: [PATCH 002/103] feat(powerx): add rolling-average display mode and
 chip toggles to telemetry charts

Add a Points / Rolling average control to the PowerX telemetry charts on both
the explorer page and the per-point PowerX tab, with a 10/30/60/300 s window
selector. The average is a centered time-window mean per chip (pure helper in
telemetry-smoothing.ts, unit-tested for empty input, single sample, irregular
timestamps and inclusive window edges), so it follows elapsed time rather than
sample count. Averaged mode draws smooth lines and keeps the sample circles as
invisible hover targets so the tooltip and crosshair still work.

The per-point PowerX tab gains the same chip legend as the explorer so
individual chips can be hidden and restored, scoped to the selected series.
The chart's t=0 now comes from the whole series rather than the visible chips
so hiding a chip does not shift the time axis.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../components/gpu-power/GpuPowerChart.tsx    |  80 ++++++++++---
 .../components/gpu-power/GpuPowerDisplay.tsx  |  17 +++
 .../gpu-power/TelemetryDisplayControls.tsx    | 111 ++++++++++++++++++
 .../gpu-power/telemetry-smoothing.test.ts     |  70 +++++++++++
 .../gpu-power/telemetry-smoothing.ts          |  61 ++++++++++
 .../agentic-point/power-telemetry-view.tsx    |  88 +++++++++++++-
 6 files changed, 409 insertions(+), 18 deletions(-)
 create mode 100644 packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
 create mode 100644 packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
 create mode 100644 packages/app/src/components/gpu-power/telemetry-smoothing.ts

diff --git a/packages/app/src/components/gpu-power/GpuPowerChart.tsx b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
index e26796b1a..62447c3e9 100644
--- a/packages/app/src/components/gpu-power/GpuPowerChart.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
@@ -5,6 +5,11 @@ import React, { useMemo } from 'react';
 
 import { D3Chart } from '@/lib/d3-chart/D3Chart';
 import { useLocale } from '@/lib/use-locale';
+import {
+  DEFAULT_TELEMETRY_DISPLAY,
+  rollingTimeAverage,
+  type TelemetryDisplayState,
+} from './telemetry-smoothing';
 import {
   type GpuMetricKey,
   type GpuMetricRow,
@@ -25,6 +30,7 @@ const STRINGS = {
     power: 'Power',
     temp: 'Temp',
     utilization: 'Chip Util',
+    rollingSuffix: (windowS: number) => `${windowS} s rolling avg`,
   },
   zh: {
     empty: '暂无可显示的芯片指标数据。',
@@ -35,14 +41,18 @@ const STRINGS = {
     power: '功耗',
     temp: '温度',
     utilization: '芯片利用率',
+    rollingSuffix: (windowS: number) => `${windowS} 秒滚动平均`,
   },
 } as const;
 
 interface ParsedPoint {
   seconds: number;
+  /** Absolute sample time in ms; smoothing and alignment work in this space. */
+  ms: number;
   value: number;
   gpuIndex: number;
-  raw: GpuMetricRow;
+  /** The raw sample behind this point; null once the value has been averaged. */
+  raw: GpuMetricRow | null;
 }
 
 interface GpuMetricsChartProps {
@@ -54,6 +64,8 @@ interface GpuMetricsChartProps {
   caption?: React.ReactNode;
   /** Max interactive points before LTTB downsampling. Infinity to disable. */
   maxPoints?: number;
+  /** Raw samples vs. time-window rolling average. Defaults to raw samples. */
+  display?: TelemetryDisplayState;
 }
 
 function parseTimestamp(raw: string): Date | null {
@@ -71,15 +83,16 @@ function buildGroupedData(
   visibleGpus: Set<number>,
   metricKey: GpuMetricKey,
 ): Map<number, ParsedPoint[]> {
+  // t=0 is the first sample of the whole series, not of the visible chips, so
+  // hiding a chip never shifts the time axis under the remaining lines.
   let minTime = Infinity;
   const parsed: { row: GpuMetricRow; ms: number }[] = [];
   for (const row of data) {
-    if (!visibleGpus.has(row.index)) continue;
     const time = parseTimestamp(row.timestamp);
     if (!time) continue;
     const ms = time.getTime();
-    parsed.push({ row, ms });
     if (ms < minTime) minTime = ms;
+    if (visibleGpus.has(row.index)) parsed.push({ row, ms });
   }
 
   const groups = new Map<number, ParsedPoint[]>();
@@ -87,6 +100,7 @@ function buildGroupedData(
     if (!groups.has(row.index)) groups.set(row.index, []);
     groups.get(row.index)!.push({
       seconds: (ms - minTime) / 1000,
+      ms,
       value: row[metricKey] ?? 0,
       gpuIndex: row.index,
       raw: row,
@@ -98,7 +112,14 @@ function buildGroupedData(
   return groups;
 }
 
-const GPU_COLORS = d3.schemeTableau10;
+/** Replace each point's value with its centered time-window mean. */
+function smoothSeries(points: ParsedPoint[], windowS: number): ParsedPoint[] {
+  const averaged = rollingTimeAverage(points, windowS * 1000);
+  return points.map((point, i) => ({ ...point, value: averaged[i]!.value, raw: null }));
+}
+
+/** Per-chip palette shared with legends that toggle chips on and off. */
+export const GPU_COLORS = d3.schemeTableau10;
 const CHART_ID = 'gpu-metrics-line';
 const MARGIN = { top: 24, right: 20, bottom: 60, left: 60 };
 
@@ -111,16 +132,27 @@ const GpuMetricsChart = React.memo(
     legendElement,
     caption,
     maxPoints,
+    display = DEFAULT_TELEMETRY_DISPLAY,
   }: GpuMetricsChartProps) => {
     const locale = useLocale();
     const t = STRINGS[locale];
     const metricConfig = ALL_METRIC_OPTIONS.find((m) => m.key === metricKey)!;
+    const rolling = display.mode === 'rolling';
 
-    const groupedData = useMemo(
+    const rawGroups = useMemo(
       () => buildGroupedData(data, visibleGpus, metricKey),
       [data, visibleGpus, metricKey],
     );
 
+    const groupedData = useMemo(() => {
+      if (!rolling) return rawGroups;
+      const smoothed = new Map<number, ParsedPoint[]>();
+      for (const [gpuIndex, points] of rawGroups) {
+        smoothed.set(gpuIndex, smoothSeries(points, display.windowS));
+      }
+      return smoothed;
+    }, [rawGroups, rolling, display.windowS]);
+
     const allPoints = useMemo(() => {
       const pts: ParsedPoint[] = [];
       for (const points of groupedData.values()) pts.push(...points);
@@ -216,7 +248,7 @@ const GpuMetricsChart = React.memo(
             lines: lineData,
             config: {
               getColor: (key) => GPU_COLORS[parseInt(key, 10) % GPU_COLORS.length],
-              strokeWidth: 1.5,
+              strokeWidth: rolling ? 1.75 : 1.5,
               curve: d3.curveMonotoneX,
             },
           },
@@ -230,8 +262,11 @@ const GpuMetricsChart = React.memo(
               getCy: () => 0,
               getX: (d) => d.seconds,
               getY: (d) => d.value,
-              getColor: (d) => GPU_COLORS[d.gpuIndex % GPU_COLORS.length],
-              getRadius: () => 2,
+              // Averaged mode draws lines only; the circles stay as invisible
+              // hover targets so the tooltip and crosshair keep working.
+              getColor: (d) =>
+                rolling ? 'transparent' : GPU_COLORS[d.gpuIndex % GPU_COLORS.length],
+              getRadius: () => (rolling ? 3 : 2),
               maxPoints,
             },
           },
@@ -246,23 +281,36 @@ const GpuMetricsChart = React.memo(
           rulerType: 'crosshair',
           content: (d: ParsedPoint, isPinned: boolean) => {
             const color = GPU_COLORS[d.gpuIndex % GPU_COLORS.length];
+            const sep = locale === 'zh' ? '：' : ':';
             return `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md backdrop-blur-sm" style="min-width: 160px; user-select: ${isPinned ? 'text' : 'none'}">
               ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
               <div class="font-semibold mb-1" style="color: ${color}">${t.chip} ${d.gpuIndex}</div>
               <div class="text-muted-foreground">${d.seconds.toFixed(1)}${locale === 'zh' ? ' 秒' : 's'}</div>
-              <div class="mt-1 font-medium">${getGpuMetricLabel(metricConfig, locale)}${locale === 'zh' ? '：' : ':'} ${d.value.toFixed(1)} ${metricConfig.unit}</div>
-              <div class="text-muted-foreground">${t.power}${locale === 'zh' ? '：' : ':'} ${d.raw.power.toFixed(1)} W</div>
-              <div class="text-muted-foreground">${t.temp}${locale === 'zh' ? '：' : ':'} ${d.raw.temperature}\u00B0C</div>
-              <div class="text-muted-foreground">${t.utilization}${locale === 'zh' ? '：' : ':'} ${d.raw.gpuUtil}%</div>
+              <div class="mt-1 font-medium">${getGpuMetricLabel(metricConfig, locale)}${sep} ${d.value.toFixed(1)} ${metricConfig.unit}</div>
+              ${rolling ? `<div class="text-muted-foreground">${t.rollingSuffix(display.windowS)}</div>` : ''}
+              ${
+                d.raw
+                  ? `<div class="text-muted-foreground">${t.power}${sep} ${d.raw.power.toFixed(1)} W</div>
+              <div class="text-muted-foreground">${t.temp}${sep} ${d.raw.temperature}\u00B0C</div>
+              <div class="text-muted-foreground">${t.utilization}${sep} ${d.raw.gpuUtil}%</div>`
+                  : ''
+              }
             </div>`;
           },
           getRulerX: (d, xScale) => (xScale as d3.ScaleLinear<number, number>)(d.seconds),
           getRulerY: (d, yScale) => yScale(d.value),
-          onHoverStart: (sel) => {
-            sel.attr('r', 5).attr('stroke', 'white').attr('stroke-width', 1);
+          onHoverStart: (sel, d) => {
+            sel
+              .attr('r', 5)
+              .attr('fill', GPU_COLORS[d.gpuIndex % GPU_COLORS.length])
+              .attr('stroke', 'white')
+              .attr('stroke-width', 1);
           },
-          onHoverEnd: (sel) => {
-            sel.attr('r', 2).attr('stroke', 'none');
+          onHoverEnd: (sel, d) => {
+            sel
+              .attr('r', rolling ? 3 : 2)
+              .attr('fill', rolling ? 'transparent' : GPU_COLORS[d.gpuIndex % GPU_COLORS.length])
+              .attr('stroke', 'none');
           },
           attachToLayer: 2,
         }}
diff --git a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
index f0949589c..544795ed7 100644
--- a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
@@ -33,6 +33,8 @@ import { useClientSearchParams } from '@/hooks/useClientSearch';
 import GpuCorrelationChart from './GpuCorrelationChart';
 import GpuMetricsChart from './GpuPowerChart';
 import GpuStatsTable from './GpuStatsTable';
+import { DEFAULT_TELEMETRY_DISPLAY, type TelemetryDisplayState } from './telemetry-smoothing';
+import { TelemetryDisplayControls } from './TelemetryDisplayControls';
 import {
   type GpuMetricKey,
   type GpuPowerApiResponse,
@@ -81,6 +83,7 @@ const STRINGS = {
     chip: 'Chip',
     chartToolbar: 'Chart controls',
     correlationAxes: 'Correlation axes',
+    displayControls: 'Line options',
   },
   zh: {
     heading: 'PowerX',
@@ -119,6 +122,7 @@ const STRINGS = {
     chip: '芯片',
     chartToolbar: '图表控制',
     correlationAxes: '相关性坐标轴',
+    displayControls: '曲线选项',
   },
 } as const;
 
@@ -237,6 +241,7 @@ export default function GpuMetricsDisplay() {
   const [chartView, setChartView] = useState<GpuMetricsView>('chart');
   const [corrXMetric, setCorrXMetric] = useState<GpuMetricKey>('power');
   const [corrYMetric, setCorrYMetric] = useState<GpuMetricKey>('temperature');
+  const [display, setDisplay] = useState<TelemetryDisplayState>(DEFAULT_TELEMETRY_DISPLAY);
   const viewOptions = useMemo<SegmentedToggleOption<GpuMetricsView>[]>(
     () => [
       {
@@ -627,6 +632,17 @@ export default function GpuMetricsDisplay() {
               </ControlPanel>
             )}
 
+            {chartView === 'chart' && (
+              <ControlPanel legend={t.displayControls} className="mb-3 no-export">
+                <TelemetryDisplayControls
+                  value={display}
+                  onChange={setDisplay}
+                  analyticsPrefix="gpu_metrics"
+                  idPrefix="gpu-metrics-display"
+                />
+              </ControlPanel>
+            )}
+
             {chartView === 'chart' && (
               <GpuMetricsChart
                 data={currentData}
@@ -634,6 +650,7 @@ export default function GpuMetricsDisplay() {
                 metricKey={selectedMetric}
                 artifactName={selectedArtifact}
                 maxPoints={downsample ? 2000 : Infinity}
+                display={display}
                 caption={
                   <>
                     <h2 className="text-lg font-semibold">
diff --git a/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx b/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
new file mode 100644
index 000000000..82fedd75b
--- /dev/null
+++ b/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
@@ -0,0 +1,111 @@
+'use client';
+
+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 { track } from '@/lib/analytics';
+import { useLocale } from '@/lib/use-locale';
+
+import {
+  SMOOTHING_WINDOWS_S,
+  type SmoothingWindowS,
+  type TelemetryDisplayMode,
+  type TelemetryDisplayState,
+} from './telemetry-smoothing';
+
+const STRINGS = {
+  en: {
+    display: 'Display',
+    points: 'Points',
+    rolling: 'Rolling average',
+    window: 'Window',
+    windowOption: (s: number) => `${s} s`,
+  },
+  zh: {
+    display: '显示方式',
+    points: '数据点',
+    rolling: '滚动平均',
+    window: '窗口',
+    windowOption: (s: number) => `${s} 秒`,
+  },
+} as const;
+
+interface Props {
+  value: TelemetryDisplayState;
+  onChange: (next: TelemetryDisplayState) => void;
+  /** Analytics event prefix, e.g. `gpu_metrics` → `gpu_metrics_display_mode_changed`. */
+  analyticsPrefix: string;
+  /** Prefix for control ids so two charts on one page do not collide. */
+  idPrefix: string;
+  className?: string;
+}
+
+/**
+ * Display-mode controls shared by the PowerX explorer and the per-point PowerX
+ * tab: raw samples vs. a time-window rolling average.
+ */
+export function TelemetryDisplayControls({
+  value,
+  onChange,
+  analyticsPrefix,
+  idPrefix,
+  className,
+}: Props) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+
+  const modeOptions: SegmentedToggleOption<TelemetryDisplayMode>[] = [
+    { value: 'points', label: t.points, testId: `${idPrefix}-mode-points` },
+    { value: 'rolling', label: t.rolling, testId: `${idPrefix}-mode-rolling` },
+  ];
+
+  return (
+    <div className={className} data-testid={`${idPrefix}-controls`}>
+      <div className="flex flex-wrap items-end gap-x-4 gap-y-3">
+        <div className="space-y-1">
+          <Label id={`${idPrefix}-mode-label`}>{t.display}</Label>
+          <SegmentedToggle
+            value={value.mode}
+            options={modeOptions}
+            role="group"
+            ariaLabel={t.display}
+            onValueChange={(mode) => {
+              track(`${analyticsPrefix}_display_mode_changed`, { mode });
+              onChange({ ...value, mode });
+            }}
+          />
+        </div>
+        {value.mode === 'rolling' && (
+          <div className="space-y-1">
+            <Label htmlFor={`${idPrefix}-window`}>{t.window}</Label>
+            <Select
+              value={String(value.windowS)}
+              onValueChange={(raw) => {
+                const windowS = Number(raw) as SmoothingWindowS;
+                track(`${analyticsPrefix}_smoothing_window_changed`, { windowS });
+                onChange({ ...value, windowS });
+              }}
+            >
+              <SelectTrigger id={`${idPrefix}-window`} className="w-24" size="sm">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {SMOOTHING_WINDOWS_S.map((s) => (
+                  <SelectItem key={s} value={String(s)}>
+                    {t.windowOption(s)}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
new file mode 100644
index 000000000..f33793617
--- /dev/null
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+
+import { rollingTimeAverage, type TimedSample } from './telemetry-smoothing';
+
+const T0 = Date.parse('2026-09-15T21:36:14.107Z');
+
+/** One sample per second starting at T0, values from `values`. */
+function everySecond(values: number[], offsetMs = 0): TimedSample[] {
+  return values.map((value, i) => ({ ms: T0 + offsetMs + i * 1000, value }));
+}
+
+describe('rollingTimeAverage', () => {
+  it('returns an empty array for empty input', () => {
+    expect(rollingTimeAverage([], 30_000)).toEqual([]);
+  });
+
+  it('returns the sample unchanged for a single sample', () => {
+    expect(rollingTimeAverage([{ ms: T0, value: 812.4 }], 60_000)).toEqual([
+      { ms: T0, value: 812.4 },
+    ]);
+  });
+
+  it('copies the input when the window is zero or negative', () => {
+    const input = everySecond([1, 2, 3]);
+    expect(rollingTimeAverage(input, 0)).toEqual(input);
+    expect(rollingTimeAverage(input, -5)).toEqual(input);
+  });
+
+  it('averages a centered window and shrinks it at the series edges', () => {
+    // 1 s cadence, 2 s window => each sample sees itself and its immediate neighbours.
+    const out = rollingTimeAverage(everySecond([100, 200, 600, 200, 100]), 2000);
+    expect(out.map((p) => p.value)).toEqual([150, 300, 1000 / 3, 300, 150]);
+    expect(out.map((p) => p.ms)).toEqual(everySecond([0, 0, 0, 0, 0]).map((p) => p.ms));
+  });
+
+  it('treats both window edges as inclusive', () => {
+    // 4 s window => samples exactly 2 s away are included, 3 s away are not.
+    const out = rollingTimeAverage(everySecond([0, 0, 90, 0, 0, 0]), 4000);
+    // index 2 sees indices 0..4 (five samples) => 18; index 5 sees 3..5 => 0.
+    expect(out[2]!.value).toBeCloseTo(18);
+    expect(out[5]!.value).toBe(0);
+    // index 0 sees 0..2 => 30.
+    expect(out[0]!.value).toBeCloseTo(30);
+  });
+
+  it('uses elapsed time, not sample count, for irregular timestamps', () => {
+    const input: TimedSample[] = [
+      { ms: T0, value: 100 },
+      { ms: T0 + 500, value: 300 }, // burst of close samples
+      { ms: T0 + 700, value: 300 },
+      { ms: T0 + 60_000, value: 900 }, // one minute gap: outside any 10 s window
+    ];
+    const out = rollingTimeAverage(input, 10_000);
+    expect(out[0]!.value).toBeCloseTo((100 + 300 + 300) / 3);
+    expect(out[3]!.value).toBe(900);
+  });
+
+  it('smooths a step change into a ramp whose plateaus keep the original level', () => {
+    const values = [
+      ...Array.from({ length: 30 }, () => 250),
+      ...Array.from({ length: 30 }, () => 950),
+    ];
+    const out = rollingTimeAverage(everySecond(values), 10_000);
+    expect(out[5]!.value).toBe(250);
+    expect(out[54]!.value).toBe(950);
+    const ramp = out.slice(25, 35).map((p) => p.value);
+    for (let i = 1; i < ramp.length; i += 1) expect(ramp[i]!).toBeGreaterThanOrEqual(ramp[i - 1]!);
+    expect(ramp.at(-1)!).toBeGreaterThan(ramp[0]!);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
new file mode 100644
index 000000000..c4ee00e82
--- /dev/null
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
@@ -0,0 +1,61 @@
+/**
+ * Pure time-series helpers for the PowerX telemetry charts. They operate on
+ * absolute millisecond timestamps so irregular sampling (dropped rows, a few
+ * ms of skew between chips) is handled by time, not by sample index.
+ */
+
+export interface TimedSample {
+  /** Absolute timestamp in milliseconds since the Unix epoch. */
+  ms: number;
+  value: number;
+}
+
+/** Rolling-average window choices offered by the chart controls, in seconds. */
+export const SMOOTHING_WINDOWS_S = [10, 30, 60, 300] as const;
+export type SmoothingWindowS = (typeof SMOOTHING_WINDOWS_S)[number];
+
+export type TelemetryDisplayMode = 'points' | 'rolling';
+
+export interface TelemetryDisplayState {
+  mode: TelemetryDisplayMode;
+  windowS: SmoothingWindowS;
+}
+
+export const DEFAULT_TELEMETRY_DISPLAY: TelemetryDisplayState = {
+  mode: 'points',
+  windowS: 30,
+};
+
+/**
+ * Centered time-window mean. Each output sample averages every input sample
+ * whose timestamp lies within `windowMs / 2` (inclusive) of its own, so the
+ * smoothed line stays time-aligned with the raw one instead of lagging by half
+ * a window as a trailing average would. Window edges are inclusive on both
+ * sides; samples near the start or end of the series average over the shorter
+ * one-sided neighbourhood that exists.
+ *
+ * `samples` must be sorted by `ms` ascending. O(n) via prefix sums.
+ */
+export function rollingTimeAverage(
+  samples: readonly TimedSample[],
+  windowMs: number,
+): TimedSample[] {
+  if (samples.length === 0) return [];
+  if (!(windowMs > 0)) return samples.map(({ ms, value }) => ({ ms, value }));
+  const half = windowMs / 2;
+  const n = samples.length;
+  const prefix = new Float64Array(n + 1);
+  for (let i = 0; i < n; i += 1) prefix[i + 1] = prefix[i]! + samples[i]!.value;
+
+  const out: TimedSample[] = Array.from({ length: n });
+  let lo = 0;
+  let hi = 0;
+  for (let i = 0; i < n; i += 1) {
+    const center = samples[i]!.ms;
+    while (samples[lo]!.ms < center - half) lo += 1;
+    while (hi < n && samples[hi]!.ms <= center + half) hi += 1;
+    const count = hi - lo;
+    out[i] = { ms: center, value: (prefix[hi]! - prefix[lo]!) / count };
+  }
+  return out;
+}
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
index 8337eedb7..f50c7d568 100644
--- a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -2,8 +2,13 @@
 
 import { useMemo, useState } from 'react';
 
-import GpuMetricsChart from '@/components/gpu-power/GpuPowerChart';
+import GpuMetricsChart, { GPU_COLORS } from '@/components/gpu-power/GpuPowerChart';
 import GpuStatsTable from '@/components/gpu-power/GpuStatsTable';
+import { TelemetryDisplayControls } from '@/components/gpu-power/TelemetryDisplayControls';
+import {
+  DEFAULT_TELEMETRY_DISPLAY,
+  type TelemetryDisplayState,
+} from '@/components/gpu-power/telemetry-smoothing';
 import {
   type GpuMetricKey,
   type GpuMetricRow,
@@ -12,6 +17,7 @@ import {
   getGpuMetricLabel,
 } from '@/components/gpu-power/types';
 import { Card } from '@/components/ui/card';
+import ChartLegend from '@/components/ui/chart-legend';
 import { Label } from '@/components/ui/label';
 import { RetryableQueryError } from '@/components/ui/retryable-query-error';
 import {
@@ -43,6 +49,7 @@ const STRINGS = {
     perGpuStats: 'Per-chip statistics',
     chip: 'Chip',
     secondsUnit: 's',
+    resetFilter: 'Show all chips',
   },
   zh: {
     loading: '正在加载 PowerX 遥测数据……',
@@ -61,6 +68,7 @@ const STRINGS = {
     perGpuStats: '单芯片统计信息',
     chip: '芯片',
     secondsUnit: '秒',
+    resetFilter: '显示全部芯片',
   },
 } as const;
 
@@ -101,7 +109,39 @@ export function PowerTelemetryView({ id, enabled }: Props) {
     ? metricSelection
     : 'power';
   const metricConfig = ALL_METRIC_OPTIONS.find((m) => m.key === metricKey)!;
-  const visibleGpus = useMemo(() => new Set(data.map((row) => row.index)), [data]);
+  const allGpuIndices = useMemo(
+    () => [...new Set(data.map((row) => row.index))].toSorted((a, b) => a - b),
+    [data],
+  );
+  // Hidden chips are scoped to the series they were hidden on so switching
+  // series never carries over a stale filter.
+  const [hiddenSelection, setHiddenSelection] = useState<{
+    seriesId: number;
+    hidden: number[];
+  } | null>(null);
+  const hiddenGpus = useMemo(
+    () =>
+      new Set(
+        hiddenSelection && hiddenSelection.seriesId === selectedSeries?.id
+          ? hiddenSelection.hidden
+          : [],
+      ),
+    [hiddenSelection, selectedSeries?.id],
+  );
+  const visibleGpus = useMemo(
+    () => new Set(allGpuIndices.filter((gpuIndex) => !hiddenGpus.has(gpuIndex))),
+    [allGpuIndices, hiddenGpus],
+  );
+  const toggleGpu = (gpuIndex: number) => {
+    if (!selectedSeries) return;
+    track('inference_agentic_power_gpu_toggled', { id, gpuIndex });
+    const next = new Set(hiddenGpus);
+    if (next.has(gpuIndex)) next.delete(gpuIndex);
+    else next.add(gpuIndex);
+    setHiddenSelection({ seriesId: selectedSeries.id, hidden: [...next] });
+  };
+  const [isLegendExpanded, setIsLegendExpanded] = useState(true);
+  const [display, setDisplay] = useState<TelemetryDisplayState>(DEFAULT_TELEMETRY_DISPLAY);
 
   if (!enabled) return null;
 
@@ -229,6 +269,13 @@ export function PowerTelemetryView({ id, enabled }: Props) {
             </Select>
           </div>
         </div>
+        <TelemetryDisplayControls
+          value={display}
+          onChange={setDisplay}
+          analyticsPrefix="inference_agentic_power"
+          idPrefix="power-telemetry-display"
+          className="mt-3 border-t border-border/60 pt-3"
+        />
       </Card>
 
       <Card className="relative" data-testid="power-telemetry-chart">
@@ -238,6 +285,43 @@ export function PowerTelemetryView({ id, enabled }: Props) {
           metricKey={metricKey}
           artifactName={selectedSeries.artifactName}
           maxPoints={2000}
+          display={display}
+          legendElement={
+            <ChartLegend
+              variant="sidebar"
+              legendItems={allGpuIndices.map((gpuIndex) => ({
+                name: `${t.chip} ${gpuIndex}`,
+                hw: String(gpuIndex),
+                label: `${t.chip} ${gpuIndex}`,
+                color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
+                isActive: visibleGpus.has(gpuIndex),
+                onClick: () => toggleGpu(gpuIndex),
+              }))}
+              onItemRemove={(hw) => {
+                const gpuIndex = Number(hw);
+                if (visibleGpus.has(gpuIndex)) toggleGpu(gpuIndex);
+              }}
+              isLegendExpanded={isLegendExpanded}
+              onExpandedChange={(expanded) => {
+                setIsLegendExpanded(expanded);
+                track('inference_agentic_power_legend_expanded', { id, expanded });
+              }}
+              actions={
+                hiddenGpus.size === 0
+                  ? []
+                  : [
+                      {
+                        id: 'power-telemetry-show-all-chips',
+                        label: t.resetFilter,
+                        onClick: () => {
+                          track('inference_agentic_power_gpu_reset_filter', { id });
+                          setHiddenSelection(null);
+                        },
+                      },
+                    ]
+              }
+            />
+          }
           caption={
             <span className="text-xs text-muted-foreground">
               {getGpuMetricLabel(metricConfig, locale)} · {t.sharedNote}

From 5422a82cb0eb4a0ce03de073c2fd9096a6f80b2d Mon Sep 17 00:00:00 2001
From: Cam Quilici <cjquilici@gmail.com>
Date: Thu, 17 Sep 2026 13:57:13 -0500
Subject: [PATCH 003/103] feat(powerx): add mean-across-chips line to telemetry
 charts

Add a Lines control (Per chip / Mean of chips / Both) next to the display-mode
toggle on both PowerX surfaces. The mean line averages the currently visible
chips at each timestamp of the longest series, aligning the other chips by
nearest sample within one estimated poll interval (median gap), so the few ms
of skew between nvidia-smi rows and the occasional dropped row do not
interpolate or misalign. It is drawn in the foreground color at a heavier
stroke, labelled in a key row under the caption, and its tooltip reports how
many chips contributed. The rolling-average mode smooths the mean line too.

The shared line layer gains an optional per-series getStrokeWidth so one
keyed join can hold both the chip lines and the heavier mean line.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../components/gpu-power/GpuPowerChart.tsx    | 105 +++++++++++++++---
 .../gpu-power/TelemetryDisplayControls.tsx    |  30 ++++-
 .../gpu-power/telemetry-smoothing.test.ts     |  94 +++++++++++++++-
 .../gpu-power/telemetry-smoothing.ts          |  72 ++++++++++++
 .../app/src/lib/d3-chart/layers/lines.test.ts |  23 ++++
 packages/app/src/lib/d3-chart/layers/lines.ts |   4 +-
 6 files changed, 309 insertions(+), 19 deletions(-)

diff --git a/packages/app/src/components/gpu-power/GpuPowerChart.tsx b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
index 62447c3e9..17a9f4790 100644
--- a/packages/app/src/components/gpu-power/GpuPowerChart.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
@@ -7,6 +7,8 @@ import { D3Chart } from '@/lib/d3-chart/D3Chart';
 import { useLocale } from '@/lib/use-locale';
 import {
   DEFAULT_TELEMETRY_DISPLAY,
+  estimateSampleIntervalMs,
+  meanAcrossSeries,
   rollingTimeAverage,
   type TelemetryDisplayState,
 } from './telemetry-smoothing';
@@ -31,6 +33,8 @@ const STRINGS = {
     temp: 'Temp',
     utilization: 'Chip Util',
     rollingSuffix: (windowS: number) => `${windowS} s rolling avg`,
+    meanChips: 'Mean of visible chips',
+    meanCount: (n: number) => `${n} chips`,
   },
   zh: {
     empty: '暂无可显示的芯片指标数据。',
@@ -42,6 +46,8 @@ const STRINGS = {
     temp: '温度',
     utilization: '芯片利用率',
     rollingSuffix: (windowS: number) => `${windowS} 秒滚动平均`,
+    meanChips: '可见芯片均值',
+    meanCount: (n: number) => `${n} 个芯片`,
   },
 } as const;
 
@@ -53,6 +59,8 @@ interface ParsedPoint {
   gpuIndex: number;
   /** The raw sample behind this point; null once the value has been averaged. */
   raw: GpuMetricRow | null;
+  /** For the mean line: how many chips contributed at this timestamp. */
+  count?: number;
 }
 
 interface GpuMetricsChartProps {
@@ -82,7 +90,7 @@ function buildGroupedData(
   data: GpuMetricRow[],
   visibleGpus: Set<number>,
   metricKey: GpuMetricKey,
-): Map<number, ParsedPoint[]> {
+): { t0Ms: number; groups: Map<number, ParsedPoint[]> } {
   // t=0 is the first sample of the whole series, not of the visible chips, so
   // hiding a chip never shifts the time axis under the remaining lines.
   let minTime = Infinity;
@@ -109,7 +117,23 @@ function buildGroupedData(
   for (const points of groups.values()) {
     points.sort((a, b) => a.seconds - b.seconds);
   }
-  return groups;
+  return { t0Ms: minTime, groups };
+}
+
+/** Mean across the visible chips, aligned by nearest sample within one poll interval. */
+function buildMeanSeries(groups: Map<number, ParsedPoint[]>, t0Ms: number): ParsedPoint[] {
+  const arrays = [...groups.values()];
+  if (arrays.length === 0) return [];
+  const longest = arrays.reduce((a, b) => (b.length > a.length ? b : a));
+  const mean = meanAcrossSeries(arrays, estimateSampleIntervalMs(longest));
+  return mean.map((p) => ({
+    seconds: (p.ms - t0Ms) / 1000,
+    ms: p.ms,
+    value: p.value,
+    gpuIndex: MEAN_INDEX,
+    raw: null,
+    count: p.count,
+  }));
 }
 
 /** Replace each point's value with its centered time-window mean. */
@@ -120,6 +144,18 @@ function smoothSeries(points: ParsedPoint[], windowS: number): ParsedPoint[] {
 
 /** Per-chip palette shared with legends that toggle chips on and off. */
 export const GPU_COLORS = d3.schemeTableau10;
+/** Pseudo chip index and line key for the mean across visible chips. */
+const MEAN_INDEX = -1;
+const MEAN_KEY = 'mean';
+const MEAN_COLOR = 'var(--foreground)';
+
+function lineKey(gpuIndex: number): string {
+  return gpuIndex === MEAN_INDEX ? MEAN_KEY : String(gpuIndex);
+}
+
+function colorFor(gpuIndex: number): string {
+  return gpuIndex === MEAN_INDEX ? MEAN_COLOR : GPU_COLORS[gpuIndex % GPU_COLORS.length]!;
+}
 const CHART_ID = 'gpu-metrics-line';
 const MARGIN = { top: 24, right: 20, bottom: 60, left: 60 };
 
@@ -138,20 +174,30 @@ const GpuMetricsChart = React.memo(
     const t = STRINGS[locale];
     const metricConfig = ALL_METRIC_OPTIONS.find((m) => m.key === metricKey)!;
     const rolling = display.mode === 'rolling';
+    const showChips = display.series !== 'mean';
+    const showMean = display.series !== 'chips';
 
-    const rawGroups = useMemo(
+    const { t0Ms, groups: rawGroups } = useMemo(
       () => buildGroupedData(data, visibleGpus, metricKey),
       [data, visibleGpus, metricKey],
     );
 
+    // Displayed series keyed by chip index (MEAN_INDEX for the mean line):
+    // per-chip and/or mean, then optionally smoothed.
     const groupedData = useMemo(() => {
-      if (!rolling) return rawGroups;
+      const series = new Map<number, ParsedPoint[]>();
+      if (showChips) for (const [gpuIndex, points] of rawGroups) series.set(gpuIndex, points);
+      if (showMean) {
+        const mean = buildMeanSeries(rawGroups, t0Ms);
+        if (mean.length > 0) series.set(MEAN_INDEX, mean);
+      }
+      if (!rolling) return series;
       const smoothed = new Map<number, ParsedPoint[]>();
-      for (const [gpuIndex, points] of rawGroups) {
+      for (const [gpuIndex, points] of series) {
         smoothed.set(gpuIndex, smoothSeries(points, display.windowS));
       }
       return smoothed;
-    }, [rawGroups, rolling, display.windowS]);
+    }, [rawGroups, t0Ms, showChips, showMean, rolling, display.windowS]);
 
     const allPoints = useMemo(() => {
       const pts: ParsedPoint[] = [];
@@ -163,11 +209,35 @@ const GpuMetricsChart = React.memo(
     const lineData = useMemo(() => {
       const result: Record<string, { x: number; y: number }[]> = {};
       for (const [gpuIndex, points] of groupedData) {
-        result[String(gpuIndex)] = points.map((p) => ({ x: p.seconds, y: p.value }));
+        result[lineKey(gpuIndex)] = points.map((p) => ({ x: p.seconds, y: p.value }));
       }
       return result;
     }, [groupedData]);
 
+    const hasMeanLine = groupedData.has(MEAN_INDEX);
+    const keyRow = hasMeanLine ? (
+      <div
+        className="mt-1 flex flex-wrap items-center gap-x-4 gap-y-1 text-xs text-muted-foreground"
+        data-testid="gpu-metrics-chart-keys"
+      >
+        <span className="inline-flex items-center gap-1.5">
+          <span
+            aria-hidden
+            className="inline-block h-0.5 w-4 rounded"
+            style={{ background: MEAN_COLOR }}
+          />
+          {t.meanChips}
+        </span>
+      </div>
+    ) : null;
+    const resolvedCaption =
+      caption || keyRow ? (
+        <>
+          {caption}
+          {keyRow}
+        </>
+      ) : undefined;
+
     // Scale domains
     const xDomain = useMemo(() => {
       if (allPoints.length === 0) return [0, 100] as [number, number];
@@ -247,8 +317,8 @@ const GpuMetricsChart = React.memo(
             key: 'gpu-lines',
             lines: lineData,
             config: {
-              getColor: (key) => GPU_COLORS[parseInt(key, 10) % GPU_COLORS.length],
-              strokeWidth: rolling ? 1.75 : 1.5,
+              getColor: (key) => (key === MEAN_KEY ? MEAN_COLOR : colorFor(parseInt(key, 10))),
+              getStrokeWidth: (key) => (key === MEAN_KEY ? 2.5 : rolling ? 1.75 : 1.5),
               curve: d3.curveMonotoneX,
             },
           },
@@ -264,8 +334,7 @@ const GpuMetricsChart = React.memo(
               getY: (d) => d.value,
               // Averaged mode draws lines only; the circles stay as invisible
               // hover targets so the tooltip and crosshair keep working.
-              getColor: (d) =>
-                rolling ? 'transparent' : GPU_COLORS[d.gpuIndex % GPU_COLORS.length],
+              getColor: (d) => (rolling ? 'transparent' : colorFor(d.gpuIndex)),
               getRadius: () => (rolling ? 3 : 2),
               maxPoints,
             },
@@ -280,11 +349,15 @@ const GpuMetricsChart = React.memo(
         tooltip={{
           rulerType: 'crosshair',
           content: (d: ParsedPoint, isPinned: boolean) => {
-            const color = GPU_COLORS[d.gpuIndex % GPU_COLORS.length];
+            const color = colorFor(d.gpuIndex);
             const sep = locale === 'zh' ? '：' : ':';
+            const title =
+              d.gpuIndex === MEAN_INDEX
+                ? `${t.meanChips}${d.count ? ` · ${t.meanCount(d.count)}` : ''}`
+                : `${t.chip} ${d.gpuIndex}`;
             return `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md backdrop-blur-sm" style="min-width: 160px; user-select: ${isPinned ? 'text' : 'none'}">
               ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
-              <div class="font-semibold mb-1" style="color: ${color}">${t.chip} ${d.gpuIndex}</div>
+              <div class="font-semibold mb-1" style="color: ${color}">${title}</div>
               <div class="text-muted-foreground">${d.seconds.toFixed(1)}${locale === 'zh' ? ' 秒' : 's'}</div>
               <div class="mt-1 font-medium">${getGpuMetricLabel(metricConfig, locale)}${sep} ${d.value.toFixed(1)} ${metricConfig.unit}</div>
               ${rolling ? `<div class="text-muted-foreground">${t.rollingSuffix(display.windowS)}</div>` : ''}
@@ -302,20 +375,20 @@ const GpuMetricsChart = React.memo(
           onHoverStart: (sel, d) => {
             sel
               .attr('r', 5)
-              .attr('fill', GPU_COLORS[d.gpuIndex % GPU_COLORS.length])
+              .attr('fill', colorFor(d.gpuIndex))
               .attr('stroke', 'white')
               .attr('stroke-width', 1);
           },
           onHoverEnd: (sel, d) => {
             sel
               .attr('r', rolling ? 3 : 2)
-              .attr('fill', rolling ? 'transparent' : GPU_COLORS[d.gpuIndex % GPU_COLORS.length])
+              .attr('fill', rolling ? 'transparent' : colorFor(d.gpuIndex))
               .attr('stroke', 'none');
           },
           attachToLayer: 2,
         }}
         legendElement={legendElement}
-        caption={caption}
+        caption={resolvedCaption}
       />
     );
   },
diff --git a/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx b/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
index 82fedd75b..816de67e3 100644
--- a/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
+++ b/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
@@ -17,6 +17,7 @@ import {
   type SmoothingWindowS,
   type TelemetryDisplayMode,
   type TelemetryDisplayState,
+  type TelemetrySeriesMode,
 } from './telemetry-smoothing';
 
 const STRINGS = {
@@ -26,6 +27,10 @@ const STRINGS = {
     rolling: 'Rolling average',
     window: 'Window',
     windowOption: (s: number) => `${s} s`,
+    series: 'Lines',
+    chips: 'Per chip',
+    mean: 'Mean of chips',
+    both: 'Both',
   },
   zh: {
     display: '显示方式',
@@ -33,6 +38,10 @@ const STRINGS = {
     rolling: '滚动平均',
     window: '窗口',
     windowOption: (s: number) => `${s} 秒`,
+    series: '曲线',
+    chips: '单芯片',
+    mean: '芯片均值',
+    both: '两者',
   },
 } as const;
 
@@ -48,7 +57,8 @@ interface Props {
 
 /**
  * Display-mode controls shared by the PowerX explorer and the per-point PowerX
- * tab: raw samples vs. a time-window rolling average.
+ * tab: raw samples vs. a time-window rolling average, and per-chip lines vs.
+ * the mean across the visible chips.
  */
 export function TelemetryDisplayControls({
   value,
@@ -64,6 +74,11 @@ export function TelemetryDisplayControls({
     { value: 'points', label: t.points, testId: `${idPrefix}-mode-points` },
     { value: 'rolling', label: t.rolling, testId: `${idPrefix}-mode-rolling` },
   ];
+  const seriesOptions: SegmentedToggleOption<TelemetrySeriesMode>[] = [
+    { value: 'chips', label: t.chips, testId: `${idPrefix}-series-chips` },
+    { value: 'mean', label: t.mean, testId: `${idPrefix}-series-mean` },
+    { value: 'both', label: t.both, testId: `${idPrefix}-series-both` },
+  ];
 
   return (
     <div className={className} data-testid={`${idPrefix}-controls`}>
@@ -105,6 +120,19 @@ export function TelemetryDisplayControls({
             </Select>
           </div>
         )}
+        <div className="space-y-1">
+          <Label id={`${idPrefix}-series-label`}>{t.series}</Label>
+          <SegmentedToggle
+            value={value.series}
+            options={seriesOptions}
+            role="group"
+            ariaLabel={t.series}
+            onValueChange={(series) => {
+              track(`${analyticsPrefix}_series_mode_changed`, { series });
+              onChange({ ...value, series });
+            }}
+          />
+        </div>
       </div>
     </div>
   );
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
index f33793617..a9d41298e 100644
--- a/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'vitest';
 
-import { rollingTimeAverage, type TimedSample } from './telemetry-smoothing';
+import {
+  estimateSampleIntervalMs,
+  meanAcrossSeries,
+  rollingTimeAverage,
+  type TimedSample,
+} from './telemetry-smoothing';
 
 const T0 = Date.parse('2026-09-15T21:36:14.107Z');
 
@@ -68,3 +73,90 @@ describe('rollingTimeAverage', () => {
     expect(ramp.at(-1)!).toBeGreaterThan(ramp[0]!);
   });
 });
+
+describe('estimateSampleIntervalMs', () => {
+  it('falls back when there are fewer than two distinct timestamps', () => {
+    expect(estimateSampleIntervalMs([], 1000)).toBe(1000);
+    expect(estimateSampleIntervalMs([{ ms: T0, value: 1 }], 750)).toBe(750);
+    expect(
+      estimateSampleIntervalMs(
+        [
+          { ms: T0, value: 1 },
+          { ms: T0, value: 2 },
+        ],
+        250,
+      ),
+    ).toBe(250);
+  });
+
+  it('returns the median gap so a single dropped sample does not skew it', () => {
+    const samples = [
+      { ms: T0, value: 0 },
+      { ms: T0 + 1000, value: 0 },
+      { ms: T0 + 2000, value: 0 },
+      { ms: T0 + 5000, value: 0 }, // dropped two rows
+      { ms: T0 + 6000, value: 0 },
+    ];
+    expect(estimateSampleIntervalMs(samples)).toBe(1000);
+  });
+});
+
+describe('meanAcrossSeries', () => {
+  it('returns an empty array when there are no series or only empty series', () => {
+    expect(meanAcrossSeries([], 1000)).toEqual([]);
+    expect(meanAcrossSeries([[], []], 1000)).toEqual([]);
+  });
+
+  it('returns a single series as its own mean with count 1', () => {
+    const only = everySecond([10, 20]);
+    expect(meanAcrossSeries([only], 1000)).toEqual([
+      { ms: only[0]!.ms, value: 10, count: 1 },
+      { ms: only[1]!.ms, value: 20, count: 1 },
+    ]);
+  });
+
+  it('aligns chips polled a few ms apart onto the reference timeline', () => {
+    // nvidia-smi writes chip rows ~12 ms apart within one 1 s poll.
+    const chip0 = everySecond([200, 400, 600]);
+    const chip1 = everySecond([300, 500, 700], 12);
+    const chip2 = everySecond([100, 300, 500], 25);
+    const out = meanAcrossSeries([chip0, chip1, chip2], 1000);
+    expect(out.map((p) => p.ms)).toEqual(chip0.map((p) => p.ms));
+    expect(out.map((p) => p.value)).toEqual([200, 400, 600]);
+    expect(out.every((p) => p.count === 3)).toBe(true);
+  });
+
+  it('uses the longest series as the reference and skips chips with no sample in tolerance', () => {
+    const chip0 = everySecond([100, 100]); // shorter: stops early
+    const chip1 = everySecond([300, 300, 300, 300]);
+    const out = meanAcrossSeries([chip0, chip1], 500);
+    expect(out).toHaveLength(4);
+    expect(out[0]).toEqual({ ms: chip1[0]!.ms, value: 200, count: 2 });
+    expect(out[1]).toEqual({ ms: chip1[1]!.ms, value: 200, count: 2 });
+    // chip0 has nothing within 500 ms of t=2 s and t=3 s.
+    expect(out[2]).toEqual({ ms: chip1[2]!.ms, value: 300, count: 1 });
+    expect(out[3]).toEqual({ ms: chip1[3]!.ms, value: 300, count: 1 });
+  });
+
+  it('picks the nearest sample when a chip dropped a row', () => {
+    const chip0 = everySecond([0, 0, 0, 0]);
+    const chip1: TimedSample[] = [
+      { ms: T0, value: 10 },
+      // row at T0 + 1000 dropped
+      { ms: T0 + 2000, value: 30 },
+      { ms: T0 + 3000, value: 40 },
+    ];
+    const out = meanAcrossSeries([chip0, chip1], 400);
+    expect(out.map((p) => p.count)).toEqual([2, 1, 2, 2]);
+    expect(out.map((p) => p.value)).toEqual([5, 0, 15, 20]);
+  });
+
+  it('treats a negative tolerance as exact-match only', () => {
+    const chip0 = everySecond([0, 0]);
+    const chip1 = everySecond([10, 10], 1);
+    expect(meanAcrossSeries([chip0, chip1], -1).every((p) => p.count === 1)).toBe(true);
+    expect(meanAcrossSeries([chip0, everySecond([10, 10])], -1).every((p) => p.count === 2)).toBe(
+      true,
+    );
+  });
+});
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
index c4ee00e82..8c44c28ca 100644
--- a/packages/app/src/components/gpu-power/telemetry-smoothing.ts
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
@@ -14,16 +14,25 @@ export interface TimedSample {
 export const SMOOTHING_WINDOWS_S = [10, 30, 60, 300] as const;
 export type SmoothingWindowS = (typeof SMOOTHING_WINDOWS_S)[number];
 
+export interface AggregatedSample extends TimedSample {
+  /** Number of chips that contributed a sample within tolerance. */
+  count: number;
+}
+
 export type TelemetryDisplayMode = 'points' | 'rolling';
+/** Per-chip lines, one mean line across the visible chips, or both. */
+export type TelemetrySeriesMode = 'chips' | 'mean' | 'both';
 
 export interface TelemetryDisplayState {
   mode: TelemetryDisplayMode;
   windowS: SmoothingWindowS;
+  series: TelemetrySeriesMode;
 }
 
 export const DEFAULT_TELEMETRY_DISPLAY: TelemetryDisplayState = {
   mode: 'points',
   windowS: 30,
+  series: 'chips',
 };
 
 /**
@@ -59,3 +68,66 @@ export function rollingTimeAverage(
   }
   return out;
 }
+
+/**
+ * Median gap between consecutive samples, in ms. Used as the alignment
+ * tolerance when averaging chips that were polled a few ms apart. Falls back
+ * to `fallbackMs` when fewer than two distinct timestamps exist.
+ */
+export function estimateSampleIntervalMs(
+  samples: readonly TimedSample[],
+  fallbackMs = 1000,
+): number {
+  const gaps: number[] = [];
+  for (let i = 1; i < samples.length; i += 1) {
+    const gap = samples[i]!.ms - samples[i - 1]!.ms;
+    if (gap > 0) gaps.push(gap);
+  }
+  if (gaps.length === 0) return fallbackMs;
+  gaps.sort((a, b) => a - b);
+  return gaps[Math.floor(gaps.length / 2)]!;
+}
+
+/**
+ * Mean across several chips at each timestamp of the reference chip (the one
+ * with the most samples, first on ties). For every reference sample each other
+ * chip contributes its nearest sample if that sample lies within
+ * `toleranceMs`; chips with no sample that close are left out of that mean
+ * rather than interpolated, and `count` records how many contributed.
+ *
+ * Every inner array must be sorted by `ms` ascending.
+ */
+export function meanAcrossSeries(
+  series: readonly (readonly TimedSample[])[],
+  toleranceMs: number,
+): AggregatedSample[] {
+  const populated = series.filter((s) => s.length > 0);
+  if (populated.length === 0) return [];
+  let reference = populated[0]!;
+  for (const s of populated) if (s.length > reference.length) reference = s;
+  const others = populated.filter((s) => s !== reference);
+  const cursors: number[] = Array.from({ length: others.length }, () => 0);
+  const tolerance = Math.max(0, toleranceMs);
+
+  return reference.map((ref) => {
+    let sum = ref.value;
+    let count = 1;
+    for (let k = 0; k < others.length; k += 1) {
+      const other = others[k]!;
+      let cursor = cursors[k]!;
+      while (
+        cursor + 1 < other.length &&
+        Math.abs(other[cursor + 1]!.ms - ref.ms) <= Math.abs(other[cursor]!.ms - ref.ms)
+      ) {
+        cursor += 1;
+      }
+      cursors[k] = cursor;
+      const candidate = other[cursor]!;
+      if (Math.abs(candidate.ms - ref.ms) <= tolerance) {
+        sum += candidate.value;
+        count += 1;
+      }
+    }
+    return { ms: ref.ms, value: sum / count, count };
+  });
+}
diff --git a/packages/app/src/lib/d3-chart/layers/lines.test.ts b/packages/app/src/lib/d3-chart/layers/lines.test.ts
index 894e9d5f3..81b3a16dc 100644
--- a/packages/app/src/lib/d3-chart/layers/lines.test.ts
+++ b/packages/app/src/lib/d3-chart/layers/lines.test.ts
@@ -130,6 +130,29 @@ describe('renderLines', () => {
     }
   });
 
+  it('uses getStrokeWidth per series and falls back to strokeWidth otherwise', () => {
+    const group = createMockGroup();
+    const { xScale, yScale } = makeScales();
+    renderLines(
+      group as any,
+      SAMPLE_LINES,
+      xScale,
+      yScale,
+      makeConfig({
+        strokeWidth: 1.5,
+        getStrokeWidth: (key) => (key === 'seriesB' ? 3 : (undefined as unknown as number)),
+      }),
+    );
+
+    const widthByClass = Object.fromEntries(
+      group
+        .selectAll('.line-path')
+        .elements.map((el) => [el.attrs['class'], el.attrs['stroke-width']]),
+    );
+    expect(widthByClass['line-path line-seriesA']).toBe(1.5);
+    expect(widthByClass['line-path line-seriesB']).toBe(3);
+  });
+
   it('generates valid d attribute from line generator', () => {
     const group = createMockGroup();
     const { xScale, yScale } = makeScales();
diff --git a/packages/app/src/lib/d3-chart/layers/lines.ts b/packages/app/src/lib/d3-chart/layers/lines.ts
index 075a1be71..885e0630d 100644
--- a/packages/app/src/lib/d3-chart/layers/lines.ts
+++ b/packages/app/src/lib/d3-chart/layers/lines.ts
@@ -9,6 +9,8 @@ export interface LineConfig {
   /** Optional per-series SVG dash pattern; return `none` for a solid line. */
   getStrokeDasharray?: (key: string) => string;
   strokeWidth?: number;
+  /** Optional per-series stroke width; falls back to `strokeWidth`, then 2. */
+  getStrokeWidth?: (key: string) => number;
   curve?: d3.CurveFactory;
   /** Return false to create gaps in the line (e.g., missing data points). */
   isDefined?: (d: { x: number; y: number }) => boolean;
@@ -61,7 +63,7 @@ export function renderLines(
     .attr('class', (d) => `line-path line-${d.key}`)
     .attr('stroke', (d) => config.getColor(d.key))
     .attr('stroke-dasharray', (d) => config.getStrokeDasharray?.(d.key) ?? null)
-    .attr('stroke-width', config.strokeWidth ?? 2)
+    .attr('stroke-width', (d) => config.getStrokeWidth?.(d.key) ?? config.strokeWidth ?? 2)
     .attr('d', (d) => lineGenerator(d.points));
 }
 

From 1c234e3d7205d8a2521d1835fce5e793d8bbacc8 Mon Sep 17 00:00:00 2001
From: Cam Quilici <cjquilici@gmail.com>
Date: Thu, 17 Sep 2026 14:04:40 -0500
Subject: [PATCH 004/103] feat(powerx): overlay decode throughput on the
 per-point telemetry chart

Add an "Overlay decode throughput" switch (default off) to the per-point
PowerX tab. When on, the point's decodeTps series from the trace server
metrics is drawn over the telemetry in violet on its own right-hand axis,
with a key-row entry and a row in every tooltip giving the nearest decode
rate. The trace's startNs is an epoch-ns wall-clock timestamp, so the two
series are aligned by absolute time; when a trace carries no wall-clock
start the overlay falls back to the telemetry start and the note under the
switch says so. Points without server metrics get an "unavailable" note
instead of an empty overlay.

The chart takes the overlay as an optional prop and renders it in a custom
D3 layer that redraws on zoom and removes its own axis when toggled off. In
rolling-average mode the overlay is smoothed with the same time window as
the chip lines so both curves describe the same interval.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../components/gpu-power/GpuPowerChart.tsx    | 180 ++++++++++++++++--
 .../gpu-power/telemetry-smoothing.test.ts     |  41 ++++
 .../gpu-power/telemetry-smoothing.ts          |  26 +++
 .../agentic-point/power-telemetry-view.tsx    |  79 +++++++-
 4 files changed, 309 insertions(+), 17 deletions(-)

diff --git a/packages/app/src/components/gpu-power/GpuPowerChart.tsx b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
index 17a9f4790..bcfe74e72 100644
--- a/packages/app/src/components/gpu-power/GpuPowerChart.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
@@ -4,13 +4,17 @@ import * as d3 from 'd3';
 import React, { useMemo } from 'react';
 
 import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import type { RenderContext } from '@/lib/d3-chart/D3Chart/types';
+import { CHART_TYPE, px } from '@/lib/d3-chart/typography';
 import { useLocale } from '@/lib/use-locale';
 import {
   DEFAULT_TELEMETRY_DISPLAY,
   estimateSampleIntervalMs,
   meanAcrossSeries,
+  nearestSample,
   rollingTimeAverage,
   type TelemetryDisplayState,
+  type TimedSample,
 } from './telemetry-smoothing';
 import {
   type GpuMetricKey,
@@ -35,6 +39,7 @@ const STRINGS = {
     rollingSuffix: (windowS: number) => `${windowS} s rolling avg`,
     meanChips: 'Mean of visible chips',
     meanCount: (n: number) => `${n} chips`,
+    rightAxis: 'right axis',
   },
   zh: {
     empty: '暂无可显示的芯片指标数据。',
@@ -48,9 +53,20 @@ const STRINGS = {
     rollingSuffix: (windowS: number) => `${windowS} 秒滚动平均`,
     meanChips: '可见芯片均值',
     meanCount: (n: number) => `${n} 个芯片`,
+    rightAxis: '右轴',
   },
 } as const;
 
+/** A second time series drawn over the telemetry on its own right-hand axis. */
+export interface TelemetryOverlaySeries {
+  key: string;
+  label: string;
+  unit: string;
+  color: string;
+  /** Absolute-time samples; the chart re-bases them onto its own t=0. */
+  points: TimedSample[];
+}
+
 interface ParsedPoint {
   seconds: number;
   /** Absolute sample time in ms; smoothing and alignment work in this space. */
@@ -74,6 +90,8 @@ interface GpuMetricsChartProps {
   maxPoints?: number;
   /** Raw samples vs. time-window rolling average. Defaults to raw samples. */
   display?: TelemetryDisplayState;
+  /** Optional secondary series (e.g. decode throughput) on a right y-axis. */
+  overlay?: TelemetryOverlaySeries | null;
 }
 
 function parseTimestamp(raw: string): Date | null {
@@ -158,6 +176,80 @@ function colorFor(gpuIndex: number): string {
 }
 const CHART_ID = 'gpu-metrics-line';
 const MARGIN = { top: 24, right: 20, bottom: 60, left: 60 };
+/** Room for the overlay's right axis ticks and rotated title. */
+const MARGIN_WITH_OVERLAY = { ...MARGIN, right: 84 };
+
+interface OverlayPoint {
+  x: number;
+  y: number;
+}
+
+function overlayYScale(points: OverlayPoint[], height: number): d3.ScaleLinear<number, number> {
+  const max = d3.max(points, (p) => p.y) ?? 0;
+  return d3
+    .scaleLinear()
+    .domain([0, max > 0 ? max * 1.05 : 1])
+    .range([height, 0])
+    .nice();
+}
+
+function overlayLine(
+  xScale: d3.ScaleLinear<number, number>,
+  yScale: d3.ScaleLinear<number, number>,
+): d3.Line<OverlayPoint> {
+  return d3
+    .line<OverlayPoint>()
+    .x((p) => xScale(p.x))
+    .y((p) => yScale(p.y))
+    .curve(d3.curveMonotoneX);
+}
+
+/**
+ * Draw the overlay path inside the clipped zoom group and its axis in the
+ * unclipped root group. Both are removed first so toggling the overlay off
+ * (or re-rendering) never leaves a stale axis behind.
+ */
+function renderOverlay(
+  group: d3.Selection<SVGGElement, unknown, null, undefined>,
+  ctx: RenderContext,
+  overlay: TelemetryOverlaySeries | null | undefined,
+  points: OverlayPoint[],
+): void {
+  group.selectAll('.telemetry-overlay').remove();
+  ctx.layout.g.selectAll('.telemetry-overlay-axis').remove();
+  if (!overlay || points.length === 0) return;
+  const xScale = ctx.xScale as d3.ScaleLinear<number, number>;
+  const yScale = overlayYScale(points, ctx.height);
+  group
+    .append('path')
+    .attr('class', 'telemetry-overlay')
+    .attr('fill', 'none')
+    .attr('stroke', overlay.color)
+    .attr('stroke-width', 1.75)
+    .attr('opacity', 0.9)
+    .attr('pointer-events', 'none')
+    .attr('d', overlayLine(xScale, yScale)(points));
+
+  const axis = ctx.layout.g
+    .append('g')
+    .attr('class', 'telemetry-overlay-axis')
+    .attr('transform', `translate(${ctx.width},0)`)
+    .call(d3.axisRight(yScale).ticks(6).tickSize(4).tickFormat(d3.format('~s')));
+  axis.select('.domain').attr('stroke', overlay.color);
+  axis.selectAll('.tick line').attr('stroke', overlay.color);
+  axis
+    .selectAll('.tick text')
+    .attr('fill', overlay.color)
+    .attr('font-size', px(CHART_TYPE.axisLabel));
+  axis
+    .append('text')
+    .attr('class', 'telemetry-overlay-axis-label')
+    .attr('transform', `translate(${ctx.layout.margin.right - 14},${ctx.height / 2}) rotate(90)`)
+    .attr('text-anchor', 'middle')
+    .attr('fill', overlay.color)
+    .attr('font-size', px(CHART_TYPE.axisLabel))
+    .text(`${overlay.label} (${overlay.unit})`);
+}
 
 const GpuMetricsChart = React.memo(
   ({
@@ -169,6 +261,7 @@ const GpuMetricsChart = React.memo(
     caption,
     maxPoints,
     display = DEFAULT_TELEMETRY_DISPLAY,
+    overlay,
   }: GpuMetricsChartProps) => {
     const locale = useLocale();
     const t = STRINGS[locale];
@@ -214,22 +307,51 @@ const GpuMetricsChart = React.memo(
       return result;
     }, [groupedData]);
 
+    // Overlay samples, smoothed with the same window as the chip lines when
+    // averaging so both series answer the same "how much over N seconds"
+    // question, then re-based onto the telemetry's t=0.
+    const overlaySamples = useMemo<TimedSample[]>(() => {
+      if (!overlay) return [];
+      return rolling ? rollingTimeAverage(overlay.points, display.windowS * 1000) : overlay.points;
+    }, [overlay, rolling, display.windowS]);
+    const overlayPoints = useMemo<OverlayPoint[]>(
+      () => overlaySamples.map((p) => ({ x: (p.ms - t0Ms) / 1000, y: p.value })),
+      [overlaySamples, t0Ms],
+    );
+    const hasOverlay = Boolean(overlay) && overlayPoints.length > 0;
+
     const hasMeanLine = groupedData.has(MEAN_INDEX);
-    const keyRow = hasMeanLine ? (
-      <div
-        className="mt-1 flex flex-wrap items-center gap-x-4 gap-y-1 text-xs text-muted-foreground"
-        data-testid="gpu-metrics-chart-keys"
-      >
-        <span className="inline-flex items-center gap-1.5">
-          <span
-            aria-hidden
-            className="inline-block h-0.5 w-4 rounded"
-            style={{ background: MEAN_COLOR }}
-          />
-          {t.meanChips}
-        </span>
-      </div>
-    ) : null;
+    const keyRow =
+      hasMeanLine || hasOverlay ? (
+        <div
+          className="mt-1 flex flex-wrap items-center gap-x-4 gap-y-1 text-xs text-muted-foreground"
+          data-testid="gpu-metrics-chart-keys"
+        >
+          {hasMeanLine && (
+            <span className="inline-flex items-center gap-1.5">
+              <span
+                aria-hidden
+                className="inline-block h-0.5 w-4 rounded"
+                style={{ background: MEAN_COLOR }}
+              />
+              {t.meanChips}
+            </span>
+          )}
+          {hasOverlay && overlay && (
+            <span
+              className="inline-flex items-center gap-1.5"
+              data-testid="gpu-metrics-overlay-key"
+            >
+              <span
+                aria-hidden
+                className="inline-block h-0.5 w-4 rounded"
+                style={{ background: overlay.color }}
+              />
+              {overlay.label} ({overlay.unit} · {t.rightAxis})
+            </span>
+          )}
+        </div>
+      ) : null;
     const resolvedCaption =
       caption || keyRow ? (
         <>
@@ -270,7 +392,7 @@ const GpuMetricsChart = React.memo(
         chartId={CHART_ID}
         data={allPoints}
         height={600}
-        margin={MARGIN}
+        margin={hasOverlay ? MARGIN_WITH_OVERLAY : MARGIN}
         watermark="logo"
         testId="gpu-metrics-chart-svg"
         grabCursor={true}
@@ -339,6 +461,24 @@ const GpuMetricsChart = React.memo(
               maxPoints,
             },
           },
+          // Secondary series on a right-hand axis (e.g. decode throughput)
+          {
+            type: 'custom',
+            key: 'telemetry-overlay',
+            render: (group, ctx) => {
+              renderOverlay(group, ctx, hasOverlay ? overlay : null, overlayPoints);
+            },
+            onZoom: (group, ctx) => {
+              if (!hasOverlay) return;
+              const xScale = ctx.newXScale as d3.ScaleLinear<number, number>;
+              group
+                .select<SVGPathElement>('.telemetry-overlay')
+                .attr(
+                  'd',
+                  overlayLine(xScale, overlayYScale(overlayPoints, ctx.height))(overlayPoints),
+                );
+            },
+          },
         ]}
         zoom={{
           enabled: true,
@@ -355,6 +495,13 @@ const GpuMetricsChart = React.memo(
               d.gpuIndex === MEAN_INDEX
                 ? `${t.meanChips}${d.count ? ` · ${t.meanCount(d.count)}` : ''}`
                 : `${t.chip} ${d.gpuIndex}`;
+            const overlayAt = hasOverlay ? nearestSample(overlaySamples, d.ms) : null;
+            const overlayRow =
+              overlay && overlayAt
+                ? `<div class="mt-1" style="color: ${overlay.color}">${overlay.label}${sep} ${
+                    overlayAt.value >= 100 ? overlayAt.value.toFixed(0) : overlayAt.value.toFixed(1)
+                  } ${overlay.unit}</div>`
+                : '';
             return `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md backdrop-blur-sm" style="min-width: 160px; user-select: ${isPinned ? 'text' : 'none'}">
               ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
               <div class="font-semibold mb-1" style="color: ${color}">${title}</div>
@@ -368,6 +515,7 @@ const GpuMetricsChart = React.memo(
               <div class="text-muted-foreground">${t.utilization}${sep} ${d.raw.gpuUtil}%</div>`
                   : ''
               }
+              ${overlayRow}
             </div>`;
           },
           getRulerX: (d, xScale) => (xScale as d3.ScaleLinear<number, number>)(d.seconds),
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
index a9d41298e..8865fc7fc 100644
--- a/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
@@ -3,7 +3,9 @@ import { describe, expect, it } from 'vitest';
 import {
   estimateSampleIntervalMs,
   meanAcrossSeries,
+  nearestSample,
   rollingTimeAverage,
+  toAbsoluteMs,
   type TimedSample,
 } from './telemetry-smoothing';
 
@@ -160,3 +162,42 @@ describe('meanAcrossSeries', () => {
     );
   });
 });
+
+describe('toAbsoluteMs', () => {
+  it('offsets relative seconds from the given origin', () => {
+    // Trace startNs from a real point, as the API returns it.
+    const originMs = 1789508185611923200 / 1e6;
+    expect(
+      toAbsoluteMs(
+        [
+          { t: 0, value: 0 },
+          { t: 1.5, value: 42 },
+        ],
+        originMs,
+      ),
+    ).toEqual([
+      { ms: originMs, value: 0 },
+      { ms: originMs + 1500, value: 42 },
+    ]);
+    expect(toAbsoluteMs([], originMs)).toEqual([]);
+  });
+});
+
+describe('nearestSample', () => {
+  const samples = everySecond([1, 2, 3, 4]);
+
+  it('returns null for an empty series', () => {
+    expect(nearestSample([], T0)).toBeNull();
+  });
+
+  it('returns the closest sample, clamping outside the series range', () => {
+    expect(nearestSample(samples, T0 - 5000)).toEqual(samples[0]);
+    expect(nearestSample(samples, T0 + 99_000)).toEqual(samples[3]);
+    expect(nearestSample(samples, T0 + 1400)).toEqual(samples[1]);
+    expect(nearestSample(samples, T0 + 1600)).toEqual(samples[2]);
+  });
+
+  it('prefers the earlier sample on an exact tie', () => {
+    expect(nearestSample(samples, T0 + 1500)).toEqual(samples[1]);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
index 8c44c28ca..91efcd64f 100644
--- a/packages/app/src/components/gpu-power/telemetry-smoothing.ts
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
@@ -131,3 +131,29 @@ export function meanAcrossSeries(
     return { ms: ref.ms, value: sum / count, count };
   });
 }
+
+/**
+ * Convert a relative-seconds series (`t` from its own start) to absolute
+ * milliseconds so it can share an x-axis with wall-clock telemetry.
+ */
+export function toAbsoluteMs(
+  points: readonly { t: number; value: number }[],
+  originMs: number,
+): TimedSample[] {
+  return points.map((p) => ({ ms: originMs + p.t * 1000, value: p.value }));
+}
+
+/** Sample nearest to `ms` (earlier one on a tie), or null when the series is empty. */
+export function nearestSample(samples: readonly TimedSample[], ms: number): TimedSample | null {
+  if (samples.length === 0) return null;
+  let lo = 0;
+  let hi = samples.length - 1;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (samples[mid]!.ms < ms) lo = mid + 1;
+    else hi = mid;
+  }
+  const after = samples[lo]!;
+  const before = lo > 0 ? samples[lo - 1]! : after;
+  return Math.abs(before.ms - ms) <= Math.abs(after.ms - ms) ? before : after;
+}
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
index f50c7d568..177b016d0 100644
--- a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -2,11 +2,15 @@
 
 import { useMemo, useState } from 'react';
 
-import GpuMetricsChart, { GPU_COLORS } from '@/components/gpu-power/GpuPowerChart';
+import GpuMetricsChart, {
+  GPU_COLORS,
+  type TelemetryOverlaySeries,
+} from '@/components/gpu-power/GpuPowerChart';
 import GpuStatsTable from '@/components/gpu-power/GpuStatsTable';
 import { TelemetryDisplayControls } from '@/components/gpu-power/TelemetryDisplayControls';
 import {
   DEFAULT_TELEMETRY_DISPLAY,
+  toAbsoluteMs,
   type TelemetryDisplayState,
 } from '@/components/gpu-power/telemetry-smoothing';
 import {
@@ -20,6 +24,7 @@ import { Card } from '@/components/ui/card';
 import ChartLegend from '@/components/ui/chart-legend';
 import { Label } from '@/components/ui/label';
 import { RetryableQueryError } from '@/components/ui/retryable-query-error';
+import { Switch } from '@/components/ui/switch';
 import {
   Select,
   SelectContent,
@@ -28,6 +33,7 @@ import {
   SelectValue,
 } from '@/components/ui/select';
 import { useGpuMetricsPoint, type GpuMetricSeries } from '@/hooks/api/use-gpu-metrics-point';
+import { useTraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
 import { track } from '@/lib/analytics';
 import { useLocale } from '@/lib/use-locale';
 
@@ -50,6 +56,14 @@ const STRINGS = {
     chip: 'Chip',
     secondsUnit: 's',
     resetFilter: 'Show all chips',
+    overlayToggle: 'Overlay decode throughput',
+    decodeTps: 'Decode throughput',
+    overlayLoading: 'Loading server metrics…',
+    overlayError: 'Server metrics failed to load; the overlay is unavailable.',
+    overlayUnavailable: 'This point has no decode-throughput server metrics to overlay.',
+    overlayAligned: 'Decode throughput is aligned to the telemetry by wall-clock timestamps.',
+    overlayRelative:
+      'The trace has no wall-clock timestamps, so decode throughput starts at the telemetry start (both at t=0).',
   },
   zh: {
     loading: '正在加载 PowerX 遥测数据……',
@@ -69,10 +83,19 @@ const STRINGS = {
     chip: '芯片',
     secondsUnit: '秒',
     resetFilter: '显示全部芯片',
+    overlayToggle: '叠加 decode 吞吐量',
+    decodeTps: 'Decode 吞吐量',
+    overlayLoading: '正在加载服务端指标……',
+    overlayError: '服务端指标加载失败，无法叠加显示。',
+    overlayUnavailable: '该数据点没有可叠加的 decode 吞吐量服务端指标。',
+    overlayAligned: 'Decode 吞吐量已按绝对时间戳与遥测数据对齐。',
+    overlayRelative: 'trace 缺少绝对时间戳，因此 decode 吞吐量与遥测数据均从各自的 t=0 开始对齐。',
   },
 } as const;
 
 const VENDOR_LABEL: Record<string, string> = { nvidia: 'nvidia-smi', amd: 'amd-smi' };
+/** Violet: outside the Tableau10 chip palette and the foreground mean line. */
+const OVERLAY_COLOR = '#8b5cf6';
 
 interface Props {
   id: number;
@@ -143,6 +166,35 @@ export function PowerTelemetryView({ id, enabled }: Props) {
   const [isLegendExpanded, setIsLegendExpanded] = useState(true);
   const [display, setDisplay] = useState<TelemetryDisplayState>(DEFAULT_TELEMETRY_DISPLAY);
 
+  // Decode-throughput overlay: fetched only once the switch is on.
+  const [overlayEnabled, setOverlayEnabled] = useState(false);
+  const metricsQuery = useTraceServerMetrics(id, enabled && overlayEnabled);
+  const serverMetrics = metricsQuery.data;
+  const decodeTps = serverMetrics?.decodeTps ?? [];
+  // Trace timeslices carry epoch-ns starts, so both series can share wall-clock
+  // time. A zero startNs means the trace only has relative time.
+  const overlayAbsolute = Boolean(serverMetrics && serverMetrics.startNs > 0);
+  const overlay = useMemo<TelemetryOverlaySeries | null>(() => {
+    if (!overlayEnabled || !serverMetrics || !selectedSeries || decodeTps.length === 0) return null;
+    const originMs = overlayAbsolute
+      ? serverMetrics.startNs / 1e6
+      : new Date(selectedSeries.startedAt).getTime();
+    return {
+      key: 'decodeTps',
+      label: t.decodeTps,
+      unit: 'tok/s',
+      color: OVERLAY_COLOR,
+      points: toAbsoluteMs(decodeTps, originMs),
+    };
+  }, [overlayEnabled, serverMetrics, selectedSeries, decodeTps, overlayAbsolute, t.decodeTps]);
+  const overlayNote = ((): string | null => {
+    if (!overlayEnabled) return null;
+    if (metricsQuery.isLoading) return t.overlayLoading;
+    if (metricsQuery.isError) return t.overlayError;
+    if (!overlay) return t.overlayUnavailable;
+    return overlayAbsolute ? t.overlayAligned : t.overlayRelative;
+  })();
+
   if (!enabled) return null;
 
   if (query.isLoading) {
@@ -276,6 +328,30 @@ export function PowerTelemetryView({ id, enabled }: Props) {
           idPrefix="power-telemetry-display"
           className="mt-3 border-t border-border/60 pt-3"
         />
+        <div className="mt-3 flex flex-wrap items-center gap-x-3 gap-y-1">
+          <div className="flex items-center gap-2">
+            <Switch
+              id="power-telemetry-overlay"
+              data-testid="power-telemetry-overlay-switch"
+              checked={overlayEnabled}
+              onCheckedChange={(checked) => {
+                track('inference_agentic_power_overlay_toggled', { id, enabled: checked });
+                setOverlayEnabled(checked);
+              }}
+            />
+            <Label htmlFor="power-telemetry-overlay" className="cursor-pointer">
+              {t.overlayToggle}
+            </Label>
+          </div>
+          {overlayNote && (
+            <span
+              className="text-xs text-muted-foreground"
+              data-testid="power-telemetry-overlay-note"
+            >
+              {overlayNote}
+            </span>
+          )}
+        </div>
       </Card>
 
       <Card className="relative" data-testid="power-telemetry-chart">
@@ -286,6 +362,7 @@ export function PowerTelemetryView({ id, enabled }: Props) {
           artifactName={selectedSeries.artifactName}
           maxPoints={2000}
           display={display}
+          overlay={overlay}
           legendElement={
             <ChartLegend
               variant="sidebar"

From fe7a07770780488eccc8d12d45ac5cae371b7665 Mon Sep 17 00:00:00 2001
From: Cam Quilici <cjquilici@gmail.com>
Date: Thu, 17 Sep 2026 14:12:59 -0500
Subject: [PATCH 005/103] feat(powerx): default telemetry charts to rolling
 average

At 1 s cadence the raw per-chip points read as noise, so both PowerX
surfaces now open in rolling-average mode (30 s window); Points remains
one click away in the Display control.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 packages/app/src/components/gpu-power/telemetry-smoothing.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
index 91efcd64f..a9ec9a307 100644
--- a/packages/app/src/components/gpu-power/telemetry-smoothing.ts
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
@@ -29,8 +29,9 @@ export interface TelemetryDisplayState {
   series: TelemetrySeriesMode;
 }
 
+/** Rolling average is the default: at 1 s cadence the raw points read as noise. */
 export const DEFAULT_TELEMETRY_DISPLAY: TelemetryDisplayState = {
-  mode: 'points',
+  mode: 'rolling',
   windowS: 30,
   series: 'chips',
 };

From ab479c8cae0f3c0294b9194596e3a5804b7d9d23 Mon Sep 17 00:00:00 2001
From: Cam Quilici <cjquilici@gmail.com>
Date: Thu, 17 Sep 2026 14:24:43 -0500
Subject: [PATCH 006/103] feat(powerx): choose any available server metric as
 the telemetry overlay

Replace the decode-only overlay switch on the per-point PowerX tab with a
single-select menu of server metrics. The menu lists only the series the
point's trace actually reports (decode/prefill throughput, KV and host KV
cache utilization, prefix cache hit rate and hits, queue depth), defaults
to "None", and is disabled when the trace has no server metrics.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../agentic-point/overlay-sources.test.ts     | 61 ++++++++++++
 .../agentic-point/overlay-sources.ts          | 83 ++++++++++++++++
 .../agentic-point/power-telemetry-view.tsx    | 98 +++++++++++--------
 3 files changed, 202 insertions(+), 40 deletions(-)
 create mode 100644 packages/app/src/components/inference/agentic-point/overlay-sources.test.ts
 create mode 100644 packages/app/src/components/inference/agentic-point/overlay-sources.ts

diff --git a/packages/app/src/components/inference/agentic-point/overlay-sources.test.ts b/packages/app/src/components/inference/agentic-point/overlay-sources.test.ts
new file mode 100644
index 000000000..04bc1d44a
--- /dev/null
+++ b/packages/app/src/components/inference/agentic-point/overlay-sources.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+
+import type { TraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
+
+import { availableOverlaySources, OVERLAY_SOURCES } from './overlay-sources';
+
+const base: TraceServerMetrics = {
+  meta: {} as TraceServerMetrics['meta'],
+  startNs: 1_789_508_185_611_923_200,
+  endNs: 1_789_512_197_546_315_776,
+  durationS: 4011.9,
+  timeslicesCount: 3,
+  kvCacheUsage: [],
+  prefixCacheHitRate: [],
+  queueDepth: [],
+  promptTokensBySource: {},
+  prefillTps: [],
+  decodeTps: [],
+  prefixCacheHitsTps: [],
+  hostKvCacheUsage: [],
+  kvCacheUsageByEngine: [],
+  kvCachePoolTokens: null,
+  metricSources: [],
+};
+
+describe('availableOverlaySources', () => {
+  it('returns nothing without metrics or when every series is empty', () => {
+    expect(availableOverlaySources(null)).toEqual([]);
+    expect(availableOverlaySources(base)).toEqual([]);
+  });
+
+  it('offers only non-empty series, in menu order', () => {
+    const metrics: TraceServerMetrics = {
+      ...base,
+      queueDepth: [{ t: 0, running: 3, waiting: 2, total: 5 }],
+      decodeTps: [{ t: 0, value: 1200 }],
+    };
+    expect(availableOverlaySources(metrics).map((s) => s.key)).toEqual(['decodeTps', 'queueDepth']);
+  });
+
+  it('converts ratios to percent and queue depth to the total', () => {
+    const metrics: TraceServerMetrics = {
+      ...base,
+      kvCacheUsage: [{ t: 1, value: 0.42 }],
+      hostKvCacheUsage: [{ t: 1, value: 0.05 }],
+      prefixCacheHitRate: [{ t: 1, value: 1 }],
+      queueDepth: [{ t: 1, running: 3, waiting: 2, total: 5 }],
+    };
+    const byKey = Object.fromEntries(OVERLAY_SOURCES.map((s) => [s.key, s.points(metrics)]));
+    expect(byKey.kvCacheUsage).toEqual([{ t: 1, value: 42 }]);
+    expect(byKey.hostKvCacheUsage[0]!.value).toBeCloseTo(5, 9);
+    expect(byKey.prefixCacheHitRate).toEqual([{ t: 1, value: 100 }]);
+    expect(byKey.queueDepth).toEqual([{ t: 1, value: 5 }]);
+    expect(byKey.decodeTps).toEqual([]);
+  });
+
+  it('gives every source a distinct key and color', () => {
+    expect(new Set(OVERLAY_SOURCES.map((s) => s.key)).size).toBe(OVERLAY_SOURCES.length);
+    expect(new Set(OVERLAY_SOURCES.map((s) => s.color)).size).toBe(OVERLAY_SOURCES.length);
+  });
+});
diff --git a/packages/app/src/components/inference/agentic-point/overlay-sources.ts b/packages/app/src/components/inference/agentic-point/overlay-sources.ts
new file mode 100644
index 000000000..029274f25
--- /dev/null
+++ b/packages/app/src/components/inference/agentic-point/overlay-sources.ts
@@ -0,0 +1,83 @@
+import type { TraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
+import type { Locale } from '@/lib/i18n';
+
+/** One server-metric series that can be drawn over the chip telemetry chart. */
+export interface OverlaySource {
+  key: string;
+  label: { en: string; zh: string };
+  unit: string;
+  color: string;
+  /** Seconds-from-trace-start samples, already in display units. */
+  points: (metrics: TraceServerMetrics) => { t: number; value: number }[];
+}
+
+const percent = (points: readonly { t: number; value: number }[]) =>
+  points.map((p) => ({ t: p.t, value: p.value * 100 }));
+
+/**
+ * Menu of overlay candidates, in display order. Only sources whose series is
+ * non-empty for the point are offered (see `availableOverlaySources`).
+ */
+export const OVERLAY_SOURCES: readonly OverlaySource[] = [
+  {
+    key: 'decodeTps',
+    label: { en: 'Decode throughput', zh: 'Decode 吞吐量' },
+    unit: 'tok/s',
+    color: '#8b5cf6',
+    points: (m) => m.decodeTps,
+  },
+  {
+    key: 'prefillTps',
+    label: { en: 'Prefill throughput', zh: 'Prefill 吞吐量' },
+    unit: 'tok/s',
+    color: '#06b6d4',
+    points: (m) => m.prefillTps,
+  },
+  {
+    key: 'kvCacheUsage',
+    label: { en: 'KV cache utilization', zh: 'KV cache 利用率' },
+    unit: '%',
+    color: '#f59e0b',
+    points: (m) => percent(m.kvCacheUsage),
+  },
+  {
+    key: 'hostKvCacheUsage',
+    label: { en: 'Host KV cache utilization', zh: '主机 KV cache 利用率' },
+    unit: '%',
+    color: '#d97706',
+    points: (m) => percent(m.hostKvCacheUsage),
+  },
+  {
+    key: 'prefixCacheHitRate',
+    label: { en: 'Prefix cache hit rate', zh: 'Prefix cache 命中率' },
+    unit: '%',
+    color: '#10b981',
+    points: (m) => percent(m.prefixCacheHitRate),
+  },
+  {
+    key: 'prefixCacheHitsTps',
+    label: { en: 'Prefix cache hits', zh: 'Prefix cache 命中量' },
+    unit: 'tok/s',
+    color: '#14b8a6',
+    points: (m) => m.prefixCacheHitsTps,
+  },
+  {
+    key: 'queueDepth',
+    label: { en: 'Queue depth (running + waiting)', zh: '队列深度（运行中 + 等待中）' },
+    unit: 'req',
+    color: '#ec4899',
+    points: (m) => m.queueDepth.map((p) => ({ t: p.t, value: p.total })),
+  },
+];
+
+/** Sources that have at least one sample for this point, in menu order. */
+export function availableOverlaySources(
+  metrics: TraceServerMetrics | null | undefined,
+): OverlaySource[] {
+  if (!metrics) return [];
+  return OVERLAY_SOURCES.filter((source) => source.points(metrics).length > 0);
+}
+
+export function overlaySourceLabel(source: OverlaySource, locale: Locale): string {
+  return source.label[locale];
+}
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
index 177b016d0..967ca41e9 100644
--- a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -24,7 +24,6 @@ import { Card } from '@/components/ui/card';
 import ChartLegend from '@/components/ui/chart-legend';
 import { Label } from '@/components/ui/label';
 import { RetryableQueryError } from '@/components/ui/retryable-query-error';
-import { Switch } from '@/components/ui/switch';
 import {
   Select,
   SelectContent,
@@ -34,6 +33,8 @@ import {
 } from '@/components/ui/select';
 import { useGpuMetricsPoint, type GpuMetricSeries } from '@/hooks/api/use-gpu-metrics-point';
 import { useTraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
+
+import { availableOverlaySources, overlaySourceLabel } from './overlay-sources';
 import { track } from '@/lib/analytics';
 import { useLocale } from '@/lib/use-locale';
 
@@ -56,14 +57,14 @@ const STRINGS = {
     chip: 'Chip',
     secondsUnit: 's',
     resetFilter: 'Show all chips',
-    overlayToggle: 'Overlay decode throughput',
-    decodeTps: 'Decode throughput',
+    overlayToggle: 'Overlay server metric',
+    overlayNone: 'None',
     overlayLoading: 'Loading server metrics…',
-    overlayError: 'Server metrics failed to load; the overlay is unavailable.',
-    overlayUnavailable: 'This point has no decode-throughput server metrics to overlay.',
-    overlayAligned: 'Decode throughput is aligned to the telemetry by wall-clock timestamps.',
+    overlayError: 'Server metrics failed to load; overlays are unavailable.',
+    overlayUnavailable: 'This point has no server-metric series to overlay.',
+    overlayAligned: 'The overlay is aligned to the telemetry by wall-clock timestamps.',
     overlayRelative:
-      'The trace has no wall-clock timestamps, so decode throughput starts at the telemetry start (both at t=0).',
+      'The trace has no wall-clock timestamps, so the overlay and the telemetry are both aligned at their own t=0.',
   },
   zh: {
     loading: '正在加载 PowerX 遥测数据……',
@@ -83,19 +84,18 @@ const STRINGS = {
     chip: '芯片',
     secondsUnit: '秒',
     resetFilter: '显示全部芯片',
-    overlayToggle: '叠加 decode 吞吐量',
-    decodeTps: 'Decode 吞吐量',
+    overlayToggle: '叠加服务端指标',
+    overlayNone: '无',
     overlayLoading: '正在加载服务端指标……',
     overlayError: '服务端指标加载失败，无法叠加显示。',
-    overlayUnavailable: '该数据点没有可叠加的 decode 吞吐量服务端指标。',
-    overlayAligned: 'Decode 吞吐量已按绝对时间戳与遥测数据对齐。',
-    overlayRelative: 'trace 缺少绝对时间戳，因此 decode 吞吐量与遥测数据均从各自的 t=0 开始对齐。',
+    overlayUnavailable: '该数据点没有可叠加的服务端指标序列。',
+    overlayAligned: '叠加曲线已按绝对时间戳与遥测数据对齐。',
+    overlayRelative: 'trace 缺少绝对时间戳，因此叠加曲线与遥测数据均从各自的 t=0 开始对齐。',
   },
 } as const;
 
 const VENDOR_LABEL: Record<string, string> = { nvidia: 'nvidia-smi', amd: 'amd-smi' };
 /** Violet: outside the Tableau10 chip palette and the foreground mean line. */
-const OVERLAY_COLOR = '#8b5cf6';
 
 interface Props {
   id: number;
@@ -166,32 +166,37 @@ export function PowerTelemetryView({ id, enabled }: Props) {
   const [isLegendExpanded, setIsLegendExpanded] = useState(true);
   const [display, setDisplay] = useState<TelemetryDisplayState>(DEFAULT_TELEMETRY_DISPLAY);
 
-  // Decode-throughput overlay: fetched only once the switch is on.
-  const [overlayEnabled, setOverlayEnabled] = useState(false);
-  const metricsQuery = useTraceServerMetrics(id, enabled && overlayEnabled);
+  // Server-metric overlay. The series are fetched as soon as the tab opens so
+  // the menu can list exactly the metrics this point has; one source at a time.
+  const metricsQuery = useTraceServerMetrics(id, enabled);
   const serverMetrics = metricsQuery.data;
-  const decodeTps = serverMetrics?.decodeTps ?? [];
+  const overlaySources = useMemo(() => availableOverlaySources(serverMetrics), [serverMetrics]);
+  const [overlaySelection, setOverlaySelection] = useState<{ id: number; key: string } | null>(
+    null,
+  );
+  const overlayKey = overlaySelection?.id === id ? overlaySelection.key : 'none';
+  const overlaySource = overlaySources.find((source) => source.key === overlayKey) ?? null;
   // Trace timeslices carry epoch-ns starts, so both series can share wall-clock
   // time. A zero startNs means the trace only has relative time.
   const overlayAbsolute = Boolean(serverMetrics && serverMetrics.startNs > 0);
   const overlay = useMemo<TelemetryOverlaySeries | null>(() => {
-    if (!overlayEnabled || !serverMetrics || !selectedSeries || decodeTps.length === 0) return null;
+    if (!overlaySource || !serverMetrics || !selectedSeries) return null;
     const originMs = overlayAbsolute
       ? serverMetrics.startNs / 1e6
       : new Date(selectedSeries.startedAt).getTime();
     return {
-      key: 'decodeTps',
-      label: t.decodeTps,
-      unit: 'tok/s',
-      color: OVERLAY_COLOR,
-      points: toAbsoluteMs(decodeTps, originMs),
+      key: overlaySource.key,
+      label: overlaySourceLabel(overlaySource, locale),
+      unit: overlaySource.unit,
+      color: overlaySource.color,
+      points: toAbsoluteMs(overlaySource.points(serverMetrics), originMs),
     };
-  }, [overlayEnabled, serverMetrics, selectedSeries, decodeTps, overlayAbsolute, t.decodeTps]);
+  }, [overlaySource, serverMetrics, selectedSeries, overlayAbsolute, locale]);
   const overlayNote = ((): string | null => {
-    if (!overlayEnabled) return null;
     if (metricsQuery.isLoading) return t.overlayLoading;
     if (metricsQuery.isError) return t.overlayError;
-    if (!overlay) return t.overlayUnavailable;
+    if (overlaySources.length === 0) return t.overlayUnavailable;
+    if (!overlay) return null;
     return overlayAbsolute ? t.overlayAligned : t.overlayRelative;
   })();
 
@@ -328,24 +333,37 @@ export function PowerTelemetryView({ id, enabled }: Props) {
           idPrefix="power-telemetry-display"
           className="mt-3 border-t border-border/60 pt-3"
         />
-        <div className="mt-3 flex flex-wrap items-center gap-x-3 gap-y-1">
-          <div className="flex items-center gap-2">
-            <Switch
-              id="power-telemetry-overlay"
-              data-testid="power-telemetry-overlay-switch"
-              checked={overlayEnabled}
-              onCheckedChange={(checked) => {
-                track('inference_agentic_power_overlay_toggled', { id, enabled: checked });
-                setOverlayEnabled(checked);
+        <div className="mt-3 flex flex-wrap items-end gap-x-3 gap-y-1">
+          <div className="space-y-1">
+            <Label htmlFor="power-telemetry-overlay">{t.overlayToggle}</Label>
+            <Select
+              value={overlayKey}
+              disabled={overlaySources.length === 0}
+              onValueChange={(value) => {
+                track('inference_agentic_power_overlay_changed', { id, source: value });
+                setOverlaySelection({ id, key: value });
               }}
-            />
-            <Label htmlFor="power-telemetry-overlay" className="cursor-pointer">
-              {t.overlayToggle}
-            </Label>
+            >
+              <SelectTrigger
+                id="power-telemetry-overlay"
+                data-testid="power-telemetry-overlay-select"
+                className="w-full sm:w-64"
+              >
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value="none">{t.overlayNone}</SelectItem>
+                {overlaySources.map((source) => (
+                  <SelectItem key={source.key} value={source.key}>
+                    {overlaySourceLabel(source, locale)} ({source.unit})
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
           </div>
           {overlayNote && (
             <span
-              className="text-xs text-muted-foreground"
+              className="pb-2 text-xs text-muted-foreground"
               data-testid="power-telemetry-overlay-note"
             >
               {overlayNote}

From 132f0b5a83334ad10543e23400e00cf527d0dd4a Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Thu, 17 Sep 2026 14:20:27 -0700
Subject: [PATCH 007/103] fix: register gpu-metrics-point route and refresh
 gpu-metrics catalog digest
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Register GET /api/v1/gpu-metrics-point as a page-owned BFF in the API route
catalog and refresh the /api/gpu-metrics digest after the DB-first digest read
landed in d5e90c40. Neither route is part of the public API reference, so the
OpenAPI document and human reference are unchanged; the exclusion reason for
/api/gpu-metrics now describes the stored-digest-then-live-artifact behavior.

中文：在 API 路由目录中登记 GET /api/v1/gpu-metrics-point（页面专用 BFF），并在
d5e90c40 引入 DB 优先读取后刷新 /api/gpu-metrics 的摘要。两条路由都不属于公开 API
参考，OpenAPI 文档与人工参考无需改动；/api/gpu-metrics 的排除说明改为描述
"已入库摘要优先、否则回退实时制品"的行为。
---
 packages/app/src/lib/api-route-catalog.ts | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index ad54bf6a8..6f090ad9f 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -68,10 +68,10 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'ui-artifact-read',
     exclusionReason: {
-      en: 'UI-only live GPU metric artifact lookup; its run artifact shape is not a stable public contract.',
-      zh: '仅供界面读取实时 GPU 指标制品；其运行制品结构不是稳定的公开契约。',
+      en: 'UI-only PowerX explorer read for one run: the ingest-time telemetry digest when stored, otherwise the live GPU metric artifacts. Its payload shape is not a stable public contract.',
+      zh: '仅供 PowerX 探索界面按 run 读取：已入库时返回 ingest 阶段生成的 telemetry 摘要，否则回退到实时 GPU 指标制品。其返回结构不是稳定的公开契约。',
     },
-    sourceSha256: '28e6cee4d67396ee8ea2e5a7e18271c6ee86228c33f33a20bf573f3a601ba8ed',
+    sourceSha256: '01d604d77ea73e252f0934f88d14d0e229a803d1b9b1d72bd9756658c506b349',
   },
   {
     source: 'src/app/api/openapi.json/route.ts',
@@ -327,6 +327,17 @@ export const apiRouteCatalog = [
     operationId: 'list-reliability',
     sourceSha256: 'ce1c5db78b47548beb77a69797f10fb33853cde01cea5c44675c8ad3519bcf20',
   },
+  {
+    source: 'src/app/api/v1/gpu-metrics-point/route.ts',
+    path: '/api/v1/gpu-metrics-point',
+    method: 'GET',
+    classification: 'page-bff',
+    exclusionReason: {
+      en: 'Agentic point-detail BFF returning the PowerX telemetry series and per-GPU digest linked to one benchmark point; coupled to the PowerX tab implementation.',
+      zh: '智能体数据点详情页专用 BFF；返回与单个基准测试数据点关联的 PowerX telemetry 序列及每 GPU 统计摘要，与 PowerX 标签页实现紧密耦合。',
+    },
+    sourceSha256: '3929581f54058183344d59a8f6127db3ef1c8487cad26c73faa93b00fe75a82d',
+  },
   {
     source: 'src/app/api/v1/request-chart-data/route.ts',
     path: '/api/v1/request-chart-data',

From 70d4cab758889f19c7b5a10e87373d0b9428f5d9 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Thu, 17 Sep 2026 14:27:05 -0700
Subject: [PATCH 008/103] docs: correct why gpu_metrics telemetry backfill is
 bounded to 90 days
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The pipeline doc blamed an artifact-name filter in the GCS backup. The backup
keeps every artifact name; it only mirrors scheduled and main-branch runs, so
PR sweeps and manual dispatches - nearly every telemetry-bearing run - are never
copied, and our own GCS reader ignores non-bmk_/server_logs_ objects anyway.
Also note that the multinode template uploads no gpu_metrics_ artifact, so
multinode and disaggregated points never get a telemetry series.

中文：修正数据管线文档中 gpu_metrics telemetry 回填受 90 天限制的原因说明。
GCS 备份并不按 artifact 名过滤，而是只镜像定时任务和 main 分支的运行，PR sweep
与手动触发的运行从不被复制；应用自身的 GCS reader 也只读取 bmk_/server_logs_
对象。同时注明多节点模板不上传 gpu_metrics_ artifact，多节点与 disagg 数据点
不会有 telemetry 序列。
---
 docs/data-pipeline.md | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index ebafd3005..eaee38601 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -525,12 +525,15 @@ Reads are **permanently tolerant**: `queries/benchmarks.ts` selects the columns
 
 ### PowerX Telemetry Digest (`gpu_metric_*`, migration 016)
 
-Every benchmark job samples `nvidia-smi` / `amd-smi` once per second for its
-whole lifetime and uploads the CSV as `gpu_metrics_<suffix>` next to
-`bmk_<suffix>` (agentic jobs: `bmk_agentic_<suffix>`, still paired by the bare
-suffix). The PowerX explorer used to download and parse those artifacts from
-GitHub on every request and lost them after GitHub's 90-day retention. CI ingest
-now digests them at ingest time, in the same step that links server logs:
+Every single-node benchmark job (`benchmark-tmpl.yml`) samples `nvidia-smi` /
+`amd-smi` once per second for its whole lifetime and uploads the CSV as
+`gpu_metrics_<suffix>` next to `bmk_<suffix>` (agentic jobs: `bmk_agentic_<suffix>`,
+still paired by the bare suffix). The multinode template uploads no `gpu_metrics_`
+artifact — its telemetry travels only inside `power_audit_` — so multinode and
+disaggregated points have no series here and their per-point PowerX tab stays
+empty. The PowerX explorer used to download and parse the artifacts from GitHub
+on every request and lost them after GitHub's 90-day retention. CI ingest now
+digests them at ingest time, in the same step that links server logs:
 
 - `gpu_metric_series` — one row per (workflow run, artifact, CSV path): vendor,
   CSV sha256, sample count, GPU count, recorded window, median cadence, and the
@@ -555,8 +558,13 @@ interval is a reader concern; the raw series deliberately includes server
 start-up and warm-up so both phases can be inspected.
 
 `bun run admin:db:backfill-gpu-metrics --all --yes` attaches telemetry for runs
-ingested before this migration. The GCS backup only mirrors `bmk_`/`server_logs_`
-uploads, so the reachable history is bounded by GitHub's 90-day retention.
+ingested before this migration. The reachable history is bounded by GitHub's
+90-day artifact retention (the upload step sets no `retention-days`) because the
+GCS backup, which keeps every artifact name, only mirrors `schedule` and `push`
+runs on `main`; PR sweeps and manual dispatches — nearly every telemetry-bearing
+run — are never copied. Our own GCS reader (`lib/gcs-artifacts.ts`) additionally
+ignores everything but `bmk_`/`server_logs_` objects, so widening the mirror's run
+filter would also need a reader change before backfill could use it.
 
 Readers: `/api/gpu-metrics?runId=` serves the digest when the run is stored and
 falls back to live GitHub artifacts otherwise (in-progress runs), and

From 87b5ebe9271cd796008c7aa277556b1e99fec3ef Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Thu, 17 Sep 2026 14:30:17 -0700
Subject: [PATCH 009/103] test: cover gpu-metrics backfill, queries, and point
 lookup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

30 PGlite-backed tests over the PowerX telemetry ingest code that had none.

- queries/gpu-metrics: null on unknown run and on a run with zero series,
  full run payload shape, includeSamples=false, latest-attempt selection,
  multinode point fan-out, availability map, and a characterization of the
  `?? 0` sample defaulting (a dropped reading reports 0 W).
- lib/benchmark-result-lookup: natural-key match scoped to run attempt and
  config, offload_mode exact match vs. unique fallback vs. ambiguous drop,
  agentic null isl/osl, and artifact JSON mapping.
- backfill-gpu-metrics: candidate selection driven through the real CLI main
  against a migrated PGlite database, with GitHub listing stubbed. Pins the
  90-day default --since, the resume hazard (runs with stored series are
  skipped without --force), --run bypassing both filters, --from-run,
  --limit, and that --shard-count/--shard-index do not partition the set.

No production source was changed.

中文：为此前完全没有测试的 PowerX 遥测 ingest 代码补充 30 个基于 PGlite 的单元
测试，覆盖 gpu-metrics 读取查询、backfill 候选筛选与 benchmark 点位匹配。要点：
读取查询在 run 不存在或没有 series 时返回 null，多节点点位返回全部关联 series，
并固化了 `?? 0` 默认值行为（采集中断的样本会显示为 0 W，与真实的 0 W 无法区分）；
点位匹配按 run attempt 与完整 config 自然键限定，并区分 offload_mode 精确匹配、
唯一回退与歧义丢弃；backfill 测试通过真实 main 驱动候选筛选，固化默认 90 天
--since 窗口、--force 之前会跳过已有 series 的 run（断点续跑隐患）、--run 同时
绕过日期与 series 过滤，以及 --shard-count/--shard-index 实际不分片的现状。
未修改任何生产代码。
---
 packages/db/src/backfill-gpu-metrics.test.ts  | 192 ++++++++++++
 .../src/lib/benchmark-result-lookup.test.ts   | 219 +++++++++++++
 packages/db/src/queries/gpu-metrics.test.ts   | 295 ++++++++++++++++++
 3 files changed, 706 insertions(+)
 create mode 100644 packages/db/src/backfill-gpu-metrics.test.ts
 create mode 100644 packages/db/src/lib/benchmark-result-lookup.test.ts
 create mode 100644 packages/db/src/queries/gpu-metrics.test.ts

diff --git a/packages/db/src/backfill-gpu-metrics.test.ts b/packages/db/src/backfill-gpu-metrics.test.ts
new file mode 100644
index 000000000..e718fdd4d
--- /dev/null
+++ b/packages/db/src/backfill-gpu-metrics.test.ts
@@ -0,0 +1,192 @@
+/**
+ * Candidate-selection tests for the gpu_metrics backfill CLI.
+ *
+ * The script owns its `sql` handle and calls `runBackfillMain` at import time,
+ * so the seam here is the module boundary: `createAdminSql` is redirected at a
+ * PGlite database that has the real migrations applied, `runBackfillMain`
+ * captures `main` instead of running it, and `listRunArtifacts` records which
+ * runs the CLI actually reached. Every candidate query runs for real; nothing
+ * touches GitHub.
+ */
+
+import fs from 'node:fs';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type * as DbUtilsModule from './etl/db-utils';
+import type * as BackfillRunnerModule from './lib/backfill-runner';
+import type * as GithubArtifactsModule from './lib/github-artifacts';
+import type { ArtifactMeta } from './lib/github-artifacts';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+let sql: Sql;
+let main: () => Promise<void>;
+const listedRunIds: string[] = [];
+const originalArgv = process.argv;
+
+vi.mock('./etl/db-utils.js', async (importOriginal) => ({
+  ...(await importOriginal<typeof DbUtilsModule>()),
+  createAdminSql: () => sql,
+}));
+
+vi.mock('./lib/github-artifacts.js', async (importOriginal) => ({
+  ...(await importOriginal<typeof GithubArtifactsModule>()),
+  listRunArtifacts: (_repository: string, runId: string): Promise<ArtifactMeta[]> => {
+    listedRunIds.push(runId);
+    return Promise.resolve([]);
+  },
+}));
+
+vi.mock('./lib/backfill-runner.js', async (importOriginal) => ({
+  ...(await importOriginal<typeof BackfillRunnerModule>()),
+  runBackfillMain: (_name: string, _sql: Sql, entry: () => Promise<void>) => {
+    main = entry;
+  },
+}));
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, { json: JSON.stringify, array: (value: unknown) => value });
+}
+
+const daysAgo = (days: number): string =>
+  new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+
+const FRESH_NO_SERIES = 34000000001;
+const FRESH_WITH_SERIES = 34000000002;
+const STALE_WITH_SERIES = 34000000003;
+const FRESH_NO_BENCHMARKS = 34000000004;
+
+/** Run the CLI in --dry-run and report which GitHub run ids it selected, in order. */
+async function selectedRuns(...args: string[]): Promise<number[]> {
+  listedRunIds.length = 0;
+  process.argv = ['bun', 'src/backfill-gpu-metrics.ts', '--dry-run', ...args];
+  await main();
+  return listedRunIds.map(Number);
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+    await db.exec(fs.readFileSync(new URL(`../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  sql = queryClient(db) as unknown as Sql;
+  await import('./backfill-gpu-metrics');
+  expect(typeof main).toBe('function');
+}, 20_000);
+
+afterAll(async () => {
+  process.argv = originalArgv;
+  await db?.close();
+});
+
+/**
+ * Four runs covering each axis of the candidate filter: fresh/stale relative to
+ * GitHub's 90-day artifact retention, with/without an already-stored series, and
+ * one run that produced no benchmark rows at all.
+ */
+beforeEach(async () => {
+  listedRunIds.length = 0;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, html_url, created_at, date)
+    VALUES (1, ${FRESH_NO_SERIES}, 1, 'Run Sweep', null, now(), '${daysAgo(10)}'),
+           (2, ${FRESH_WITH_SERIES}, 1, 'Run Sweep', null, now(), '${daysAgo(10)}'),
+           (3, ${STALE_WITH_SERIES}, 1, 'Run Sweep', null, now(), '${daysAgo(100)}'),
+           (4, ${FRESH_NO_BENCHMARKS}, 1, 'Run Sweep', null, now(), '${daysAgo(10)}');
+
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 8, 8, 8, 8);
+
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+      isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 32, '{}'),
+           (11, 2, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 32, '{}'),
+           (12, 3, 1, 'single_turn', '${daysAgo(100)}', 8192, 1024, 32, '{}');
+
+    INSERT INTO gpu_metric_series (workflow_run_id, artifact_name, config_key, file_name,
+      vendor, csv_sha256, sample_count, gpu_count, started_at, ended_at)
+    VALUES (2, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+              'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'gpu_metrics.csv', 'nvidia', 'sha-2',
+              1, 8, now(), now()),
+           (3, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+              'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'gpu_metrics.csv', 'nvidia', 'sha-3',
+              1, 8, now(), now());`);
+});
+
+describe('candidate selection', () => {
+  it('defaults --since to GitHub 90-day artifact retention window', async () => {
+    // --force removes the series filter, isolating the date cutoff. The 100-day-old
+    // run is unreachable on GitHub, so it must not be queued.
+    expect(await selectedRuns('--all', '--force')).toEqual([FRESH_WITH_SERIES, FRESH_NO_SERIES]);
+  });
+
+  it('reaches past the retention window when --since is given explicitly', async () => {
+    expect(await selectedRuns('--all', '--force', '--since', '2020-01-01')).toEqual([
+      FRESH_WITH_SERIES,
+      FRESH_NO_SERIES,
+      STALE_WITH_SERIES,
+    ]);
+  });
+
+  it('resume hazard: a run that stored any series is skipped on a rerun without --force', async () => {
+    // An interrupted backfill leaves a run with one of its several artifacts
+    // stored. Re-invoking --all silently treats that run as finished.
+    expect(await selectedRuns('--all')).toEqual([FRESH_NO_SERIES]);
+  });
+
+  it('--run bypasses both the retention cutoff and the already-has-series filter', async () => {
+    expect(await selectedRuns('--run', String(STALE_WITH_SERIES))).toEqual([STALE_WITH_SERIES]);
+  });
+
+  it('--run still requires the run to have benchmark rows to attach telemetry to', async () => {
+    expect(await selectedRuns('--run', String(FRESH_NO_BENCHMARKS))).toEqual([]);
+  });
+
+  it('--from-run raises the GitHub run id floor', async () => {
+    expect(await selectedRuns('--all', '--force', '--from-run', String(FRESH_WITH_SERIES))).toEqual(
+      [FRESH_WITH_SERIES],
+    );
+  });
+
+  it('--limit truncates the ordered candidate list', async () => {
+    expect(await selectedRuns('--all', '--force', '--limit', '1')).toEqual([FRESH_WITH_SERIES]);
+  });
+
+  it('accepts --shard-count/--shard-index but does not partition the candidate set', async () => {
+    // Unlike the other sharded backfills, this script never applies the shard to
+    // its query, so every shard process would download the same artifacts.
+    const unsharded = await selectedRuns('--all', '--force');
+    for (const shardIndex of ['0', '1', '2', '3']) {
+      expect(
+        await selectedRuns('--all', '--force', '--shard-count', '4', '--shard-index', shardIndex),
+      ).toEqual(unsharded);
+    }
+  });
+});
+
+describe('flag validation', () => {
+  it('refuses to run without a run selector', async () => {
+    process.argv = ['bun', 'src/backfill-gpu-metrics.ts', '--dry-run'];
+    await expect(main()).rejects.toThrow('Pass --run <github run id> or --all');
+    expect(listedRunIds).toEqual([]);
+  });
+
+  it.each([
+    { args: ['--all', '--since', '09/01/2026'], message: '--since requires a YYYY-MM-DD date' },
+    { args: ['--all', '--parallel', '0'], message: '--parallel requires a positive integer' },
+    { args: ['--run', '0'], message: '--run requires a positive integer' },
+  ])('rejects $args', async ({ args, message }) => {
+    process.argv = ['bun', 'src/backfill-gpu-metrics.ts', '--dry-run', ...args];
+    await expect(main()).rejects.toThrow(message);
+    expect(listedRunIds).toEqual([]);
+  });
+});
diff --git a/packages/db/src/lib/benchmark-result-lookup.test.ts b/packages/db/src/lib/benchmark-result-lookup.test.ts
new file mode 100644
index 000000000..985a5723a
--- /dev/null
+++ b/packages/db/src/lib/benchmark-result-lookup.test.ts
@@ -0,0 +1,219 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import { mapBenchmarkRow, type BenchmarkParams } from '../etl/benchmark-mapper';
+import { createSkipTracker } from '../etl/skip-tracker';
+import { findBenchmarkResultIds, readMappedBenchmarkRows } from './benchmark-result-lookup';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+let sql: Sql;
+const roots: string[] = [];
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, { json: JSON.stringify, array: (value: unknown) => value });
+}
+
+const GITHUB_RUN_ID = 34557177019;
+const RUN = { github_run_id: GITHUB_RUN_ID, run_attempt: 2 };
+
+/** Raw `bmk_` JSON as the runner emits it for a fixed-sequence sweep. */
+function rawRow(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    infmax_model_prefix: 'dsr1',
+    hw: 'b200-nv',
+    framework: 'sglang',
+    precision: 'fp4',
+    isl: 8192,
+    osl: 1024,
+    conc: 32,
+    tp: 8,
+    ep: 1,
+    dp_attention: false,
+    tput_per_gpu: 1234.5,
+    ...overrides,
+  };
+}
+
+function mapped(raw: Record<string, unknown>): BenchmarkParams {
+  const row = mapBenchmarkRow(raw, createSkipTracker());
+  if (!row) throw new Error('fixture did not map');
+  return row;
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  const dir = new URL('../../migrations/', import.meta.url);
+  for (const name of fs.readdirSync(dir).toSorted()) {
+    if (name.endsWith('.sql')) await db.exec(fs.readFileSync(new URL(name, dir), 'utf8'));
+  }
+  sql = queryClient(db) as unknown as Sql;
+}, 30_000);
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+afterAll(async () => {
+  await db?.close();
+});
+
+/**
+ * Config 1 matches the fixture rows; config 2 differs only in decode_tp. Attempt 1
+ * of the same GitHub run holds a point that must never be matched from attempt 2.
+ */
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
+    VALUES (1, ${GITHUB_RUN_ID}, 1, 'Run Sweep', '2026-09-11T04:00:00Z', '2026-09-11'),
+           (2, ${GITHUB_RUN_ID}, 2, 'Run Sweep', '2026-09-11T06:00:00Z', '2026-09-11');
+
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      is_multinode, prefill_tp, prefill_ep, prefill_dp_attention, prefill_num_workers,
+      decode_tp, decode_ep, decode_dp_attention, decode_num_workers,
+      num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, false, 8, 1, false, 0,
+              8, 1, false, 0, 8, 8),
+           (2, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, false, 8, 1, false, 0,
+              4, 1, false, 0, 8, 8),
+           (3, 'dsv4', 'b200', 'vllm', 'fp4', 'none', false, false, 1, 1, false, 0,
+              1, 1, false, 0, 1, 1);
+
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+      isl, osl, conc, offload_mode, metrics)
+    VALUES (20, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'off', '{}'),
+           (21, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, 'off', '{}'),
+           (22, 2, 2, 'single_turn', '2026-09-11', 8192, 1024, 32, 'off', '{}'),
+           (23, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'off', '{}'),
+           (24, 2, 3, 'agentic_traces', '2026-09-11', null, null, 72, 'off', '{}');`);
+});
+
+describe('findBenchmarkResultIds', () => {
+  it('resolves one persisted point per mapped row using the run attempt and config key', async () => {
+    const ids = await findBenchmarkResultIds(sql, RUN, [
+      mapped(rawRow()),
+      mapped(rawRow({ conc: 64 })),
+    ]);
+    expect(ids.toSorted()).toEqual([20, 21]);
+  });
+
+  it('never matches another attempt of the same run or a config with different parallelism', async () => {
+    // Point 23 is the same natural key under attempt 1; point 22 is attempt 2 but
+    // decode_tp 4. Neither may be linked to the attempt-2 telemetry.
+    expect(
+      await findBenchmarkResultIds(sql, { ...RUN, run_attempt: 3 }, [mapped(rawRow())]),
+    ).toEqual([]);
+    expect(await findBenchmarkResultIds(sql, RUN, [mapped(rawRow({ tp: 4 }))])).toEqual([]);
+    const attempt1 = await findBenchmarkResultIds(sql, { ...RUN, run_attempt: 1 }, [
+      mapped(rawRow()),
+    ]);
+    expect(attempt1).toEqual([23]);
+  });
+
+  it('matches an agentic row whose isl and osl are null', async () => {
+    const agentic = mapped({
+      infmax_model_prefix: 'dsv4',
+      hw: 'b200-nv',
+      framework: 'vllm',
+      precision: 'fp4',
+      scenario_type: 'agentic-coding',
+      users: 72,
+      tput_per_gpu: 20000,
+    });
+    expect(agentic.isl).toBeNull();
+    expect(await findBenchmarkResultIds(sql, RUN, [agentic])).toEqual([24]);
+  });
+
+  it('prefers the offload-exact point and reports no unique fallback', async () => {
+    await db.exec(`INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type,
+      date, isl, osl, conc, offload_mode, metrics)
+      VALUES (25, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'on', '{}');`);
+    const fallbacks: number[] = [];
+    const ids = await findBenchmarkResultIds(sql, RUN, [mapped(rawRow())], (id) =>
+      fallbacks.push(id),
+    );
+    expect(ids).toEqual([20]);
+    expect(fallbacks).toEqual([]);
+  });
+
+  it('accepts a lone offload-drifted point through the unique fallback', async () => {
+    // Historical mapper drift: the only surviving point carries 'on' while the
+    // current mapper derives 'off'. Attaching telemetry is still unambiguous.
+    await db.exec(`UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 20;`);
+    const fallbacks: number[] = [];
+    const ids = await findBenchmarkResultIds(sql, RUN, [mapped(rawRow())], (id) =>
+      fallbacks.push(id),
+    );
+    expect(ids).toEqual([20]);
+    expect(fallbacks).toEqual([20]);
+  });
+
+  it('leaves ambiguous offload-drifted points unlinked', async () => {
+    await db.exec(`UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 20;
+      INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type,
+        date, isl, osl, conc, offload_mode, metrics)
+      VALUES (26, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'dram', '{}');`);
+    const fallbacks: number[] = [];
+    const ids = await findBenchmarkResultIds(sql, RUN, [mapped(rawRow())], (id) =>
+      fallbacks.push(id),
+    );
+    expect(ids).toEqual([]);
+    expect(fallbacks).toEqual([]);
+  });
+});
+
+describe('readMappedBenchmarkRows', () => {
+  function writeArtifact(files: Record<string, string>): string {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'bmk-lookup-'));
+    roots.push(root);
+    for (const [name, body] of Object.entries(files)) {
+      const target = path.join(root, name);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, body);
+    }
+    return root;
+  }
+
+  it('maps every benchmark JSON under the artifact, accepting arrays and single objects', () => {
+    const root = writeArtifact({
+      'conc32.json': JSON.stringify(rawRow()),
+      'nested/conc64.json': JSON.stringify([rawRow({ conc: 64 }), rawRow({ conc: 128 })]),
+    });
+    const rows = readMappedBenchmarkRows(root);
+    expect(rows.map((row) => row.conc).toSorted((a, b) => a - b)).toEqual([32, 64, 128]);
+    expect(rows[0]?.config).toMatchObject({
+      model: 'dsr1',
+      hardware: 'b200',
+      framework: 'sglang',
+      precision: 'fp4',
+      decodeTp: 8,
+    });
+  });
+
+  it('drops rows the production mapper rejects and files that are not JSON', () => {
+    const root = writeArtifact({
+      'conc32.json': JSON.stringify([
+        rawRow(),
+        rawRow({ hw: 'not-a-gpu' }),
+        rawRow({ conc: undefined }),
+        'not-an-object',
+        null,
+      ]),
+      'gpu_metrics.csv': 'timestamp, index\n2026/09/11 04:19:41.982, 0\n',
+      'README.md': '# ignored',
+    });
+    const rows = readMappedBenchmarkRows(root);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({ conc: 32, isl: 8192, osl: 1024, offloadMode: 'off' });
+  });
+});
diff --git a/packages/db/src/queries/gpu-metrics.test.ts b/packages/db/src/queries/gpu-metrics.test.ts
new file mode 100644
index 000000000..23a90485b
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics.test.ts
@@ -0,0 +1,295 @@
+import fs from 'node:fs';
+
+import { PGlite } from '@electric-sql/pglite';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import type { DbClient } from '../connection';
+import {
+  getGpuMetricsAvailability,
+  getGpuMetricsForPoint,
+  getGpuMetricsForRun,
+} from './gpu-metrics';
+
+let db: PGlite;
+const sql: DbClient = async (strings, ...values) => {
+  const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+  const result = await db.query<Record<string, unknown>>(query, values);
+  return result.rows;
+};
+
+/** Stand-in client that fails loudly if a query slips past an early return. */
+const exploding: DbClient = () => {
+  throw new Error('should not query');
+};
+
+const WITH_SERIES = 34557177019;
+const WITHOUT_SERIES = 34557177020;
+const RETRIED = 34557177021;
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+}, 20_000);
+
+afterAll(async () => {
+  await db?.close();
+});
+
+/**
+ * Run 1 holds a two-node artifact (one CSV per serving node) whose first CSV is
+ * shared by points 10 and 11; run 3 is a rerun of run 2's GitHub id. Point 12
+ * is deliberately left unlinked.
+ */
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion,
+      head_branch, head_sha, html_url, created_at, date)
+    VALUES (1, ${WITH_SERIES}, 1, 'Run Sweep', 'completed', 'success', 'main', 'abc123',
+        'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${WITH_SERIES}',
+        '2026-09-11T04:19:00Z', '2026-09-11'),
+      (2, ${WITHOUT_SERIES}, 1, 'Run Sweep', 'completed', 'success', null, null, null,
+        '2026-09-12T04:19:00Z', '2026-09-12'),
+      (3, ${RETRIED}, 1, 'Run Sweep', 'completed', 'failure', null, null, null,
+        '2026-09-13T04:19:00Z', '2026-09-13'),
+      (4, ${RETRIED}, 2, 'Run Sweep', 'completed', 'success', null, null, null,
+        '2026-09-13T06:19:00Z', '2026-09-13');
+
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      is_multinode, prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, true, 8, 8, 8, 8);
+
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+      isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+           (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}'),
+           (12, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 128, '{}');
+
+    INSERT INTO gpu_metric_series (id, workflow_run_id, artifact_name, config_key, file_name,
+      vendor, csv_sha256, sample_interval_s, sample_count, gpu_count, started_at, ended_at,
+      sidecars)
+    VALUES (100, 1, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'node0/gpu_metrics.csv', 'nvidia', 'sha-node0',
+        1, 3, 2, '2026-09-11T04:19:41Z', '2026-09-11T04:19:43Z',
+        '{"context": {"timestamp_timezone": "UTC"}}'),
+      (101, 1, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'node1/gpu_metrics.csv', 'nvidia', 'sha-node1',
+        1, 1, 1, '2026-09-11T04:19:41Z', '2026-09-11T04:19:42Z', '{}'),
+      (102, 4, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_1',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_1', 'gpu_metrics.csv', 'amd', 'sha-attempt2',
+        null, 1, 1, '2026-09-13T06:20:00Z', '2026-09-13T06:20:01Z', '{}'),
+      (103, 3, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'gpu_metrics.csv', 'nvidia', 'sha-attempt1',
+        null, 1, 1, '2026-09-13T04:20:00Z', '2026-09-13T04:20:01Z', '{}');
+
+    INSERT INTO benchmark_result_gpu_metrics (benchmark_result_id, series_id)
+    VALUES (10, 100), (11, 100), (10, 101);
+
+    INSERT INTO gpu_metric_gpu_stats (series_id, gpu_index, metric, sample_count,
+      min_value, max_value, mean_value, median_value, p95_value, p99_value, stddev_value)
+    VALUES (100, 0, 'powerW', 2, 187.5, 912.25, 549.875, 549.875, 912.25, 912.25, 362.375),
+           (100, 1, 'powerW', 1, 190.5, 190.5, 190.5, 190.5, 190.5, 190.5, 0),
+           (101, 0, 'powerW', 1, 500.5, 500.5, 500.5, 500.5, 500.5, 500.5, 0),
+           (102, 0, 'powerW', 1, 700.5, 700.5, 700.5, 700.5, 700.5, 700.5, 0),
+           (103, 0, 'powerW', 1, 100.5, 100.5, 100.5, 100.5, 100.5, 100.5, 0);
+
+    INSERT INTO gpu_metric_samples (series_id, gpu_index, sampled_at, power_w, temperature_c,
+      sm_clock_mhz, mem_clock_mhz, gpu_util_pct, mem_util_pct, edge_temp_c, mem_temp_c,
+      gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv, fclk_mhz, socclk_mhz, mm_activity_pct)
+    VALUES (100, 0, '2026-09-11T04:19:41Z', 187.5, 33, 120, 3996, 0, 0,
+              35.5, 40.5, 750, 800, 1350, 1940, 1100, 12.5),
+           (100, 1, '2026-09-11T04:19:41Z', 190.5, 39, 120, 3996, 0, 0,
+              null, null, null, null, null, null, null, null),
+           -- Collector dropout: the row exists but every metric column is null.
+           (100, 0, '2026-09-11T04:19:42Z', null, null, null, null, null, null,
+              null, null, null, null, null, null, null, null),
+           (101, 0, '2026-09-11T04:19:41Z', 500.5, 50, 1965, 3996, 98, 74,
+              null, null, null, null, null, null, null, null),
+           (102, 0, '2026-09-13T06:20:00Z', 700.5, 60, 1965, 3996, 99, 80,
+              null, null, null, null, null, null, null, null),
+           (103, 0, '2026-09-13T04:20:00Z', 100.5, 20, 120, 3996, 0, 0,
+              null, null, null, null, null, null, null, null);`);
+});
+
+describe('getGpuMetricsForRun', () => {
+  it('returns null for a GitHub run id that was never ingested', async () => {
+    expect(await getGpuMetricsForRun(sql, 99999999999)).toBeNull();
+  });
+
+  it('returns null for an ingested run that stored no telemetry series', async () => {
+    // The run row exists, so the null must come from the empty-series branch and
+    // not from a missing workflow_runs lookup.
+    const [row] = await sql`select id from workflow_runs where github_run_id = ${WITHOUT_SERIES}`;
+    expect(Number(row!.id)).toBe(2);
+    expect(await getGpuMetricsForRun(sql, WITHOUT_SERIES)).toBeNull();
+  });
+
+  it('returns the run header, every series, its per-GPU stats, and its samples', async () => {
+    const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
+
+    expect(payload?.workflowRun).toEqual({
+      id: 1,
+      githubRunId: WITH_SERIES,
+      runAttempt: 1,
+      name: 'Run Sweep',
+      date: '2026-09-11',
+      htmlUrl: `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${WITH_SERIES}`,
+      headBranch: 'main',
+      headSha: 'abc123',
+      conclusion: 'success',
+      status: 'completed',
+      createdAt: '2026-09-11T04:19:00.000Z',
+    });
+
+    expect(payload?.series.map((series) => series.fileName)).toEqual([
+      'node0/gpu_metrics.csv',
+      'node1/gpu_metrics.csv',
+    ]);
+
+    const [node0, node1] = payload!.series;
+    expect(node0).toMatchObject({
+      id: 100,
+      artifactName: 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+      configKey: 'dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 3,
+      gpuCount: 2,
+      startedAt: '2026-09-11T04:19:41.000Z',
+      endedAt: '2026-09-11T04:19:43.000Z',
+      sidecars: { context: { timestamp_timezone: 'UTC' } },
+      benchmarkResultIds: [10, 11],
+    });
+    expect(node0?.stats).toEqual([
+      {
+        gpuIndex: 0,
+        metric: 'powerW',
+        count: 2,
+        min: 187.5,
+        max: 912.25,
+        mean: 549.875,
+        median: 549.875,
+        p95: 912.25,
+        p99: 912.25,
+        stddev: 362.375,
+      },
+      {
+        gpuIndex: 1,
+        metric: 'powerW',
+        count: 1,
+        min: 190.5,
+        max: 190.5,
+        mean: 190.5,
+        median: 190.5,
+        p95: 190.5,
+        p99: 190.5,
+        stddev: 0,
+      },
+    ]);
+    expect(node0?.data.map((sample) => [sample.timestamp, sample.index, sample.power])).toEqual([
+      ['2026-09-11T04:19:41.000Z', 0, 187.5],
+      ['2026-09-11T04:19:41.000Z', 1, 190.5],
+      ['2026-09-11T04:19:42.000Z', 0, 0],
+    ]);
+    expect(node0?.data[0]).toEqual({
+      timestamp: '2026-09-11T04:19:41.000Z',
+      index: 0,
+      power: 187.5,
+      temperature: 33,
+      smClock: 120,
+      memClock: 3996,
+      gpuUtil: 0,
+      memUtil: 0,
+      edgeTemp: 35.5,
+      memTemp: 40.5,
+      gfxVoltage: 750,
+      socVoltage: 800,
+      memVoltage: 1350,
+      fclk: 1940,
+      socClk: 1100,
+      mmActivity: 12.5,
+    });
+    expect(node1?.benchmarkResultIds).toEqual([10]);
+  });
+
+  it('omits samples but keeps the digest when includeSamples is false', async () => {
+    const payload = await getGpuMetricsForRun(sql, WITH_SERIES, { includeSamples: false });
+    expect(payload?.series.map((series) => series.data)).toEqual([[], []]);
+    expect(payload?.series[0]?.stats).toHaveLength(2);
+    // sampleCount is the stored column, so it still reports the full series length.
+    expect(payload?.series[0]?.sampleCount).toBe(3);
+  });
+
+  it('reads the latest attempt of a rerun GitHub run id, not the first', async () => {
+    const payload = await getGpuMetricsForRun(sql, RETRIED);
+    expect(payload?.workflowRun).toMatchObject({ id: 4, runAttempt: 2, conclusion: 'success' });
+    expect(payload?.series.map((series) => ({ id: series.id, vendor: series.vendor }))).toEqual([
+      { id: 102, vendor: 'amd' },
+    ]);
+  });
+
+  it('reports a dropped sample as zeroes for the core metrics and drops the vendor extras', async () => {
+    const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
+    const dropped = payload?.series[0]?.data.at(-1);
+    // Characterizes the `?? 0` defaulting: a null power reading is indistinguishable
+    // from a genuine 0 W reading once it reaches the chart.
+    expect(dropped).toEqual({
+      timestamp: '2026-09-11T04:19:42.000Z',
+      index: 0,
+      power: 0,
+      temperature: 0,
+      smClock: 0,
+      memClock: 0,
+      gpuUtil: 0,
+      memUtil: 0,
+      edgeTemp: undefined,
+      memTemp: undefined,
+      gfxVoltage: undefined,
+      socVoltage: undefined,
+      memVoltage: undefined,
+      fclk: undefined,
+      socClk: undefined,
+      mmActivity: undefined,
+    });
+    // The AMD-only columns are absent rather than zeroed, so consumers can tell
+    // "not collected" from "collected as zero" for those — but not for the core six.
+    expect(Object.hasOwn(dropped!, 'edgeTemp')).toBe(true);
+    expect(dropped?.edgeTemp).toBeUndefined();
+  });
+});
+
+describe('getGpuMetricsForPoint', () => {
+  it('returns null for a benchmark point with no linked series', async () => {
+    expect(await getGpuMetricsForPoint(sql, 12)).toBeNull();
+    expect(await getGpuMetricsForPoint(sql, 9999)).toBeNull();
+  });
+
+  it('returns every series linked to a multinode point, with each series full sample set', async () => {
+    const payload = await getGpuMetricsForPoint(sql, 10);
+    expect(payload?.benchmarkResultId).toBe(10);
+    expect(payload?.series.map((series) => [series.id, series.fileName])).toEqual([
+      [100, 'node0/gpu_metrics.csv'],
+      [101, 'node1/gpu_metrics.csv'],
+    ]);
+    expect(payload?.series.map((series) => series.data.length)).toEqual([3, 1]);
+    // Each series carries every point that references it, not just the queried one.
+    expect(payload?.series.map((series) => series.benchmarkResultIds)).toEqual([[10, 11], [10]]);
+
+    const single = await getGpuMetricsForPoint(sql, 11);
+    expect(single?.series.map((series) => series.id)).toEqual([100]);
+  });
+});
+
+describe('getGpuMetricsAvailability', () => {
+  it('flags only the point ids that have at least one linked series', async () => {
+    expect(await getGpuMetricsAvailability(sql, [10, 11, 12, 9999])).toEqual({
+      10: true,
+      11: true,
+    });
+  });
+
+  it('short-circuits an empty id list without querying', async () => {
+    expect(await getGpuMetricsAvailability(exploding, [])).toEqual({});
+  });
+});

From 855009f4e83e70efa558f5123cf67879b649c7b2 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 18 Sep 2026 15:02:33 -0700
Subject: [PATCH 010/103] fix: skip runs GitHub has deleted in artifact
 backfills
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`gh api …/runs/<id>/artifacts` returns HTTP 404 once a run is deleted or
purged, and `retryArtifactOperation` spent the full backoff schedule on it
before `backfill-gpu-metrics --all --dry-run` aborted on the first such run
(34533943809, 18 runs into a 224-run sweep). Classify that 404 as
`WorkflowRunNotFoundError`, a `NonRetryableArtifactError` the retry helper
rethrows at once, and let both gpu-metrics and server-log backfills report
the run as gone and continue. The gpu-metrics header also drops the wrong
"GCS mirrors only bmk_/server_logs_" retention explanation.

中文：`gh api` 在 run 被删除或清理后返回 HTTP 404，之前 `retryArtifactOperation`
会把完整退避重试跑完，`backfill-gpu-metrics --all --dry-run` 在 224 个候选中
第 19 个 run（34533943809）处直接崩溃。现将该 404 归类为不可重试的
`WorkflowRunNotFoundError`，重试助手立即抛出，gpu-metrics 与 server-log 两个
backfill 记录该 run 已不存在并继续；同时修正 gpu-metrics 头注释中错误的
GCS 镜像保留说明。
---
 packages/db/src/backfill-gpu-metrics.test.ts | 34 +++++++++++---
 packages/db/src/backfill-gpu-metrics.ts      | 47 ++++++++++++-------
 packages/db/src/backfill-server-log-files.ts | 16 ++++---
 packages/db/src/lib/artifact-retry.test.ts   | 20 +++++++-
 packages/db/src/lib/artifact-retry.ts        | 13 ++++++
 packages/db/src/lib/backfill-runner.ts       | 25 ++++++++++
 packages/db/src/lib/github-artifacts.test.ts | 49 +++++++++++++++++++-
 packages/db/src/lib/github-artifacts.ts      | 46 ++++++++++++++++--
 8 files changed, 213 insertions(+), 37 deletions(-)

diff --git a/packages/db/src/backfill-gpu-metrics.test.ts b/packages/db/src/backfill-gpu-metrics.test.ts
index e718fdd4d..e54fe1d78 100644
--- a/packages/db/src/backfill-gpu-metrics.test.ts
+++ b/packages/db/src/backfill-gpu-metrics.test.ts
@@ -25,6 +25,8 @@ let db: PGlite;
 let sql: Sql;
 let main: () => Promise<void>;
 const listedRunIds: string[] = [];
+/** GitHub run ids whose artifact listing should 404 (the run was deleted). */
+const goneRunIds = new Set<string>();
 const originalArgv = process.argv;
 
 vi.mock('./etl/db-utils.js', async (importOriginal) => ({
@@ -32,13 +34,19 @@ vi.mock('./etl/db-utils.js', async (importOriginal) => ({
   createAdminSql: () => sql,
 }));
 
-vi.mock('./lib/github-artifacts.js', async (importOriginal) => ({
-  ...(await importOriginal<typeof GithubArtifactsModule>()),
-  listRunArtifacts: (_repository: string, runId: string): Promise<ArtifactMeta[]> => {
-    listedRunIds.push(runId);
-    return Promise.resolve([]);
-  },
-}));
+vi.mock('./lib/github-artifacts.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof GithubArtifactsModule>();
+  return {
+    ...actual,
+    listRunArtifacts: (repository: string, runId: string): Promise<ArtifactMeta[]> => {
+      listedRunIds.push(runId);
+      if (goneRunIds.has(runId)) {
+        return Promise.reject(new actual.WorkflowRunNotFoundError(repository, runId));
+      }
+      return Promise.resolve([]);
+    },
+  };
+});
 
 vi.mock('./lib/backfill-runner.js', async (importOriginal) => ({
   ...(await importOriginal<typeof BackfillRunnerModule>()),
@@ -94,6 +102,7 @@ afterAll(async () => {
  */
 beforeEach(async () => {
   listedRunIds.length = 0;
+  goneRunIds.clear();
   vi.spyOn(console, 'log').mockImplementation(() => {});
   await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
     INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, html_url, created_at, date)
@@ -143,6 +152,17 @@ describe('candidate selection', () => {
     expect(await selectedRuns('--all')).toEqual([FRESH_NO_SERIES]);
   });
 
+  it('a run GitHub has deleted is reported and skipped, not fatal for the sweep', async () => {
+    // GitHub 404s the artifact listing once a run is deleted (or purged past
+    // retention). One such run must not abort a months-long --all pass.
+    goneRunIds.add(String(FRESH_WITH_SERIES));
+    expect(await selectedRuns('--all', '--force')).toEqual([FRESH_WITH_SERIES, FRESH_NO_SERIES]);
+    const lines = vi.mocked(console.log).mock.calls.map((call) => call.join(' '));
+    expect(lines).toContainEqual(expect.stringContaining(`run ${FRESH_WITH_SERIES}`));
+    expect(lines).toContainEqual(expect.stringContaining('gone from GitHub'));
+    expect(lines.at(-1)).toContain('1 gone from GitHub');
+  });
+
   it('--run bypasses both the retention cutoff and the already-has-series filter', async () => {
     expect(await selectedRuns('--run', String(STALE_WITH_SERIES))).toEqual([STALE_WITH_SERIES]);
   });
diff --git a/packages/db/src/backfill-gpu-metrics.ts b/packages/db/src/backfill-gpu-metrics.ts
index 5cbfa640d..5141256d8 100644
--- a/packages/db/src/backfill-gpu-metrics.ts
+++ b/packages/db/src/backfill-gpu-metrics.ts
@@ -3,9 +3,10 @@
  * migration-016 tables for runs that were ingested before the CI path
  * digested them.
  *
- * GitHub keeps run artifacts for 90 days and the GCS backup only mirrors
- * bmk_/server_logs_ uploads, so the reachable history is bounded by GitHub
- * retention. Each gpu_metrics artifact is paired with its exact `bmk_<suffix>`
+ * GitHub keeps run artifacts for 90 days and the GCS mirror only covers
+ * scheduled/push runs on main, so the reachable history is bounded by GitHub
+ * retention; runs GitHub has since deleted are reported and skipped. Each
+ * gpu_metrics artifact is paired with its exact `bmk_<suffix>`
  * (or `bmk_agentic_<suffix>`) sibling, the raw rows are mapped through the
  * production mapper, and the series is linked to those persisted points.
  *
@@ -29,9 +30,14 @@ import { AsyncSemaphore } from './etl/async-semaphore.js';
 import { createAdminSql } from './etl/db-utils.js';
 import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest.js';
 import { retryArtifactOperation } from './lib/artifact-retry.js';
-import { confirmProceed, parseLimitForceFlags, runBackfillMain } from './lib/backfill-runner.js';
+import {
+  confirmProceed,
+  listBackfillRunArtifacts,
+  parseLimitForceFlags,
+  runBackfillMain,
+} from './lib/backfill-runner.js';
 import { findBenchmarkResultIds, readMappedBenchmarkRows } from './lib/benchmark-result-lookup.js';
-import { downloadArtifact, listRunArtifacts } from './lib/github-artifacts.js';
+import { downloadArtifact } from './lib/github-artifacts.js';
 import {
   pairGpuMetricsArtifacts,
   type GpuMetricsArtifactPair,
@@ -195,19 +201,23 @@ async function main(): Promise<void> {
   if (flags.dryRun) {
     let pairedRuns = 0;
     let pairs = 0;
+    let goneRuns = 0;
     for (const run of runs) {
       const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
-      const artifacts = await retryArtifactOperation(
-        `listing GitHub artifacts for run ${run.github_run_id}`,
-        () => listRunArtifacts(repository, String(run.github_run_id)),
-      );
+      const artifacts = await listBackfillRunArtifacts(repository, run.github_run_id);
+      if (artifacts === null) {
+        goneRuns++;
+        console.log(`  run ${run.github_run_id} (${run.date}): gone from GitHub`);
+        continue;
+      }
       const runPairs = pairGpuMetricsArtifacts(artifacts);
       if (runPairs.length > 0) pairedRuns++;
       pairs += runPairs.length;
       console.log(`  run ${run.github_run_id} (${run.date}): ${runPairs.length} pair(s)`);
     }
     console.log(
-      `\n=== dry run: ${runs.length} run(s), ${pairedRuns} with pairs, ${pairs} pair(s) ===`,
+      `\n=== dry run: ${runs.length} run(s), ${pairedRuns} with pairs, ${pairs} pair(s), ` +
+        `${goneRuns} gone from GitHub ===`,
     );
     return;
   }
@@ -225,6 +235,7 @@ async function main(): Promise<void> {
   let artifactFailures = 0;
   let runFailures = 0;
   let missingRuns = 0;
+  let goneRuns = 0;
 
   for (const [runIndex, run] of runs.entries()) {
     const runId = run.github_run_id;
@@ -232,10 +243,14 @@ async function main(): Promise<void> {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `gpu-metrics-backfill-${runId}-`));
     const runStart = Date.now();
     try {
-      const artifacts = await retryArtifactOperation(
-        `listing GitHub artifacts for run ${runId}`,
-        () => listRunArtifacts(repository, String(runId)),
-      );
+      const artifacts = await listBackfillRunArtifacts(repository, runId);
+      if (artifacts === null) {
+        goneRuns++;
+        console.log(
+          `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt}: gone from GitHub`,
+        );
+        continue;
+      }
       const pairs = pairGpuMetricsArtifacts(artifacts);
       if (pairs.length === 0) {
         missingRuns++;
@@ -293,8 +308,8 @@ async function main(): Promise<void> {
     `\n=== backfill complete: ${artifactsProcessed} artifact(s), ${seriesStored} series, ` +
       `${samplesStored} sample(s), ${pointsLinked} point link(s), ` +
       `${unmatchedArtifacts} unmatched artifact(s), ${emptyArtifacts} empty artifact(s), ` +
-      `${missingRuns} run(s) without pairs, ${artifactFailures} failed artifact(s), ` +
-      `${runFailures} failed run(s) ===`,
+      `${missingRuns} run(s) without pairs, ${goneRuns} run(s) gone from GitHub, ` +
+      `${artifactFailures} failed artifact(s), ${runFailures} failed run(s) ===`,
   );
   console.log('  Invalidate API cache after the backfill: bun run admin:cache:invalidate');
   if (artifactFailures > 0 || runFailures > 0) process.exitCode = 1;
diff --git a/packages/db/src/backfill-server-log-files.ts b/packages/db/src/backfill-server-log-files.ts
index 3208194a2..46c0d05be 100644
--- a/packages/db/src/backfill-server-log-files.ts
+++ b/packages/db/src/backfill-server-log-files.ts
@@ -22,13 +22,18 @@ import { hasNoSslFlag } from './cli-utils.js';
 import { insertServerLogFilePaths } from './etl/benchmark-ingest.js';
 import { createAdminSql } from './etl/db-utils.js';
 import { listServerLogFilePaths, serverLogArtifactRoot } from './etl/server-log-artifacts.js';
-import { downloadArtifact, listRunArtifacts } from './lib/github-artifacts.js';
+import { downloadArtifact } from './lib/github-artifacts.js';
 import {
   downloadGcsArtifact,
   listGcsServerLogArtifacts,
   type GcsArtifactMeta,
 } from './lib/gcs-artifacts.js';
-import { confirmProceed, parseLimitForceFlags, runBackfillMain } from './lib/backfill-runner.js';
+import {
+  confirmProceed,
+  listBackfillRunArtifacts,
+  parseLimitForceFlags,
+  runBackfillMain,
+} from './lib/backfill-runner.js';
 import { retryArtifactOperation } from './lib/artifact-retry.js';
 import { findBenchmarkResultIds, readMappedBenchmarkRows } from './lib/benchmark-result-lookup.js';
 import { repositoryFromRunUrl } from './lib/runtime-metadata-artifacts.js';
@@ -197,11 +202,8 @@ async function main(): Promise<void> {
         flags.source !== 'gcs' &&
         (flags.source === 'github' || isWithinGithubRetention(run.date))
       ) {
-        const artifacts = await retryArtifactOperation(
-          `listing GitHub artifacts for run ${runId}`,
-          () => listRunArtifacts(repository, String(runId)),
-        );
-        pairs = pairServerLogArtifacts(artifacts.filter((artifact) => !artifact.expired));
+        const artifacts = await listBackfillRunArtifacts(repository, runId);
+        pairs = pairServerLogArtifacts((artifacts ?? []).filter((artifact) => !artifact.expired));
         if (pairs.length > 0) {
           source = 'github';
           githubRuns++;
diff --git a/packages/db/src/lib/artifact-retry.test.ts b/packages/db/src/lib/artifact-retry.test.ts
index 675355b59..d369efc88 100644
--- a/packages/db/src/lib/artifact-retry.test.ts
+++ b/packages/db/src/lib/artifact-retry.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 
-import { retryArtifactOperation } from './artifact-retry.js';
+import { NonRetryableArtifactError, retryArtifactOperation } from './artifact-retry.js';
 
 describe('retryArtifactOperation', () => {
   it('retries transient failures using the configured delays', async () => {
@@ -39,4 +39,22 @@ describe('retryArtifactOperation', () => {
     ).rejects.toBe(failure);
     expect(wait).toHaveBeenCalledOnce();
   });
+
+  it('rethrows a non-retryable failure at once without waiting or warning', async () => {
+    // A deleted run 404s forever; sleeping through the full backoff schedule
+    // (~3.8 min at the default delays) per such run would stall a history sweep.
+    const gone = new NonRetryableArtifactError('run is gone');
+    const operation = vi.fn(() => {
+      throw gone;
+    });
+    const wait = vi.fn<(delayMs: number) => Promise<void>>(() => Promise.resolve());
+    const warn = vi.fn<(message: string) => void>();
+
+    await expect(
+      retryArtifactOperation('artifact', operation, { delaysMs: [5, 15], wait, warn }),
+    ).rejects.toBe(gone);
+    expect(operation).toHaveBeenCalledOnce();
+    expect(wait).not.toHaveBeenCalled();
+    expect(warn).not.toHaveBeenCalled();
+  });
 });
diff --git a/packages/db/src/lib/artifact-retry.ts b/packages/db/src/lib/artifact-retry.ts
index e145aa04d..4044dc35b 100644
--- a/packages/db/src/lib/artifact-retry.ts
+++ b/packages/db/src/lib/artifact-retry.ts
@@ -1,5 +1,17 @@
 const DEFAULT_RETRY_DELAYS_MS = [5_000, 15_000, 30_000, 60_000, 120_000] as const;
 
+/**
+ * Marks a failure no retry can fix (the run or artifact is gone, not
+ * unreachable). `retryArtifactOperation` rethrows it immediately instead of
+ * burning the full backoff schedule on it.
+ */
+export class NonRetryableArtifactError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'NonRetryableArtifactError';
+  }
+}
+
 interface ArtifactRetryOptions {
   delaysMs?: readonly number[];
   wait?: (delayMs: number) => Promise<void>;
@@ -26,6 +38,7 @@ export async function retryArtifactOperation<T>(
     try {
       return await operation();
     } catch (error) {
+      if (error instanceof NonRetryableArtifactError) throw error;
       lastError = error;
       if (attempt >= delaysMs.length) break;
       const delayMs = delaysMs[attempt];
diff --git a/packages/db/src/lib/backfill-runner.ts b/packages/db/src/lib/backfill-runner.ts
index 876e559b2..2051e493d 100644
--- a/packages/db/src/lib/backfill-runner.ts
+++ b/packages/db/src/lib/backfill-runner.ts
@@ -8,6 +8,12 @@
 
 import { confirm, hasYesFlag } from '../cli-utils.js';
 import type { Sql } from '../etl/db-utils.js';
+import { retryArtifactOperation } from './artifact-retry.js';
+import {
+  WorkflowRunNotFoundError,
+  listRunArtifacts,
+  type ArtifactMeta,
+} from './github-artifacts.js';
 
 export interface LimitForceFlags {
   limit: number | null;
@@ -165,6 +171,25 @@ export async function runCandidateIdBackfill(
  * class instances/prototypes so postgres.js serializes plain data only —
  * matches what the inline ingest path stores.
  */
+/**
+ * List a candidate run's GitHub artifacts with transient-failure retry.
+ * Returns `null` when GitHub no longer has the run at all, so a sweep over
+ * months of history reports the gap and moves on instead of aborting.
+ */
+export async function listBackfillRunArtifacts(
+  repository: string,
+  runId: number,
+): Promise<ArtifactMeta[] | null> {
+  try {
+    return await retryArtifactOperation(`listing GitHub artifacts for run ${runId}`, () =>
+      listRunArtifacts(repository, String(runId)),
+    );
+  } catch (error) {
+    if (error instanceof WorkflowRunNotFoundError) return null;
+    throw error;
+  }
+}
+
 export function jsonbParam(sql: Sql, value: unknown): ReturnType<Sql['json']> {
   return sql.json(structuredClone(value) as unknown as Parameters<typeof sql.json>[0]);
 }
diff --git a/packages/db/src/lib/github-artifacts.test.ts b/packages/db/src/lib/github-artifacts.test.ts
index 571643a5e..ae71f8890 100644
--- a/packages/db/src/lib/github-artifacts.test.ts
+++ b/packages/db/src/lib/github-artifacts.test.ts
@@ -1,6 +1,12 @@
 import { describe, expect, it } from 'vitest';
 
-import { RUNNER_SUFFIX_RE, dedupeArtifactsByLogicalName } from './github-artifacts.js';
+import { NonRetryableArtifactError } from './artifact-retry.js';
+import {
+  RUNNER_SUFFIX_RE,
+  WorkflowRunNotFoundError,
+  dedupeArtifactsByLogicalName,
+  isGithubNotFoundError,
+} from './github-artifacts.js';
 
 const art = (name: string, created_at: string) => ({
   name,
@@ -40,3 +46,44 @@ describe('dedupeArtifactsByLogicalName', () => {
     expect(deduped.get('run-stats')?.name).toBe('run-stats');
   });
 });
+
+describe('isGithubNotFoundError', () => {
+  it('recognises the status gh prints to stderr for a deleted run', () => {
+    // Shape of the error execSync throws with `encoding: 'utf8'`: the message
+    // only names the command; the HTTP status lives in stderr.
+    const error = Object.assign(
+      new Error('Command failed: gh api repos/o/r/actions/runs/1/artifacts'),
+      {
+        status: 1,
+        stderr: 'gh: Not Found (HTTP 404)\n{"message":"Not Found"}\n',
+      },
+    );
+    expect(isGithubNotFoundError(error)).toBe(true);
+  });
+
+  it('leaves transient failures retryable', () => {
+    expect(
+      isGithubNotFoundError(
+        Object.assign(new Error('Command failed'), {
+          stderr: 'gh: error connecting to api.github.com\n',
+        }),
+      ),
+    ).toBe(false);
+    expect(
+      isGithubNotFoundError(
+        Object.assign(new Error('Command failed'), { stderr: 'gh: Server Error (HTTP 502)\n' }),
+      ),
+    ).toBe(false);
+    expect(isGithubNotFoundError(null)).toBe(false);
+    expect(isGithubNotFoundError('HTTP 404')).toBe(false);
+  });
+});
+
+describe('WorkflowRunNotFoundError', () => {
+  it('is non-retryable and names the run', () => {
+    const error = new WorkflowRunNotFoundError('SemiAnalysisAI/InferenceX', '34533943809');
+    expect(error).toBeInstanceOf(NonRetryableArtifactError);
+    expect(error.runId).toBe('34533943809');
+    expect(error.message).toContain('34533943809');
+  });
+});
diff --git a/packages/db/src/lib/github-artifacts.ts b/packages/db/src/lib/github-artifacts.ts
index 67827855e..c95957755 100644
--- a/packages/db/src/lib/github-artifacts.ts
+++ b/packages/db/src/lib/github-artifacts.ts
@@ -8,6 +8,8 @@ import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { NonRetryableArtifactError } from './artifact-retry.js';
+
 export interface ArtifactMeta {
   id?: number;
   name: string;
@@ -32,12 +34,46 @@ export interface ArtifactMeta {
  */
 export const RUNNER_SUFFIX_RE = /_[a-zA-Z][a-zA-Z0-9.-]*_\d+$/u;
 
-/** List a workflow run's artifacts via `gh api` (paginated). Malformed lines are skipped. */
+/**
+ * GitHub no longer has the run (deleted, or purged past retention), so its
+ * artifact listing 404s. Distinct from expired artifacts, which still list
+ * with `expired: true`.
+ */
+export class WorkflowRunNotFoundError extends NonRetryableArtifactError {
+  readonly repo: string;
+  readonly runId: string;
+
+  constructor(repo: string, runId: string) {
+    super(`GitHub has no run ${runId} in ${repo} (HTTP 404)`);
+    this.name = 'WorkflowRunNotFoundError';
+    this.repo = repo;
+    this.runId = runId;
+  }
+}
+
+/** `gh api` reports the HTTP status in its stderr (`gh: Not Found (HTTP 404)`). */
+export function isGithubNotFoundError(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) return false;
+  const { stderr, message } = error as { stderr?: unknown; message?: unknown };
+  const text = [stderr, message].filter((part) => typeof part === 'string').join('\n');
+  return /\(HTTP 404\)/u.test(text);
+}
+
+/**
+ * List a workflow run's artifacts via `gh api` (paginated). Malformed lines
+ * are skipped; a 404 surfaces as `WorkflowRunNotFoundError`.
+ */
 export function listRunArtifacts(repo: string, runId: string): ArtifactMeta[] {
-  const json = execSync(
-    `gh api "repos/${repo}/actions/runs/${runId}/artifacts" --paginate --jq '.artifacts[]'`,
-    { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 },
-  );
+  let json: string;
+  try {
+    json = execSync(
+      `gh api "repos/${repo}/actions/runs/${runId}/artifacts" --paginate --jq '.artifacts[]'`,
+      { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 },
+    );
+  } catch (error) {
+    if (isGithubNotFoundError(error)) throw new WorkflowRunNotFoundError(repo, runId);
+    throw error;
+  }
   const out: ArtifactMeta[] = [];
   for (const line of json.trim().split('\n')) {
     if (!line) continue;

From 65c650101da6cc286985443b31ce3a66db1c9907 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 18 Sep 2026 15:49:33 -0700
Subject: [PATCH 011/103] feat: plan modeled power for aggregate multinode
 chassis at the deployment mean
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Aggregate multinode producers (Kimi K3 B200 dynamo-vLLM TP8/PP2, H200 vLLM
TP16×2) emit no per-worker telemetry, so `modelSystemPower` rejected every
such row as `topology` and the smart-provision basis showed no NVIDIA K3 SKU.
Add a `uniform-hosts` topology basis for non-disaggregated multinode rows
without a worker array: the telemetry GPU count must fill whole eight-GPU
hosts and match TP×PP×PCP×replicas, and each chassis is modeled at the
deployment mean; rows that carry per-worker telemetry keep the exact
worker-hosts path and disaggregated rows still require it. `planningKwPerGpu`
now admits every fully measured multi-chassis estimate instead of only one
single-node chassis. Tooltip copy (en/zh) names the uniform-hosts assumption
and the system-power doc records the admission rule.

中文：聚合多节点的采集端（Kimi K3 B200 dynamo-vLLM TP8/PP2、H200 vLLM
TP16×2）不输出逐 worker 功耗，`modelSystemPower` 一律按 `topology` 拒绝，
smart provision 里因此没有任何 NVIDIA K3 SKU。新增 `uniform-hosts` 拓扑基准：
非 disagg 多节点且无 worker 数组时，要求 telemetry GPU 数填满整数个八卡主机并
等于 TP×PP×PCP×副本数，每个机箱按部署平均功耗建模；带逐 worker 功耗的行仍走
精确的 worker-hosts 路径，disagg 行仍需逐 worker 数据。`planningKwPerGpu`
改为接受所有机箱均完整实测的估算。tooltip 中英文说明该假设，系统功耗文档同步。
---
 docs/powerx-system-power.md                   | 11 ++-
 .../calculator/profit-power.test.ts           | 38 +++++++++
 .../src/components/calculator/profit-power.ts | 11 +--
 .../inference/utils/tooltipUtils.ts           |  5 +-
 .../app/src/lib/modeled-system-power.test.ts  | 83 +++++++++++++++++++
 packages/app/src/lib/modeled-system-power.ts  | 40 ++++++++-
 6 files changed, 175 insertions(+), 13 deletions(-)

diff --git a/docs/powerx-system-power.md b/docs/powerx-system-power.md
index efee20866..30a758ca2 100644
--- a/docs/powerx-system-power.md
+++ b/docs/powerx-system-power.md
@@ -95,9 +95,14 @@ facility kW/GPU used to calculate capacity per GW. Consequently, revenue,
 compute expense, license fee, and profit scale together; profit margin does not
 change. Electricity expense is not recomputed separately.
 
-This opt-in AgentX estimate requires validated schema-v2 telemetry and a complete
-single-node eight-GPU chassis supported by the pinned model. Partial allocations,
-unsupported GB200/GB300 chassis, and missing/invalid measurements stay unavailable.
+This opt-in AgentX estimate requires validated schema-v2 telemetry and fully
+measured eight-GPU chassis supported by the pinned model: one single-node chassis,
+one chassis per measured worker host, or, for an aggregate multinode deployment
+whose producer emits no per-worker telemetry, every chassis at the deployment-mean
+GPU power (`topologyBasis: 'uniform-hosts'`; symmetric TP/PP/DP shards load each
+host alike). Partial allocations, unsupported GB200/GB300 chassis, disaggregated
+deployments without per-worker telemetry, and missing/invalid measurements stay
+unavailable.
 The ordinary 8K/1K transformation keeps its existing admission policy.
 
 At an exact frontier point, use that point's modeled power. Between points,
diff --git a/packages/app/src/components/calculator/profit-power.test.ts b/packages/app/src/components/calculator/profit-power.test.ts
index ce13042d8..37cc13173 100644
--- a/packages/app/src/components/calculator/profit-power.test.ts
+++ b/packages/app/src/components/calculator/profit-power.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest';
 
 import type { BenchmarkRow } from '@/lib/api';
 import { modelSystemPower } from '@/lib/modeled-system-power';
+import { estimateChassisPower } from '@/lib/system-power-model';
 import { Percentile, Sequence } from '@/lib/data-mappings';
 import { buildGpuGroups, interpolateForGPU } from './useThroughputData';
 import { estimateProfitRows } from './profit-estimator';
@@ -142,6 +143,43 @@ describe('profit power basis preview', () => {
     ).toBeNull();
   });
 
+  it('plans fully measured multi-chassis deployments at the same facility watts per GPU', () => {
+    // Kimi K3 B200 dynamo-vLLM TP8/PP2: sixteen GPUs on two hosts, aggregate
+    // producer without a per-worker array → uniform-hosts basis.
+    const multinode: BenchmarkRow = {
+      ...source,
+      hardware: 'b200',
+      framework: 'dynamo-vllm',
+      is_multinode: true,
+      num_prefill_gpu: 16,
+      num_decode_gpu: 16,
+      decode_num_workers: 1,
+      metrics: {
+        power_valid: 1,
+        power_metric_schema_version: 2,
+        avg_power_w: 715.095,
+        avg_total_gpu_power_w: 11441.513,
+        decode_pp: 2,
+      },
+    };
+    expect(modelSystemPower(multinode, undefined, true)).toMatchObject({
+      status: 'supported',
+      topologyBasis: 'uniform-hosts',
+      chassisBasis: 'full',
+    });
+    const perChassis = estimateChassisPower('b200', 11441.513 / 2, 1.3)!;
+    expect(
+      modeledPowerAtTarget({ ...result, nearestPoints: [{ ...point, sourceRow: multinode }] }, 45),
+    ).toBeCloseTo(((perChassis.facilityWatts * 2) / 16 / 1000) * 1.1, 8);
+    // Disaggregated multinode rows still need per-worker telemetry.
+    expect(
+      modeledPowerAtTarget(
+        { ...result, nearestPoints: [{ ...point, sourceRow: { ...multinode, disagg: true } }] },
+        45,
+      ),
+    ).toBeNull();
+  });
+
   it('leaves the default estimator and default AgentX model gate unchanged', () => {
     expect(
       estimateProfitByPower([result], specs, pricing, assumptions, 'provisioned', 45, labels),
diff --git a/packages/app/src/components/calculator/profit-power.ts b/packages/app/src/components/calculator/profit-power.ts
index 086322574..71308ed85 100644
--- a/packages/app/src/components/calculator/profit-power.ts
+++ b/packages/app/src/components/calculator/profit-power.ts
@@ -17,13 +17,10 @@ function planningKwPerGpu(point: GPUDataPoint): number | null {
   const row = point.sourceRow;
   if (!row || row.metrics.power_metric_schema_version !== 2) return null;
   const estimate = modelSystemPower(row, undefined, true);
-  if (
-    estimate.status !== 'supported' ||
-    estimate.gpuCount !== 8 ||
-    estimate.topologyBasis !== 'single-node' ||
-    estimate.chassisBasis !== 'full'
-  )
-    return null;
+  // Every modeled chassis must be fully measured; a partial allocation's
+  // extrapolated share is not a planning figure. Multi-chassis deployments
+  // (per-worker or uniform hosts) plan at the same facility watts per GPU.
+  if (estimate.status !== 'supported' || estimate.chassisBasis !== 'full') return null;
   return (estimate.deploymentFacilityWatts / estimate.gpuCount / 1000) * 1.1;
 }
 
diff --git a/packages/app/src/components/inference/utils/tooltipUtils.ts b/packages/app/src/components/inference/utils/tooltipUtils.ts
index 314941a89..26626ed04 100644
--- a/packages/app/src/components/inference/utils/tooltipUtils.ts
+++ b/packages/app/src/components/inference/utils/tooltipUtils.ts
@@ -228,6 +228,8 @@ const SYSTEM_POWER_STRINGS = {
         : `${chassis} eight-GPU chassis · ${measured} of ${modeled} GPUs measured, extrapolated to full chassis`,
     extrapolation:
       'Unmeasured chassis GPUs are assumed to run the same workload at the measured per-GPU power; deployment values are the measured GPUs’ share.',
+    uniformHosts:
+      'No per-host telemetry for this multinode deployment; every chassis is modeled at the deployment-mean GPU power.',
     normalization: 'AC power is divided by all modeled chassis GPUs, including prefill and decode.',
     boundary: 'Includes GPU chassis CPUs; excludes separate CPU-only frontend/router hosts.',
     model: 'Power model source',
@@ -257,6 +259,7 @@ const SYSTEM_POWER_STRINGS = {
         : `${chassis} 个八卡机箱 · 实测 ${measured}/${modeled} 张 GPU，按满机箱外推`,
     extrapolation:
       '假设机箱内未实测的 GPU 运行相同负载、功耗与实测每卡功耗相同；部署数值为实测 GPU 所占份额。',
+    uniformHosts: '该多节点部署没有逐主机功耗数据；每个机箱按部署平均每卡功耗建模。',
     normalization: '交流功耗按所有建模机箱的 GPU 总数分摊，包括 Prefill 与 Decode。',
     boundary: '计入 GPU 机箱内的 CPU；不计入独立的纯 CPU 前端或路由主机。',
     model: '功耗模型来源',
@@ -303,7 +306,7 @@ const modeledSystemPowerHTML = (
         ? `
       ${tooltipLine(t.deploymentAc, `${fmt(estimate.deploymentAcWatts)} W`)}
       ${tooltipLine(`${t.facility} (PUE ${fmt(estimate.pue)})`, `${fmt(estimate.deploymentFacilityWatts)} W`)}
-      <div style="color: var(--muted-foreground); margin-bottom: 4px;">${t.topology(estimate.chassisCount, estimate.gpuCount, estimate.modeledGpuCount)}${estimate.chassisBasis === 'extrapolated' ? `<br/>${t.extrapolation}` : ''}<br/>${t.assumptions}<br/>${t.platformAssumptions}<br/>${t.normalization}<br/>${t.boundary}</div>
+      <div style="color: var(--muted-foreground); margin-bottom: 4px;">${t.topology(estimate.chassisCount, estimate.gpuCount, estimate.modeledGpuCount)}${estimate.chassisBasis === 'extrapolated' ? `<br/>${t.extrapolation}` : ''}${estimate.topologyBasis === 'uniform-hosts' ? `<br/>${t.uniformHosts}` : ''}<br/>${t.assumptions}<br/>${t.platformAssumptions}<br/>${t.normalization}<br/>${t.boundary}</div>
       ${tooltipLine(t.model, `<a href="${escapeHtml(sourceUrl)}" target="_blank" rel="noopener noreferrer" style="text-decoration: underline;">${escapeHtml(estimate.hardware)} · ${escapeHtml(estimate.modelRevision.slice(0, 12))}</a>`)}
       <a href="${escapeHtml(readmeUrl)}" target="_blank" rel="noopener noreferrer" style="text-decoration: underline;">${t.sweep}</a>
     `
diff --git a/packages/app/src/lib/modeled-system-power.test.ts b/packages/app/src/lib/modeled-system-power.test.ts
index c968537ae..c8fb4c26e 100644
--- a/packages/app/src/lib/modeled-system-power.test.ts
+++ b/packages/app/src/lib/modeled-system-power.test.ts
@@ -222,6 +222,89 @@ describe('modeled system power admission and accounting', () => {
     expect(modelSystemPower(source)).toMatchObject({ reason: 'role-power' });
   });
 
+  it('models an aggregate multinode deployment without worker telemetry at the deployment mean', () => {
+    // Kimi K3 B200 dynamo-vLLM TP8/PP2 (prod rows, 2026-09-17): two eight-GPU hosts,
+    // aggregate producer, no per-worker array. The K3 H200 vLLM row below is
+    // TP16 × 2 DP replicas across four hosts.
+    const b200 = row({
+      is_multinode: true,
+      num_prefill_gpu: 16,
+      num_decode_gpu: 16,
+      decode_num_workers: 1,
+      metrics: {
+        power_valid: 1,
+        power_metric_schema_version: 2,
+        avg_power_w: 715.095,
+        avg_total_gpu_power_w: 11441.513,
+        decode_pp: 2,
+      },
+    });
+    const perChassis = estimateChassisPower('b200', 11441.513 / 2, 1.3)!;
+    const estimate = modelSystemPower(b200);
+    expect(estimate).toMatchObject({
+      status: 'supported',
+      topologyBasis: 'uniform-hosts',
+      chassisBasis: 'full',
+      gpuCount: 16,
+      chassisCount: 2,
+      modeledGpuCount: 16,
+    });
+    if (estimate.status !== 'supported') throw new Error('unreachable');
+    expect(estimate.chassisAcWatts).toBeCloseTo(perChassis.chassisAcWatts * 2, 6);
+    expect(estimate.deploymentFacilityWatts).toBe(estimate.facilityWatts);
+    expect(estimate.chassisAcWattsPerGpu).toBeCloseTo(perChassis.chassisAcWatts / 8, 6);
+
+    const h200 = row({
+      hardware: 'h200',
+      is_multinode: true,
+      prefill_tp: 16,
+      decode_tp: 16,
+      decode_ep: 32,
+      decode_dp_attention: true,
+      decode_num_workers: 2,
+      num_prefill_gpu: 32,
+      num_decode_gpu: 32,
+      metrics: {
+        power_valid: 1,
+        power_metric_schema_version: 2,
+        avg_power_w: 167.357,
+        avg_total_gpu_power_w: 5355.413,
+        decode_pp: 1,
+      },
+    });
+    expect(modelSystemPower(h200)).toMatchObject({
+      status: 'supported',
+      topologyBasis: 'uniform-hosts',
+      chassisCount: 4,
+      gpuCount: 32,
+    });
+
+    // A replica count that does not explain the telemetry width is not guessed around.
+    expect(modelSystemPower({ ...h200, decode_num_workers: 1 })).toMatchObject({
+      reason: 'gpu-count',
+    });
+    // Twelve GPUs cannot fill whole eight-GPU hosts; placement is unknown.
+    const twelve = row({ is_multinode: true, decode_tp: 12, prefill_tp: 12 });
+    twelve.metrics.avg_total_gpu_power_w = twelve.metrics.avg_power_w * 12;
+    expect(modelSystemPower(twelve)).toMatchObject({ reason: 'topology' });
+    // Per-worker telemetry, when present, keeps the more exact worker path.
+    const withWorkers = {
+      ...b200,
+      workers: ['host-a', 'host-b'].map((host, worker_idx) => ({
+        role: 'agg',
+        worker_idx,
+        hosts: [host],
+        num_gpus: 8,
+        avg_power_w: 715.095,
+      })),
+    };
+    expect(modelSystemPower(withWorkers)).toMatchObject({
+      status: 'supported',
+      topologyBasis: 'worker-hosts',
+      chassisCount: 2,
+    });
+  });
+
   it('preserves meaningful aggregate PP and PCP aliases before checking physical width', () => {
     for (const widths of [
       { decode_pp: 1, prefill_pp: 2 },
diff --git a/packages/app/src/lib/modeled-system-power.ts b/packages/app/src/lib/modeled-system-power.ts
index 550fe23fc..aadb737f6 100644
--- a/packages/app/src/lib/modeled-system-power.ts
+++ b/packages/app/src/lib/modeled-system-power.ts
@@ -43,7 +43,13 @@ export type SystemPowerEstimate =
       deploymentFacilityWatts: number;
       pue: number;
       telemetryBasis: 'validated-v2' | 'validated-unversioned-single-node';
-      topologyBasis: 'single-node' | 'worker-hosts';
+      /**
+       * 'single-node': one host, one chassis. 'worker-hosts': one chassis per
+       * measured worker, each at its own telemetry. 'uniform-hosts': an
+       * aggregate multinode deployment whose producer emitted no per-worker
+       * telemetry; every eight-GPU chassis is modeled at the deployment mean.
+       */
+      topologyBasis: 'single-node' | 'worker-hosts' | 'uniform-hosts';
       /**
        * 'full': every chassis had all eight GPUs measured. 'extrapolated': at least
        * one chassis was partially allocated; its model input is the measured per-GPU
@@ -138,7 +144,7 @@ export function modelSystemPower(
   }
 
   const chassis: MeasuredChassis[] = [];
-  let topologyBasis: 'single-node' | 'worker-hosts';
+  let topologyBasis: 'single-node' | 'worker-hosts' | 'uniform-hosts';
   if (row.disagg === false && row.is_multinode === false) {
     // One host cannot hold more than one chassis.
     if (gpuCount > CHASSIS_GPU_COUNT) return unavailable('topology');
@@ -173,6 +179,36 @@ export function modelSystemPower(
           ? m.avg_total_gpu_power_w
           : m.avg_power_w * CHASSIS_GPU_COUNT,
     });
+  } else if (row.disagg === false && (!Array.isArray(row.workers) || row.workers.length === 0)) {
+    // Aggregate multinode producers emit no per-worker telemetry. Symmetric
+    // TP/PP/DP shards load every host alike, so each full eight-GPU chassis is
+    // modeled at the deployment mean; the supported hardware only ships in
+    // eight-GPU hosts, so the count must fill whole chassis on several hosts.
+    // Disaggregated roles differ in load and stay on the worker path.
+    const hostCount = gpuCount / CHASSIS_GPU_COUNT;
+    if (!count(hostCount) || hostCount < 2) return unavailable('topology');
+    const tp = row.decode_tp > 0 ? row.decode_tp : row.prefill_tp;
+    const pp = Math.max(m.pp ?? 1, m.decode_pp ?? 1, m.prefill_pp ?? 1);
+    const pcp = Math.max(m.pcp_size ?? 1, m.decode_pcp_size ?? 1, m.prefill_pcp_size ?? 1);
+    // Data-parallel replicas widen the deployment beyond one TP×PP×PCP group.
+    const replicas = Math.max(1, row.decode_num_workers);
+    if (
+      !count(tp) ||
+      !count(pp) ||
+      !count(pcp) ||
+      !count(replicas) ||
+      tp * pp * pcp * replicas !== gpuCount
+    ) {
+      return unavailable('gpu-count');
+    }
+    topologyBasis = 'uniform-hosts';
+    for (let host = 0; host < hostCount; host++) {
+      chassis.push({
+        measuredGpus: CHASSIS_GPU_COUNT,
+        // Partition the producer's exact total so the chassis inputs sum back to it.
+        modelInputWatts: m.avg_total_gpu_power_w / hostCount,
+      });
+    }
   } else {
     // A role average across several hosts is insufficient for nonlinear
     // fan/PSU evaluation. Require one chassis per measured worker and a

From 9ee4301545b4893202b008f440c8001f87e663d3 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 18 Sep 2026 18:06:31 -0700
Subject: [PATCH 012/103] feat: ingest multinode power_audit telemetry as
 per-host series
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Multinode InferenceX jobs upload no `gpu_metrics_` artifact; their per-GPU
1 Hz power lives in `power_audit_<suffix>/LOGS/power/samples.csv`, one
deployment-wide CSV from srt-slurm's `dcgm-power` collector. Every Kimi K3
NVIDIA point therefore had an empty PowerX tab while the data sat in GitHub.

Accept the bundle as a fallback telemetry artifact: `gpuMetricsArtifactSuffix`
recognises `power_audit_`, discovery (CI ingest) and backfill pairing prefer a
`gpu_metrics_` sibling and use the bundle only when none exists, and
`prepareGpuMetricsArtifact` regroups `samples.csv` by hostname into one
power-only series per host (`file_name` `LOGS/power/samples.csv#<host>`,
manifest as context sidecar, GPU UUIDs as identity).

Power-only series made a latent reader defect visible: `toSampleRow` coerced
null clocks, temperature and utilization to 0, so the UI offered and plotted
fabricated flat-zero metrics. The five non-power core fields are now optional
end to end (reader, `GpuMetricRow`, anomaly checks, chart and correlation
points, tooltip, correlation default). The PowerX tab labels the collector
from the recorded producer instead of `nvidia-smi`, and takes the point's
hardware key for the TDP line because multinode artifact names are
hash-truncated. Docs record the adapter.

Backfilled into the branch DB: K3 B200 34674595026 (7 points, 14 series),
GB300 34873998796 (5 of 11; the six disaggregated jobs report
`multinode_power_contract_missing`), H200 34744300699 (10 points, 40 series).
Not covered here: the explorer's live GitHub fallback for not-yet-ingested
runs still reads `gpu_metrics_` only.

中文：多节点 InferenceX 任务不上传 `gpu_metrics_` artifact，每 GPU 1 Hz 功耗数据
在 `power_audit_<suffix>/LOGS/power/samples.csv`（srt-slurm `dcgm-power` 采集，
整个部署一个 CSV）里，Kimi K3 NVIDIA 数据点的 PowerX 标签页因此一直为空。
本次将该 bundle 作为回退 telemetry artifact：suffix 识别 `power_audit_`，
CI 入库发现与 backfill 配对优先使用 `gpu_metrics_`，仅在没有时使用 bundle；
`prepareGpuMetricsArtifact` 按 hostname 拆成每主机一条仅含功耗的序列。
同时修正读取端把空的时钟/温度/利用率读成 0 的问题（五个字段全链路改为可选），
PowerX 标签页的 Collector 改为显示真实采集器，TDP 参考线改用数据点的硬件 key。
已回填 branch DB：K3 B200、GB300（5/11，disagg 任务无功耗合约）、H200。
未覆盖：explorer 对未入库 run 的 GitHub 实时回退仍只读 `gpu_metrics_`。
---
 docs/data-pipeline.md                         |  12 +-
 .../gpu-power/GpuCorrelationChart.tsx         |   7 +-
 .../components/gpu-power/GpuPowerChart.tsx    |  30 ++++-
 .../components/gpu-power/GpuPowerDisplay.tsx  |  13 +-
 .../src/components/gpu-power/types.test.ts    |  44 +++++++
 .../app/src/components/gpu-power/types.ts     |  32 +++--
 .../agentic-point/agentic-point-detail.tsx    |   2 +-
 .../power-telemetry-view.test.ts              |  26 ++++
 .../agentic-point/power-telemetry-view.tsx    |  21 +++-
 .../db/src/etl/gpu-metrics-artifacts.test.ts  |  35 ++++++
 packages/db/src/etl/gpu-metrics-artifacts.ts  |  72 +++++++++--
 .../db/src/etl/gpu-metrics-ingest.test.ts     | 110 +++++++++++++++++
 packages/db/src/etl/gpu-metrics-ingest.ts     |  54 ++++++++-
 .../src/etl/multinode-power-samples.test.ts   |  85 +++++++++++++
 .../db/src/etl/multinode-power-samples.ts     | 114 ++++++++++++++++++
 packages/db/src/ingest-ci-run.ts              |   7 +-
 .../db/src/lib/gpu-metrics-backfill.test.ts   |  17 +++
 packages/db/src/lib/gpu-metrics-backfill.ts   |  15 ++-
 packages/db/src/queries/gpu-metrics.test.ts   |  21 ++--
 packages/db/src/queries/gpu-metrics.ts        |  25 ++--
 20 files changed, 678 insertions(+), 64 deletions(-)
 create mode 100644 packages/app/src/components/inference/agentic-point/power-telemetry-view.test.ts
 create mode 100644 packages/db/src/etl/multinode-power-samples.test.ts
 create mode 100644 packages/db/src/etl/multinode-power-samples.ts

diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index eaee38601..cf005cd11 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -529,9 +529,15 @@ Every single-node benchmark job (`benchmark-tmpl.yml`) samples `nvidia-smi` /
 `amd-smi` once per second for its whole lifetime and uploads the CSV as
 `gpu_metrics_<suffix>` next to `bmk_<suffix>` (agentic jobs: `bmk_agentic_<suffix>`,
 still paired by the bare suffix). The multinode template uploads no `gpu_metrics_`
-artifact — its telemetry travels only inside `power_audit_` — so multinode and
-disaggregated points have no series here and their per-point PowerX tab stays
-empty. The PowerX explorer used to download and parse the artifacts from GitHub
+artifact; its telemetry travels inside `power_audit_<suffix>` as
+`LOGS/power/samples.csv`, one deployment-wide CSV written by srt-slurm's
+`dcgm-power` collector (`timestamp_unix, hostname, gpu_index, gpu_uuid, power_w`,
+power only). `etl/multinode-power-samples.ts` regroups it per host and the ingest
+stores one series per host (`file_name` = `LOGS/power/samples.csv#<hostname>`),
+so multinode and disaggregated points get per-GPU power curves with null clocks,
+temperature and utilization. Single-node jobs upload a `power_audit_` bundle too,
+so discovery and backfill pairing use it only for a suffix with no `gpu_metrics_`
+upload. The PowerX explorer used to download and parse the artifacts from GitHub
 on every request and lost them after GitHub's 90-day retention. CI ingest now
 digests them at ingest time, in the same step that links server logs:
 
diff --git a/packages/app/src/components/gpu-power/GpuCorrelationChart.tsx b/packages/app/src/components/gpu-power/GpuCorrelationChart.tsx
index 40b12b88e..fd8530eaf 100644
--- a/packages/app/src/components/gpu-power/GpuCorrelationChart.tsx
+++ b/packages/app/src/components/gpu-power/GpuCorrelationChart.tsx
@@ -68,7 +68,12 @@ const GpuCorrelationChart = React.memo(
       () =>
         data
           .filter((r) => visibleGpus.has(r.index))
-          .map((r) => ({ x: r[xMetric] ?? 0, y: r[yMetric] ?? 0, gpuIndex: r.index, raw: r })),
+          // Rows missing either metric were never sampled for it; skip them.
+          .flatMap((r) => {
+            const x = r[xMetric];
+            const y = r[yMetric];
+            return x === undefined || y === undefined ? [] : [{ x, y, gpuIndex: r.index, raw: r }];
+          }),
       [data, visibleGpus, xMetric, yMetric],
     );
 
diff --git a/packages/app/src/components/gpu-power/GpuPowerChart.tsx b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
index bcfe74e72..addb25953 100644
--- a/packages/app/src/components/gpu-power/GpuPowerChart.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
@@ -21,6 +21,7 @@ import {
   type GpuMetricRow,
   ALL_METRIC_OPTIONS,
   detectTdpFromArtifactName,
+  tdpForHardware,
   getGpuMetricLabel,
   getGpuMetricYAxisLabel,
 } from './types';
@@ -84,6 +85,12 @@ interface GpuMetricsChartProps {
   visibleGpus: Set<number>;
   metricKey: GpuMetricKey;
   artifactName: string;
+  /**
+   * Hardware key of the benchmark point (`b200`, `h200`, …). Multinode bundle
+   * names are hash-truncated and carry no SKU token, so callers that know the
+   * point pass it explicitly; the artifact-name sniff stays the fallback.
+   */
+  hardware?: string;
   legendElement?: React.ReactNode;
   caption?: React.ReactNode;
   /** Max interactive points before LTTB downsampling. Infinity to disable. */
@@ -123,11 +130,14 @@ function buildGroupedData(
 
   const groups = new Map<number, ParsedPoint[]>();
   for (const { row, ms } of parsed) {
+    const value = row[metricKey];
+    // A metric the collector never sampled has no point, not a zero.
+    if (value === undefined) continue;
     if (!groups.has(row.index)) groups.set(row.index, []);
     groups.get(row.index)!.push({
       seconds: (ms - minTime) / 1000,
       ms,
-      value: row[metricKey] ?? 0,
+      value,
       gpuIndex: row.index,
       raw: row,
     });
@@ -257,6 +267,7 @@ const GpuMetricsChart = React.memo(
     visibleGpus,
     metricKey,
     artifactName,
+    hardware,
     legendElement,
     caption,
     maxPoints,
@@ -367,7 +378,10 @@ const GpuMetricsChart = React.memo(
       return ext;
     }, [allPoints]);
 
-    const tdpInfo = metricKey === 'power' ? detectTdpFromArtifactName(artifactName) : null;
+    const tdpInfo =
+      metricKey === 'power'
+        ? (tdpForHardware(hardware) ?? detectTdpFromArtifactName(artifactName))
+        : null;
 
     const yDomain = useMemo(() => {
       if (allPoints.length === 0) return [0, 100] as [number, number];
@@ -510,9 +524,15 @@ const GpuMetricsChart = React.memo(
               ${rolling ? `<div class="text-muted-foreground">${t.rollingSuffix(display.windowS)}</div>` : ''}
               ${
                 d.raw
-                  ? `<div class="text-muted-foreground">${t.power}${sep} ${d.raw.power.toFixed(1)} W</div>
-              <div class="text-muted-foreground">${t.temp}${sep} ${d.raw.temperature}\u00B0C</div>
-              <div class="text-muted-foreground">${t.utilization}${sep} ${d.raw.gpuUtil}%</div>`
+                  ? `<div class="text-muted-foreground">${t.power}${sep} ${d.raw.power.toFixed(1)} W</div>${
+                      d.raw.temperature === undefined
+                        ? ''
+                        : `<div class="text-muted-foreground">${t.temp}${sep} ${d.raw.temperature}\u00B0C</div>`
+                    }${
+                      d.raw.gpuUtil === undefined
+                        ? ''
+                        : `<div class="text-muted-foreground">${t.utilization}${sep} ${d.raw.gpuUtil}%</div>`
+                    }`
                   : ''
               }
               ${overlayRow}
diff --git a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
index 544795ed7..c5e5d4d77 100644
--- a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
@@ -241,6 +241,15 @@ export default function GpuMetricsDisplay() {
   const [chartView, setChartView] = useState<GpuMetricsView>('chart');
   const [corrXMetric, setCorrXMetric] = useState<GpuMetricKey>('power');
   const [corrYMetric, setCorrYMetric] = useState<GpuMetricKey>('temperature');
+  // A power-only series (multinode DCGM bundle) has no temperature axis to
+  // default to; use the first other collected metric instead of an empty plot.
+  const effectiveCorrYMetric = useMemo<GpuMetricKey>(
+    () =>
+      availableMetrics.some((m) => m.key === corrYMetric)
+        ? corrYMetric
+        : (availableMetrics.find((m) => m.key !== corrXMetric)?.key ?? corrXMetric),
+    [availableMetrics, corrXMetric, corrYMetric],
+  );
   const [display, setDisplay] = useState<TelemetryDisplayState>(DEFAULT_TELEMETRY_DISPLAY);
   const viewOptions = useMemo<SegmentedToggleOption<GpuMetricsView>[]>(
     () => [
@@ -613,7 +622,7 @@ export default function GpuMetricsDisplay() {
                   <div className="space-y-1 min-w-0">
                     <Label htmlFor="gpu-metrics-correlation-y">{t.yAxis}</Label>
                     <Select
-                      value={corrYMetric}
+                      value={effectiveCorrYMetric}
                       onValueChange={(v) => handleCorrelationMetricChange('y', v)}
                     >
                       <SelectTrigger id="gpu-metrics-correlation-y" className="w-full">
@@ -708,7 +717,7 @@ export default function GpuMetricsDisplay() {
                 data={currentData}
                 visibleGpus={visibleGpus}
                 xMetric={corrXMetric}
-                yMetric={corrYMetric}
+                yMetric={effectiveCorrYMetric}
                 maxPoints={downsample ? 2000 : Infinity}
                 caption={
                   <>
diff --git a/packages/app/src/components/gpu-power/types.test.ts b/packages/app/src/components/gpu-power/types.test.ts
index cefd8d6ef..2886fdd30 100644
--- a/packages/app/src/components/gpu-power/types.test.ts
+++ b/packages/app/src/components/gpu-power/types.test.ts
@@ -6,6 +6,7 @@ import {
   detectAnomalies,
   detectTdpFromArtifactName,
   getAvailableMetrics,
+  tdpForHardware,
   type GpuMetricRow,
   GPU_METRIC_OPTIONS,
   parseCsvData,
@@ -715,3 +716,46 @@ describe('GPU_METRIC_OPTIONS', () => {
     }
   });
 });
+
+describe('tdpForHardware', () => {
+  it('resolves a benchmark point hardware key regardless of artifact naming', () => {
+    expect(tdpForHardware('b200')).toEqual({
+      sku: 'B200',
+      tdp: detectTdpFromArtifactName('gpu_metrics_x_b200-nb_0')!.tdp,
+    });
+    expect(tdpForHardware('GB300')?.sku).toBe('GB300');
+    expect(tdpForHardware(undefined)).toBeNull();
+    expect(tdpForHardware('not-a-sku')).toBeNull();
+  });
+});
+
+/** A multinode DCGM bundle row: power sampled, nothing else collected. */
+const powerOnly = (index: number, power: number) => ({
+  timestamp: '2026-09-12T22:08:20Z',
+  index,
+  power,
+});
+
+describe('power-only rows', () => {
+  it('offers only the metrics the collector sampled', () => {
+    expect(getAvailableMetrics([powerOnly(0, 700), powerOnly(1, 710)]).map((m) => m.key)).toEqual([
+      'power',
+    ]);
+  });
+
+  it('raises no thermal, clock, or utilization anomalies from absent readings', () => {
+    const rows = Array.from({ length: 40 }, (_, i) => ({
+      ...powerOnly(0, 700 + (i % 2)),
+      timestamp: new Date(1789194365292 + i * 1000).toISOString(),
+    }));
+    expect(
+      detectAnomalies(rows, 'power', 'power_audit_kimik3_conc48').map((a) => a.type),
+    ).not.toContain('thermal');
+    expect(
+      detectAnomalies(rows, 'power', 'power_audit_kimik3_conc48').map((a) => a.type),
+    ).not.toContain('clock_drop');
+    expect(
+      detectAnomalies(rows, 'power', 'power_audit_kimik3_conc48').map((a) => a.type),
+    ).not.toContain('util_drop');
+  });
+});
diff --git a/packages/app/src/components/gpu-power/types.ts b/packages/app/src/components/gpu-power/types.ts
index 814eb2bb5..ce6e3c5a0 100644
--- a/packages/app/src/components/gpu-power/types.ts
+++ b/packages/app/src/components/gpu-power/types.ts
@@ -4,11 +4,13 @@ export interface GpuMetricRow {
   timestamp: string;
   index: number;
   power: number;
-  temperature: number;
-  smClock: number;
-  memClock: number;
-  gpuUtil: number;
-  memUtil: number;
+  // Absent when the collector did not sample the metric (multinode DCGM
+  // bundles are power-only); a missing value is never plotted as 0.
+  temperature?: number;
+  smClock?: number;
+  memClock?: number;
+  gpuUtil?: number;
+  memUtil?: number;
   // AMD-specific optional fields
   edgeTemp?: number;
   memTemp?: number;
@@ -210,6 +212,13 @@ export function getAvailableMetrics(data: GpuMetricRow[]): GpuMetricConfig[] {
  * Detect GPU SKU from an artifact name and return its TDP in watts.
  * Artifact names look like: gpu_metrics_dsr1_1k8k_fp8_sglang_tp8_..._h200-nb_0
  */
+/** TDP for a known hardware key, e.g. the benchmark point's own `hardware`. */
+export function tdpForHardware(hardware: string | undefined): { sku: string; tdp: number } | null {
+  const key = hardware?.toLowerCase();
+  const entry = key ? HW_REGISTRY[key] : undefined;
+  return entry ? { sku: key!.toUpperCase(), tdp: entry.tdp } : null;
+}
+
 export function detectTdpFromArtifactName(
   artifactName: string,
 ): { sku: string; tdp: number } | null {
@@ -288,8 +297,11 @@ export function detectAnomalies(
     const mad = median(absDeviations);
 
     // Pre-compute SM clock median for clock_drop detection (avoid O(n^2))
+    const smClocks = rows.map((r) => r.smClock).filter((v): v is number => v !== undefined);
     const smMedian =
-      metricKey === 'smClock' || metricKey === 'power' ? median(rows.map((r) => r.smClock)) : 0;
+      (metricKey === 'smClock' || metricKey === 'power') && smClocks.length > 0
+        ? median(smClocks)
+        : 0;
 
     for (let i = 0; i < rows.length; i++) {
       const row = rows[i];
@@ -312,7 +324,7 @@ export function detectAnomalies(
       }
 
       // Domain-specific: thermal throttle (temperature > 83°C)
-      if (row.temperature > 83) {
+      if (row.temperature !== undefined && row.temperature > 83) {
         anomalies.push({
           type: 'thermal',
           label: 'Thermal Throttle',
@@ -339,6 +351,7 @@ export function detectAnomalies(
       if (
         (metricKey === 'smClock' || metricKey === 'power') &&
         smMedian > 0 &&
+        row.smClock !== undefined &&
         row.smClock < smMedian * 0.7
       ) {
         anomalies.push({
@@ -352,14 +365,15 @@ export function detectAnomalies(
       }
 
       // Domain-specific: utilization drop (GPU util = 0 after being > 50%)
-      if (row.gpuUtil === 0 && i > 0 && rows[i - 1].gpuUtil > 50) {
+      const previousUtil = i > 0 ? rows[i - 1].gpuUtil : undefined;
+      if (row.gpuUtil === 0 && previousUtil !== undefined && previousUtil > 50) {
         anomalies.push({
           type: 'util_drop',
           label: 'Utilization Drop',
           gpuIndex,
           seconds,
           value: 0,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: utilization dropped to 0% (was ${rows[i - 1].gpuUtil}%)`,
+          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: utilization dropped to 0% (was ${previousUtil}%)`,
         });
       }
     }
diff --git a/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx b/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx
index f78e3b2af..f53d51dce 100644
--- a/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx
+++ b/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx
@@ -352,7 +352,7 @@ export function AgenticPointDetail({ id }: Props) {
       {view === 'logs' ? (
         <ServerLogViewer id={id} enabled />
       ) : view === 'power' ? (
-        <PowerTelemetryView id={id} enabled />
+        <PowerTelemetryView id={id} enabled hardware={siblingsData?.sku.hardware} />
       ) : view === 'aggregates' ? (
         aggregatesQuery.isError ? (
           <RetryableQueryError
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.test.ts b/packages/app/src/components/inference/agentic-point/power-telemetry-view.test.ts
new file mode 100644
index 000000000..3fb14973f
--- /dev/null
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+
+import { collectorLabel } from './power-telemetry-view';
+
+describe('collectorLabel', () => {
+  it('names the recorded producer for multinode power bundles', () => {
+    expect(
+      collectorLabel({
+        vendor: 'nvidia',
+        sidecars: {
+          context: { producer: 'srt-slurm.dcgm-power', source_metric: 'DCGM_FI_DEV_POWER_USAGE' },
+        },
+      }),
+    ).toBe('srt-slurm.dcgm-power');
+  });
+
+  it('falls back to the vendor CLI for single-node CSVs', () => {
+    expect(
+      collectorLabel({ vendor: 'nvidia', sidecars: { context: { timestamp_timezone: 'UTC' } } }),
+    ).toBe('nvidia-smi');
+    expect(collectorLabel({ vendor: 'amd', sidecars: {} })).toBe('amd-smi');
+    expect(collectorLabel({ vendor: 'other', sidecars: { context: { producer: '  ' } } })).toBe(
+      'other',
+    );
+  });
+});
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
index 967ca41e9..a2c437f72 100644
--- a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -95,11 +95,25 @@ const STRINGS = {
 } as const;
 
 const VENDOR_LABEL: Record<string, string> = { nvidia: 'nvidia-smi', amd: 'amd-smi' };
+
+/**
+ * Single-node CSVs come from the vendor CLI; multinode power bundles record
+ * their own producer (e.g. `srt-slurm.dcgm-power`) in the context sidecar.
+ */
+export function collectorLabel(series: Pick<GpuMetricSeries, 'vendor' | 'sidecars'>): string {
+  const context = series.sidecars?.context;
+  const producer =
+    context && typeof context === 'object' ? (context as { producer?: unknown }).producer : null;
+  if (typeof producer === 'string' && producer.trim() !== '') return producer;
+  return VENDOR_LABEL[series.vendor] ?? series.vendor;
+}
 /** Violet: outside the Tableau10 chip palette and the foreground mean line. */
 
 interface Props {
   id: number;
   enabled: boolean;
+  /** The point's hardware key, for the TDP reference line. */
+  hardware?: string;
 }
 
 function seriesLabel(series: GpuMetricSeries, total: number): string {
@@ -111,7 +125,7 @@ function seriesLabel(series: GpuMetricSeries, total: number): string {
  * recorded while this benchmark point ran, read from the ingest-time digest
  * (migration 016) rather than from GitHub artifacts.
  */
-export function PowerTelemetryView({ id, enabled }: Props) {
+export function PowerTelemetryView({ id, enabled, hardware }: Props) {
   const locale = useLocale();
   const t = STRINGS[locale];
   const query = useGpuMetricsPoint(id, enabled);
@@ -246,9 +260,7 @@ export function PowerTelemetryView({ id, enabled }: Props) {
         <dl className="mb-4 grid grid-cols-2 gap-x-4 gap-y-3 text-sm sm:grid-cols-3 lg:grid-cols-5">
           <div className="min-w-0">
             <dt className="text-xs text-muted-foreground">{t.vendor}</dt>
-            <dd className="font-medium">
-              {VENDOR_LABEL[selectedSeries.vendor] ?? selectedSeries.vendor}
-            </dd>
+            <dd className="font-medium">{collectorLabel(selectedSeries)}</dd>
           </div>
           <div className="min-w-0">
             <dt className="text-xs text-muted-foreground">{t.samples}</dt>
@@ -378,6 +390,7 @@ export function PowerTelemetryView({ id, enabled }: Props) {
           visibleGpus={visibleGpus}
           metricKey={metricKey}
           artifactName={selectedSeries.artifactName}
+          hardware={hardware}
           maxPoints={2000}
           display={display}
           overlay={overlay}
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.test.ts b/packages/db/src/etl/gpu-metrics-artifacts.test.ts
index f5efe03d4..877865568 100644
--- a/packages/db/src/etl/gpu-metrics-artifacts.test.ts
+++ b/packages/db/src/etl/gpu-metrics-artifacts.test.ts
@@ -9,6 +9,7 @@ import {
   discoverGpuMetricsArtifacts,
   gpuMetricsArtifactSuffix,
   listGpuMetricsCsvFiles,
+  listMultinodePowerSampleFiles,
   parseEnergyCsv,
   readGpuMetricsSidecars,
 } from './gpu-metrics-artifacts.js';
@@ -32,6 +33,21 @@ describe('gpu_metrics artifact discovery', () => {
     );
     expect(gpuMetricsArtifactSuffix('eval_gpu_metrics_dsr1_8k1k_conc1_b200-x_0')).toBeNull();
     expect(gpuMetricsArtifactSuffix('bmk_dsr1')).toBeNull();
+    expect(gpuMetricsArtifactSuffix('power_audit_kimik3_conc8_b200-slurm_0')).toBe(
+      'kimik3_conc8_b200-slurm_0',
+    );
+  });
+
+  it('lists the multinode power CSV but none of the bundle metadata', () => {
+    const root = tempRoot();
+    fs.mkdirSync(path.join(root, 'LOGS', 'power', 'windows'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'LOGS', 'power', 'samples.csv'), 'schema_version\n');
+    fs.writeFileSync(path.join(root, 'LOGS', 'power', 'manifest.json'), '{}');
+    fs.writeFileSync(path.join(root, 'agg_cfg_conc8.json'), '{}');
+    expect(listMultinodePowerSampleFiles(root).map((file) => file.fileName)).toEqual([
+      'LOGS/power/samples.csv',
+    ]);
+    expect(listGpuMetricsCsvFiles(root)).toEqual([]);
   });
 
   it('lists telemetry CSVs recursively but skips identity and energy sidecars', () => {
@@ -58,6 +74,25 @@ describe('gpu_metrics artifact discovery', () => {
     expect([...discovered.keys()]).toEqual(['cfg-a_runner_0']);
     expect(discovered.get('cfg-a_runner_0')?.artifactName).toBe('gpu_metrics_cfg-a_runner_0');
   });
+
+  it('uses the power_audit bundle only for suffixes without a gpu_metrics upload', () => {
+    const root = tempRoot();
+    for (const name of [
+      'power_audit_cfg-a_runner_0',
+      'gpu_metrics_cfg-a_runner_0',
+      'power_audit_cfg-mn_slurm_0',
+      'bmk_cfg-mn_slurm_0',
+    ]) {
+      fs.mkdirSync(path.join(root, name));
+    }
+    const discovered = discoverGpuMetricsArtifacts(root);
+    expect(
+      [...discovered.entries()].map(([suffix, artifact]) => [suffix, artifact.artifactName]),
+    ).toEqual([
+      ['cfg-a_runner_0', 'gpu_metrics_cfg-a_runner_0'],
+      ['cfg-mn_slurm_0', 'power_audit_cfg-mn_slurm_0'],
+    ]);
+  });
 });
 
 describe('sidecars', () => {
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.ts b/packages/db/src/etl/gpu-metrics-artifacts.ts
index 885c6f0af..07258b3eb 100644
--- a/packages/db/src/etl/gpu-metrics-artifacts.ts
+++ b/packages/db/src/etl/gpu-metrics-artifacts.ts
@@ -9,6 +9,13 @@
  *   gpu_metrics_identity.{json,csv}         SKU / UUID / driver per GPU
  *   gpu_metrics_energy_{start,end}.csv      amd-smi energy counters
  *
+ * Multinode jobs (`benchmark-multinode-tmpl.yml`) upload no `gpu_metrics_`
+ * artifact; their telemetry travels inside `power_audit_<suffix>`:
+ *   LOGS/power/samples.csv                  deployment-wide DCGM power, one row per (host, GPU, s)
+ *   LOGS/power/manifest.json                producer, source metric, cadence
+ * Single-node jobs upload a `power_audit_` bundle too, so it only stands in
+ * for a point when no `gpu_metrics_<suffix>` sibling exists.
+ *
  * `eval_gpu_metrics_<suffix>` (eval-only jobs) is deliberately ignored: those
  * jobs produce no benchmark point to attach the telemetry to.
  */
@@ -16,7 +23,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { isMultinodePowerSamplesPath } from './multinode-power-samples.js';
+
 export const GPU_METRICS_ARTIFACT_PREFIX = 'gpu_metrics_';
+export const POWER_AUDIT_ARTIFACT_PREFIX = 'power_audit_';
 
 export interface GpuMetricsArtifact {
   artifactName: string;
@@ -36,11 +46,17 @@ export interface GpuMetricsSidecars {
   energyEnd: Record<string, number> | null;
 }
 
-/** Return the shared suffix that pairs a gpu_metrics artifact with bmk[_agentic]_<suffix>. */
+/** Return the shared suffix that pairs a telemetry artifact with bmk[_agentic]_<suffix>. */
 export function gpuMetricsArtifactSuffix(artifactName: string): string | null {
-  return artifactName.startsWith(GPU_METRICS_ARTIFACT_PREFIX)
-    ? artifactName.slice(GPU_METRICS_ARTIFACT_PREFIX.length)
-    : null;
+  for (const prefix of [GPU_METRICS_ARTIFACT_PREFIX, POWER_AUDIT_ARTIFACT_PREFIX]) {
+    if (artifactName.startsWith(prefix)) return artifactName.slice(prefix.length);
+  }
+  return null;
+}
+
+/** The nvidia-smi/amd-smi CSV carries clocks, utilization and temperature; the power bundle only power. */
+export function isPowerAuditArtifact(artifactName: string): boolean {
+  return artifactName.startsWith(POWER_AUDIT_ARTIFACT_PREFIX);
 }
 
 function isGpuMetricsCsvName(fileName: string): boolean {
@@ -70,6 +86,32 @@ export function listGpuMetricsCsvFiles(root: string): GpuMetricsCsvFile[] {
   return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
 }
 
+/** Every multinode power CSV under an extracted `power_audit_` root. */
+export function listMultinodePowerSampleFiles(root: string): GpuMetricsCsvFile[] {
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return [];
+  const files: GpuMetricsCsvFile[] = [];
+  const visit = (directory: string): void => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const pathname = path.join(directory, entry.name);
+      if (entry.isDirectory()) visit(pathname);
+      else if (entry.isFile()) {
+        const fileName = path.relative(root, pathname).split(path.sep).join('/');
+        if (isMultinodePowerSamplesPath(fileName)) files.push({ fileName, path: pathname });
+      }
+    }
+  };
+  visit(root);
+  return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
+}
+
+/** The producer manifest next to `samples.csv`; null when absent or malformed. */
+export function readMultinodePowerManifest(samplesPath: string): Record<string, unknown> | null {
+  const parsed = readJsonIfPresent(path.join(path.dirname(samplesPath), 'manifest.json'));
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+    ? (parsed as Record<string, unknown>)
+    : null;
+}
+
 function readJsonIfPresent(pathname: string): unknown | null {
   if (!fs.existsSync(pathname)) return null;
   try {
@@ -158,16 +200,24 @@ export function contextUtcOffsetMinutes(context: Record<string, unknown> | null)
   return match.groups.sign === '-' ? -minutes : minutes;
 }
 
-/** Index every extracted gpu_metrics artifact by its shared suffix. */
+/**
+ * Index every extracted telemetry artifact by its shared suffix. A
+ * `gpu_metrics_` upload wins over the `power_audit_` bundle for the same
+ * suffix; the bundle only fills in for multinode jobs that have no other.
+ */
 export function discoverGpuMetricsArtifacts(artifactsDir: string): Map<string, GpuMetricsArtifact> {
   const discovered = new Map<string, GpuMetricsArtifact>();
   if (!fs.existsSync(artifactsDir)) return discovered;
-  for (const artifactName of fs.readdirSync(artifactsDir)) {
-    const suffix = gpuMetricsArtifactSuffix(artifactName);
-    if (!suffix) continue;
-    const artifactDir = path.join(artifactsDir, artifactName);
-    if (!fs.statSync(artifactDir).isDirectory()) continue;
-    discovered.set(suffix, { artifactName, artifactDir });
+  const names = fs
+    .readdirSync(artifactsDir)
+    .filter((artifactName) => fs.statSync(path.join(artifactsDir, artifactName)).isDirectory());
+  for (const preferred of [false, true]) {
+    for (const artifactName of names) {
+      if (isPowerAuditArtifact(artifactName) !== preferred) continue;
+      const suffix = gpuMetricsArtifactSuffix(artifactName);
+      if (!suffix || discovered.has(suffix)) continue;
+      discovered.set(suffix, { artifactName, artifactDir: path.join(artifactsDir, artifactName) });
+    }
   }
   return discovered;
 }
diff --git a/packages/db/src/etl/gpu-metrics-ingest.test.ts b/packages/db/src/etl/gpu-metrics-ingest.test.ts
index c1d135aa5..604cafb18 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.test.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.test.ts
@@ -84,7 +84,77 @@ function writeArtifact(csv: string, contextZone = 'UTC') {
   return { artifactName, artifactDir };
 }
 
+// Multinode bundle: two hosts × two GPUs × two scrapes, host-local indices.
+const MULTINODE_POWER_CSV = [
+  'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+  '1,1789194365.292,4,host-b,0,GPU-b0,401.5',
+  '1,1789194365.292,4,host-a,0,GPU-a0,186.656',
+  '1,1789194365.292,4,host-a,1,GPU-a1,190.1',
+  '1,1789194366.292,5,host-a,0,GPU-a0,700.25',
+  '1,1789194366.292,5,host-a,1,GPU-a1,702.0',
+  '1,1789194366.292,5,host-b,0,GPU-b0,650.0',
+  '1,1789194366.292,5,host-b,1,GPU-b1,655.0',
+].join('\n');
+const MULTINODE_MANIFEST = {
+  schema_version: 1,
+  producer: 'srt-slurm.dcgm-power',
+  source_metric: 'DCGM_FI_DEV_POWER_USAGE',
+  sample_interval_seconds: 1,
+};
+
+function writePowerAuditArtifact(options: { withGpuMetricsCsv?: boolean } = {}) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-ingest-'));
+  roots.push(root);
+  const artifactName = 'power_audit_kimik3_conc8_fp4_dynamo-vllm_b200-slurm_0';
+  const artifactDir = path.join(root, artifactName);
+  fs.mkdirSync(path.join(artifactDir, 'LOGS', 'power'), { recursive: true });
+  fs.writeFileSync(path.join(artifactDir, 'LOGS', 'power', 'samples.csv'), MULTINODE_POWER_CSV);
+  fs.writeFileSync(
+    path.join(artifactDir, 'LOGS', 'power', 'manifest.json'),
+    JSON.stringify(MULTINODE_MANIFEST),
+  );
+  fs.writeFileSync(path.join(artifactDir, 'agg_kimik3_conc8.json'), '{}');
+  if (options.withGpuMetricsCsv) {
+    fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), NVIDIA_CSV);
+  }
+  return { artifactName, artifactDir };
+}
+
 describe('prepareGpuMetricsArtifact', () => {
+  it('falls back to the multinode power bundle, one power-only series per host', () => {
+    const prepared = prepareGpuMetricsArtifact(writePowerAuditArtifact());
+    expect(prepared.map((series) => series.fileName)).toEqual([
+      'LOGS/power/samples.csv#host-a',
+      'LOGS/power/samples.csv#host-b',
+    ]);
+    const [hostA, hostB] = prepared;
+    expect(hostA!.vendor).toBe('nvidia');
+    expect(hostA!.gpuCount).toBe(2);
+    expect(hostA!.samples).toHaveLength(4);
+    expect(hostA!.startedAtMs).toBe(1789194365292);
+    expect(hostA!.endedAtMs).toBe(1789194366292);
+    expect(hostA!.sampleIntervalS).toBe(1);
+    // One deployment-wide CSV: both host series share its hash.
+    expect(hostB!.csvSha256).toBe(hostA!.csvSha256);
+    // Only power was scraped; no zero-filled clock/temperature/utilization digests.
+    expect(new Set(hostA!.stats.map((s) => s.metric))).toEqual(new Set(['powerW']));
+    expect(hostA!.stats.find((s) => s.gpuIndex === 1)?.max).toBe(702);
+    expect(hostA!.sidecars.context).toEqual(MULTINODE_MANIFEST);
+    expect(hostA!.sidecars.identity).toEqual([
+      { hostname: 'host-a', gpu_index: 0, gpu_uuid: 'GPU-a0' },
+      { hostname: 'host-a', gpu_index: 1, gpu_uuid: 'GPU-a1' },
+    ]);
+    expect(hostA!.sidecars.energyStart).toBeNull();
+  });
+
+  it('prefers an nvidia-smi CSV in the same bundle over the power-only samples', () => {
+    // Single-node jobs upload gpu_metrics.csv inside power_audit_ as well.
+    const prepared = prepareGpuMetricsArtifact(
+      writePowerAuditArtifact({ withGpuMetricsCsv: true }),
+    );
+    expect(prepared.map((series) => series.fileName)).toEqual(['gpu_metrics.csv']);
+  });
+
   it('parses each CSV with its sidecars and digest', () => {
     const [series] = prepareGpuMetricsArtifact(writeArtifact(NVIDIA_CSV));
     expect(series?.fileName).toBe('gpu_metrics.csv');
@@ -169,6 +239,46 @@ describe('ingestGpuMetricsArtifact', () => {
     expect(count!.n).toBe(4);
   });
 
+  it('stores every host of a multinode power bundle under the bare config key', async () => {
+    const artifact = writePowerAuditArtifact();
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(first.seriesIds).toHaveLength(2);
+    expect(first.samplesInserted).toBe(7);
+
+    const series = await sql<{ config_key: string; file_name: string; gpu_count: number }[]>`
+      select config_key, file_name, gpu_count from gpu_metric_series order by file_name`;
+    expect(series).toEqual([
+      {
+        config_key: 'kimik3_conc8_fp4_dynamo-vllm_b200-slurm_0',
+        file_name: 'LOGS/power/samples.csv#host-a',
+        gpu_count: 2,
+      },
+      {
+        config_key: 'kimik3_conc8_fp4_dynamo-vllm_b200-slurm_0',
+        file_name: 'LOGS/power/samples.csv#host-b',
+        gpu_count: 2,
+      },
+    ]);
+    const metrics = await sql<{ metric: string }[]>`
+      select distinct metric from gpu_metric_gpu_stats`;
+    expect(metrics.map((m) => m.metric)).toEqual(['power_w']);
+    const links = await sql<{ n: number }[]>`
+      select count(*)::int as n from benchmark_result_gpu_metrics where benchmark_result_id = 10`;
+    expect(links[0]!.n).toBe(2);
+
+    const rerun = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(rerun.samplesInserted).toBe(0);
+    expect(rerun.seriesSkipped).toBe(2);
+  });
+
   it('replaces samples and digest when the CSV content changes', async () => {
     const artifact = writeArtifact(NVIDIA_CSV);
     await ingestGpuMetricsArtifact(sql, { workflowRunId: 1, artifact, benchmarkResultIds: [10] });
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
index dc68d0e74..11202879c 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -29,10 +29,13 @@ import {
   contextUtcOffsetMinutes,
   gpuMetricsArtifactSuffix,
   listGpuMetricsCsvFiles,
+  listMultinodePowerSampleFiles,
   readGpuMetricsSidecars,
+  readMultinodePowerManifest,
   type GpuMetricsArtifact,
   type GpuMetricsSidecars,
 } from './gpu-metrics-artifacts.js';
+import { multinodePowerVendor, parseMultinodePowerSamples } from './multinode-power-samples.js';
 
 /** Samples are streamed to Postgres in unnest batches of this many rows. */
 const SAMPLE_BATCH_SIZE = 5000;
@@ -56,7 +59,54 @@ export interface GpuMetricsIngestResult {
   seriesSkipped: number;
 }
 
-/** Parse every CSV in an extracted artifact; unparseable files are skipped. */
+/**
+ * One series per host from the multinode power bundle. The deployment-wide
+ * CSV is hashed once, so every host series of one upload shares its sha and
+ * re-ingests stay no-ops together. The `#<hostname>` fragment keeps the
+ * (run, artifact, file) identity unique per host.
+ */
+function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
+  const prepared: PreparedGpuMetricSeries[] = [];
+  for (const file of listMultinodePowerSampleFiles(artifact.artifactDir)) {
+    const csvText = fs.readFileSync(file.path, 'utf8');
+    const hosts = parseMultinodePowerSamples(csvText);
+    if (!hosts) continue;
+    const manifest = readMultinodePowerManifest(file.path);
+    const vendor = multinodePowerVendor(manifest);
+    const csvSha256 = createHash('sha256').update(csvText).digest('hex');
+    for (const host of hosts) {
+      const summary = summarizeGpuMetricSamples(host.samples);
+      if (!summary) continue;
+      prepared.push({
+        fileName: `${file.fileName}#${host.hostname}`,
+        vendor,
+        csvSha256,
+        samples: host.samples,
+        stats: computeGpuMetricStats(host.samples),
+        sampleIntervalS: summary.sampleIntervalS,
+        gpuCount: summary.gpuCount,
+        startedAtMs: summary.startedAtMs,
+        endedAtMs: summary.endedAtMs,
+        sidecars: {
+          context: manifest,
+          identity: Object.entries(host.gpuUuids).map(([index, uuid]) => ({
+            hostname: host.hostname,
+            gpu_index: Number(index),
+            gpu_uuid: uuid,
+          })),
+          energyStart: null,
+          energyEnd: null,
+        },
+      });
+    }
+  }
+  return prepared;
+}
+
+/**
+ * Parse every CSV in an extracted artifact; unparseable files are skipped.
+ * Without any nvidia-smi/amd-smi CSV, fall back to the multinode power bundle.
+ */
 export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
   const prepared: PreparedGpuMetricSeries[] = [];
   for (const file of listGpuMetricsCsvFiles(artifact.artifactDir)) {
@@ -81,7 +131,7 @@ export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): Prepare
       sidecars,
     });
   }
-  return prepared;
+  return prepared.length > 0 ? prepared : prepareMultinodePowerSeries(artifact);
 }
 
 const STAT_METRIC_COLUMN: Record<GpuMetricStats['metric'], string> = {
diff --git a/packages/db/src/etl/multinode-power-samples.test.ts b/packages/db/src/etl/multinode-power-samples.test.ts
new file mode 100644
index 000000000..3ec8b5024
--- /dev/null
+++ b/packages/db/src/etl/multinode-power-samples.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  isMultinodePowerSamplesPath,
+  multinodePowerVendor,
+  parseMultinodePowerSamples,
+} from './multinode-power-samples.js';
+
+// Shape of run 34674595026's LOGS/power/samples.csv (Kimi K3 B200, two hosts),
+// trimmed to two GPUs and two scrapes, with one malformed row of each kind.
+const CSV = [
+  'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+  '1,1789194365.2924976,4,im-b200-c002,0,GPU-c2-0,401.5',
+  '1,1789194365.2924976,4,im-b200-c001,0,GPU-c1-0,186.656',
+  '1,1789194365.2924976,4,im-b200-c001,1,GPU-c1-1,190.1',
+  '1,1789194366.29,5,im-b200-c001,0,GPU-c1-0,700.25',
+  '1,1789194366.29,5,im-b200-c001,1,GPU-c1-1,702.0',
+  '1,1789194366.29,5,im-b200-c002,0,GPU-c2-0,650.0',
+  '1,not-a-time,6,im-b200-c001,0,GPU-c1-0,1.0',
+  '1,1789194367.29,6,im-b200-c001,x,GPU-c1-0,1.0',
+  '1,1789194367.29,6,,0,GPU-c1-0,1.0',
+  '',
+].join('\n');
+
+describe('parseMultinodePowerSamples', () => {
+  it('regroups the deployment CSV into power-only samples per host, sorted by hostname', () => {
+    const hosts = parseMultinodePowerSamples(CSV);
+    expect(hosts?.map((host) => host.hostname)).toEqual(['im-b200-c001', 'im-b200-c002']);
+    const [c001, c002] = hosts!;
+    expect(c001.samples).toHaveLength(4);
+    expect(c002.samples).toHaveLength(2);
+    expect(c001.samples[0]).toEqual({
+      timestampMs: 1789194365292,
+      gpuIndex: 0,
+      powerW: 186.656,
+      temperatureC: null,
+      smClockMhz: null,
+      memClockMhz: null,
+      gpuUtilPct: null,
+      memUtilPct: null,
+      edgeTempC: null,
+      memTempC: null,
+      gfxVoltageMv: null,
+      socVoltageMv: null,
+      memVoltageMv: null,
+      fclkMhz: null,
+      socclkMhz: null,
+      mmActivityPct: null,
+    });
+    expect(c001.gpuUuids).toEqual({ 0: 'GPU-c1-0', 1: 'GPU-c1-1' });
+    expect(c002.gpuUuids).toEqual({ 0: 'GPU-c2-0' });
+  });
+
+  it('rejects other CSV layouts instead of guessing', () => {
+    expect(parseMultinodePowerSamples('timestamp, index, power.draw [W]\n1,0,1\n')).toBeNull();
+    expect(
+      parseMultinodePowerSamples('schema_version,timestamp_unix,gpu_index,power_w\n1,1,0,1\n'),
+    ).toBeNull();
+    expect(parseMultinodePowerSamples(CSV.split('\n')[0]!)).toBeNull();
+    expect(parseMultinodePowerSamples('')).toBeNull();
+  });
+});
+
+describe('multinode power bundle layout', () => {
+  it('recognises only samples.csv under LOGS/', () => {
+    expect(isMultinodePowerSamplesPath('LOGS/power/samples.csv')).toBe(true);
+    expect(isMultinodePowerSamplesPath('LOGS/native_power/node-1/samples.csv')).toBe(true);
+    expect(isMultinodePowerSamplesPath(String.raw`LOGS\power\samples.csv`)).toBe(true);
+    expect(isMultinodePowerSamplesPath('samples.csv')).toBe(false);
+    expect(isMultinodePowerSamplesPath('LOGS/power/manifest.json')).toBe(false);
+    expect(isMultinodePowerSamplesPath('results/gpu_metrics.csv')).toBe(false);
+  });
+
+  it('maps the producer manifest to a vendor, defaulting to NVIDIA/DCGM', () => {
+    expect(
+      multinodePowerVendor({
+        producer: 'srt-slurm.dcgm-power',
+        source_metric: 'DCGM_FI_DEV_POWER_USAGE',
+      }),
+    ).toBe('nvidia');
+    expect(multinodePowerVendor({ producer: 'srt-slurm.amd-smi-power' })).toBe('amd');
+    expect(multinodePowerVendor({ source_metric: 'rocm_smi_power' })).toBe('amd');
+    expect(multinodePowerVendor(null)).toBe('nvidia');
+  });
+});
diff --git a/packages/db/src/etl/multinode-power-samples.ts b/packages/db/src/etl/multinode-power-samples.ts
new file mode 100644
index 000000000..9c711c4de
--- /dev/null
+++ b/packages/db/src/etl/multinode-power-samples.ts
@@ -0,0 +1,114 @@
+/**
+ * Parser for the multinode power producer's `LOGS/power/samples.csv`.
+ *
+ * `benchmark-multinode-tmpl.yml` uploads no `gpu_metrics_` artifact; its
+ * telemetry travels inside `power_audit_<suffix>` as one CSV for the whole
+ * deployment, written by `srt-slurm.dcgm-power` (DCGM scraped on every host
+ * once per second):
+ *
+ *   schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w
+ *
+ * Only power is scraped, so every other `GpuMetricSample` field stays null and
+ * the digest carries `powerW` alone. Rows are regrouped per host so each host
+ * becomes its own series, the shape the reader already uses for multinode
+ * staging ("one CSV per node"). Pure module: no I/O.
+ */
+
+import { splitCsvLine, type GpuMetricSample, type GpuMetricsVendor } from './gpu-metrics-csv.js';
+
+export interface MultinodePowerHost {
+  hostname: string;
+  /** Host-local GPU indices, as DCGM reports them. */
+  samples: GpuMetricSample[];
+  /** gpu_index → gpu_uuid for the identity sidecar. */
+  gpuUuids: Record<number, string>;
+}
+
+const REQUIRED_COLUMNS = ['timestamp_unix', 'hostname', 'gpu_index', 'power_w'] as const;
+
+/** `samples.csv` under `LOGS/` is the producer's only time-series file. */
+export function isMultinodePowerSamplesPath(relativePath: string): boolean {
+  const posix = relativePath.split('\\').join('/');
+  return /^LOGS\/(?:[^/]+\/)*samples\.csv$/u.test(posix);
+}
+
+function powerOnlySample(timestampMs: number, gpuIndex: number, powerW: number): GpuMetricSample {
+  return {
+    timestampMs,
+    gpuIndex,
+    powerW,
+    temperatureC: null,
+    smClockMhz: null,
+    memClockMhz: null,
+    gpuUtilPct: null,
+    memUtilPct: null,
+    edgeTempC: null,
+    memTempC: null,
+    gfxVoltageMv: null,
+    socVoltageMv: null,
+    memVoltageMv: null,
+    fclkMhz: null,
+    socclkMhz: null,
+    mmActivityPct: null,
+  };
+}
+
+/**
+ * Group the deployment-wide CSV by host. Returns null when the header is not
+ * the multinode power schema; malformed rows are skipped. Hosts sort by name
+ * so series order is stable across re-ingests.
+ */
+export function parseMultinodePowerSamples(csvText: string): MultinodePowerHost[] | null {
+  const lines = csvText
+    .split('\n')
+    .map((line) => line.replace(/\r$/u, ''))
+    .filter((line) => line.trim().length > 0);
+  if (lines.length <= 1) return null;
+  const header = splitCsvLine(lines[0]!).map((cell) => cell.trim().toLowerCase());
+  const column = new Map(header.map((name, index) => [name, index] as const));
+  if (REQUIRED_COLUMNS.some((name) => !column.has(name))) return null;
+  const at = (cells: string[], name: string): string | undefined => cells[column.get(name)!];
+
+  const hosts = new Map<string, MultinodePowerHost>();
+  for (const line of lines.slice(1)) {
+    const cells = splitCsvLine(line).map((cell) => cell.trim());
+    const hostname = at(cells, 'hostname');
+    const seconds = Number.parseFloat(at(cells, 'timestamp_unix') ?? '');
+    const gpuIndex = Number.parseInt(at(cells, 'gpu_index') ?? '', 10);
+    const powerW = Number.parseFloat(at(cells, 'power_w') ?? '');
+    if (
+      !hostname ||
+      !Number.isFinite(seconds) ||
+      !Number.isSafeInteger(gpuIndex) ||
+      gpuIndex < 0 ||
+      !Number.isFinite(powerW)
+    ) {
+      continue;
+    }
+    let host = hosts.get(hostname);
+    if (!host) {
+      host = { hostname, samples: [], gpuUuids: {} };
+      hosts.set(hostname, host);
+    }
+    host.samples.push(powerOnlySample(Math.round(seconds * 1000), gpuIndex, powerW));
+    const uuid = at(cells, 'gpu_uuid');
+    if (uuid && !(gpuIndex in host.gpuUuids)) host.gpuUuids[gpuIndex] = uuid;
+  }
+  if (hosts.size === 0) return null;
+  return [...hosts.values()].toSorted((a, b) => a.hostname.localeCompare(b.hostname));
+}
+
+/**
+ * The producer manifest names its source metric; DCGM means NVIDIA. Anything
+ * naming AMD tooling maps to 'amd', and an absent manifest defaults to NVIDIA
+ * because only the DCGM producer writes this layout today.
+ */
+export function multinodePowerVendor(manifest: Record<string, unknown> | null): GpuMetricsVendor {
+  const source = [manifest?.source_metric, manifest?.producer]
+    .filter((value): value is string => typeof value === 'string')
+    .join(' ')
+    .toLowerCase();
+  // `amd-smi`, `rocm_smi`: the tool name may continue with `-` or `_`.
+  if (/\b(?:amd|rocm)/u.test(source)) return 'amd';
+  return 'nvidia';
+}
diff --git a/packages/db/src/ingest-ci-run.ts b/packages/db/src/ingest-ci-run.ts
index 90e87c33f..932a6f194 100644
--- a/packages/db/src/ingest-ci-run.ts
+++ b/packages/db/src/ingest-ci-run.ts
@@ -489,11 +489,12 @@ async function main(): Promise<void> {
       console.log(`  Found ${serverLogArtifacts.size} server log artifact(s)`);
     }
     // PowerX telemetry: `gpu_metrics_<key>` is uploaded next to `bmk_<key>` by
-    // every benchmark job (see migration 016). Digested here so the dashboard
-    // never re-downloads GitHub artifacts and keeps the series past retention.
+    // every single-node job; multinode jobs carry it inside `power_audit_<key>`
+    // instead (see migration 016). Digested here so the dashboard never
+    // re-downloads GitHub artifacts and keeps the series past retention.
     const gpuMetricsArtifacts = discoverGpuMetricsArtifacts(artifactsDir);
     if (gpuMetricsArtifacts.size > 0) {
-      console.log(`  Found ${gpuMetricsArtifacts.size} gpu_metrics artifact(s)`);
+      console.log(`  Found ${gpuMetricsArtifacts.size} telemetry artifact(s)`);
     }
 
     // Sibling aiperf artifacts: each `bmk_agentic_<suffix>` is paired with an
diff --git a/packages/db/src/lib/gpu-metrics-backfill.test.ts b/packages/db/src/lib/gpu-metrics-backfill.test.ts
index 7ebf88d66..ed8c1e32a 100644
--- a/packages/db/src/lib/gpu-metrics-backfill.test.ts
+++ b/packages/db/src/lib/gpu-metrics-backfill.test.ts
@@ -33,6 +33,23 @@ describe('pairGpuMetricsArtifacts', () => {
     ]);
   });
 
+  it('lets a power_audit bundle stand in only when its suffix has no gpu_metrics upload', () => {
+    // The bundle is listed before its gpu_metrics sibling on purpose: input
+    // order alone must not decide the winner.
+    const pairs = pairGpuMetricsArtifacts([
+      meta('power_audit_cfg-mn_b200-slurm_0', 1),
+      meta('bmk_cfg-mn_b200-slurm_0', 2),
+      meta('power_audit_cfg-sn_h200-cw_0', 4),
+      meta('gpu_metrics_cfg-sn_h200-cw_0', 3),
+      meta('bmk_cfg-sn_h200-cw_0', 5),
+      meta('power_audit_orphan_b200-slurm_0', 6),
+    ]);
+    expect(pairs.map((pair) => [pair.gpuMetrics.name, pair.benchmarks.name])).toEqual([
+      ['gpu_metrics_cfg-sn_h200-cw_0', 'bmk_cfg-sn_h200-cw_0'],
+      ['power_audit_cfg-mn_b200-slurm_0', 'bmk_cfg-mn_b200-slurm_0'],
+    ]);
+  });
+
   it('keeps only the newest retry per logical benchmark and drops expired uploads', () => {
     const pairs = pairGpuMetricsArtifacts([
       meta('gpu_metrics_cfg-a_h200-cw_0', 1, '2026-09-11T00:00:00Z'),
diff --git a/packages/db/src/lib/gpu-metrics-backfill.ts b/packages/db/src/lib/gpu-metrics-backfill.ts
index 94a09105a..59c012f55 100644
--- a/packages/db/src/lib/gpu-metrics-backfill.ts
+++ b/packages/db/src/lib/gpu-metrics-backfill.ts
@@ -1,9 +1,10 @@
 /** Pairing rules for the historical gpu_metrics backfill. */
 
-import { gpuMetricsArtifactSuffix } from '../etl/gpu-metrics-artifacts.js';
+import { gpuMetricsArtifactSuffix, isPowerAuditArtifact } from '../etl/gpu-metrics-artifacts.js';
 import { RUNNER_SUFFIX_RE, type ArtifactMeta } from './github-artifacts.js';
 
 export interface GpuMetricsArtifactPair {
+  /** `gpu_metrics_<suffix>`, or the `power_audit_<suffix>` bundle when a multinode job uploaded no other. */
   gpuMetrics: ArtifactMeta;
   benchmarks: ArtifactMeta;
 }
@@ -16,9 +17,11 @@ function isNewerArtifact(candidate: ArtifactMeta, existing: ArtifactMeta): boole
 }
 
 /**
- * Pair every unexpired gpu_metrics artifact with its exact bmk sibling. Retried
+ * Pair every unexpired telemetry artifact with its exact bmk sibling. Retried
  * jobs upload on different runners, so the newest artifact per logical
- * (runner-suffix-stripped) benchmark name wins, matching CI ingest.
+ * (runner-suffix-stripped) benchmark name wins, matching CI ingest. A
+ * `power_audit_` bundle pairs only when its suffix has no `gpu_metrics_`
+ * upload, the same preference `discoverGpuMetricsArtifacts` applies.
  */
 export function pairGpuMetricsArtifacts(
   artifacts: readonly ArtifactMeta[],
@@ -29,10 +32,16 @@ export function pairGpuMetricsArtifacts(
     const existing = byName.get(artifact.name);
     if (!existing || isNewerArtifact(artifact, existing)) byName.set(artifact.name, artifact);
   }
+  const gpuMetricsSuffixes = new Set<string>();
+  for (const name of byName.keys()) {
+    const suffix = gpuMetricsArtifactSuffix(name);
+    if (suffix && !isPowerAuditArtifact(name)) gpuMetricsSuffixes.add(suffix);
+  }
   const byLogicalBenchmark = new Map<string, GpuMetricsArtifactPair>();
   for (const gpuMetrics of byName.values()) {
     const suffix = gpuMetricsArtifactSuffix(gpuMetrics.name);
     if (!suffix) continue;
+    if (isPowerAuditArtifact(gpuMetrics.name) && gpuMetricsSuffixes.has(suffix)) continue;
     const benchmarks = byName.get(`bmk_agentic_${suffix}`) ?? byName.get(`bmk_${suffix}`);
     if (!benchmarks) continue;
     const logicalName = benchmarks.name.replace(RUNNER_SUFFIX_RE, '');
diff --git a/packages/db/src/queries/gpu-metrics.test.ts b/packages/db/src/queries/gpu-metrics.test.ts
index 23a90485b..e8eafa799 100644
--- a/packages/db/src/queries/gpu-metrics.test.ts
+++ b/packages/db/src/queries/gpu-metrics.test.ts
@@ -229,20 +229,21 @@ describe('getGpuMetricsForRun', () => {
     ]);
   });
 
-  it('reports a dropped sample as zeroes for the core metrics and drops the vendor extras', async () => {
+  it('reports a dropped sample as zero power with every other metric absent', async () => {
     const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
     const dropped = payload?.series[0]?.data.at(-1);
-    // Characterizes the `?? 0` defaulting: a null power reading is indistinguishable
-    // from a genuine 0 W reading once it reaches the chart.
+    // Power keeps the `?? 0` default (a null power reading is indistinguishable
+    // from a genuine 0 W reading once it reaches the chart); the other metrics
+    // stay absent so a power-only collector never shows up as 0 °C / 0 MHz / 0 %.
     expect(dropped).toEqual({
       timestamp: '2026-09-11T04:19:42.000Z',
       index: 0,
       power: 0,
-      temperature: 0,
-      smClock: 0,
-      memClock: 0,
-      gpuUtil: 0,
-      memUtil: 0,
+      temperature: undefined,
+      smClock: undefined,
+      memClock: undefined,
+      gpuUtil: undefined,
+      memUtil: undefined,
       edgeTemp: undefined,
       memTemp: undefined,
       gfxVoltage: undefined,
@@ -252,8 +253,8 @@ describe('getGpuMetricsForRun', () => {
       socClk: undefined,
       mmActivity: undefined,
     });
-    // The AMD-only columns are absent rather than zeroed, so consumers can tell
-    // "not collected" from "collected as zero" for those — but not for the core six.
+    // Absent rather than zeroed, so consumers can tell "not collected" from
+    // "collected as zero" for everything except power.
     expect(Object.hasOwn(dropped!, 'edgeTemp')).toBe(true);
     expect(dropped?.edgeTemp).toBeUndefined();
   });
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
index 1d6bfdb64..3319130a4 100644
--- a/packages/db/src/queries/gpu-metrics.ts
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -13,11 +13,16 @@ export interface GpuMetricSampleRow {
   timestamp: string;
   index: number;
   power: number;
-  temperature: number;
-  smClock: number;
-  memClock: number;
-  gpuUtil: number;
-  memUtil: number;
+  /**
+   * Absent when the collector did not sample the metric (the multinode DCGM
+   * power bundle scrapes power only), so readers can tell "not collected"
+   * from a genuine zero reading.
+   */
+  temperature?: number;
+  smClock?: number;
+  memClock?: number;
+  gpuUtil?: number;
+  memUtil?: number;
   edgeTemp?: number;
   memTemp?: number;
   gfxVoltage?: number;
@@ -135,11 +140,11 @@ function toSampleRow(raw: RawSampleRow): GpuMetricSampleRow {
     timestamp: isoString(raw.sampled_at),
     index: Number(raw.gpu_index),
     power: raw.power_w ?? 0,
-    temperature: raw.temperature_c ?? 0,
-    smClock: raw.sm_clock_mhz ?? 0,
-    memClock: raw.mem_clock_mhz ?? 0,
-    gpuUtil: raw.gpu_util_pct ?? 0,
-    memUtil: raw.mem_util_pct ?? 0,
+    temperature: optional(raw.temperature_c),
+    smClock: optional(raw.sm_clock_mhz),
+    memClock: optional(raw.mem_clock_mhz),
+    gpuUtil: optional(raw.gpu_util_pct),
+    memUtil: optional(raw.mem_util_pct),
     edgeTemp: optional(raw.edge_temp_c),
     memTemp: optional(raw.mem_temp_c),
     gfxVoltage: optional(raw.gfx_voltage_mv),

From 8139739f12ac93f9a0e3ddcd34c61c14fe17017d Mon Sep 17 00:00:00 2001
From: Wenyao Gao <105094497+edwingao28@users.noreply.github.com>
Date: Sun, 20 Sep 2026 18:32:07 -0700
Subject: [PATCH 013/103] =?UTF-8?q?[PowerX]=20add=20power=20boundaries,=20?=
 =?UTF-8?q?rulers,=20comparison=20series=20and=20a=20power=20timeline=20/?=
 =?UTF-8?q?=20=E6=96=B0=E5=A2=9E=E5=8A=9F=E8=80=97=E8=BE=B9=E7=95=8C?=
 =?UTF-8?q?=E3=80=81=E6=A0=87=E5=B0=BA=E3=80=81=E5=AF=B9=E6=AF=94=E5=BA=8F?=
 =?UTF-8?q?=E5=88=97=E4=B8=8E=E5=8A=9F=E8=80=97=E6=97=B6=E9=97=B4=E7=BA=BF?=
 =?UTF-8?q?=20(#1177)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat: share placed perf rulers through the i_rulers URL param

Rulers placed on the primary Inference chart now live in a provider-owned
store and serialize into the share link as `i_rulers`
(`isoX|curveA|curveB;...`). Opening such a link restores the rulers once both
curves have rendered, switches the tool on, clears them when the x-axis mode
changes the rendered chart, and ignores malformed values. Overlay-run curves
are addressable too.

中文：图表上放置的 Perf Ruler 现在保存在 provider 级的 store 中，并以
`i_rulers` 参数写入分享链接；打开链接后会在两条曲线都渲染完成时恢复标尺并自动
开启该工具，切换 X 轴模式导致图表更换时清除，格式错误的值将被忽略。非官方运行
的 overlay 曲线同样可被引用。

* feat: derive provisioned and modelled power boundary fields

Adds `lib/power-basis.ts` with the B2–B4 boundary maths and wires it into
`buildDerivedChartFields`: GPU provisioned (registry TDP), utility provisioned
(registry all-in kW per GPU) and utility modelled (measured GPU power carried
through the chassis model to the utility meter, PUE applied once). Energy
variants count every allocated GPU per output token; values are omitted, never
estimated, when a spec, throughput or telemetry input is missing. Registers the
six `y_*` metric keys with bilingual labels and axis explanations.

中文：新增 `lib/power-basis.ts`，实现 B2–B4 功耗边界的计算并接入
`buildDerivedChartFields`：GPU 额定（注册表 TDP）、全电源配置（注册表每 GPU
all-in kW）以及数据中心建模（GPU 实测功耗经机箱模型推算至市电侧，PUE 仅计入一
次）。能耗指标按每输出 token 计入全部已分配 GPU；缺少规格、吞吐量或遥测输入时
省略数值而不做估算。同时注册六个 `y_*` 指标键及中英文标签与坐标轴说明。

* feat: add a Boundary control to the gated measured power groups

The ↑↑↓↓-gated Measured Power / Measured Energy controls gain a Boundary select
(GPU measured, GPU provisioned, utility provisioned, utility modelled). The
boundary rides on `i_metric`, so existing share links keep working and a
shared boundary view renders even while the gate is locked. Boundary watt
gauges draw the same upper envelope as measured watts and stay envelope-locked
under Optimal Only; tied maxima now stay on the envelope so a flat TDP series
spans its tested range. The availability panel explains per point why a
boundary value is withheld, and the chart caption states each boundary's
formula and assumptions.

中文：↑↑↓↓ 门控的 Measured Power / Measured Energy 控件新增“功耗边界”下拉
（GPU 实测、GPU 额定、全电源配置、数据中心建模）。边界随 `i_metric` 传递，现有
分享链接不受影响，门控锁定时分享的边界视图仍可渲染。边界功率指标与实测功率一
样绘制上包络线，并在“仅最优”下保持包络锁定；包络线现在保留并列最大值，使平坦
的 TDP 序列覆盖完整测试范围。可用性面板逐点说明边界值缺失的原因，图表说明列出
各边界的公式与假设。

* Shorten chip config comparison label / 缩短芯片配置对比文案 (#1168)

* fix: shorten chip config comparison label

Shorten the comparison selector placeholder in the inference chart and profit estimator, with matching Simplified Chinese copy.\n\n中文：缩短推理图表和利润估算器中的芯片配置对比选择器占位文案，并同步更新简体中文。

* test: update chip config placeholder assertions

Update the profit estimator E2E assertions for the shortened English and Simplified Chinese placeholders.\n\n中文：更新利润估算器端到端测试断言，使其匹配缩短后的英文和简体中文占位文案。

* feat: add a measured power timeline display to the gated power group

Third value of the Measured Power Display control (`timeline`,
`y_measuredPowerTimeline`). The key aliases the measured average so the
point set, table view, availability panel and share link are unchanged;
ChartDisplay swaps ScatterGraph for the new PowerTimeline, which joins
each validated point to its `gpu_metrics_<RESULT_FILENAME>` artifact via
`power_audit.source`, fetches one prefixed request per workflow run, and
draws one-second per-GPU power over the whole job with the validated
window emphasized, TDP references per hardware, an opt-in all-in line,
wall-clock / elapsed axes, per-GPU lines, overlay-run colours, and an
explicit list of undrawn configs by reason.

`/api/gpu-metrics` gains `series=power` (compact one-second buckets,
~1 MB instead of ~27 MB raw for a 25-config run) and `prefix=` to skip
other models' artifacts; downloads run four at a time.

中文：在受门控的实测功耗组中新增「时间线」显示方式
（`y_measuredPowerTimeline`）。该指标键复用实测平均功耗，因此数据点集合、
表格视图、可用性面板和分享链接保持不变；ChartDisplay 在该模式下用新的
PowerTimeline 替换散点图：按 `power_audit.source` 将每个有效数据点关联到
对应的 `gpu_metrics_<RESULT_FILENAME>` 产物，按工作流运行各发起一次带前缀的
请求，绘制整个基准测试任务期间每 GPU 的逐秒功耗，突出显示有效测量窗口，
按硬件绘制 TDP 参考线（全电源配置线可选开启），支持实际时刻 / 相对起点两种
时间轴、每 GPU 单独曲线、非官方运行的配色，并按原因列出未绘制的配置。

`/api/gpu-metrics` 新增 `series=power`（一秒分桶的紧凑序列，25 个配置约
1 MB，而原始行约 27 MB）和 `prefix=` 参数以跳过其他模型的产物；下载并发数为 4。

* fix(landing): hide DeepSeek V4 Pro and Qwen3.8 Flash Next / 首页隐藏两个模型 (#1169)

* fix(landing): hide DeepSeek V4 Pro and Qwen3.8 Flash Next

中文：从首页隐藏 DeepSeek V4 Pro 和 Qwen3.8 Flash Next，保留比较页及仪表板行为，并添加双语回归测试。

* test(landing): update model row and badge expectations

中文：更新首页模型行数及 NEW 标记数量的测试预期。

* fix: temporarily label DSpark run 35166686551 as MoRI UMBP SGLang (#1170)

中文：为 DSpark 运行 35166686551 添加三周有效的 MoRI UMBP SGLang 显示名称，保留其他运行和原始数据，并测试到期边界。

Co-authored-by: Perplexity Computer <computer@users.noreply.github.com>

* docs: require exact AI model disclosure (#1171)

中文：要求 PR 描述列出确切的 AI 模型名称/版本及工作内容，更新 agent 指引并新增双语 PR 模板。

* docs: expand bilingual glossary from Rubin AgentX article (#1172)

Add 12 terms, update 10 definitions, and test bilingual coverage and metric boundaries.

中文：根据 Rubin AgentX 文章扩充双语术语表，新增 12 个词条、更新 10 个定义，并补充双语覆盖与指标边界回归测试。

* feat: redirect /xvideo and /xxvideo aliases to /video (#1173)

Add a small alias table (`video-alias-redirects.ts`) wired into
`next.config.ts` so `/xvideo` and `/xxvideo` (plus the `/zh` siblings)
308-redirect to the canonical `/video` route. Subpaths and query strings
carry through via `:path*`. Unit test mirrors the inference-model alias
redirect test.

中文：新增 `video-alias-redirects.ts` 别名表并接入 `next.config.ts`，使
`/xvideo` 与 `/xxvideo`（含 `/zh` 版本）以 308 永久重定向到规范路由
`/video`，子路径和查询参数通过 `:path*` 原样透传。单元测试与推理模型
别名重定向测试保持一致。

* fix: refresh the gpu-metrics route digest after formatting

The pre-commit formatter rewrote src/app/api/gpu-metrics/route.ts after its
catalog digest was computed, so the API route catalog guard failed on a
clean checkout. Documentation and classification are unchanged.

中文：提交前的格式化工具在计算摘要之后重写了 gpu-metrics 路由文件，导致 API
路由目录校验在干净检出时失败；此处仅刷新 SHA-256 摘要，文档与分类不变。

* feat: overlay power boundary and role comparison series via i_pcompare

Add a Compare control to the gated Measured controls that overlays sibling
series on the selected metric without changing it: every power boundary
(GPU measured, GPU provisioned, utility provisioned, utility modeled) or
the prefill / decode worker pools. useChartData and the ?unofficialrun=
overlay processor both append one clone per sibling to every base point
(same x, y from the sibling's field, powerVariant set) through
utils/power-compare.ts; base points are untouched, so charts without a
comparison render byte-identically.

ScatterGraph keys series on hwKey + precision + variant, draws siblings in
the hardware colour (overlay runs keep the run colour) with a per-variant
dash and their own frontier, dims clone points, adds legend rows with line
swatches that toggle and highlight a series across hardware, and labels
the series in tooltips, the Table and the CSV export. Clones stay out of
best-per-SKU ranking, tier counts, the legend points table, the
availability panel and the date-comparison GPUGraph.

For PowerX Figure 7 the prefill pool's J per input token is carried onto
the output-token axis by the served input:output ratio
(utils/role-energy.ts, reconstructedPrefillJPerOutputToken) so it stacks
against the decode pool's J per output token. The comparison rides on the
new i_pcompare URL parameter (boundaries | roles; empty = off) and pauses
with a hint on metrics without a common axis instead of being cleared.

中文：在受门控的 Measured 控件中新增“对比”选项，可在所选指标上叠加同源系列而不改变
该指标：四种功耗边界（GPU 实测、GPU 额定、全电源配置、数据中心建模）或预填充 / 解码
worker 池。useChartData 与 ?unofficialrun= overlay 处理路径均通过 utils/power-compare.ts
为每个基础数据点追加对应系列的克隆点（x 相同、y 取自对应字段、标记 powerVariant），
基础点保持不变，未开启对比的图表渲染结果与之前完全一致。ScatterGraph 以
hwKey + 精度 + 变体作为系列键，同色不同虚线绘制，图例新增可切换、可高亮的线型行，
tooltip、表格与 CSV 标注系列；克隆点不参与 best-per-SKU、功耗等级计数、图例数据点表、
可用性面板及日期对比 GPUGraph。针对 PowerX 图 7，utils/role-energy.ts 按实际服务的
输入/输出 token 比将预填充池的每输入 token 能耗折算到每输出 token 轴
（reconstructedPrefillJPerOutputToken），与解码池并列。对比模式由新 URL 参数
i_pcompare 承载（boundaries | roles，空为关闭），在没有公共坐标轴的指标上暂停并提示，
而不是被清除。

* Add Qwen3.8-27B / 新增 Qwen3.8-27B (#1176)

Register the qwen3.827b and qwen3.827beager DB keys as the experimental
Qwen3.8-27B and Qwen3.8-27B-Eager dashboard models (InferenceX#3260, #3263):
constants, ETL normalizer path, Model enum and MODEL_CONFIG, compare slugs,
compare SSR known models, refreshed constants digest, AGENTS.md parameter row,
and the pinned registry counts.

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>

* [Cache Reuse] add prefix-cache tier share tab and agentic entry links / 新增前缀缓存复用页及智能体入口链接 (#1175)

* feat: add Prefix Cache Reuse tab with agentic entry links

Footer-only /cache-reuse (+ /zh) stacks per-concurrency shares of prompt
tokens served from HBM, the host tier, or recomputed, for one configuration.
Host tier is the CPU-offload rate, falling back to the external rate; never
summed. TensorRT-LLM offload rows draw one combined segment. Fixed sequences
keep the scenario selector and explain that no cache tiers are recorded.
Unofficial runs on the same hardware render as outlined series. c_cfg seeds
the configuration from a share link. Agentic chart footer and point summary
link into the tab.

中文：新增 footer 级 /cache-reuse（含 /zh）页面，按并发数堆叠展示单一配置的
prompt token 来源占比：HBM 缓存、主机层、未复用。主机层取 CPU offload 命中率，
缺失时改用外部缓存命中率，两者不相加；TensorRT-LLM offload 行绘制为单一合并段。
固定序列保留场景选择器并说明无缓存分层数据。同硬件的非官方运行以描边系列叠加。
c_cfg 参数用于分享链接定位配置。智能体图表页脚和数据点摘要新增入口链接。

* fix: pin point links to one precision and drop the empty official series

The point-detail link now writes i_prec from the point, so the tab keys its
groups by bare hardware key and c_cfg matches instead of falling back to
another sweep. buildCacheReuse lists an official series only when official
rows exist, so an overlay-only configuration draws full-width run bars.

中文：数据点详情页链接现在写入该点的 i_prec，页面按纯硬件键分组，c_cfg 能精确
匹配而不会回退到其他配置。buildCacheReuse 仅在存在官方数据行时列出官方系列，
仅存在于非官方运行中的配置以全宽柱形绘制。

* feat: draw worker-pool power traces from power-audit bundles on the timeline

PowerX Figure 1 on the gated Timeline display (y_measuredPowerTimeline):

- /api/gpu-metrics?series=power also downloads power_audit_<RESULT_FILENAME>
  bundles (Slurm / Dynamo DCGM collector, up to 256 MiB), cuts
  LOGS/power/samples.csv into one series per power_validation_*.json window
  (±60 s) and labels devices <hostname>/<GPU-uuid> with their prefill / decode
  role; a corrupt archive skips that artifact instead of failing the run.
- The timeline joins bundle-cut series by validation file name, keeps the
  gpu_metrics join for single-node rows, and gains a "Prefill / decode pools"
  line mode: summed pool watts with pool size × TDP references, pool tooltip,
  and an all-GPU total for traces without roles.
- Pinned scatter tooltips on measured-power metrics offer "View power trace",
  which opens the timeline focused on that config (official and
  ?unofficialrun= points); the anchor href carries the canonical chart state.
- Docs, catalog digest, unit / component / e2e coverage in en and zh.

中文：在受门控的功耗时间线视图上实现 PowerX 图 1。/api/gpu-metrics?series=power
现在也会下载 Slurm / Dynamo（DCGM）运行上传的 power_audit_* 产物包（上限 256 MiB），
按每个 power_validation_*.json 的测量窗口（前后各 60 s）切出独立序列，并按
prefill / decode 角色标注每个 <hostname>/<GPU-uuid> 设备；损坏的压缩包只跳过该产物，
不再让整个请求失败。时间线通过校验文件名关联这些序列（单节点行仍按 gpu_metrics
关联），新增"预填充 / 解码 GPU 池"线型：按池求和的功耗、池内 GPU 数 × TDP 的参考线、
池级提示框，无角色的曲线则显示全部 GPU 总功耗。实测功耗散点图的固定提示框新增
"查看功耗曲线"操作，可直接跳转到聚焦该配置的时间线（官方点与 ?unofficialrun= 叠加点
均支持），链接携带规范化的图表状态。同步更新文档、路由目录摘要及中英文单元 /
组件 / 端到端测试。

* [First-Token Limits] add measured TTFT-cap cost comparison tab / 新增首 token 延迟约束成本对比页 (#1174)

* feat: add First-Token Limits tab comparing cheapest measured configs per TTFT cap

New footer-only dashboard tab at /first-token and /zh/first-token. For each
time-to-first-token cap it picks the cheapest measured row per chip vendor
that also clears an interactivity floor, draws grouped bars with the
best-vs-runner-up gap under the axis, and lists every winner with its run
link. Unofficial runs render as their own series. TTFT is now carried on
GPUDataPoint and kept by the calculator API view.

中文：新增页脚入口的仪表板页面 /first-token 与 /zh/first-token。按每一档首 token
延迟（TTFT）上限，从满足交互性下限的实测数据行中逐厂商选出成本最低的配置，以分组
柱形展示并在坐标轴下方标注最优与次优的成本差距，表格列出各优胜配置及其运行链接。
非官方运行以独立系列呈现。GPUDataPoint 新增 ttft 字段，calculator API 视图保留
TTFT 指标。

* fix: count overlay rows in the first-token empty state

Overlay-only rows that carry a TTFT but miss the interactivity floor were
described as having no first-token measurement, because the empty state only
looked at official rows. Report overlay readable rows separately so the
caption stays official-only while the empty state sees both.

中文：仅有非官方运行数据、且带 TTFT 但未达交互性下限时，空状态误报为「未报告首
token 延迟」。现单独统计叠加运行的可读行，标题说明仍只计官方数据，空状态则同时
考虑两者。

* fix: blame the cap ladder when qualifying rows clear no first-token cap

The empty state told readers to lower the interactivity floor whenever no
bar drew, even when rows cleared the floor and only the TTFT caps were too
tight. It now distinguishes three cases: no TTFT reported, nothing reaches
the floor, and nothing finishes within the largest cap. Overlay rows count
toward the floor check through overlayQualifyingRows; formatCap moves to
the shared module so the message prints caps like the axis ticks.

中文：此前只要没有柱形可画，空状态就提示降低交互性下限，即使数据行已达到下限、
只是 TTFT 上限过紧。现在区分三种情况：未报告 TTFT、无配置达到下限、无配置落在
最大上限之内。非官方运行行通过 overlayQualifyingRows 参与下限判断；formatCap
移入共享模块，使提示中的上限格式与坐标轴刻度一致。

* fix: prevent measured power statistic label overflow

Size the control grid to its container and preserve statistic label widths. Add English and Chinese desktop/mobile geometry regression coverage.

中文：修复实测功耗统计量标签溢出。根据容器宽度排列控件，并保留按钮标签所需宽度；新增中英文桌面和移动端布局回归测试。

* fix: keep power envelope ties only for provisioned and modelled gauges

The tie-keeping added for flat boundary gauges applied to every power
curve, so the measured watt axes kept tied points that Optimal Only used
to collapse (certified-power-filter rendered 6 of 6 instead of 2 of 6).
`upperPowerEnvelope` takes `keepTies`; both charts pass it per series via
`isPowerGaugeSeries`, true for a boundary axis or a boundary comparison
clone, false for measured series, the measured clone and role clones.

中文：此前为平直的边界量表加入的"保留并列点"逻辑作用到了所有功耗曲线，
实测功率轴上 Optimal Only 本应收起的并列点被保留（certified-power-filter
显示 6/6 而非 2/6）。`upperPowerEnvelope` 新增 `keepTies` 参数，两张图按
序列通过 `isPowerGaugeSeries` 传入：边界轴或边界对比克隆为 true，实测序列、
实测克隆和角色克隆为 false。

* fix: key comparison legend rows by the base series identity

`isBase` was "no official point carries this variant", which is wrong when
only an `?unofficialrun=` overlay carries the comparison: every row became
the base, all swatches drew solid and every toggle hid the base key, so a
sibling could never be hidden on its own. Derive the base from
`powerCompareBase` for the selected metric instead. A component test
covers the overlay-only case.

中文：`isBase` 原来的判断是"没有官方点带这个 variant"，当只有 `?unofficialrun=`
overlay 带对比序列时所有行都被当成 base，图例全画实线且每次切换都隐藏
base，兄弟序列无法单独隐藏。改为按所选指标通过 `powerCompareBase` 推导
base。新增组件测试覆盖仅 overlay 的情况。

* fix: rename the timeline axis so a "Measured Power" search stays unique

The Timeline display adds a fourteenth `y_measured*` option. Its label
began with "Measured Power", so the family search matched two options.
Lead with "Measured Average Power", as the %TDP display does, and update
the selector count test, the timeline specs and the Chinese label.

中文：Timeline 显示模式新增了第 14 个 `y_measured*` 选项，其标签以
"Measured Power" 开头，导致按系列名搜索时匹配到两项。改为与 %TDP 显示
一致地以"Measured Average Power"开头，同步更新选择器数量测试、时间线
测试和中文标签。

* fix: label each power comparison series on its own line

Under i_pcompare the line labels were grouped by hardware only, so one
label per hardware landed on whichever variant had the most points
(usually the TDP boundary) and multi-precision views drew identical
labels on every sibling. Group by hardware and variant, keep the plain
label on the base measured series, and suffix siblings with the short
variant name plus the flat watts of a provisioned boundary
(`H200 (SGLang) · TDP 700 W`, `… · Decode GPUs`). Label groups now carry
data-series-id / data-power-variant hooks; overlays get the same text.

中文：对比模式（i_pcompare）下曲线标签原先只按硬件分组，每个硬件只有一个
标签且落在点数最多的 variant 线上（通常是 TDP 边界线），多精度视图则给每条
兄弟线画出相同文字。现改为按硬件 + variant 分组：基线保留原标签，兄弟线追加
简短 variant 名及平直边界的瓦数（如 `H200 (SGLang) · TDP 700 W`、
`… · Decode GPUs`）；标签组新增 data-series-id / data-power-variant 钩子，
叠加运行同样处理。

* fix: load overlay runs first in the power timeline run cap

`?unofficialrun=` telemetry sorted after official runs by run id and was the
run dropped by POWER_TIMELINE_MAX_RUNS; overlay runs now take the cap's slots
right after the deep-linked run. Adds prioritizeRuns with unit and component
coverage and records the order in docs/powerx-permanent-view.md.

中文：功耗时间线每张图最多加载 4 个 run，此前按 run id 排序，`?unofficialrun=`
叠加的 run 通常最新、排在最后而被丢弃；现在叠加 run 紧随深链 run 优先占位。
新增 prioritizeRuns 及单元 / 组件测试，并在 docs/powerx-permanent-view.md 记录顺序。

* fix: route timeline legend clicks through the unified overlay selection

With an overlay loaded the timeline reads localOfficialOverride, so the
context toggleHwType changed nothing visible. Official rows now solo through
setUnifiedOverlaySelection like ScatterGraph; component test added.

中文：加载 `?unofficialrun=` 叠加后，时间线读取 localOfficialOverride，图例点击
只改 activeHwTypes、界面无变化。现在官方硬件行与 ScatterGraph 一样通过
setUnifiedOverlaySelection 独显，并补充组件测试。

* fix: name the hardware instead of the branch on overlay line labels

Unofficial-run pills read `✕ <hardware>`, parsed like official pills so the
GPU stays bold; a short run tag (` · main`, ` · …<date>-<sha>`) is appended only
when several overlay runs draw the same hardware. Branch names run to 70+
characters, so two of them could not share a chart and one pill was hidden.
Legend rows keep the full branch. Unit and component coverage added.

中文：叠加曲线标签改为「✕ 硬件名」，与官方标签同样解析、GPU 名加粗；仅当多个
叠加 run 画同一硬件时追加短 run 标签（` · main`、` · …<日期>-<sha>`）。分支名
常超过 70 字符，两条标签放不下会被隐藏。图例行仍显示完整分支。补充单元与
组件测试。

* fix: keep overlay line labels visible when only their overlay row is active

The filter-sync opacity pass judged every line label by the official
hardware set, so soloing one official hardware hid the pills of every other
overlay hardware. Overlay labels now follow activeOverlayHwTypes; unit tests
cover the rule and the component test pins the rendered pill visibility.

中文：图例筛选后的标签透明度同步只看官方硬件集合，独显一个官方硬件会把其他
硬件的叠加曲线标签一并隐藏。叠加标签现在跟随 activeOverlayHwTypes；单元测试
覆盖规则，组件测试固定渲染后的可见性。

* fix: merge equal-size pool TDP references and stack coinciding labels

In pool mode a prefill pool and a decode pool of the same GPU count drew two
references at the same watts, printing their labels over each other. Pools
of one hardware that share a size now draw one line labelled
`prefill / decode ×16`, and labels of lines at equal watts stack upward.

中文：池模式下 prefill 池与 decode 池 GPU 数相同时，两条参考线重合、标签互相
覆盖。同一硬件、相同 GPU 数的池现在只画一条参考线，标签为
`prefill / decode ×16`；瓦数相同的参考线标签向上错开排列。

---------

Co-authored-by: Alec Ibarra <93070681+adibarra@users.noreply.github.com>
Co-authored-by: functionstackx <47992694+functionstackx@users.noreply.github.com>
Co-authored-by: Perplexity Computer <computer@users.noreply.github.com>
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 .github/pull_request_template.md              |   22 +
 AGENTS.md                                     |    7 +
 docs/data-transforms.md                       |   37 +-
 docs/index.md                                 |    5 +-
 docs/powerx-permanent-view.md                 |  291 ++++
 docs/state-ownership.md                       |   74 +
 docs/tco-calculator.md                        |   52 +
 packages/app/AGENTS.md                        |    9 +
 packages/app/CLAUDE.md                        |    1 +
 .../component/inference-chart-controls.cy.tsx |    6 +-
 .../component/measured-metric-controls.cy.tsx |   38 +
 .../cypress/component/power-compare.cy.tsx    |  568 +++++++
 .../power-metric-availability.cy.tsx          |  154 ++
 .../cypress/component/power-timeline.cy.tsx   |  727 ++++++++
 .../cypress/component/scatter-graph.cy.tsx    |  346 +++-
 packages/app/cypress/e2e/cache-reuse.cy.ts    |  163 ++
 .../app/cypress/e2e/first-token-limits.cy.ts  |  221 +++
 .../e2e/landing-dashboard-navigation.cy.ts    |   31 +
 .../cypress/e2e/measured-power-overlay.cy.ts  |   30 +
 packages/app/cypress/e2e/navigation.cy.ts     |   28 +-
 packages/app/cypress/e2e/nudge-system.cy.ts   |    6 +-
 packages/app/cypress/e2e/powerx-basis.cy.ts   |  342 ++++
 packages/app/cypress/e2e/powerx-compare.cy.ts |  301 ++++
 .../app/cypress/e2e/powerx-timeline.cy.ts     |  336 ++++
 .../app/cypress/e2e/profit-estimator.cy.ts    |    8 +-
 packages/app/cypress/e2e/url-params.cy.ts     |  124 ++
 packages/app/cypress/e2e/zh-pages.cy.ts       |    4 +-
 packages/app/cypress/support/mock-data.ts     |    2 +
 packages/app/cypress/support/share-link.ts    |   27 +
 packages/app/next.config.ts                   |    2 +
 .../src/app/(dashboard)/cache-reuse/page.tsx  |   17 +
 .../src/app/(dashboard)/first-token/page.tsx  |   17 +
 .../app/src/app/api/gpu-metrics/route.test.ts |  472 +++++-
 packages/app/src/app/api/gpu-metrics/route.ts |  271 ++-
 .../app/zh/(dashboard)/cache-reuse/page.tsx   |   23 +
 .../app/zh/(dashboard)/first-token/page.tsx   |   23 +
 .../components/calculator/CacheReuseChart.tsx |  394 +++++
 .../calculator/CacheReuseDisplay.tsx          |  682 ++++++++
 .../calculator/FirstTokenLimitsChart.tsx      |  454 +++++
 .../calculator/FirstTokenLimitsDisplay.tsx    |  987 +++++++++++
 .../calculator/ProfitEstimatorDisplay.tsx     |    4 +-
 .../components/calculator/cache-reuse.test.ts |  288 ++++
 .../src/components/calculator/cache-reuse.ts  |  227 +++
 .../calculator/first-token-limits.test.ts     |  324 ++++
 .../calculator/first-token-limits.ts          |  330 ++++
 .../app/src/components/calculator/types.ts    |    7 +
 .../calculator/useThroughputData.test.ts      |   52 +
 .../calculator/useThroughputData.ts           |   24 +-
 .../compare/agentx-compare-hero.tsx           |    9 +-
 packages/app/src/components/footer/footer.tsx |   20 +
 .../gpu-power/power-audit-bundle.test.ts      |  231 +++
 .../gpu-power/power-audit-bundle.ts           |  280 ++++
 .../components/gpu-power/power-series.test.ts |  119 ++
 .../src/components/gpu-power/power-series.ts  |  180 ++
 .../components/inference/InferenceContext.tsx |   42 +-
 .../agentic-point/point-summary.test.ts       |   19 +
 .../inference/agentic-point/point-summary.tsx |   29 +-
 .../inference/axis-metric-explanations.ts     |  110 ++
 .../inference/hooks/useChartData.ts           |   13 +-
 .../inference/measured-metric-config.test.ts  |  145 +-
 .../inference/measured-metric-config.ts       |   87 +-
 .../measured-power-direction.test.ts          |   63 +
 .../inference/metric-registry.test.ts         |   54 +-
 .../components/inference/metric-registry.ts   |  105 +-
 .../inference/perf-ruler-store.test.ts        |  246 +++
 .../components/inference/perf-ruler-store.ts  |  179 ++
 .../app/src/components/inference/types.ts     |   63 +
 .../inference/ui/CacheReuseLink.tsx           |   36 +
 .../components/inference/ui/ChartControls.tsx |   15 +-
 .../components/inference/ui/ChartDisplay.tsx  |   86 +-
 .../src/components/inference/ui/GPUGraph.tsx  |   15 +-
 .../inference/ui/InferenceTable.tsx           |   20 +-
 .../inference/ui/MeasuredMetricControls.tsx   |  137 +-
 .../inference/ui/PowerMetricAvailability.tsx  |  161 +-
 .../components/inference/ui/PowerTimeline.tsx | 1469 +++++++++++++++++
 .../components/inference/ui/ScatterGraph.tsx  |  582 ++++++-
 .../ui/line-label-visibility.test.ts          |   58 +
 .../inference/ui/line-label-visibility.ts     |   14 +-
 .../app/src/components/inference/utils.ts     |   22 +-
 .../inference/utils/best-series-per-sku.ts    |    4 +-
 .../inference/utils/point-identity.test.ts    |   30 +-
 .../inference/utils/point-identity.ts         |   38 +
 .../inference/utils/power-compare.test.ts     |  295 ++++
 .../inference/utils/power-compare.ts          |  344 ++++
 .../inference/utils/powerCurves.test.ts       |   64 +-
 .../components/inference/utils/powerCurves.ts |   40 +-
 .../inference/utils/powerTimeline.test.ts     |  421 +++++
 .../inference/utils/powerTimeline.ts          |  349 ++++
 .../inference/utils/role-energy.test.ts       |   41 +
 .../components/inference/utils/role-energy.ts |   64 +
 .../utils/tooltip-utils.power-trace.test.ts   |  184 +++
 .../inference/utils/tooltipUtils.ts           |  168 +-
 packages/app/src/components/tab-nav.tsx       |    2 +
 packages/app/src/lib/api-route-catalog.ts     |   11 +-
 .../app/src/lib/benchmark-api-view.test.ts    |   30 +
 packages/app/src/lib/benchmark-api-view.ts    |    4 +-
 packages/app/src/lib/cache-reuse-link.test.ts |   69 +
 packages/app/src/lib/cache-reuse-link.ts      |   45 +
 packages/app/src/lib/chart-utils.test.ts      |  176 ++
 packages/app/src/lib/chart-utils.ts           |   41 +-
 packages/app/src/lib/compare-slug.test.ts     |    2 +
 packages/app/src/lib/compare-slug.ts          |   16 +
 packages/app/src/lib/compare-ssr.ts           |    2 +
 .../app/src/lib/csv-export-helpers.test.ts    |   30 +
 packages/app/src/lib/csv-export-helpers.ts    |   11 +-
 .../lib/d3-chart/layers/perf-ruler.test.ts    |  128 ++
 .../app/src/lib/d3-chart/layers/perf-ruler.ts |   66 +
 packages/app/src/lib/dashboard-routes.ts      |   20 +
 packages/app/src/lib/data-mappings.ts         |   23 +
 packages/app/src/lib/github-artifacts.test.ts |   23 +
 packages/app/src/lib/github-artifacts.ts      |   18 +
 packages/app/src/lib/glossary-zh.ts           |  187 ++-
 packages/app/src/lib/glossary.test.ts         |   51 +
 packages/app/src/lib/glossary.ts              |  332 +++-
 packages/app/src/lib/inference-labels.test.ts |   92 +-
 packages/app/src/lib/inference-labels.ts      |   55 +-
 packages/app/src/lib/power-basis.test.ts      |  444 +++++
 packages/app/src/lib/power-basis.ts           |  211 +++
 packages/app/src/lib/rankings.test.ts         |    2 +-
 packages/app/src/lib/run-pages.test.ts        |    2 +-
 packages/app/src/lib/tab-meta-zh.ts           |   16 +
 packages/app/src/lib/tab-meta.ts              |   10 +
 packages/app/src/lib/url-state.test.ts        |   88 +
 packages/app/src/lib/url-state.ts             |   38 +
 .../app/src/lib/video-alias-redirects.test.ts |   34 +
 packages/app/src/lib/video-alias-redirects.ts |   25 +
 packages/app/timings.json                     |   20 +
 packages/constants/src/models.ts              |   12 +
 packages/db/src/etl/normalizers.ts            |    6 +
 129 files changed, 17242 insertions(+), 309 deletions(-)
 create mode 100644 .github/pull_request_template.md
 create mode 100644 docs/powerx-permanent-view.md
 create mode 100644 packages/app/AGENTS.md
 create mode 100644 packages/app/CLAUDE.md
 create mode 100644 packages/app/cypress/component/measured-metric-controls.cy.tsx
 create mode 100644 packages/app/cypress/component/power-compare.cy.tsx
 create mode 100644 packages/app/cypress/component/power-timeline.cy.tsx
 create mode 100644 packages/app/cypress/e2e/cache-reuse.cy.ts
 create mode 100644 packages/app/cypress/e2e/first-token-limits.cy.ts
 create mode 100644 packages/app/cypress/e2e/powerx-basis.cy.ts
 create mode 100644 packages/app/cypress/e2e/powerx-compare.cy.ts
 create mode 100644 packages/app/cypress/e2e/powerx-timeline.cy.ts
 create mode 100644 packages/app/cypress/support/share-link.ts
 create mode 100644 packages/app/src/app/(dashboard)/cache-reuse/page.tsx
 create mode 100644 packages/app/src/app/(dashboard)/first-token/page.tsx
 create mode 100644 packages/app/src/app/zh/(dashboard)/cache-reuse/page.tsx
 create mode 100644 packages/app/src/app/zh/(dashboard)/first-token/page.tsx
 create mode 100644 packages/app/src/components/calculator/CacheReuseChart.tsx
 create mode 100644 packages/app/src/components/calculator/CacheReuseDisplay.tsx
 create mode 100644 packages/app/src/components/calculator/FirstTokenLimitsChart.tsx
 create mode 100644 packages/app/src/components/calculator/FirstTokenLimitsDisplay.tsx
 create mode 100644 packages/app/src/components/calculator/cache-reuse.test.ts
 create mode 100644 packages/app/src/components/calculator/cache-reuse.ts
 create mode 100644 packages/app/src/components/calculator/first-token-limits.test.ts
 create mode 100644 packages/app/src/components/calculator/first-token-limits.ts
 create mode 100644 packages/app/src/components/gpu-power/power-audit-bundle.test.ts
 create mode 100644 packages/app/src/components/gpu-power/power-audit-bundle.ts
 create mode 100644 packages/app/src/components/gpu-power/power-series.test.ts
 create mode 100644 packages/app/src/components/gpu-power/power-series.ts
 create mode 100644 packages/app/src/components/inference/perf-ruler-store.test.ts
 create mode 100644 packages/app/src/components/inference/perf-ruler-store.ts
 create mode 100644 packages/app/src/components/inference/ui/CacheReuseLink.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerTimeline.tsx
 create mode 100644 packages/app/src/components/inference/utils/power-compare.test.ts
 create mode 100644 packages/app/src/components/inference/utils/power-compare.ts
 create mode 100644 packages/app/src/components/inference/utils/powerTimeline.test.ts
 create mode 100644 packages/app/src/components/inference/utils/powerTimeline.ts
 create mode 100644 packages/app/src/components/inference/utils/role-energy.test.ts
 create mode 100644 packages/app/src/components/inference/utils/role-energy.ts
 create mode 100644 packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
 create mode 100644 packages/app/src/lib/cache-reuse-link.test.ts
 create mode 100644 packages/app/src/lib/cache-reuse-link.ts
 create mode 100644 packages/app/src/lib/power-basis.test.ts
 create mode 100644 packages/app/src/lib/power-basis.ts
 create mode 100644 packages/app/src/lib/video-alias-redirects.test.ts
 create mode 100644 packages/app/src/lib/video-alias-redirects.ts

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 000000000..8580a756a
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,22 @@
+<!-- Title: <English title> / <中文标题> -->
+
+## Summary
+
+<!-- Describe the changes and why they are needed. -->
+
+## AI model disclosure
+
+<!-- Required: name the exact model/version used to prepare this PR and its role. List every contributing model, including delegated agents; a tool name alone (Claude Code, Cursor, Perplexity Computer) is insufficient. Use the identifier exposed by the runtime, never a guessed identifier. If unavailable, explicitly state that the exact model could not be verified. For human-only PRs, write "No AI used". Update this section if later edits use another model. -->
+
+- Model/version:
+- Role:
+
+## Validation
+
+<!-- List checks actually run and their results. Explain any checks not run. For chart features, include verification for official runs and ?unofficialrun= overlays. -->
+
+- [ ] I have completed the AI model disclosure and kept it current
+
+## 中文说明
+
+<!-- 用自然的简体中文说明改动及验证结果。AI 模型使用说明必须列出实际使用的完整模型名称/版本及各自的工作内容（包括委派给其他 agent 的工作），不能只写工具名，也不能猜测运行环境未提供的模型标识；无法确认时须明确说明。未使用 AI 时填写 “No AI used”。后续修改使用其他模型时须更新说明。模型标识、代码、命令及日志保持原样。 -->
diff --git a/AGENTS.md b/AGENTS.md
index ad909b256..a70899a18 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -2,6 +2,12 @@
 
 For detailed subsystem docs, see [docs/index.md](./docs/index.md).
 
+## AI model disclosure
+
+Every PR description must include an **AI model disclosure** section naming the exact model/version used to prepare the PR. List each contributing model and its role, including delegated agents. Tool names such as Claude Code, Cursor, or Perplexity Computer are not model identities. Copy the model identifier exposed by the runtime; do not guess an unavailable identifier. If the runtime does not expose the exact model, explicitly state that it could not be verified. Human-only PRs must state `No AI used`. Keep the disclosure current when later edits use another model.
+
+## Contribution requirements
+
 > **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 产物. In first-party ML infrastructure UI and technical prose, keep established English technical terms and phrases that Chinese engineers normally use in English; decide from real industry usage and the surface, not from a closed list. `warmup`, `seed`, and `offload` are examples, not the whole category. Follow `docs/chinese-copy.md` for explanatory and quotation exceptions.
@@ -230,6 +236,7 @@ Authoritative total / active parameter counts for every model in the dashboard.
 | Kimi-K2.7-Code         | 1T    | 32B         | `moonshotai/Kimi-K2.7-Code`         | HF model card                      |
 | Qwen3.5-397B-A17B      | 397B  | 17B         | `Qwen/Qwen3.5-397B-A17B`            | HF model card                      |
 | Qwen3.8-Flash-Next     | 176B  | 6B          | `Qwen/Qwen3.8-Flash-Next-FP8`       | HF model card                      |
+| Qwen3.8-27B            | 27B   | 27B (dense) | `Qwen/Qwen3.8-27B`                  | HF model card                      |
 | GLM-5                  | 744B  | 40B         | `zai-org/GLM-5`                     | HF model card                      |
 | GLM-5.1                | 744B  | 40B         | `zai-org/GLM-5.1-FP8`               | HF model card (same base as GLM-5) |
 | MiniMax-M2.5           | 230B  | 10B         | `MiniMaxAI/MiniMax-M2.5`            | HF model card                      |
diff --git a/docs/data-transforms.md b/docs/data-transforms.md
index b430fad3e..f5dcd0935 100644
--- a/docs/data-transforms.md
+++ b/docs/data-transforms.md
@@ -64,7 +64,26 @@ Returns `{ chartData: InferenceData[][], hardwareConfig: HardwareConfig }`.
 - `tpPerMw` — `(tputPerGpu * 1000) / hardwarePower` (GPU power in kW, result in tok/s/MW).
 - Cost-per-million fields — GPU hourly cost divided by tokens-per-hour (in millions): `costh` / `costr` for owning-at-large-hyperscaler-volume / 3-year-rental pricing respectively. Three token variants exist: combined (`costh`/`costr`), output-only (`costhOutput`/`costrOutput`), and input-only (`costhi`/`costri`). The former Neocloud tier (`costn`/`costni`/`costnOutput`) was removed; its share-link keys alias to the hyperscaler-volume metric.
 - Infrastructure purchasing-power fields divide tokens per hour by the same hourly costs. Total (`tokensPerDollarH`/`R`), output-only (`outputTokensPerDollarH`/`R`), and input-only (`inputTokensPerDollarH`/`R`) are separate USD Y-axis metrics. The former ¥-priced `tokensPerRmb*` axes and the Neocloud `*PerDollarN` axes were removed; their share-link keys alias to the matching hyperscaler-volume $ metric. The dashboard defaults to the hyperscaler-volume total-tokens-per-dollar axis (`y_tokensPerDollarH`). Links created for the removed API-price `i_metric=y_tokensPerDollar` axis resolve to the same hyperscaler-volume variant.
-- Energy fields — `jTotal` / `jOutput` / `jInput`: `(hardwarePower * 1000) / tputPerGpu` (Joules per token, where power in kW is converted to W).
+- Energy fields — `jTotal` / `jOutput` / `jInput`: `(hardwarePower * 1000) / tputPerGpu` (Joules per token, where power in kW is converted to W). These divide one GPU's all-in power by that GPU's reported throughput; for disaggregated rows `output_tput_per_gpu` is per decode GPU, so `jOutput` ignores the prefill pool. Its semantics are frozen; the whole-deployment view lives in the power boundaries below.
+- Power-boundary fields — see [Power boundaries](#power-boundaries).
+
+#### Power boundaries
+
+`lib/power-basis.ts` derives the three boundaries beyond GPU-measured telemetry as W per allocated GPU plus J per successful output token. `buildDerivedChartFields` calls `buildPowerBasisChartFields(entry, specs)` right after the measured fields, so the official chart, the `?unofficialrun=` overlay (`transformBenchmarkRows`), and Historical Trends (`rowToLightweightPoint` with `requestedMetrics`) share one formula set; each key is gated by `wants(key)` so selective output stays exact.
+
+| Basis                                         | W / GPU                                                                    | J / output token                   | Fields                                                             |
+| --------------------------------------------- | -------------------------------------------------------------------------- | ---------------------------------- | ------------------------------------------------------------------ |
+| B1 GPU measured                               | `avg_power_w`                                                              | `joules_per_output_token`          | existing `measuredAvgPower`, `measuredJPerOutputToken` (unchanged) |
+| B2 GPU provisioned                            | `HW_REGISTRY.tdp`                                                          | `W × N_alloc ÷ total output tok/s` | `gpuProvisionedWatts`, `gpuProvisionedJPerOutputToken`             |
+| B3 utility provisioned (all-in)               | `HW_REGISTRY.power × 1000`                                                 | `W × N_alloc ÷ total output tok/s` | `utilityProvisionedWatts`, `utilityProvisionedJPerOutputToken`     |
+| B4 utility modeled (measured → chassis → PUE) | `modeledSystemPower.deploymentFacilityWatts ÷ modeledSystemPower.gpuCount` | `B1 J/out × (B4 W ÷ B1 W)`         | `utilityModeledWatts`, `utilityModeledJPerOutputToken`             |
+
+- **N_alloc and total throughput** (`powerBasisNormalization`). Aggregate rows report output per allocated GPU, so `N_alloc` cancels and the builder uses `W ÷ output_tput_per_gpu` without trusting display counts (legacy ingest can encode TP × EP twice). Fixed-sequence disaggregated rows (`disagg && benchmark_type === 'single_turn'`) report output per decode GPU while the deployment also powers the prefill pool, so `total output tok/s = output_tput_per_gpu × num_decode_gpu` and `N_alloc = num_prefill_gpu + num_decode_gpu`; the article's 4P+4D counts eight GPUs, and B3 energy is `(P + D) / D` times `jOutput` on such rows. Other disaggregated benchmark types emit no provisioned energy because it is not verifiable in-app whether AgentX throughput already divides by all GPUs.
+- **B4 source.** Reuses the `SystemPowerEstimate` that `rowToAggDataEntry` attached as `entry.modeledSystemPower`; nothing re-runs `modelSystemPower`. `deploymentFacilityWatts` is chassis AC × PUE with PUE applied exactly once inside `estimateChassisPower`, divided by the physical measured GPU count (not `modeledGpuCount`, which over-counts partially allocated chassis: a 4P+4D deployment on two worker hosts models 16 GPUs while measuring 8, and the unit test pins that divisor). This is a different quantity from the existing `modeledChassisPowerPerGpu` (chassis AC ÷ modeled GPU count, no PUE). Modeled energy scales the producer's same-window `joules_per_output_token` by `B4 W ÷ avg_power_w`, so it inherits B1's token denominator and survives rows whose `output_tput_per_gpu` is missing (the provisioned energies do not; a per-basis point count cannot assume one shared denominator).
+- **Null rules.** A value is emitted only when finite and positive; otherwise the key is omitted (never `{ y: 0 }`), because the metric filters drop points by `metricKey in point` and `remapInferencePoint` falls back to raw throughput when a key exists with an unusable value. B2/B3 W are absent for hardware without registry specs (`getGpuSpecs` returns zeros); their energies are also absent without output throughput or disaggregated counts. B4 requires `modeledSystemPower.status === 'supported'` and B1 watts (`avg_power_w` after `rowToAggDataEntry`'s `power_valid !== 0` admission); B4 energy additionally needs `joules_per_output_token`. Telemetry admission belongs to `modelSystemPower`, which accepts `power_valid === 1` with schema v2 or the validated unversioned single-node producer (`telemetryBasis: 'validated-unversioned-single-node'`), so B4 renders on exactly the rows that show B1 and `modeledChassisPowerPerGpu`; off-8k/1k workloads, unsupported hardware such as GB200/GB300 NVL72 (`reason: 'hardware'`), and telemetry/topology failures withhold it. The public API's `strictV2` row filter is not re-applied in the chart for B1, so it is not re-applied for B4 either (plan §3.1 describes B1 with that filter; the app's chart path is the authority here).
+- **Ordering invariant** (unit-tested on real B200 telemetry): B3 ≥ B4 ≥ B1 and B2 ≥ B1 for both W/GPU and J/out on the same point.
+- **Reconstructed prefill energy** (`reconstructedPrefillJPerOutputToken`, `utils/role-energy.ts`). For validated (`power_valid === 1`, schema 2) disaggregated rows, `prefill_joules_per_input_token × (joules_per_output_token ÷ joules_per_input_token)` carries the prefill pool's energy onto the output-token axis: the ratio is the served input:output token count because schema-2 aggregate energy has one numerator. With `decode_joules_per_output_token` it sums back to the deployment's J/out. It feeds only the `i_pcompare=roles` comparison on the energy axis (PowerX Figure 7) and is never a y-axis of its own; aggregate rows and rows missing any of the four inputs omit it.
+- Historical Trends substitutes `output_tput_per_gpu := tput_per_gpu` for legacy rows lacking output throughput; provisioned energies in trends inherit that fallback.
 
 **GPU specs lookup** happens inside `buildDerivedChartFields`. `getGpuSpecs(hwKey)` (`lib/constants.ts`) splits on `[-_]` to extract the base GPU token (for example, `"b200_trt_mtp"` becomes `"b200"`) and looks it up in `HW_REGISTRY`. Missing keys return zeroed specs, producing `0` cost/energy values rather than crashing.
 
@@ -84,6 +103,22 @@ The hook runs a 5-step memoized pipeline:
 
 ---
 
+## Prefix-Cache Tier Shares (`/cache-reuse`)
+
+The Prefix Cache Reuse tab stacks, per concurrency, where one configuration's prompt tokens came from: the chip's HBM KV cache, the host tier behind it, or nowhere (recomputed). It reads the calculator's `GPUDataPoint` groups (`useThroughputData`) and takes the tiers from each point's `sourceRow.metrics`, so official rows and `?unofficialrun=` overlays flow through the same mapper; the pure logic lives in `components/calculator/cache-reuse.ts`.
+
+Why the shares are built the way they are:
+
+- **The host segment is the CPU-offload rate**, falling back to `server_external_cache_hit_rate` only when a row reports no CPU figure, and the two are never summed. This deliberately differs from `measuredCacheHitRate` in `lib/cache-pricing.ts`, which prefers the external figure to price cached input conservatively: that protects a revenue number from double-counting, while this chart names the tier a token came from, and on SGLang HiCache rows the host tier is the CPU figure (it is also what the GLM-5.3 article plotted).
+- **TensorRT-LLM with offload reports one combined figure.** The point summary already labels it "Combined chip + CPU"; the tab draws it as a single reused segment (`combined: true`) instead of inventing a split.
+- **Clamping is visible, not silent.** Some rows report a GPU rate above 1 (GB300 Dynamo, 1.012). Shares are clamped so the bar sums to 100%, and the unclamped `reportedTotal` is kept for the tooltip caveat.
+- **Rows without any tier are drawn as gaps, not zeros.** A GB300 sweep scraped only at the Dynamo frontend has a theoretical ceiling but no server counters; those concurrencies get a marker and are counted in the caption as unmeasured.
+- **Fixed sequences record no cache tier at all**, so the tab keeps the scenario selector and shows an explanatory empty state rather than an empty chart.
+
+The configuration selector defaults to the group with the most tiered rows, preferring SGLang on a tie because SGLang separates the two tiers; `c_cfg` seeds it from a share link. Overlay runs on the same hardware become their own outlined series so a branch can be read against the published curve concurrency by concurrency. Cypress fixtures: `interceptOverlayRun` (agentic rows with gpu 0.8 / external 0.1 / cpu 0.05, which must render as 80 / 5 / 15).
+
+The tab is footer-only, so the agentic chart links into it: `CacheReuseLink` sits in the chart's status-notes footer (chart state rides along via `withChartState`) and in the point summary of an agentic detail page, where `cacheReuseHref` (`lib/cache-reuse-link.ts`) writes the point's own `g_model`, `i_seq`, `i_prec`, and `c_cfg` because a reader who landed cold has no in-memory chart state to inherit; pinning one precision matters because with several selected the groups are keyed `hwKey__precision` and a bare hardware key would miss.
+
 ## Hardware Key Construction
 
 This is the most complex and bug-prone part of the pipeline. A bad hardware key produces either a missing legend entry, zeroed cost/energy metrics (because `getGpuSpecs` returns zeros), or a chart point that never matches the active hardware filter.
diff --git a/docs/index.md b/docs/index.md
index 41884d3c3..72bcc017d 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -6,6 +6,7 @@ Design rationale and non-obvious conventions. See [CLAUDE.md](../CLAUDE.md) for
 
 - [API Skill Examples](./inferencex-api-examples.md) — Install the public skill, query benchmarks, export measured PowerX data, and explain empty results
 - [PowerX System Power](./powerx-system-power.md) — Pinned chassis model, measured-input guards, assumptions, and reproducible article exports
+- [PowerX Permanent View](./powerx-permanent-view.md) — Power boundaries as gated Measured Energy metrics, `i_metric`/`i_rulers` share links, missing-value states
 - [API Skill Releases](./inferencex-skills-release.md) — Prepare an immutable package, verify clean installations and agent exports, and publish through the package-specific workflow
 - [API Skill Discovery](./inferencex-skills-discovery.md) — Accept or reject implicit skill discovery in fresh Codex and Claude Code projects
 - [CLI Compatibility](./inferencex-cli-compatibility.md) — Contract 1 schemas, bundle and exit semantics, platform scope, and legacy migration
@@ -16,11 +17,11 @@ Design rationale and non-obvious conventions. See [CLAUDE.md](../CLAUDE.md) for
 - [Data Pipeline](./data-pipeline.md) — DB schema reasoning, ETL design, transform pipeline, spline method choice, normalizer resolution order (model/GPU/framework)
 - [Pitfalls](./pitfalls.md) — Failure modes: token type consistency, schema evolution, empty objects, zoom loss, stale closures, disaggregated metrics, negative splines, date stamping, ref stability, cost inheritance
 - [GPU Specs](./gpu-specs.md) — Unit conventions, topology invariants, SVG layout rationale, hardware gotchas
-- [TCO Calculator](./tco-calculator.md) — Why interpolation, composite keys, cost matrix, token type bugs, badge logic, state design
+- [TCO Calculator](./tco-calculator.md) — Why interpolation, composite keys, cost matrix, token type bugs, badge logic, state design, Fleet Lifecycle, Profit Estimator, First-Token Limits
 - [Adding Entities](./adding-entities.md) — Step-by-step checklists for adding new models, GPUs, precisions, sequences, frameworks (ingest + constants + frontend), plus featuring a day-0 model (launch banner, modal, Quick Comparisons preset)
 - [Testing](./testing.md) — Requirements, quality standards, pre-commit checklist
 - [Typography](./typography.md) — Type tokens (text-2xs/3xs, named tracking), Heading/Eyebrow components, TS-based chart font sizes, and the check:typography ratchet gate + allowlist burndown
-- [Data Transforms](./data-transforms.md) — Full pipeline from BenchmarkRow to RenderableGraph: type hierarchy, hardware key construction, derived metrics, memoization strategy
+- [Data Transforms](./data-transforms.md) — Full pipeline from BenchmarkRow to RenderableGraph: type hierarchy, hardware key construction, derived metrics, memoization strategy, prefix-cache tier shares (`/cache-reuse`)
 - [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
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
new file mode 100644
index 000000000..9559fb31e
--- /dev/null
+++ b/docs/powerx-permanent-view.md
@@ -0,0 +1,291 @@
+# PowerX Permanent View
+
+How the PowerX article's power-boundary figures live inside `/inference` instead of a
+separate page. The measured-power UI, the four power boundaries, and their share links all
+sit in the existing ↑↑↓↓-gated **Measured Energy** metric group.
+
+## Purpose
+
+The article compares one deployment's power at four boundaries, from the GPU board to the
+utility meter, both as W per GPU and as J per output token. The dashboard already had
+GPU-measured telemetry (`measured*` metrics) and an ungated all-in provisioned energy
+(`jOutput`). This view adds the other boundaries as ordinary y-axis metrics so every chart
+feature (zoom, tooltip, Perf Ruler, Optimal Only, Table, CSV, PNG, `?unofficialrun=` overlay,
+share URL) applies unchanged. One chart engine, no second chart component.
+
+## Gate
+
+The Measured Energy group is `gated: true` in `metric-registry.ts`. `ChartControls` hides a
+gated group while the gate is locked unless the selected `i_metric` belongs to it, so a
+shared link to any boundary renders for a reader who never unlocked the gate, while the
+group stays out of the selector otherwise. The boundary metrics are members of that group
+(`POWER_BASIS_METRIC_CONFIG_KEYS` is spread into it) so they inherit exactly this behaviour;
+Cypress `powerx-basis.cy.ts` covers the locked, unlocked and shared-link cases.
+
+## Boundaries
+
+| Basis (`PowerBasis`)  | Selector label               | W / GPU metric                               | J / output token metric                           | Source                                                                  |
+| --------------------- | ---------------------------- | -------------------------------------------- | ------------------------------------------------- | ----------------------------------------------------------------------- |
+| `gpu-measured`        | GPU measured                 | `y_measuredAvgPower` (+P75/P90, roles, %TDP) | `y_measuredJPerOutputToken` (+ input/total/query) | runner telemetry; existing metrics, unchanged                           |
+| `gpu-provisioned`     | GPU provisioned (TDP)        | `y_gpuProvisionedWatts`                      | `y_gpuProvisionedJPerOutputToken`                 | `HW_REGISTRY.tdp`                                                       |
+| `utility-provisioned` | Utility provisioned (all-in) | `y_utilityProvisionedWatts`                  | `y_utilityProvisionedJPerOutputToken`             | `HW_REGISTRY.power` (all-in kW per GPU)                                 |
+| `utility-modeled`     | Utility modeled (PUE)        | `y_utilityModeledWatts`                      | `y_utilityModeledJPerOutputToken`                 | `modelSystemPower` chassis AC × PUE 1.3 (applied once), ÷ measured GPUs |
+
+Formulas, the all-GPU normalization (`N_alloc` = prefill + decode GPUs for disaggregated
+rows) and the null rules are specified in
+[Data Transforms → Power boundaries](./data-transforms.md#power-boundaries); the chassis model
+itself in [PowerX System Power](./powerx-system-power.md). The ungated `jOutput` keeps its
+per-decode-GPU normalization; its labels and the boundary metric's `all GPUs` label keep the
+two distinguishable in the selector, the availability list and CSV headers.
+
+Every boundary metric has `polarity: 'lower'`. Energy metrics therefore get the usual
+lower-is-better Pareto frontier. The three watt keys are listed in `POWER_CURVE_METRICS`
+(`utils/powerCurves.ts`), so `ScatterGraph`/`GPUGraph` draw the upper power envelope for them
+exactly as for `y_measuredAvgPower`, and Optimal Only keeps every load point; the declared
+`lower_*` roofline only drives the ascending Table sort. They stay out of
+`isMeasuredPowerCurveMetric`, like `y_modeledChassisPowerPerGpu`, so telemetry-only decorations
+do not apply. `measured-power-direction.test.ts` pins both halves. A flat provisioned series
+(TDP or all-in W is one constant per hardware) has a single envelope vertex per hardware, so no
+envelope line is drawn for it — only the points.
+
+## Why the metric key carries the boundary
+
+There is no `i_pbasis` URL parameter. The Boundary select in `MeasuredMetricControls` is
+presentation over `selectedYAxisMetric`, exactly like Per / Scope / Statistic / Display /
+Unit: `measured-metric-config.ts` gives every Measured Energy key a `basis` and resolves each
+control change to the nearest registered key. Consequences:
+
+- One share link per figure, and `i_metric` already round-trips through every existing
+  surface (share button, Historical Trends hand-off, Table, CSV header).
+- Existing links are byte-identical: all `measured*` keys carry `basis: 'gpu-measured'`, and
+  `MEASURED_METRIC_DEFAULTS` did not change.
+- Choosing a derived boundary snaps to its canonical combination (whole deployment, average
+  watts, joules per output token). Changing any telemetry-only setting while on a derived
+  boundary returns to GPU measured, so no control ever points at a key that does not exist.
+- A gated metric selected through a shared URL keeps its Measured controls, as the
+  `measured*` siblings already do.
+- The Y-axis dropdown's collapsed "Measured Power" / "Measured Energy" option for the other
+  family resolves to `MEASURED_METRIC_DEFAULTS[family]` (GPU measured), so switching family
+  from the dropdown resets the boundary; the resolver itself keeps `basis` on a family change
+  (`changeMeasuredMetricConfig(key, { family })`), which is what a future family control in
+  the Measured row should call.
+
+The Boundary select tracks `inference_power_basis_changed { basis, family }` in addition to the
+existing `inference_y_axis_metric_selected` fired by `ChartControls`.
+
+## Missing values
+
+A point without a value for the selected boundary is omitted from that series only (the
+builders never emit `{ y: 0 }`, and both the official and overlay paths filter by
+`metricKey in point`). The PowerX availability panel explains the gap per point:
+
+| State              | Meaning                                                                                                                                                  |
+| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `noSpec`           | hardware has no `tdp` / `power` in `HW_REGISTRY`                                                                                                         |
+| `noThroughput`     | provisioned watts exist but the row has no output throughput                                                                                             |
+| `noNormalization`  | disaggregated row with throughput but no whole-deployment GPU count (`powerBasisNormalization`: not `single_turn`, or non-integer prefill/decode counts) |
+| `noTelemetry`      | modeled boundary needs validated GPU telemetry (B4 follows B1)                                                                                           |
+| `invalid`          | `power_valid === 0`                                                                                                                                      |
+| `modelWorkload`    | chassis model covers 8K / 1K only                                                                                                                        |
+| `modelHardware`    | hardware outside the chassis profiles (GB200 / GB300 NVL72)                                                                                              |
+| `modelUnsupported` | other `modelSystemPower` reasons (gpu-count, topology, role-power …)                                                                                     |
+
+The chart caption (`data-testid="power-basis-assumptions"`) names the boundary, the formula in
+words, the PUE constant and the chassis-model revision so a screenshot records its method.
+The pinned tooltip's "Modeled system power" block (`tooltipUtils.ts` `modeledSystemPowerHTML`)
+renders only for `measured*` keys and `y_modeledChassisPowerPerGpu`, so on the boundary keys the
+caption is the only per-chart provenance; the caption does not promise more.
+The empty state for the utility-modeled boundary says why nothing rendered and points at the
+Boundary select.
+
+## Article figure → share link
+
+Base: `/inference?g_model=<model>&i_seq=8k/1k&i_prec=<precision>` plus the hardware legend
+selection. Append:
+
+| Figure | Content                                       | Parameters                                                                                                                                                               |
+| ------ | --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 2      | H200 W/GPU, all four boundaries on one chart  | `&i_metric=y_measuredAvgPower&i_pcompare=boundaries` (one boundary at a time: `&i_metric=y_gpuProvisionedWatts` / `y_utilityProvisionedWatts` / `y_utilityModeledWatts`) |
+| 3      | H200 J/output token, all four boundaries      | `&i_metric=y_measuredJPerOutputToken&i_pcompare=boundaries` (single boundary: the matching `…JPerOutputToken` key)                                                       |
+| 4 / 5  | B200 vs B300, GB200 vs GB300 at fixed X       | `&i_metric=<measured key>&i_rulers=<x>` (Perf Ruler, T1)                                                                                                                 |
+| 6      | Prefill vs decode W/GPU with the whole deploy | `&i_metric=y_measuredAvgPower&i_pcompare=roles`                                                                                                                          |
+| 7      | Reconstructed request energy, prefill share   | `&i_metric=y_measuredJPerOutputToken&i_pcompare=roles` (prefill share in the clone's tooltip)                                                                            |
+| 1      | Measured power over the benchmark job         | `&i_metric=y_measuredPowerTimeline` (Display → Timeline, see below)                                                                                                      |
+
+The `/gpu-metrics` page keeps the raw per-run explorer (every metric, one artifact at a time);
+the timeline below is the chart-scoped view of the same artifacts.
+
+## Comparison series (`i_pcompare`)
+
+`i_pcompare=boundaries|roles` (default `''`, "Off") overlays sibling series on the selected
+metric without changing it. `utils/power-compare.ts` is the single source: `useChartData` and
+the `?unofficialrun=` processor (`processOverlayChartDataWithClipping`) both call
+`expandPowerCompareSeries`, which appends one clone per sibling to every base point — same
+`x`, `y` taken from the sibling's field, `powerVariant` set — and leaves the base points
+untouched, so a chart without a comparison is byte-identical to before. A point lacking a
+sibling's value contributes nothing to that series (never a 0), so each boundary's and
+role's availability rules carry through unchanged.
+
+| Mode         | Base series                                       | Siblings                   | Fields                                                                                                                                                                               |
+| ------------ | ------------------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `boundaries` | the selected boundary (`basis` of the metric key) | the other three boundaries | `measuredAvgPower` / `POWER_BASIS_FIELDS[*].watts`, or `measuredJPerOutputToken` / `POWER_BASIS_FIELDS[*].energy`                                                                    |
+| `roles`      | the selected scope (`all`, `prefill`, `decode`)   | the other two worker pools | W: `measuredAvgPower`, `measuredPrefillAvgPower`, `measuredDecodeAvgPower`; J/out: `measuredJPerOutputToken`, `reconstructedPrefillJPerOutputToken`, `measuredDecodeJPerOutputToken` |
+
+Siblings exist only where the metric names the whole-deployment **average W/chip** or **J per
+output token** (the only quantities every boundary and role publishes on one axis); role
+energy additionally excludes the prefill J per input token scope. Elsewhere
+`powerCompareVariants` returns nothing, the Compare select disables the option, and — when a
+link arrives with an inapplicable mode — a hint (`measured-compare-hint`) says the comparison is
+paused. The parameter is kept, so switching back to an applicable setting resumes it.
+
+Rendering (`ScatterGraph`): the series key is `scatterSeriesKey(point)` =
+`<hwKey>_<precision>[-v-<variant>]` (`utils/point-identity.ts`), so rooflines, frontiers,
+Optimal Only, line labels, overflow continuations and the perf ruler treat each sibling as its
+own series; `parseScatterSeriesKey` recovers hardware, precision and variant wherever the key
+was previously split on `_`. Siblings keep the hardware colour (overlay runs keep the run
+colour) and take a per-variant `stroke-dasharray` (`powerVariantDash`); clone points render
+at 0.6 opacity behind their base and carry `data-power-variant`. Line labels are placed per
+hardware _and_ sibling: the base series keeps its plain hardware label, while a sibling appends
+` · <short name>` (`powerLineLabel`: TDP, All-in, PUE modeled, Prefill GPUs, …) and, when a
+boundary is flat on a watts axis, its shared value (`B300 (SGLang) · TDP 1.2 kW`), so an exported
+PNG explains its dashed lines without the legend; each pill carries `data-series-id`
+(`<hw>::<variant>` for a sibling) and `data-power-variant`. The legend appends one
+line-swatch row per series present (base first); rows toggle chart-local visibility
+(`hiddenPowerVariants`, not in the URL) and hover-highlight that series across every hardware.
+`scatterPointConfigId` includes the variant so a clone never replaces its base in a D3 join.
+Tooltips add a "Series" line; on the energy axis a role clone also reports its share of the
+reconstructed request energy. Table adds a "Series" column and CSV a trailing "Power Series"
+column only while clones are present. Comparison clones are excluded from `bestSeriesPerSku`,
+the power-tier counts, the legend points table, the availability panel (which reads
+`selectionPoints`) and the date-comparison `GPUGraph`. Unofficial-run pills read `✕ <hardware>` (`getOverlayLineLabel`); the branch stays in the
+legend and a short run tag (` · main`, ` · …<date>-<sha>`) is appended only when several overlay
+runs draw the same hardware.
+
+Figure 7's reconstruction lives in `utils/role-energy.ts`: schema-2 aggregate energy has one
+numerator, so `J/out ÷ J/in` is the served input:output token ratio and
+`prefill_joules_per_input_token × (J/out ÷ J/in)` is the prefill pool's energy per output
+token; with `decode_joules_per_output_token` it sums back to the deployment's J/out when the
+pool energies partition the total. `buildDerivedChartFields` emits it as
+`reconstructedPrefillJPerOutputToken` for validated (`power_valid === 1`, schema 2)
+disaggregated rows only; it is never a y-axis of its own.
+
+The Compare select tracks `inference_power_compare_changed { mode, family }`; legend rows
+track `inference_power_compare_series_toggled { series, visible }`.
+
+## Power timeline (Display → Timeline)
+
+`y_measuredPowerTimeline` is the third value of the Measured Power **Display** control
+(`watts` / `tdp` / `timeline`, `MeasuredPowerDisplay` in `measured-metric-config.ts`). Its
+registry field aliases `measuredAvgPower`, so the point set, the availability panel, the Table
+view and the share link are those of the measured average; only the chart body changes:
+`ChartDisplay` renders `ui/PowerTimeline.tsx` instead of `ScatterGraph` when the resolved
+config is `display: 'timeline'`.
+
+- **Join.** Each validated row's `power_audit.source` is `power_validation_<name>.json`.
+  Two collectors publish the telemetry behind it (`utils/powerTimeline.ts`):
+  - single-node runners upload one `gpu_metrics_<name>` CSV artifact per config
+    (`benchmark-tmpl.yml`), so the source names the artifact exactly
+    (`telemetryArtifactForPoint`);
+  - Slurm / Dynamo disaggregated runners upload one `power_audit_<RESULT_FILENAME>` bundle per
+    concurrency sweep whose `LOGS/power/samples.csv` (DCGM, `<hostname>/<GPU-uuid>` per device)
+    covers every concurrency. The API cuts it into one series per `power_validation_*.json` the
+    bundle contains (`components/gpu-power/power-audit-bundle.ts`: the validation file's
+    `selected_window` ± 60 s, roles from its `per_gpu_role`, manifest `expected_devices` as the
+    fallback) and labels each with that file name in `series.source`, which `joinPowerTimeline`
+    matches before falling back to the artifact name.
+
+  Nothing is matched by hardware or concurrency. Rows whose telemetry is missing (expired
+  artifact, bundle over the download cap, another collector) are listed under the chart
+  (`data-testid="power-timeline-missing"`), never estimated. Trace keys are
+  `<runId>:<name>` (`traceKeyForPoint`), unique per point in both collectors.
+
+- **Fetch.** One request per workflow run in the visible points
+  (`planPowerTimelineRequests`, at most `POWER_TIMELINE_MAX_RUNS`; a deep-linked trace's run
+  goes first, then `?unofficialrun=` overlay runs, then official runs — `prioritizeRun` /
+  `prioritizeRuns` — so an overlay the user asked for is never the run that gets dropped),
+  narrowed with
+  `prefix=` to the common RESULT_FILENAME prefix so a nightly sweep's other models are not
+  downloaded. `/api/gpu-metrics?series=power` returns one-second per-GPU buckets
+  (`components/gpu-power/power-series.ts`, ~1 MB for a 25-config run instead of ~27 MB of
+  raw rows); with `series=power` the route also downloads `power_audit_*` bundles whose name
+  shares the prefix (a bundle names the sweep, so the match runs both ways), reads only
+  `LOGS/power/samples.csv`, `LOGS/power/manifest.json` and the top-level
+  `power_validation_*.json` entries, and skips bundles above 256 MiB (the GB200 nw8 sweep is
+  215 MB). A bundle-cut series carries `source` and `devices[] { id, role? }`; CSV series carry
+  neither. Runner timestamps are UTC wall clock and are parsed as such
+  (`parseTelemetryTimestampUtc`); `new Date('2026/09/12 20:19:57')` would read browser local
+  time and misplace the audit window.
+- **Legend with overlays.** Once `?unofficialrun=` data is in, the chart reads
+  `localOfficialOverride`, so the timeline legend writes the unified selection
+  (`setUnifiedOverlaySelection`, `computeToggle` solo semantics) exactly as `ScatterGraph`
+  does; the context's `toggleHwType` alone would change nothing visible there.
+
+- **Drawing.** One trace per config, mean of its GPUs (legend switch: one line per GPU),
+  coloured by hardware for official rows and by `overlayRunColor(runIndex)` for
+  `?unofficialrun=` rows; legend toggles follow `activeHwTypes` / `activeOverlayHwTypes`
+  exactly as in `ScatterGraph`. The whole job is drawn faint and the `power_audit` window
+  emphasized (`data-segment="full" | "window"`). Rated TDP is a dashed reference per hardware;
+  the all-in provisioned line is an opt-in legend switch because it halves the traces'
+  vertical resolution. X axis: wall clock (UTC) when the visible traces come from one run,
+  otherwise seconds since each trace's start; both are a toolbar toggle. `c<conc>` labels sit
+  at the end of the emphasized segment.
+- **Pools (Figure 1).** The legend switch _Prefill / decode pools_ (shown when a visible
+  trace carries worker roles) sums the board power of each role's GPUs
+  (`tracePools` / `sumPowerAt`) and draws one line per pool — prefill dashed `7 3`, decode
+  `2 3`, the same dashes as the `i_pcompare=roles` series — labelled `c<conc> · prefill` /
+  `· decode`, on a _GPU pool power (W)_ axis. Traces without roles draw their deployment total
+  as one `all` line so single-node configs stay comparable. Reference lines become pool size ×
+  rated TDP per (hardware, pool size): roles of one hardware that hold the same GPU count share
+  one line labelled `prefill / decode ×16` (`data-pool` on `.power-reference` lists the roles,
+  `groupPoolsBySize`), and labels of lines at equal watts stack upward (`referenceLabelSlots`)
+  instead of overprinting; and the
+  all-in switch scales the same way. The tooltip names the pool, its summed watts against the
+  pool TDP, and the mean / min / max per GPU inside it. Pool mode and per-GPU lines are
+  mutually exclusive.
+- **Deep link.** A pinned scatter tooltip on any metric of the measured family offers _View
+  power trace_ (`data-action="view-power-trace"`, official and `?unofficialrun=` points
+  alike). It switches the Display to Timeline in place and records the point's trace key in a
+  one-shot module store (`requestPowerTraceFocus`); the timeline consumes it on mount, dims
+  every other trace, switches to pool mode when the trace has roles, and shows a _Focused on …_
+  chip (`data-testid="power-timeline-focus"`) with _Show all_ to clear. The link's `href` is
+  the current page with `i_metric=y_measuredPowerTimeline`, so open-in-new-tab lands on the
+  timeline (unfocused: the focus is a gesture, not URL state).
+- **State.** Axis mode, line mode (mean / per GPU / pools), the all-in switch, the focused
+  trace and hover highlight are component state, not URL state: the share link is `i_metric=y_measuredPowerTimeline` plus the usual
+  scope, and a reader lands on the same defaults.
+- **Analytics.** `inference_power_timeline_loaded { traces, missing, runs }`,
+  `inference_power_timeline_axis_changed { mode }`,
+  `inference_power_timeline_lines_changed { lines: 'mean' | 'gpu' | 'pool' }`,
+  `inference_power_timeline_utility_toggled { enabled }`,
+  `inference_power_trace_opened { hwKey, conc, overlay }` (scatter tooltip action),
+  `inference_power_timeline_focus_cleared`.
+
+## Tests
+
+- `metric-registry.test.ts` — the six keys are in the gated group, resolve as themselves, are
+  bilingual, are not `measured*` keys, and map 1:1 onto `POWER_BASIS_FIELDS`.
+- `measured-metric-config.test.ts` — basis round-trips, snapping, return-to-measured, family
+  switch.
+- `measured-power-direction.test.ts` — watt keys share the measured corners and ascending
+  table sort, are power-curve metrics (upper envelope keeps the dominated peak) but not
+  measured-power-curve metrics; energy keys use the Pareto frontier and stay off the envelope.
+- `cypress/component/power-metric-availability.cy.tsx` — per-point explanations (en/zh)
+  including `noSpec`, `noNormalization`, `modelWorkload`, the overlay-aware count, and the
+  measured dictionary staying separate from the boundary dictionary.
+- `cypress/e2e/powerx-basis.cy.ts`, `measured-power-overlay.cy.ts` — control, URL, table,
+  `/zh`, overlay run.
+- `power-series.test.ts` — UTC timestamp parsing, one-second bucketing with `null` gaps, pool
+  sums.
+- `power-audit-bundle.test.ts` — cutting a DCGM bundle into per-validation series: window
+  clipping, device order and roles (validation file, manifest fallback), malformed entries.
+- `utils/powerTimeline.test.ts` — artifact-name and `source` joins, trace keys, per-run request
+  planning with the common prefix, missing rows, window phases, role pools, the focus store.
+- `api/gpu-metrics/route.test.ts` — `series=power` shape, `prefix=` narrowing the downloads
+  (both ways for bundles), the bundle size cap, the raw shape ignoring bundles, 400s for
+  malformed params.
+- `cypress/component/power-timeline.cy.tsx` — traces, emphasized window, TDP / all-in
+  references, per-GPU lines, pool lines with per-pool TDP, the focus chip, axis toggle,
+  overlay-run colour and filter, failed run, `/zh`.
+- `cypress/e2e/powerx-timeline.cy.ts` — Display → Timeline round trip through the share link,
+  shared-link entry, Table view on the alias, `?unofficialrun=` overlay traces, _View power
+  trace_ from a pinned tooltip (official and overlay), `/zh`.
diff --git a/docs/state-ownership.md b/docs/state-ownership.md
index d4922dae3..4c8ff69d5 100644
--- a/docs/state-ownership.md
+++ b/docs/state-ownership.md
@@ -113,12 +113,65 @@ them.
 Axis and presentation state:
 
 - selected x-axis and y-axis metrics, percentile, and effective x-axis mode
+- the Measured controls (Boundary / Per / Scope / Statistic / Display / Unit) own no state: `measured-metric-config.ts` resolves each selection to the nearest registered metric key and writes it back to `selectedYAxisMetric`, so the power boundary rides on `i_metric` (there is deliberately no `i_pbasis`; see [PowerX Permanent View](./powerx-permanent-view.md))
+- the Measured Power Display value `timeline` (`y_measuredPowerTimeline`) swaps the chart body for `PowerTimeline`; its axis mode, per-GPU lines and all-in reference switch are component state and never enter the URL
 - token-revenue price source (`i_revenue`): normalized uncached/cached/output pricing or the selected model's live OpenRouter catalog prices
 - scale, optimal-point, label, contrast, legend, and overlay controls
 
 Display changes stay in this domain. A contrast or label toggle therefore does not
 notify filter-only or data-only consumers.
 
+**`usePerfRulerStore`** (perf rulers, `i_rulers`)
+
+Completed Perf Rulers on the primary inference chart (`chart-0`) are provider state,
+exposed through a dedicated `PerfRulerStoreContext`
+(`packages/app/src/components/inference/perf-ruler-store.ts`) rather than the display domain: a
+ruler commit would otherwise rerender every display consumer, and harnesses that mount
+`InferenceContextsProvider` with static mock values would silently lose ruler
+interactivity. The store is scoped to one chart id on purpose. The replay chart
+(`replay-chart-0`) draws the same curve classes under the same provider, so a shared
+store would render every ruler twice and let the replay's prune pass delete rulers the
+main chart still shows; it and `GPUGraph` keep component-local state, which `ScatterGraph`
+also falls back to when no store is present.
+
+`ScatterGraph` reads `state`/`setState` from the store, so the existing reducers, refs,
+and draw passes are unchanged. The one thing that moved is the axis reset:
+`usePerfRulerAxisReset` adjusts state during the chart's render, which is only legal for
+the chart's own state, so for persisted rulers the same reset (either axis metric changes
+→ rulers, draft, and pending share-link rulers are cleared) runs inside the provider. Its
+key, `persistedPerfRulerAxisKey`, describes the graph `ChartDisplay` renders as `chart-0`,
+not `graphs[0]`: `graphs` is always `[interactivity, e2e]` and ChartDisplay shows the e2e
+graph for every non-interactivity x mode, so the key picks the graph by `selectedXAxisMode`
+(as `bestHwTypes` does), uses its `x_scale_field` (which carries the percentile), and folds
+the mode itself in because the derived agentic modes override the e2e graph's x field inside
+ChartDisplay only. The first chart definition (null → key) and a reload of the same axes
+(key → null → key) are not axis changes, so share-link rulers survive the load.
+
+Restoring from a link is a two-phase commit because of a load race. Rulers parsed from
+`i_rulers` start as `pending`; data, `i_gpus`, comparison dates, and `?unofficialrun=`
+overlays all arrive after the chart's first draw, and the chart prunes any committed
+ruler whose curve path is absent from the DOM. The chart therefore commits a pending
+ruler only once BOTH of its curve paths exist (hidden-at-opacity-0 counts as present, as
+for prune), clamping the iso-x to the pair's overlap through the drawn paths. The commit
+runs inside the perf-ruler D3 layer's draw pass (`drawPerfRuler`), not in a React effect:
+the chart's first draw happens in a `D3Chart`-local re-render after its container is
+measured, which re-renders nothing in `ScatterGraph`, so an effect keyed on the chart's
+props could miss the first draw and leave resolvable rulers pending for the session. No
+commit happens while the ruler mode is off (the power envelope forces it off on
+non-measured axes; the mode-off effect discards pending rulers instead). Rulers whose
+curves never appear stay pending — invisible and unserialized — until an axis change,
+toggle-off, or clear discards them; this is a deliberate choice over a "data settled"
+readiness predicate (fragile across the async order of availability, benchmark, overlay,
+and derived-metric fetches). The visible cost is that a link whose curves the recipient's
+view lacks lands with the ruler switch on and nothing drawn, and a later legend change on
+the same axes can surface the ruler. A non-empty restore switches the ruler mode on for
+that chart instance (rulers only render in mode) and fires
+`interactivity_perf_ruler_shared_load` once per opened link, with `count` = the number of
+rulers the link carried, the first time any of them renders — never per commit batch, so
+the event counts links, not curve arrivals. Because the URL is read in a `useState`
+initialiser, a retained-provider tab switch onto `/inference?i_rulers=…` does not
+re-import the param — the same limitation as the other `i_*` toggles.
+
 **`useInferenceActions`**
 
 All inference commands and setters. The context value and every exposed action keep
@@ -360,3 +413,24 @@ Dashboard scope membership is declared by `shareParamScopes` in
 `packages/app/src/lib/dashboard-routes.ts`. Tests enforce completeness and route-specific
 share behavior, so this document deliberately does not duplicate a manually maintained
 parameter table.
+
+One entry needs a note on its encoding: `i_rulers` (inference scope, default `''`) is
+`serializePerfRulers` output — `isoX|curveA|curveB` per ruler joined by `;`, where the
+curve ids are the rendered roofline path identity classes (`roofline-<hwKey>_<precision>`,
+`overlay-roofline-<hwKey>_<precision>_run<N>`, optionally `__<encoded date>`) and the
+iso-x is in DATA space rounded to four significant digits. `parsePerfRulers` only accepts
+curve ids of that identity-class shape — the shared `roofline-path` marker class or any
+other zoom-group node would match many paths and draw a ruler between arbitrary curves.
+Only committed rulers are serialized (never the draft or still-pending link rulers), and
+the chart prunes them against the rendered curves, so a link written from one data set
+degrades to fewer rulers, never to an error. Overlay ids depend on the run order in `unofficialruns`, which the share
+link already carries.
+
+`i_pcompare` (inference scope, default `''`) is the power comparison mode, `boundaries` or
+`roles`, owned by `InferenceProvider` as `powerCompare` (display context) with
+`setPowerCompare` (actions). It is written as `''` for `none`. It is deliberately NOT cleared
+when the metric changes to one without a common axis for the siblings: the chart then draws
+the metric alone and the Measured controls show a hint, so the link's intent survives a
+detour through another setting. Which comparison rows a reader hid from the legend is
+`ScatterGraph` component state (`hiddenPowerVariants`), never shared — see
+[PowerX Permanent View](./powerx-permanent-view.md#comparison-series-i_pcompare).
diff --git a/docs/tco-calculator.md b/docs/tco-calculator.md
index 42668a738..756ccf4d8 100644
--- a/docs/tco-calculator.md
+++ b/docs/tco-calculator.md
@@ -1206,3 +1206,55 @@ The captured API fixtures carry no `agentic_traces` rows, so the Cypress spec
 (`cypress/e2e/profit-estimator.cy.ts`) intercepts availability and benchmarks with
 synthetic Kimi K3 curves from `cypress/support/profit-fixtures.ts`. The H200 curve
 stops below 45 tok/s/user on purpose so the exclusion path stays covered.
+
+## First-Token Limits (`/first-token`)
+
+> Hosted by `FirstTokenLimitsDisplay.tsx` with the selection in `first-token-limits.ts`
+> and the bars in `FirstTokenLimitsChart.tsx`. Mirrored at `/zh/first-token`. Footer-only
+> navigation, like Fleet Lifecycle.
+
+The calculator answers "what does each chip cost at this interactivity". This tab adds
+the constraint an interactivity target leaves out: how long the user waits for the first
+token. For each cap in a ladder (default 2 / 5 / 10 / 15 / 20 s) it keeps, per vendor, the
+cheapest **measured** row whose interactivity clears a floor (default 150 tok/s/user for
+AgentX, 35 for fixed sequences) and whose TTFT is under the cap. Under each cap it names
+the winning SKU against the runner-up vendor and the gap as a percentage of the runner-up.
+
+It started as a one-off article figure ("First-token limits change the best tested
+systems"); the point of the tab is that every model, workload, and precision gets the
+figure with no regeneration.
+
+- **Measured rows, not the frontier.** The calculator's spline tracks throughput against
+  interactivity; a TTFT cap is a third constraint the frontier does not carry, and a knot
+  that interpolates cheaply can sit between two rows whose first-token waits differ by
+  seconds. Reading rows keeps every bar a configuration that ran under both constraints,
+  and gives the tooltip and table a run URL to cite. The trade is granularity: a cheaper
+  configuration can sit just outside a cap and only appear under the next one, which the
+  note under the chart says.
+- **Two separate percentile statistics.** The floor and the cap are both read on the same
+  row, at the selected percentile for agentic rows (P90 by default, P75 behind the
+  feature gate) and the median for fixed sequences — the split the inference chart's
+  axes make. Clearing both means the row cleared each measure, not that every request
+  did; the note says that too.
+- **`ttft` on `GPUDataPoint`.** The shared row → point mapper (`buildGpuGroups`) sets it,
+  so official and overlay rows get it by the same rule. It is absent, never zero, when
+  the row has no measurement: a zero would clear every cap.
+- **Vendors from the registry.** Series are the vendors of the visible hardware
+  (`HW_REGISTRY[base].vendor`), NVIDIA then AMD then alphabetical, so a third vendor is
+  a third bar with no code change. A vendor with rows but nothing under a cap keeps its
+  slot with a `—` marker: "nothing measured under this limit" is the finding.
+- **Overlays are their own series.** Each `?unofficialrun=` run contributes one bar per
+  cap — its cheapest qualifying row across every chip it touched — in `overlayRunColor`,
+  labelled `✕ branch`. Overlay rows never enter a vendor bar or the gap summary. The
+  legend is the calculator's: one entry per chip governs official and overlay bars
+  together, and overlay-only hardware is merged in so it can be hidden.
+- **URL state.** `c_ivmin` (floor) and `c_ttft` (comma-joined ladder, at most eight
+  values) on top of the calculator seed (`g_model`, `i_seq`, `i_prec`, `i_pctl`,
+  `g_rundate`). Empty means the sequence-aware default and is not written, so a link
+  without them follows the defaults if they change.
+
+### Fixtures
+
+`cypress/e2e/first-token-limits.cy.ts` reuses `interceptCalculatorOverlayRun`: every
+fixed-sequence row reports a 0.5 s median TTFT, so `c_ttft=0.1,2` gives one cap nothing
+clears and one cap everything clears, and the interactivity floor picks the concurrency.
diff --git a/packages/app/AGENTS.md b/packages/app/AGENTS.md
new file mode 100644
index 000000000..643577dfa
--- /dev/null
+++ b/packages/app/AGENTS.md
@@ -0,0 +1,9 @@
+<!-- BEGIN:nextjs-agent-rules -->
+
+# This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in `node_modules/next/dist/docs/` (resolved from this file's directory; in monorepos the `next` package may not be visible from the repo root) before writing any code. Heed deprecation notices.
+
+This block is written and re-added by `next dev` — verify at `node_modules/next/dist/server/lib/generate-agent-files.js`. Removing it from a diff only re-creates the uncommitted change; committing it with your work keeps the tree clean.
+
+<!-- END:nextjs-agent-rules -->
diff --git a/packages/app/CLAUDE.md b/packages/app/CLAUDE.md
new file mode 100644
index 000000000..43c994c2d
--- /dev/null
+++ b/packages/app/CLAUDE.md
@@ -0,0 +1 @@
+@AGENTS.md
diff --git a/packages/app/cypress/component/inference-chart-controls.cy.tsx b/packages/app/cypress/component/inference-chart-controls.cy.tsx
index ded6bd9ba..4445d303b 100644
--- a/packages/app/cypress/component/inference-chart-controls.cy.tsx
+++ b/packages/app/cypress/component/inference-chart-controls.cy.tsx
@@ -469,8 +469,10 @@ describe('Inference ChartControls grouped measured metrics', () => {
       cy.get(`input[aria-label="${searchLabel}"]`).type(group);
       cy.get('[data-select-option][data-value^="y_measured"]').should(($options) => {
         const values = [...$options].map((option) => option.dataset.value);
-        expect(values).to.have.length(13);
-        expect(new Set(values).size).to.equal(13);
+        // Thirteen measured axes plus the Timeline display of measured power.
+        expect(values).to.have.length(14);
+        expect(new Set(values).size).to.equal(14);
+        expect(values).to.include('y_measuredPowerTimeline');
       });
       cy.get(`input[aria-label="${searchLabel}"]`).clear().type(power);
       cy.get('[data-select-option]')
diff --git a/packages/app/cypress/component/measured-metric-controls.cy.tsx b/packages/app/cypress/component/measured-metric-controls.cy.tsx
new file mode 100644
index 000000000..bd34d29b4
--- /dev/null
+++ b/packages/app/cypress/component/measured-metric-controls.cy.tsx
@@ -0,0 +1,38 @@
+import { MeasuredMetricControls } from '@/components/inference/ui/MeasuredMetricControls';
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+
+describe('MeasuredMetricControls statistic layout', () => {
+  for (const pathname of ['/inference', '/zh/inference']) {
+    for (const width of [375, 1280]) {
+      it(`contains statistic labels at ${width}px on ${pathname}`, () => {
+        cy.viewport(width, 800);
+        cy.mount(
+          <PathnameContext.Provider value={pathname}>
+            <div style={{ width: '100%', maxWidth: 570 }}>
+              <MeasuredMetricControls
+                metric="y_measuredAvgPower"
+                onChange={cy.stub().as('change')}
+              />
+            </div>
+          </PathnameContext.Provider>,
+        );
+        cy.get('[data-testid^="measured-power-statistic-"]')
+          .should('have.length', 3)
+          .each(($button) => {
+            const button = $button[0];
+            const bounds = button.getBoundingClientRect();
+            const group = button.parentElement!.getBoundingClientRect();
+            const range = button.ownerDocument.createRange();
+            range.selectNodeContents(button);
+            const label = range.getBoundingClientRect();
+            expect(label.left, 'label stays inside its button').to.be.at.least(bounds.left);
+            expect(label.right, 'label stays inside its button').to.be.at.most(bounds.right);
+            expect(bounds.left, 'button stays inside the group').to.be.at.least(group.left);
+            expect(bounds.right, 'button stays inside the group').to.be.at.most(group.right);
+          });
+        cy.get('[data-testid="measured-power-statistic-p75"]').click();
+        cy.get('@change').should('have.been.calledOnceWith', 'y_measuredP75Power');
+      });
+    }
+  }
+});
diff --git a/packages/app/cypress/component/power-compare.cy.tsx b/packages/app/cypress/component/power-compare.cy.tsx
new file mode 100644
index 000000000..d14304e38
--- /dev/null
+++ b/packages/app/cypress/component/power-compare.cy.tsx
@@ -0,0 +1,568 @@
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+
+import ScatterGraph from '@/components/inference/ui/ScatterGraph';
+import type { InferenceData } from '@/components/inference/types';
+import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
+import { Precision } from '@/lib/data-mappings';
+import { overlayRunColor } from '@/lib/overlay-run-style';
+
+import {
+  createMockChartDefinition,
+  createMockHardwareConfig,
+  createMockInferenceData,
+} from '../support/mock-data';
+import { mountWithProviders } from '../support/test-utils';
+
+// Power comparison series (`i_pcompare`): useChartData / the overlay processor
+// append one clone per boundary or role to every base point. ScatterGraph must
+// draw the clones as their own series — hardware colour, per-variant dash, its
+// own frontier — with legend rows that toggle and highlight them, and one line
+// label per series that names the boundary or role it plots.
+
+const OVERLAY_RUN_ID = 31415926535;
+const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
+const hwConfig = createMockHardwareConfig();
+const chartDefinition = createMockChartDefinition({
+  chartType: 'interactivity',
+  y_measuredAvgPower: 'measuredAvgPower.y',
+  y_measuredAvgPower_roofline: 'lower_left',
+  y_measuredJPerOutputToken: 'measuredJPerOutputToken.y',
+  // Interactivity chart, lower-is-better metric (metric-registry `rooflineDirection`).
+  y_measuredJPerOutputToken_roofline: 'lower_right',
+});
+
+type CompareMetric = 'y_measuredAvgPower' | 'y_measuredJPerOutputToken';
+
+const Y_LABELS: Record<CompareMetric, string> = {
+  y_measuredAvgPower: 'Measured Power per Chip (W)',
+  y_measuredJPerOutputToken: 'Energy per Output Token (J)',
+};
+
+const metric = (y: number) => ({ y, roof: false });
+
+interface CurveOptions {
+  run_url?: string;
+  precision?: Precision;
+  /** Measured W per chip at x = 8, 16, 32. Falls as x rises so every point sits on the envelope. */
+  measured?: readonly [number, number, number];
+  /** Per-chip provisioned boundaries; the defaults are the B200 registry figures. */
+  tdpWatts?: number;
+  allInWatts?: number;
+}
+
+/**
+ * H100 registry boundaries (700 W TDP, 1.37 kW all-in) with measured watts far
+ * enough below the TDP line that a label anchored on the wrong series is
+ * unambiguous in pixels.
+ */
+const H100_CURVE: CurveOptions = { measured: [400, 360, 320], tdpWatts: 700, allInWatts: 1370 };
+
+/**
+ * Three measured points with every boundary and both roles available. Power
+ * falls as x rises so every point sits on the upper power envelope the chart
+ * draws for watt axes (maximise x, keep the running maximum y).
+ */
+function measuredCurve(hwKey: string, options: CurveOptions = {}): InferenceData[] {
+  const {
+    run_url,
+    precision = Precision.FP4,
+    measured = [700, 600, 500],
+    tdpWatts = 1000,
+    allInWatts = 1710,
+  } = options;
+  return [
+    [8, 840, 500],
+    [16, 820, 450],
+    [32, 800, 400],
+  ].map(([x, prefill, decode], index) =>
+    createMockInferenceData({
+      hwKey,
+      x,
+      conc: x,
+      y: measured[index],
+      precision,
+      run_url,
+      disagg: true,
+      measuredAvgPower: metric(measured[index]),
+      measuredPrefillAvgPower: metric(prefill),
+      measuredDecodeAvgPower: metric(decode),
+      gpuProvisionedWatts: metric(tdpWatts),
+      utilityProvisionedWatts: metric(allInWatts),
+    }),
+  );
+}
+
+/**
+ * J per output token for the measured and provisioned boundaries. Energy rises
+ * with interactivity, so the lower-right Pareto frontier keeps all three points
+ * of every series.
+ */
+function energyCurve(hwKey: string): InferenceData[] {
+  return [
+    [8, 0.5, 0.9, 1.7],
+    [16, 0.6, 1, 1.9],
+    [32, 0.7, 1.1, 2.1],
+  ].map(([x, measured, tdp, allIn]) =>
+    createMockInferenceData({
+      hwKey,
+      x,
+      conc: x,
+      y: measured,
+      precision: Precision.FP4,
+      disagg: true,
+      measuredJPerOutputToken: metric(measured),
+      gpuProvisionedJPerOutputToken: metric(tdp),
+      utilityProvisionedJPerOutputToken: metric(allIn),
+    }),
+  );
+}
+
+function mountCompare(
+  data: InferenceData[],
+  options: {
+    pathname?: string;
+    overlay?: InferenceData[];
+    hiddenNonOptimal?: boolean;
+    metric?: CompareMetric;
+    lineLabels?: boolean;
+    precisions?: Precision[];
+  } = {},
+) {
+  const metricKey = options.metric ?? 'y_measuredAvgPower';
+  mountWithProviders(
+    <PathnameContext.Provider value={options.pathname ?? '/inference'}>
+      <div style={{ width: 1000, height: 640 }}>
+        <ScatterGraph
+          chartId="power-compare-test"
+          modelLabel="DeepSeek V4 Pro"
+          data={data}
+          xLabel="Interactivity (tok/s/user)"
+          yLabel={Y_LABELS[metricKey]}
+          chartDefinition={chartDefinition}
+          overlayData={
+            options.overlay
+              ? {
+                  data: options.overlay,
+                  hardwareConfig: hwConfig,
+                  label: 'powerx-compare',
+                  runUrl: OVERLAY_RUN_URL,
+                }
+              : undefined
+          }
+        />
+      </div>
+    </PathnameContext.Provider>,
+    {
+      inference: {
+        selectedYAxisMetric: metricKey,
+        hardwareConfig: hwConfig,
+        activeHwTypes: new Set(['b200', 'h100']),
+        hwTypesWithData: new Set(['b200', 'h100']),
+        selectedPrecisions: options.precisions ?? [Precision.FP4],
+        hideNonOptimal: options.hiddenNonOptimal ?? false,
+        showLineLabels: options.lineLabels ?? false,
+      },
+      unofficial: options.overlay
+        ? {
+            isUnofficialRun: true,
+            activeOverlayHwTypes: new Set(['h100']),
+            allOverlayHwTypes: new Set(['h100']),
+            runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [String(OVERLAY_RUN_ID)]: 0 },
+            unofficialRunInfos: [
+              {
+                id: OVERLAY_RUN_ID,
+                name: 'powerx-compare',
+                branch: 'powerx-compare',
+                sha: 'abc000',
+                createdAt: '2026-09-01T00:00:00Z',
+                url: OVERLAY_RUN_URL,
+                conclusion: 'success',
+                status: 'completed',
+                isNonMainBranch: true,
+              },
+            ],
+          }
+        : {},
+    },
+  );
+}
+
+const svg = '#power-compare-test svg';
+const legend = '#power-compare-test [data-testid="chart-legend"]';
+const lineLabels = `${svg} .line-label`;
+/** Selector for the pill of one comparison series, relative to the chart svg. */
+const labelSelector = (variant: string) => `.line-label[data-power-variant="${variant}"]`;
+const lineLabel = (variant: string) => `${svg} ${labelSelector(variant)}`;
+
+/** A pill's rendered text, whitespace-normalised across its tspans. */
+const pillText = (node: Element): string =>
+  (node.querySelector('.ll-text')?.textContent ?? '').replaceAll(/\s+/gu, ' ').trim();
+
+/** Rendered pill text keyed by the comparison variant the pill labels. */
+const pillTextByVariant = ($labels: JQuery<HTMLElement>): Record<string, string> =>
+  Object.fromEntries([...$labels].map((node) => [node.dataset.powerVariant, pillText(node)]));
+
+/** Vertical translate of a `.line-label` or `.dot-group`, in zoom-group pixels. */
+const translateY = (node: Element): number => {
+  const match = /translate\([^,]+,(?<y>[^)]+)\)/u.exec(node.getAttribute('transform') ?? '');
+  return match?.groups?.y === undefined ? Number.NaN : Number.parseFloat(match.groups.y);
+};
+
+/** Pixel distance from `y` to the nearest marker of one comparison series. */
+const distanceToSeries = (root: Element, variant: string, y: number): number =>
+  Math.min(
+    ...[...root.querySelectorAll(`.dot-group[data-power-variant="${variant}"]`)].map((marker) =>
+      Math.abs(translateY(marker) - y),
+    ),
+  );
+
+describe('ScatterGraph power comparison series', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message.includes('ResizeObserver loop')) return false;
+    });
+  });
+
+  it('draws each boundary as a dashed sibling series in the hardware colour with a toggling legend row', () => {
+    const data = expandPowerCompareSeries(
+      measuredCurve('b200'),
+      'y_measuredAvgPower',
+      'boundaries',
+    );
+    // Three base points plus TDP and all-in clones; no modeled watts on these rows.
+    expect(data).to.have.length(9);
+    mountCompare(data);
+
+    cy.get(`${svg} .dot-group[data-power-variant=""]`).should('have.length', 3);
+    cy.get(`${svg} .dot-group[data-power-variant="gpu-provisioned"]`)
+      .should('have.length', 3)
+      .each(($point) => {
+        // Clones sit behind the base series they annotate.
+        expect(Number(getComputedStyle($point[0]).opacity)).to.be.closeTo(0.6, 0.01);
+      });
+    cy.get(`${svg} .roofline-path[data-hw-key="b200"]`).should('have.length', 3);
+    cy.get(`${svg} .roofline-path:not([data-power-variant])`)
+      .should('have.length', 1)
+      .and('not.have.attr', 'stroke-dasharray');
+    cy.get(`${svg} .roofline-path[data-power-variant="gpu-provisioned"]`)
+      .should('have.length', 1)
+      .and('have.attr', 'stroke-dasharray', '8 4');
+    cy.get(`${svg} .roofline-path[data-power-variant="utility-provisioned"]`)
+      .should('have.attr', 'stroke-dasharray', '3 3')
+      .then(($sibling) => {
+        cy.get(`${svg} .roofline-path:not([data-power-variant])`).should(($base) => {
+          // Same hardware, same colour: only the dash tells the series apart.
+          expect($sibling.attr('stroke')).to.eq($base.attr('stroke'));
+        });
+      });
+
+    // Legend: the base series first, then its siblings, each with a line swatch.
+    cy.get(legend).within(() => {
+      cy.contains('GPU measured').should('exist');
+      cy.contains('GPU provisioned (TDP)').should('exist');
+      cy.contains('Utility provisioned (all-in)').should('exist');
+      cy.contains('Utility modeled (PUE)').should('not.exist');
+      cy.contains('GPU provisioned (TDP)').click();
+    });
+    cy.get(`${svg} .roofline-path[data-power-variant="gpu-provisioned"]`).should(
+      'have.css',
+      'opacity',
+      '0',
+    );
+    cy.get(`${svg} .dot-group[data-power-variant="gpu-provisioned"]`).each(($point) => {
+      expect(getComputedStyle($point[0]).opacity).to.eq('0');
+    });
+    // The base series and the other sibling stay.
+    cy.get(`${svg} .roofline-path[data-power-variant="utility-provisioned"]`).should(
+      'have.css',
+      'opacity',
+      '1',
+    );
+    cy.get(`${svg} .dot-group[data-power-variant=""]`).each(($point) => {
+      expect(getComputedStyle($point[0]).opacity).to.eq('1');
+    });
+  });
+
+  it('draws role siblings for ?unofficialrun= overlays in the run colour with the role dash', () => {
+    const official = expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles');
+    const overlay = expandPowerCompareSeries(
+      measuredCurve('h100', { run_url: OVERLAY_RUN_URL }),
+      'y_measuredAvgPower',
+      'roles',
+    );
+    mountCompare(official, { overlay });
+
+    cy.get(`${svg} .roofline-path[data-power-variant="prefill"]`).should(
+      'have.attr',
+      'stroke-dasharray',
+      '7 3',
+    );
+    cy.get(`${svg} .unofficial-overlay-pt`).should('have.length', 9);
+    cy.get(`${svg} .overlay-roofline-path[data-power-variant="decode"]`)
+      .should('have.length', 1)
+      .and('have.attr', 'stroke', overlayRunColor(0))
+      .and('have.attr', 'stroke-dasharray', '2 3');
+    cy.get(`${svg} .overlay-roofline-path:not([data-power-variant])`).should('have.length', 1);
+    cy.get(legend).within(() => {
+      cy.contains('All GPUs').should('exist');
+      cy.contains('Prefill GPUs').should('exist');
+      cy.contains('Decode GPUs').click();
+    });
+    cy.get(`${svg} .overlay-roofline-path[data-power-variant="decode"]`).should(
+      'have.css',
+      'opacity',
+      '0',
+    );
+    cy.get(`${svg} .unofficial-overlay-pt`).then(($points) => {
+      const hidden = [...$points].filter((point) => getComputedStyle(point).opacity === '0');
+      expect(hidden).to.have.length(3);
+    });
+  });
+
+  it('keys legend rows by the comparison base when only an overlay carries the series', () => {
+    // No official measured points at all: the base row must still be the
+    // selected metric, and each sibling must keep its own toggle.
+    const overlay = expandPowerCompareSeries(
+      measuredCurve('h100', { run_url: OVERLAY_RUN_URL }),
+      'y_measuredAvgPower',
+      'roles',
+    );
+    mountCompare([], { overlay });
+
+    cy.get(`${svg} .unofficial-overlay-pt`).should('have.length', 9);
+    cy.get(legend).within(() => {
+      cy.contains('All GPUs').should('exist');
+      cy.contains('Decode GPUs').click();
+    });
+    cy.get(`${svg} .overlay-roofline-path[data-power-variant="decode"]`).should(
+      'have.css',
+      'opacity',
+      '0',
+    );
+    cy.get(`${svg} .overlay-roofline-path:not([data-power-variant])`).should(
+      'have.css',
+      'opacity',
+      '1',
+    );
+    cy.get(`${svg} .unofficial-overlay-pt`).then(($points) => {
+      const hidden = [...$points].filter((point) => getComputedStyle(point).opacity === '0');
+      expect(hidden).to.have.length(3);
+    });
+  });
+
+  it('translates the comparison legend rows on /zh', () => {
+    mountCompare(expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles'), {
+      pathname: '/zh/inference',
+    });
+    cy.get(legend)
+      .should('contain.text', '全部 GPU')
+      .and('contain.text', '预填充 GPU')
+      .and('contain.text', '解码 GPU');
+  });
+
+  // Line labels: one pill per drawn series. The base series keeps its ordinary
+  // hardware label; a sibling appends the boundary or role it plots, and on a
+  // watts axis a flat boundary also carries its per-chip watts.
+
+  it('labels every boundary series once, with the boundary watts, each on its own line', () => {
+    const data = expandPowerCompareSeries(
+      measuredCurve('h100', H100_CURVE),
+      'y_measuredAvgPower',
+      'boundaries',
+    );
+    mountCompare(data, { lineLabels: true });
+
+    cy.get(lineLabels).should('have.length', 3);
+    cy.get(lineLabel(''))
+      .should('have.length', 1)
+      .and('have.attr', 'data-series-id', 'h100')
+      .and('have.attr', 'data-visible', '1');
+    cy.get(lineLabel('gpu-provisioned'))
+      .should('have.length', 1)
+      .and('have.attr', 'data-series-id', 'h100::gpu-provisioned')
+      .and('have.attr', 'data-visible', '1');
+    cy.get(lineLabel('utility-provisioned'))
+      .should('have.length', 1)
+      .and('have.attr', 'data-series-id', 'h100::utility-provisioned')
+      .and('have.attr', 'data-visible', '1');
+    cy.get(lineLabels).then(($labels) => {
+      expect(pillTextByVariant($labels)).to.deep.equal({
+        '': 'H100',
+        'gpu-provisioned': 'H100 · TDP 700 W',
+        'utility-provisioned': 'H100 · All-in 1.37 kW',
+      });
+      // Same hardware, same pill colour: the text tells the series apart.
+      const fills = new Set(
+        [...$labels].map((node) => node.querySelector('.ll-bg')?.getAttribute('fill')),
+      );
+      expect([...fills]).to.have.length(1);
+    });
+
+    // Each pill hugs the series it names: the base label sits on the measured
+    // curve, not on the flat TDP line above it, and the TDP label vice versa.
+    cy.get(svg).then(($svg) => {
+      const root = $svg[0];
+      const pillY = (variant: string) => translateY(root.querySelector(labelSelector(variant))!);
+      const baseY = pillY('');
+      expect(distanceToSeries(root, '', baseY)).to.be.lessThan(
+        distanceToSeries(root, 'gpu-provisioned', baseY),
+      );
+      const tdpY = pillY('gpu-provisioned');
+      expect(distanceToSeries(root, 'gpu-provisioned', tdpY)).to.be.lessThan(
+        distanceToSeries(root, '', tdpY),
+      );
+    });
+  });
+
+  it('labels role siblings with the worker pool and never with watts', () => {
+    mountCompare(expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles'), {
+      lineLabels: true,
+    });
+
+    cy.get(lineLabels)
+      .should('have.length', 3)
+      .then(($labels) => {
+        expect(pillTextByVariant($labels)).to.deep.equal({
+          '': 'B200',
+          prefill: 'B200 · Prefill GPUs',
+          decode: 'B200 · Decode GPUs',
+        });
+      });
+    cy.get(lineLabel('prefill')).should('have.attr', 'data-series-id', 'b200::prefill');
+    cy.get(lineLabel('decode')).should('have.attr', 'data-series-id', 'b200::decode');
+
+    // Hiding a sibling from the legend hides its label with it.
+    cy.get(legend).within(() => {
+      cy.contains('Decode GPUs').click();
+    });
+    cy.get(`${svg} .roofline-path[data-power-variant="decode"]`).should('have.css', 'opacity', '0');
+    cy.get(svg).should(($svg) => {
+      const label = $svg[0].querySelector<SVGGElement>(labelSelector('decode'));
+      expect(label === null || getComputedStyle(label).opacity === '0').to.eq(true);
+    });
+    cy.get(lineLabel('prefill')).should('have.css', 'opacity', '1');
+  });
+
+  it('keeps the boundary suffix but drops the watts on a J per token axis', () => {
+    const data = expandPowerCompareSeries(
+      energyCurve('h100'),
+      'y_measuredJPerOutputToken',
+      'boundaries',
+    );
+    expect(data).to.have.length(9);
+    mountCompare(data, { lineLabels: true, metric: 'y_measuredJPerOutputToken' });
+
+    cy.get(`${svg} .roofline-path`).should('have.length', 3);
+    cy.get(lineLabels)
+      .should('have.length', 3)
+      .then(($labels) => {
+        expect(pillTextByVariant($labels)).to.deep.equal({
+          '': 'H100',
+          'gpu-provisioned': 'H100 · TDP',
+          'utility-provisioned': 'H100 · All-in',
+        });
+      });
+  });
+
+  it('translates boundary line labels on /zh', () => {
+    const data = expandPowerCompareSeries(
+      measuredCurve('h100', H100_CURVE),
+      'y_measuredAvgPower',
+      'boundaries',
+    );
+    mountCompare(data, { lineLabels: true, pathname: '/zh/inference' });
+
+    cy.get(lineLabels)
+      .should('have.length', 3)
+      .then(($labels) => {
+        expect(pillTextByVariant($labels)).to.deep.equal({
+          '': 'H100',
+          'gpu-provisioned': 'H100 · TDP 700 W',
+          'utility-provisioned': 'H100 · 全站 1.37 kW',
+        });
+      });
+  });
+
+  it('translates role line labels on /zh', () => {
+    mountCompare(expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles'), {
+      lineLabels: true,
+      pathname: '/zh/inference',
+    });
+
+    cy.get(lineLabels)
+      .should('have.length', 3)
+      .then(($labels) => {
+        expect(pillTextByVariant($labels)).to.deep.equal({
+          '': 'B200',
+          prefill: 'B200 · 预填充 GPU',
+          decode: 'B200 · 解码 GPU',
+        });
+      });
+  });
+
+  it('labels ?unofficialrun= comparison siblings with the marked hardware and the variant', () => {
+    const overlay = expandPowerCompareSeries(
+      measuredCurve('h100', { run_url: OVERLAY_RUN_URL }),
+      'y_measuredAvgPower',
+      'roles',
+    );
+    mountCompare([], { overlay, lineLabels: true });
+
+    cy.get(lineLabels)
+      .should('have.length', 3)
+      .each(($label) => {
+        expect($label.attr('data-line-key')).to.match(/^overlay-/u);
+        // Overlay pills take the run colour, like the overlay rooflines.
+        expect($label.find('.ll-bg').attr('fill')).to.eq(overlayRunColor(0));
+      })
+      .then(($labels) => {
+        // The branch stays in the legend; pills name the hardware behind the marker.
+        expect(pillTextByVariant($labels)).to.deep.equal({
+          '': '✕ H100',
+          prefill: '✕ H100 · Prefill GPUs',
+          decode: '✕ H100 · Decode GPUs',
+        });
+      });
+    cy.get(lineLabel('')).should('have.attr', 'data-series-id', 'h100');
+    cy.get(lineLabel('decode')).should('have.attr', 'data-series-id', 'h100::decode');
+  });
+
+  it('labels each precision of every boundary series when several precisions are shown', () => {
+    const fp4 = measuredCurve('h100', H100_CURVE);
+    const fp8 = measuredCurve('h100', {
+      ...H100_CURVE,
+      measured: [200, 180, 160],
+      precision: Precision.FP8,
+    });
+    const data = expandPowerCompareSeries([...fp4, ...fp8], 'y_measuredAvgPower', 'boundaries');
+    mountCompare(data, { lineLabels: true, precisions: [Precision.FP4, Precision.FP8] });
+
+    cy.get(lineLabels)
+      .should('have.length', 6)
+      .then(($labels) => {
+        expect([...$labels].map(pillText)).to.have.members([
+          'H100 FP4',
+          'H100 FP4 · TDP 700 W',
+          'H100 FP4 · All-in 1.37 kW',
+          'H100 FP8',
+          'H100 FP8 · TDP 700 W',
+          'H100 FP8 · All-in 1.37 kW',
+        ]);
+      });
+    cy.get(lineLabel('')).should('have.length', 2);
+    cy.get(lineLabel('gpu-provisioned')).should('have.length', 2);
+    cy.get(lineLabel('utility-provisioned')).should('have.length', 2);
+  });
+
+  it('leaves line labels untouched without a comparison', () => {
+    mountCompare([...measuredCurve('b200'), ...measuredCurve('h100', H100_CURVE)], {
+      lineLabels: true,
+    });
+
+    cy.get(lineLabels)
+      .should('have.length', 2)
+      .then(($labels) => {
+        expect([...$labels].map(pillText)).to.have.members(['B200', 'H100']);
+      });
+  });
+});
diff --git a/packages/app/cypress/component/power-metric-availability.cy.tsx b/packages/app/cypress/component/power-metric-availability.cy.tsx
index 6a6c7b1a6..fa2a9f3a8 100644
--- a/packages/app/cypress/component/power-metric-availability.cy.tsx
+++ b/packages/app/cypress/component/power-metric-availability.cy.tsx
@@ -24,6 +24,71 @@ const measured = createMockInferenceData({
   power_metric_schema_version: 2,
   measuredAvgPower: { y: 640, roof: false },
 });
+
+// Derived power boundaries (lib/power-basis.ts). The registered B200 carries
+// every boundary; the GB200 NVL72 has spec watts but sits outside the chassis
+// power model; the AMD row failed validation, so its modeled boundary is
+// withheld even though its spec constants exist; the disaggregated AgentX row
+// reports throughput but no whole-deployment GPU count, so its provisioned
+// energy is withheld and the chassis model rejects its workload; the
+// unregistered hardware has no spec constants at all.
+const boundaries = createMockInferenceData({
+  ...base,
+  hwKey: 'b200',
+  power_valid: 1,
+  power_metric_schema_version: 2,
+  measuredAvgPower: { y: 640, roof: false },
+  gpuProvisionedWatts: { y: 1000, roof: false },
+  gpuProvisionedJPerOutputToken: { y: 3.6, roof: false },
+  utilityProvisionedWatts: { y: 1710, roof: false },
+  utilityProvisionedJPerOutputToken: { y: 6.1, roof: false },
+  utilityModeledWatts: { y: 1105, roof: false },
+  utilityModeledJPerOutputToken: { y: 3.9, roof: false },
+});
+const outsideModel = createMockInferenceData({
+  ...base,
+  hwKey: 'gb200',
+  output_tput_per_gpu: undefined,
+  gpuProvisionedWatts: { y: 1200, roof: false },
+  utilityProvisionedWatts: { y: 1870, roof: false },
+  modeledSystemPower: { status: 'unsupported', reason: 'hardware', modelRevision: 'abc1234' },
+});
+const failedValidation = createMockInferenceData({
+  ...base,
+  hwKey: 'mi355x',
+  power_valid: 0,
+  power_invalid_reasons: ['sampling_gap_exceeded'],
+  gpuProvisionedWatts: { y: 1400, roof: false },
+  gpuProvisionedJPerOutputToken: { y: 5, roof: false },
+  utilityProvisionedWatts: { y: 2200, roof: false },
+  utilityProvisionedJPerOutputToken: { y: 7.9, roof: false },
+});
+const agenticDisagg = createMockInferenceData({
+  ...base,
+  hwKey: 'b200_disagg',
+  disagg: true,
+  benchmark_type: 'agentic_traces',
+  output_tput_per_gpu: 300,
+  num_prefill_gpu: 4,
+  num_decode_gpu: 4,
+  power_valid: 1,
+  power_metric_schema_version: 2,
+  measuredAvgPower: { y: 700, roof: false },
+  gpuProvisionedWatts: { y: 1000, roof: false },
+  utilityProvisionedWatts: { y: 1710, roof: false },
+  modeledSystemPower: { status: 'unsupported', reason: 'workload', modelRevision: 'abc1234' },
+});
+const unregistered = createMockInferenceData({ ...base, hwKey: 'unknown_hw' });
+function BoundaryPanel({ metric: initial }: { metric: string }) {
+  const [metric, select] = useState(initial);
+  return (
+    <PowerMetricAvailabilityPanel
+      points={[boundaries, outsideModel, failedValidation, agenticDisagg, unregistered]}
+      metric={metric}
+      onSelect={select}
+    />
+  );
+}
 function Panel() {
   const [metric, select] = useState('y_measuredAvgPower');
   return (
@@ -60,6 +125,95 @@ describe('PowerX metric availability', () => {
     cy.contains('summary', '所有实测指标的可用性').click();
     cy.contains('缺失值不会被替换为零或 TDP 估算值');
   });
+  it('explains why derived power boundaries are missing per point', () => {
+    cy.mount(<BoundaryPanel metric="y_utilityModeledWatts" />);
+    // B4 follows the chassis model and the telemetry verdict.
+    cy.contains('1 of 5 points have this metric');
+    cy.contains('Value available: 1');
+    cy.contains('Hardware not in the chassis power model: 1');
+    cy.contains('Chassis model covers 8K / 1K only: 1');
+    cy.contains('No validated GPU telemetry: 1');
+    cy.contains('Validation failed: 1');
+    cy.contains('summary', 'source details').click();
+    cy.contains('gb200: Hardware not in the chassis power model (1)');
+    cy.contains('b200_disagg: Chassis model covers 8K / 1K only (1)');
+    cy.contains('unknown_hw: No validated GPU telemetry (1)');
+    cy.contains('mi355x: Validation failed (1) · sampling_gap_exceeded');
+    // Spec-constant watts exist for every registered hardware, validated or not.
+    cy.contains('summary', 'all measured metrics').click();
+    cy.contains('button', 'GPU Provisioned Power per Chip (TDP)').should('contain', '4/5').click();
+    cy.contains('4 of 5 points have this metric');
+    cy.contains('No published spec for this hardware: 1');
+    cy.get('[data-testid="power-metric-availability"]').should('not.contain', 'Validation failed');
+    // Provisioned energy additionally needs output throughput and, for
+    // disaggregated rows, the whole-deployment GPU count (the list stays open).
+    cy.contains('button', 'Utility Provisioned Joules per Output Token, all GPUs (all-in)')
+      .should('contain', '2/5')
+      .click();
+    cy.contains('2 of 5 points have this metric');
+    cy.contains('No output throughput reported: 1');
+    cy.contains('Whole-deployment GPU count unavailable for this disaggregated row: 1');
+    cy.contains('No published spec for this hardware: 1');
+    cy.contains('gb200: No output throughput reported (1)');
+    cy.contains(
+      'b200_disagg: Whole-deployment GPU count unavailable for this disaggregated row (1)',
+    );
+  });
+  it('uses Chinese copy for the derived boundary states', () => {
+    cy.mount(
+      <PathnameContext.Provider value="/zh/inference/qwen-3-5">
+        <BoundaryPanel metric="y_utilityModeledJPerOutputToken" />
+      </PathnameContext.Provider>,
+    );
+    cy.contains('5 个数据点中有 1 个提供此指标');
+    cy.contains('有数值: 1');
+    cy.contains('硬件不在机箱功耗模型范围内: 1');
+    cy.contains('机箱功耗模型仅覆盖 8K / 1K: 1');
+    cy.contains('没有已验证的 GPU 遥测: 1');
+    cy.contains('验证失败: 1');
+    cy.contains('summary', '所有实测指标的可用性').click();
+    cy.contains('button', '每芯片 GPU 额定功耗（TDP）').should('contain', '4/5');
+    cy.contains('button', '每输出 token 全电源配置焦耳能耗，按全部 GPU 归一（all-in）')
+      .should('contain', '2/5')
+      .click();
+    cy.contains('无法确定该分离式部署的 GPU 总数: 1');
+    cy.contains('该硬件没有公开的规格参数: 1');
+  });
+  it('keeps the measured validation copy on the measured dictionary', () => {
+    // `invalid` exists in both dictionaries; the measured metric must read
+    // its own so a future basis-copy edit cannot rewrite the measured string.
+    // Only the registered B200 and the disaggregated AgentX row carry
+    // validated telemetry; the GB200 and the unregistered hardware report
+    // nothing and the AMD row failed validation.
+    cy.mount(<BoundaryPanel metric="y_measuredAvgPower" />);
+    cy.contains('2 of 5 points have this metric');
+    cy.contains('Validation failed: 1');
+    cy.contains('Metric not reported: 2');
+    cy.get('[data-testid="power-metric-availability"]').should('not.contain', 'Value available');
+  });
+  it('counts derived boundaries on visible unofficial overlay rows only', () => {
+    mountWithProviders(
+      <PowerMetricAvailability metric="y_gpuProvisionedJPerOutputToken" onSelect={cy.stub()} />,
+      {
+        inference: {
+          selectionPoints: [outsideModel],
+          activeHwTypes: new Set(['gb200']),
+          selectedModel: Model.Qwen3_5,
+          selectedSequence: Sequence.EightK_OneK,
+          selectedPrecisions: [Precision.FP8],
+        },
+        unofficial: {
+          isUnofficialRun: true,
+          activeOverlayHwTypes: new Set(['b200']),
+          getOverlayData: () => ({ data: [boundaries, failedValidation], hardwareConfig: {} }),
+        },
+      },
+    );
+    // Official GB200 (no throughput) + visible overlay B200; hidden overlay mi355x excluded.
+    cy.contains('1 of 2 points have this metric');
+    cy.contains('No output throughput reported: 1');
+    cy.get('[data-testid="power-metric-availability"]').should('not.contain', 'Validation failed');
+  });
   it('counts filtered unofficial rows before the metric filter and respects hidden overlay hardware', () => {
     mountWithProviders(
       <PowerMetricAvailability metric="y_measuredAvgPower" onSelect={cy.stub()} />,
diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
new file mode 100644
index 000000000..f0f332914
--- /dev/null
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -0,0 +1,727 @@
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
+
+import type {
+  GpuPowerDevice,
+  GpuPowerSeries,
+  GpuPowerSeriesResponse,
+} from '@/components/gpu-power/power-series';
+import PowerTimeline from '@/components/inference/ui/PowerTimeline';
+import type { InferenceData } from '@/components/inference/types';
+import {
+  requestPowerTraceFocus,
+  traceKeyForPoint,
+} from '@/components/inference/utils/powerTimeline';
+import { Model, Precision, Sequence } from '@/lib/data-mappings';
+import { overlayRunColor } from '@/lib/overlay-run-style';
+
+import {
+  createMockHardwareConfig,
+  createMockInferenceData,
+  createMockUnofficialRunContext,
+} from '../support/mock-data';
+import { mountWithProviders } from '../support/test-utils';
+
+// PowerTimeline joins chart points to `gpu_metrics_<RESULT_FILENAME>` artifacts
+// (or to the series the API cuts out of a `power_audit_*` bundle) by the
+// `power_audit.source` file name and draws one trace per config: the whole job
+// faint, the validated window emphasized, TDP dashed per hardware. Bundle
+// series carry worker roles, which unlock the prefill / decode pool mode.
+
+const RUN_ID = '34716669498';
+const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
+const OVERLAY_RUN_ID = '31415926535';
+const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
+const runUrlFor = (runId: string) =>
+  `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${runId}`;
+const START_MS = Date.UTC(2026, 8, 12, 20, 20, 0);
+const hwConfig = {
+  ...createMockHardwareConfig(),
+  gb200: {
+    name: 'gb200',
+    label: 'GB200 NVL72',
+    suffix: '',
+    gpu: "NVIDIA 'Blackwell' GB200 NVL72",
+  },
+};
+const HW_TYPES = new Set(['b200', 'h100', 'gb200']);
+
+const resultName = (hardware: string, conc: number) =>
+  `dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc${conc}_${hardware}-host-0123456789abcdef0123`;
+
+// A Slurm / Dynamo disaggregated sweep: one bundle per sweep, one validation
+// file per concurrency inside it, DCGM device ids as `<hostname>/<GPU-uuid>`.
+const DISAGG_RESULT =
+  'qwen3.5_8k1k_fp8_dynamo-sglang_prefill-tp4-pp1-dcp1-pcp1-ep1-dpfalse-nw1_decode-tp4-pp1-dcp1-pcp1-e-5b35252b29d80b104d11';
+const disaggSource = (conc: number) =>
+  `power_validation_${DISAGG_RESULT}_sa-bench_isl_8192_osl_1024_conc${conc}_gpus_8_ctx_4_gen_4.json`;
+const HOST = 'watchtower-navy-cn01';
+const WINDOW = {
+  // Window covers the last 20 s of a 60 s job.
+  window_start_unix: (START_MS + 40_000) / 1000,
+  window_end_unix: (START_MS + 60_000) / 1000,
+};
+
+function measuredPoint(
+  hwKey: string,
+  conc: number,
+  watts: number,
+  overrides: Partial<InferenceData> = {},
+): InferenceData {
+  return createMockInferenceData({
+    hwKey,
+    conc,
+    tp: 8,
+    x: conc,
+    y: watts,
+    precision: Precision.FP4,
+    run_url: RUN_URL,
+    measuredAvgPower: { y: watts, roof: true },
+    measuredPowerTimeline: { y: watts, roof: true },
+    power_audit: {
+      source: `power_validation_${resultName(hwKey.split('_')[0], conc)}.json`,
+      ...WINDOW,
+    },
+    ...overrides,
+  });
+}
+
+function disaggPoint(
+  conc: number,
+  watts: number,
+  overrides: Partial<InferenceData> = {},
+): InferenceData {
+  return measuredPoint('gb200', conc, watts, {
+    tp: 4,
+    disagg: true,
+    power_audit: { source: disaggSource(conc), ...WINDOW },
+    ...overrides,
+  });
+}
+
+/** 61 one-second buckets: idle 200 W, ramps to `peak` inside the window. */
+function series(hwKey: string, conc: number, peak: number, gpus = [0, 1]): GpuPowerSeries {
+  const t = Array.from({ length: 61 }, (_, i) => i);
+  return {
+    artifact: `gpu_metrics_${resultName(hwKey.split('_')[0], conc)}`,
+    startMs: START_MS,
+    bucketSeconds: 1,
+    gpus,
+    t,
+    power: gpus.map((gpu) => t.map((second) => (second >= 40 ? peak + gpu * 10 : 200 + gpu))),
+  };
+}
+
+/**
+ * Bundle-cut series: 4 prefill + 4 decode devices. Prefill idles at 300 W and
+ * works at 900 W (+row), decode at 250 W and 700 W (+row), so the pool sums in
+ * the window are 3606 W and 2822 W.
+ */
+function poolSeries(conc: number, prefillCount = 4): GpuPowerSeries {
+  const t = Array.from({ length: 61 }, (_, i) => i);
+  const devices: GpuPowerDevice[] = Array.from({ length: 8 }, (_, i) => ({
+    id: `${HOST}/GPU-${String(i).padStart(8, '0')}-d62f-0ff2-b4e5-e36f6fac8f1b`,
+    role: i < prefillCount ? 'prefill' : 'decode',
+  }));
+  return {
+    artifact: `power_audit_${DISAGG_RESULT}`,
+    source: disaggSource(conc),
+    startMs: START_MS,
+    bucketSeconds: 1,
+    gpus: devices.map((_, i) => i),
+    t,
+    power: devices.map((device, i) =>
+      t.map((second) => {
+        const prefill = device.role === 'prefill';
+        return second >= 40 ? (prefill ? 900 : 700) + i : prefill ? 300 : 250;
+      }),
+    ),
+    devices,
+  };
+}
+
+const response: GpuPowerSeriesResponse = {
+  runInfo: {
+    id: Number(RUN_ID),
+    name: 'Run Sweep',
+    branch: 'main',
+    sha: 'abc123',
+    createdAt: '2026-09-12T20:00:00Z',
+    url: RUN_URL,
+    conclusion: 'success',
+    status: 'completed',
+  },
+  series: [series('b200', 16, 700), series('b200', 64, 900)],
+};
+
+/** A single-node B200 config and a disaggregated GB200 config from the same run. */
+const poolResponse: GpuPowerSeriesResponse = {
+  runInfo: response.runInfo,
+  series: [series('b200', 16, 700), poolSeries(8)],
+};
+
+const GB200_TDP = HW_REGISTRY.gb200?.tdp || HW_REGISTRY.b200.tdp;
+
+function mountTimeline(
+  data: InferenceData[],
+  options: {
+    pathname?: string;
+    overlay?: Parameters<typeof PowerTimeline>[0]['overlayData'];
+    unofficial?: Parameters<typeof createMockUnofficialRunContext>[0];
+  } = {},
+) {
+  mountWithProviders(
+    <PathnameContext.Provider value={options.pathname ?? '/inference'}>
+      <div style={{ width: 1100, height: 700 }}>
+        <PowerTimeline
+          chartId="power-timeline-test"
+          data={data}
+          overlayData={options.overlay}
+          yLabel="Measured Average Power per Chip over Time (W)"
+        />
+      </div>
+    </PathnameContext.Provider>,
+    {
+      inference: {
+        selectedModel: Model.DeepSeek_V4_Pro,
+        selectedSequence: Sequence.EightK_OneK,
+        selectedYAxisMetric: 'y_measuredPowerTimeline',
+        hardwareConfig: hwConfig,
+        activeHwTypes: new Set(HW_TYPES),
+        hwTypesWithData: new Set(HW_TYPES),
+      },
+      unofficial: options.unofficial ?? {},
+    },
+  );
+}
+
+const svg = () => cy.get('[data-testid="power-timeline-chart-svg"]');
+
+describe('PowerTimeline', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message.includes('ResizeObserver loop')) return false;
+    });
+  });
+
+  it('fetches one prefixed series request per run and draws the job with its window emphasized', () => {
+    cy.intercept('GET', '/api/gpu-metrics*', { body: response }).as('series');
+    mountTimeline([
+      measuredPoint('b200', 16, 700),
+      measuredPoint('b200', 64, 900),
+      // Same run, no artifact uploaded (e.g. a disaggregated Dynamo row).
+      measuredPoint('b200', 256, 950, {
+        disagg: true,
+        power_audit: { source: 'power_validation_dsv4_8k1k_fp4_dynamo-sglang_conc256.json' },
+      }),
+    ]);
+
+    cy.wait('@series').then(({ request }) => {
+      const url = new URL(request.url);
+      expect(url.searchParams.get('runId')).to.eq(RUN_ID);
+      expect(url.searchParams.get('series')).to.eq('power');
+      expect(url.searchParams.get('prefix')).to.eq('dsv4_8k1k_fp4_');
+    });
+
+    svg().within(() => {
+      cy.get('path.power-trace[data-segment="full"]').should('have.length', 2);
+      cy.get('path.power-trace[data-segment="window"]')
+        .should('have.length', 2)
+        .each(($path) => {
+          // The window segment is the emphasized one.
+          expect(Number($path.attr('stroke-width'))).to.be.greaterThan(2);
+          expect(Number($path.attr('opacity'))).to.eq(1);
+        });
+      cy.get('path.power-trace[data-hw="b200"]').should('have.length', 4);
+      // Mean mode carries no pool attributes or dashes.
+      cy.get('path.power-trace[data-pool]').should('not.exist');
+      cy.get('path.power-trace[stroke-dasharray]').should('not.exist');
+      cy.get('.power-reference[data-reference="tdp"][data-watts="1000"]').should('exist');
+      cy.get('.power-reference[data-reference="tdp"] text').should('contain.text', 'TDP 1000 W');
+      cy.get('.power-reference[data-reference="utility"]').should('not.exist');
+      cy.get('text.power-trace-label').should('have.length', 2);
+      cy.get('text.power-trace-label').first().should('contain.text', 'c');
+      cy.get('.x-axis-label, text').contains('Time (UTC)').should('exist');
+    });
+    cy.get('[data-testid="power-timeline-missing"]')
+      .should('contain.text', '1 of 3 measured configs have no telemetry trace')
+      .and('contain.text', '1 have no gpu_metrics artifact or power-audit bundle in their run')
+      .and('contain.text', 'Not drawn: B200 PD · TP8 · c256');
+    cy.get('[data-testid="power-timeline-source"] a')
+      .should('have.attr', 'href', RUN_URL)
+      .and('contain.text', `run ${RUN_ID}`);
+    cy.get('[data-testid="power-timeline-empty"]').should('not.exist');
+    // No trace carries worker roles, so the pools switch is not offered.
+    cy.get('[data-testid="power-timeline-pools"]').should('not.exist');
+    cy.get('[data-testid="power-timeline-focus"]').should('not.exist');
+
+    // One line per GPU doubles the polylines; the all-in switch adds its reference.
+    cy.get('[data-testid="power-timeline-per-gpu"]').click();
+    cy.get('[data-testid="power-timeline-chart-svg"] path.power-trace[data-segment="full"]').should(
+      'have.length',
+      4,
+    );
+    cy.get('[data-testid="power-timeline-utility"]').click();
+    cy.get(
+      '[data-testid="power-timeline-chart-svg"] .power-reference[data-reference="utility"]',
+    ).should('exist');
+
+    // Elapsed axis relabels the x-axis and keeps every trace.
+    cy.get('[data-testid="power-timeline-axis-elapsed"]').click();
+    svg().within(() => {
+      cy.get('text').contains('Time since telemetry start').should('exist');
+      cy.get('path.power-trace[data-segment="full"]').should('have.length', 4);
+    });
+  });
+
+  it('colours overlay-run traces by run and honours the overlay hardware filter', () => {
+    const overlayPoint = measuredPoint('h200', 16, 500, {
+      run_url: OVERLAY_RUN_URL,
+      power_audit: {
+        source: `power_validation_${resultName('h200', 16)}.json`,
+        ...WINDOW,
+      },
+    });
+    const overlayResponse: GpuPowerSeriesResponse = {
+      runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
+      series: [series('h200', 16, 500)],
+    };
+    cy.intercept('GET', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
+    cy.intercept('GET', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+      body: overlayResponse,
+    }).as('overlay');
+    mountTimeline([measuredPoint('b200', 16, 700)], {
+      overlay: {
+        data: [overlayPoint],
+        hardwareConfig: hwConfig,
+        label: 'powerx-timeline',
+        runUrl: OVERLAY_RUN_URL,
+      },
+      unofficial: createMockUnofficialRunContext({
+        isUnofficialRun: true,
+        unofficialRunInfos: [
+          {
+            id: Number(OVERLAY_RUN_ID),
+            name: 'powerx-timeline',
+            branch: 'powerx-timeline',
+            sha: 'abc000',
+            createdAt: '2026-09-12T00:00:00Z',
+            url: OVERLAY_RUN_URL,
+            conclusion: 'success',
+            status: 'completed',
+            isNonMainBranch: true,
+          },
+        ],
+        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
+        activeOverlayHwTypes: new Set(['h200']),
+      }),
+    });
+    cy.wait(['@official', '@overlay']);
+
+    svg().within(() => {
+      cy.get('path.power-trace[data-run-index="0"][data-segment="window"]')
+        .should('have.length', 1)
+        .and('have.attr', 'stroke', overlayRunColor(0));
+      cy.get('path.power-trace[data-hw="b200"][data-segment="window"]').should('have.length', 1);
+      // Two runs: the axis defaults to elapsed time so traces overlap by phase.
+      cy.get('text').contains('Time since telemetry start').should('exist');
+      // Reference lines cover both hardware SKUs.
+      cy.get('.power-reference[data-reference="tdp"]').should('have.length', 2);
+    });
+    cy.get('[data-testid="chart-legend"]').should('contain.text', '✕ powerx-timeline');
+  });
+
+  it('solos an official row through the unified overlay selection while an overlay is loaded', () => {
+    // localOfficialOverride shadows activeHwTypes once an overlay is in, so the
+    // context toggle would be invisible: the legend must write both selections.
+    const overlayPoint = measuredPoint('h200', 16, 500, {
+      run_url: OVERLAY_RUN_URL,
+      power_audit: {
+        source: `power_validation_${resultName('h200', 16)}.json`,
+        ...WINDOW,
+      },
+    });
+    cy.intercept('GET', '/api/gpu-metrics*', { body: response }).as('series');
+    mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('h100', 16, 600)], {
+      overlay: {
+        data: [overlayPoint],
+        hardwareConfig: hwConfig,
+        label: 'powerx-timeline',
+        runUrl: OVERLAY_RUN_URL,
+      },
+      // Plain overrides: mountWithProviders builds the context itself, so the
+      // aliased stubs below are the ones the component receives.
+      unofficial: {
+        isUnofficialRun: true,
+        unofficialRunInfos: [
+          {
+            id: Number(OVERLAY_RUN_ID),
+            name: 'powerx-timeline',
+            branch: 'powerx-timeline',
+            sha: 'abc000',
+            createdAt: '2026-09-12T00:00:00Z',
+            url: OVERLAY_RUN_URL,
+            conclusion: 'success',
+            status: 'completed',
+            isNonMainBranch: true,
+          },
+        ],
+        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
+        activeOverlayHwTypes: new Set(['h200']),
+      },
+    });
+    cy.wait('@series');
+
+    cy.get('[data-testid="chart-legend"] label[for="checkbox-b200"]').click();
+    cy.get('@setUnifiedOverlaySelection')
+      .should('have.been.calledOnce')
+      .then((stub) => {
+        const [official, overlay] = (stub as unknown as sinon.SinonStub).firstCall.args as [
+          Set<string>,
+          Set<string>,
+        ];
+        expect([...official]).to.deep.equal(['b200']);
+        expect([...overlay]).to.deep.equal(['h200']);
+      });
+  });
+
+  it('keeps ?unofficialrun= overlay telemetry inside the per-chart run cap', () => {
+    // Four official runs already fill the cap and all sort before the overlay run
+    // id: the overlay the user asked for is fetched anyway and the last official
+    // run (by id) is the one left out.
+    const officialRuns = ['30000000001', '30000000002', '30000000003', '30000000004'];
+    const officialPoints = officialRuns.map((runId, index) =>
+      measuredPoint('b200', 8 * 2 ** index, 700, { run_url: runUrlFor(runId) }),
+    );
+    officialRuns.forEach((runId, index) => {
+      cy.intercept('GET', `/api/gpu-metrics?runId=${runId}*`, {
+        body: {
+          runInfo: { ...response.runInfo, id: Number(runId), url: runUrlFor(runId) },
+          series: [series('b200', 8 * 2 ** index, 700)],
+        } satisfies GpuPowerSeriesResponse,
+      }).as(`official${index}`);
+    });
+    const overlayPoint = measuredPoint('h200', 16, 500, {
+      run_url: OVERLAY_RUN_URL,
+      power_audit: {
+        source: `power_validation_${resultName('h200', 16)}.json`,
+        ...WINDOW,
+      },
+    });
+    cy.intercept('GET', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+      body: {
+        runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
+        series: [series('h200', 16, 500)],
+      } satisfies GpuPowerSeriesResponse,
+    }).as('overlay');
+    mountTimeline(officialPoints, {
+      overlay: {
+        data: [overlayPoint],
+        hardwareConfig: hwConfig,
+        label: 'powerx-timeline',
+        runUrl: OVERLAY_RUN_URL,
+      },
+      unofficial: createMockUnofficialRunContext({
+        isUnofficialRun: true,
+        unofficialRunInfos: [
+          {
+            id: Number(OVERLAY_RUN_ID),
+            name: 'powerx-timeline',
+            branch: 'powerx-timeline',
+            sha: 'abc000',
+            createdAt: '2026-09-12T00:00:00Z',
+            url: OVERLAY_RUN_URL,
+            conclusion: 'success',
+            status: 'completed',
+            isNonMainBranch: true,
+          },
+        ],
+        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
+        activeOverlayHwTypes: new Set(['h200']),
+      }),
+    });
+    cy.wait(['@overlay', '@official0', '@official1', '@official2']);
+
+    cy.get('[data-testid="power-timeline-status"]').should(
+      'contain.text',
+      'Telemetry from 1 more run was not loaded',
+    );
+    cy.get('@official3.all').should('have.length', 0);
+    svg().within(() => {
+      cy.get('path.power-trace[data-run-index="0"][data-segment="window"]')
+        .should('have.length', 1)
+        .and('have.attr', 'stroke', overlayRunColor(0));
+      cy.get('path.power-trace[data-hw="b200"][data-segment="window"]').should('have.length', 3);
+    });
+  });
+
+  it('reports a failed run and hides traces the legend has switched off', () => {
+    cy.intercept('GET', '/api/gpu-metrics*', {
+      statusCode: 500,
+      body: { error: 'No gpu_metrics artifacts found for this run' },
+    }).as('failed');
+    mountTimeline([measuredPoint('b200', 16, 700)]);
+    cy.wait('@failed');
+    cy.get('[data-testid="power-timeline-status"] [role="alert"]').should(
+      'contain.text',
+      `Run ${RUN_ID}: No gpu_metrics artifacts found for this run`,
+    );
+    cy.get('[data-testid="power-timeline-chart-svg"] path.power-trace').should('not.exist');
+    cy.get('[data-testid="power-timeline-empty"]').should('contain.text', 'No telemetry traces');
+  });
+
+  it('translates the toolbar, legend switches and status on /zh', () => {
+    cy.intercept('GET', '/api/gpu-metrics*', { body: response }).as('series');
+    mountTimeline([measuredPoint('b200', 16, 700)], { pathname: '/zh/inference' });
+    cy.wait('@series');
+    cy.get('[data-testid="power-timeline-toolbar"]').should('contain.text', '时间轴');
+    cy.get('[data-testid="power-timeline-axis-wall"]').should('contain.text', '实际时刻');
+    cy.get('[data-testid="chart-legend"]').should('contain.text', '每个 GPU 一条线');
+    cy.get('[data-testid="power-timeline-status"]').should('contain.text', '遥测来源');
+    cy.get('[data-testid="power-timeline-chart-svg"] text').contains('时间（UTC）').should('exist');
+  });
+
+  it('sums prefill and decode pools against pool-sized TDP references in pool mode', () => {
+    cy.intercept('GET', '/api/gpu-metrics*', { body: poolResponse }).as('series');
+    mountTimeline([measuredPoint('b200', 16, 700), disaggPoint(8, 800)]);
+    cy.wait('@series');
+
+    // Mean mode treats the bundle-cut trace like any other: one line, per-GPU TDP.
+    svg().within(() => {
+      cy.get('path.power-trace[data-hw="gb200"][data-segment="full"]').should('have.length', 1);
+      cy.get('path.power-trace[data-pool]').should('not.exist');
+      cy.get(`.power-reference[data-reference="tdp"][data-watts="${GB200_TDP}"]`).should('exist');
+      cy.get('.power-reference[data-pool]').should('not.exist');
+    });
+    cy.get('[data-testid="power-timeline-missing"]').should('not.exist');
+
+    cy.get('[data-testid="power-timeline-pools"]').should('exist').click();
+    cy.get('[data-testid="power-timeline-per-gpu"]').should('have.attr', 'data-state', 'unchecked');
+    svg().within(() => {
+      // One dashed line per pool, full job plus window emphasis.
+      cy.get('path.power-trace[data-pool="prefill"]')
+        .should('have.length', 2)
+        .each(($path) => expect($path.attr('stroke-dasharray')).to.eq('7 3'));
+      cy.get('path.power-trace[data-pool="decode"]')
+        .should('have.length', 2)
+        .each(($path) => expect($path.attr('stroke-dasharray')).to.eq('2 3'));
+      // The single-node trace falls back to its whole deployment as one solid pool.
+      cy.get('path.power-trace[data-hw="b200"][data-pool="all"]')
+        .should('have.length', 2)
+        .and('not.have.attr', 'stroke-dasharray');
+      cy.get('path.power-trace[data-hw="gb200"][data-segment="window"]').should('have.length', 2);
+
+      // References scale to the pool: both GB200 pools hold 4 GPUs, so they
+      // share one ceiling and one label instead of two printed over each other;
+      // 2 × rated TDP for the B200 pair.
+      cy.get('.power-reference[data-reference="tdp"][data-pool="prefill decode"]')
+        .should('have.attr', 'data-watts', String(4 * GB200_TDP))
+        .find('text')
+        .should('contain.text', `GB200 NVL72 prefill / decode ×4 TDP ${4 * GB200_TDP} W`);
+      cy.get('.power-reference[data-reference="tdp"][data-pool="all"]')
+        .should('have.attr', 'data-watts', String(2 * HW_REGISTRY.b200.tdp))
+        .find('text')
+        .should('contain.text', 'B200 all GPUs ×2 TDP');
+      cy.get('.power-reference[data-reference="tdp"]').should('have.length', 2);
+
+      // End labels name the pool; the axis reads pool watts.
+      cy.get('text.power-trace-label[data-pool="prefill"]').should('contain.text', 'c8 · prefill');
+      cy.get('text.power-trace-label[data-pool="decode"]').should('contain.text', 'c8 · decode');
+      cy.get('text.power-trace-label[data-hw="b200"]').should('contain.text', 'c16 · all GPUs');
+      cy.get('text').contains('GPU pool power (W)').should('exist');
+    });
+
+    // Hover a prefill hit point: the B200 pool stream comes first (61 buckets), then prefill.
+    cy.get('[data-testid="power-timeline-chart-svg"] circle.point').eq(61).trigger('mouseenter');
+    cy.get('[data-chart-tooltip]')
+      .should('contain.text', 'GB200 NVL72 · PD · TP4 · c8')
+      .and('contain.text', 'Pool: prefill · 4 GPUs')
+      .and(
+        'contain.text',
+        `Pool power: 1,200 W (${Math.round((1200 / (4 * GB200_TDP)) * 100)}% pool TDP)`,
+      )
+      .and('contain.text', 'Mean per GPU: 300.0 W · min 300.0 W · max 300.0 W')
+      .and('contain.text', 'Before window');
+
+    // The all-in switch also scales to the pool.
+    cy.get('[data-testid="power-timeline-utility"]').click();
+    svg()
+      .find('.power-reference[data-reference="utility"][data-pool~="prefill"]')
+      .should('have.attr', 'data-watts', String(4 * Math.round(HW_REGISTRY.gb200.power * 1000)));
+
+    // Per-GPU and pools are mutually exclusive; per-GPU restores the per-GPU TDP line.
+    cy.get('[data-testid="power-timeline-per-gpu"]').click();
+    cy.get('[data-testid="power-timeline-pools"]').should('have.attr', 'data-state', 'unchecked');
+    svg().within(() => {
+      cy.get('path.power-trace[data-pool]').should('not.exist');
+      cy.get('path.power-trace[data-hw="gb200"][data-segment="full"]').should('have.length', 8);
+      cy.get(`.power-reference[data-reference="tdp"][data-watts="${GB200_TDP}"]`).should('exist');
+      cy.get('text').contains('Measured Average Power per Chip over Time (W)').should('exist');
+    });
+  });
+
+  it('keeps separate pool references when prefill and decode pools differ in size', () => {
+    cy.intercept('GET', '/api/gpu-metrics*', {
+      body: {
+        runInfo: response.runInfo,
+        series: [poolSeries(8, 6)],
+      } satisfies GpuPowerSeriesResponse,
+    }).as('series');
+    mountTimeline([disaggPoint(8, 800)]);
+    cy.wait('@series');
+    cy.get('[data-testid="power-timeline-pools"]').click();
+
+    svg().within(() => {
+      cy.get('.power-reference[data-reference="tdp"][data-pool="prefill"]')
+        .should('have.attr', 'data-watts', String(6 * GB200_TDP))
+        .find('text')
+        .should('contain.text', `GB200 NVL72 prefill ×6 TDP ${6 * GB200_TDP} W`);
+      cy.get('.power-reference[data-reference="tdp"][data-pool="decode"]')
+        .should('have.attr', 'data-watts', String(2 * GB200_TDP))
+        .find('text')
+        .should('contain.text', `GB200 NVL72 decode ×2 TDP ${2 * GB200_TDP} W`);
+      cy.get('.power-reference[data-reference="tdp"]').should('have.length', 2);
+    });
+  });
+
+  it('draws an overlay-run pool trace in the run colour', () => {
+    const overlayPoint = disaggPoint(8, 800, { run_url: OVERLAY_RUN_URL });
+    const overlayResponse: GpuPowerSeriesResponse = {
+      runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
+      series: [poolSeries(8)],
+    };
+    cy.intercept('GET', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
+    cy.intercept('GET', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+      body: overlayResponse,
+    }).as('overlay');
+    mountTimeline([measuredPoint('b200', 16, 700)], {
+      overlay: {
+        data: [overlayPoint],
+        hardwareConfig: hwConfig,
+        label: 'powerx-pools',
+        runUrl: OVERLAY_RUN_URL,
+      },
+      unofficial: createMockUnofficialRunContext({
+        isUnofficialRun: true,
+        unofficialRunInfos: [
+          {
+            id: Number(OVERLAY_RUN_ID),
+            name: 'powerx-pools',
+            branch: 'powerx-pools',
+            sha: 'abc000',
+            createdAt: '2026-09-12T00:00:00Z',
+            url: OVERLAY_RUN_URL,
+            conclusion: 'success',
+            status: 'completed',
+            isNonMainBranch: true,
+          },
+        ],
+        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
+        activeOverlayHwTypes: new Set(['gb200']),
+      }),
+    });
+    cy.wait(['@official', '@overlay']);
+
+    cy.get('[data-testid="power-timeline-pools"]').click();
+    svg().within(() => {
+      cy.get('path.power-trace[data-run-index="0"][data-pool="prefill"][data-segment="window"]')
+        .should('have.length', 1)
+        .and('have.attr', 'stroke', overlayRunColor(0))
+        .and('have.attr', 'stroke-dasharray', '7 3');
+      cy.get('path.power-trace[data-run-index="0"][data-pool="decode"]').should('have.length', 2);
+      cy.get('.power-reference[data-reference="tdp"][data-pool~="prefill"] line').should(
+        'have.attr',
+        'stroke',
+        overlayRunColor(0),
+      );
+      // The official trace keeps its hardware colour and solid all-GPU pool.
+      cy.get('path.power-trace[data-hw="b200"][data-pool="all"][data-segment="window"]')
+        .should('have.length', 1)
+        .and('not.have.attr', 'stroke', overlayRunColor(0));
+      cy.get('path.power-trace[data-hw="b200"][data-pool="all"][stroke-dasharray]').should(
+        'not.exist',
+      );
+      cy.get('.power-reference[data-reference="tdp"][data-pool="all"] line').should(
+        'not.have.attr',
+        'stroke',
+        overlayRunColor(0),
+      );
+    });
+    cy.get('[data-testid="chart-legend"]').should('contain.text', '✕ powerx-pools');
+  });
+
+  it('focuses the deep-linked trace, opens pool mode for it and clears on request', () => {
+    const disagg = disaggPoint(8, 800);
+    requestPowerTraceFocus(traceKeyForPoint(disagg)!);
+    cy.intercept('GET', '/api/gpu-metrics*', { body: poolResponse }).as('series');
+    mountTimeline([measuredPoint('b200', 16, 700), disagg]);
+    cy.wait('@series');
+
+    cy.get('[data-testid="power-timeline-focus"]').should(
+      'contain.text',
+      'Focused on GB200 NVL72 · PD · TP4 · c8',
+    );
+    // A pooled trace opens in pool mode without touching the switch.
+    cy.get('[data-testid="power-timeline-pools"]').should('have.attr', 'data-state', 'checked');
+    svg().within(() => {
+      cy.get('path.power-trace[data-pool="prefill"]').should('exist');
+      cy.get('path.power-trace[data-hw="gb200"][data-segment="window"]').each(($path) =>
+        expect($path.attr('opacity')).to.eq('1'),
+      );
+      cy.get('text.power-trace-label[data-hw="gb200"]').each(($label) =>
+        expect($label.attr('opacity')).to.eq('1'),
+      );
+      // Every other trace dims: labels to 0.2, lines to 15 % of their weight.
+      cy.get('text.power-trace-label[data-hw="b200"]').should('have.attr', 'opacity', '0.2');
+      cy.get('path.power-trace[data-hw="b200"][data-segment="window"]').should(
+        'have.attr',
+        'opacity',
+        '0.15',
+      );
+    });
+
+    cy.get('[data-testid="power-timeline-focus-clear"]').should('contain.text', 'Show all').click();
+    cy.get('[data-testid="power-timeline-focus"]').should('not.exist');
+    svg().within(() => {
+      cy.get('text.power-trace-label[data-hw="b200"]').should('have.attr', 'opacity', '1');
+      cy.get('path.power-trace[data-hw="b200"][data-segment="window"]').should(
+        'have.attr',
+        'opacity',
+        '1',
+      );
+      // Pool mode stays: clearing the focus only restores the other traces.
+      cy.get('path.power-trace[data-pool="prefill"]').should('exist');
+    });
+  });
+
+  it('translates the pool switch, pool labels and focus chip on /zh', () => {
+    const disagg = disaggPoint(8, 800);
+    requestPowerTraceFocus(traceKeyForPoint(disagg)!);
+    cy.intercept('GET', '/api/gpu-metrics*', { body: poolResponse }).as('series');
+    mountTimeline([disagg], { pathname: '/zh/inference' });
+    cy.wait('@series');
+
+    cy.get('[data-testid="chart-legend"]').should('contain.text', '预填充 / 解码 GPU 池');
+    cy.get('[data-testid="power-timeline-pools"]').should('have.attr', 'data-state', 'checked');
+    svg().within(() => {
+      cy.get('text').contains('GPU 池功耗（W）').should('exist');
+      cy.get('text.power-trace-label[data-pool="prefill"]').should('contain.text', 'c8 · 预填充');
+      cy.get('text.power-trace-label[data-pool="decode"]').should('contain.text', 'c8 · 解码');
+      cy.get('.power-reference[data-reference="tdp"][data-pool~="decode"] text').should(
+        'contain.text',
+        `GB200 NVL72 预填充 / 解码 ×4 TDP ${4 * GB200_TDP} W`,
+      );
+    });
+    cy.get('[data-testid="power-timeline-focus"]')
+      .should('contain.text', '聚焦：GB200 NVL72 · PD · TP4 · c8')
+      .find('[data-testid="power-timeline-focus-clear"]')
+      .should('contain.text', '显示全部');
+    cy.get('[data-testid="power-timeline-status"]').should('contain.text', 'GPU 池模式');
+
+    cy.get('[data-testid="power-timeline-chart-svg"] circle.point').first().trigger('mouseenter');
+    cy.get('[data-chart-tooltip]')
+      .should('contain.text', 'GPU 池： 预填充 · 4 个 GPU')
+      .and('contain.text', '池功耗： 1,200 W')
+      .and('contain.text', '池 TDP');
+  });
+});
diff --git a/packages/app/cypress/component/scatter-graph.cy.tsx b/packages/app/cypress/component/scatter-graph.cy.tsx
index 1eb6d4c3c..26c75684d 100644
--- a/packages/app/cypress/component/scatter-graph.cy.tsx
+++ b/packages/app/cypress/component/scatter-graph.cy.tsx
@@ -1,6 +1,12 @@
 import { useReducer, useState } from 'react';
 import { GlobalFilterSelectionContext } from '@/components/GlobalFilterContext';
 import { InferenceContextsProvider } from '@/components/inference/InferenceContext';
+import {
+  PerfRulerStoreContext,
+  usePerfRulerStoreValue,
+} from '@/components/inference/perf-ruler-store';
+import { perfRulerAxisMetricKey } from '@/hooks/usePerfRulerAxisReset';
+import { serializePerfRulers } from '@/lib/d3-chart/layers/perf-ruler';
 import {
   overlaySelectionReducer,
   UnofficialRunContext,
@@ -25,6 +31,19 @@ import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.share
 const defaultChartDef = createMockChartDefinition();
 const hwConfig = createMockHardwareConfig();
 
+/** FP4 curve through x = 8, 16, 32 with distinct `conc` join keys. */
+const threePointCurve = (hwKey: string, ys: number[], extra: Partial<{ run_url: string }> = {}) =>
+  ys.map((y, index) =>
+    createMockInferenceData({
+      hwKey,
+      x: [8, 16, 32][index],
+      y,
+      conc: [8, 16, 32][index],
+      precision: Precision.FP4,
+      ...extra,
+    }),
+  );
+
 describe('ScatterGraph', () => {
   it('toggles global Pareto highlights independently and removes dismissed overlay winners', () => {
     const official = [
@@ -870,14 +889,19 @@ describe('ScatterGraph', () => {
     cy.get('#test-scatter-overlay-labels svg .line-label')
       .filter('[data-line-key]:not([data-line-key^="overlay-"])')
       .should('have.length.greaterThan', 0);
-    // The exact branch that crashed the production page remains visible in the
-    // overlay line label and legend after ScatterGraph's render-time updates.
-    cy.get('#test-scatter-overlay-labels svg .line-label[data-line-key^="overlay-"]')
-      .find('text')
-      .should('contain.text', runBranch);
+    // The pill names the hardware behind the ✕ marker, parsed like an official
+    // pill; the long branch that crashed the production page stays in the legend.
+    cy.get('#test-scatter-overlay-labels svg .line-label[data-line-key^="overlay-"] .ll-text')
+      .should('have.text', '✕ B200 (TRTLLM)')
+      .and('not.contain.text', runBranch);
     cy.get(
       '#test-scatter-overlay-labels svg .line-label[data-line-key^="overlay-"] .ll-gpu',
-    ).should('not.exist');
+    ).should('have.text', 'B200');
+    // b200_trt is active only in the overlay legend (official rows: h100), so
+    // the overlay pill must stay visible after the filter-sync effect.
+    cy.get('#test-scatter-overlay-labels svg .line-label[data-line-key^="overlay-"]')
+      .should('have.attr', 'data-visible', '1')
+      .and('have.css', 'opacity', '1');
     cy.get('#test-scatter-overlay-labels [data-testid="chart-legend"]').should(
       'contain.text',
       runBranch,
@@ -1039,7 +1063,7 @@ describe('ScatterGraph', () => {
     cy.get('#test-scatter-singleton-overlay-label svg .line-label[data-line-key^="overlay-"]')
       .should('have.length', 1)
       .find('text')
-      .should('contain.text', 'tileRT');
+      .should('have.text', '✕ B200 (TRTLLM)');
 
     cy.get('#test-scatter-singleton-overlay-label svg').then(($svg) => {
       const svg = $svg[0];
@@ -1061,6 +1085,107 @@ describe('ScatterGraph', () => {
     ).should('have.css', 'opacity', '1');
   });
 
+  it('tags overlay line labels with the run only when several runs draw the same hardware', () => {
+    const interactivityChartDef = createMockChartDefinition({
+      chartType: 'interactivity',
+      y_tpPerGpu_roofline: 'upper_left',
+    });
+    const runs = [
+      { id: 31756025413, branch: 'main' },
+      {
+        id: 35319956855,
+        branch: 'klaud/qwen3.5-fp8-gb200-dynamo-sglang-nightly-dev-cu13-20260918-20518d85',
+      },
+    ].map((run) => ({
+      ...run,
+      url: `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${run.id}`,
+    }));
+    const overlayData = {
+      data: runs.flatMap((run, index) =>
+        [8, 16, 32].map((x, i) =>
+          createMockInferenceData({
+            hwKey: 'b200_trt',
+            x,
+            y: [320, 280, 220][i] - index * 60,
+            precision: Precision.FP4,
+            run_url: run.url,
+          }),
+        ),
+      ),
+      hardwareConfig: hwConfig,
+      label: runs[0].branch,
+      runUrl: runs[0].url,
+    };
+
+    mountWithProviders(
+      <div style={{ width: 800, height: 600 }}>
+        <ScatterGraph
+          chartId="test-scatter-overlay-run-tags"
+          modelLabel="DeepSeek R1"
+          data={[]}
+          xLabel="Concurrency"
+          yLabel="Throughput / Chip (tok/s)"
+          chartDefinition={interactivityChartDef}
+          overlayData={overlayData}
+        />
+      </div>,
+      {
+        inference: {
+          hardwareConfig: hwConfig,
+          activeHwTypes: new Set<string>(),
+          hwTypesWithData: new Set<string>(),
+          selectedPrecisions: [Precision.FP4],
+          showLineLabels: true,
+        },
+        unofficial: {
+          activeOverlayHwTypes: new Set(['b200_trt']),
+          allOverlayHwTypes: new Set(['b200_trt']),
+          runIndexByUrl: Object.fromEntries(
+            runs.flatMap((run, index) => [
+              [run.url, index],
+              [String(run.id), index],
+            ]),
+          ),
+          unofficialRunInfos: runs.map((run) => ({
+            id: run.id,
+            name: 'CI run',
+            branch: run.branch,
+            sha: '7a4a06b',
+            createdAt: '2026-09-18T19:40:51Z',
+            url: run.url,
+            conclusion: 'success',
+            status: 'completed',
+            isNonMainBranch: run.branch !== 'main',
+          })),
+        },
+      },
+    );
+
+    // No official hardware is active, yet both overlay pills stay visible: they
+    // follow the overlay legend rows, not the official ones.
+    cy.get('#test-scatter-overlay-run-tags svg .line-label[data-line-key^="overlay-"]')
+      .should('have.length', 2)
+      .each(($label) => {
+        expect($label.attr('data-visible')).to.eq('1');
+        expect($label.css('opacity')).to.eq('1');
+      });
+    // Same hardware from two runs: each pill carries a short run tag, the
+    // long klaud branch shortened to its date-sha tail.
+    cy.get('#test-scatter-overlay-run-tags svg .line-label[data-line-key^="overlay-"] .ll-text')
+      .should('have.length', 2)
+      .then(($labels) => {
+        expect($labels.toArray().map((label) => label.textContent)).to.have.members([
+          '✕ B200 (TRTLLM) · main',
+          '✕ B200 (TRTLLM) · …20260918-20518d85',
+        ]);
+        for (const label of $labels) {
+          expect(
+            [...label.querySelectorAll('tspan')].map((segment) => segment.className.baseVal),
+          ).to.deep.equal(['ll-marker', 'll-gpu', 'll-engine', 'll-run']);
+        }
+      });
+  });
+
   it('renders a line label for a singleton ingested hardware series', () => {
     const interactivityChartDef = createMockChartDefinition({
       chartType: 'interactivity',
@@ -1666,6 +1791,213 @@ describe('ScatterGraph', () => {
     expectCurvesIntact();
     placeRuler();
   });
+
+  it('restores share-link perf rulers from the provider store once their curves render', () => {
+    const chartId = 'chart-0';
+    const runUrl = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/777';
+    // Three-point curves with a 2x (official pair) and 4x (official vs
+    // overlay) ratio at every knot, so the restored ruler at x=16 reads
+    // exactly on both.
+    const b200 = threePointCurve('b200_sglang', [400, 300, 200]);
+    const h100 = threePointCurve('h100_vllm', [200, 150, 100]);
+    const overlay = threePointCurve('b200_vllm', [100, 75, 50], { run_url: runUrl });
+    const chartDefinition = createMockChartDefinition({
+      chartType: 'interactivity',
+      y_tpPerGpu_roofline: 'upper_left',
+    });
+    const OFFICIAL_RULER = '16|roofline-b200_sglang_fp4|roofline-h100_vllm_fp4';
+    const OVERLAY_RULER = '16|roofline-b200_sglang_fp4|overlay-roofline-b200_vllm_fp4_run0';
+    // The overlay run carries its own hardware config; a roofline is only
+    // drawn for hardware that config knows, so the run's vLLM B200 needs an
+    // entry of its own.
+    const overlayHwConfig = { ...hwConfig, b200_vllm: hwConfig.b200_sglang };
+    const baseInference = createMockInferenceContextValues();
+
+    function StoreHarness() {
+      // The h100 curve arrives after the first draw, like `i_gpus` or a
+      // comparison date resolving on a real share-link load.
+      const [h100Loaded, setH100Loaded] = useState(false);
+      const [overlayDismissed, setOverlayDismissed] = useState(false);
+      const store = usePerfRulerStoreValue(
+        chartId,
+        `${OFFICIAL_RULER};${OVERLAY_RULER}`,
+        perfRulerAxisMetricKey(chartDefinition.x_scale_field, 'y_tpPerGpu'),
+      );
+      const inference = {
+        ...baseInference,
+        hardwareConfig: hwConfig,
+        activeHwTypes: new Set(['b200_sglang', 'h100_vllm']),
+        hwTypesWithData: new Set(h100Loaded ? ['b200_sglang', 'h100_vllm'] : ['b200_sglang']),
+        selectedModel: Model.DeepSeek_V4_Pro,
+        selectedSequence: Sequence.AgenticTraces,
+        selectedPrecisions: [Precision.FP4],
+        selectedYAxisMetric: 'y_tpPerGpu',
+      };
+      const unofficial = createMockUnofficialRunContext({
+        isUnofficialRun: true,
+        activeOverlayHwTypes: new Set(['b200_vllm']),
+        allOverlayHwTypes: new Set(['b200_vllm']),
+        runIndexByUrl: { [runUrl]: 0, '777': 0 },
+      });
+      const overlayData = overlayDismissed
+        ? undefined
+        : { data: overlay, hardwareConfig: overlayHwConfig, label: 'Overlay', runUrl };
+      return (
+        <InferenceContextsProvider
+          data={inference}
+          filters={inference}
+          display={inference}
+          actions={inference}
+        >
+          <UnofficialRunContext.Provider value={unofficial}>
+            <PerfRulerStoreContext.Provider value={store}>
+              <button data-testid="load-h100" onClick={() => setH100Loaded(true)}>
+                Load h100
+              </button>
+              <button data-testid="dismiss-overlay" onClick={() => setOverlayDismissed(true)}>
+                Dismiss overlay
+              </button>
+              <output data-testid="i-rulers">{serializePerfRulers(store.state)}</output>
+              <output data-testid="pending-count">{store.pending?.length ?? 0}</output>
+              <div style={{ width: 800, height: 600 }}>
+                <ScatterGraph
+                  chartId={chartId}
+                  modelLabel={Model.DeepSeek_V4_Pro}
+                  data={h100Loaded ? [...b200, ...h100] : b200}
+                  xLabel="Interactivity"
+                  yLabel="Throughput / Chip (tok/s)"
+                  chartDefinition={chartDefinition}
+                  overlayData={overlayData}
+                  transitionDuration={0}
+                />
+              </div>
+              {/* The replay chart draws the same curve classes under the same
+                  provider and must not pick the persisted rulers up. */}
+              <div style={{ width: 800, height: 600 }}>
+                <ScatterGraph
+                  chartId={`replay-${chartId}`}
+                  modelLabel={Model.DeepSeek_V4_Pro}
+                  data={[...b200, ...h100]}
+                  xLabel="Interactivity"
+                  yLabel="Throughput / Chip (tok/s)"
+                  chartDefinition={chartDefinition}
+                  transitionDuration={0}
+                />
+              </div>
+            </PerfRulerStoreContext.Provider>
+          </UnofficialRunContext.Provider>
+        </InferenceContextsProvider>
+      );
+    }
+
+    mountWithProviders(<StoreHarness />);
+
+    // Nobody clicked anything: the mode is on for the persisted chart only,
+    // the overlay pair renders (both curves exist), and the official pair
+    // waits for its second curve instead of being pruned. Advanced switches
+    // only mount once each legend's drawer is open.
+    cy.get(`#${chartId} svg .roofline-path`).should('have.length', 1);
+    cy.get('[data-testid="legend-advanced-toggle"]')
+      .should('have.length', 2)
+      .click({ multiple: true });
+    // Two charts render the switch under one id; jQuery's `#id` fast path
+    // returns only the first match, so select by attribute.
+    cy.get('[id="scatter-perf-ruler"]').should('have.length', 2);
+    cy.get('[id="scatter-perf-ruler"]').first().should('have.attr', 'aria-checked', 'true');
+    cy.get(`#${chartId} svg .perf-ruler`).should('have.length', 1);
+    cy.get(`#${chartId} svg .perf-ruler .pr-text-ratio`).should('have.text', '4.00x');
+    cy.get('[data-testid="i-rulers"]').should('have.text', OVERLAY_RULER);
+    cy.get('[data-testid="pending-count"]').should('have.text', '1');
+    cy.get(`#replay-${chartId} svg .roofline-path`).should('have.length', 2);
+    cy.get(`#replay-${chartId} svg .perf-ruler`).should('not.exist');
+    cy.get('[id="scatter-perf-ruler"]').eq(1).should('have.attr', 'aria-checked', 'false');
+
+    // The late curve arrives: the pending ruler commits and both render.
+    cy.get('[data-testid="load-h100"]').click();
+    cy.get(`#${chartId} svg .roofline-path`).should('have.length', 2);
+    cy.get(`#${chartId} svg .perf-ruler`).should('have.length', 2);
+    cy.get(`#${chartId} svg .perf-ruler .pr-text-ratio`).then(($labels) => {
+      expect([...$labels].map((label) => label.textContent).sort()).to.deep.equal([
+        '2.00x',
+        '4.00x',
+      ]);
+    });
+    cy.get('[data-testid="pending-count"]').should('have.text', '0');
+    cy.get('[data-testid="i-rulers"]').should('have.text', `${OVERLAY_RULER};${OFFICIAL_RULER}`);
+    cy.get(`#replay-${chartId} svg .perf-ruler`).should('not.exist');
+
+    // Dismissing the overlay run prunes only the ruler that referenced it.
+    cy.get('[data-testid="dismiss-overlay"]').click();
+    cy.get(`#${chartId} svg .overlay-roofline-path`).should('not.exist');
+    cy.get(`#${chartId} svg .perf-ruler`).should('have.length', 1);
+    cy.get(`#${chartId} svg .perf-ruler .pr-text-ratio`).should('have.text', '2.00x');
+    cy.get('[data-testid="i-rulers"]').should('have.text', OFFICIAL_RULER);
+
+    // Toggling the tool off clears the persisted rulers, so the share link
+    // drops the param.
+    cy.get('[id="scatter-perf-ruler"]').first().click({ force: true });
+    cy.get(`#${chartId} svg .perf-ruler`).should('not.exist');
+    cy.get('[data-testid="i-rulers"]').should('have.text', '');
+  });
+
+  it('discards pending share-link rulers when the tool is switched off before their curves load', () => {
+    const chartId = 'chart-0';
+    const chartDefinition = createMockChartDefinition({
+      chartType: 'interactivity',
+      y_tpPerGpu_roofline: 'upper_left',
+    });
+    const b200 = [8, 16, 32].map((x, index) =>
+      createMockInferenceData({ hwKey: 'b200_sglang', x, y: 400 - index * 100, conc: x }),
+    );
+    const baseInference = createMockInferenceContextValues();
+
+    function PendingHarness() {
+      const store = usePerfRulerStoreValue(
+        chartId,
+        '16|roofline-b200_sglang_fp4|roofline-h100_vllm_fp4',
+        perfRulerAxisMetricKey(chartDefinition.x_scale_field, 'y_tpPerGpu'),
+      );
+      const inference = {
+        ...baseInference,
+        hardwareConfig: hwConfig,
+        activeHwTypes: new Set(['b200_sglang']),
+        hwTypesWithData: new Set(['b200_sglang']),
+        selectedYAxisMetric: 'y_tpPerGpu',
+      };
+      return (
+        <InferenceContextsProvider
+          data={inference}
+          filters={inference}
+          display={inference}
+          actions={inference}
+        >
+          <PerfRulerStoreContext.Provider value={store}>
+            <output data-testid="pending-count">{store.pending?.length ?? 0}</output>
+            <div style={{ width: 800, height: 600 }}>
+              <ScatterGraph
+                chartId={chartId}
+                modelLabel={Model.DeepSeek_V4_Pro}
+                data={b200}
+                xLabel="Interactivity"
+                yLabel="Throughput / Chip (tok/s)"
+                chartDefinition={chartDefinition}
+                transitionDuration={0}
+              />
+            </div>
+          </PerfRulerStoreContext.Provider>
+        </InferenceContextsProvider>
+      );
+    }
+
+    mountWithProviders(<PendingHarness />, { unofficial: {} });
+    cy.get(`#${chartId} svg .roofline-path`).should('have.length', 1);
+    expandLegendAdvanced();
+    cy.get('#scatter-perf-ruler').should('have.attr', 'aria-checked', 'true');
+    cy.get('[data-testid="pending-count"]').should('have.text', '1');
+    cy.get('#scatter-perf-ruler').click({ force: true });
+    cy.get('#scatter-perf-ruler').should('have.attr', 'aria-checked', 'false');
+    cy.get('[data-testid="pending-count"]').should('have.text', '0');
+  });
 });
 
 describe('ChartDisplay responsive status notes', () => {
diff --git a/packages/app/cypress/e2e/cache-reuse.cy.ts b/packages/app/cypress/e2e/cache-reuse.cy.ts
new file mode 100644
index 000000000..7843b06ed
--- /dev/null
+++ b/packages/app/cypress/e2e/cache-reuse.cy.ts
@@ -0,0 +1,163 @@
+/**
+ * Prefix Cache Reuse (`/cache-reuse`).
+ *
+ * Stacked shares of prompt tokens per concurrency for one configuration: HBM
+ * hits, host-tier hits, and the rest. The agentic overlay fixtures report
+ * gpu 0.8 / external 0.1 / cpu 0.05 with offload on, so every bar must read
+ * 80 / 5 / 15 — the host tier is the CPU-offload figure and the router's
+ * external figure is not added on top. The fixed-sequence fixtures carry no
+ * cache tier at all, which is the page's honest empty state for that scenario.
+ */
+import { interceptDerivedAgenticMetrics, unlockAgenticGate } from '../support/e2e';
+import {
+  interceptCalculatorOverlayRun,
+  interceptOverlayRun,
+  OVERLAY_RUN_BRANCH,
+  OVERLAY_RUN_ID,
+  REAL_CONFIGS,
+} from '../support/overlay-fixtures';
+
+const BARS = '[data-testid="cache-reuse-chart"] svg .cr-bar';
+const SEGMENTS = '[data-testid="cache-reuse-chart"] svg .cr-segment';
+const X_TICKS = '[data-testid="cache-reuse-chart"] svg .x-axis .tick text';
+
+const dismissNudges = (win: Cypress.AUTWindow) => {
+  win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
+  win.sessionStorage.setItem('inferencex-reproducibility-nudge-shown', '1');
+};
+
+const firstRowCell = (header: string) =>
+  cy.get('[data-testid="cache-reuse-table"] thead th').then(($ths) => {
+    const index = $ths.toArray().findIndex((th) => (th.textContent ?? '').includes(header));
+    expect(index, `a column headed "${header}"`).to.be.greaterThan(-1);
+    return cy.get('[data-testid="cache-reuse-table"] tbody tr').first().find('td').eq(index);
+  });
+
+describe('Prefix Cache Reuse', () => {
+  describe('official rows', () => {
+    before(() => {
+      interceptOverlayRun();
+      cy.visit('/cache-reuse', { onBeforeLoad: dismissNudges });
+      cy.wait('@benchmarks');
+      cy.get('[data-testid="cache-reuse-figure"]').should('exist');
+    });
+
+    it('stacks HBM, host, and not-reused shares for every measured concurrency', () => {
+      cy.get(BARS).should('have.length', REAL_CONFIGS.length);
+      for (const tier of ['hbm', 'host', 'unreused']) {
+        cy.get(`${SEGMENTS}[data-tier="${tier}"]`).should('have.length', REAL_CONFIGS.length);
+      }
+      cy.get(X_TICKS).then(($ticks) => {
+        expect([...$ticks].map((el) => el.textContent)).to.deep.equal(['1', '2', '4', '8', '48']);
+      });
+      cy.get('.sidebar-legend')
+        .should('contain.text', 'HBM cache')
+        .and('contain.text', 'Host cache')
+        .and('contain.text', 'Not reused');
+    });
+
+    it('takes the host tier from the CPU-offload rate and leaves the external rate out', () => {
+      firstRowCell('HBM').should('have.text', '80.0%');
+      firstRowCell('Host').should('have.text', '5.0%');
+      firstRowCell('Not reused').should('have.text', '15.0%');
+    });
+
+    it('labels the configuration control and shows the plotted config', () => {
+      cy.get('label[for="cache-reuse-config"]').should('contain.text', 'Configuration');
+      cy.get('[data-testid="cache-reuse-config-selector"]').should('contain.text', 'B300');
+      cy.get('[data-testid="cache-reuse-figure"] figcaption').should(
+        'contain.text',
+        `${REAL_CONFIGS.length} of ${REAL_CONFIGS.length} measured rows report cache tiers`,
+      );
+    });
+  });
+
+  describe('share-link seeding', () => {
+    it('falls back to a tiered configuration when the requested one is unknown', () => {
+      interceptOverlayRun();
+      cy.visit('/cache-reuse?c_cfg=nope_sglang', { onBeforeLoad: dismissNudges });
+      cy.wait('@benchmarks');
+      cy.get(BARS).should('have.length', REAL_CONFIGS.length);
+      cy.get('[data-testid="cache-reuse-config-selector"]').should('contain.text', 'B300');
+    });
+  });
+
+  describe('unofficial-run overlay', () => {
+    before(() => {
+      interceptOverlayRun();
+      cy.visit(`/cache-reuse?unofficialrun=${OVERLAY_RUN_ID}`, { onBeforeLoad: dismissNudges });
+      cy.wait('@unofficialRun');
+      cy.get(`${BARS}[data-series="run:0"]`).should('have.length', REAL_CONFIGS.length);
+    });
+
+    it('draws the run as its own outlined series beside the official bars', () => {
+      cy.get(BARS).should('have.length', REAL_CONFIGS.length * 2);
+      cy.get(`${BARS}[data-series="run:0"]`)
+        .first()
+        .should('have.attr', 'stroke')
+        .and('include', 'overlay-run-0');
+      cy.get(`${BARS}[data-series="official"]`).first().should('have.attr', 'stroke', 'none');
+      cy.get('.sidebar-legend').should('contain.text', OVERLAY_RUN_BRANCH);
+    });
+
+    it('lists the run under its branch in the table', () => {
+      cy.get('[data-testid="cache-reuse-table"] tbody tr').should(
+        'have.length',
+        REAL_CONFIGS.length * 2,
+      );
+      cy.get('[data-testid="cache-reuse-table"] tbody').should('contain.text', OVERLAY_RUN_BRANCH);
+    });
+  });
+
+  describe('fixed sequences', () => {
+    it('explains that fixed-sequence rows record no cache tiers', () => {
+      interceptCalculatorOverlayRun();
+      cy.visit('/cache-reuse?i_seq=1k%2F1k', { onBeforeLoad: dismissNudges });
+      cy.wait('@benchmarks');
+      cy.get('[data-testid="cache-reuse-no-tiers"]').should('contain.text', 'Fixed-sequence');
+      cy.get(BARS).should('not.exist');
+    });
+  });
+
+  describe('entry from the inference chart', () => {
+    it('links the agentic footer to the tab with the chart state attached', () => {
+      interceptOverlayRun();
+      interceptDerivedAgenticMetrics();
+      cy.visit('/inference?g_model=DeepSeek-V4-Pro&i_seq=agentic-traces&i_prec=fp4', {
+        onBeforeLoad(win) {
+          dismissNudges(win);
+          unlockAgenticGate(win);
+        },
+      });
+      cy.wait('@benchmarks');
+      cy.get('[data-testid="chart-status-notes"] [data-testid="cache-reuse-link"]')
+        .should('have.attr', 'href')
+        .and('match', /^\/cache-reuse\?/)
+        .and('include', 'i_seq=agentic-traces');
+      cy.get('[data-testid="cache-reuse-link"]').click();
+      cy.location('pathname').should('eq', '/cache-reuse');
+      cy.get(BARS).should('have.length', REAL_CONFIGS.length);
+    });
+
+    it('stays off the fixed-sequence chart', () => {
+      interceptCalculatorOverlayRun();
+      cy.visit('/inference?i_seq=1k%2F1k', { onBeforeLoad: dismissNudges });
+      cy.wait('@benchmarks');
+      cy.get('[data-testid="chart-status-notes"] [data-testid="cache-reuse-link"]').should(
+        'not.exist',
+      );
+    });
+  });
+
+  describe('Chinese page', () => {
+    it('renders the intro and Chinese tier labels', () => {
+      interceptOverlayRun();
+      cy.visit('/zh/cache-reuse', { onBeforeLoad: dismissNudges });
+      cy.wait('@benchmarks');
+      cy.get('[data-testid="zh-tab-intro"]').should('contain.text', '前缀缓存复用');
+      cy.get('label[for="cache-reuse-config"]').should('contain.text', '配置');
+      cy.get('.sidebar-legend').should('contain.text', 'HBM 缓存').and('contain.text', '未复用');
+      firstRowCell('HBM').should('have.text', '80.0%');
+    });
+  });
+});
diff --git a/packages/app/cypress/e2e/first-token-limits.cy.ts b/packages/app/cypress/e2e/first-token-limits.cy.ts
new file mode 100644
index 000000000..febb1cf87
--- /dev/null
+++ b/packages/app/cypress/e2e/first-token-limits.cy.ts
@@ -0,0 +1,221 @@
+/**
+ * First-Token Limits (`/first-token`).
+ *
+ * The page reads *measured* rows: for each time-to-first-token cap, the cheapest
+ * configuration per vendor that also clears an interactivity floor. The
+ * fixed-sequence overlay fixtures suit it well — every row reports a 0.5 s
+ * median TTFT, so a 0.1 s cap empties every slot and a 2 s cap fills them, and
+ * the floor decides which concurrency wins.
+ *
+ * Official data: B300 (tput ×1) and B200 (×0.6), both NVIDIA, so the page shows
+ * one vendor series. The unofficial run adds B300 (×1.3) and an overlay-only
+ * MI355X (×0.8), which must render as the run's own bar rather than an AMD bar.
+ */
+import {
+  interceptCalculatorOverlayRun,
+  OVERLAY_ONLY_HARDWARE,
+  OVERLAY_RUN_BRANCH,
+  OVERLAY_RUN_ID,
+  SINGLE_TURN_CONFIGS,
+} from '../support/overlay-fixtures';
+
+const SEQUENCE = '1k/1k';
+const BARS = '[data-testid="first-token-chart"] svg .ft-bar';
+const EMPTY_MARKS = '[data-testid="first-token-chart"] svg .ft-empty';
+const X_TICKS = '[data-testid="first-token-chart"] svg .x-axis .tick text';
+const SUMMARY = '[data-testid="first-token-chart"] svg .ft-summary-who';
+
+const concurrenciesAtOrAbove = (floor: number) =>
+  SINGLE_TURN_CONFIGS.filter(([, intvty]) => intvty >= floor).map(([conc]) => conc);
+
+const dismissNudges = (win: Cypress.AUTWindow) => {
+  win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
+  win.sessionStorage.setItem('inferencex-reproducibility-nudge-shown', '1');
+};
+
+/**
+ * A named cell of the first table row, resolved by header text so a new column
+ * cannot silently re-point an assertion at its neighbour.
+ */
+const firstRowCell = (header: string) =>
+  cy.get('[data-testid="first-token-table"] thead th').then(($ths) => {
+    const index = $ths.toArray().findIndex((th) => (th.textContent ?? '').includes(header));
+    expect(index, `a column headed "${header}"`).to.be.greaterThan(-1);
+    return cy.get('[data-testid="first-token-table"] tbody tr').first().find('td').eq(index);
+  });
+
+describe('First-Token Limits', () => {
+  describe('official rows only', () => {
+    before(() => {
+      interceptCalculatorOverlayRun();
+      cy.visit(`/first-token?i_seq=${encodeURIComponent(SEQUENCE)}&c_ttft=0.1,2`, {
+        onBeforeLoad: dismissNudges,
+      });
+      cy.wait('@benchmarks');
+      cy.get('[data-testid="first-token-figure"]').should('exist');
+    });
+
+    it('labels the controls and reads the cap ladder from the URL', () => {
+      cy.get('label[for="first-token-caps"]').should('contain.text', 'TTFT Caps');
+      cy.get('[data-testid="first-token-caps"]').should('have.value', '0.1,2');
+      cy.get('label[for="first-token-min-interactivity"]').should(
+        'contain.text',
+        'Minimum Median Interactivity',
+      );
+      // Fixed sequences default to the calculator's floor; the field shows it
+      // as a placeholder rather than writing the default into the URL.
+      cy.get('[data-testid="first-token-min-interactivity"]')
+        .should('have.value', '')
+        .and('have.attr', 'placeholder', '35');
+      cy.get(X_TICKS).should('have.length', 2);
+      cy.get(X_TICKS).first().should('have.text', '≤0.1s');
+      cy.get(X_TICKS).last().should('have.text', '≤2s');
+    });
+
+    it('draws one bar per vendor under a cap the rows clear, and marks the cap they do not', () => {
+      cy.get(BARS).should('have.length', 1);
+      cy.get(BARS).should('have.attr', 'data-series', 'vendor:NVIDIA');
+      cy.get(BARS).should('have.attr', 'data-hw', 'b300_sglang');
+      cy.get(EMPTY_MARKS).should('have.length', 1);
+      cy.get(SUMMARY).then(($texts) => {
+        const labels = [...$texts].map((el) => el.textContent ?? '');
+        expect(labels).to.deep.equal(['', 'B300 only']);
+      });
+    });
+
+    it('picks the cheapest row that clears the interactivity floor, not the cheapest row', () => {
+      // At the 35 tok/s floor the 48-concurrency row (10.6 tok/s) is out, so the
+      // winner is the next-highest-throughput row: concurrency 8.
+      expect(concurrenciesAtOrAbove(35)).to.deep.equal([8, 2, 1]);
+      firstRowCell('Concurrency').should('have.text', '8');
+      firstRowCell('Configuration').should('contain.text', 'B300');
+      firstRowCell('Median TTFT').should('have.text', '0.50');
+
+      // Raising the floor above 111 tok/s leaves only the single-user row.
+      cy.get('[data-testid="first-token-min-interactivity"]').clear().type('120').blur();
+      firstRowCell('Concurrency').should('have.text', '1');
+      cy.get(BARS).should('have.length', 1);
+
+      cy.get('[data-testid="first-token-min-interactivity"]').clear().blur();
+      firstRowCell('Concurrency').should('have.text', '8');
+    });
+
+    it('re-picks the winner when the legend isolates another chip', () => {
+      // Clicking a visible entry while everything is visible solos it, the
+      // calculator's legend convention; clicking the lone entry restores all.
+      cy.get('.sidebar-legend label').contains('B200').click();
+      cy.get(BARS).should('have.attr', 'data-hw', 'b200_sglang');
+      cy.get(SUMMARY).last().should('have.text', 'B200 only');
+      cy.get('.sidebar-legend label').contains('B200').click();
+      cy.get(BARS).should('have.attr', 'data-hw', 'b300_sglang');
+    });
+
+    it('normalizes a typed ladder into the field and the axis', () => {
+      cy.get('[data-testid="first-token-caps"]').clear().type('5, 1,junk,1').blur();
+      cy.get('[data-testid="first-token-caps"]').should('have.value', '1,5');
+      cy.get(X_TICKS).should('have.length', 2);
+      cy.get(X_TICKS).first().should('have.text', '≤1s');
+      cy.get(BARS).should('have.length', 2);
+      cy.get('[data-testid="first-token-caps"]').clear().type('0.1,2').blur();
+      cy.get(BARS).should('have.length', 1);
+    });
+  });
+
+  describe('empty states', () => {
+    it('blames the cap ladder, not the floor, when rows qualify but none clears a cap', () => {
+      interceptCalculatorOverlayRun();
+      cy.visit(`/first-token?i_seq=${encodeURIComponent(SEQUENCE)}&c_ttft=0.01`, {
+        onBeforeLoad: dismissNudges,
+      });
+      cy.wait('@benchmarks');
+      cy.get('[data-testid="first-token-none-qualify"]')
+        .should('contain.text', 'largest cap on this ladder (≤0.01s)')
+        .and('not.contain.text', 'Lower the floor');
+      cy.get(BARS).should('not.exist');
+    });
+
+    it('blames the floor when nothing reaches the requested interactivity', () => {
+      interceptCalculatorOverlayRun();
+      cy.visit(`/first-token?i_seq=${encodeURIComponent(SEQUENCE)}&c_ivmin=100000`, {
+        onBeforeLoad: dismissNudges,
+      });
+      cy.wait('@benchmarks');
+      cy.get('[data-testid="first-token-none-qualify"]').should('contain.text', 'Lower the floor');
+    });
+  });
+
+  describe('share-link seeding', () => {
+    it('reads the interactivity floor and cap ladder from the URL', () => {
+      // Share-link params are stripped from the address bar on load and carried
+      // by the share button instead, so seeding is asserted on the controls.
+      interceptCalculatorOverlayRun();
+      cy.visit(`/first-token?i_seq=${encodeURIComponent(SEQUENCE)}&c_ivmin=120&c_ttft=1`, {
+        onBeforeLoad: dismissNudges,
+      });
+      cy.wait('@benchmarks');
+      cy.get('[data-testid="first-token-min-interactivity"]').should('have.value', '120');
+      cy.get('[data-testid="first-token-caps"]').should('have.value', '1');
+      cy.get(X_TICKS).should('have.length', 1);
+      firstRowCell('Concurrency').should('have.text', '1');
+    });
+  });
+
+  describe('unofficial-run overlay', () => {
+    before(() => {
+      interceptCalculatorOverlayRun();
+      cy.visit(
+        `/first-token?unofficialrun=${OVERLAY_RUN_ID}&i_seq=${encodeURIComponent(SEQUENCE)}&c_ttft=0.1,2`,
+        { onBeforeLoad: dismissNudges },
+      );
+      cy.wait('@unofficialRun');
+      cy.get(BARS).should('have.length', 2);
+    });
+
+    it('adds the run as its own series in the palette color, never as a vendor bar', () => {
+      cy.get(BARS).then(($bars) => {
+        const series = [...$bars].map((el) => el.dataset.series);
+        expect(series).to.deep.equal(['vendor:NVIDIA', 'run:0']);
+        const fills = [...$bars].map((el) => el.getAttribute('fill') ?? '');
+        expect(fills.filter((f) => f.includes('overlay-run-0'))).to.have.length(1);
+      });
+      // The run's cheapest qualifying row is its faster B300, not the overlay-only MI355X.
+      cy.get(`${BARS}[data-series="run:0"]`).should('have.attr', 'data-hw', 'b300_sglang');
+      cy.get(EMPTY_MARKS).should('have.length', 2);
+      cy.get('.sidebar-legend').should('contain.text', OVERLAY_RUN_BRANCH);
+      cy.get('.sidebar-legend').should('contain.text', OVERLAY_ONLY_HARDWARE.toUpperCase());
+    });
+
+    it('lists the run under the branch name in the table with the official rows above', () => {
+      cy.get('[data-testid="first-token-table"] tbody tr').should('have.length', 2);
+      cy.get('[data-testid="first-token-table"] tbody').should('contain.text', OVERLAY_RUN_BRANCH);
+    });
+
+    it('lets the legend hide hardware inside the run too', () => {
+      // Solo the overlay-only MI355X: no official chip is visible, so the vendor
+      // bar goes, and the run's bar moves off its (hidden) B300 onto MI355X.
+      cy.get('.sidebar-legend label').contains(OVERLAY_ONLY_HARDWARE.toUpperCase()).click();
+      cy.get(BARS).should('have.length', 1);
+      cy.get(BARS)
+        .should('have.attr', 'data-series', 'run:0')
+        .and('have.attr', 'data-hw', `${OVERLAY_ONLY_HARDWARE}_sglang`);
+      cy.get('.sidebar-legend label').contains(OVERLAY_ONLY_HARDWARE.toUpperCase()).click();
+      cy.get(BARS).should('have.length', 2);
+      cy.get(`${BARS}[data-series="run:0"]`).should('have.attr', 'data-hw', 'b300_sglang');
+    });
+  });
+
+  describe('Chinese page', () => {
+    it('renders the intro and Chinese control labels', () => {
+      interceptCalculatorOverlayRun();
+      cy.visit(`/zh/first-token?i_seq=${encodeURIComponent(SEQUENCE)}`, {
+        onBeforeLoad: dismissNudges,
+      });
+      cy.wait('@benchmarks');
+      cy.get('[data-testid="zh-tab-intro"]').should('contain.text', '首 token 延迟约束');
+      cy.get('label[for="first-token-caps"]').should('contain.text', 'TTFT 上限');
+      cy.get('label[for="first-token-min-interactivity"]').should('contain.text', '交互性');
+      cy.get('[data-testid="first-token-figure"]').should('exist');
+      cy.get(SUMMARY).last().should('have.text', '仅 B300');
+    });
+  });
+});
diff --git a/packages/app/cypress/e2e/landing-dashboard-navigation.cy.ts b/packages/app/cypress/e2e/landing-dashboard-navigation.cy.ts
index 291a834a2..584edf8c8 100644
--- a/packages/app/cypress/e2e/landing-dashboard-navigation.cy.ts
+++ b/packages/app/cypress/e2e/landing-dashboard-navigation.cy.ts
@@ -23,6 +23,37 @@ interface HistoryWrite {
   pathname: string;
 }
 
+describe('landing model curation', () => {
+  for (const prefix of ['', '/zh']) {
+    it(`shows the curated ledger on ${prefix || '/'} without changing compare coverage`, () => {
+      cy.visit(prefix || '/');
+      cy.get('[data-testid="compare-agentx-primary"]').within(() => {
+        cy.get('[data-testid^="compare-agentx-model-"]').should(($links) => {
+          expect([...$links].map((link) => link.getAttribute('href'))).to.deep.eq(
+            ['kimi-k3', 'deepseek-v41-flash', 'glm-5-3', 'minimax-m3', 'qwen-3-5'].map(
+              (slug) => `${prefix}/inference/${slug}`,
+            ),
+          );
+        });
+        cy.get('[data-testid="compare-agentx-model-deepseek-v4"]').should('not.exist');
+        cy.get('[data-testid="compare-agentx-model-qwen-3-8-flash-next"]').should('not.exist');
+      });
+
+      cy.visit(`${prefix}/compare`);
+      cy.get('[data-testid="compare-agentx-primary"]').within(() => {
+        cy.get('[data-testid^="compare-agentx-model-"]').should('have.length', 7);
+        for (const slug of ['deepseek-v4', 'qwen-3-8-flash-next']) {
+          cy.get(`[data-testid="compare-agentx-model-${slug}"]`).should(
+            'have.attr',
+            'href',
+            `${prefix}/inference/${slug}`,
+          );
+        }
+      });
+    });
+  }
+});
+
 describe('landing → full dashboard navigation', () => {
   const isChromium = Cypress.browser.family === 'chromium';
 
diff --git a/packages/app/cypress/e2e/measured-power-overlay.cy.ts b/packages/app/cypress/e2e/measured-power-overlay.cy.ts
index 13ea47a29..2f6d05ba7 100644
--- a/packages/app/cypress/e2e/measured-power-overlay.cy.ts
+++ b/packages/app/cypress/e2e/measured-power-overlay.cy.ts
@@ -1,3 +1,5 @@
+import { assertShareLinkMetric } from '../support/share-link';
+
 // Verifies the new measured-power Y-axis options render on the unofficial-run
 // overlay path against a real GitHub Actions artifact (run 26312107787 — the
 // on-PR sweep for PR #1558 / qwen3.5-fp8-h200-sglang). This is the canonical
@@ -70,4 +72,32 @@ describe('Measured power on unofficial-run overlay', () => {
     cy.screenshot('measured-joules-selected', { capture: 'viewport' });
     cy.get('[data-testid="inference-chart-display"] svg').should('exist');
   });
+
+  it('switches the power boundary on the overlay view and keeps the derived key in the URL', () => {
+    cy.get('[data-testid="yaxis-metric-selector"]').click('right');
+    cy.contains('[data-slot="select-item"]', /^Measured Power$/u)
+      .scrollIntoView()
+      .click();
+    cy.get('[data-testid="measured-power-basis"]').should('contain.text', 'GPU measured');
+    // The boundary control and its derived key ride the overlay view like any
+    // other Measured setting. Overlay rows plotted on a derived boundary are
+    // covered with intercepted rows in powerx-basis.cy.ts.
+    cy.get('[data-testid="measured-power-basis"]').click();
+    cy.get('[data-slot="select-item"][data-value="utility-provisioned"]').click();
+    assertShareLinkMetric('y_utilityProvisionedWatts');
+    cy.get('[data-testid="chart-figure"] h2').should(
+      'contain.text',
+      'Utility Provisioned Power per Chip (all-in)',
+    );
+    cy.get('[data-testid="measured-basis-hint"]').should('be.visible');
+    cy.get('[data-testid="power-basis-assumptions"]')
+      .should('have.attr', 'data-power-basis', 'utility-provisioned')
+      .and('contain.text', 'all-in provisioned utility power per GPU');
+    cy.get('[data-testid="inference-chart-display"] svg').should('exist');
+    // Any telemetry-only setting returns to the GPU measured boundary.
+    cy.get('[data-testid="measured-power-statistic-p90"]').click();
+    assertShareLinkMetric('y_measuredP90Power');
+    cy.get('[data-testid="measured-power-basis"]').should('contain.text', 'GPU measured');
+    cy.get('[data-testid="measured-basis-hint"]').should('not.exist');
+  });
 });
diff --git a/packages/app/cypress/e2e/navigation.cy.ts b/packages/app/cypress/e2e/navigation.cy.ts
index f671a9808..aa088182b 100644
--- a/packages/app/cypress/e2e/navigation.cy.ts
+++ b/packages/app/cypress/e2e/navigation.cy.ts
@@ -53,6 +53,22 @@ describe('Chart Section Tabs — E2E', () => {
     cy.url().should('include', '/fleet');
   });
 
+  it('opens First-Token Limits from the footer link', () => {
+    cy.get('[data-testid="tab-trigger-first-token"]').should('not.exist');
+
+    cy.get('[data-testid="footer-link-first-token"]').scrollIntoView().click();
+    cy.url().should('include', '/first-token');
+    cy.get('[data-testid="first-token-controls"]').should('exist');
+  });
+
+  it('opens Prefix Cache Reuse from the footer link', () => {
+    cy.get('[data-testid="tab-trigger-cache-reuse"]').should('not.exist');
+
+    cy.get('[data-testid="footer-link-cache-reuse"]').scrollIntoView().click();
+    cy.url().should('include', '/cache-reuse');
+    cy.get('[data-testid="cache-reuse-controls"]').should('exist');
+  });
+
   it('opens GPU Reliability from the footer link', () => {
     cy.get('[data-testid="tab-trigger-reliability"]').should('not.exist');
 
@@ -166,8 +182,8 @@ describe('First-load navigation', () => {
         .should('have.text', 'Dashboard')
         .and('have.attr', 'href', '/inference/kimi-k3');
       cy.get('[data-testid="compare-agentx-methodology-link"]').should('not.exist');
-      cy.get('[data-testid^="compare-agentx-model-"]').should('have.length', 7);
-      // Editorial order, not alphabetical — see FEATURED_AGENTX_MODEL_SLUGS.
+      cy.get('[data-testid^="compare-agentx-model-"]').should('have.length', 5);
+      // Landing curation preserves the relative editorial order.
       cy.get('[data-testid^="compare-agentx-model-"]').then(($rows) => {
         const slugs = [...$rows].map((row) =>
           (row.dataset.testid ?? '').replace('compare-agentx-model-', ''),
@@ -175,23 +191,21 @@ describe('First-load navigation', () => {
         expect(slugs).to.deep.equal([
           'kimi-k3',
           'deepseek-v41-flash',
-          'deepseek-v4',
           'glm-5-3',
           'minimax-m3',
           'qwen-3-5',
-          'qwen-3-8-flash-next',
         ]);
       });
       // Only the still-new rows carry the NEW pill — see AGENTX_NEW_MODEL_SLUGS.
       cy.get('[data-testid^="compare-agentx-model-"] [data-new-badge="agentx-ledger"]')
-        .should('have.length', 4)
+        .should('have.length', 3)
         .each(($badge) => expect($badge.text()).to.equal('NEW'));
-      for (const slug of ['kimi-k3', 'deepseek-v41-flash', 'glm-5-3', 'qwen-3-8-flash-next']) {
+      for (const slug of ['kimi-k3', 'deepseek-v41-flash', 'glm-5-3']) {
         cy.get(
           `[data-testid="compare-agentx-model-${slug}"] [data-new-badge="agentx-ledger"]`,
         ).should('exist');
       }
-      for (const slug of ['deepseek-v4', 'minimax-m3', 'qwen-3-5']) {
+      for (const slug of ['minimax-m3', 'qwen-3-5']) {
         cy.get(
           `[data-testid="compare-agentx-model-${slug}"] [data-new-badge="agentx-ledger"]`,
         ).should('not.exist');
diff --git a/packages/app/cypress/e2e/nudge-system.cy.ts b/packages/app/cypress/e2e/nudge-system.cy.ts
index ee716fb28..d46fe7ba7 100644
--- a/packages/app/cypress/e2e/nudge-system.cy.ts
+++ b/packages/app/cypress/e2e/nudge-system.cy.ts
@@ -51,11 +51,11 @@ describe('Landing nudges — modals', { testIsolation: true }, () => {
       .and('contain.text', 'Rubin Agentic Inference Performance')
       .and('contain.text', '67x Faster than Blackwell Ultra')
       .and('contain.text', 'View results');
-    // Banner + header-nav badges, plus the four still-new AgentX hero ledger
-    // rows (AGENTX_NEW_MODEL_SLUGS) — the shared pill must render at the same
+    // Banner + header-nav badges, plus the three still-new landing ledger
+    // rows — the shared pill must render at the same
     // fixed size everywhere it appears.
     cy.get('[data-new-badge]')
-      .should('have.length', 6)
+      .should('have.length', 5)
       .then(($badges) => {
         const sizes = [...$badges].map((badge) => {
           const rect = badge.getBoundingClientRect();
diff --git a/packages/app/cypress/e2e/powerx-basis.cy.ts b/packages/app/cypress/e2e/powerx-basis.cy.ts
new file mode 100644
index 000000000..41fc06b9e
--- /dev/null
+++ b/packages/app/cypress/e2e/powerx-basis.cy.ts
@@ -0,0 +1,342 @@
+import { assertShareLinkMetric } from '../support/share-link';
+
+// Power boundaries inside the gated Measured Energy group. Deterministic
+// intercepted rows carry validated telemetry and throughput, so every boundary
+// (GPU measured, GPU provisioned, utility provisioned, utility modeled) has a
+// value on the official B200 rows; the overlay run adds H200 rows. The metric
+// key carries the boundary — there is no separate URL parameter to round-trip.
+
+const BASIS_MODEL = 'dsv4';
+const BASIS_DATE = '2026-09-01';
+const BASIS_OVERLAY_RUN_ID = '31415926535';
+const BASIS_OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${BASIS_OVERLAY_RUN_ID}`;
+
+/** conc, interactivity (tok/s/user), output tok/s per GPU, measured W per GPU, measured J/out */
+const BASIS_CONFIGS: [number, number, number, number, number][] = [
+  [16, 90, 200, 500, 2.5],
+  [64, 60, 400, 600, 1.5],
+  [256, 30, 800, 700, 0.875],
+];
+
+// HW_REGISTRY: b200 tdp 1000 W / all-in 1.71 kW; h200 tdp 700 W / all-in 1.37 kW.
+const B200_ALL_IN_WATTS = 1710;
+const H200_ALL_IN_WATTS = 1370;
+const B200_TDP_WATTS = 1000;
+
+const basisMetrics = (
+  intvty: number,
+  outputTput: number,
+  watts: number,
+  joulesPerOutput: number,
+): Record<string, number> => ({
+  median_intvty: intvty,
+  median_itl: 1 / intvty,
+  median_e2el: 20,
+  median_ttft: 0.5,
+  tput_per_gpu: outputTput * 9,
+  output_tput_per_gpu: outputTput,
+  input_tput_per_gpu: outputTput * 8,
+  power_valid: 1,
+  power_metric_schema_version: 2,
+  avg_power_w: watts,
+  // Eight validated GPUs on one host: the chassis model recovers the count
+  // from total ÷ per-GPU watts, so the utility modeled boundary is supported.
+  avg_total_gpu_power_w: watts * 8,
+  joules_per_output_token: joulesPerOutput,
+});
+
+let basisId = 970000;
+const basisRows = (runUrl: string | null, hardware: 'b200' | 'h200') =>
+  BASIS_CONFIGS.map(([conc, intvty, outputTput, watts, joules]) => ({
+    id: runUrl ? 0 : basisId++,
+    hardware,
+    framework: 'sglang',
+    model: BASIS_MODEL,
+    precision: 'fp4',
+    spec_method: 'none',
+    disagg: false,
+    is_multinode: false,
+    prefill_tp: 8,
+    decode_tp: 8,
+    num_prefill_gpu: 8,
+    num_decode_gpu: 8,
+    isl: 8192,
+    osl: 1024,
+    conc,
+    offload_mode: 'off',
+    benchmark_type: 'single_turn',
+    image: 'sglang:test',
+    metrics: basisMetrics(intvty, outputTput, watts, joules),
+    workers: null,
+    date: BASIS_DATE,
+    run_url: runUrl,
+  }));
+
+const basisAvailability = [
+  {
+    model: BASIS_MODEL,
+    isl: 8192,
+    osl: 1024,
+    precision: 'fp4',
+    hardware: 'b200',
+    framework: 'sglang',
+    spec_method: 'none',
+    disagg: false,
+    benchmark_type: 'single_turn',
+    date: BASIS_DATE,
+  },
+];
+
+function interceptBasisRows() {
+  cy.intercept('GET', '/api/v1/availability', { body: basisAvailability }).as('availability');
+  cy.intercept('GET', '/api/v1/benchmarks*', { body: basisRows(null, 'b200') }).as('benchmarks');
+  cy.intercept('GET', '/api/v1/workflow-info*', {
+    body: { runs: [], changelogs: [], configs: [] },
+  });
+}
+
+function interceptOverlayRows() {
+  cy.intercept('GET', '/api/unofficial-run*', {
+    body: {
+      runInfos: [
+        {
+          id: BASIS_OVERLAY_RUN_ID,
+          name: 'powerx-basis',
+          branch: 'powerx-basis',
+          sha: 'abc000',
+          createdAt: `${BASIS_DATE}T00:00:00Z`,
+          url: BASIS_OVERLAY_RUN_URL,
+          conclusion: 'success',
+          status: 'completed',
+          isNonMainBranch: true,
+        },
+      ],
+      benchmarks: basisRows(BASIS_OVERLAY_RUN_URL, 'h200'),
+      evaluations: [],
+    },
+  }).as('unofficialRun');
+}
+
+function visitBasisChart({
+  path = '/inference',
+  extraParams = '',
+  gateUnlocked,
+}: {
+  path?: string;
+  extraParams?: string;
+  gateUnlocked: boolean;
+}) {
+  interceptBasisRows();
+  cy.visit(`${path}?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4${extraParams}`, {
+    onBeforeLoad(win) {
+      win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
+      if (gateUnlocked) win.localStorage.setItem('inferencex-feature-gate', '1');
+      else win.localStorage.removeItem('inferencex-feature-gate');
+    },
+  });
+  cy.wait(['@availability', '@benchmarks']);
+  cy.get('[data-testid="inference-chart-display"]').should('exist');
+  cy.get('[data-testid="chart-figure"]').should('have.length.at.least', 1);
+}
+
+/** Plotted y values (sorted) of every point matching `selector`, visible or not. */
+function assertPlottedValues(selector: string, expected: number[]) {
+  cy.get<SVGElement & { __data__: { y: number } }>(
+    `[data-testid="inference-chart-display"] svg ${selector}`,
+  ).should(($points) => {
+    const values = Array.from($points, (point) => point.__data__.y).sort((a, b) => a - b);
+    expect(values).to.have.length(expected.length);
+    for (const [index, value] of values.entries()) {
+      expect(value).to.be.closeTo(expected[index], 1e-6);
+    }
+  });
+}
+
+const sortedAsc = (values: number[]) => [...values].sort((a, b) => a - b);
+
+describe('PowerX power boundaries in the Measured Energy group', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message === 'ResizeObserver loop completed with undelivered notifications.') {
+        return false;
+      }
+    });
+  });
+
+  it('switches the boundary from the Measured controls and carries it in i_metric', () => {
+    visitBasisChart({ gateUnlocked: true, extraParams: '&i_metric=y_measuredJPerOutputToken' });
+    cy.get('[data-testid="measured-metric-controls"]').should('be.visible');
+    cy.get('[data-testid="measured-energy-basis"]')
+      .should('be.visible')
+      .and('contain.text', 'GPU measured');
+    cy.get('[data-testid="power-basis-assumptions"]').should('not.exist');
+
+    cy.get('[data-testid="measured-energy-basis"]').click();
+    cy.get('[data-slot="select-item"][data-value="utility-provisioned"]')
+      .should('contain.text', 'Utility provisioned (all-in)')
+      .click();
+
+    assertShareLinkMetric('y_utilityProvisionedJPerOutputToken');
+    cy.get('[data-testid="chart-figure"] h2').should(
+      'contain.text',
+      'Utility Provisioned Joules per Output Token, all GPUs (all-in)',
+    );
+    // Aggregate rows: all-in W ÷ output tok/s per GPU (N_alloc cancels).
+    assertPlottedValues(
+      '.dot-group',
+      sortedAsc(BASIS_CONFIGS.map((config) => B200_ALL_IN_WATTS / config[2])),
+    );
+    cy.get('[data-testid="power-basis-assumptions"]')
+      .should('have.attr', 'data-power-basis', 'utility-provisioned')
+      .and('contain.text', 'all-in provisioned utility power per GPU')
+      .and('contain.text', 'prefill and decode GPUs together');
+    cy.get('[data-testid="power-metric-availability"]').should(
+      'contain.text',
+      '3 of 3 points have this metric',
+    );
+    // The collapsed Y-axis option carries the boundary metric's own
+    // explanation, so its help popover must resolve for a boundary key.
+    cy.get('[data-testid="selected-option-help-y_utilityProvisionedJPerOutputToken"]').trigger(
+      'pointerover',
+      { pointerType: 'mouse' },
+    );
+    cy.get('[data-testid="selected-option-help-content-y_utilityProvisionedJPerOutputToken"]')
+      .should('be.visible')
+      .and('contain.text', 'J/tok')
+      .and('contain.text', 'allocated GPUs');
+    cy.get('[data-testid="selected-option-help-y_utilityProvisionedJPerOutputToken"]').trigger(
+      'pointerout',
+      { pointerType: 'mouse' },
+    );
+    // The other energy settings stay usable and return to GPU measured.
+    cy.get('[data-testid="measured-energy-denominator"]').click();
+    cy.get('[data-slot="select-item"][data-value="query"]').click();
+    assertShareLinkMetric('y_measuredJPerSuccessfulQuery');
+    cy.get('[data-testid="measured-energy-basis"]').should('contain.text', 'GPU measured');
+  });
+
+  it('renders a shared utility-modeled link while the gate is locked and hides the group otherwise', () => {
+    visitBasisChart({ gateUnlocked: false, extraParams: '&i_metric=y_utilityModeledWatts' });
+    cy.get('[data-testid="chart-figure"] h2').should(
+      'contain.text',
+      'Utility Modeled Power per Chip (PUE)',
+    );
+    // B200 8k/1k with eight validated GPUs is inside the chassis model, so
+    // every row has a modeled utility value above its measured watts.
+    cy.get<SVGElement & { __data__: { y: number } }>(
+      '[data-testid="inference-chart-display"] svg .dot-group',
+    ).should(($points) => {
+      expect($points).to.have.length(BASIS_CONFIGS.length);
+      const measured = sortedAsc(BASIS_CONFIGS.map((config) => config[3]));
+      const plotted = sortedAsc(Array.from($points, (point) => point.__data__.y));
+      for (const [index, value] of plotted.entries()) {
+        // Chassis AC × PUE 1.3 per GPU exceeds the GPU-board watts but stays
+        // below the 1.71 kW all-in provisioning.
+        expect(value).to.be.greaterThan(measured[index]);
+        expect(value).to.be.lessThan(B200_ALL_IN_WATTS);
+      }
+    });
+    cy.get('[data-testid="power-basis-assumptions"]')
+      .should('have.attr', 'data-power-basis', 'utility-modeled')
+      .and('contain.text', 'PUE 1.3')
+      .and('contain.text', 'revision');
+    // Watt boundaries draw the upper power envelope like measured watts, so
+    // Optimal Only (default on) keeps every load point instead of a Pareto corner.
+    cy.get('[data-testid="power-curve-description"]').should('exist');
+    cy.get('[data-testid="inference-chart-display"] svg .roofline-path')
+      .should('have.length.at.least', 1)
+      .and('have.attr', 'data-curve-kind', 'power-envelope');
+    cy.get<SVGElement>('[data-testid="inference-chart-display"] svg .dot-group').should(
+      ($points) => {
+        const shown = [...$points].filter((point) => getComputedStyle(point).opacity === '1');
+        expect(shown).to.have.length(BASIS_CONFIGS.length);
+      },
+    );
+    // Like its Measured siblings, the selected gated metric keeps its own
+    // controls reachable from a shared link.
+    cy.get('[data-testid="measured-power-basis"]').should('contain.text', 'Utility modeled (PUE)');
+    cy.get('[data-testid="measured-basis-hint"]').should('be.visible');
+
+    // Without the shared metric the locked gate hides the whole group.
+    visitBasisChart({ gateUnlocked: false });
+    cy.get('[data-testid="measured-metric-controls"]').should('not.exist');
+    cy.get('[data-testid="yaxis-metric-selector"]').click('right');
+    cy.get('[data-slot="select-content"]').should('exist');
+    cy.get('[data-slot="select-item"]').should('not.contain.text', 'Measured Power');
+    cy.get('[data-slot="select-item"]').should('not.contain.text', 'Measured Energy');
+  });
+
+  it('shows the boundary column in the Table view', () => {
+    visitBasisChart({ gateUnlocked: true, extraParams: '&i_metric=y_gpuProvisionedWatts' });
+    cy.get('[data-testid="inference-table-view-btn"]').click();
+    cy.get('[data-testid="inference-chart-display"] table').within(() => {
+      cy.contains('th', 'GPU Provisioned Power per Chip (TDP, W)').should('be.visible');
+      // formatInferenceTableNumber renders the 1000 W spec constant as "1,000".
+      cy.contains('td', B200_TDP_WATTS.toLocaleString('en-US')).should('exist');
+    });
+  });
+
+  it('translates the boundary control and metric on /zh/inference', () => {
+    visitBasisChart({
+      path: '/zh/inference',
+      gateUnlocked: true,
+      extraParams: '&i_metric=y_gpuProvisionedJPerOutputToken',
+    });
+    cy.get('[data-testid="chart-figure"] h2').should(
+      'contain.text',
+      '每输出 token GPU 额定焦耳能耗（TDP）',
+    );
+    cy.get('[data-testid="measured-metric-controls"]').should('contain.text', '功耗边界');
+    cy.get('[data-testid="measured-energy-basis"]').should('contain.text', 'GPU 额定（TDP）');
+    cy.get('[data-testid="measured-basis-hint"]').should('contain.text', '返回 GPU 实测');
+    cy.get('[data-testid="power-basis-assumptions"]').should('contain.text', 'GPU 额定边界');
+    cy.get('[data-testid="power-metric-availability"]').should(
+      'contain.text',
+      '3 个数据点中有 3 个提供此指标',
+    );
+    assertPlottedValues(
+      '.dot-group',
+      sortedAsc(BASIS_CONFIGS.map((config) => B200_TDP_WATTS / config[2])),
+    );
+  });
+
+  it('plots the boundary for ?unofficialrun= overlay rows with the overlay hardware specs', () => {
+    interceptOverlayRows();
+    visitBasisChart({
+      gateUnlocked: true,
+      extraParams: `&unofficialrun=${BASIS_OVERLAY_RUN_ID}&i_metric=y_utilityProvisionedJPerOutputToken`,
+    });
+    cy.wait('@unofficialRun');
+    cy.get('[data-testid="chart-figure"] h2').should(
+      'contain.text',
+      'Utility Provisioned Joules per Output Token, all GPUs (all-in)',
+    );
+    assertPlottedValues(
+      '.dot-group',
+      sortedAsc(BASIS_CONFIGS.map((config) => B200_ALL_IN_WATTS / config[2])),
+    );
+    // Overlay H200 rows derive from their own registry specs, not the official B200's.
+    assertPlottedValues(
+      '.unofficial-overlay-pt',
+      sortedAsc(BASIS_CONFIGS.map((config) => H200_ALL_IN_WATTS / config[2])),
+    );
+    // Official (3) + visible overlay (3) rows feed the availability count.
+    cy.get('[data-testid="power-metric-availability"]').should(
+      'contain.text',
+      '6 of 6 points have this metric',
+    );
+    // The modeled boundary rides the same overlay path: validated H200 8k/1k
+    // telemetry is inside the chassis model too.
+    cy.get('[data-testid="measured-energy-basis"]').click();
+    cy.get('[data-slot="select-item"][data-value="utility-modeled"]').click();
+    assertShareLinkMetric('y_utilityModeledJPerOutputToken');
+    cy.get('[data-testid="inference-chart-display"] svg .unofficial-overlay-pt').should(
+      'have.length',
+      BASIS_CONFIGS.length,
+    );
+    cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
+      'have.length',
+      BASIS_CONFIGS.length,
+    );
+  });
+});
diff --git a/packages/app/cypress/e2e/powerx-compare.cy.ts b/packages/app/cypress/e2e/powerx-compare.cy.ts
new file mode 100644
index 000000000..af2594200
--- /dev/null
+++ b/packages/app/cypress/e2e/powerx-compare.cy.ts
@@ -0,0 +1,301 @@
+import { assertShareLinkParams } from '../support/share-link';
+
+// Power comparison series (`i_pcompare`) inside the gated Measured Energy
+// group: `boundaries` overlays every power boundary, `roles` the prefill and
+// decode pools, on the same points as the selected metric. Deterministic
+// disaggregated rows carry validated whole-deployment and per-role telemetry,
+// so every sibling series has a value; the overlay run adds H200 rows.
+
+const MODEL = 'dsv4';
+const DATE = '2026-09-01';
+const OVERLAY_RUN_ID = '31415926535';
+const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
+
+/**
+ * conc, interactivity (tok/s/user), output tok/s per GPU, measured W per GPU,
+ * prefill W per GPU, decode W per GPU, J per output token, decode J per output token.
+ * Input tokens outnumber output tokens 8:1, so J/in = J/out ÷ 8 and the prefill
+ * pool's J/in reconstructs to J/out − decode J/out on the output-token axis.
+ */
+const CONFIGS: [number, number, number, number, number, number, number, number][] = [
+  [16, 90, 200, 500, 800, 400, 2.4, 1.6],
+  [64, 60, 400, 600, 820, 450, 1.6, 1],
+  [256, 30, 800, 700, 840, 500, 1, 0.6],
+];
+const TOKEN_RATIO = 8;
+
+// HW_REGISTRY: b200 tdp 1000 W / all-in 1.71 kW; h200 tdp 700 W / all-in 1.37 kW.
+const B200_TDP_WATTS = 1000;
+const B200_ALL_IN_WATTS = 1710;
+
+let rowId = 990000;
+const rows = (runUrl: string | null, hardware: 'b200' | 'h200') =>
+  CONFIGS.map(([conc, intvty, outputTput, watts, prefillWatts, decodeWatts, jOut, decodeJOut]) => ({
+    id: runUrl ? 0 : rowId++,
+    hardware,
+    framework: 'dynamo-sglang',
+    model: MODEL,
+    precision: 'fp4',
+    spec_method: 'none',
+    disagg: true,
+    is_multinode: true,
+    prefill_tp: 4,
+    decode_tp: 4,
+    num_prefill_gpu: 4,
+    num_decode_gpu: 4,
+    isl: 8192,
+    osl: 1024,
+    conc,
+    offload_mode: 'off',
+    benchmark_type: 'single_turn',
+    image: 'dynamo:test',
+    metrics: {
+      median_intvty: intvty,
+      median_itl: 1 / intvty,
+      median_e2el: 20,
+      median_ttft: 0.5,
+      tput_per_gpu: outputTput * 9,
+      output_tput_per_gpu: outputTput,
+      input_tput_per_gpu: outputTput * 8,
+      power_valid: 1,
+      power_metric_schema_version: 2,
+      avg_power_w: watts,
+      avg_total_gpu_power_w: watts * 8,
+      prefill_avg_power_w: prefillWatts,
+      decode_avg_power_w: decodeWatts,
+      joules_per_output_token: jOut,
+      joules_per_input_token: jOut / TOKEN_RATIO,
+      prefill_joules_per_input_token: (jOut - decodeJOut) / TOKEN_RATIO,
+      decode_joules_per_output_token: decodeJOut,
+    },
+    workers: null,
+    date: DATE,
+    run_url: runUrl,
+  }));
+
+const availability = [
+  {
+    model: MODEL,
+    isl: 8192,
+    osl: 1024,
+    precision: 'fp4',
+    hardware: 'b200',
+    framework: 'dynamo-sglang',
+    spec_method: 'none',
+    disagg: true,
+    benchmark_type: 'single_turn',
+    date: DATE,
+  },
+];
+
+function interceptRows() {
+  cy.intercept('GET', '/api/v1/availability', { body: availability }).as('availability');
+  cy.intercept('GET', '/api/v1/benchmarks*', { body: rows(null, 'b200') }).as('benchmarks');
+  cy.intercept('GET', '/api/v1/workflow-info*', {
+    body: { runs: [], changelogs: [], configs: [] },
+  });
+}
+
+function interceptOverlayRows() {
+  cy.intercept('GET', '/api/unofficial-run*', {
+    body: {
+      runInfos: [
+        {
+          id: OVERLAY_RUN_ID,
+          name: 'powerx-compare',
+          branch: 'powerx-compare',
+          sha: 'abc000',
+          createdAt: `${DATE}T00:00:00Z`,
+          url: OVERLAY_RUN_URL,
+          conclusion: 'success',
+          status: 'completed',
+          isNonMainBranch: true,
+        },
+      ],
+      benchmarks: rows(OVERLAY_RUN_URL, 'h200'),
+      evaluations: [],
+    },
+  }).as('unofficialRun');
+}
+
+function visitChart({
+  path = '/inference',
+  extraParams = '',
+}: {
+  path?: string;
+  extraParams?: string;
+}) {
+  interceptRows();
+  cy.visit(`${path}?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4${extraParams}`, {
+    onBeforeLoad(win) {
+      win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
+      win.localStorage.setItem('inferencex-feature-gate', '1');
+    },
+  });
+  cy.wait(['@availability', '@benchmarks']);
+  cy.get('[data-testid="inference-chart-display"]').should('exist');
+  cy.get('[data-testid="chart-figure"]').should('have.length.at.least', 1);
+}
+
+const sortedAsc = (values: number[]) => [...values].sort((a, b) => a - b);
+
+/** Plotted y values (sorted) of every point matching `selector`, visible or not. */
+function assertPlottedValues(selector: string, expected: number[]) {
+  cy.get<SVGElement & { __data__: { y: number } }>(
+    `[data-testid="inference-chart-display"] svg ${selector}`,
+  ).should(($points) => {
+    const values = sortedAsc(Array.from($points, (point) => point.__data__.y));
+    expect(values).to.have.length(expected.length);
+    for (const [index, value] of values.entries()) {
+      expect(value).to.be.closeTo(expected[index], 1e-6);
+    }
+  });
+}
+
+function chooseCompare(mode: 'none' | 'boundaries' | 'roles') {
+  cy.get('[data-testid="measured-power-compare"]').click();
+  cy.get(`[data-slot="select-item"][data-value="${mode}"]`).click();
+}
+
+describe('PowerX comparison series (i_pcompare)', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message === 'ResizeObserver loop completed with undelivered notifications.') {
+        return false;
+      }
+    });
+  });
+
+  it('overlays every boundary from a shared link and switches to roles from the Compare control', () => {
+    visitChart({ extraParams: '&i_metric=y_measuredAvgPower&i_pcompare=boundaries' });
+    cy.get('[data-testid="measured-power-compare"]').should('contain.text', 'All boundaries');
+
+    const measured = CONFIGS.map((config) => config[3]);
+    assertPlottedValues('.dot-group[data-power-variant=""]', sortedAsc(measured));
+    assertPlottedValues(
+      '.dot-group[data-power-variant="gpu-provisioned"]',
+      CONFIGS.map(() => B200_TDP_WATTS),
+    );
+    assertPlottedValues(
+      '.dot-group[data-power-variant="utility-provisioned"]',
+      CONFIGS.map(() => B200_ALL_IN_WATTS),
+    );
+    // Siblings share the hardware colour and differ by dash; every series
+    // draws its own power envelope.
+    cy.get('[data-testid="inference-chart-display"] svg .roofline-path:not([data-power-variant])')
+      .should('have.length', 1)
+      .and('have.attr', 'data-hw-key', 'b200_dynamo-sglang');
+    cy.get(
+      '[data-testid="inference-chart-display"] svg .roofline-path[data-power-variant="gpu-provisioned"]',
+    )
+      .should('have.attr', 'stroke-dasharray', '8 4')
+      .and('have.attr', 'data-hw-key', 'b200_dynamo-sglang');
+    cy.get('[data-testid="chart-legend"]')
+      .should('contain.text', 'GPU measured')
+      .and('contain.text', 'GPU provisioned (TDP)')
+      .and('contain.text', 'Utility provisioned (all-in)');
+    assertShareLinkParams({ i_metric: 'y_measuredAvgPower', i_pcompare: 'boundaries' });
+
+    chooseCompare('roles');
+    assertPlottedValues(
+      '.dot-group[data-power-variant="prefill"]',
+      sortedAsc(CONFIGS.map((config) => config[4])),
+    );
+    assertPlottedValues(
+      '.dot-group[data-power-variant="decode"]',
+      sortedAsc(CONFIGS.map((config) => config[5])),
+    );
+    cy.get(
+      '[data-testid="inference-chart-display"] svg .dot-group[data-power-variant^="gpu-"]',
+    ).should('not.exist');
+    assertShareLinkParams({ i_pcompare: 'roles' });
+
+    // The Table names each row's series.
+    cy.get('[data-testid="inference-table-view-btn"]').click();
+    cy.get('[data-testid="inference-chart-display"] table').within(() => {
+      cy.contains('th', 'Series').should('be.visible');
+      cy.contains('td', 'Prefill GPUs').should('exist');
+      cy.contains('td', 'All GPUs').should('exist');
+    });
+    cy.get('[data-testid="inference-chart-view-btn"]').click();
+
+    chooseCompare('none');
+    cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
+      'have.length',
+      CONFIGS.length,
+    );
+    assertShareLinkParams({ i_pcompare: null });
+  });
+
+  it('reconstructs the prefill pool on the output-token energy axis and pauses off it', () => {
+    visitChart({ extraParams: '&i_metric=y_measuredJPerOutputToken&i_pcompare=roles' });
+    assertPlottedValues(
+      '.dot-group[data-power-variant=""]',
+      sortedAsc(CONFIGS.map((config) => config[6])),
+    );
+    // Prefill J/in × (J/out ÷ J/in) = the prefill pool's J per output token.
+    assertPlottedValues(
+      '.dot-group[data-power-variant="prefill"]',
+      sortedAsc(CONFIGS.map((config) => config[6] - config[7])),
+    );
+    assertPlottedValues(
+      '.dot-group[data-power-variant="decode"]',
+      sortedAsc(CONFIGS.map((config) => config[7])),
+    );
+    cy.get('[data-testid="measured-compare-hint"]').should('not.exist');
+
+    // A prefill J per input token axis has no decode counterpart: the
+    // comparison pauses and says so instead of drawing a mismatched series.
+    cy.get('[data-testid="measured-energy-denominator"]').click();
+    cy.get('[data-slot="select-item"][data-value="input"]').click();
+    cy.get('[data-testid="measured-compare-hint"]').should('be.visible');
+    cy.get(
+      '[data-testid="inference-chart-display"] svg .dot-group[data-power-variant="prefill"]',
+    ).should('not.exist');
+    cy.get('[data-testid="measured-power-compare"]').should('contain.text', 'Prefill vs decode');
+    assertShareLinkParams({ i_metric: 'y_measuredJPerInputToken', i_pcompare: 'roles' });
+  });
+
+  it('draws comparison siblings for ?unofficialrun= overlay rows in the run colour', () => {
+    interceptOverlayRows();
+    visitChart({
+      extraParams: `&unofficialrun=${OVERLAY_RUN_ID}&i_metric=y_measuredAvgPower&i_pcompare=boundaries`,
+    });
+    cy.wait('@unofficialRun');
+    // Three overlay rows × (measured + TDP + all-in).
+    cy.get('[data-testid="inference-chart-display"] svg .unofficial-overlay-pt').should(
+      'have.length',
+      CONFIGS.length * 3,
+    );
+    cy.get(
+      '[data-testid="inference-chart-display"] svg .overlay-roofline-path[data-power-variant="gpu-provisioned"]',
+    )
+      .should('have.length', 1)
+      .and('have.attr', 'stroke-dasharray', '8 4')
+      .then(($sibling) => {
+        cy.get(
+          '[data-testid="inference-chart-display"] svg .overlay-roofline-path:not([data-power-variant])',
+        ).should(($base) => {
+          expect($sibling.attr('stroke')).to.eq($base.attr('stroke'));
+        });
+      });
+    // Comparison clones do not inflate the availability count.
+    cy.get('[data-testid="power-metric-availability"]').should(
+      'contain.text',
+      '6 of 6 points have this metric',
+    );
+  });
+
+  it('translates the Compare control and legend rows on /zh/inference', () => {
+    visitChart({
+      path: '/zh/inference',
+      extraParams: '&i_metric=y_measuredAvgPower&i_pcompare=roles',
+    });
+    cy.get('[data-testid="measured-metric-controls"]').should('contain.text', '对比');
+    cy.get('[data-testid="measured-power-compare"]').should('contain.text', '预填充 vs 解码');
+    cy.get('[data-testid="chart-legend"]')
+      .should('contain.text', '全部 GPU')
+      .and('contain.text', '预填充 GPU')
+      .and('contain.text', '解码 GPU');
+  });
+});
diff --git a/packages/app/cypress/e2e/powerx-timeline.cy.ts b/packages/app/cypress/e2e/powerx-timeline.cy.ts
new file mode 100644
index 000000000..b78ca57cd
--- /dev/null
+++ b/packages/app/cypress/e2e/powerx-timeline.cy.ts
@@ -0,0 +1,336 @@
+import { assertShareLinkMetric } from '../support/share-link';
+
+// The Measured Power "Timeline" display (`y_measuredPowerTimeline`) inside the
+// gated Measured Energy group. Deterministic intercepted rows carry validated
+// telemetry plus the `power_audit.source` / `run_url` provenance that names each
+// point's `gpu_metrics_*` artifact; `/api/gpu-metrics?series=power` is
+// intercepted with matching one-second series.
+
+const MODEL = 'dsv4';
+const DATE = '2026-09-01';
+const RUN_ID = '34716669498';
+const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
+const OVERLAY_RUN_ID = '31415926535';
+const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
+const START_MS = Date.UTC(2026, 8, 1, 20, 0, 0);
+
+/** conc, interactivity (tok/s/user), output tok/s per GPU, measured W per GPU */
+const CONFIGS: [number, number, number, number][] = [
+  [16, 90, 200, 500],
+  [64, 60, 400, 600],
+  [256, 30, 800, 700],
+];
+
+const resultName = (hardware: string, conc: number) =>
+  `dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc${conc}_${hardware}-host-0123456789abcdef0123`;
+
+let rowId = 980000;
+const rows = (runUrl: string, hardware: 'b200' | 'h200') =>
+  CONFIGS.map(([conc, intvty, outputTput, watts]) => ({
+    id: hardware === 'b200' ? rowId++ : 0,
+    hardware,
+    framework: 'sglang',
+    model: MODEL,
+    precision: 'fp4',
+    spec_method: 'none',
+    disagg: false,
+    is_multinode: false,
+    prefill_tp: 8,
+    decode_tp: 8,
+    num_prefill_gpu: 8,
+    num_decode_gpu: 8,
+    isl: 8192,
+    osl: 1024,
+    conc,
+    offload_mode: 'off',
+    benchmark_type: 'single_turn',
+    image: 'sglang:test',
+    metrics: {
+      median_intvty: intvty,
+      median_itl: 1 / intvty,
+      median_e2el: 20,
+      median_ttft: 0.5,
+      tput_per_gpu: outputTput * 9,
+      output_tput_per_gpu: outputTput,
+      input_tput_per_gpu: outputTput * 8,
+      power_valid: 1,
+      power_metric_schema_version: 2,
+      avg_power_w: watts,
+      avg_total_gpu_power_w: watts * 8,
+      joules_per_output_token: watts / outputTput,
+    },
+    workers: null,
+    power_audit: {
+      source: `power_validation_${resultName(hardware, conc)}.json`,
+      sample_count: 160,
+      window_start_unix: (START_MS + 40_000) / 1000,
+      window_end_unix: (START_MS + 60_000) / 1000,
+      observed_gpu_ids: ['0', '1', '2', '3', '4', '5', '6', '7'],
+    },
+    date: DATE,
+    run_url: runUrl,
+  }));
+
+const seriesFor = (hardware: string, runUrl: string, runId: string) => ({
+  runInfo: {
+    id: Number(runId),
+    name: 'Run Sweep',
+    branch: hardware === 'b200' ? 'main' : 'powerx-timeline',
+    sha: 'abc123',
+    createdAt: `${DATE}T20:00:00Z`,
+    url: runUrl,
+    conclusion: 'success',
+    status: 'completed',
+  },
+  series: CONFIGS.map((config) => {
+    const [conc] = config;
+    const watts = config[3];
+    const t = Array.from({ length: 61 }, (_, i) => i);
+    return {
+      artifact: `gpu_metrics_${resultName(hardware, conc)}`,
+      startMs: START_MS,
+      bucketSeconds: 1,
+      gpus: [0, 1],
+      t,
+      power: [0, 1].map((gpu) => t.map((second) => (second >= 40 ? watts + gpu : 150 + gpu))),
+    };
+  }),
+});
+
+const availability = [
+  {
+    model: MODEL,
+    isl: 8192,
+    osl: 1024,
+    precision: 'fp4',
+    hardware: 'b200',
+    framework: 'sglang',
+    spec_method: 'none',
+    disagg: false,
+    benchmark_type: 'single_turn',
+    date: DATE,
+  },
+];
+
+function interceptRows() {
+  cy.intercept('GET', '/api/v1/availability', { body: availability }).as('availability');
+  cy.intercept('GET', '/api/v1/benchmarks*', { body: rows(RUN_URL, 'b200') }).as('benchmarks');
+  cy.intercept('GET', '/api/v1/workflow-info*', {
+    body: { runs: [], changelogs: [], configs: [] },
+  });
+  cy.intercept('GET', `/api/gpu-metrics?runId=${RUN_ID}*`, {
+    body: seriesFor('b200', RUN_URL, RUN_ID),
+  }).as('series');
+}
+
+function interceptOverlay() {
+  cy.intercept('GET', '/api/unofficial-run*', {
+    body: {
+      runInfos: [
+        {
+          id: OVERLAY_RUN_ID,
+          name: 'powerx-timeline',
+          branch: 'powerx-timeline',
+          sha: 'abc000',
+          createdAt: `${DATE}T00:00:00Z`,
+          url: OVERLAY_RUN_URL,
+          conclusion: 'success',
+          status: 'completed',
+          isNonMainBranch: true,
+        },
+      ],
+      benchmarks: rows(OVERLAY_RUN_URL, 'h200'),
+      evaluations: [],
+    },
+  }).as('unofficialRun');
+  cy.intercept('GET', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+    body: seriesFor('h200', OVERLAY_RUN_URL, OVERLAY_RUN_ID),
+  }).as('overlaySeries');
+}
+
+function visitChart({
+  path = '/inference',
+  extraParams = '',
+}: {
+  path?: string;
+  extraParams?: string;
+}) {
+  interceptRows();
+  cy.visit(`${path}?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4${extraParams}`, {
+    onBeforeLoad(win) {
+      win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
+      win.localStorage.setItem('inferencex-feature-gate', '1');
+    },
+  });
+  cy.wait(['@availability', '@benchmarks']);
+  cy.get('[data-testid="inference-chart-display"]').should('exist');
+}
+
+describe('PowerX measured power timeline', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message === 'ResizeObserver loop completed with undelivered notifications.') {
+        return false;
+      }
+    });
+  });
+
+  it('switches the Display control to Timeline and renders the per-second traces', () => {
+    visitChart({ extraParams: '&i_metric=y_measuredAvgPower' });
+    cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
+      'have.length',
+      CONFIGS.length,
+    );
+
+    cy.get('[data-testid="measured-power-display"]').click();
+    cy.get('[data-slot="select-item"][data-value="timeline"]')
+      .should('contain.text', 'Timeline')
+      .click();
+
+    assertShareLinkMetric('y_measuredPowerTimeline');
+    cy.get('[data-testid="chart-figure"] h2').should(
+      'contain.text',
+      'Measured Average Power per Chip over Time',
+    );
+    cy.wait('@series').then(({ request }) => {
+      const url = new URL(request.url);
+      expect(url.searchParams.get('series')).to.eq('power');
+      expect(url.searchParams.get('prefix')).to.eq(
+        'dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc',
+      );
+    });
+    cy.get('[data-testid="power-timeline-chart-svg"]').within(() => {
+      cy.get('path.power-trace[data-segment="full"]').should('have.length', CONFIGS.length);
+      cy.get('path.power-trace[data-segment="window"]').should('have.length', CONFIGS.length);
+      cy.get('.power-reference[data-reference="tdp"][data-watts="1000"]').should('exist');
+      cy.get('text.power-trace-label').should('have.length', CONFIGS.length);
+    });
+    cy.get('[data-testid="power-timeline-source"] a').should('have.attr', 'href', RUN_URL);
+    cy.get('[data-testid="power-metric-availability"]').should(
+      'contain.text',
+      '3 of 3 points have this metric',
+    );
+
+    // Back to watts returns the scatter body on the same points.
+    cy.get('[data-testid="measured-power-display"]').click();
+    cy.get('[data-slot="select-item"][data-value="watts"]').click();
+    assertShareLinkMetric('y_measuredAvgPower');
+    cy.get('[data-testid="power-timeline"]').should('not.exist');
+    cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
+      'have.length',
+      CONFIGS.length,
+    );
+  });
+
+  it('opens the timeline from a shared link and keeps the Table view on the measured average', () => {
+    visitChart({ extraParams: '&i_metric=y_measuredPowerTimeline' });
+    cy.wait('@series');
+    cy.get('[data-testid="measured-power-display"]').should('contain.text', 'Timeline');
+    cy.get('[data-testid="power-timeline-chart-svg"] path.power-trace').should(
+      'have.length.at.least',
+      CONFIGS.length,
+    );
+    cy.get('[data-testid="inference-table-view-btn"]').click();
+    cy.get('[data-testid="inference-chart-display"] table').within(() => {
+      cy.contains('th', 'Measured Average Power per Chip over Time (W)').should('be.visible');
+      cy.contains('td', '700').should('exist');
+    });
+  });
+
+  it('draws ?unofficialrun= overlay traces in the run colour', () => {
+    interceptOverlay();
+    visitChart({
+      extraParams: `&unofficialrun=${OVERLAY_RUN_ID}&i_metric=y_measuredPowerTimeline`,
+    });
+    cy.wait(['@unofficialRun', '@series', '@overlaySeries']);
+    cy.get('[data-testid="power-timeline-chart-svg"]').within(() => {
+      cy.get('path.power-trace[data-run-index="0"][data-segment="window"]').should(
+        'have.length',
+        CONFIGS.length,
+      );
+      // Official hardware keys carry the framework suffix (`b200_sglang`).
+      cy.get('path.power-trace[data-hw^="b200"][data-segment="window"]').should(
+        'have.length',
+        CONFIGS.length,
+      );
+      // B200 and H200 references.
+      cy.get('.power-reference[data-reference="tdp"]').should('have.length', 2);
+    });
+    cy.get('[data-testid="chart-legend"]').should('contain.text', '✕ powerx-timeline');
+  });
+
+  it('translates the display option and chart on /zh/inference', () => {
+    visitChart({ path: '/zh/inference', extraParams: '&i_metric=y_measuredPowerTimeline' });
+    cy.wait('@series');
+    cy.get('[data-testid="chart-figure"] h2').should('contain.text', '每芯片实测平均功耗时间线');
+    cy.get('[data-testid="measured-power-display"]').should('contain.text', '时间线');
+    cy.get('[data-testid="power-timeline-toolbar"]').should('contain.text', '时间轴');
+  });
+
+  // ── "View power trace" on pinned scatter tooltips ─────────────────────────
+
+  const POWER_TRACE_ACTION = '[data-chart-tooltip]:visible [data-action="view-power-trace"]';
+
+  /** Pin the tooltip of the marker plotted for `conc` (official `.dot-group` or overlay X). */
+  function pinPointTooltip(selector: string, conc: number): void {
+    cy.get(`[data-testid="inference-chart-display"] svg ${selector}`)
+      .should('have.length', CONFIGS.length)
+      .then(($points) => {
+        const target = [...$points].find(
+          (node) => (node as unknown as { __data__?: { conc?: number } }).__data__?.conc === conc,
+        );
+        expect(target, `a ${selector} marker at concurrency ${conc}`).to.not.equal(undefined);
+        cy.wrap(target).find('.visible-shape').click({ force: true });
+      });
+  }
+
+  it('jumps from a pinned point to the timeline focused on that config', () => {
+    visitChart({ extraParams: '&i_metric=y_measuredAvgPower' });
+    // Only a pinned tooltip offers the action (the hover gate is unit-tested).
+    pinPointTooltip('.dot-group', 64);
+    cy.get(POWER_TRACE_ACTION)
+      .should('be.visible')
+      .should('contain.text', 'View power trace')
+      .invoke('attr', 'href')
+      .should('contain', 'i_metric=y_measuredPowerTimeline');
+    cy.get(POWER_TRACE_ACTION).click();
+
+    // Same-tab click switches the metric in place instead of navigating.
+    cy.location('pathname').should('eq', '/inference');
+    cy.get('[data-testid="power-timeline"]').should('exist');
+    cy.wait('@series');
+    cy.get(
+      '[data-testid="power-timeline-chart-svg"] path.power-trace[data-segment="window"]',
+    ).should('have.length', CONFIGS.length);
+    assertShareLinkMetric('y_measuredPowerTimeline');
+    cy.get('[data-testid="power-timeline-focus"]').should('contain.text', 'c64');
+  });
+
+  it('offers the action on pinned ?unofficialrun= overlay tooltips and opens the overlay trace', () => {
+    interceptOverlay();
+    visitChart({
+      extraParams: `&unofficialrun=${OVERLAY_RUN_ID}&i_metric=y_measuredAvgPower`,
+    });
+    cy.wait('@unofficialRun');
+    pinPointTooltip('.unofficial-overlay-pt', 64);
+    cy.get(POWER_TRACE_ACTION).should('be.visible').should('contain.text', 'View power trace');
+    cy.get(POWER_TRACE_ACTION).click();
+
+    cy.get('[data-testid="power-timeline"]').should('exist');
+    cy.wait(['@series', '@overlaySeries']);
+    cy.get('[data-testid="power-timeline-chart-svg"]').within(() => {
+      cy.get('path.power-trace[data-run-index="0"][data-segment="window"]').should(
+        'have.length',
+        CONFIGS.length,
+      );
+    });
+    assertShareLinkMetric('y_measuredPowerTimeline');
+    cy.get('[data-testid="power-timeline-focus"]').should('contain.text', 'c64');
+  });
+
+  it('translates the tooltip action on /zh/inference', () => {
+    visitChart({ path: '/zh/inference', extraParams: '&i_metric=y_measuredAvgPower' });
+    pinPointTooltip('.dot-group', 64);
+    cy.get(POWER_TRACE_ACTION).should('be.visible').should('contain.text', '查看功耗曲线');
+  });
+});
diff --git a/packages/app/cypress/e2e/profit-estimator.cy.ts b/packages/app/cypress/e2e/profit-estimator.cy.ts
index bf50c1206..a48532ecd 100644
--- a/packages/app/cypress/e2e/profit-estimator.cy.ts
+++ b/packages/app/cypress/e2e/profit-estimator.cy.ts
@@ -623,7 +623,7 @@ describe('Profit Estimator per GW — compare history', () => {
     bars()
       .its('length')
       .then((allBars) => {
-        chipTrigger().should('contain.text', 'Select a Chip Config for comparison');
+        chipTrigger().should('contain.text', 'Select Chip Config');
         chipTrigger().click({ force: true });
         // Every agentic SKU at the effective precisions. The lone fp8 curve
         // (H200) keeps both precisions in play (the sparse-precision rule), so
@@ -643,7 +643,7 @@ describe('Profit Estimator per GW — compare history', () => {
         cy.get('[role="option"]').contains('GB300').click();
         cy.get('body').type('{esc}');
         cy.get('[data-testid="profit-history-date-range"]').should('not.exist');
-        chipTrigger().should('contain.text', 'Select a Chip Config for comparison');
+        chipTrigger().should('contain.text', 'Select Chip Config');
       });
   });
 
@@ -695,7 +695,7 @@ describe('Profit Estimator per GW — compare history', () => {
     cy.get('[data-testid="profit-history-date-range"]').should('not.exist');
     cy.get('[data-testid="profit-history-note"]').should('not.exist');
     chart().find('rect.bar-tco').should('have.length', 4);
-    chipTrigger().should('contain.text', 'Select a Chip Config for comparison');
+    chipTrigger().should('contain.text', 'Select Chip Config');
     changelog().should('not.exist');
   });
 
@@ -804,7 +804,7 @@ describe('Profit Estimator per GW — compare history', () => {
     cy.visit('/zh/profit-estimator-per-gigawatt', { onBeforeLoad: suppressNudges });
     waitForChart();
     historyPanel().should('contain.text', '对比历史趋势').and('contain.text', '芯片配置');
-    chipTrigger().should('contain.text', '选择芯片配置进行对比');
+    chipTrigger().should('contain.text', '选择芯片配置');
     pickChip('GB300');
     changelog().should('contain.text', '配置变更日志').and('contain.text', '添加到图表');
   });
diff --git a/packages/app/cypress/e2e/url-params.cy.ts b/packages/app/cypress/e2e/url-params.cy.ts
index 93f7ebda2..428b9833e 100644
--- a/packages/app/cypress/e2e/url-params.cy.ts
+++ b/packages/app/cypress/e2e/url-params.cy.ts
@@ -137,6 +137,130 @@ describe('URL Parameter Persistence', () => {
     });
   });
 
+  describe('Perf ruler share state', () => {
+    const chart = '#chart-0 svg';
+
+    // The second click completes a ruler only when the two curves share an
+    // x range; real fixture curves do not all overlap, so walk the hit
+    // strokes until one pairs with the first.
+    const completeRuler = (index: number) => {
+      cy.get(`${chart} .perf-ruler-hit`)
+        .its('length')
+        .then((count) => {
+          expect(index, 'a curve overlapping the first one').to.be.lessThan(count);
+          cy.get(`${chart} .perf-ruler-hit`).eq(index).click({ force: true });
+          cy.get(chart).then(($svg) => {
+            if ($svg.find('.perf-ruler').length === 0) completeRuler(index + 1);
+          });
+        });
+    };
+
+    it('round-trips a placed ruler through the share link and restores it on load', () => {
+      visitWithDismissedModal('/inference?g_model=DeepSeek-R1-0528&i_best=0');
+      cy.get(`${chart} .roofline-path`).should('have.length.greaterThan', 1);
+      expandLegendAdvanced();
+      cy.get('#scatter-perf-ruler').should('have.attr', 'aria-checked', 'false');
+      cy.get('#scatter-perf-ruler').click({ force: true });
+      cy.get(`${chart} .perf-ruler-hit`).should('have.length.greaterThan', 1);
+      cy.get(`${chart} .perf-ruler-hit`).eq(0).click({ force: true });
+      completeRuler(1);
+      cy.get(`${chart} .perf-ruler`).should('have.length', 1);
+
+      cy.get(`${chart} .perf-ruler .pr-text-ratio`)
+        .invoke('text')
+        .then((ratio) => {
+          expect(ratio).to.match(/^\d+\.\d{2}x$/u);
+          // The address bar stays clean after load, so the share link is
+          // where the placed ruler must show up.
+          cy.get('[data-testid="share-button"]').first().click();
+          cy.get('[data-testid="share-url-input"]')
+            .invoke('val')
+            .then((value) => {
+              const shareUrl = new URL(String(value));
+              const rulers = shareUrl.searchParams.get('i_rulers');
+              expect(rulers, 'i_rulers in the share link').to.match(
+                /^[\d.e+-]+\|roofline-[\w%.-]+\|roofline-[\w%.-]+$/u,
+              );
+
+              // Opening the link reproduces the ruler without a click and
+              // switches the tool on so it is visible.
+              visitWithDismissedModal(`${shareUrl.pathname}${shareUrl.search}`);
+              cy.get(`${chart} .perf-ruler`).should('have.length', 1);
+              // The link stores the iso-x to four significant digits, so the
+              // restored ratio may differ from the placed one in the last
+              // displayed decimal.
+              cy.get(`${chart} .perf-ruler .pr-text-ratio`)
+                .invoke('text')
+                .then((restoredRatio) => {
+                  expect(Number.parseFloat(restoredRatio)).to.be.closeTo(
+                    Number.parseFloat(ratio),
+                    0.011,
+                  );
+                });
+              expandLegendAdvanced();
+              cy.get('#scatter-perf-ruler').should('have.attr', 'aria-checked', 'true');
+              cy.get('[data-testid="share-button"]').first().click();
+              cy.get('[data-testid="share-url-input"]')
+                .invoke('val')
+                .then((restoredValue) => {
+                  expect(new URL(String(restoredValue)).searchParams.get('i_rulers')).to.equal(
+                    rulers,
+                  );
+                });
+              cy.get('body').type('{esc}');
+
+              // Clearing the rulers drops the param from the next share link.
+              cy.get('[data-testid="scatter-clear-perf-rulers"]').click();
+              cy.get(`${chart} .perf-ruler`).should('not.exist');
+              cy.get('[data-testid="share-button"]').first().click();
+              cy.get('[data-testid="share-url-input"]')
+                .invoke('val')
+                .should('not.include', 'i_rulers');
+            });
+        });
+    });
+
+    it('clears a restored ruler when the x-axis mode changes the rendered chart', () => {
+      // Build the link through the UI so it references curves the fixture
+      // really renders, then reopen it and swap the x axis: chart-0 now
+      // draws the e2e graph in seconds, so the ruler placed in tok/s/user
+      // must go, on screen and in the next share link.
+      visitWithDismissedModal('/inference?g_model=DeepSeek-R1-0528&i_best=0');
+      cy.get(`${chart} .roofline-path`).should('have.length.greaterThan', 1);
+      expandLegendAdvanced();
+      cy.get('#scatter-perf-ruler').click({ force: true });
+      cy.get(`${chart} .perf-ruler-hit`).should('have.length.greaterThan', 1);
+      cy.get(`${chart} .perf-ruler-hit`).eq(0).click({ force: true });
+      completeRuler(1);
+      cy.get(`${chart} .perf-ruler`).should('have.length', 1);
+      cy.get('[data-testid="share-button"]').first().click();
+      cy.get('[data-testid="share-url-input"]')
+        .invoke('val')
+        .then((value) => {
+          const shareUrl = new URL(String(value));
+          expect(shareUrl.searchParams.get('i_rulers')).to.include('|roofline-');
+          visitWithDismissedModal(`${shareUrl.pathname}${shareUrl.search}`);
+          cy.get(`${chart} .perf-ruler`).should('have.length', 1);
+
+          selectXAxisMode('e2e');
+          cy.get(`${chart} .perf-ruler`).should('not.exist');
+          cy.get('[data-testid="share-button"]').first().click();
+          cy.get('[data-testid="share-url-input"]')
+            .invoke('val')
+            .should('include', 'i_xmode=e2e')
+            .and('not.include', 'i_rulers');
+        });
+    });
+
+    it('ignores a malformed i_rulers value and leaves the tool off', () => {
+      visitWithDismissedModal('/inference?g_model=DeepSeek-R1-0528&i_rulers=not-a-ruler');
+      cy.get(`${chart} .roofline-path`).should('have.length.greaterThan', 1);
+      cy.get(`${chart} .perf-ruler`).should('not.exist');
+      expandLegendAdvanced();
+      cy.get('#scatter-perf-ruler').should('have.attr', 'aria-checked', 'false');
+    });
+  });
+
   describe('Provider remount state', () => {
     it('preserves filters across a standalone dashboard route', () => {
       visitWithDismissedModal('/inference');
diff --git a/packages/app/cypress/e2e/zh-pages.cy.ts b/packages/app/cypress/e2e/zh-pages.cy.ts
index a08bd71bc..91f33b754 100644
--- a/packages/app/cypress/e2e/zh-pages.cy.ts
+++ b/packages/app/cypress/e2e/zh-pages.cy.ts
@@ -42,9 +42,9 @@ describe('Chinese (/zh) pages', () => {
           .and('have.attr', 'href', '/zh/inference/kimi-k3');
         cy.get('[data-testid="compare-agentx-methodology-link"]').should('not.exist');
         // Ledger NEW pills localize to 新 on the Chinese landing page.
-        cy.get('[data-testid^="compare-agentx-model-"]').should('have.length', 7);
+        cy.get('[data-testid^="compare-agentx-model-"]').should('have.length', 5);
         cy.get('[data-testid^="compare-agentx-model-"] [data-new-badge="agentx-ledger"]')
-          .should('have.length', 4)
+          .should('have.length', 3)
           .each(($badge) => expect($badge.text()).to.equal('新'));
       });
     });
diff --git a/packages/app/cypress/support/mock-data.ts b/packages/app/cypress/support/mock-data.ts
index cf9b20614..710d5d758 100644
--- a/packages/app/cypress/support/mock-data.ts
+++ b/packages/app/cypress/support/mock-data.ts
@@ -232,6 +232,8 @@ export function createMockInferenceContextValues(
     setSelectedXAxisMode: namedStub('setSelectedXAxisMode'),
     scaleType: 'auto',
     setScaleType: namedStub('setScaleType'),
+    powerCompare: 'none' as const,
+    setPowerCompare: namedStub('setPowerCompare'),
     quickFilters: { vendors: [], frameworks: [], deployment: [], spec: [], power: [] },
     availableQuickFilters: { vendors: [], frameworks: [], deployment: [], spec: [], power: [] },
     setQuickFilterVendors: namedStub('setQuickFilterVendors'),
diff --git a/packages/app/cypress/support/share-link.ts b/packages/app/cypress/support/share-link.ts
new file mode 100644
index 000000000..0ff42a514
--- /dev/null
+++ b/packages/app/cypress/support/share-link.ts
@@ -0,0 +1,27 @@
+/**
+ * The address bar is stripped clean after load (share-link state lives in the
+ * in-memory store), so the Share popover is where a metric change must land.
+ * Closes the popover again so the controls stay clickable.
+ */
+export function assertShareLinkMetric(metric: string): void {
+  assertShareLinkParams({ i_metric: metric });
+}
+
+/**
+ * Asserts several share-link parameters in one popover round trip. A `null`
+ * expectation means the parameter must be absent (stripped as a default).
+ */
+export function assertShareLinkParams(expected: Record<string, string | null>): void {
+  cy.get('[data-testid="share-button"]').first().click();
+  cy.get('[data-testid="share-url-input"]')
+    .invoke('val')
+    .should((value) => {
+      const params = new URL(String(value)).searchParams;
+      for (const [key, param] of Object.entries(expected)) {
+        expect(params.get(key), `${key} in the share link`).to.eq(param);
+      }
+    });
+  // The link field is read-only, so dismiss the popover from the document.
+  cy.get('body').type('{esc}');
+  cy.get('[data-testid="share-url-input"]').should('not.exist');
+}
diff --git a/packages/app/next.config.ts b/packages/app/next.config.ts
index cd6203071..0ac25747e 100644
--- a/packages/app/next.config.ts
+++ b/packages/app/next.config.ts
@@ -2,6 +2,7 @@ import { withPostHogConfig } from '@posthog/nextjs-config';
 import type { NextConfig } from 'next';
 import { allowedDevOriginsFromEnv } from './src/lib/allowed-dev-origins';
 import { INFERENCE_MODEL_ALIAS_REDIRECTS } from './src/lib/inference-model-redirects';
+import { VIDEO_ALIAS_REDIRECTS } from './src/lib/video-alias-redirects';
 
 const nextConfig: NextConfig = {
   // Allow a second, isolated dev server (e.g. a dump-mode instance on another
@@ -16,6 +17,7 @@ const nextConfig: NextConfig = {
   redirects() {
     return Promise.resolve([
       ...INFERENCE_MODEL_ALIAS_REDIRECTS,
+      ...VIDEO_ALIAS_REDIRECTS,
       {
         source: '/datasets/:path*',
         destination: '/agentx/:path*',
diff --git a/packages/app/src/app/(dashboard)/cache-reuse/page.tsx b/packages/app/src/app/(dashboard)/cache-reuse/page.tsx
new file mode 100644
index 000000000..883dafda2
--- /dev/null
+++ b/packages/app/src/app/(dashboard)/cache-reuse/page.tsx
@@ -0,0 +1,17 @@
+import type { Metadata } from 'next';
+
+import CacheReuseDisplay from '@/components/calculator/CacheReuseDisplay';
+import { resolveCalculatorUrlSeed } from '@/components/calculator/url-seed';
+import { tabMetadata } from '@/lib/tab-meta';
+
+export const metadata: Metadata = tabMetadata('cache-reuse');
+
+interface Props {
+  searchParams: Promise<Record<string, string | string[] | undefined>>;
+}
+
+export default async function CacheReusePage({ searchParams }: Props) {
+  const sp = await searchParams;
+  const seed = resolveCalculatorUrlSeed(sp);
+  return <CacheReuseDisplay urlSeed={seed} />;
+}
diff --git a/packages/app/src/app/(dashboard)/first-token/page.tsx b/packages/app/src/app/(dashboard)/first-token/page.tsx
new file mode 100644
index 000000000..5d303e353
--- /dev/null
+++ b/packages/app/src/app/(dashboard)/first-token/page.tsx
@@ -0,0 +1,17 @@
+import type { Metadata } from 'next';
+
+import FirstTokenLimitsDisplay from '@/components/calculator/FirstTokenLimitsDisplay';
+import { resolveCalculatorUrlSeed } from '@/components/calculator/url-seed';
+import { tabMetadata } from '@/lib/tab-meta';
+
+export const metadata: Metadata = tabMetadata('first-token');
+
+interface Props {
+  searchParams: Promise<Record<string, string | string[] | undefined>>;
+}
+
+export default async function FirstTokenPage({ searchParams }: Props) {
+  const sp = await searchParams;
+  const seed = resolveCalculatorUrlSeed(sp);
+  return <FirstTokenLimitsDisplay urlSeed={seed} />;
+}
diff --git a/packages/app/src/app/api/gpu-metrics/route.test.ts b/packages/app/src/app/api/gpu-metrics/route.test.ts
index 790a0ff64..06dff6412 100644
--- a/packages/app/src/app/api/gpu-metrics/route.test.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.test.ts
@@ -1,22 +1,36 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
 
-const { mockParseCsvData } = vi.hoisted(() => ({
-  mockParseCsvData: vi.fn((csv: string) => {
-    if (csv.trim().length === 0) return [];
-    return [
-      {
-        timestamp: '2026-03-01T00:00:00Z',
-        index: 0,
-        power: 300,
-        temperature: 65,
-        smClock: 1500,
-        memClock: 2000,
-        gpuUtil: 95,
-        memUtil: 80,
-      },
-    ];
-  }),
-}));
+const { mockParseCsvData, zipArchives } = vi.hoisted(() => {
+  interface ZipEntry {
+    entryName: string;
+    data: string;
+  }
+  const csvArchive: ZipEntry[] = [
+    { entryName: 'gpu_metrics_0.csv', data: 'timestamp,index,power\n2026-03-01T00:00:00Z,0,300' },
+  ];
+  return {
+    mockParseCsvData: vi.fn((csv: string) => {
+      if (csv.trim().length === 0) return [];
+      return [
+        {
+          timestamp: '2026-03-01T00:00:00Z',
+          index: 0,
+          power: 300,
+          temperature: 65,
+          smClock: 1500,
+          memClock: 2000,
+          gpuUtil: 95,
+          memUtil: 80,
+        },
+      ];
+    }),
+    /**
+     * Entries the adm-zip mock serves, keyed by the downloaded buffer's text.
+     * An empty download (the default in older tests) is the one-CSV artifact.
+     */
+    zipArchives: { byKey: new Map<string, ZipEntry[]>(), csvArchive },
+  };
+});
 
 vi.mock('@semianalysisai/inferencex-constants', () => ({
   GITHUB_API_BASE: 'https://api.github.com',
@@ -41,16 +55,21 @@ vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
 }));
 
 vi.mock('adm-zip', () => {
-  const csvContent = 'timestamp,index,power\n2026-03-01T00:00:00Z,0,300';
   class MockAdmZip {
+    private readonly key: string;
+    constructor(buffer: Buffer) {
+      this.key = buffer.toString('utf8');
+    }
     getEntries() {
-      return [
-        {
-          entryName: 'gpu_metrics_0.csv',
-          isDirectory: false,
-          getData: () => Buffer.from(csvContent),
-        },
-      ];
+      if (this.key === 'corrupt') {
+        throw new Error('ADM-ZIP: Invalid or unsupported zip format. No END header found');
+      }
+      const entries = zipArchives.byKey.get(this.key) ?? zipArchives.csvArchive;
+      return entries.map((entry) => ({
+        entryName: entry.entryName,
+        isDirectory: false,
+        getData: () => Buffer.from(entry.data),
+      }));
     }
   }
   return { default: MockAdmZip };
@@ -69,6 +88,7 @@ function req(url: string): NextRequest {
 
 beforeEach(() => {
   vi.clearAllMocks();
+  zipArchives.byKey.clear();
   origToken = process.env.GITHUB_TOKEN;
   origReadonlyUrl = process.env.DATABASE_READONLY_URL;
   process.env.GITHUB_TOKEN = 'test-gh-token';
@@ -368,6 +388,119 @@ describe('GET /api/gpu-metrics', () => {
     expect(body.artifacts[0].data).toHaveLength(1);
   });
 
+  it('returns 400 for a malformed prefix or an unknown series shape', async () => {
+    const badPrefix = await GET(req('/api/gpu-metrics?runId=12345&prefix=a%20b'));
+    expect(badPrefix.status).toBe(400);
+    const badPrefixBody = await badPrefix.json();
+    expect(badPrefixBody.error).toContain('prefix');
+    const badSeries = await GET(req('/api/gpu-metrics?runId=12345&series=temperature'));
+    expect(badSeries.status).toBe(400);
+    const badSeriesBody = await badSeries.json();
+    expect(badSeriesBody.error).toContain('series');
+  });
+
+  it('narrows downloads to the prefix and returns bucketed power series on demand', async () => {
+    const mockRunData = {
+      id: 12345,
+      name: 'Run Sweep',
+      head_branch: 'main',
+      head_sha: 'abc123',
+      created_at: '2026-03-01T00:00:00Z',
+      html_url: 'https://github.com/TestOwner/TestRepo/actions/runs/12345',
+      conclusion: 'success',
+      status: 'completed',
+    };
+    mockParseCsvData.mockImplementationOnce(() => [
+      {
+        timestamp: '2026/03/01 00:00:00.100',
+        index: 0,
+        power: 300,
+        temperature: 1,
+        smClock: 1,
+        memClock: 1,
+        gpuUtil: 0,
+        memUtil: 0,
+      },
+      {
+        timestamp: '2026/03/01 00:00:00.104',
+        index: 1,
+        power: 310,
+        temperature: 1,
+        smClock: 1,
+        memClock: 1,
+        gpuUtil: 0,
+        memUtil: 0,
+      },
+      {
+        timestamp: '2026/03/01 00:00:01.100',
+        index: 0,
+        power: 500,
+        temperature: 1,
+        smClock: 1,
+        memClock: 1,
+        gpuUtil: 0,
+        memUtil: 0,
+      },
+    ]);
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRunData) })
+      .mockResolvedValueOnce({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            artifacts: [
+              // Another model in the same sweep: filtered out before download.
+              {
+                id: 1,
+                name: 'gpu_metrics_dsr1_1k1k_fp8_x',
+                archive_download_url: 'https://example.com/dl/1',
+              },
+              {
+                id: 2,
+                name: 'gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc16',
+                archive_download_url: 'https://example.com/dl/2',
+              },
+              {
+                id: 3,
+                name: 'eval_gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc16',
+                archive_download_url: 'https://example.com/dl/3',
+              },
+            ],
+          }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers({ 'Content-Length': '1024' }),
+        arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+      });
+    globalThis.fetch = fetchMock;
+
+    const res = await GET(
+      req('/api/gpu-metrics?runId=12345&series=power&prefix=qwen3.5_8k1k_fp8_'),
+    );
+    expect(res.status).toBe(200);
+    // Run info, artifact list, and exactly one artifact download.
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+    expect(fetchMock.mock.calls[2][0]).toBe('https://example.com/dl/2');
+    const body = await res.json();
+    expect(body.runInfo.id).toBe(12345);
+    expect(body.artifacts).toBeUndefined();
+    expect(body.series).toEqual([
+      {
+        artifact: 'gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc16',
+        startMs: Date.UTC(2026, 2, 1, 0, 0, 0),
+        bucketSeconds: 1,
+        gpus: [0, 1],
+        t: [0, 1],
+        power: [
+          [300, 500],
+          [310, null],
+        ],
+      },
+    ]);
+  });
+
   it('returns 500 when workflow run fetch fails', async () => {
     globalThis.fetch = vi.fn().mockResolvedValueOnce({
       ok: false,
@@ -536,3 +669,292 @@ describe('GET /api/gpu-metrics', () => {
     expect(body.artifacts[0].name).toBe('gpu_metrics_dsr1_b200');
   });
 });
+
+/**
+ * Bundle fixtures: one `power_audit_*` sweep with two devices and one
+ * validated window, plus a GitHub mock that answers by URL so download order
+ * does not matter.
+ */
+const BUNDLE_RESULT = 'qwen3.5_8k1k_fp8_dynamo-sglang_prefill-tp4-pp1_decode-tp4-pp1-e-5b35252b';
+const BUNDLE_NAME = `power_audit_${BUNDLE_RESULT}`;
+const BUNDLE_VALIDATION = `power_validation_${BUNDLE_RESULT}_sa-bench_isl_8192_osl_1024_conc8_gpus_8_ctx_4_gen_4.json`;
+const OTHER_BUNDLE_NAME = 'power_audit_dsr1_1k1k_fp8_dynamo-sglang_prefill-tp4-abc';
+const CSV_NAME = 'gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc16';
+const RUN = {
+  id: 12345,
+  name: 'Run Sweep',
+  head_branch: 'main',
+  head_sha: 'abc123',
+  created_at: '2026-03-01T00:00:00Z',
+  html_url: 'https://github.com/TestOwner/TestRepo/actions/runs/12345',
+  conclusion: 'success',
+  status: 'completed',
+};
+
+const BUNDLE_ARCHIVE = [
+  {
+    entryName: 'LOGS/power/samples.csv',
+    data: [
+      'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+      '1,1000.2,1,cn02,0,GPU-d,500',
+      '1,1000.2,1,cn01,0,GPU-p,300',
+      '1,1001.2,2,cn02,0,GPU-d,510',
+      '1,1001.2,2,cn01,0,GPU-p,310',
+    ].join('\n'),
+  },
+  {
+    entryName: 'LOGS/power/manifest.json',
+    data: JSON.stringify({
+      expected_devices: [
+        { hostname: 'cn02', gpu_index: 0, assignments: [{ worker_role: 'decode' }] },
+      ],
+    }),
+  },
+  {
+    entryName: BUNDLE_VALIDATION,
+    data: JSON.stringify({
+      selected_window: { concurrency: 8, start_time_unix: 1000, end_time_unix: 1001 },
+      per_gpu_role: { 'cn01/GPU-p': 'prefill' },
+    }),
+  },
+  {
+    entryName: `LOGS/sa-bench_isl_8192_osl_1024/results_concurrency_8.json`,
+    data: '{"huge": true}',
+  },
+  { entryName: `agg_${BUNDLE_RESULT}_conc8.json`, data: '{}' },
+];
+
+const EXPECTED_BUNDLE_SERIES = {
+  artifact: BUNDLE_NAME,
+  source: BUNDLE_VALIDATION,
+  startMs: 1000 * 1000,
+  bucketSeconds: 1,
+  gpus: [0, 1],
+  t: [0, 1],
+  power: [
+    [300, 310],
+    [500, 510],
+  ],
+  devices: [
+    { id: 'cn01/GPU-p', role: 'prefill' },
+    { id: 'cn02/GPU-d', role: 'decode' },
+  ],
+};
+
+interface MockDownload {
+  /** Key of the zip archive the adm-zip mock serves for this download. */
+  archive: string;
+  contentLength?: number;
+}
+
+/** Answers run info, the artifact listing, and downloads by URL; returns the fetch spy. */
+function mockGithub(
+  artifacts: { name: string; url: string }[],
+  downloads: Record<string, MockDownload>,
+) {
+  const fetchMock = vi.fn((input: string) => {
+    if (input.endsWith('/actions/runs/12345')) {
+      return Promise.resolve({ ok: true, json: () => Promise.resolve(RUN) });
+    }
+    if (input.includes('/actions/runs/12345/artifacts')) {
+      return Promise.resolve({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            artifacts: artifacts.map((artifact, index) => ({
+              id: index + 1,
+              name: artifact.name,
+              archive_download_url: artifact.url,
+            })),
+          }),
+      });
+    }
+    const download = downloads[input];
+    if (!download) return Promise.resolve({ ok: false, statusText: `Unexpected ${input}` });
+    const bytes = new TextEncoder().encode(download.archive);
+    return Promise.resolve({
+      ok: true,
+      headers: new Headers({ 'Content-Length': String(download.contentLength ?? 1024) }),
+      arrayBuffer: () => Promise.resolve(bytes.buffer),
+    });
+  });
+  globalThis.fetch = fetchMock as unknown as typeof fetch;
+  return fetchMock;
+}
+
+function downloadedUrls(fetchMock: ReturnType<typeof mockGithub>): string[] {
+  return fetchMock.mock.calls.map(([url]) => url).filter((url) => url.includes('/dl/'));
+}
+
+describe('GET /api/gpu-metrics?series=power with power_audit bundles', () => {
+  beforeEach(() => {
+    zipArchives.byKey.set('bundle', BUNDLE_ARCHIVE);
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  it('cuts a bundle into per-window series alongside gpu_metrics series', async () => {
+    const fetchMock = mockGithub(
+      [
+        { name: CSV_NAME, url: 'https://example.com/dl/csv' },
+        { name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' },
+      ],
+      {
+        'https://example.com/dl/csv': { archive: '' },
+        'https://example.com/dl/bundle': { archive: 'bundle' },
+      },
+    );
+
+    const res = await GET(
+      req('/api/gpu-metrics?runId=12345&series=power&prefix=qwen3.5_8k1k_fp8_'),
+    );
+    expect(res.status).toBe(200);
+    expect(downloadedUrls(fetchMock)).toEqual([
+      'https://example.com/dl/csv',
+      'https://example.com/dl/bundle',
+    ]);
+    const body = await res.json();
+    expect(body.runInfo.id).toBe(12345);
+    expect(body.artifacts).toBeUndefined();
+    expect(body.series).toHaveLength(2);
+    expect(body.series[0]).toMatchObject({ artifact: CSV_NAME, gpus: [0] });
+    expect(body.series[0].source).toBeUndefined();
+    expect(body.series[1]).toEqual(EXPECTED_BUNDLE_SERIES);
+  });
+
+  it('skips a bundle whose archive cannot be read and keeps the other series', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    mockGithub(
+      [
+        { name: CSV_NAME, url: 'https://example.com/dl/csv' },
+        { name: BUNDLE_NAME, url: 'https://example.com/dl/corrupt' },
+      ],
+      {
+        'https://example.com/dl/csv': { archive: '' },
+        'https://example.com/dl/corrupt': { archive: 'corrupt' },
+      },
+    );
+
+    const res = await GET(
+      req('/api/gpu-metrics?runId=12345&series=power&prefix=qwen3.5_8k1k_fp8_'),
+    );
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.series).toHaveLength(1);
+    expect(body.series[0]).toMatchObject({ artifact: CSV_NAME });
+    expect(warn).toHaveBeenCalledWith(
+      `Failed to read artifact ${BUNDLE_NAME}:`,
+      expect.objectContaining({ message: expect.stringContaining('ADM-ZIP') }),
+    );
+  });
+
+  it('selects a bundle whether the prefix stops short of or runs past its name', async () => {
+    const artifacts = [
+      { name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' },
+      { name: OTHER_BUNDLE_NAME, url: 'https://example.com/dl/other' },
+    ];
+    const downloads = {
+      'https://example.com/dl/bundle': { archive: 'bundle' },
+      'https://example.com/dl/other': { archive: 'bundle' },
+    };
+
+    const longPrefix = `${BUNDLE_RESULT}_sa-bench_isl_8192_osl_1024_conc`;
+    let fetchMock = mockGithub(artifacts, downloads);
+    let res = await GET(req(`/api/gpu-metrics?runId=12345&series=power&prefix=${longPrefix}`));
+    expect(res.status).toBe(200);
+    expect(downloadedUrls(fetchMock)).toEqual(['https://example.com/dl/bundle']);
+    let body = await res.json();
+    expect(body.series).toEqual([EXPECTED_BUNDLE_SERIES]);
+
+    fetchMock = mockGithub(artifacts, downloads);
+    res = await GET(req('/api/gpu-metrics?runId=12345&series=power&prefix=qwen3.5_8k1k_'));
+    expect(res.status).toBe(200);
+    expect(downloadedUrls(fetchMock)).toEqual(['https://example.com/dl/bundle']);
+    body = await res.json();
+    expect(body.series.map((entry: { artifact: string }) => entry.artifact)).toEqual([BUNDLE_NAME]);
+
+    // No prefix: every bundle of the run.
+    fetchMock = mockGithub(artifacts, downloads);
+    res = await GET(req('/api/gpu-metrics?runId=12345&series=power'));
+    expect(res.status).toBe(200);
+    expect(downloadedUrls(fetchMock)).toEqual([
+      'https://example.com/dl/bundle',
+      'https://example.com/dl/other',
+    ]);
+    body = await res.json();
+    expect(body.series.map((entry: { artifact: string }) => entry.artifact)).toEqual([
+      BUNDLE_NAME,
+      OTHER_BUNDLE_NAME,
+    ]);
+  });
+
+  it('skips bundles above 256 MiB with a warning', async () => {
+    mockGithub(
+      [
+        { name: OTHER_BUNDLE_NAME, url: 'https://example.com/dl/other' },
+        { name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' },
+      ],
+      {
+        'https://example.com/dl/other': { archive: 'bundle', contentLength: 300 * 1024 * 1024 },
+        // Above the 50 MB CSV cap, below the bundle cap.
+        'https://example.com/dl/bundle': { archive: 'bundle', contentLength: 200 * 1024 * 1024 },
+      },
+    );
+
+    const res = await GET(req('/api/gpu-metrics?runId=12345&series=power'));
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.series).toEqual([EXPECTED_BUNDLE_SERIES]);
+    expect(console.warn).toHaveBeenCalledWith(
+      `Artifact ${OTHER_BUNDLE_NAME} exceeds 256 MB, skipping`,
+    );
+  });
+
+  it('keeps the raw-rows shape blind to bundles', async () => {
+    let fetchMock = mockGithub(
+      [
+        { name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' },
+        { name: CSV_NAME, url: 'https://example.com/dl/csv' },
+      ],
+      {
+        'https://example.com/dl/csv': { archive: '' },
+        'https://example.com/dl/bundle': { archive: 'bundle' },
+      },
+    );
+    let res = await GET(req('/api/gpu-metrics?runId=12345'));
+    expect(res.status).toBe(200);
+    expect(downloadedUrls(fetchMock)).toEqual(['https://example.com/dl/csv']);
+    const body = await res.json();
+    expect(body.series).toBeUndefined();
+    expect(body.artifacts.map((artifact: { name: string }) => artifact.name)).toEqual([CSV_NAME]);
+
+    fetchMock = mockGithub([{ name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' }], {
+      'https://example.com/dl/bundle': { archive: 'bundle' },
+    });
+    res = await GET(req('/api/gpu-metrics?runId=12345'));
+    expect(res.status).toBe(500);
+    expect(downloadedUrls(fetchMock)).toEqual([]);
+    const bundleOnly = await res.json();
+    expect(bundleOnly.error).toBe('No gpu_metrics artifacts found for this run');
+  });
+
+  it('names both collectors when a power request finds no telemetry', async () => {
+    mockGithub([{ name: 'benchmark_results', url: 'https://example.com/dl/results' }], {});
+    const res = await GET(req('/api/gpu-metrics?runId=12345&series=power'));
+    expect(res.status).toBe(500);
+    const body = await res.json();
+    expect(body.error).toBe(
+      'No telemetry artifacts (gpu_metrics or power_audit) found for this run',
+    );
+  });
+
+  it('reports no data when the only bundle has no power entries', async () => {
+    zipArchives.byKey.set('empty', [{ entryName: `agg_${BUNDLE_RESULT}_conc8.json`, data: '{}' }]);
+    mockGithub([{ name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' }], {
+      'https://example.com/dl/bundle': { archive: 'empty' },
+    });
+    const res = await GET(req('/api/gpu-metrics?runId=12345&series=power'));
+    expect(res.status).toBe(500);
+    const body = await res.json();
+    expect(body.error).toBe('No Chip metrics data found in artifacts');
+  });
+});
diff --git a/packages/app/src/app/api/gpu-metrics/route.ts b/packages/app/src/app/api/gpu-metrics/route.ts
index e523ec2b8..87488e11c 100644
--- a/packages/app/src/app/api/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.ts
@@ -1,5 +1,5 @@
 /**
- * PowerX explorer data for one GitHub Actions run.
+ * PowerX telemetry for one GitHub Actions run.
  *
  * Reads the ingest-time telemetry digest first (migration 016: series,
  * samples, per-GPU statistics, point links). Runs that have not been ingested
@@ -9,6 +9,29 @@
  * DO NOT ADD CACHING (blob, CDN, or unstable_cache) to this route. The
  * fallback fetches live GitHub Actions artifacts which change while a run is
  * in progress, and the database path is already a single indexed read.
+ *
+ * Two telemetry collectors publish GPU power for a run:
+ * - single-node runners (nvidia-smi / amd-smi) publish one `gpu_metrics_<RESULT_FILENAME>`
+ *   CSV artifact per benchmark config;
+ * - Slurm / Dynamo disaggregated runners (DCGM) publish one `power_audit_<RESULT_FILENAME>`
+ *   bundle per concurrency sweep, holding the sweep's samples plus one
+ *   `power_validation_*.json` window per config
+ *   (`components/gpu-power/power-audit-bundle.ts`).
+ *
+ * Two response shapes:
+ * - default: every `gpu_metrics_*` artifact's parsed rows (the `/gpu-metrics`
+ *   page), from the stored digest when the run is ingested, else from GitHub;
+ *   bundles are ignored on the GitHub path;
+ * - `series=power`: compact per-GPU watt series bucketed to one second
+ *   (`components/gpu-power/power-series.ts`) for the PowerX timeline, from
+ *   CSV artifacts and from bundles cut per validation window. The timeline
+ *   joins them to chart points by `source` (bundle) or artifact name (CSV).
+ *   This shape still reads GitHub: the stored digest holds the same samples
+ *   but no per-window cut yet.
+ * `prefix=<RESULT_FILENAME prefix>` narrows either shape to the artifacts of
+ * one model / workload / precision so a full nightly sweep is not downloaded
+ * for one chart. A bundle names a whole sweep, so it also matches when the
+ * prefix extends past its name into the per-concurrency suffix.
  */
 import { type NextRequest, NextResponse } from 'next/server';
 
@@ -24,6 +47,11 @@ import {
   type GpuMetricRow,
   type GpuPowerRunInfo,
 } from '@/components/gpu-power/types';
+import {
+  cutPowerAuditBundle,
+  isPowerAuditBundleEntry,
+} from '@/components/gpu-power/power-audit-bundle';
+import { bucketPowerSeries, type GpuPowerSeries } from '@/components/gpu-power/power-series';
 import {
   downloadGithubArtifact,
   extractZipEntries,
@@ -31,10 +59,22 @@ import {
   fetchGithubWorkflowRun,
   getGithubToken,
   normalizeGithubRunInfo,
+  readZipEntries,
+  type GithubArtifact,
   type GithubWorkflowRun,
 } from '@/lib/github-artifacts';
 
 const MAX_ARTIFACT_BYTES = 50 * 1024 * 1024;
+/** Bundles carry a whole sweep (215 MB seen for nw8); only the power entries are decoded. */
+const MAX_BUNDLE_BYTES = 256 * 1024 * 1024;
+/** Bundle downloads are latency-bound; match the other artifact routes' budget. */
+export const maxDuration = 300;
+/** Parallel artifact downloads; GitHub's zip redirects are latency-bound, not CPU-bound. */
+const DOWNLOAD_CONCURRENCY = 4;
+const ARTIFACT_PREFIX = 'gpu_metrics_';
+const BUNDLE_PREFIX = 'power_audit_';
+/** RESULT_FILENAME characters: model, workload, precision, framework, parallelism, host, hash. */
+const PREFIX_PATTERN = /^[A-Za-z0-9._-]{1,200}$/u;
 
 export type GpuMetricsSource = 'database' | 'github';
 
@@ -84,7 +124,147 @@ export function databasePayloadToResponse(payload: GpuMetricsRunPayload): GpuMet
   };
 }
 
-async function fetchGpuMetricsFromGithub(runId: string): Promise<GpuMetricsRouteResponse> {
+/** The GitHub path also carries the bundle series the timeline draws. */
+interface GithubGpuMetricsResponse extends GpuMetricsRouteResponse {
+  source: 'github';
+  bundleSeries: GpuPowerSeries[];
+}
+
+type TelemetryJob =
+  | { kind: 'csv'; artifact: GithubArtifact }
+  | { kind: 'bundle'; artifact: GithubArtifact };
+
+type TelemetryResult =
+  | { kind: 'csv'; parsed: GpuMetricsArtifactPayload }
+  | { kind: 'bundle'; series: GpuPowerSeries[] };
+
+/** Fetches one artifact zip, or `null` (with a warning) when it fails or exceeds `maxBytes`. */
+async function downloadZip(
+  artifact: GithubArtifact,
+  githubToken: string,
+  maxBytes: number,
+): Promise<Buffer | null> {
+  const dlResp = await downloadGithubArtifact(artifact.archive_download_url, githubToken);
+  if (!dlResp.ok) {
+    console.warn(`Failed to download artifact ${artifact.name}: ${dlResp.statusText}`);
+    return null;
+  }
+
+  const contentLength = dlResp.headers.get('Content-Length');
+  if (contentLength && parseInt(contentLength, 10) > maxBytes) {
+    console.warn(`Artifact ${artifact.name} exceeds ${maxBytes / (1024 * 1024)} MB, skipping`);
+    return null;
+  }
+  return Buffer.from(await dlResp.arrayBuffer());
+}
+
+async function downloadArtifact(
+  artifact: GithubArtifact,
+  githubToken: string,
+): Promise<GpuMetricsArtifactPayload | null> {
+  const buffer = await downloadZip(artifact, githubToken, MAX_ARTIFACT_BYTES);
+  if (!buffer) return null;
+  const rows = extractZipEntries(
+    buffer,
+    '.csv',
+    (_entryName, contents) => parseCsvData(contents),
+    (entryName, error) => {
+      console.warn(`Failed to parse CSV ${entryName} from ${artifact.name}:`, error);
+    },
+  );
+  return rows.length > 0 ? { name: artifact.name, data: rows } : null;
+}
+
+async function downloadBundle(
+  artifact: GithubArtifact,
+  githubToken: string,
+): Promise<GpuPowerSeries[] | null> {
+  const buffer = await downloadZip(artifact, githubToken, MAX_BUNDLE_BYTES);
+  if (!buffer) return null;
+  const series = cutPowerAuditBundle(
+    artifact.name,
+    readZipEntries(buffer, isPowerAuditBundleEntry),
+  );
+  return series.length > 0 ? series : null;
+}
+
+/**
+ * One artifact download and parse. A corrupt or truncated archive is that
+ * artifact's failure alone: it is logged and skipped so the other series of
+ * the run still reach the chart (the client would otherwise retry the whole
+ * multi-hundred-megabyte request).
+ */
+async function runJob(job: TelemetryJob, githubToken: string): Promise<TelemetryResult | null> {
+  try {
+    return await runJobUnguarded(job, githubToken);
+  } catch (error) {
+    console.warn(`Failed to read artifact ${job.artifact.name}:`, error);
+    return null;
+  }
+}
+
+async function runJobUnguarded(
+  job: TelemetryJob,
+  githubToken: string,
+): Promise<TelemetryResult | null> {
+  if (job.kind === 'csv') {
+    const parsed = await downloadArtifact(job.artifact, githubToken);
+    return parsed ? { kind: 'csv', parsed } : null;
+  }
+  const series = await downloadBundle(job.artifact, githubToken);
+  return series ? { kind: 'bundle', series } : null;
+}
+
+/** Downloads in listing order with a bounded number of requests in flight. */
+async function downloadTelemetry(
+  jobs: TelemetryJob[],
+  githubToken: string,
+): Promise<TelemetryResult[]> {
+  const results: (TelemetryResult | null)[] = Array.from({ length: jobs.length }, () => null);
+  let next = 0;
+  const worker = async () => {
+    while (next < jobs.length) {
+      const index = next++;
+      results[index] = await runJob(jobs[index], githubToken);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(DOWNLOAD_CONCURRENCY, jobs.length) }, worker));
+  return results.filter((result): result is TelemetryResult => result !== null);
+}
+
+/**
+ * A bundle names a whole sweep, while the client's prefix (the longest common
+ * prefix of its points' validation names) may run into the `_sa-bench_…_conc<c>`
+ * suffix; either side being a prefix of the other selects the bundle.
+ */
+function isWantedBundle(name: string, prefix: string | null): boolean {
+  if (!name.startsWith(BUNDLE_PREFIX)) return false;
+  if (prefix === null) return true;
+  const wanted = `${BUNDLE_PREFIX}${prefix}`;
+  return name.startsWith(wanted) || wanted.startsWith(name);
+}
+
+/**
+ * Narrows a stored run to the artifacts a `prefix` names, mirroring the GitHub
+ * listing filter so both sources answer the same request the same way.
+ */
+function filterArtifactsByPrefix(
+  artifacts: GpuMetricsArtifactPayload[],
+  prefix: string | null,
+): GpuMetricsArtifactPayload[] {
+  if (prefix === null) return artifacts;
+  const wanted = `${ARTIFACT_PREFIX}${prefix}`;
+  return artifacts.filter((artifact) => {
+    const name = artifact.series?.artifactName ?? artifact.name;
+    return name.startsWith(wanted) || isWantedBundle(name, prefix);
+  });
+}
+
+async function fetchGpuMetricsFromGithub(
+  runId: string,
+  prefix: string | null,
+  includeBundles: boolean,
+): Promise<GithubGpuMetricsResponse> {
   const githubToken = getGithubToken();
   if (!githubToken) throw new Error('GitHub token not configured');
 
@@ -94,40 +274,38 @@ async function fetchGpuMetricsFromGithub(runId: string): Promise<GpuMetricsRoute
 
   const artifacts = await fetchGithubRunArtifacts(runId, githubToken);
 
-  const gpuArtifacts = artifacts.filter((a) => a.name.startsWith('gpu_metrics'));
-  if (gpuArtifacts.length === 0) throw new Error('No gpu_metrics artifacts found for this run');
-
-  const parsedArtifacts: GpuMetricsArtifactPayload[] = [];
-  for (const artifact of gpuArtifacts) {
-    const dlResp = await downloadGithubArtifact(artifact.archive_download_url, githubToken);
-    if (!dlResp.ok) {
-      console.warn(`Failed to download artifact ${artifact.name}: ${dlResp.statusText}`);
-      continue;
-    }
-
-    const contentLength = dlResp.headers.get('Content-Length');
-    if (contentLength && parseInt(contentLength, 10) > MAX_ARTIFACT_BYTES) {
-      console.warn(`Artifact ${artifact.name} exceeds 50 MB, skipping`);
-      continue;
+  // `eval_gpu_metrics_*` artifacts are excluded by the bare `gpu_metrics` test.
+  const wanted = prefix ? `${ARTIFACT_PREFIX}${prefix}` : 'gpu_metrics';
+  const jobs: TelemetryJob[] = artifacts
+    .filter((a) => a.name.startsWith(wanted))
+    .map((artifact) => ({ kind: 'csv', artifact }));
+  if (includeBundles) {
+    for (const artifact of artifacts) {
+      if (isWantedBundle(artifact.name, prefix)) jobs.push({ kind: 'bundle', artifact });
     }
-
-    const rows = extractZipEntries(
-      Buffer.from(await dlResp.arrayBuffer()),
-      '.csv',
-      (_entryName, contents) => parseCsvData(contents),
-      (entryName, error) => {
-        console.warn(`Failed to parse CSV ${entryName} from ${artifact.name}:`, error);
-      },
+  }
+  if (jobs.length === 0) {
+    throw new Error(
+      includeBundles
+        ? 'No telemetry artifacts (gpu_metrics or power_audit) found for this run'
+        : 'No gpu_metrics artifacts found for this run',
     );
-    if (rows.length > 0) parsedArtifacts.push({ name: artifact.name, data: rows });
   }
 
-  if (parsedArtifacts.length === 0) throw new Error('No Chip metrics data found in artifacts');
+  const results = await downloadTelemetry(jobs, githubToken);
+  if (results.length === 0) throw new Error('No Chip metrics data found in artifacts');
 
+  const parsedArtifacts: GpuMetricsArtifactPayload[] = [];
+  const bundleSeries: GpuPowerSeries[] = [];
+  for (const result of results) {
+    if (result.kind === 'csv') parsedArtifacts.push(result.parsed);
+    else bundleSeries.push(...result.series);
+  }
   return {
     source: 'github',
     runInfo: normalizeGithubRunInfo(run) as GpuPowerRunInfo,
     artifacts: parsedArtifacts,
+    bundleSeries,
   };
 }
 
@@ -145,16 +323,47 @@ async function fetchGpuMetricsFromDatabase(runId: string): Promise<GpuMetricsRou
 }
 
 export async function GET(request: NextRequest) {
-  const runId = request.nextUrl.searchParams.get('runId');
+  const params = request.nextUrl.searchParams;
+  const runId = params.get('runId');
 
   if (!runId || !/^\d+$/u.test(runId)) {
     return NextResponse.json({ error: 'runId must be a numeric workflow run ID' }, { status: 400 });
   }
+  const prefix = params.get('prefix');
+  if (prefix !== null && !PREFIX_PATTERN.test(prefix)) {
+    return NextResponse.json(
+      { error: 'prefix must be a RESULT_FILENAME prefix (letters, digits, . _ -)' },
+      { status: 400 },
+    );
+  }
+  const series = params.get('series');
+  if (series !== null && series !== 'power') {
+    return NextResponse.json({ error: 'series must be "power" when present' }, { status: 400 });
+  }
 
   try {
-    const data =
-      (await fetchGpuMetricsFromDatabase(runId)) ?? (await fetchGpuMetricsFromGithub(runId));
-    return NextResponse.json(data);
+    if (series === 'power') {
+      const { runInfo, artifacts, bundleSeries } = await fetchGpuMetricsFromGithub(
+        runId,
+        prefix,
+        true,
+      );
+      const powerSeries = artifacts
+        .map((artifact) => bucketPowerSeries(artifact.name, artifact.data))
+        .filter((entry): entry is GpuPowerSeries => entry !== null);
+      return NextResponse.json({ runInfo, series: [...powerSeries, ...bundleSeries] });
+    }
+    const stored = await fetchGpuMetricsFromDatabase(runId);
+    if (stored) {
+      const artifacts = filterArtifactsByPrefix(stored.artifacts, prefix);
+      if (artifacts.length > 0) return NextResponse.json({ ...stored, artifacts });
+    }
+    const live = await fetchGpuMetricsFromGithub(runId, prefix, false);
+    return NextResponse.json({
+      source: live.source,
+      runInfo: live.runInfo,
+      artifacts: live.artifacts,
+    });
   } catch (error) {
     console.error('Error fetching GPU power data:', error);
     return NextResponse.json(
diff --git a/packages/app/src/app/zh/(dashboard)/cache-reuse/page.tsx b/packages/app/src/app/zh/(dashboard)/cache-reuse/page.tsx
new file mode 100644
index 000000000..e94ace0f8
--- /dev/null
+++ b/packages/app/src/app/zh/(dashboard)/cache-reuse/page.tsx
@@ -0,0 +1,23 @@
+import type { Metadata } from 'next';
+
+import CacheReuseDisplay from '@/components/calculator/CacheReuseDisplay';
+import { resolveCalculatorUrlSeed } from '@/components/calculator/url-seed';
+import { ZhTabIntro } from '@/components/zh/zh-tab-intro';
+import { tabMetadataZh } from '@/lib/tab-meta-zh';
+
+export const metadata: Metadata = tabMetadataZh('cache-reuse');
+
+interface Props {
+  searchParams: Promise<Record<string, string | string[] | undefined>>;
+}
+
+export default async function ZhCacheReusePage({ searchParams }: Props) {
+  const sp = await searchParams;
+  const seed = resolveCalculatorUrlSeed(sp);
+  return (
+    <>
+      <ZhTabIntro tab="cache-reuse" />
+      <CacheReuseDisplay urlSeed={seed} />
+    </>
+  );
+}
diff --git a/packages/app/src/app/zh/(dashboard)/first-token/page.tsx b/packages/app/src/app/zh/(dashboard)/first-token/page.tsx
new file mode 100644
index 000000000..8921a9109
--- /dev/null
+++ b/packages/app/src/app/zh/(dashboard)/first-token/page.tsx
@@ -0,0 +1,23 @@
+import type { Metadata } from 'next';
+
+import FirstTokenLimitsDisplay from '@/components/calculator/FirstTokenLimitsDisplay';
+import { resolveCalculatorUrlSeed } from '@/components/calculator/url-seed';
+import { ZhTabIntro } from '@/components/zh/zh-tab-intro';
+import { tabMetadataZh } from '@/lib/tab-meta-zh';
+
+export const metadata: Metadata = tabMetadataZh('first-token');
+
+interface Props {
+  searchParams: Promise<Record<string, string | string[] | undefined>>;
+}
+
+export default async function ZhFirstTokenPage({ searchParams }: Props) {
+  const sp = await searchParams;
+  const seed = resolveCalculatorUrlSeed(sp);
+  return (
+    <>
+      <ZhTabIntro tab="first-token" />
+      <FirstTokenLimitsDisplay urlSeed={seed} />
+    </>
+  );
+}
diff --git a/packages/app/src/components/calculator/CacheReuseChart.tsx b/packages/app/src/components/calculator/CacheReuseChart.tsx
new file mode 100644
index 000000000..6f7e1391a
--- /dev/null
+++ b/packages/app/src/components/calculator/CacheReuseChart.tsx
@@ -0,0 +1,394 @@
+'use client';
+
+import * as d3 from 'd3';
+import React, { useMemo, useRef } from 'react';
+
+import type { HardwareConfig } from '@/components/inference/types';
+import { getHardwareConfig } from '@/lib/constants';
+import { CHART_TYPE, px } from '@/lib/d3-chart/typography';
+import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import type { CustomLayerConfig, D3ChartHandle, RenderContext } from '@/lib/d3-chart/D3Chart/types';
+import { getChartWatermark } from '@/lib/data-mappings';
+import type { Locale } from '@/lib/i18n';
+import { overlayRunColor } from '@/lib/overlay-run-style';
+import { useLocale } from '@/lib/use-locale';
+import { escapeHtml, getDisplayLabel } from '@/lib/utils';
+
+import {
+  CACHE_TIER_COLORS,
+  formatShare,
+  type CacheReuseBar,
+  type CacheReuseResult,
+  type CacheTier,
+} from './cache-reuse';
+
+export const CACHE_REUSE_STRINGS = {
+  en: {
+    xTitle: 'Concurrency',
+    yTitle: 'Share of prompt tokens',
+    hbm: 'HBM cache',
+    host: 'Host cache',
+    combined: 'HBM + host cache (reported together)',
+    unreused: 'Not reused',
+    ceiling: 'Theoretical ceiling',
+    noTiers: 'No cache tiers reported',
+    instructions: 'Hover a bar for the breakdown · Click to pin its tooltip',
+    unofficialRun: 'UNOFFICIAL RUN',
+    branch: 'Branch:',
+    dismiss: 'Click elsewhere to dismiss',
+    concurrency: 'Concurrency:',
+    hostSource: 'Host tier from:',
+    external: 'router / external cache',
+    cpu: 'CPU offload',
+    reportedTotal: 'Reported total:',
+    overReported: 'above 100%, clamped',
+    precision: 'Precision:',
+    tp: 'TP:',
+    viewRun: 'View workflow run',
+    viewOfficial: 'View raw result on GitHub',
+  },
+  zh: {
+    xTitle: '并发数',
+    yTitle: 'prompt token 占比',
+    hbm: 'HBM 缓存',
+    host: '主机缓存',
+    combined: 'HBM + 主机缓存（合并上报）',
+    unreused: '未复用',
+    ceiling: '理论上限',
+    noTiers: '未上报缓存层级',
+    instructions: '悬停柱形查看拆分 · 点击固定提示框',
+    unofficialRun: '非官方运行',
+    branch: '分支：',
+    dismiss: '点击其他区域关闭',
+    concurrency: '并发数：',
+    hostSource: '主机层来源：',
+    external: 'router / 外部缓存',
+    cpu: 'CPU offload',
+    reportedTotal: '上报合计：',
+    overReported: '超过 100%，已截断',
+    precision: '精度：',
+    tp: 'TP：',
+    viewRun: '查看工作流运行',
+    viewOfficial: '在 GitHub 查看原始结果',
+  },
+} as const;
+
+export function configLabel(hwKey: string, hardwareConfig: HardwareConfig): string {
+  const config = hardwareConfig[hwKey] ?? getHardwareConfig(hwKey);
+  return config ? getDisplayLabel(config) : hwKey;
+}
+
+export function tierLabel(tier: CacheTier, combined: boolean, locale: Locale): string {
+  const t = CACHE_REUSE_STRINGS[locale];
+  if (tier === 'hbm') return combined ? t.combined : t.hbm;
+  return t[tier];
+}
+
+interface Segment {
+  bar: CacheReuseBar;
+  tier: CacheTier;
+  y0: number;
+  y1: number;
+}
+
+function segmentsOf(bars: readonly CacheReuseBar[]): Segment[] {
+  const out: Segment[] = [];
+  for (const bar of bars) {
+    const { hbm, host, unreused } = bar.share;
+    out.push({ bar, tier: 'hbm', y0: 0, y1: hbm });
+    if (host > 0) out.push({ bar, tier: 'host', y0: hbm, y1: hbm + host });
+    if (unreused > 0)
+      out.push({ bar, tier: 'unreused', y0: hbm + host, y1: hbm + host + unreused });
+  }
+  return out;
+}
+
+function row(html: string): string {
+  return `<div style="color: var(--muted-foreground); font-size: 11px; margin-bottom: 4px;">${html}</div>`;
+}
+
+function swatchRow(color: string, label: string, value: string): string {
+  return row(
+    `<span style="display:inline-block;width:9px;height:9px;border-radius:2px;background:${color};margin-right:6px;vertical-align:middle;"></span><strong>${label}</strong> ${value}`,
+  );
+}
+
+export function generateCacheReuseTooltipHTML(
+  bar: CacheReuseBar,
+  options: {
+    hardwareConfig: HardwareConfig;
+    runInfoByIndex: Record<number, { branch: string; url: string }>;
+    locale: Locale;
+    isPinned: boolean;
+  },
+): string {
+  const { hardwareConfig, runInfoByIndex, locale } = options;
+  const t = CACHE_REUSE_STRINGS[locale];
+  const { share, point } = bar;
+  const isOverlay = bar.runIndex !== undefined;
+  const runInfo = isOverlay ? runInfoByIndex[bar.runIndex!] : undefined;
+  const label = escapeHtml(configLabel(point.hwKey, hardwareConfig));
+  const runUrl = isOverlay ? runInfo?.url : point.sourceRow?.run_url;
+  const runLink = runUrl
+    ? `<div style="margin-top: 8px; border-top: 1px solid var(--border); padding-top: 8px;"><a href="${escapeHtml(
+        runUrl,
+      )}" target="_blank" rel="noopener noreferrer" style="color: var(--primary); font-size: 11px; text-decoration: underline; cursor: pointer;">${
+        isOverlay ? t.viewRun : t.viewOfficial
+      } &#8599;</a></div>`
+    : '';
+  const overlayHeader = isOverlay
+    ? `<div style="color: var(--destructive, #ef4444); font-size: 11px; font-weight: 600; margin-bottom: 4px;">${t.unofficialRun}</div>${
+        runInfo?.branch ? row(`<strong>${t.branch}</strong> ${escapeHtml(runInfo.branch)}`) : ''
+      }`
+    : '';
+  const hostSource =
+    share.hostSource === null ? '' : row(`<strong>${t.hostSource}</strong> ${t[share.hostSource]}`);
+  const ceiling =
+    share.theoretical === null
+      ? ''
+      : row(`<strong>${t.ceiling}:</strong> ${formatShare(share.theoretical)}`);
+  const overReported =
+    share.reportedTotal > 1.005
+      ? row(
+          `<strong>${t.reportedTotal}</strong> ${formatShare(share.reportedTotal)} (${t.overReported})`,
+        )
+      : '';
+
+  return `
+    <div style="background: var(--popover); border: 1px solid var(--border); border-radius: 8px; padding: 12px; box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1); max-width: 320px; pointer-events: auto; user-select: ${options.isPinned ? 'text' : 'none'};">
+      ${options.isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
+      ${overlayHeader}
+      <div style="color: var(--foreground); font-size: 13px; font-weight: 600; margin-bottom: 8px;">${label}</div>
+      ${row(`<strong>${t.concurrency}</strong> ${point.concurrency}`)}
+      ${swatchRow(CACHE_TIER_COLORS.hbm, `${tierLabel('hbm', share.combined, locale)}:`, formatShare(share.hbm))}
+      ${share.combined ? '' : swatchRow(CACHE_TIER_COLORS.host, `${t.host}:`, formatShare(share.host))}
+      ${swatchRow(CACHE_TIER_COLORS.unreused, `${t.unreused}:`, formatShare(share.unreused))}
+      ${hostSource}
+      ${ceiling}
+      ${overReported}
+      ${row(`<strong>${t.precision}</strong> ${escapeHtml(point.precision.toUpperCase())}`)}
+      ${row(`<strong>${t.tp}</strong> ${point.tp}`)}
+      ${runLink}
+    </div>
+  `;
+}
+
+interface CacheReuseChartProps {
+  result: CacheReuseResult;
+  hardwareConfig: HardwareConfig;
+  showCeiling: boolean;
+  runInfoByIndex: Record<number, { branch: string; url: string }>;
+  legendElement?: React.ReactNode;
+  caption?: React.ReactNode;
+}
+
+const MARGIN = { top: 16, right: 20, bottom: 64, left: 64 };
+const HEIGHT = 480;
+/** Inner gap between the official and run bars of one concurrency. */
+const SERIES_PADDING = 0.12;
+/** Segments shorter than this draw no percentage; the tooltip still has it. */
+const MIN_LABEL_HEIGHT = 14;
+
+const CacheReuseChart = React.memo(
+  ({
+    result,
+    hardwareConfig,
+    showCeiling,
+    runInfoByIndex,
+    legendElement,
+    caption,
+  }: CacheReuseChartProps) => {
+    const locale = useLocale();
+    const t = CACHE_REUSE_STRINGS[locale];
+    const chartRef = useRef<D3ChartHandle | null>(null);
+
+    const seriesKeys = useMemo(() => result.series.map((s) => s.key), [result.series]);
+    const segments = useMemo(() => segmentsOf(result.bars), [result.bars]);
+
+    const xScale = useMemo(
+      () => ({
+        type: 'band' as const,
+        domain: result.concurrencies.map(String),
+        padding: seriesKeys.length > 1 ? 0.22 : 0.35,
+      }),
+      [result.concurrencies, seriesKeys.length],
+    );
+    const yScale = useMemo(
+      () => ({ type: 'linear' as const, domain: [0, 1] as [number, number], nice: false }),
+      [],
+    );
+    const xAxis = useMemo(() => ({ grid: false, label: t.xTitle }), [t]);
+    const yAxis = useMemo(
+      () => ({
+        label: t.yTitle,
+        tickFormat: (d: d3.AxisDomain) => d3.format('.0%')(Number(d)),
+        tickCount: 5,
+      }),
+      [t],
+    );
+
+    const layers = useMemo<CustomLayerConfig[]>(() => {
+      const render = (
+        group: d3.Selection<SVGGElement, unknown, null, undefined>,
+        ctx: RenderContext,
+      ) => {
+        const x0 = ctx.xScale as d3.ScaleBand<string>;
+        const y = ctx.yScale as d3.ScaleLinear<number, number>;
+        const x1 = d3
+          .scaleBand<string>()
+          .domain(seriesKeys)
+          .range([0, x0.bandwidth()])
+          .padding(seriesKeys.length > 1 ? SERIES_PADDING : 0);
+        const slotX = (concurrency: number, seriesKey: string) =>
+          (x0(String(concurrency)) ?? 0) + (x1(seriesKey) ?? 0);
+        const width = x1.bandwidth();
+
+        group
+          .selectAll<SVGRectElement, Segment>('.cr-segment')
+          .data(segments, (s) => `${s.bar.key}|${s.tier}`)
+          .join('rect')
+          .attr('class', (s) => `cr-segment cr-${s.tier}`)
+          .attr('data-tier', (s) => s.tier)
+          .attr('data-series', (s) => s.bar.seriesKey)
+          .attr('data-conc', (s) => s.bar.concurrency)
+          .attr('x', (s) => slotX(s.bar.concurrency, s.bar.seriesKey))
+          .attr('width', width)
+          .attr('y', (s) => y(s.y1))
+          .attr('height', (s) => Math.max(0, y(s.y0) - y(s.y1)))
+          .attr('fill', (s) => CACHE_TIER_COLORS[s.tier])
+          .style('pointer-events', 'none');
+
+        group
+          .selectAll<SVGTextElement, Segment>('.cr-value')
+          .data(
+            segments.filter((s) => y(s.y0) - y(s.y1) >= MIN_LABEL_HEIGHT),
+            (s) => `${s.bar.key}|${s.tier}`,
+          )
+          .join('text')
+          .attr('class', 'cr-value')
+          .attr('x', (s) => slotX(s.bar.concurrency, s.bar.seriesKey) + width / 2)
+          .attr('y', (s) => (y(s.y0) + y(s.y1)) / 2)
+          .attr('dy', '0.35em')
+          .attr('text-anchor', 'middle')
+          .attr('font-size', px(CHART_TYPE.annotation))
+          .attr('font-weight', '600')
+          // Dark ink on the pale tiers, light on the slate one: contrast holds in
+          // both themes because the tier colors are fixed, not themed.
+          .style('fill', (s) => (s.tier === 'unreused' ? '#f5f5f5' : '#0b0f14'))
+          .style('pointer-events', 'none')
+          .text((s) => formatShare(s.y1 - s.y0));
+
+        group
+          .selectAll<SVGLineElement, CacheReuseBar>('.cr-ceiling')
+          .data(
+            showCeiling ? result.bars.filter((b) => b.share.theoretical !== null) : [],
+            (b) => b.key,
+          )
+          .join('line')
+          .attr('class', 'cr-ceiling')
+          .attr('x1', (b) => slotX(b.concurrency, b.seriesKey) - 3)
+          .attr('x2', (b) => slotX(b.concurrency, b.seriesKey) + width + 3)
+          .attr('y1', (b) => y(b.share.theoretical!))
+          .attr('y2', (b) => y(b.share.theoretical!))
+          .attr('stroke', 'var(--foreground)')
+          .attr('stroke-width', 1.5)
+          .attr('stroke-dasharray', '4 3')
+          .style('pointer-events', 'none')
+          .append('title')
+          .text((b) => `${t.ceiling}: ${formatShare(b.share.theoretical!)}`);
+
+        // A row that ran but reported no tier is a gap in the measurement, not
+        // in the sweep, so it gets a marker rather than an empty slot.
+        group
+          .selectAll<SVGTextElement, CacheReuseResult['unmeasured'][number]>('.cr-empty')
+          .data(result.unmeasured, (u) => `${u.concurrency}|${u.seriesKey}`)
+          .join('text')
+          .attr('class', 'cr-empty')
+          .attr('x', (u) => slotX(u.concurrency, u.seriesKey) + width / 2)
+          .attr('y', ctx.height - 8)
+          .attr('text-anchor', 'middle')
+          .attr('font-size', px(CHART_TYPE.dataLabel))
+          .style('fill', 'var(--muted-foreground)')
+          .style('pointer-events', 'none')
+          .text('—')
+          .append('title')
+          .text(t.noTiers);
+
+        // One full-height hit target per bar carries the tooltip and, for a run,
+        // the palette-colored outline that tells it apart from the official bar.
+        return group
+          .selectAll<SVGRectElement, CacheReuseBar>('.cr-bar')
+          .data(result.bars, (b) => b.key)
+          .join('rect')
+          .attr('class', 'cr-bar bar')
+          .attr('data-series', (b) => b.seriesKey)
+          .attr('data-conc', (b) => b.concurrency)
+          .attr('x', (b) => slotX(b.concurrency, b.seriesKey))
+          .attr('width', width)
+          .attr('y', y(1))
+          .attr('height', Math.max(0, ctx.height - y(1)))
+          .attr('fill', 'transparent')
+          .attr('stroke', (b) => (b.runIndex === undefined ? 'none' : overlayRunColor(b.runIndex)))
+          .attr('stroke-width', 2)
+          .attr('cursor', 'pointer');
+      };
+      return [{ type: 'custom', key: 'cache-reuse-bars', render }];
+    }, [segments, seriesKeys, result.bars, result.unmeasured, showCeiling, t]);
+
+    const tooltipStateRef = useRef({ hardwareConfig, runInfoByIndex, locale });
+    tooltipStateRef.current = { hardwareConfig, runInfoByIndex, locale };
+
+    const tooltip = useMemo(
+      () => ({
+        rulerType: 'none' as const,
+        content: (bar: CacheReuseBar, isPinned: boolean) =>
+          generateCacheReuseTooltipHTML(bar, { ...tooltipStateRef.current, isPinned }),
+        getRulerX: () => 0,
+        onHoverStart: (
+          selection: d3.Selection<SVGRectElement, CacheReuseBar, SVGGElement, unknown>,
+        ) => {
+          selection.attr('stroke', 'var(--foreground)').attr('stroke-width', 1.5);
+        },
+        onHoverEnd: (
+          selection: d3.Selection<SVGRectElement, CacheReuseBar, SVGGElement, unknown>,
+        ) => {
+          selection
+            .attr('stroke', (b) =>
+              b.runIndex === undefined ? 'none' : overlayRunColor(b.runIndex),
+            )
+            .attr('stroke-width', 2);
+        },
+        attachToLayer: 0,
+      }),
+      [],
+    );
+
+    const zoom = useMemo(() => ({ enabled: false }), []);
+
+    return (
+      <D3Chart<CacheReuseBar>
+        ref={chartRef}
+        chartId="cache-reuse"
+        data={result.bars}
+        height={HEIGHT}
+        margin={MARGIN}
+        watermark={getChartWatermark()}
+        testId="cache-reuse-chart"
+        clipContent={false}
+        xScale={xScale}
+        yScale={yScale}
+        xAxis={xAxis}
+        yAxis={yAxis}
+        layers={layers}
+        zoom={zoom}
+        instructions={t.instructions}
+        tooltip={tooltip}
+        legendElement={legendElement}
+        caption={caption}
+      />
+    );
+  },
+);
+CacheReuseChart.displayName = 'CacheReuseChart';
+
+export default CacheReuseChart;
diff --git a/packages/app/src/components/calculator/CacheReuseDisplay.tsx b/packages/app/src/components/calculator/CacheReuseDisplay.tsx
new file mode 100644
index 000000000..790ef6bee
--- /dev/null
+++ b/packages/app/src/components/calculator/CacheReuseDisplay.tsx
@@ -0,0 +1,682 @@
+'use client';
+
+import { useCallback, useMemo, useState } from 'react';
+
+import type { CalculatorUrlSeed } from '@/components/calculator/url-seed';
+import {
+  GlobalFilterProvider,
+  useGlobalFilterActions,
+  useGlobalFilterAvailability,
+  useGlobalFilterRun,
+  useGlobalFilterSelection,
+} from '@/components/GlobalFilterContext';
+import {
+  includesJalapenoResult,
+  includesTpuv7Result,
+  includesVeraRubinResult,
+  JalapenoOfficialPreviewNotice,
+  Tpuv7OfficialPreviewNotice,
+  VeraRubinOfficialPreviewNotice,
+} from '@/components/official-preview-notice';
+import { Card } from '@/components/ui/card';
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { ChartShareActions } from '@/components/ui/chart-display-helpers';
+import ChartLegend from '@/components/ui/chart-legend';
+import {
+  ModelSelector,
+  PrecisionSelector,
+  ScenarioSelector,
+} from '@/components/ui/chart-selectors';
+import { ControlPanel } from '@/components/ui/control-panel';
+import { DashboardSectionHeader } from '@/components/ui/dashboard-section-header';
+import { type DataTableColumn, DataTable } from '@/components/ui/data-table';
+import { ExternalLinkIcon } from '@/components/ui/external-link-icon';
+import { Heading } from '@/components/ui/heading';
+import { LabelWithTooltip } from '@/components/ui/label-with-tooltip';
+import { MultiSelect } from '@/components/ui/multi-select';
+import { Skeleton } from '@/components/ui/skeleton';
+import { TooltipProvider } from '@/components/ui/tooltip';
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
+import { useOpenDropdown } from '@/hooks/useOpenDropdown';
+import { track } from '@/lib/analytics';
+import { getModelSortIndex } from '@/lib/constants';
+import { exportToCsv } from '@/lib/csv-export';
+import {
+  getModelLabel,
+  getSequenceLabel,
+  Percentile,
+  Sequence,
+  type Model,
+} from '@/lib/data-mappings';
+import { overlayRunColor } from '@/lib/overlay-run-style';
+import { readUrlParams, writeUrlParams } from '@/lib/url-state';
+import { useLocale } from '@/lib/use-locale';
+
+import {
+  buildCacheReuse,
+  CACHE_TIER_COLORS,
+  defaultCacheReuseGroup,
+  formatShare,
+  tieredRowCount,
+  type CacheReuseBar,
+} from './cache-reuse';
+import CacheReuseChart, { CACHE_REUSE_STRINGS, configLabel, tierLabel } from './CacheReuseChart';
+import { useThroughputData, type GroupMeta } from './useThroughputData';
+
+const STRINGS = {
+  en: {
+    title: 'Prefix Cache Reuse',
+    description:
+      'Where a configuration finds its prompt tokens as concurrency rises: served from the chip’s HBM cache, from the host tier behind it, or recomputed. Each stacked bar is one measured row, read from the runtime’s own cache counters.',
+    benchmarkGroup: 'Benchmark Config',
+    chartGroup: 'Chart Config',
+    configLabel: 'Configuration',
+    configTooltip:
+      'The chip and serving framework whose sweep is plotted. Configurations that reported no cache tier for this selection are listed but draw no bars.',
+    configPlaceholder: 'Configuration',
+    ceiling: 'Theoretical ceiling',
+    errorLoading: 'Error loading data. Please try a different selection.',
+    noData:
+      'No measured data for the current selection. Try another model, workload, or precision.',
+    noTiersFixed:
+      'Fixed-sequence runs record no prefix-cache tiers, so there is nothing to stack here. Switch the scenario to AgentX.',
+    noTiers:
+      'None of the measured rows for this configuration reported a prefix-cache tier. Try another configuration or run date.',
+    captionRows: (tiered: number, measured: number) =>
+      `${tiered} of ${measured} measured rows report cache tiers`,
+    captionSource: 'Source: SemiAnalysis InferenceX',
+    unofficialRun: 'Unofficial run',
+    note: 'Note:',
+    methodology:
+      ' Shares are the runtime’s own prefix-cache hit counters over all prompt tokens of the run, so HBM, host, and not-reused sum to 100%. The host tier is the CPU-offload rate (HiCache and similar host-memory caches) and falls back to the router’s external cache rate only when a row reports no CPU figure; the two are never added together. TensorRT-LLM with offload enabled reports both tiers as one figure, drawn as a single reused segment. The dashed tick is the trace’s infinite-cache ceiling.',
+    colSeries: 'Series',
+    colConcurrency: 'Concurrency',
+    colHbm: 'HBM',
+    colHost: 'Host',
+    colUnreused: 'Not reused',
+    colCeiling: 'Ceiling',
+    colTp: 'TP',
+    colRun: 'Run',
+    viewRun: 'View',
+    official: 'Official',
+  },
+  zh: {
+    title: '前缀缓存复用',
+    description:
+      '随并发数上升，一个配置的 prompt token 从哪里来：命中芯片 HBM 缓存、命中其后的主机层缓存，还是重新计算。每个堆叠柱形对应一行实测数据，数值取自运行时自身的缓存计数。',
+    benchmarkGroup: '基准测试配置',
+    chartGroup: '图表配置',
+    configLabel: '配置',
+    configTooltip:
+      '要绘制的芯片与推理框架组合。当前选择下未上报任何缓存层级的配置仍会列出，但不绘制柱形。',
+    configPlaceholder: '配置',
+    ceiling: '理论上限',
+    errorLoading: '加载数据出错，请尝试其他选择。',
+    noData: '当前选择没有实测数据。请尝试其他模型、工作负载或精度。',
+    noTiersFixed: '固定序列的运行不记录前缀缓存层级，此处没有可堆叠的数据。请将场景切换为 AgentX。',
+    noTiers: '该配置的实测数据行均未上报前缀缓存层级。请尝试其他配置或运行日期。',
+    captionRows: (tiered: number, measured: number) =>
+      `${measured} 行实测数据中有 ${tiered} 行上报缓存层级`,
+    captionSource: '来源：SemiAnalysis InferenceX',
+    unofficialRun: '非官方运行',
+    note: '注：',
+    methodology:
+      ' 占比取自运行时自身的前缀缓存命中计数，分母为本次运行的全部 prompt token，因此 HBM、主机与未复用三者之和为 100%。主机层取 CPU offload 命中率（HiCache 等主机内存缓存），仅当数据行未上报 CPU 数值时才改用 router 的外部缓存命中率，两者不会相加。TensorRT-LLM 开启 offload 时将两层合并上报，图中绘制为单个复用段。虚线刻度为该 trace 的无限缓存理论上限。',
+    colSeries: '系列',
+    colConcurrency: '并发数',
+    colHbm: 'HBM',
+    colHost: '主机',
+    colUnreused: '未复用',
+    colCeiling: '理论上限',
+    colTp: 'TP',
+    colRun: '运行记录',
+    viewRun: '查看',
+    official: '官方',
+  },
+} as const;
+
+interface CacheReuseRow {
+  key: string;
+  series: string;
+  concurrency: number;
+  hbm: number;
+  host: number | null;
+  unreused: number;
+  ceiling: number | null;
+  tp: number;
+  runUrl: string | null;
+}
+
+interface ConfigOption {
+  key: string;
+  meta: GroupMeta;
+  label: string;
+  /** No official rows; the configuration exists only in a loaded run. */
+  overlayOnly: boolean;
+}
+
+export default function CacheReuseDisplay({ urlSeed }: { urlSeed?: CalculatorUrlSeed }) {
+  return (
+    <GlobalFilterProvider
+      initialModel={urlSeed?.model}
+      initialSequence={urlSeed?.sequence}
+      initialPrecisions={urlSeed?.precisions}
+      initialRunDate={urlSeed?.runDate}
+      initialRunId={urlSeed?.runId}
+    >
+      <CacheReuseInner />
+    </GlobalFilterProvider>
+  );
+}
+
+function CacheReuseInner() {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const tc = CACHE_REUSE_STRINGS[locale];
+  const { openDropdown, handleDropdownOpenChange } = useOpenDropdown();
+
+  const {
+    tcoBasis,
+    selectedModel,
+    effectiveSequence: selectedSequence,
+    effectivePrecisions: selectedPrecisions,
+  } = useGlobalFilterSelection();
+  const { setSelectedModel, setSelectedSequence, setSelectedPrecisions } = useGlobalFilterActions();
+  const { selectedRunDate } = useGlobalFilterRun();
+  const { availablePrecisions, availableSequences, availableModels } =
+    useGlobalFilterAvailability();
+
+  // URL-seeded so an article can link the exact configuration; empty means
+  // "the configuration with the most tiered rows", which is why the default
+  // is never written back.
+  const [configInput, setConfigInput] = useState<string>(() => readUrlParams().c_cfg ?? '');
+  const [showCeiling, setShowCeiling] = useState(false);
+  const [isLegendExpanded, setIsLegendExpanded] = useState(true);
+
+  const { isUnofficialRun, unofficialBenchmarkRows, unofficialRunInfos, runIndexByUrl } =
+    useUnofficialRun();
+  const overlayInput = useMemo(
+    () => ({ rows: unofficialBenchmarkRows, runIndexByUrl }),
+    [unofficialBenchmarkRows, runIndexByUrl],
+  );
+
+  const {
+    gpuDataByGroupKey,
+    gpuGroupMeta,
+    overlayGpuDataByGroupKey,
+    overlayGroupMeta,
+    hardwareConfig,
+    loading,
+    error,
+    hasData,
+    hasOverlayData,
+    availableHwKeys,
+    overlayAvailableHwKeys,
+  } = useThroughputData(
+    selectedModel,
+    selectedSequence,
+    selectedPrecisions,
+    selectedRunDate,
+    overlayInput,
+    Percentile.P90,
+    undefined,
+    true,
+    'total',
+    tcoBasis,
+  );
+
+  const isAgenticSequence = selectedSequence === Sequence.AgenticTraces;
+
+  const configOptions = useMemo<ConfigOption[]>(() => {
+    const label = (meta: GroupMeta) =>
+      `${configLabel(meta.hwKey, hardwareConfig)}${meta.precision ? ` · ${meta.precision.toUpperCase()}` : ''}`;
+    const options: ConfigOption[] = Object.entries(gpuGroupMeta).map(([key, meta]) => ({
+      key,
+      meta,
+      label: label(meta),
+      overlayOnly: false,
+    }));
+    const official = new Set(options.map((o) => o.key));
+    for (const meta of Object.values(overlayGroupMeta)) {
+      const key = `${meta.hwKey}${meta.precision ? `__${meta.precision}` : ''}`;
+      if (official.has(key)) continue;
+      official.add(key);
+      options.push({
+        key,
+        meta: { hwKey: meta.hwKey, precision: meta.precision },
+        label: `✕ ${label(meta)}`,
+        overlayOnly: true,
+      });
+    }
+    return options.toSorted(
+      (a, b) =>
+        getModelSortIndex(a.meta.hwKey) - getModelSortIndex(b.meta.hwKey) ||
+        a.label.localeCompare(b.label),
+    );
+  }, [gpuGroupMeta, overlayGroupMeta, hardwareConfig]);
+
+  const selectedConfig = useMemo<ConfigOption | null>(() => {
+    const requested = configOptions.find((o) => o.key === configInput);
+    if (requested) return requested;
+    const fallback = defaultCacheReuseGroup(gpuDataByGroupKey, gpuGroupMeta);
+    return (
+      configOptions.find((o) => o.key === fallback) ??
+      configOptions.find((o) => o.overlayOnly) ??
+      configOptions[0] ??
+      null
+    );
+  }, [configOptions, configInput, gpuDataByGroupKey, gpuGroupMeta]);
+
+  const runInfoByIndex = useMemo(() => {
+    const map: Record<number, { branch: string; url: string }> = {};
+    unofficialRunInfos.forEach((info, idx) => {
+      map[idx] = { branch: info.branch || `run ${info.id}`, url: info.url };
+    });
+    return map;
+  }, [unofficialRunInfos]);
+  const overlayLabels = useMemo(
+    () =>
+      Object.fromEntries(Object.entries(runInfoByIndex).map(([idx, info]) => [idx, info.branch])),
+    [runInfoByIndex],
+  );
+
+  const officialPoints = useMemo(
+    () => (selectedConfig ? (gpuDataByGroupKey[selectedConfig.key] ?? []) : []),
+    [selectedConfig, gpuDataByGroupKey],
+  );
+  const result = useMemo(
+    () =>
+      buildCacheReuse({
+        official: officialPoints,
+        overlay: overlayGpuDataByGroupKey,
+        overlayMeta: overlayGroupMeta,
+        overlayLabels,
+        config: selectedConfig?.meta ?? { hwKey: '' },
+      }),
+    [officialPoints, overlayGpuDataByGroupKey, overlayGroupMeta, overlayLabels, selectedConfig],
+  );
+  const hasAnyData = hasData || hasOverlayData;
+  const hasBars = result.bars.length > 0;
+  const tieredRows = useMemo(() => tieredRowCount(officialPoints), [officialPoints]);
+
+  const handleModelChange = useCallback(
+    (value: string) => {
+      setSelectedModel(value as Model);
+      track('cache_reuse_model_selected', { model: value });
+    },
+    [setSelectedModel],
+  );
+  const handleSequenceChange = useCallback(
+    (value: string) => {
+      setSelectedSequence(value as Sequence);
+      track('cache_reuse_sequence_selected', { sequence: value });
+    },
+    [setSelectedSequence],
+  );
+  const handlePrecisionChange = useCallback(
+    (value: string[]) => {
+      setSelectedPrecisions(value);
+      track('cache_reuse_precision_selected', { precision: value.join(',') });
+    },
+    [setSelectedPrecisions],
+  );
+  const handleConfigChange = useCallback((key: string) => {
+    setConfigInput(key);
+    writeUrlParams({ c_cfg: key });
+    track('cache_reuse_config_selected', { config: key });
+  }, []);
+
+  const legendItems = useMemo(() => {
+    const tiers = (['hbm', 'host', 'unreused'] as const)
+      .filter(
+        (tier) =>
+          tier !== 'host' || !result.anyCombined || result.bars.some((b) => !b.share.combined),
+      )
+      .map((tier) => ({
+        name: `tier-${tier}`,
+        label: tierLabel(tier, tier === 'hbm' && result.anyCombined, locale),
+        color: CACHE_TIER_COLORS[tier],
+        title: tierLabel(tier, tier === 'hbm' && result.anyCombined, locale),
+        hw: `cache-tier-${tier}`,
+        isActive: true,
+        isRemovable: false,
+        onClick: () => {},
+      }));
+    const runs = result.series
+      .filter((series) => series.runIndex !== undefined)
+      .map((series) => {
+        const info = unofficialRunInfos[series.runIndex!];
+        return {
+          name: `✕ unofficial-run-${info?.id ?? series.runIndex}`,
+          label: series.label,
+          color: overlayRunColor(series.runIndex!),
+          title: `${t.unofficialRun}: ${series.label}`,
+          hw: `overlay-run-${info?.id ?? series.runIndex}`,
+          isActive: true,
+          isRemovable: false,
+          onClick: () => {},
+        };
+      });
+    return [...runs, ...tiers];
+  }, [result.anyCombined, result.bars, result.series, unofficialRunInfos, locale, t]);
+
+  const tableRows = useMemo<CacheReuseRow[]>(
+    () =>
+      result.bars.map((bar: CacheReuseBar) => ({
+        key: bar.key,
+        series:
+          bar.runIndex === undefined
+            ? t.official
+            : (result.series.find((s) => s.key === bar.seriesKey)?.label ?? bar.seriesKey),
+        concurrency: bar.concurrency,
+        hbm: bar.share.hbm,
+        host: bar.share.combined ? null : bar.share.host,
+        unreused: bar.share.unreused,
+        ceiling: bar.share.theoretical,
+        tp: bar.point.tp,
+        runUrl:
+          bar.runIndex === undefined
+            ? (bar.point.sourceRow?.run_url ?? null)
+            : (runInfoByIndex[bar.runIndex]?.url ?? null),
+      })),
+    [result.bars, result.series, runInfoByIndex, t],
+  );
+
+  const columns = useMemo<DataTableColumn<CacheReuseRow>[]>(
+    () => [
+      { header: t.colSeries, cell: (r) => r.series, sortValue: (r) => r.series, pinned: true },
+      {
+        header: t.colConcurrency,
+        cell: (r) => r.concurrency,
+        sortValue: (r) => r.concurrency,
+        align: 'right',
+      },
+      {
+        header: result.anyCombined ? tc.combined : t.colHbm,
+        cell: (r) => formatShare(r.hbm),
+        sortValue: (r) => r.hbm,
+        align: 'right',
+      },
+      {
+        header: t.colHost,
+        cell: (r) => (r.host === null ? '—' : formatShare(r.host)),
+        sortValue: (r) => r.host ?? -1,
+        align: 'right',
+      },
+      {
+        header: t.colUnreused,
+        cell: (r) => formatShare(r.unreused),
+        sortValue: (r) => r.unreused,
+        align: 'right',
+      },
+      {
+        header: t.colCeiling,
+        cell: (r) => (r.ceiling === null ? '—' : formatShare(r.ceiling)),
+        sortValue: (r) => r.ceiling ?? -1,
+        align: 'right',
+      },
+      { header: t.colTp, cell: (r) => r.tp, sortValue: (r) => r.tp, align: 'right' },
+      {
+        header: t.colRun,
+        cell: (r) =>
+          r.runUrl ? (
+            <a
+              href={r.runUrl}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="text-primary underline underline-offset-2"
+              onClick={() => track('cache_reuse_run_link_clicked')}
+            >
+              {t.viewRun}
+              <ExternalLinkIcon />
+            </a>
+          ) : (
+            '—'
+          ),
+      },
+    ],
+    [t, tc, result.anyCombined],
+  );
+
+  const handleExportCsv = useCallback(() => {
+    const headers = [
+      t.colSeries,
+      t.colConcurrency,
+      t.colHbm,
+      t.colHost,
+      t.colUnreused,
+      t.colCeiling,
+      t.colTp,
+      t.colRun,
+    ];
+    const body = tableRows.map((r) => [
+      r.series,
+      r.concurrency,
+      r.hbm,
+      r.host ?? '',
+      r.unreused,
+      r.ceiling ?? '',
+      r.tp,
+      r.runUrl ?? '',
+    ]);
+    exportToCsv(`InferenceX_cache_reuse_${selectedModel}.csv`, headers, body, [
+      `${getModelLabel(selectedModel)} • ${getSequenceLabel(selectedSequence, locale)}`,
+      selectedConfig?.label ?? '',
+    ]);
+    track('cache_reuse_csv_exported', { model: selectedModel });
+  }, [t, tableRows, selectedModel, selectedSequence, locale, selectedConfig]);
+
+  const legendHwKeys = useMemo(
+    () => [...new Set([...availableHwKeys, ...(isUnofficialRun ? overlayAvailableHwKeys : [])])],
+    [availableHwKeys, overlayAvailableHwKeys, isUnofficialRun],
+  );
+  const showsJalapenoPreview = includesJalapenoResult(legendHwKeys);
+  const showsVeraRubinPreview = includesVeraRubinResult(legendHwKeys);
+  const showsTpuv7Preview = includesTpuv7Result(legendHwKeys);
+
+  const caption = (
+    <>
+      <Heading as="h2" level="card">
+        {t.title}
+      </Heading>
+      <p className="text-sm text-muted-foreground mb-2">
+        {getModelLabel(selectedModel)} • {getSequenceLabel(selectedSequence, locale)}
+        {selectedConfig ? ` • ${selectedConfig.label}` : ''} •{' '}
+        {t.captionRows(tieredRows, officialPoints.length)} • {t.captionSource}
+      </p>
+    </>
+  );
+
+  const legendElement = (
+    <ChartLegend
+      variant="sidebar"
+      legendItems={legendItems}
+      isLegendExpanded={isLegendExpanded}
+      onExpandedChange={(expanded) => {
+        setIsLegendExpanded(expanded);
+        track('cache_reuse_legend_expanded', { expanded });
+      }}
+      switches={[
+        {
+          id: 'cache-reuse-ceiling',
+          label: t.ceiling,
+          checked: showCeiling,
+          onCheckedChange: (checked: boolean) => {
+            setShowCeiling(checked);
+            track('cache_reuse_ceiling_toggled', { enabled: checked });
+          },
+        },
+      ]}
+    />
+  );
+
+  if (!loading && error) {
+    console.error(error);
+    return (
+      <Card>
+        <div className="flex items-center justify-center h-64 text-muted-foreground">
+          {t.errorLoading}
+        </div>
+      </Card>
+    );
+  }
+
+  return (
+    <div className="flex flex-col gap-4">
+      <section data-testid="cache-reuse-controls">
+        <Card className="relative z-30">
+          <div className="flex flex-col gap-4">
+            <DashboardSectionHeader
+              title={t.title}
+              description={t.description}
+              actions={<ChartShareActions />}
+            />
+
+            <TooltipProvider delayDuration={0}>
+              <ControlPanel
+                legend={t.benchmarkGroup}
+                data-testid="cache-reuse-benchmark-panel"
+                className="grid-cols-1 md:grid-cols-2 lg:grid-cols-4"
+              >
+                <div className="min-w-0 md:col-span-2">
+                  <ModelSelector
+                    id="cache-reuse-model"
+                    data-testid="cache-reuse-model-selector"
+                    value={selectedModel}
+                    onChange={handleModelChange}
+                    open={openDropdown === 'model'}
+                    onOpenChange={handleDropdownOpenChange('model')}
+                    availableModels={availableModels}
+                  />
+                </div>
+                <ScenarioSelector
+                  id="cache-reuse-sequence"
+                  data-testid="cache-reuse-sequence-selector"
+                  value={selectedSequence}
+                  onChange={handleSequenceChange}
+                  open={openDropdown === 'sequence'}
+                  onOpenChange={handleDropdownOpenChange('sequence')}
+                  availableSequences={availableSequences}
+                  model={selectedModel}
+                />
+                <PrecisionSelector
+                  id="cache-reuse-precision"
+                  data-testid="cache-reuse-precision-selector"
+                  value={selectedPrecisions}
+                  onChange={handlePrecisionChange}
+                  open={openDropdown === 'precision'}
+                  onOpenChange={handleDropdownOpenChange('precision')}
+                  availablePrecisions={availablePrecisions}
+                />
+              </ControlPanel>
+
+              <ControlPanel
+                legend={t.chartGroup}
+                data-testid="cache-reuse-chart-panel"
+                className="grid-cols-1 md:grid-cols-2"
+              >
+                <div className="flex min-w-0 flex-col space-y-1.5">
+                  <LabelWithTooltip
+                    htmlFor="cache-reuse-config"
+                    label={t.configLabel}
+                    tooltip={t.configTooltip}
+                  />
+                  <div data-testid="cache-reuse-config-selector">
+                    <MultiSelect
+                      triggerId="cache-reuse-config"
+                      options={configOptions.map((o) => ({ value: o.key, label: o.label }))}
+                      value={selectedConfig ? [selectedConfig.key] : []}
+                      onChange={(values) => {
+                        const next = values[0];
+                        if (next) handleConfigChange(next);
+                      }}
+                      open={openDropdown === 'config'}
+                      onOpenChange={handleDropdownOpenChange('config')}
+                      placeholder={t.configPlaceholder}
+                      minSelections={1}
+                      maxSelections={1}
+                      showClearAll={false}
+                      plainSelectedText
+                      showSelectionSummary={false}
+                    />
+                  </div>
+                </div>
+              </ControlPanel>
+            </TooltipProvider>
+          </div>
+        </Card>
+      </section>
+
+      {loading && (
+        <Card>
+          <Skeleton className="h-64 w-full" />
+        </Card>
+      )}
+
+      {!loading && !hasAnyData && (
+        <Card>
+          <div
+            className="flex items-center justify-center h-64 text-muted-foreground text-center px-6"
+            data-testid="cache-reuse-no-data"
+          >
+            {t.noData}
+          </div>
+        </Card>
+      )}
+
+      {!loading && hasAnyData && (
+        <Card>
+          <figure data-testid="cache-reuse-figure" className="relative rounded-lg">
+            <ChartButtons
+              chartId="cache-reuse"
+              analyticsPrefix="cache_reuse"
+              hideZoomReset
+              onExportCsv={handleExportCsv}
+              exportFileName={`InferenceX_cache_reuse_${selectedModel}`}
+            />
+            {showsJalapenoPreview && <JalapenoOfficialPreviewNotice />}
+            {showsVeraRubinPreview && <VeraRubinOfficialPreviewNotice />}
+            {showsTpuv7Preview && <Tpuv7OfficialPreviewNotice />}
+            {hasBars ? (
+              <CacheReuseChart
+                result={result}
+                hardwareConfig={hardwareConfig}
+                showCeiling={showCeiling}
+                runInfoByIndex={runInfoByIndex}
+                legendElement={legendElement}
+                caption={caption}
+              />
+            ) : (
+              <>
+                <figcaption>{caption}</figcaption>
+                <div
+                  className="flex items-center justify-center h-48 text-muted-foreground text-center px-6"
+                  data-testid="cache-reuse-no-tiers"
+                >
+                  {isAgenticSequence ? t.noTiers : t.noTiersFixed}
+                </div>
+              </>
+            )}
+          </figure>
+
+          <p className="mt-4 text-xs text-muted-foreground">
+            <strong>{t.note}</strong>
+            {t.methodology}
+          </p>
+
+          {tableRows.length > 0 && (
+            <div className="mt-4">
+              <DataTable
+                data={tableRows}
+                columns={columns}
+                testId="cache-reuse-table"
+                analyticsPrefix="cache_reuse_table"
+                searchable={false}
+              />
+            </div>
+          )}
+        </Card>
+      )}
+    </div>
+  );
+}
diff --git a/packages/app/src/components/calculator/FirstTokenLimitsChart.tsx b/packages/app/src/components/calculator/FirstTokenLimitsChart.tsx
new file mode 100644
index 000000000..57c1771d3
--- /dev/null
+++ b/packages/app/src/components/calculator/FirstTokenLimitsChart.tsx
@@ -0,0 +1,454 @@
+'use client';
+
+import * as d3 from 'd3';
+import React, { useCallback, useMemo, useRef } from 'react';
+
+import type { HardwareConfig } from '@/components/inference/types';
+import { getHardwareConfig } from '@/lib/constants';
+import { CHART_TYPE, px } from '@/lib/d3-chart/typography';
+import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import type { CustomLayerConfig, D3ChartHandle, RenderContext } from '@/lib/d3-chart/D3Chart/types';
+import { getChartWatermark } from '@/lib/data-mappings';
+import type { Locale } from '@/lib/i18n';
+import { overlayRunColor } from '@/lib/overlay-run-style';
+import { useLocale } from '@/lib/use-locale';
+import { escapeHtml, getDisplayLabel } from '@/lib/utils';
+
+import {
+  formatCap,
+  zhStatPhrase,
+  type FirstTokenCell,
+  type FirstTokenResult,
+  type FirstTokenWinner,
+} from './first-token-limits';
+import { getCostTypeLabel } from './ThroughputBarChart';
+import type { CostType } from './types';
+
+/** One bar: a cap × series cell that found a qualifying configuration. */
+export interface FirstTokenBar {
+  key: string;
+  cap: number;
+  seriesKey: string;
+  winner: FirstTokenWinner;
+}
+
+const STRINGS = {
+  en: {
+    capTick: (cap: number) => `≤${formatCap(cap)}s`,
+    xTitle: (stat: string) => `Maximum ${stat} time to first token`,
+    yTitle: (tokenType: string) => `$ per million ${tokenType} tokens`,
+    noConfig: 'No measured config',
+    instructions: 'Hover a bar for the configuration · Click to pin its tooltip',
+    lower: (pct: number) => `${pct}% lower`,
+    only: (label: string) => `${label} only`,
+    unofficialRun: 'UNOFFICIAL RUN',
+    branch: 'Branch:',
+    dismiss: 'Click elsewhere to dismiss',
+    cost: 'Cost:',
+    ttft: (stat: string) => `${stat} TTFT:`,
+    interactivity: (stat: string) => `${stat} interactivity:`,
+    concurrency: 'Concurrency:',
+    precision: 'Precision:',
+    parallelism: 'Parallelism:',
+    disaggregated: 'Disaggregated:',
+    yes: 'Yes',
+    viewRun: 'View workflow run',
+    viewOfficial: 'View raw result on GitHub',
+  },
+  zh: {
+    capTick: (cap: number) => `≤${formatCap(cap)}s`,
+    xTitle: (stat: string) => `${zhStatPhrase('首 token 延迟', stat)}上限`,
+    yTitle: (tokenType: string) => `每百万${tokenType} token 成本（$）`,
+    noConfig: '无实测配置',
+    instructions: '悬停柱形查看配置 · 点击固定提示框',
+    lower: (pct: number) => `低 ${pct}%`,
+    only: (label: string) => `仅 ${label}`,
+    unofficialRun: '非官方运行',
+    branch: '分支：',
+    dismiss: '点击其他区域关闭',
+    cost: '成本：',
+    ttft: (stat: string) => `${zhStatPhrase('TTFT', stat)}：`,
+    interactivity: (stat: string) => `${zhStatPhrase('交互性', stat)}：`,
+    concurrency: '并发数：',
+    precision: '精度：',
+    parallelism: '并行策略：',
+    disaggregated: '分离式：',
+    yes: '是',
+    viewRun: '查看工作流运行',
+    viewOfficial: '在 GitHub 查看原始结果',
+  },
+} as const;
+
+const TOKEN_TYPE_WORD = {
+  en: { total: 'total', input: 'input', output: 'output' },
+  zh: { total: '总', input: '输入', output: '输出' },
+} as const;
+
+/** Three decimals below a dollar, two above — the calculator's cost labels. */
+export function formatCost(cost: number): string {
+  return `$${cost.toFixed(cost < 1 ? 3 : 2)}`;
+}
+
+/** Bare SKU (`GB300`) for the under-axis summary, where the full label will not fit. */
+function skuLabel(hwKey: string, hardwareConfig: HardwareConfig): string {
+  const config = hardwareConfig[hwKey] ?? getHardwareConfig(hwKey);
+  return config?.label ?? hwKey;
+}
+
+export function configLabel(hwKey: string, hardwareConfig: HardwareConfig): string {
+  const config = hardwareConfig[hwKey] ?? getHardwareConfig(hwKey);
+  return config ? getDisplayLabel(config) : hwKey;
+}
+
+export function barsFromCells(cells: readonly FirstTokenCell[]): FirstTokenBar[] {
+  const bars: FirstTokenBar[] = [];
+  for (const cell of cells) {
+    if (!cell.winner) continue;
+    bars.push({
+      key: `${cell.cap}|${cell.series.key}`,
+      cap: cell.cap,
+      seriesKey: cell.series.key,
+      winner: cell.winner,
+    });
+  }
+  return bars;
+}
+
+function row(html: string): string {
+  return `<div style="color: var(--muted-foreground); font-size: 11px; margin-bottom: 4px;">${html}</div>`;
+}
+
+function parallelismText(
+  winner: FirstTokenWinner,
+  t: (typeof STRINGS)[Locale],
+  locale: Locale,
+): string {
+  const { tp, ep, dp_attention: dpa } = winner.point;
+  const colon = locale === 'zh' ? '：' : ':';
+  const dpaValue = locale === 'zh' ? t.yes : 'True';
+  if (ep !== null && ep !== undefined && ep > 1 && tp === ep) {
+    return `<strong>${t.parallelism}</strong> ${dpa ? 'DEP' : 'TEP'}${tp}`;
+  }
+  if (ep !== null && ep !== undefined && ep > 1) {
+    return `<strong>TP${colon}</strong> ${tp}, <strong>EP${colon}</strong> ${ep}${
+      dpa ? `, <strong>DPA${colon}</strong> ${dpaValue}` : ''
+    }`;
+  }
+  return `<strong>TP${colon}</strong> ${tp}${dpa ? `, <strong>DPA${colon}</strong> ${dpaValue}` : ''}`;
+}
+
+export function generateFirstTokenTooltipHTML(
+  bar: FirstTokenBar,
+  options: {
+    hardwareConfig: HardwareConfig;
+    costType: CostType;
+    ttftStat: string;
+    interactivityStat: string;
+    runInfoByIndex: Record<number, { branch: string; url: string }>;
+    locale: Locale;
+    isPinned: boolean;
+  },
+): string {
+  const { hardwareConfig, costType, ttftStat, interactivityStat, runInfoByIndex, locale } = options;
+  const t = STRINGS[locale];
+  const { winner } = bar;
+  const isOverlay = winner.runIndex !== undefined;
+  const runInfo = isOverlay ? runInfoByIndex[winner.runIndex!] : undefined;
+  // Branch names and run URLs come from the GitHub API for whatever run the
+  // reader pasted; labels are ours but are escaped for uniformity.
+  const label = escapeHtml(configLabel(winner.hwKey, hardwareConfig));
+  const runUrl = isOverlay ? runInfo?.url : winner.point.sourceRow?.run_url;
+  const runLink = runUrl
+    ? `<div style="margin-top: 8px; border-top: 1px solid var(--border); padding-top: 8px;"><a href="${escapeHtml(
+        runUrl,
+      )}" target="_blank" rel="noopener noreferrer" style="color: var(--primary); font-size: 11px; text-decoration: underline; cursor: pointer;">${
+        isOverlay ? t.viewRun : t.viewOfficial
+      } &#8599;</a></div>`
+    : '';
+  const overlayHeader = isOverlay
+    ? `<div style="color: var(--destructive, #ef4444); font-size: 11px; font-weight: 600; margin-bottom: 4px;">${t.unofficialRun}</div>${
+        runInfo?.branch ? row(`<strong>${t.branch}</strong> ${escapeHtml(runInfo.branch)}`) : ''
+      }`
+    : '';
+
+  return `
+    <div style="background: var(--popover); border: 1px solid var(--border); border-radius: 8px; padding: 12px; box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1); max-width: 320px; pointer-events: auto; user-select: ${options.isPinned ? 'text' : 'none'};">
+      ${options.isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
+      ${overlayHeader}
+      <div style="color: var(--foreground); font-size: 13px; font-weight: 600; margin-bottom: 8px;">${label}</div>
+      ${row(`<strong>${t.cost}</strong> ${formatCost(winner.cost)}${getCostTypeLabel(costType)}`)}
+      ${row(`<strong>${t.ttft(ttftStat)}</strong> ${winner.ttft.toFixed(2)} s`)}
+      ${row(`<strong>${t.interactivity(interactivityStat)}</strong> ${winner.interactivity.toFixed(1)} tok/s/user`)}
+      ${row(`<strong>${t.concurrency}</strong> ${winner.point.concurrency}`)}
+      ${row(`<strong>${t.precision}</strong> ${escapeHtml(winner.precision.toUpperCase())}`)}
+      ${row(parallelismText(winner, t, locale))}
+      ${winner.point.disagg ? row(`<strong>${t.disaggregated}</strong> ${t.yes}`) : ''}
+      ${runLink}
+    </div>
+  `;
+}
+
+interface FirstTokenLimitsChartProps {
+  result: FirstTokenResult;
+  hardwareConfig: HardwareConfig;
+  costType: CostType;
+  /** `P90` / `Median`, naming the statistic the TTFT cap is read on. */
+  ttftStat: string;
+  /** `P90` / `Median`, naming the statistic the interactivity floor is read on. */
+  interactivityStat: string;
+  colorResolver: (hwKey: string) => string;
+  runInfoByIndex: Record<number, { branch: string; url: string }>;
+  legendElement?: React.ReactNode;
+  caption?: React.ReactNode;
+}
+
+const MARGIN = { top: 24, right: 20, bottom: 104, left: 76 };
+const HEIGHT = 500;
+/** Inner gap between a cap's bars, as a fraction of the inner band. */
+const SERIES_PADDING = 0.15;
+
+const FirstTokenLimitsChart = React.memo(
+  ({
+    result,
+    hardwareConfig,
+    costType,
+    ttftStat,
+    interactivityStat,
+    colorResolver,
+    runInfoByIndex,
+    legendElement,
+    caption,
+  }: FirstTokenLimitsChartProps) => {
+    const locale = useLocale();
+    const t = STRINGS[locale];
+    const chartRef = useRef<D3ChartHandle | null>(null);
+
+    const caps = useMemo(() => [...new Set(result.cells.map((c) => c.cap))], [result.cells]);
+    const seriesKeys = useMemo(() => result.series.map((s) => s.key), [result.series]);
+    const bars = useMemo(() => barsFromCells(result.cells), [result.cells]);
+    const emptyCells = useMemo(() => result.cells.filter((c) => !c.winner), [result.cells]);
+
+    const maxCost = useMemo(() => d3.max(bars, (b) => b.winner.cost) ?? 0, [bars]);
+
+    const barColor = useCallback(
+      (bar: FirstTokenBar) =>
+        bar.winner.runIndex === undefined
+          ? colorResolver(bar.winner.hwKey)
+          : overlayRunColor(bar.winner.runIndex),
+      [colorResolver],
+    );
+
+    const xScale = useMemo(
+      () => ({ type: 'band' as const, domain: caps.map((c) => t.capTick(c)), padding: 0.28 }),
+      [caps, t],
+    );
+    // Headroom for the value label above the tallest bar.
+    const yScale = useMemo(
+      () => ({
+        type: 'linear' as const,
+        domain: [0, maxCost > 0 ? maxCost * 1.18 : 1] as [number, number],
+        nice: true,
+      }),
+      [maxCost],
+    );
+    const xAxis = useMemo(() => ({ grid: false }), []);
+    const yAxis = useMemo(
+      () => ({
+        label: t.yTitle(TOKEN_TYPE_WORD[locale][costType]),
+        tickFormat: (d: d3.AxisDomain) => formatCost(Number(d)),
+        tickCount: 6,
+      }),
+      [t, locale, costType],
+    );
+
+    const layers = useMemo<CustomLayerConfig[]>(() => {
+      const render = (
+        group: d3.Selection<SVGGElement, unknown, null, undefined>,
+        ctx: RenderContext,
+      ) => {
+        const x0 = ctx.xScale as d3.ScaleBand<string>;
+        const y = ctx.yScale as d3.ScaleLinear<number, number>;
+        const x1 = d3
+          .scaleBand<string>()
+          .domain(seriesKeys)
+          .range([0, x0.bandwidth()])
+          .padding(SERIES_PADDING);
+        const slotX = (cap: number, seriesKey: string) =>
+          (x0(t.capTick(cap)) ?? 0) + (x1(seriesKey) ?? 0);
+
+        const rects = group
+          .selectAll<SVGRectElement, FirstTokenBar>('.ft-bar')
+          .data(bars, (b) => b.key)
+          .join('rect')
+          .attr('class', 'ft-bar bar')
+          .attr('data-series', (b) => b.seriesKey)
+          .attr('data-hw', (b) => b.winner.hwKey)
+          .attr('x', (b) => slotX(b.cap, b.seriesKey))
+          .attr('width', x1.bandwidth())
+          .attr('y', (b) => y(b.winner.cost))
+          .attr('height', (b) => Math.max(0, ctx.height - y(b.winner.cost)))
+          .attr('rx', 3)
+          .attr('fill', (b) => barColor(b))
+          .attr('opacity', 0.9)
+          .attr('cursor', 'pointer');
+
+        group
+          .selectAll<SVGTextElement, FirstTokenBar>('.ft-value')
+          .data(bars, (b) => b.key)
+          .join('text')
+          .attr('class', 'ft-value')
+          .attr('x', (b) => slotX(b.cap, b.seriesKey) + x1.bandwidth() / 2)
+          .attr('y', (b) => y(b.winner.cost) - 6)
+          .attr('text-anchor', 'middle')
+          .attr('font-size', px(CHART_TYPE.annotation))
+          .attr('font-weight', '600')
+          .style('fill', 'var(--foreground)')
+          .style('pointer-events', 'none')
+          .text((b) => formatCost(b.winner.cost));
+
+        // A slot with nothing under the cap is the finding, so mark it rather
+        // than leaving a gap the eye reads as a missing vendor.
+        group
+          .selectAll<SVGTextElement, FirstTokenCell>('.ft-empty')
+          .data(emptyCells, (c) => `${c.cap}|${c.series.key}`)
+          .join('text')
+          .attr('class', 'ft-empty')
+          .attr('x', (c) => slotX(c.cap, c.series.key) + x1.bandwidth() / 2)
+          .attr('y', ctx.height - 8)
+          .attr('text-anchor', 'middle')
+          .attr('font-size', px(CHART_TYPE.dataLabel))
+          .style('fill', 'var(--muted-foreground)')
+          .style('pointer-events', 'none')
+          .text('—')
+          .append('title')
+          .text(t.noConfig);
+
+        return rects;
+      };
+      return [{ type: 'custom', key: 'first-token-bars', render }];
+    }, [bars, emptyCells, seriesKeys, barColor, t]);
+
+    /**
+     * Under-axis summary per cap — the winning SKU against the runner-up and the
+     * gap — plus the x title. Drawn on the root group so it sits below the axis.
+     */
+    const onRender = useCallback(
+      (ctx: RenderContext) => {
+        const x0 = ctx.xScale as d3.ScaleBand<string>;
+        const g = ctx.layout.g;
+        const center = (cap: number) => (x0(t.capTick(cap)) ?? 0) + x0.bandwidth() / 2;
+
+        g.selectAll<SVGTextElement, (typeof result.summaries)[number]>('.ft-summary-who')
+          .data(result.summaries, (s) => String(s.cap))
+          .join('text')
+          .attr('class', 'ft-summary-who')
+          .attr('x', (s) => center(s.cap))
+          .attr('y', ctx.height + 40)
+          .attr('text-anchor', 'middle')
+          .attr('font-size', px(CHART_TYPE.axisLabelSub))
+          .style('fill', 'var(--muted-foreground)')
+          .text((s) => {
+            if (!s.best) return '';
+            const best = skuLabel(s.best.hwKey, hardwareConfig);
+            if (!s.runnerUp) return t.only(best);
+            return `${best} vs ${skuLabel(s.runnerUp.hwKey, hardwareConfig)}`;
+          });
+
+        g.selectAll<SVGTextElement, (typeof result.summaries)[number]>('.ft-summary-gap')
+          .data(result.summaries, (s) => String(s.cap))
+          .join('text')
+          .attr('class', 'ft-summary-gap')
+          .attr('x', (s) => center(s.cap))
+          .attr('y', ctx.height + 54)
+          .attr('text-anchor', 'middle')
+          .attr('font-size', px(CHART_TYPE.axisLabelSub))
+          .attr('font-weight', '600')
+          .style('fill', 'var(--foreground)')
+          .text((s) => (s.pctLower === null ? '' : t.lower(Math.round(s.pctLower * 100))));
+
+        let xTitle = g.select<SVGTextElement>('.ft-x-title');
+        if (xTitle.empty()) xTitle = g.append('text').attr('class', 'ft-x-title');
+        xTitle
+          .attr('x', ctx.width / 2)
+          .attr('y', ctx.height + 82)
+          .attr('text-anchor', 'middle')
+          .attr('font-size', px(CHART_TYPE.axisLabel))
+          .attr('font-weight', '600')
+          .style('fill', 'var(--foreground)')
+          .text(t.xTitle(ttftStat));
+      },
+      [result.summaries, hardwareConfig, t, ttftStat],
+    );
+
+    const tooltipStateRef = useRef({
+      hardwareConfig,
+      costType,
+      ttftStat,
+      interactivityStat,
+      runInfoByIndex,
+      locale,
+    });
+    tooltipStateRef.current = {
+      hardwareConfig,
+      costType,
+      ttftStat,
+      interactivityStat,
+      runInfoByIndex,
+      locale,
+    };
+    const hoveredBarWidthRef = useRef(0);
+
+    const tooltip = useMemo(
+      () => ({
+        rulerType: 'none' as const,
+        content: (bar: FirstTokenBar, isPinned: boolean) =>
+          generateFirstTokenTooltipHTML(bar, { ...tooltipStateRef.current, isPinned }),
+        getRulerX: () => hoveredBarWidthRef.current,
+        onHoverStart: (
+          selection: d3.Selection<SVGRectElement, FirstTokenBar, SVGGElement, unknown>,
+        ) => {
+          selection
+            .attr('opacity', 1)
+            .attr('stroke', 'var(--foreground)')
+            .attr('stroke-width', 1.5);
+        },
+        onHoverEnd: (
+          selection: d3.Selection<SVGRectElement, FirstTokenBar, SVGGElement, unknown>,
+        ) => {
+          selection.attr('opacity', 0.9).attr('stroke', 'none');
+        },
+        attachToLayer: 0,
+      }),
+      [],
+    );
+
+    const zoom = useMemo(() => ({ enabled: false }), []);
+
+    return (
+      <D3Chart<FirstTokenBar>
+        ref={chartRef}
+        chartId="first-token-limits"
+        data={bars}
+        height={HEIGHT}
+        margin={MARGIN}
+        watermark={getChartWatermark()}
+        testId="first-token-chart"
+        clipContent={false}
+        xScale={xScale}
+        yScale={yScale}
+        xAxis={xAxis}
+        yAxis={yAxis}
+        layers={layers}
+        zoom={zoom}
+        instructions={t.instructions}
+        tooltip={tooltip}
+        onRender={onRender}
+        legendElement={legendElement}
+        caption={caption}
+      />
+    );
+  },
+);
+FirstTokenLimitsChart.displayName = 'FirstTokenLimitsChart';
+
+export default FirstTokenLimitsChart;
diff --git a/packages/app/src/components/calculator/FirstTokenLimitsDisplay.tsx b/packages/app/src/components/calculator/FirstTokenLimitsDisplay.tsx
new file mode 100644
index 000000000..ac5a0338f
--- /dev/null
+++ b/packages/app/src/components/calculator/FirstTokenLimitsDisplay.tsx
@@ -0,0 +1,987 @@
+'use client';
+
+import { useCallback, useMemo, useState } from 'react';
+
+import { TCO_SOURCE_TITLE, TCO_SOURCE_URL } from '@semianalysisai/inferencex-constants';
+
+import {
+  resolveCalculatorVisibility,
+  type CalculatorVisibilityIntent,
+} from '@/components/calculator/ThroughputCalculatorDisplay';
+import type { CalculatorUrlSeed } from '@/components/calculator/url-seed';
+import {
+  GlobalFilterProvider,
+  useGlobalFilterActions,
+  useGlobalFilterAvailability,
+  useGlobalFilterRun,
+  useGlobalFilterSelection,
+} from '@/components/GlobalFilterContext';
+import {
+  includesJalapenoResult,
+  includesTpuv7Result,
+  includesVeraRubinResult,
+  JalapenoOfficialPreviewNotice,
+  Tpuv7OfficialPreviewNotice,
+  VeraRubinOfficialPreviewNotice,
+} from '@/components/official-preview-notice';
+import { Card } from '@/components/ui/card';
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { ChartShareActions } from '@/components/ui/chart-display-helpers';
+import ChartLegend from '@/components/ui/chart-legend';
+import {
+  ModelSelector,
+  PercentileSelector,
+  PrecisionSelector,
+  ScenarioSelector,
+} from '@/components/ui/chart-selectors';
+import { ControlPanel } from '@/components/ui/control-panel';
+import { DashboardSectionHeader } from '@/components/ui/dashboard-section-header';
+import { type DataTableColumn, DataTable } from '@/components/ui/data-table';
+import { ExternalLinkIcon } from '@/components/ui/external-link-icon';
+import { Heading } from '@/components/ui/heading';
+import { Input } from '@/components/ui/input';
+import { LabelWithTooltip } from '@/components/ui/label-with-tooltip';
+import { MultiSelect } from '@/components/ui/multi-select';
+import { Skeleton } from '@/components/ui/skeleton';
+import { TcoBasisToggle, useShowsTcoBasisSelector } from '@/components/ui/tco-basis-toggle';
+import { lockedCostProviderOptions, useLockedTierDialog } from '@/components/ui/tco-model-dialog';
+import { TooltipProvider } from '@/components/ui/tooltip';
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
+import { useOpenDropdown } from '@/hooks/useOpenDropdown';
+import { useThemeColors } from '@/hooks/useThemeColors';
+import { useUrlState } from '@/hooks/useUrlState';
+import { track } from '@/lib/analytics';
+import { getModelSortIndex } from '@/lib/constants';
+import { exportToCsv } from '@/lib/csv-export';
+import {
+  getModelLabel,
+  getSequenceLabel,
+  Percentile,
+  Sequence,
+  type Model,
+} from '@/lib/data-mappings';
+import { overlayRunColor } from '@/lib/overlay-run-style';
+import { readUrlParams, writeUrlParams } from '@/lib/url-state';
+import { useFeatureGate } from '@/lib/use-feature-gate';
+import { useLocale } from '@/lib/use-locale';
+import { getDisplayLabel } from '@/lib/utils';
+
+import {
+  DEFAULT_FIRST_TOKEN_CAPS,
+  DEFAULT_FIRST_TOKEN_MIN_INTERACTIVITY,
+  formatCap,
+  formatFirstTokenCaps,
+  parseFirstTokenCaps,
+  selectFirstTokenWinners,
+  ZH_MEDIAN,
+  zhStatPhrase,
+  type FirstTokenCell,
+} from './first-token-limits';
+import FirstTokenLimitsChart, { configLabel, formatCost } from './FirstTokenLimitsChart';
+import { getCostProviderLabel, getCostTypeLabel } from './ThroughputBarChart';
+import type { CostProvider, CostType } from './types';
+import { useThroughputData } from './useThroughputData';
+
+const COST_PROVIDER_OPTIONS: {
+  value: CostProvider;
+  label: string;
+  labelZh: string;
+}[] = [
+  {
+    value: 'costh',
+    label: 'Owning at Large Hyperscaler Volume',
+    labelZh: '自有 - 超大规模云大批量',
+  },
+  { value: 'costr', label: 'Rent - 3 Year Commit', labelZh: '租赁 - 3 年承诺' },
+];
+
+const COST_TYPE_OPTIONS: { value: CostType; label: string; labelZh: string }[] = [
+  { value: 'total', label: 'Total Tokens', labelZh: '总 Token' },
+  { value: 'input', label: 'Input Tokens', labelZh: '输入 Token' },
+  { value: 'output', label: 'Output Tokens', labelZh: '输出 Token' },
+];
+
+const STRINGS = {
+  en: {
+    title: 'First-Token Limits',
+    description:
+      'Which chip wins depends on how long a user may wait for the first token. For each cap on time to first token, this reads the measured configurations that also clear the interactivity floor and keeps the cheapest one per vendor. Measured rows only: no interpolation, and every bar links to the run behind it.',
+    benchmarkGroup: 'Benchmark Config',
+    chartGroup: 'Chart Config',
+    costProviderLabel: 'Cost Provider',
+    costProviderTooltip:
+      'The pricing tier the bars are costed at. Owning at large hyperscaler purchasing volume (e.g. AWS/GCP) or renting on a 3-year commit. Locked rental terms (on demand through 2 year commit) are published in the SemiAnalysis AI Cloud TCO Model.',
+    costProviderPlaceholder: 'Cost provider',
+    tokenTypeLabel: 'Token Type',
+    tokenTypeTooltip:
+      'Whether cost is per million total, input, or output tokens. Disaggregated configs report input and output throughput per prefill and per decode chip, so their input- and output-basis costs are not per chip overall.',
+    tokenTypePlaceholder: 'Token type',
+    minInteractivityLabel: (stat: string) => `Minimum ${stat} Interactivity (tok/s/user)`,
+    minInteractivityTooltip: (stat: string) =>
+      `Only rows whose ${stat} interactivity is at or above this floor are eligible. Set it to the streaming speed the workload needs; a cap on first-token wait is then applied on top.`,
+    capsLabel: 'TTFT Caps (s, comma-separated)',
+    capsTooltip:
+      'The ladder of maximum first-token waits to compare, in seconds. Each cap gets its own group of bars. Up to eight values.',
+    capsPlaceholder: formatFirstTokenCaps(DEFAULT_FIRST_TOKEN_CAPS),
+    highContrast: 'High Contrast',
+    errorLoading: 'Error loading data. Please try a different selection.',
+    noData:
+      'No measured data for the current selection. Try another model, workload, or precision.',
+    noneQualify: (min: number, stat: string) =>
+      `No measured configuration reaches ${min} tok/s/user ${stat} interactivity for this selection. Lower the floor to compare first-token limits.`,
+    noTtft: (stat: string) =>
+      `The measured rows for this selection report no ${stat} time to first token, so there is nothing to cap. Try another workload or run date.`,
+    noneUnderCaps: (cap: string, stat: string) =>
+      `Measured configurations clear the interactivity floor, but none delivers a ${stat} time to first token within the largest cap on this ladder (≤${cap}s). Raise a cap or add a looser one to compare first-token limits.`,
+    captionFloor: (min: number, stat: string) => `≥${min} tok/s/user ${stat} interactivity`,
+    captionRows: (qualifying: number, measured: number) =>
+      `${qualifying} of ${measured} measured rows clear the floor`,
+    captionSource: 'Source: SemiAnalysis InferenceX',
+    unofficialRun: 'Unofficial run',
+    note: 'Note:',
+    methodology: (ttftStat: string, ivStat: string) =>
+      ` Cost is $ per million tokens at 100% utilization from the SemiAnalysis AI Cloud TCO Model. The ${ivStat} interactivity floor and the ${ttftStat} time-to-first-token cap are separate percentile statistics on the same row: a row that clears both did so on each measure, which does not mean every individual request did. Bars are measured rows, not interpolated frontier points, so a cheaper configuration can sit just outside a cap and only appear under the next one.`,
+    source: 'Source: ',
+    colCap: 'TTFT cap (s)',
+    colSeries: 'Series',
+    colConfig: 'Configuration',
+    colPrecision: 'Precision',
+    colConcurrency: 'Concurrency',
+    colTp: 'TP',
+    colTtft: (stat: string) => `${stat} TTFT (s)`,
+    colInteractivity: (stat: string) => `${stat} interactivity (tok/s/user)`,
+    colCost: (unit: string) => `Cost ($${unit})`,
+    colRun: 'Run',
+    viewRun: 'View',
+  },
+  zh: {
+    title: '首 token 延迟约束',
+    description:
+      '哪款芯片最优，取决于用户能接受多长的首 token 等待。本页面按每一档首 token 延迟（TTFT）上限，从同时满足交互性下限的实测配置中，逐厂商选出成本最低的一个。仅使用实测数据，不做插值，每个柱形都可追溯到对应的运行记录。',
+    benchmarkGroup: '基准测试配置',
+    chartGroup: '图表配置',
+    costProviderLabel: '成本供应商',
+    costProviderTooltip:
+      '柱形成本采用的定价层级。按超大规模云厂商大批量采购价自有（如 AWS/GCP）或 3 年承诺租赁。带锁的租赁期限（按需至 2 年承诺）收录于 SemiAnalysis AI Cloud TCO 模型。',
+    costProviderPlaceholder: '成本供应商',
+    tokenTypeLabel: 'Token 类型',
+    tokenTypeTooltip:
+      '成本按每百万总 token、输入 token 还是输出 token 计。分离式配置的输入、输出吞吐量分别按 prefill 芯片和 decode 芯片统计，因此其输入、输出口径的成本并非按全部芯片计。',
+    tokenTypePlaceholder: 'Token 类型',
+    minInteractivityLabel: (stat: string) => `${zhStatPhrase('交互性', stat, '最低')} (tok/s/user)`,
+    minInteractivityTooltip: (stat: string) =>
+      `${zhStatPhrase('交互性', stat, '仅')}不低于该下限的数据行参与比较。请设为工作负载所需的流式输出速度，再在此基础上施加首 token 延迟上限。`,
+    capsLabel: 'TTFT 上限（秒，逗号分隔）',
+    capsTooltip:
+      '要对比的各档首 token 最长等待时间，单位为秒。每一档上限对应一组柱形，最多 8 个值。',
+    capsPlaceholder: formatFirstTokenCaps(DEFAULT_FIRST_TOKEN_CAPS),
+    highContrast: '高对比度',
+    errorLoading: '加载数据出错，请尝试其他选择。',
+    noData: '当前选择没有实测数据。请尝试其他模型、工作负载或精度。',
+    noneQualify: (min: number, stat: string) =>
+      `${zhStatPhrase('交互性', stat, '当前选择下没有实测配置的')}达到 ${min} tok/s/user。请降低下限后再比较首 token 延迟约束。`,
+    noTtft: (stat: string) =>
+      `${zhStatPhrase('首 token 延迟', stat, '当前选择的实测数据行未报告')}，无法施加上限。请尝试其他工作负载或运行日期。`,
+    noneUnderCaps: (cap: string, stat: string) =>
+      `${zhStatPhrase('首 token 延迟', stat, '实测配置达到了交互性下限，但没有任何配置的')}落在本梯度最大上限（≤${cap}s）之内。请提高或新增上限后再比较首 token 延迟约束。`,
+    captionFloor: (min: number, stat: string) =>
+      `${zhStatPhrase('交互性', stat)} ≥${min} tok/s/user`,
+    captionRows: (qualifying: number, measured: number) =>
+      `${measured} 行实测数据中有 ${qualifying} 行满足下限`,
+    captionSource: '来源：SemiAnalysis InferenceX',
+    unofficialRun: '非官方运行',
+    note: '注：',
+    methodology: (ttftStat: string, ivStat: string) =>
+      ` 成本为 100% 利用率下的每百万 token 成本，取自 SemiAnalysis AI Cloud TCO 模型。${zhStatPhrase('交互性', ivStat)}下限与${zhStatPhrase('首 token 延迟', ttftStat, '')}上限是同一数据行上两个独立的分位数统计：同时满足两者，表示该行在两项指标上分别达标，不代表每个请求都同时达标。柱形为实测数据行而非插值的前沿点，因此更便宜的配置可能刚好超出某一档上限，只出现在下一档中。`,
+    source: '来源：',
+    colCap: 'TTFT 上限 (s)',
+    colSeries: '系列',
+    colConfig: '配置',
+    colPrecision: '精度',
+    colConcurrency: '并发数',
+    colTp: 'TP',
+    colTtft: (stat: string) => `${zhStatPhrase('TTFT', stat)} (s)`,
+    colInteractivity: (stat: string) => `${zhStatPhrase('交互性', stat)} (tok/s/user)`,
+    colCost: (unit: string) => `成本 ($${unit})`,
+    colRun: '运行记录',
+    viewRun: '查看',
+  },
+} as const;
+
+const STAT_LABELS = {
+  en: { median: 'Median' },
+  zh: { median: ZH_MEDIAN },
+} as const;
+
+interface FirstTokenRow {
+  key: string;
+  cap: number;
+  series: string;
+  config: string;
+  precision: string;
+  concurrency: number;
+  tp: number;
+  ttft: number;
+  interactivity: number;
+  cost: number;
+  runUrl: string | null;
+}
+
+export default function FirstTokenLimitsDisplay({ urlSeed }: { urlSeed?: CalculatorUrlSeed }) {
+  return (
+    <GlobalFilterProvider
+      initialModel={urlSeed?.model}
+      initialSequence={urlSeed?.sequence}
+      initialPrecisions={urlSeed?.precisions}
+      initialRunDate={urlSeed?.runDate}
+      initialRunId={urlSeed?.runId}
+    >
+      <FirstTokenLimitsInner initialPercentile={urlSeed?.percentile ?? Percentile.P90} />
+    </GlobalFilterProvider>
+  );
+}
+
+function FirstTokenLimitsInner({ initialPercentile }: { initialPercentile: Percentile }) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const { setUrlParam } = useUrlState();
+  const { openDropdown, handleDropdownOpenChange } = useOpenDropdown();
+  const { interceptLocked: interceptLockedTier, dialog: tcoModelDialog } = useLockedTierDialog(
+    'first_token_cost_provider',
+  );
+
+  const {
+    tcoBasis,
+    selectedModel,
+    effectiveSequence: selectedSequence,
+    effectivePrecisions: selectedPrecisions,
+  } = useGlobalFilterSelection();
+  const showsTcoBasis = useShowsTcoBasisSelector();
+  const { setSelectedModel, setSelectedSequence, setSelectedPrecisions } = useGlobalFilterActions();
+  const { selectedRunDate } = useGlobalFilterRun();
+  const { availablePrecisions, availableSequences, availableModels } =
+    useGlobalFilterAvailability();
+
+  const [costProvider, setCostProvider] = useState<CostProvider>('costh');
+  const [costType, setCostType] = useState<CostType>('total');
+  const [selectedPercentile, setSelectedPercentile] = useState<Percentile>(initialPercentile);
+  const [visibilityIntent, setVisibilityIntent] = useState<CalculatorVisibilityIntent | null>(null);
+  const [highContrast, setHighContrast] = useState(false);
+  const [isLegendExpanded, setIsLegendExpanded] = useState(true);
+  // Both inputs are URL-seeded so an article can link the exact figure. Empty
+  // means "use the sequence-aware default", which is why the defaults are not
+  // written into the URL.
+  const [minInteractivityInput, setMinInteractivityInput] = useState<string>(
+    () => readUrlParams().c_ivmin ?? '',
+  );
+  const [capsInput, setCapsInput] = useState<string>(() => readUrlParams().c_ttft ?? '');
+
+  // Unofficial-run overlay (`?unofficialrun=…`): each loaded run gets its own
+  // bar per cap, chosen from its own rows only, in the run's palette color.
+  const { isUnofficialRun, unofficialBenchmarkRows, unofficialRunInfos, runIndexByUrl } =
+    useUnofficialRun();
+  const overlayInput = useMemo(
+    () => ({ rows: unofficialBenchmarkRows, runIndexByUrl }),
+    [unofficialBenchmarkRows, runIndexByUrl],
+  );
+
+  const {
+    gpuDataByGroupKey,
+    gpuGroupMeta,
+    overlayGpuDataByGroupKey,
+    overlayGroupMeta,
+    hardwareConfig,
+    loading,
+    error,
+    hasData,
+    hasOverlayData,
+    availableHwKeys,
+    overlayAvailableHwKeys,
+  } = useThroughputData(
+    selectedModel,
+    selectedSequence,
+    selectedPrecisions,
+    selectedRunDate,
+    overlayInput,
+    selectedPercentile,
+    undefined,
+    true,
+    costType,
+    tcoBasis,
+  );
+
+  const isAgenticSequence = selectedSequence === Sequence.AgenticTraces;
+  const featureGateUnlocked = useFeatureGate();
+  // Agentic rows are read at the selected percentile; fixed sequences at the
+  // median, the same split as the inference chart's interactivity and TTFT axes.
+  const statLabel = isAgenticSequence
+    ? selectedPercentile.toUpperCase()
+    : STAT_LABELS[locale].median;
+
+  const defaultMinInteractivity = isAgenticSequence
+    ? DEFAULT_FIRST_TOKEN_MIN_INTERACTIVITY.agentic
+    : DEFAULT_FIRST_TOKEN_MIN_INTERACTIVITY.fixed;
+  const minInteractivity = useMemo(() => {
+    const parsed = Number.parseFloat(minInteractivityInput);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : defaultMinInteractivity;
+  }, [minInteractivityInput, defaultMinInteractivity]);
+  const caps = useMemo(
+    () => parseFirstTokenCaps(capsInput) ?? [...DEFAULT_FIRST_TOKEN_CAPS],
+    [capsInput],
+  );
+
+  // One legend governs a chip's official and overlay bars together; overlay-only
+  // hardware is merged in so its bar can be hidden. See docs/tco-calculator.md.
+  const legendHwKeys = useMemo(() => {
+    if (!isUnofficialRun || overlayAvailableHwKeys.length === 0) return availableHwKeys;
+    return [...new Set([...availableHwKeys, ...overlayAvailableHwKeys])];
+  }, [isUnofficialRun, availableHwKeys, overlayAvailableHwKeys]);
+
+  const selectionKey = `${selectedModel}|${selectedSequence}|${[...selectedPrecisions]
+    .toSorted()
+    .join(',')}|${selectedRunDate}|${[...availableHwKeys].toSorted().join(',')}`;
+
+  const visibleHwKeys = useMemo(
+    () => resolveCalculatorVisibility(visibilityIntent, selectionKey, legendHwKeys),
+    [visibilityIntent, selectionKey, legendHwKeys],
+  );
+  const visibleKeysArray = useMemo(() => [...visibleHwKeys], [visibleHwKeys]);
+  const { resolveColor } = useThemeColors({ highContrast, activeKeys: visibleKeysArray });
+
+  const runInfoByIndex = useMemo(() => {
+    const map: Record<number, { branch: string; url: string }> = {};
+    unofficialRunInfos.forEach((info, idx) => {
+      map[idx] = { branch: info.branch || `run ${info.id}`, url: info.url };
+    });
+    return map;
+  }, [unofficialRunInfos]);
+  const overlayLabels = useMemo(
+    () =>
+      Object.fromEntries(Object.entries(runInfoByIndex).map(([idx, info]) => [idx, info.branch])),
+    [runInfoByIndex],
+  );
+
+  const result = useMemo(
+    () =>
+      selectFirstTokenWinners({
+        official: gpuDataByGroupKey,
+        officialMeta: gpuGroupMeta,
+        overlay: overlayGpuDataByGroupKey,
+        overlayMeta: overlayGroupMeta,
+        overlayLabels,
+        caps,
+        minInteractivity,
+        costProvider,
+        costType,
+        visibleHwKeys,
+      }),
+    [
+      gpuDataByGroupKey,
+      gpuGroupMeta,
+      overlayGpuDataByGroupKey,
+      overlayGroupMeta,
+      overlayLabels,
+      caps,
+      minInteractivity,
+      costProvider,
+      costType,
+      visibleHwKeys,
+    ],
+  );
+  const hasAnyData = hasData || hasOverlayData;
+  const hasBars = result.cells.some((cell) => cell.winner !== null);
+
+  const handleModelChange = useCallback(
+    (value: string) => {
+      setVisibilityIntent(null);
+      setSelectedModel(value as Model);
+      track('first_token_model_selected', { model: value });
+    },
+    [setSelectedModel],
+  );
+  const handleSequenceChange = useCallback(
+    (value: string) => {
+      setVisibilityIntent(null);
+      setSelectedSequence(value as Sequence);
+      track('first_token_sequence_selected', { sequence: value });
+    },
+    [setSelectedSequence],
+  );
+  const handlePrecisionChange = useCallback(
+    (value: string[]) => {
+      setVisibilityIntent(null);
+      setSelectedPrecisions(value);
+      track('first_token_precision_selected', { precision: value.join(',') });
+    },
+    [setSelectedPrecisions],
+  );
+  const handlePercentileChange = useCallback(
+    (value: Percentile) => {
+      setSelectedPercentile(value);
+      setUrlParam('i_pctl', value);
+      track('first_token_percentile_selected', { percentile: value });
+    },
+    [setUrlParam],
+  );
+
+  const handleMinInteractivityChange = useCallback((raw: string) => {
+    setMinInteractivityInput(raw);
+    const parsed = Number.parseFloat(raw);
+    writeUrlParams({ c_ivmin: Number.isFinite(parsed) && parsed >= 0 ? raw : '' });
+  }, []);
+  const handleMinInteractivityBlur = useCallback(() => {
+    track('first_token_min_interactivity_set', { value: minInteractivity });
+  }, [minInteractivity]);
+
+  const handleCapsChange = useCallback((raw: string) => {
+    setCapsInput(raw);
+    const parsed = parseFirstTokenCaps(raw);
+    writeUrlParams({ c_ttft: parsed ? formatFirstTokenCaps(parsed) : '' });
+  }, []);
+  const handleCapsBlur = useCallback(() => {
+    // Normalize what was typed to the ladder actually in use, so the field and
+    // the chart agree; an unusable entry falls back to the default ladder.
+    const parsed = parseFirstTokenCaps(capsInput);
+    setCapsInput(parsed ? formatFirstTokenCaps(parsed) : '');
+    track('first_token_caps_set', { caps: formatFirstTokenCaps(caps) });
+  }, [capsInput, caps]);
+
+  const toggleGpuVisibility = useCallback(
+    (hwKey: string) => {
+      const visibleLegendKeys = legendHwKeys.filter((key) => visibleHwKeys.has(key));
+      const allVisible = visibleLegendKeys.length === legendHwKeys.length;
+      const isVisible = visibleHwKeys.has(hwKey);
+      let next: Set<string>;
+      if (isVisible && allVisible) {
+        next = new Set([hwKey]);
+      } else if (isVisible && visibleLegendKeys.length === 1) {
+        next = new Set(legendHwKeys);
+      } else {
+        next = new Set(visibleHwKeys);
+        if (isVisible) next.delete(hwKey);
+        else next.add(hwKey);
+      }
+      setVisibilityIntent({ scopeKey: selectionKey, visible: next, known: new Set(legendHwKeys) });
+      track('first_token_gpu_toggled', { gpu: hwKey });
+    },
+    [legendHwKeys, visibleHwKeys, selectionKey],
+  );
+  const removeGpu = useCallback(
+    (hwKey: string) => {
+      const next = new Set(visibleHwKeys);
+      next.delete(hwKey);
+      setVisibilityIntent({ scopeKey: selectionKey, visible: next, known: new Set(legendHwKeys) });
+      track('first_token_gpu_removed', { gpu: hwKey });
+    },
+    [visibleHwKeys, selectionKey, legendHwKeys],
+  );
+
+  const legendItems = useMemo(() => {
+    const availableSet = new Set(legendHwKeys);
+    const runItems = result.series
+      .filter((series) => series.runIndex !== undefined)
+      .map((series) => {
+        const info = unofficialRunInfos[series.runIndex!];
+        return {
+          name: `✕ unofficial-run-${info?.id ?? series.runIndex}`,
+          label: series.label,
+          color: overlayRunColor(series.runIndex!),
+          title: `${t.unofficialRun}: ${series.label}`,
+          hw: `overlay-run-${info?.id ?? series.runIndex}`,
+          isActive: true,
+          // A label for the run, not a series the legend can hide: per-run
+          // removal lives in the unofficial-run banner.
+          isRemovable: false,
+          onClick: () => {},
+        };
+      });
+    return [
+      ...runItems,
+      ...Object.entries(hardwareConfig)
+        .filter(([key]) => availableSet.has(key))
+        .toSorted(([a], [b]) => getModelSortIndex(a) - getModelSortIndex(b) || a.localeCompare(b))
+        .map(([key, config]) => ({
+          name: config.name,
+          label: getDisplayLabel(config),
+          color: resolveColor(key),
+          title: config.gpu,
+          hw: key,
+          isActive: visibleHwKeys.has(key),
+          onClick: () => toggleGpuVisibility(key),
+        })),
+    ];
+  }, [
+    legendHwKeys,
+    result.series,
+    unofficialRunInfos,
+    hardwareConfig,
+    visibleHwKeys,
+    resolveColor,
+    toggleGpuVisibility,
+    t,
+  ]);
+
+  const costUnit = getCostTypeLabel(costType);
+  const tableRows = useMemo<FirstTokenRow[]>(
+    () =>
+      result.cells.flatMap((cell: FirstTokenCell) => {
+        if (!cell.winner) return [];
+        const { winner } = cell;
+        const runUrl =
+          winner.runIndex === undefined
+            ? (winner.point.sourceRow?.run_url ?? null)
+            : (runInfoByIndex[winner.runIndex]?.url ?? null);
+        return [
+          {
+            key: `${cell.cap}|${cell.series.key}`,
+            cap: cell.cap,
+            series: cell.series.label,
+            config: configLabel(winner.hwKey, hardwareConfig),
+            precision: winner.precision.toUpperCase(),
+            concurrency: winner.point.concurrency,
+            tp: winner.point.tp,
+            ttft: winner.ttft,
+            interactivity: winner.interactivity,
+            cost: winner.cost,
+            runUrl,
+          },
+        ];
+      }),
+    [result.cells, hardwareConfig, runInfoByIndex],
+  );
+
+  const columns = useMemo<DataTableColumn<FirstTokenRow>[]>(
+    () => [
+      {
+        header: t.colCap,
+        cell: (r) => r.cap,
+        sortValue: (r) => r.cap,
+        align: 'right',
+        pinned: true,
+      },
+      { header: t.colSeries, cell: (r) => r.series, sortValue: (r) => r.series },
+      { header: t.colConfig, cell: (r) => r.config, sortValue: (r) => r.config },
+      { header: t.colPrecision, cell: (r) => r.precision, sortValue: (r) => r.precision },
+      {
+        header: t.colConcurrency,
+        cell: (r) => r.concurrency,
+        sortValue: (r) => r.concurrency,
+        align: 'right',
+      },
+      { header: t.colTp, cell: (r) => r.tp, sortValue: (r) => r.tp, align: 'right' },
+      {
+        header: t.colTtft(statLabel),
+        cell: (r) => r.ttft.toFixed(2),
+        sortValue: (r) => r.ttft,
+        align: 'right',
+      },
+      {
+        header: t.colInteractivity(statLabel),
+        cell: (r) => r.interactivity.toFixed(1),
+        sortValue: (r) => r.interactivity,
+        align: 'right',
+      },
+      {
+        header: t.colCost(costUnit),
+        cell: (r) => formatCost(r.cost),
+        sortValue: (r) => r.cost,
+        align: 'right',
+      },
+      {
+        header: t.colRun,
+        cell: (r) =>
+          r.runUrl ? (
+            <a
+              href={r.runUrl}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="text-primary underline underline-offset-2"
+              onClick={() => track('first_token_run_link_clicked')}
+            >
+              {t.viewRun}
+              <ExternalLinkIcon />
+            </a>
+          ) : (
+            '—'
+          ),
+      },
+    ],
+    [t, statLabel, costUnit],
+  );
+
+  const handleExportCsv = useCallback(() => {
+    const headers = [
+      t.colCap,
+      t.colSeries,
+      t.colConfig,
+      t.colPrecision,
+      t.colConcurrency,
+      t.colTp,
+      t.colTtft(statLabel),
+      t.colInteractivity(statLabel),
+      t.colCost(costUnit),
+      t.colRun,
+    ];
+    const body = tableRows.map((r) => [
+      r.cap,
+      r.series,
+      r.config,
+      r.precision,
+      r.concurrency,
+      r.tp,
+      r.ttft,
+      r.interactivity,
+      r.cost,
+      r.runUrl ?? '',
+    ]);
+    exportToCsv(`InferenceX_first_token_limits_${selectedModel}.csv`, headers, body, [
+      `${getModelLabel(selectedModel)} • ${getSequenceLabel(selectedSequence, locale)}`,
+      t.captionFloor(minInteractivity, statLabel),
+      getCostProviderLabel(costProvider, locale),
+    ]);
+    track('first_token_csv_exported', { model: selectedModel });
+  }, [
+    t,
+    statLabel,
+    costUnit,
+    tableRows,
+    selectedModel,
+    selectedSequence,
+    locale,
+    minInteractivity,
+    costProvider,
+  ]);
+
+  const showsJalapenoPreview = includesJalapenoResult(legendHwKeys);
+  const showsVeraRubinPreview = includesVeraRubinResult(legendHwKeys);
+  const showsTpuv7Preview = includesTpuv7Result(legendHwKeys);
+
+  const caption = (
+    <>
+      <Heading as="h2" level="card">
+        {t.title}
+      </Heading>
+      <p className="text-sm text-muted-foreground mb-2">
+        {getModelLabel(selectedModel)} • {getSequenceLabel(selectedSequence, locale)} •{' '}
+        {t.captionFloor(minInteractivity, statLabel)} • {getCostProviderLabel(costProvider, locale)}{' '}
+        • {t.captionRows(result.qualifyingRows, result.measuredRows)} • {t.captionSource}
+      </p>
+    </>
+  );
+
+  const legendElement = (
+    <ChartLegend
+      variant="sidebar"
+      legendItems={legendItems}
+      onItemRemove={removeGpu}
+      isLegendExpanded={isLegendExpanded}
+      onExpandedChange={(expanded) => {
+        setIsLegendExpanded(expanded);
+        track('first_token_legend_expanded', { expanded });
+      }}
+      switches={[
+        {
+          id: 'first-token-high-contrast',
+          label: t.highContrast,
+          checked: highContrast,
+          onCheckedChange: (checked: boolean) => {
+            setHighContrast(checked);
+            track('first_token_high_contrast_toggled', { enabled: checked });
+          },
+        },
+      ]}
+    />
+  );
+
+  if (!loading && error) {
+    console.error(error);
+    return (
+      <Card>
+        <div className="flex items-center justify-center h-64 text-muted-foreground">
+          {t.errorLoading}
+        </div>
+      </Card>
+    );
+  }
+
+  return (
+    <div className="flex flex-col gap-4">
+      <section data-testid="first-token-controls">
+        <Card className="relative z-30">
+          <div className="flex flex-col gap-4">
+            <DashboardSectionHeader
+              title={t.title}
+              description={t.description}
+              actions={<ChartShareActions />}
+            />
+
+            <TooltipProvider delayDuration={0}>
+              <ControlPanel
+                legend={t.benchmarkGroup}
+                data-testid="first-token-benchmark-panel"
+                className={`grid-cols-1 md:grid-cols-2 ${
+                  isAgenticSequence && featureGateUnlocked ? 'lg:grid-cols-5' : 'lg:grid-cols-4'
+                }`}
+              >
+                <div className="min-w-0 md:col-span-2">
+                  <ModelSelector
+                    id="first-token-model"
+                    data-testid="first-token-model-selector"
+                    value={selectedModel}
+                    onChange={handleModelChange}
+                    open={openDropdown === 'model'}
+                    onOpenChange={handleDropdownOpenChange('model')}
+                    availableModels={availableModels}
+                  />
+                </div>
+                <ScenarioSelector
+                  id="first-token-sequence"
+                  data-testid="first-token-sequence-selector"
+                  value={selectedSequence}
+                  onChange={handleSequenceChange}
+                  open={openDropdown === 'sequence'}
+                  onOpenChange={handleDropdownOpenChange('sequence')}
+                  availableSequences={availableSequences}
+                  model={selectedModel}
+                />
+                {isAgenticSequence && featureGateUnlocked && (
+                  <PercentileSelector
+                    id="first-token-percentile"
+                    data-testid="first-token-percentile-selector"
+                    value={selectedPercentile}
+                    onChange={handlePercentileChange}
+                  />
+                )}
+                <PrecisionSelector
+                  id="first-token-precision"
+                  data-testid="first-token-precision-selector"
+                  value={selectedPrecisions}
+                  onChange={handlePrecisionChange}
+                  open={openDropdown === 'precision'}
+                  onOpenChange={handleDropdownOpenChange('precision')}
+                  availablePrecisions={availablePrecisions}
+                />
+              </ControlPanel>
+
+              <ControlPanel
+                legend={t.chartGroup}
+                data-testid="first-token-chart-panel"
+                className="grid-cols-1 md:grid-cols-2 xl:grid-cols-4"
+              >
+                <div className="flex min-w-0 flex-col space-y-1.5">
+                  <LabelWithTooltip
+                    htmlFor="first-token-cost"
+                    label={t.costProviderLabel}
+                    tooltip={t.costProviderTooltip}
+                  />
+                  <div data-testid="first-token-cost-selector">
+                    <MultiSelect
+                      triggerId="first-token-cost"
+                      options={[
+                        ...COST_PROVIDER_OPTIONS.map((provider) => ({
+                          value: provider.value,
+                          label: locale === 'zh' ? provider.labelZh : provider.label,
+                        })),
+                        ...lockedCostProviderOptions(locale),
+                      ]}
+                      value={[costProvider]}
+                      onChange={(values) => {
+                        const next = values[0];
+                        if (!next) return;
+                        if (interceptLockedTier(next)) return;
+                        setCostProvider(next as CostProvider);
+                        track('first_token_cost_provider_changed', { provider: next });
+                      }}
+                      open={openDropdown === 'costProvider'}
+                      onOpenChange={handleDropdownOpenChange('costProvider')}
+                      placeholder={t.costProviderPlaceholder}
+                      minSelections={1}
+                      maxSelections={1}
+                      showClearAll={false}
+                      searchable={false}
+                      plainSelectedText
+                      showSelectionSummary={false}
+                    />
+                  </div>
+                </div>
+
+                <div className="flex min-w-0 flex-col space-y-1.5">
+                  <LabelWithTooltip
+                    htmlFor="first-token-cost-type"
+                    label={t.tokenTypeLabel}
+                    tooltip={t.tokenTypeTooltip}
+                  />
+                  <div data-testid="first-token-cost-type-selector">
+                    <MultiSelect
+                      triggerId="first-token-cost-type"
+                      options={COST_TYPE_OPTIONS.map((ct) => ({
+                        value: ct.value,
+                        label: locale === 'zh' ? ct.labelZh : ct.label,
+                      }))}
+                      value={[costType]}
+                      onChange={(values) => {
+                        const next = values[0];
+                        if (!next) return;
+                        setCostType(next as CostType);
+                        track('first_token_cost_type_changed', { costType: next });
+                      }}
+                      open={openDropdown === 'costType'}
+                      onOpenChange={handleDropdownOpenChange('costType')}
+                      placeholder={t.tokenTypePlaceholder}
+                      minSelections={1}
+                      maxSelections={1}
+                      showClearAll={false}
+                      searchable={false}
+                      plainSelectedText
+                      showSelectionSummary={false}
+                    />
+                  </div>
+                </div>
+
+                <div className="flex min-w-0 flex-col space-y-1.5">
+                  <LabelWithTooltip
+                    htmlFor="first-token-min-interactivity"
+                    label={t.minInteractivityLabel(statLabel)}
+                    tooltip={t.minInteractivityTooltip(statLabel)}
+                  />
+                  <Input
+                    id="first-token-min-interactivity"
+                    data-testid="first-token-min-interactivity"
+                    type="number"
+                    inputMode="decimal"
+                    min={0}
+                    step={5}
+                    placeholder={String(defaultMinInteractivity)}
+                    value={minInteractivityInput}
+                    onChange={(e) => handleMinInteractivityChange(e.target.value)}
+                    onBlur={handleMinInteractivityBlur}
+                  />
+                </div>
+
+                <div className="flex min-w-0 flex-col space-y-1.5">
+                  <LabelWithTooltip
+                    htmlFor="first-token-caps"
+                    label={t.capsLabel}
+                    tooltip={t.capsTooltip}
+                  />
+                  <Input
+                    id="first-token-caps"
+                    data-testid="first-token-caps"
+                    type="text"
+                    inputMode="decimal"
+                    placeholder={t.capsPlaceholder}
+                    value={capsInput}
+                    onChange={(e) => handleCapsChange(e.target.value)}
+                    onBlur={handleCapsBlur}
+                  />
+                </div>
+
+                {showsTcoBasis && (
+                  <div className="flex min-w-0 max-w-48 flex-col space-y-1.5">
+                    <LabelWithTooltip
+                      label={locale === 'zh' ? 'TCO 口径' : 'TCO Basis'}
+                      tooltip={
+                        locale === 'zh'
+                          ? '外部客户价格或内部持有成本；目前仅影响 TPUv7。'
+                          : 'External customer pricing or internal owner cost; currently affects only TPUv7.'
+                      }
+                    />
+                    <TcoBasisToggle source="first_token" className="md:h-9" />
+                  </div>
+                )}
+              </ControlPanel>
+            </TooltipProvider>
+          </div>
+        </Card>
+      </section>
+
+      {loading && (
+        <Card>
+          <Skeleton className="h-64 w-full" />
+        </Card>
+      )}
+
+      {!loading && !hasAnyData && (
+        <Card>
+          <div
+            className="flex items-center justify-center h-64 text-muted-foreground text-center px-6"
+            data-testid="first-token-no-data"
+          >
+            {t.noData}
+          </div>
+        </Card>
+      )}
+
+      {!loading && hasAnyData && (
+        <Card>
+          <figure data-testid="first-token-figure" className="relative rounded-lg">
+            <ChartButtons
+              chartId="first-token-limits"
+              analyticsPrefix="first_token"
+              hideZoomReset
+              onExportCsv={handleExportCsv}
+              exportFileName={`InferenceX_first_token_limits_${selectedModel}`}
+            />
+            {showsJalapenoPreview && <JalapenoOfficialPreviewNotice />}
+            {showsVeraRubinPreview && <VeraRubinOfficialPreviewNotice />}
+            {showsTpuv7Preview && <Tpuv7OfficialPreviewNotice />}
+            {hasBars ? (
+              <FirstTokenLimitsChart
+                result={result}
+                hardwareConfig={hardwareConfig}
+                costType={costType}
+                ttftStat={statLabel}
+                interactivityStat={statLabel}
+                colorResolver={resolveColor}
+                runInfoByIndex={runInfoByIndex}
+                legendElement={legendElement}
+                caption={caption}
+              />
+            ) : (
+              <>
+                <figcaption>{caption}</figcaption>
+                <div
+                  className="flex items-center justify-center h-48 text-muted-foreground text-center px-6"
+                  data-testid="first-token-none-qualify"
+                >
+                  {result.measuredRows + result.overlayMeasuredRows === 0
+                    ? t.noTtft(statLabel)
+                    : result.qualifyingRows + result.overlayQualifyingRows === 0
+                      ? t.noneQualify(minInteractivity, statLabel)
+                      : t.noneUnderCaps(formatCap(Math.max(...caps)), statLabel)}
+                </div>
+              </>
+            )}
+          </figure>
+
+          <p className="mt-4 text-xs text-muted-foreground">
+            <strong>{t.note}</strong>
+            {t.methodology(statLabel, statLabel)} {t.source}
+            <a
+              href={TCO_SOURCE_URL}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="underline underline-offset-2 hover:text-foreground"
+            >
+              {TCO_SOURCE_TITLE}
+              <ExternalLinkIcon />
+            </a>
+          </p>
+
+          {tableRows.length > 0 && (
+            <div className="mt-4">
+              <DataTable
+                data={tableRows}
+                columns={columns}
+                testId="first-token-table"
+                analyticsPrefix="first_token_table"
+                searchable={false}
+              />
+            </div>
+          )}
+        </Card>
+      )}
+      {tcoModelDialog}
+    </div>
+  );
+}
diff --git a/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx b/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx
index a3bef4ea9..a5367a87b 100644
--- a/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx
+++ b/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx
@@ -302,7 +302,7 @@ const STRINGS = {
     compareHistory: 'Compare history',
     gpuConfig: 'Chip Config',
     gpuConfigTooltip: `Select up to ${PROFIT_HISTORY_MAX_GPUS} chip configurations to compare how their estimated revenue and profit have moved over time. Each config is priced again on every compared date (the ends of the date range, plus any date or run added from the Config Changelog below) using the run measured then, so software updates show up as a change in the bar.`,
-    gpuConfigPlaceholder: 'Select a Chip Config for comparison',
+    gpuConfigPlaceholder: 'Select Chip Config',
     comparisonDateRange: 'Comparison Date Range',
     comparisonDateRangeTooltip:
       'Select the start and end dates for the historical comparison. The chart adds a bar for each selected chip config at both dates, next to its bar for the run date shown above. Dates in between can be added one at a time from the Config Changelog.',
@@ -416,7 +416,7 @@ const STRINGS = {
     compareHistory: '对比历史趋势',
     gpuConfig: '芯片配置',
     gpuConfigTooltip: `最多选择 ${PROFIT_HISTORY_MAX_GPUS} 个芯片配置，对比其收入与利润估算随时间的变化。每个配置都会用当日实测的运行结果，在每个对比日期（日期范围的起止两端，以及从下方配置变更日志中添加的日期或运行）重新估价，软件更新带来的差异会直接体现在柱形上。`,
-    gpuConfigPlaceholder: '选择芯片配置进行对比',
+    gpuConfigPlaceholder: '选择芯片配置',
     comparisonDateRange: '对比日期范围',
     comparisonDateRangeTooltip:
       '选择历史对比的起止日期。图表会在上方所示运行日期的柱形旁，为所选芯片配置在这两个日期各增加一根柱形。范围内的其他日期可在配置变更日志中逐个添加。',
diff --git a/packages/app/src/components/calculator/cache-reuse.test.ts b/packages/app/src/components/calculator/cache-reuse.test.ts
new file mode 100644
index 000000000..589d572a7
--- /dev/null
+++ b/packages/app/src/components/calculator/cache-reuse.test.ts
@@ -0,0 +1,288 @@
+import { describe, expect, it } from 'vitest';
+
+import type { BenchmarkRow } from '@/lib/api';
+
+import {
+  buildCacheReuse,
+  cacheShareOf,
+  defaultCacheReuseGroup,
+  formatShare,
+  tieredRowCount,
+} from './cache-reuse';
+import type { GPUDataPoint } from './types';
+
+function makeRow(overrides: Partial<BenchmarkRow> = {}): BenchmarkRow {
+  return {
+    id: 1,
+    hardware: 'b200',
+    framework: 'sglang',
+    model: 'glm5.2',
+    precision: 'fp4',
+    spec_method: 'none',
+    disagg: false,
+    is_multinode: false,
+    prefill_tp: 8,
+    decode_tp: 8,
+    num_prefill_gpu: 8,
+    num_decode_gpu: 8,
+    isl: null,
+    osl: null,
+    conc: 8,
+    offload_mode: 'on',
+    benchmark_type: 'agentic_traces',
+    image: 'sglang:test',
+    metrics: {},
+    workers: null,
+    date: '2026-09-17',
+    run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/1',
+    ...overrides,
+  } as BenchmarkRow;
+}
+
+function makePoint(
+  metrics: Record<string, number>,
+  row: Partial<BenchmarkRow> = {},
+  point: Partial<GPUDataPoint> = {},
+): GPUDataPoint {
+  return {
+    hwKey: `${row.hardware ?? 'b200'}_${row.framework ?? 'sglang'}`,
+    interactivity: 100,
+    throughput: 1000,
+    outputThroughput: 300,
+    inputThroughput: 700,
+    concurrency: row.conc ?? 8,
+    tp: 8,
+    precision: 'fp4',
+    costh: 0.1,
+    costr: 0.2,
+    costhi: 0.05,
+    costri: 0.1,
+    costhOutput: 0.3,
+    costrOutput: 0.6,
+    tpPerMw: 0,
+    inputTpPerMw: 0,
+    outputTpPerMw: 0,
+    sourceRow: makeRow({ ...row, metrics }),
+    ...point,
+  } as GPUDataPoint;
+}
+
+describe('cacheShareOf', () => {
+  it('reproduces the article: B200 + SGLang at concurrency 8, 12, 16', () => {
+    // Live GLM-5.2 rows, 2026-09-17. The article rounds the remainder to one decimal.
+    const rows = [
+      [8, 0.903, 0.06, 0.056],
+      [12, 0.765, 0.192, 0.123],
+      [16, 0.548, 0.403, 0.368],
+    ] as const;
+    const shares = rows.map(([conc, gpu, cpu, external]) =>
+      cacheShareOf(
+        makePoint(
+          {
+            server_gpu_cache_hit_rate: gpu,
+            server_cpu_cache_hit_rate: cpu,
+            server_external_cache_hit_rate: external,
+          },
+          { conc },
+        ),
+      ),
+    );
+    // The CPU-offload figure is the HiCache host tier the article plots; the
+    // router's external figure is reported too and must not be added on top.
+    expect(shares.map((s) => s?.hostSource)).toEqual(['cpu', 'cpu', 'cpu']);
+    expect(shares.map((s) => formatShare(s!.hbm))).toEqual(['90.3%', '76.5%', '54.8%']);
+    expect(shares.map((s) => formatShare(s!.host))).toEqual(['6.0%', '19.2%', '40.3%']);
+    expect(shares.map((s) => formatShare(s!.unreused))).toEqual(['3.7%', '4.3%', '4.9%']);
+  });
+
+  it('falls back to the external tier when no CPU rate is reported', () => {
+    const share = cacheShareOf(
+      makePoint({ server_gpu_cache_hit_rate: 0.7, server_external_cache_hit_rate: 0.2 }),
+    );
+    expect(share).toMatchObject({ hbm: 0.7, host: 0.2, hostSource: 'external', combined: false });
+    expect(share!.unreused).toBeCloseTo(0.1);
+  });
+
+  it('draws TensorRT-LLM with offload as one combined reused segment', () => {
+    const share = cacheShareOf(
+      makePoint(
+        { server_gpu_cache_hit_rate: 0.85, server_cpu_cache_hit_rate: 0.3 },
+        { framework: 'trt', offload_mode: 'on' },
+      ),
+    );
+    expect(share).toMatchObject({ hbm: 0.85, host: 0, combined: true, hostSource: null });
+    expect(share!.unreused).toBeCloseTo(0.15);
+  });
+
+  it('keeps TensorRT-LLM without offload as a plain HBM figure', () => {
+    const share = cacheShareOf(
+      makePoint({ server_gpu_cache_hit_rate: 0.9 }, { framework: 'trt', offload_mode: 'off' }),
+    );
+    expect(share).toMatchObject({ hbm: 0.9, host: 0, combined: false });
+  });
+
+  it('reads the canonical offload descriptor over the legacy mode flag', () => {
+    const share = cacheShareOf(
+      makePoint(
+        {
+          server_gpu_cache_hit_rate: 0.8,
+          server_cpu_cache_hit_rate: 0.1,
+          // The descriptor is a string inside the numeric metrics bag on real rows.
+          kv_offloading: 'none' as unknown as number,
+        },
+        { framework: 'trt', offload_mode: 'on' },
+      ),
+    );
+    expect(share!.combined).toBe(false);
+  });
+
+  it('clamps an over-reported runtime figure and keeps the raw total for the caveat', () => {
+    // GB300 Dynamo rows report 1.012 on occasion.
+    const share = cacheShareOf(makePoint({ server_gpu_cache_hit_rate: 1.012 }));
+    expect(share).toMatchObject({ hbm: 1, host: 0, unreused: 0 });
+    expect(share!.reportedTotal).toBeCloseTo(1.012);
+
+    const both = cacheShareOf(
+      makePoint({ server_gpu_cache_hit_rate: 0.9, server_external_cache_hit_rate: 0.3 }),
+    );
+    expect(both!.host).toBeCloseTo(0.1);
+    expect(both!.unreused).toBe(0);
+    expect(both!.reportedTotal).toBeCloseTo(1.2);
+  });
+
+  it('carries the theoretical ceiling and returns null without any tier', () => {
+    expect(
+      cacheShareOf(makePoint({ server_gpu_cache_hit_rate: 0.5, theoretical_cache_hit_rate: 0.97 }))!
+        .theoretical,
+    ).toBe(0.97);
+    // A GB300 row scraped only at the frontend: ceiling but no measured tier.
+    expect(cacheShareOf(makePoint({ theoretical_cache_hit_rate: 0.97 }))).toBeNull();
+    expect(cacheShareOf(makePoint({ tput_per_gpu: 100 }))).toBeNull();
+    expect(
+      cacheShareOf({ ...makePoint({ server_gpu_cache_hit_rate: 0.5 }), sourceRow: undefined }),
+    ).toBeNull();
+  });
+});
+
+describe('buildCacheReuse', () => {
+  const official = [
+    makePoint({ server_gpu_cache_hit_rate: 0.9, server_cpu_cache_hit_rate: 0.05 }, { conc: 8 }),
+    makePoint({ server_gpu_cache_hit_rate: 0.7, server_cpu_cache_hit_rate: 0.2 }, { conc: 16 }),
+    makePoint({ tput_per_gpu: 1 }, { conc: 32 }),
+  ];
+  const config = { hwKey: 'b200_sglang' };
+
+  it('lists one official bar per concurrency and reports rows without tiers', () => {
+    const result = buildCacheReuse({ official, config });
+    expect(result.series).toEqual([{ key: 'official', label: 'official' }]);
+    expect(result.concurrencies).toEqual([8, 16, 32]);
+    expect(result.bars.map((b) => [b.concurrency, b.share.hbm])).toEqual([
+      [8, 0.9],
+      [16, 0.7],
+    ]);
+    expect(result.unmeasured).toMatchObject([{ seriesKey: 'official', concurrency: 32 }]);
+    expect(result.anyCombined).toBe(false);
+  });
+
+  it('adds each unofficial run on the same hardware as its own series', () => {
+    const result = buildCacheReuse({
+      official,
+      config,
+      overlay: {
+        b200_sglang__run0: [
+          makePoint(
+            { server_gpu_cache_hit_rate: 0.95, server_cpu_cache_hit_rate: 0.02 },
+            { conc: 8 },
+          ),
+          makePoint({ server_gpu_cache_hit_rate: 0.6 }, { conc: 24 }),
+        ],
+        // Another chip in the same run: not this configuration, so not drawn.
+        mi355x_sglang__run0: [
+          makePoint({ server_gpu_cache_hit_rate: 0.5 }, { hardware: 'mi355x' }),
+        ],
+        b200_sglang__run1: [makePoint({ server_gpu_cache_hit_rate: 0.8 }, { conc: 8 })],
+      },
+      overlayMeta: {
+        b200_sglang__run0: { hwKey: 'b200_sglang', runIndex: 0 },
+        mi355x_sglang__run0: { hwKey: 'mi355x_sglang', runIndex: 0 },
+        b200_sglang__run1: { hwKey: 'b200_sglang', runIndex: 1 },
+      },
+      overlayLabels: { 0: 'perf/hicache' },
+    });
+    expect(result.series.map((s) => s.key)).toEqual(['official', 'run:0', 'run:1']);
+    expect(result.series[1]).toMatchObject({ label: '✕ perf/hicache', runIndex: 0 });
+    expect(result.series[2].label).toBe('✕ run 2');
+    expect(result.concurrencies).toEqual([8, 16, 24, 32]);
+    expect(result.bars.filter((b) => b.seriesKey === 'run:0').map((b) => b.concurrency)).toEqual([
+      8, 24,
+    ]);
+    expect(result.bars.find((b) => b.seriesKey === 'run:0' && b.concurrency === 8)?.runIndex).toBe(
+      0,
+    );
+  });
+
+  it('gives an overlay-only configuration the full bar width', () => {
+    const result = buildCacheReuse({
+      official: [],
+      config: { hwKey: 'mi355x_sglang' },
+      overlay: {
+        mi355x_sglang__run0: [
+          makePoint({ server_gpu_cache_hit_rate: 0.5 }, { hardware: 'mi355x', conc: 8 }),
+        ],
+      },
+      overlayMeta: { mi355x_sglang__run0: { hwKey: 'mi355x_sglang', runIndex: 0 } },
+    });
+    expect(result.series.map((s) => s.key)).toEqual(['run:0']);
+    expect(result.bars.map((b) => b.seriesKey)).toEqual(['run:0']);
+    expect(result.unmeasured).toEqual([]);
+  });
+
+  it('matches overlay groups on precision when the page splits by precision', () => {
+    const result = buildCacheReuse({
+      official,
+      config: { hwKey: 'b200_sglang', precision: 'fp4' },
+      overlay: {
+        b200_sglang__fp8__run0: [makePoint({ server_gpu_cache_hit_rate: 0.5 }, { conc: 8 })],
+        b200_sglang__fp4__run0: [makePoint({ server_gpu_cache_hit_rate: 0.6 }, { conc: 8 })],
+      },
+      overlayMeta: {
+        b200_sglang__fp8__run0: { hwKey: 'b200_sglang', precision: 'fp8', runIndex: 0 },
+        b200_sglang__fp4__run0: { hwKey: 'b200_sglang', precision: 'fp4', runIndex: 0 },
+      },
+    });
+    expect(result.bars.filter((b) => b.seriesKey === 'run:0')).toHaveLength(1);
+    expect(result.bars.find((b) => b.seriesKey === 'run:0')?.share.hbm).toBe(0.6);
+  });
+});
+
+describe('defaultCacheReuseGroup', () => {
+  const tiered = (n: number, hardware: string, framework: string) =>
+    Array.from({ length: n }, (_, i) =>
+      makePoint({ server_gpu_cache_hit_rate: 0.5 }, { hardware, framework, conc: i + 1 }),
+    );
+
+  it('opens on the configuration with the most tiered rows', () => {
+    const groups = {
+      b300_sglang: tiered(3, 'b300', 'sglang'),
+      b200_vllm: tiered(5, 'b200', 'vllm'),
+    };
+    const meta = { b300_sglang: { hwKey: 'b300_sglang' }, b200_vllm: { hwKey: 'b200_vllm' } };
+    expect(defaultCacheReuseGroup(groups, meta)).toBe('b200_vllm');
+  });
+
+  it('prefers SGLang on a tie and returns null when nothing reports a tier', () => {
+    const groups = {
+      b200_trt: tiered(4, 'b200', 'trt'),
+      b200_sglang: tiered(4, 'b200', 'sglang'),
+      h100_sglang: [makePoint({ tput_per_gpu: 1 }, { hardware: 'h100' })],
+    };
+    const meta = {
+      b200_trt: { hwKey: 'b200_trt' },
+      b200_sglang: { hwKey: 'b200_sglang' },
+      h100_sglang: { hwKey: 'h100_sglang' },
+    };
+    expect(defaultCacheReuseGroup(groups, meta)).toBe('b200_sglang');
+    expect(tieredRowCount(groups.h100_sglang)).toBe(0);
+    expect(defaultCacheReuseGroup({ h100_sglang: groups.h100_sglang }, meta)).toBeNull();
+  });
+});
diff --git a/packages/app/src/components/calculator/cache-reuse.ts b/packages/app/src/components/calculator/cache-reuse.ts
new file mode 100644
index 000000000..70537cfec
--- /dev/null
+++ b/packages/app/src/components/calculator/cache-reuse.ts
@@ -0,0 +1,227 @@
+import { frameworkFamily } from '@/lib/framework-family';
+import { isKvOffloadEnabled } from '@/lib/kv-offload';
+
+import type { GPUDataPoint } from './types';
+import type { GroupMeta, OverlayGroupMeta } from './useThroughputData';
+
+/**
+ * Prefix-cache reuse: where a configuration's prompt tokens came from at each
+ * concurrency — HBM (the chip's own KV cache), the host tier behind it, or
+ * nowhere (recomputed) — as shares of all prompt tokens.
+ *
+ * Every bar is one measured row. The host segment is the CPU-offload rate
+ * (HiCache and its peers report host-memory hits there) and falls back to the
+ * router's external rate only when a row reports no CPU figure. This differs
+ * from `measuredCacheHitRate`, which prices cached input conservatively by
+ * preferring the external figure: that guards a revenue number against
+ * double-counting, whereas this chart names the tier a token was served from,
+ * and on SGLang rows the host figure is the CPU one. Both tiers are never
+ * summed here, so the bar cannot double count.
+ *
+ * TensorRT-LLM with offload enabled reports HBM and host as one combined figure
+ * (the point summary labels it "Combined chip + CPU"), so those rows draw one
+ * reused segment rather than inventing a split the data does not have.
+ */
+
+export type CacheTier = 'hbm' | 'host' | 'unreused';
+
+/** Tier colors, fixed rather than per-hardware: the bars compare tiers, not chips. */
+export const CACHE_TIER_COLORS: Record<CacheTier, string> = {
+  hbm: '#3f9fe0',
+  host: '#f2b13a',
+  unreused: '#5f6672',
+};
+
+export interface CacheShare {
+  /** Prompt tokens served from the chip's KV cache, 0..1. */
+  hbm: number;
+  /** Prompt tokens served from the host tier (CPU offload, else the router's external cache), 0..1. */
+  host: number;
+  /** Prompt tokens recomputed, 0..1; the three shares sum to 1. */
+  unreused: number;
+  /** The runtime folded host hits into the HBM figure, so `hbm` is both tiers. */
+  combined: boolean;
+  hostSource: 'cpu' | 'external' | null;
+  /** Infinite-cache ceiling from the trace itself, when the row carries one. */
+  theoretical: number | null;
+  /** Reported tiers summed before clamping; above 1 the runtime over-reported. */
+  reportedTotal: number;
+}
+
+const finite = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isFinite(value);
+const clamp01 = (value: number) => Math.max(0, Math.min(1, value));
+
+/** Prompt-token shares for one row, or null when the runtime reported no tier at all. */
+export function cacheShareOf(point: GPUDataPoint): CacheShare | null {
+  const row = point.sourceRow;
+  if (!row) return null;
+  const m = row.metrics;
+  const gpu = m.server_gpu_cache_hit_rate;
+  const external = m.server_external_cache_hit_rate;
+  const cpu = m.server_cpu_cache_hit_rate;
+  if (!finite(gpu) && !finite(external) && !finite(cpu)) return null;
+
+  const offloadOn = isKvOffloadEnabled({
+    kv_offloading: typeof m.kv_offloading === 'string' ? m.kv_offloading : null,
+    offload_mode: row.offload_mode,
+  });
+  const combined = offloadOn && frameworkFamily(row.framework) === 'trt';
+
+  const hostSource: CacheShare['hostSource'] = combined
+    ? null
+    : finite(cpu)
+      ? 'cpu'
+      : finite(external)
+        ? 'external'
+        : null;
+  const hostRaw = hostSource === 'cpu' ? cpu! : hostSource === 'external' ? external! : 0;
+  const hbm = clamp01(finite(gpu) ? gpu : 0);
+  const host = Math.max(0, Math.min(1 - hbm, hostRaw));
+
+  return {
+    hbm,
+    host,
+    unreused: Math.max(0, 1 - hbm - host),
+    combined,
+    hostSource,
+    theoretical: finite(m.theoretical_cache_hit_rate)
+      ? clamp01(m.theoretical_cache_hit_rate)
+      : null,
+    reportedTotal: (finite(gpu) ? gpu : 0) + hostRaw,
+  };
+}
+
+export interface CacheReuseSeries {
+  /** `official`, or `run:<index>` for an unofficial run. */
+  key: string;
+  label: string;
+  runIndex?: number;
+}
+
+export interface CacheReuseBar {
+  key: string;
+  concurrency: number;
+  seriesKey: string;
+  runIndex?: number;
+  point: GPUDataPoint;
+  share: CacheShare;
+}
+
+export interface CacheReuseResult {
+  series: CacheReuseSeries[];
+  /** Ascending, the union across series. */
+  concurrencies: number[];
+  bars: CacheReuseBar[];
+  /** Rows of the chosen configuration that reported no cache tier, per series. */
+  unmeasured: { seriesKey: string; concurrency: number; point: GPUDataPoint }[];
+  anyCombined: boolean;
+}
+
+export interface CacheReuseInput {
+  official: readonly GPUDataPoint[];
+  /** Every overlay group; only those on the same hardware (and precision) are read. */
+  overlay?: Record<string, GPUDataPoint[]>;
+  overlayMeta?: Record<string, OverlayGroupMeta>;
+  overlayLabels?: Record<number, string>;
+  /** The chosen configuration, matched against overlay group metadata. */
+  config: GroupMeta;
+}
+
+/**
+ * The stacked bars for one configuration: its official rows, plus each loaded
+ * unofficial run's rows on the same hardware as their own series, so a branch
+ * can be read against the published curve concurrency by concurrency.
+ */
+export function buildCacheReuse(input: CacheReuseInput): CacheReuseResult {
+  // A configuration that exists only in a loaded run has no official slot;
+  // listing one anyway would halve every run bar beside an empty column.
+  const series: CacheReuseSeries[] =
+    input.official.length > 0 ? [{ key: 'official', label: 'official' }] : [];
+  const perSeries = new Map<string, readonly GPUDataPoint[]>([['official', input.official]]);
+
+  const runIndexes = new Set<number>();
+  for (const [groupKey, meta] of Object.entries(input.overlayMeta ?? {})) {
+    if (meta.hwKey !== input.config.hwKey) continue;
+    if (input.config.precision !== undefined && meta.precision !== input.config.precision) continue;
+    const points = input.overlay?.[groupKey];
+    if (!points || points.length === 0) continue;
+    runIndexes.add(meta.runIndex);
+    const key = `run:${meta.runIndex}`;
+    perSeries.set(key, [...(perSeries.get(key) ?? []), ...points]);
+  }
+  for (const runIndex of [...runIndexes].toSorted((a, b) => a - b)) {
+    series.push({
+      key: `run:${runIndex}`,
+      label: `✕ ${input.overlayLabels?.[runIndex] ?? `run ${runIndex + 1}`}`,
+      runIndex,
+    });
+  }
+
+  const bars: CacheReuseBar[] = [];
+  const unmeasured: CacheReuseResult['unmeasured'] = [];
+  const concurrencies = new Set<number>();
+  for (const entry of series) {
+    // One bar per concurrency: the latest official row is already unique per
+    // (config, concurrency); a run that repeats one keeps its first row.
+    const seen = new Set<number>();
+    for (const point of perSeries.get(entry.key) ?? []) {
+      if (seen.has(point.concurrency)) continue;
+      seen.add(point.concurrency);
+      concurrencies.add(point.concurrency);
+      const share = cacheShareOf(point);
+      if (!share) {
+        unmeasured.push({ seriesKey: entry.key, concurrency: point.concurrency, point });
+        continue;
+      }
+      bars.push({
+        key: `${point.concurrency}|${entry.key}`,
+        concurrency: point.concurrency,
+        seriesKey: entry.key,
+        ...(entry.runIndex === undefined ? {} : { runIndex: entry.runIndex }),
+        point,
+        share,
+      });
+    }
+  }
+
+  return {
+    series,
+    concurrencies: [...concurrencies].toSorted((a, b) => a - b),
+    bars,
+    unmeasured,
+    anyCombined: bars.some((b) => b.share.combined),
+  };
+}
+
+export function tieredRowCount(points: readonly GPUDataPoint[]): number {
+  return points.filter((p) => cacheShareOf(p) !== null).length;
+}
+
+/**
+ * The configuration the page opens on: the one with the most rows reporting
+ * cache tiers, preferring an SGLang-family config on a tie because SGLang
+ * separates HBM from host hits. Null when no group reports any tier.
+ */
+export function defaultCacheReuseGroup(
+  groups: Record<string, GPUDataPoint[]>,
+  meta: Record<string, GroupMeta>,
+): string | null {
+  let best: { key: string; tiered: number; sglang: boolean } | null = null;
+  for (const [key, points] of Object.entries(groups)) {
+    const tiered = tieredRowCount(points);
+    if (tiered === 0) continue;
+    const sglang = frameworkFamily(meta[key]?.hwKey ?? key) === 'sglang';
+    if (
+      best === null ||
+      tiered > best.tiered ||
+      (tiered === best.tiered && sglang && !best.sglang) ||
+      (tiered === best.tiered && sglang === best.sglang && key.localeCompare(best.key) < 0)
+    ) {
+      best = { key, tiered, sglang };
+    }
+  }
+  return best?.key ?? null;
+}
+
+export const formatShare = (share: number): string => `${(share * 100).toFixed(1)}%`;
diff --git a/packages/app/src/components/calculator/first-token-limits.test.ts b/packages/app/src/components/calculator/first-token-limits.test.ts
new file mode 100644
index 000000000..71555e967
--- /dev/null
+++ b/packages/app/src/components/calculator/first-token-limits.test.ts
@@ -0,0 +1,324 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  compareVendors,
+  DEFAULT_FIRST_TOKEN_CAPS,
+  formatFirstTokenCaps,
+  hardwareVendor,
+  MAX_FIRST_TOKEN_CAPS,
+  parseFirstTokenCaps,
+  selectFirstTokenWinners,
+  UNKNOWN_VENDOR,
+  ZH_MEDIAN,
+  zhStatPhrase,
+  formatCap,
+} from './first-token-limits';
+import type { GPUDataPoint } from './types';
+
+function makePoint(overrides: Partial<GPUDataPoint> = {}): GPUDataPoint {
+  return {
+    hwKey: 'b200_sglang',
+    interactivity: 160,
+    ttft: 1.5,
+    throughput: 1000,
+    outputThroughput: 300,
+    inputThroughput: 700,
+    concurrency: 8,
+    tp: 8,
+    precision: 'fp4',
+    costh: 0.1,
+    costr: 0.2,
+    costhi: 0.05,
+    costri: 0.1,
+    costhOutput: 0.3,
+    costrOutput: 0.6,
+    tpPerMw: 1000,
+    inputTpPerMw: 700,
+    outputTpPerMw: 300,
+    ...overrides,
+  };
+}
+
+const CAPS = [2, 5, 10];
+
+/** The article's Figure 3 shape: B200 wins tight caps, GB300 wins looser ones. */
+const OFFICIAL = {
+  b200_sglang: [
+    makePoint({ hwKey: 'b200_sglang', ttft: 1.6, costh: 0.067 }),
+    // Cheaper but too slow to start — must only appear under caps ≥ 5 s.
+    makePoint({ hwKey: 'b200_sglang', ttft: 4.2, costh: 0.06 }),
+  ],
+  'gb300_dynamo-trt': [
+    makePoint({ hwKey: 'gb300_dynamo-trt', ttft: 8.9, costh: 0.045 }),
+    // Fails the interactivity floor: never eligible, however cheap.
+    makePoint({ hwKey: 'gb300_dynamo-trt', ttft: 0.9, costh: 0.01, interactivity: 90 }),
+  ],
+  mi355x_sglang: [makePoint({ hwKey: 'mi355x_sglang', ttft: 1.4, costh: 0.127 })],
+};
+const OFFICIAL_META = {
+  b200_sglang: { hwKey: 'b200_sglang' },
+  'gb300_dynamo-trt': { hwKey: 'gb300_dynamo-trt' },
+  mi355x_sglang: { hwKey: 'mi355x_sglang' },
+};
+
+const select = (extra: Partial<Parameters<typeof selectFirstTokenWinners>[0]> = {}) =>
+  selectFirstTokenWinners({
+    official: OFFICIAL,
+    officialMeta: OFFICIAL_META,
+    caps: CAPS,
+    minInteractivity: 150,
+    costProvider: 'costh',
+    costType: 'total',
+    ...extra,
+  });
+
+const winnerOf = (
+  result: ReturnType<typeof selectFirstTokenWinners>,
+  cap: number,
+  seriesKey: string,
+) => result.cells.find((c) => c.cap === cap && c.series.key === seriesKey)?.winner ?? null;
+
+describe('formatCap', () => {
+  it('prints caps the way the axis ticks do', () => {
+    expect([2, 0.5, 1 / 3].map(formatCap)).toEqual(['2', '0.5', '0.33']);
+  });
+});
+
+describe('parseFirstTokenCaps', () => {
+  it('parses, de-duplicates, sorts, and drops junk', () => {
+    expect(parseFirstTokenCaps('10, 2,5,2,abc,-1,0')).toEqual([2, 5, 10]);
+  });
+
+  it('returns null when nothing is usable so callers fall back to the default', () => {
+    expect(parseFirstTokenCaps('')).toBeNull();
+    expect(parseFirstTokenCaps(undefined)).toBeNull();
+    expect(parseFirstTokenCaps('x,y')).toBeNull();
+  });
+
+  it('caps the ladder length', () => {
+    const many = Array.from({ length: MAX_FIRST_TOKEN_CAPS + 4 }, (_, i) => i + 1).join(',');
+    expect(parseFirstTokenCaps(many)).toHaveLength(MAX_FIRST_TOKEN_CAPS);
+  });
+
+  it('round-trips the default ladder through the URL form', () => {
+    expect(parseFirstTokenCaps(formatFirstTokenCaps(DEFAULT_FIRST_TOKEN_CAPS))).toEqual([
+      ...DEFAULT_FIRST_TOKEN_CAPS,
+    ]);
+  });
+});
+
+describe('zhStatPhrase', () => {
+  it('puts the median after its noun and a percentile before it', () => {
+    expect(zhStatPhrase('交互性', ZH_MEDIAN)).toBe('交互性中位数');
+    expect(zhStatPhrase('TTFT', ZH_MEDIAN)).toBe('TTFT 中位数');
+    expect(zhStatPhrase('交互性', 'P90')).toBe('P90 交互性');
+  });
+
+  it('spaces the phrase off the preceding text only when it starts with Latin', () => {
+    expect(zhStatPhrase('交互性', 'P90', '最低')).toBe('最低 P90 交互性');
+    expect(zhStatPhrase('交互性', ZH_MEDIAN, '最低')).toBe('最低交互性中位数');
+  });
+});
+
+describe('hardwareVendor', () => {
+  it('reads the vendor off the registry base key, whatever the framework suffix', () => {
+    expect(hardwareVendor('b200_dynamo-sglang')).toBe('NVIDIA');
+    expect(hardwareVendor('gb300-dynamo-trt')).toBe('NVIDIA');
+    expect(hardwareVendor('mi355x_atom')).toBe('AMD');
+    expect(hardwareVendor('tpuv7_vllm')).toBe('Google');
+  });
+
+  it('falls back for hardware the registry does not know', () => {
+    expect(hardwareVendor('mystery_sglang')).toBe(UNKNOWN_VENDOR);
+  });
+
+  it('orders NVIDIA, then AMD, then everyone else alphabetically', () => {
+    expect(['Google', 'AMD', 'OpenAI', 'NVIDIA'].toSorted(compareVendors)).toEqual([
+      'NVIDIA',
+      'AMD',
+      'Google',
+      'OpenAI',
+    ]);
+  });
+});
+
+describe('selectFirstTokenWinners', () => {
+  it('lists one official series per vendor, NVIDIA first', () => {
+    expect(select().series.map((s) => s.key)).toEqual(['vendor:NVIDIA', 'vendor:AMD']);
+  });
+
+  it('picks the cheapest row under each cap that also clears the interactivity floor', () => {
+    const result = select();
+    // Under 2 s only the fast B200 row qualifies for NVIDIA; the cheap GB300
+    // row is too slow to start and the cheaper-still GB300 row is below 150 tok/s.
+    expect(winnerOf(result, 2, 'vendor:NVIDIA')).toMatchObject({
+      hwKey: 'b200_sglang',
+      cost: 0.067,
+    });
+    // At 5 s the slower-to-start, cheaper B200 row takes over.
+    expect(winnerOf(result, 5, 'vendor:NVIDIA')).toMatchObject({
+      hwKey: 'b200_sglang',
+      cost: 0.06,
+    });
+    // At 10 s GB300 finally clears the cap and is cheapest of all.
+    expect(winnerOf(result, 10, 'vendor:NVIDIA')).toMatchObject({
+      hwKey: 'gb300_dynamo-trt',
+      cost: 0.045,
+    });
+    for (const cap of CAPS) {
+      expect(winnerOf(result, cap, 'vendor:AMD')).toMatchObject({
+        hwKey: 'mi355x_sglang',
+        cost: 0.127,
+      });
+    }
+  });
+
+  it('summarizes the cross-vendor gap as a fraction of the runner-up', () => {
+    const [two, , ten] = select().summaries;
+    expect(two.best?.hwKey).toBe('b200_sglang');
+    expect(two.runnerUp?.hwKey).toBe('mi355x_sglang');
+    expect(two.pctLower).toBeCloseTo((0.127 - 0.067) / 0.127, 10);
+    expect(ten.best?.hwKey).toBe('gb300_dynamo-trt');
+    expect(ten.pctLower).toBeCloseTo((0.127 - 0.045) / 0.127, 10);
+  });
+
+  it('leaves a vendor column empty rather than dropping the vendor when nothing qualifies', () => {
+    const result = select({ caps: [1] });
+    expect(result.series.map((s) => s.key)).toEqual(['vendor:NVIDIA', 'vendor:AMD']);
+    expect(winnerOf(result, 1, 'vendor:NVIDIA')).toBeNull();
+    expect(winnerOf(result, 1, 'vendor:AMD')).toBeNull();
+    expect(result.summaries[0]).toMatchObject({ best: null, runnerUp: null, pctLower: null });
+  });
+
+  it('has no gap when only one vendor qualifies', () => {
+    const result = select({ minInteractivity: 155, official: { ...OFFICIAL, mi355x_sglang: [] } });
+    expect(result.summaries[0].best?.hwKey).toBe('b200_sglang');
+    expect(result.summaries[0].runnerUp).toBeNull();
+    expect(result.summaries[0].pctLower).toBeNull();
+  });
+
+  it('respects the legend: hidden hardware is not a candidate', () => {
+    const result = select({
+      visibleHwKeys: new Set(['gb300_dynamo-trt', 'mi355x_sglang']),
+    });
+    expect(winnerOf(result, 2, 'vendor:NVIDIA')).toBeNull();
+    expect(winnerOf(result, 10, 'vendor:NVIDIA')?.hwKey).toBe('gb300_dynamo-trt');
+  });
+
+  it('reads the cost for the selected pricing tier and token type', () => {
+    const rental = select({ costProvider: 'costr' });
+    expect(winnerOf(rental, 2, 'vendor:NVIDIA')?.cost).toBe(0.2);
+    const output = select({ costType: 'output' });
+    expect(winnerOf(output, 2, 'vendor:AMD')?.cost).toBe(0.3);
+  });
+
+  it('ignores rows with no usable first-token measurement', () => {
+    const result = select({
+      official: {
+        ...OFFICIAL,
+        b200_sglang: [
+          makePoint({ hwKey: 'b200_sglang', ttft: undefined, costh: 0.001 }),
+          makePoint({ hwKey: 'b200_sglang', ttft: 0, costh: 0.002 }),
+          makePoint({ hwKey: 'b200_sglang', ttft: Number.NaN, costh: 0.003 }),
+        ],
+      },
+    });
+    for (const cap of CAPS)
+      expect(winnerOf(result, cap, 'vendor:NVIDIA')?.hwKey).toBe(
+        cap >= 10 ? 'gb300_dynamo-trt' : undefined,
+      );
+    // The unreadable rows are not counted as measured either.
+    expect(result.measuredRows).toBe(3);
+  });
+
+  it('breaks cost ties toward the shorter first token, then the faster stream', () => {
+    const result = select({
+      official: {
+        a: [
+          makePoint({ hwKey: 'b200_sglang', ttft: 1.9, costh: 0.05, interactivity: 160 }),
+          makePoint({ hwKey: 'b200_sglang', ttft: 1.2, costh: 0.05, interactivity: 155 }),
+          makePoint({ hwKey: 'b200_sglang', ttft: 1.2, costh: 0.05, interactivity: 170 }),
+        ],
+      },
+      officialMeta: { a: { hwKey: 'b200_sglang' } },
+    });
+    expect(winnerOf(result, 2, 'vendor:NVIDIA')).toMatchObject({ ttft: 1.2, interactivity: 170 });
+  });
+
+  it('counts qualifying and measured rows for the subtitle', () => {
+    const result = select();
+    expect(result.measuredRows).toBe(5);
+    // The 90 tok/s GB300 row fails the floor.
+    expect(result.qualifyingRows).toBe(4);
+  });
+
+  describe('unofficial-run overlays', () => {
+    const OVERLAY = {
+      b200_sglang__run0: [makePoint({ hwKey: 'b200_sglang', ttft: 1.1, costh: 0.03 })],
+      mi355x_sglang__run0: [makePoint({ hwKey: 'mi355x_sglang', ttft: 1, costh: 0.02 })],
+      b300_sglang__run1: [makePoint({ hwKey: 'b300_sglang', ttft: 7, costh: 0.01 })],
+    };
+    const OVERLAY_META = {
+      b200_sglang__run0: { hwKey: 'b200_sglang', runIndex: 0 },
+      mi355x_sglang__run0: { hwKey: 'mi355x_sglang', runIndex: 0 },
+      b300_sglang__run1: { hwKey: 'b300_sglang', runIndex: 1 },
+    };
+
+    it('adds one series per run after the vendors, labelled with the branch', () => {
+      const result = select({
+        overlay: OVERLAY,
+        overlayMeta: OVERLAY_META,
+        overlayLabels: { 0: 'perf/faster-prefill' },
+      });
+      expect(result.series.map((s) => s.key)).toEqual([
+        'vendor:NVIDIA',
+        'vendor:AMD',
+        'run:0',
+        'run:1',
+      ]);
+      expect(result.series[2]).toMatchObject({ label: '✕ perf/faster-prefill', runIndex: 0 });
+      expect(result.series[3].label).toBe('✕ run 2');
+    });
+
+    it('picks a run’s cheapest qualifying row across every vendor it touched', () => {
+      const result = select({ overlay: OVERLAY, overlayMeta: OVERLAY_META });
+      expect(winnerOf(result, 2, 'run:0')).toMatchObject({ hwKey: 'mi355x_sglang', cost: 0.02 });
+      expect(winnerOf(result, 2, 'run:1')).toBeNull();
+      expect(winnerOf(result, 10, 'run:1')).toMatchObject({ hwKey: 'b300_sglang', runIndex: 1 });
+    });
+
+    it('never lets an overlay row into the official vendor bars or the gap summary', () => {
+      const result = select({ overlay: OVERLAY, overlayMeta: OVERLAY_META });
+      expect(winnerOf(result, 2, 'vendor:AMD')?.cost).toBe(0.127);
+      expect(result.summaries[0].best?.cost).toBe(0.067);
+    });
+
+    it('counts readable overlay rows separately so an overlay-only page is not "no TTFT"', () => {
+      const result = select({
+        official: {},
+        officialMeta: {},
+        overlay: {
+          b200_sglang__run0: [
+            makePoint({ hwKey: 'b200_sglang', ttft: 1, interactivity: 90 }),
+            makePoint({ hwKey: 'b200_sglang', ttft: 40, interactivity: 200 }),
+          ],
+        },
+        overlayMeta: { b200_sglang__run0: { hwKey: 'b200_sglang', runIndex: 0 } },
+      });
+      expect(result.measuredRows).toBe(0);
+      expect(result.overlayMeasuredRows).toBe(2);
+      expect(result.overlayQualifyingRows).toBe(1);
+      expect(winnerOf(result, 2, 'run:0')).toBeNull();
+    });
+
+    it('hides overlay rows for hardware the legend has switched off', () => {
+      const result = select({
+        overlay: OVERLAY,
+        overlayMeta: OVERLAY_META,
+        visibleHwKeys: new Set(['b200_sglang', 'gb300_dynamo-trt']),
+      });
+      expect(winnerOf(result, 2, 'run:0')).toMatchObject({ hwKey: 'b200_sglang', cost: 0.03 });
+      expect(result.series.map((s) => s.key)).not.toContain('run:1');
+    });
+  });
+});
diff --git a/packages/app/src/components/calculator/first-token-limits.ts b/packages/app/src/components/calculator/first-token-limits.ts
new file mode 100644
index 000000000..7b939b03a
--- /dev/null
+++ b/packages/app/src/components/calculator/first-token-limits.ts
@@ -0,0 +1,330 @@
+import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
+
+import { getCostField } from './interpolation';
+import type { CostProvider, CostType, GPUDataPoint } from './types';
+import type { GroupMeta, OverlayGroupMeta } from './useThroughputData';
+
+/**
+ * First-token limits: the cheapest *measured* configuration per vendor that
+ * clears an interactivity floor while keeping time-to-first-token under a cap.
+ *
+ * This deliberately reads measured rows, not the interpolated Pareto frontier
+ * the calculator uses. A TTFT cap is a hard operating constraint, and the
+ * frontier only tracks throughput against interactivity — a knot that
+ * interpolates cheaply at the target may sit between two rows whose first-token
+ * waits are seconds apart. Reading rows keeps every bar a configuration that
+ * actually ran under both constraints at once, which is also what an article
+ * can cite: a run URL, not a spline.
+ *
+ * The interactivity and TTFT filters are separate percentile statistics on the
+ * same row. Passing both says the row's p90 streaming speed and its p90 first
+ * token both cleared their bars, not that every individual request did.
+ */
+
+/** Default TTFT ladder, in seconds. */
+export const DEFAULT_FIRST_TOKEN_CAPS: readonly number[] = [2, 5, 10, 15, 20];
+
+/** Hard ceiling on ladder length so a pasted URL cannot render hundreds of groups. */
+export const MAX_FIRST_TOKEN_CAPS = 8;
+
+/**
+ * Interactivity floor the page opens on. AgentX publishes its cost comparisons
+ * at 150 tok/s/user; fixed sequences are read at the calculator's default.
+ */
+export const DEFAULT_FIRST_TOKEN_MIN_INTERACTIVITY = { agentic: 150, fixed: 35 } as const;
+
+/**
+ * Parse a comma-separated ladder such as `2,5,10`. Values are de-duplicated,
+ * sorted ascending, and capped at {@link MAX_FIRST_TOKEN_CAPS}. Returns null
+ * when nothing usable remains, so callers can fall back to the default.
+ */
+export function parseFirstTokenCaps(raw: string | null | undefined): number[] | null {
+  if (!raw) return null;
+  const caps = new Set<number>();
+  for (const part of raw.split(',')) {
+    const value = Number.parseFloat(part.trim());
+    if (Number.isFinite(value) && value > 0) caps.add(value);
+  }
+  if (caps.size === 0) return null;
+  return [...caps].toSorted((a, b) => a - b).slice(0, MAX_FIRST_TOKEN_CAPS);
+}
+
+export function formatFirstTokenCaps(caps: readonly number[]): string {
+  return caps.join(',');
+}
+
+/** Two decimals is as fine as a cap gets typed; `Number()` drops the zeros `toFixed` pads. */
+export function formatCap(cap: number): string {
+  return Number.isInteger(cap) ? String(cap) : String(Number(cap.toFixed(2)));
+}
+
+/** Chinese label of the median statistic; percentiles stay `P90` / `P75`. */
+export const ZH_MEDIAN = '中位数';
+
+/**
+ * Chinese names a statistic differently for the median and for a percentile:
+ * the median follows its noun (`交互性中位数`, `TTFT 中位数`) while a percentile
+ * precedes it (`P90 交互性`), the way the rest of the site writes them. `before`
+ * is the text the phrase continues; a space separates the two only when the
+ * phrase begins with Latin text, matching the site's CJK/Latin spacing.
+ */
+export function zhStatPhrase(noun: string, stat: string, before = ''): string {
+  const phrase =
+    stat === ZH_MEDIAN
+      ? `${noun}${/[A-Za-z]$/u.test(noun) ? ' ' : ''}${ZH_MEDIAN}`
+      : `${stat} ${noun}`;
+  const gap = before !== '' && /^[A-Za-z]/u.test(phrase) ? ' ' : '';
+  return `${before}${gap}${phrase}`;
+}
+
+/** Vendors shown first, in this order; any other vendor follows alphabetically. */
+const VENDOR_ORDER = ['NVIDIA', 'AMD'];
+
+export const UNKNOWN_VENDOR = 'Other';
+
+/** Vendor for a hardware key — `b200_dynamo-sglang` → `NVIDIA`. */
+export function hardwareVendor(hwKey: string): string {
+  const base = hwKey.split(/[-_]/u)[0];
+  return HW_REGISTRY[base]?.vendor ?? UNKNOWN_VENDOR;
+}
+
+export function compareVendors(a: string, b: string): number {
+  const ia = VENDOR_ORDER.indexOf(a);
+  const ib = VENDOR_ORDER.indexOf(b);
+  if (ia !== -1 || ib !== -1) {
+    if (ia === -1) return 1;
+    if (ib === -1) return -1;
+    return ia - ib;
+  }
+  return a.localeCompare(b);
+}
+
+/** One bar family: a vendor's official rows, or one unofficial run's rows. */
+export interface FirstTokenSeries {
+  /** `vendor:<name>` for official series, `run:<index>` for overlays. */
+  key: string;
+  label: string;
+  vendor?: string;
+  runIndex?: number;
+}
+
+/** The configuration a bar stands for. */
+export interface FirstTokenWinner {
+  seriesKey: string;
+  hwKey: string;
+  vendor: string;
+  precision: string;
+  /** $/M tokens at the selected pricing tier and token type. */
+  cost: number;
+  /** Seconds, at the percentile the page reads. */
+  ttft: number;
+  /** tok/s/user, at the percentile the page reads. */
+  interactivity: number;
+  point: GPUDataPoint;
+  runIndex?: number;
+}
+
+export interface FirstTokenCell {
+  cap: number;
+  series: FirstTokenSeries;
+  /** Null when nothing in the series cleared both constraints. */
+  winner: FirstTokenWinner | null;
+}
+
+/** How the official vendors compare under one cap. */
+export interface FirstTokenCapSummary {
+  cap: number;
+  best: FirstTokenWinner | null;
+  runnerUp: FirstTokenWinner | null;
+  /** `(runnerUp − best) / runnerUp`; null without two qualifying vendors. */
+  pctLower: number | null;
+}
+
+export interface FirstTokenResult {
+  series: FirstTokenSeries[];
+  cells: FirstTokenCell[];
+  summaries: FirstTokenCapSummary[];
+  /** Official rows that cleared the interactivity floor, before any TTFT cap. */
+  qualifyingRows: number;
+  /** Official rows the page could read at all: visible hardware with a TTFT. */
+  measuredRows: number;
+  /** Same, for the loaded unofficial runs; kept apart so the caption stays official-only. */
+  overlayMeasuredRows: number;
+  overlayQualifyingRows: number;
+}
+
+export interface FirstTokenSelectionInput {
+  official: Record<string, GPUDataPoint[]>;
+  officialMeta: Record<string, GroupMeta>;
+  overlay?: Record<string, GPUDataPoint[]>;
+  overlayMeta?: Record<string, OverlayGroupMeta>;
+  /** Branch (or fallback) label per run index, for the overlay series label. */
+  overlayLabels?: Record<number, string>;
+  caps: readonly number[];
+  minInteractivity: number;
+  costProvider: CostProvider;
+  costType: CostType;
+  /** Legend selection by base hwKey. Omit to consider every group. */
+  visibleHwKeys?: ReadonlySet<string>;
+}
+
+interface Candidate {
+  hwKey: string;
+  precision: string;
+  vendor: string;
+  cost: number;
+  ttft: number;
+  interactivity: number;
+  point: GPUDataPoint;
+  runIndex?: number;
+}
+
+function readable(point: GPUDataPoint): point is GPUDataPoint & { ttft: number } {
+  return typeof point.ttft === 'number' && Number.isFinite(point.ttft) && point.ttft > 0;
+}
+
+function collectCandidates(
+  groups: Record<string, GPUDataPoint[]>,
+  meta: Record<string, GroupMeta | OverlayGroupMeta>,
+  costProvider: CostProvider,
+  costType: CostType,
+  visibleHwKeys?: ReadonlySet<string>,
+): Candidate[] {
+  const out: Candidate[] = [];
+  for (const [groupKey, points] of Object.entries(groups)) {
+    const groupMeta = meta[groupKey];
+    const hwKey = groupMeta?.hwKey ?? groupKey;
+    if (visibleHwKeys && !visibleHwKeys.has(hwKey)) continue;
+    const runIndex = groupMeta && 'runIndex' in groupMeta ? groupMeta.runIndex : undefined;
+    const vendor = hardwareVendor(hwKey);
+    for (const point of points) {
+      if (!readable(point)) continue;
+      const cost = getCostField(point, costProvider, costType);
+      if (!Number.isFinite(cost) || cost <= 0) continue;
+      if (!Number.isFinite(point.interactivity)) continue;
+      out.push({
+        hwKey,
+        precision: point.precision,
+        vendor,
+        cost,
+        ttft: point.ttft,
+        interactivity: point.interactivity,
+        point,
+        ...(runIndex === undefined ? {} : { runIndex }),
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * Lower cost wins. Ties break toward the shorter first-token wait, then the
+ * faster stream, so a duplicate row cannot pick the worse-behaved twin.
+ */
+function betterCandidate(a: Candidate, b: Candidate): boolean {
+  if (a.cost !== b.cost) return a.cost < b.cost;
+  if (a.ttft !== b.ttft) return a.ttft < b.ttft;
+  return a.interactivity > b.interactivity;
+}
+
+function pickWinner(
+  candidates: readonly Candidate[],
+  cap: number,
+  minInteractivity: number,
+  seriesKey: string,
+): FirstTokenWinner | null {
+  let best: Candidate | null = null;
+  for (const candidate of candidates) {
+    if (candidate.ttft > cap || candidate.interactivity < minInteractivity) continue;
+    if (best === null || betterCandidate(candidate, best)) best = candidate;
+  }
+  return best ? { seriesKey, ...best } : null;
+}
+
+/**
+ * For every cap in the ladder, the cheapest measured configuration per vendor
+ * (and per loaded unofficial run) that cleared the interactivity floor with a
+ * first token under the cap.
+ */
+export function selectFirstTokenWinners(input: FirstTokenSelectionInput): FirstTokenResult {
+  const { caps, minInteractivity, costProvider, costType, visibleHwKeys } = input;
+
+  const official = collectCandidates(
+    input.official,
+    input.officialMeta,
+    costProvider,
+    costType,
+    visibleHwKeys,
+  );
+  const overlay = collectCandidates(
+    input.overlay ?? {},
+    input.overlayMeta ?? {},
+    costProvider,
+    costType,
+    visibleHwKeys,
+  );
+
+  // A vendor appears as soon as it has readable rows, even when none of them
+  // clear a cap: an empty column says "nothing measured under this limit",
+  // which is the finding, and hiding it would read as the vendor not existing.
+  const vendors = [...new Set(official.map((c) => c.vendor))].toSorted(compareVendors);
+  const byVendor = new Map<string, Candidate[]>();
+  for (const candidate of official) {
+    const list = byVendor.get(candidate.vendor) ?? [];
+    list.push(candidate);
+    byVendor.set(candidate.vendor, list);
+  }
+
+  const runIndexes = [
+    ...new Set(overlay.map((c) => c.runIndex).filter((idx): idx is number => idx !== undefined)),
+  ].toSorted((a, b) => a - b);
+  const byRun = new Map<number, Candidate[]>();
+  for (const candidate of overlay) {
+    if (candidate.runIndex === undefined) continue;
+    const list = byRun.get(candidate.runIndex) ?? [];
+    list.push(candidate);
+    byRun.set(candidate.runIndex, list);
+  }
+
+  const series: FirstTokenSeries[] = [
+    ...vendors.map((vendor) => ({ key: `vendor:${vendor}`, label: vendor, vendor })),
+    ...runIndexes.map((runIndex) => ({
+      key: `run:${runIndex}`,
+      label: `✕ ${input.overlayLabels?.[runIndex] ?? `run ${runIndex + 1}`}`,
+      runIndex,
+    })),
+  ];
+
+  const cells: FirstTokenCell[] = [];
+  const summaries: FirstTokenCapSummary[] = [];
+  for (const cap of caps) {
+    const officialWinners: FirstTokenWinner[] = [];
+    for (const entry of series) {
+      const candidates =
+        entry.vendor === undefined ? byRun.get(entry.runIndex!) : byVendor.get(entry.vendor);
+      const winner = pickWinner(candidates ?? [], cap, minInteractivity, entry.key);
+      cells.push({ cap, series: entry, winner });
+      if (winner && entry.vendor !== undefined) officialWinners.push(winner);
+    }
+    officialWinners.sort((a, b) => a.cost - b.cost);
+    const best = officialWinners[0] ?? null;
+    const runnerUp = officialWinners[1] ?? null;
+    summaries.push({
+      cap,
+      best,
+      runnerUp,
+      pctLower:
+        best && runnerUp && runnerUp.cost > 0 ? (runnerUp.cost - best.cost) / runnerUp.cost : null,
+    });
+  }
+
+  return {
+    series,
+    cells,
+    summaries,
+    qualifyingRows: official.filter((c) => c.interactivity >= minInteractivity).length,
+    measuredRows: official.length,
+    overlayMeasuredRows: overlay.length,
+    overlayQualifyingRows: overlay.filter((c) => c.interactivity >= minInteractivity).length,
+  };
+}
diff --git a/packages/app/src/components/calculator/types.ts b/packages/app/src/components/calculator/types.ts
index 1c2da8c95..9fec2ae52 100644
--- a/packages/app/src/components/calculator/types.ts
+++ b/packages/app/src/components/calculator/types.ts
@@ -13,6 +13,13 @@ export interface GPUDataPoint {
   sourceRow?: BenchmarkRow;
   hwKey: string;
   interactivity: number; // tokens/sec/user (median_intvty = x in interactivity chart)
+  /**
+   * Time to first token in seconds, read at the same percentile as
+   * `interactivity` (agentic rows) or the median (fixed sequences), mirroring
+   * the inference chart's TTFT axis. Absent when the row reported none, so a
+   * missing measurement can never pass a first-token cap as a zero.
+   */
+  ttft?: number;
   /**
    * End-to-end latency at the selected percentile. Agentic calculator groups
    * use this to keep only the same anti-benchmark-hacking Pareto winners as the
diff --git a/packages/app/src/components/calculator/useThroughputData.test.ts b/packages/app/src/components/calculator/useThroughputData.test.ts
index 242ff4d0b..6ca4ffafd 100644
--- a/packages/app/src/components/calculator/useThroughputData.test.ts
+++ b/packages/app/src/components/calculator/useThroughputData.test.ts
@@ -1148,6 +1148,58 @@ describe('buildGpuGroups', () => {
     expect(first.tpPerMw).toBeGreaterThan(0);
   });
 
+  describe('time to first token', () => {
+    const only = (row: BenchmarkRow, sequence = Sequence.OneK_OneK, percentile?: Percentile) => {
+      const { grouped } = buildGpuGroups([row], {
+        sequence,
+        precisions: ['fp4'],
+        percentile,
+        classify: singlePrecisionClassify,
+      });
+      return Object.values(grouped)[0][0];
+    };
+
+    it('reads the median for fixed-sequence rows, matching the inference TTFT axis', () => {
+      const point = only(
+        makeRow({
+          metrics: { median_intvty: 50, tput_per_gpu: 900, median_ttft: 0.8, p90_ttft: 2.4 },
+        }),
+      );
+      expect(point.ttft).toBe(0.8);
+    });
+
+    it('reads the selected percentile for agentic rows', () => {
+      const agentic = (percentile: Percentile) =>
+        only(
+          makeRow({
+            benchmark_type: 'agentic_traces',
+            isl: null,
+            osl: null,
+            metrics: {
+              p75_itl: 1 / 200,
+              p90_itl: 1 / 160,
+              p75_e2el: 20,
+              p90_e2el: 30,
+              tput_per_gpu: 900,
+              median_ttft: 0.5,
+              p75_ttft: 1.2,
+              p90_ttft: 3.1,
+            },
+          }),
+          Sequence.AgenticTraces,
+          percentile,
+        );
+      expect(agentic(Percentile.P90).ttft).toBe(3.1);
+      expect(agentic(Percentile.P75).ttft).toBe(1.2);
+    });
+
+    it('is absent, not zero, when the row reported no first-token time', () => {
+      // A zero would clear every first-token cap; absence is filtered out.
+      expect(only(makeRow()).ttft).toBeUndefined();
+      expect('ttft' in only(makeRow())).toBe(false);
+    });
+  });
+
   describe('cached-input fraction', () => {
     const withMetrics = (extra: Record<string, number>) =>
       makeRow({
diff --git a/packages/app/src/components/calculator/useThroughputData.ts b/packages/app/src/components/calculator/useThroughputData.ts
index af71981f0..ea3a144db 100644
--- a/packages/app/src/components/calculator/useThroughputData.ts
+++ b/packages/app/src/components/calculator/useThroughputData.ts
@@ -67,12 +67,31 @@ export interface OverlayGroupMeta extends GroupMeta {
 function getAgenticMetric(
   entry: AggDataEntry,
   percentile: Percentile,
-  suffix: 'intvty' | 'e2el',
+  suffix: 'intvty' | 'e2el' | 'ttft',
 ): number {
   const value = entry[`${percentile}_${suffix}` as keyof AggDataEntry];
   return typeof value === 'number' ? value : 0;
 }
 
+/**
+ * Time to first token for a row, at the percentile `interactivity` uses for
+ * agentic rows and the median for fixed sequences — the same split the
+ * inference chart's TTFT axis makes. Undefined rather than zero when the row
+ * has no usable measurement: the first-token page filters on this value, and
+ * a zero would clear every cap.
+ */
+function firstTokenSeconds(
+  entry: AggDataEntry,
+  sequence: Sequence,
+  percentile: Percentile,
+): number | undefined {
+  const value =
+    sequence === Sequence.AgenticTraces
+      ? getAgenticMetric(entry, percentile, 'ttft')
+      : entry.median_ttft;
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
 /**
  * Fraction of a row's input tokens served from cache, or null when the row
  * carries no cache metric at all — which is every fixed-sequence row.
@@ -212,6 +231,8 @@ export function buildGpuGroups<M extends GroupMeta>(
     if (!grouped[groupKey]) grouped[groupKey] = [];
     groupMeta[groupKey] = meta;
 
+    const ttft = firstTokenSeconds(entry, sequence, percentile);
+
     grouped[groupKey].push({
       sourceRow: row,
       hwKey,
@@ -219,6 +240,7 @@ export function buildGpuGroups<M extends GroupMeta>(
         sequence === Sequence.AgenticTraces
           ? getAgenticMetric(entry, percentile, 'intvty')
           : entry.median_intvty,
+      ...(ttft === undefined ? {} : { ttft }),
       ...(sequence === Sequence.AgenticTraces
         ? {
             e2eLatency: getAgenticMetric(entry, percentile, 'e2el'),
diff --git a/packages/app/src/components/compare/agentx-compare-hero.tsx b/packages/app/src/components/compare/agentx-compare-hero.tsx
index 535488652..31193ade7 100644
--- a/packages/app/src/components/compare/agentx-compare-hero.tsx
+++ b/packages/app/src/components/compare/agentx-compare-hero.tsx
@@ -436,6 +436,13 @@ export function AgentXCompareHero({
   const t = STRINGS[locale];
   const prefix = locale === 'zh' ? '/zh' : '';
   const Heading = headingLevel;
+  // Landing curation must not change compare coverage or dashboard defaults.
+  const ledgerModels =
+    surface === 'landing'
+      ? FEATURED_AGENTX_MODELS.filter(
+          (model) => model.slug !== 'deepseek-v4' && model.slug !== 'qwen-3-8-flash-next',
+        )
+      : FEATURED_AGENTX_MODELS;
 
   return (
     <section data-testid="compare-agentx-primary">
@@ -534,7 +541,7 @@ export function AgentXCompareHero({
             {/* The visible ledger header is dropped; `ledgerTitle` stays as the
                 nav's accessible name so screen readers still get the label. */}
             <nav aria-label={t.ledgerTitle} className="divide-y divide-border/70">
-              {FEATURED_AGENTX_MODELS.map((model) => (
+              {ledgerModels.map((model) => (
                 <CompareIndexTrackedLink
                   key={model.slug}
                   data-testid={`compare-agentx-model-${model.slug}`}
diff --git a/packages/app/src/components/footer/footer.tsx b/packages/app/src/components/footer/footer.tsx
index 10e6b19bb..eb4cba1b8 100644
--- a/packages/app/src/components/footer/footer.tsx
+++ b/packages/app/src/components/footer/footer.tsx
@@ -37,6 +37,8 @@ const STRINGS = {
     historicalTrends: 'Historical Trends',
     tcoCalculator: 'TCO Calculator',
     fleetLifecycle: 'Fleet Lifecycle',
+    firstTokenLimits: 'First-Token Limits',
+    cacheReuse: 'Prefix Cache Reuse',
     gpuReliability: 'Chip Reliability',
     gpuSpecsDashboard: 'Chip Specs Dashboard',
     perfPerDollar: 'Performance per Dollar',
@@ -72,6 +74,8 @@ const STRINGS = {
     historicalTrends: '历史趋势',
     tcoCalculator: 'TCO 计算器',
     fleetLifecycle: '集群生命周期',
+    firstTokenLimits: '首 token 延迟约束',
+    cacheReuse: '前缀缓存复用',
     gpuReliability: '芯片可靠性',
     gpuSpecsDashboard: '芯片规格仪表板',
     apiReference: 'API 文档',
@@ -300,6 +304,22 @@ export const Footer = ({ starCount }: { starCount?: number | null }) => {
                 >
                   {t.fleetLifecycle}
                 </Link>
+                <Link
+                  data-testid="footer-link-first-token"
+                  href={`${prefix}/first-token`}
+                  className="inline-flex min-h-11 items-center rounded-sm py-1 text-sm leading-snug text-muted-foreground transition-colors hover:text-foreground hover:underline hover:underline-offset-4 focus-visible:outline-none md:min-h-8"
+                  onClick={() => track('footer_first_token_clicked')}
+                >
+                  {t.firstTokenLimits}
+                </Link>
+                <Link
+                  data-testid="footer-link-cache-reuse"
+                  href={`${prefix}/cache-reuse`}
+                  className="inline-flex min-h-11 items-center rounded-sm py-1 text-sm leading-snug text-muted-foreground transition-colors hover:text-foreground hover:underline hover:underline-offset-4 focus-visible:outline-none md:min-h-8"
+                  onClick={() => track('footer_cache_reuse_clicked')}
+                >
+                  {t.cacheReuse}
+                </Link>
                 <Link
                   data-testid="footer-link-reliability"
                   href={`${prefix}/reliability`}
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.test.ts b/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
new file mode 100644
index 000000000..00bd200d6
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
@@ -0,0 +1,231 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  BUNDLE_MANIFEST_ENTRY,
+  BUNDLE_SAMPLES_ENTRY,
+  BUNDLE_WINDOW_PAD_SECONDS,
+  cutPowerAuditBundle,
+  isPowerAuditBundleEntry,
+} from './power-audit-bundle';
+
+const ARTIFACT = 'power_audit_qwen3.5_8k1k_fp8_dynamo-sglang_x';
+const RESULT = 'qwen3.5_8k1k_fp8_dynamo-sglang_x_sa-bench_isl_8192_osl_1024';
+
+/** `<hostname>/<GPU-uuid>` ids of the 2 × 2 synthetic cluster. */
+const A0 = 'cn01/GPU-a0';
+const A1 = 'cn01/GPU-a1';
+const B0 = 'cn02/GPU-b0';
+const B1 = 'cn02/GPU-b1';
+
+const HEADER = 'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w';
+
+function sample(time: number, device: string, power: number): string {
+  const [hostname, uuid] = device.split('/');
+  const gpuIndex = uuid.endsWith('0') ? 0 : 1;
+  return `1,${time},7,${hostname},${gpuIndex},${uuid},${power}`;
+}
+
+/** Every device sampled once per whole second in `[from, to]`, in scrambled device order. */
+function tick(time: number, watts: Record<string, number>): string[] {
+  return [B1, A1, B0, A0].map((device) => sample(time, device, watts[device]));
+}
+
+const WATTS = { [A0]: 100, [A1]: 110, [B0]: 200, [B1]: 50 };
+
+/** Window 1 at 1000–1010 s, window 2 at 2000–2010 s; nothing near window 3 at 5000 s. */
+const SAMPLES = [
+  HEADER,
+  // Just outside the 60 s pad of window 1.
+  ...tick(1000 - BUNDLE_WINDOW_PAD_SECONDS - 1, WATTS),
+  // Pad boundaries and the window itself.
+  ...tick(1000 - BUNDLE_WINDOW_PAD_SECONDS, WATTS),
+  ...tick(1000, WATTS),
+  ...tick(1005.4, { [A0]: 300, [A1]: 310, [B0]: 400, [B1]: 60 }),
+  ...tick(1010, WATTS),
+  ...tick(1010 + BUNDLE_WINDOW_PAD_SECONDS, WATTS),
+  ...tick(1010 + BUNDLE_WINDOW_PAD_SECONDS + 1, WATTS),
+  // Window 2, sampled by three devices only.
+  sample(2000, A1, 120),
+  sample(2000, A0, 130),
+  sample(2000, B0, 220),
+  sample(2001, A1, 121),
+  sample(2001, A0, 131),
+  sample(2001, B0, 221),
+  // Malformed rows: short line, non-numeric power, blank power (`Number('')`
+  // is 0), blank gpu_index, blank line.
+  '1,2002,7,cn01',
+  `1,2002,7,cn01,0,GPU-a0,N/A`,
+  `1,2002,7,cn01,0,GPU-a0,`,
+  `1,2002,7,cn01, ,GPU-a0,55`,
+  '',
+].join('\n');
+
+const MANIFEST = JSON.stringify({
+  schema_version: 1,
+  producer: 'srt-slurm.dcgm-power',
+  expected_devices: [
+    { hostname: 'cn01', gpu_index: 0, assignments: [{ worker_role: 'prefill' }] },
+    { hostname: 'cn01', gpu_index: 1, assignments: [{ worker_role: 'prefill' }] },
+    { hostname: 'cn02', gpu_index: 0, assignments: [{ worker_role: 'decode' }] },
+    { hostname: 'cn02', gpu_index: 1, assignments: [] },
+  ],
+});
+
+function validationName(conc: number): string {
+  return `power_validation_${RESULT}_conc${conc}_gpus_4_ctx_2_gen_2.json`;
+}
+
+/** Window 1: roles from `per_gpu_role`, where cn02/GPU-b0 is a prefill worker and GPU-b1 is unassigned. */
+const VALIDATION_1 = JSON.stringify({
+  schema_version: 1,
+  benchmark_window: { start_time_unix: 900, end_time_unix: 1100 },
+  selected_window: { concurrency: 1, start_time_unix: 1000, end_time_unix: 1010 },
+  per_gpu_role: { [A0]: 'decode', [A1]: 'prefill', [B0]: 'prefill' },
+});
+
+/** Window 2: no `per_gpu_role` and no `selected_window`, so the manifest and `benchmark_window` apply. */
+const VALIDATION_2 = JSON.stringify({
+  schema_version: 1,
+  benchmark_window: { start_time_unix: 2000, end_time_unix: 2010 },
+});
+
+/** Window 3: valid, but no sample lands within the pad. */
+const VALIDATION_3 = JSON.stringify({
+  selected_window: { concurrency: 3, start_time_unix: 5000, end_time_unix: 5010 },
+});
+
+function bundle(overrides: Record<string, string | undefined> = {}): Map<string, string> {
+  const files = new Map<string, string | undefined>([
+    [validationName(3), VALIDATION_3],
+    [validationName(1), VALIDATION_1],
+    [BUNDLE_SAMPLES_ENTRY, SAMPLES],
+    [BUNDLE_MANIFEST_ENTRY, MANIFEST],
+    [validationName(2), VALIDATION_2],
+  ]);
+  for (const [name, text] of Object.entries(overrides)) files.set(name, text);
+  const present = new Map<string, string>();
+  for (const [name, text] of files) if (text !== undefined) present.set(name, text);
+  return present;
+}
+
+describe('isPowerAuditBundleEntry', () => {
+  it('selects samples, manifest, and top-level validations only', () => {
+    expect(isPowerAuditBundleEntry(BUNDLE_SAMPLES_ENTRY)).toBe(true);
+    expect(isPowerAuditBundleEntry(BUNDLE_MANIFEST_ENTRY)).toBe(true);
+    expect(isPowerAuditBundleEntry(validationName(8))).toBe(true);
+    expect(isPowerAuditBundleEntry('LOGS/power/windows/results_concurrency_8.json')).toBe(false);
+    expect(isPowerAuditBundleEntry(`LOGS/sa-bench_isl_8192_osl_1024/results.json`)).toBe(false);
+    expect(isPowerAuditBundleEntry(`agg_${RESULT}_conc8.json`)).toBe(false);
+    expect(isPowerAuditBundleEntry(`${RESULT}_conc8.json`)).toBe(false);
+    expect(isPowerAuditBundleEntry(`nested/${validationName(8)}`)).toBe(false);
+    expect(isPowerAuditBundleEntry('power_validation_x.json.bak')).toBe(false);
+  });
+});
+
+describe('cutPowerAuditBundle', () => {
+  it('emits one series per validation window with samples, in window order', () => {
+    const series = cutPowerAuditBundle(ARTIFACT, bundle());
+    expect(series.map((entry) => entry.source)).toEqual([validationName(1), validationName(2)]);
+    expect(series.every((entry) => entry.artifact === ARTIFACT)).toBe(true);
+    expect(series.every((entry) => entry.bucketSeconds === 1)).toBe(true);
+  });
+
+  it('orders rows prefill, decode, unassigned, then by hostname and gpu_index', () => {
+    const [first] = cutPowerAuditBundle(ARTIFACT, bundle());
+    expect(first.devices).toEqual([
+      { id: A1, role: 'prefill' },
+      { id: B0, role: 'prefill' },
+      { id: A0, role: 'decode' },
+      { id: B1 },
+    ]);
+    expect(first.gpus).toEqual([0, 1, 2, 3]);
+    expect(first.power).toHaveLength(4);
+    // Row order is the device order: A1 reads 110 W, then 310 W in the window.
+    expect(first.power[0][1]).toBe(110);
+    expect(first.power[0][2]).toBe(310);
+    expect(first.power[3][2]).toBe(60);
+  });
+
+  it('falls back to manifest roles and to benchmark_window', () => {
+    const [, second] = cutPowerAuditBundle(ARTIFACT, bundle());
+    expect(second.source).toBe(validationName(2));
+    expect(second.devices).toEqual([
+      { id: A0, role: 'prefill' },
+      { id: A1, role: 'prefill' },
+      { id: B0, role: 'decode' },
+    ]);
+    expect(second.startMs).toBe(2000 * 1000);
+    expect(second.t).toEqual([0, 1]);
+    expect(second.power).toEqual([
+      [130, 131],
+      [120, 121],
+      [220, 221],
+    ]);
+  });
+
+  it('leaves roles undefined without a manifest or per_gpu_role', () => {
+    const [, second] = cutPowerAuditBundle(
+      ARTIFACT,
+      bundle({ [BUNDLE_MANIFEST_ENTRY]: undefined }),
+    );
+    expect(second.devices).toEqual([{ id: A0 }, { id: A1 }, { id: B0 }]);
+    const [first] = cutPowerAuditBundle(ARTIFACT, bundle({ [BUNDLE_MANIFEST_ENTRY]: '{oops' }));
+    expect(first.devices!.map((device) => device.role)).toEqual([
+      'prefill',
+      'prefill',
+      'decode',
+      undefined,
+    ]);
+  });
+
+  it('clips samples to the window plus the pad on both sides', () => {
+    const [first] = cutPowerAuditBundle(ARTIFACT, bundle());
+    expect(first.startMs).toBe((1000 - BUNDLE_WINDOW_PAD_SECONDS) * 1000);
+    expect(first.t).toEqual([0, 60, 65, 70, 130]);
+    // 1005.4 s lands in the 1005 s bucket; the malformed 2002 s rows never appear.
+    expect(first.power[2]).toEqual([100, 100, 300, 100, 100]);
+  });
+
+  it('skips the sweep entirely without samples', () => {
+    expect(cutPowerAuditBundle(ARTIFACT, bundle({ [BUNDLE_SAMPLES_ENTRY]: undefined }))).toEqual(
+      [],
+    );
+    expect(cutPowerAuditBundle(ARTIFACT, bundle({ [BUNDLE_SAMPLES_ENTRY]: '' }))).toEqual([]);
+    expect(
+      cutPowerAuditBundle(ARTIFACT, bundle({ [BUNDLE_SAMPLES_ENTRY]: `${HEADER}\n` })),
+    ).toEqual([]);
+    // A header without the required columns is as good as no samples.
+    expect(
+      cutPowerAuditBundle(
+        ARTIFACT,
+        bundle({ [BUNDLE_SAMPLES_ENTRY]: 'timestamp,index,power\n1000,0,100' }),
+      ),
+    ).toEqual([]);
+  });
+
+  it('reads columns by header name, not position', () => {
+    const reordered = [
+      'power_w,gpu_uuid,gpu_index,hostname,timestamp_unix',
+      '123.5,GPU-a0,0,cn01,1000',
+      '124.5,GPU-a0,0,cn01,1001.2',
+    ].join('\r\n');
+    const [first] = cutPowerAuditBundle(ARTIFACT, bundle({ [BUNDLE_SAMPLES_ENTRY]: reordered }));
+    expect(first.devices).toEqual([{ id: A0, role: 'decode' }]);
+    expect(first.power).toEqual([[123.5, 124.5]]);
+  });
+
+  it('skips malformed validation files and files without a window', () => {
+    const series = cutPowerAuditBundle(
+      ARTIFACT,
+      bundle({
+        [validationName(1)]: '{"selected_window": ',
+        [validationName(4)]: JSON.stringify({ power_valid: true }),
+        [validationName(5)]: JSON.stringify([1, 2]),
+        [validationName(6)]: JSON.stringify({
+          selected_window: { start_time_unix: 2010, end_time_unix: 2000 },
+        }),
+      }),
+    );
+    expect(series.map((entry) => entry.source)).toEqual([validationName(2)]);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.ts b/packages/app/src/components/gpu-power/power-audit-bundle.ts
new file mode 100644
index 000000000..03c01583e
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.ts
@@ -0,0 +1,280 @@
+/**
+ * Cuts per-config power series out of a `power_audit_<RESULT_FILENAME>` bundle.
+ *
+ * Slurm / Dynamo disaggregated runners do not publish one `gpu_metrics_*` CSV
+ * per config. Their DCGM collector writes one bundle per concurrency sweep:
+ * `LOGS/power/samples.csv` holds ~1 Hz watts for every GPU across the whole
+ * sweep, `LOGS/power/manifest.json` names the devices and their worker role,
+ * and one top-level `power_validation_*.json` per concurrency records the
+ * validated measurement window. Each validation file becomes one
+ * `GpuPowerSeries` whose `source` is that file's basename, so the timeline
+ * joins it to the chart row carrying the same `power_audit.source`.
+ *
+ * Pure: the route hands over the extracted entry texts; nothing here reads
+ * the network or the zip.
+ */
+import {
+  bucketPowerSeries,
+  type GpuPowerDevice,
+  type GpuPowerRole,
+  type GpuPowerSeries,
+} from './power-series';
+import type { GpuMetricRow } from './types';
+
+/** Seconds of telemetry kept on each side of a validated window (ramp-up / drain context). */
+export const BUNDLE_WINDOW_PAD_SECONDS = 60;
+
+export const BUNDLE_SAMPLES_ENTRY = 'LOGS/power/samples.csv';
+export const BUNDLE_MANIFEST_ENTRY = 'LOGS/power/manifest.json';
+/** Top-level `power_validation_<name>.json`; the `LOGS/` copies of results are not validations. */
+const VALIDATION_ENTRY = /^power_validation_[^/]+\.json$/u;
+
+/** Zip entries the route must extract for `cutPowerAuditBundle`; everything else stays compressed. */
+export function isPowerAuditBundleEntry(entryName: string): boolean {
+  return (
+    entryName === BUNDLE_SAMPLES_ENTRY ||
+    entryName === BUNDLE_MANIFEST_ENTRY ||
+    VALIDATION_ENTRY.test(entryName)
+  );
+}
+
+interface Sample {
+  /** Unix seconds. */
+  time: number;
+  deviceId: string;
+  power: number;
+}
+
+interface Device {
+  /** `<hostname>/<GPU-uuid>`, the form `power_audit.observed_gpu_ids` uses. */
+  id: string;
+  hostname: string;
+  gpuIndex: number;
+}
+
+interface ParsedSamples {
+  samples: Sample[];
+  /** Devices in first-seen order. */
+  devices: Map<string, Device>;
+}
+
+const SAMPLE_COLUMNS = ['timestamp_unix', 'hostname', 'gpu_index', 'gpu_uuid', 'power_w'] as const;
+
+const NUMERIC_CELL = /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/iu;
+
+/** A CSV cell as a number, or NaN for anything that is not a plain numeral (`Number('')` is 0). */
+function numericCell(cell: string): number {
+  const text = cell.trim();
+  return NUMERIC_CELL.test(text) ? Number(text) : Number.NaN;
+}
+
+function splitCsvLines(text: string): string[] {
+  return text.split('\n').map((line) => (line.endsWith('\r') ? line.slice(0, -1) : line));
+}
+
+/** Header-driven parse of `samples.csv`; malformed rows are skipped. */
+function parseSamples(csv: string): ParsedSamples {
+  const lines = splitCsvLines(csv);
+  const headerIndex = lines.findIndex((line) => line.trim().length > 0);
+  const empty: ParsedSamples = { samples: [], devices: new Map() };
+  if (headerIndex === -1) return empty;
+  const header = lines[headerIndex].split(',').map((cell) => cell.trim());
+  const columns = SAMPLE_COLUMNS.map((name) => header.indexOf(name));
+  if (columns.includes(-1)) return empty;
+  const [timeCol, hostCol, indexCol, uuidCol, powerCol] = columns;
+  const width = Math.max(...columns) + 1;
+
+  const samples: Sample[] = [];
+  const devices = new Map<string, Device>();
+  for (const line of lines.slice(headerIndex + 1)) {
+    const cells = line.split(',');
+    if (cells.length < width) continue;
+    const time = numericCell(cells[timeCol]);
+    const power = numericCell(cells[powerCol]);
+    const gpuIndex = numericCell(cells[indexCol]);
+    const hostname = cells[hostCol].trim();
+    const uuid = cells[uuidCol].trim();
+    if (
+      !Number.isFinite(time) ||
+      !Number.isFinite(power) ||
+      !Number.isInteger(gpuIndex) ||
+      hostname.length === 0 ||
+      uuid.length === 0
+    ) {
+      continue;
+    }
+    const deviceId = `${hostname}/${uuid}`;
+    if (!devices.has(deviceId)) devices.set(deviceId, { id: deviceId, hostname, gpuIndex });
+    samples.push({ time, deviceId, power });
+  }
+  return { samples, devices };
+}
+
+function asRole(value: unknown): GpuPowerRole | undefined {
+  return value === 'prefill' || value === 'decode' ? value : undefined;
+}
+
+function parseJsonObject(text: string | undefined): Record<string, unknown> | null {
+  if (text === undefined) return null;
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function manifestSlot(hostname: string, gpuIndex: number): string {
+  return `${hostname}#${gpuIndex}`;
+}
+
+/** `expected_devices[].assignments[0].worker_role`, keyed by hostname + gpu_index. */
+function manifestRoles(manifest: Record<string, unknown> | null): Map<string, GpuPowerRole> {
+  const roles = new Map<string, GpuPowerRole>();
+  const expected = manifest?.expected_devices;
+  if (!Array.isArray(expected)) return roles;
+  for (const device of expected) {
+    if (!isRecord(device)) continue;
+    const { hostname, gpu_index: gpuIndex, assignments } = device;
+    if (
+      typeof hostname !== 'string' ||
+      typeof gpuIndex !== 'number' ||
+      !Array.isArray(assignments)
+    ) {
+      continue;
+    }
+    const first: unknown = assignments[0];
+    const role = isRecord(first) ? asRole(first.worker_role) : undefined;
+    if (role) roles.set(manifestSlot(hostname, gpuIndex), role);
+  }
+  return roles;
+}
+
+interface TimeWindow {
+  start: number;
+  end: number;
+}
+
+/** `selected_window`, else `benchmark_window`; `null` when neither has a finite range. */
+function validationWindow(validation: Record<string, unknown>): TimeWindow | null {
+  for (const key of ['selected_window', 'benchmark_window']) {
+    const window = validation[key];
+    if (!isRecord(window)) continue;
+    const start = window.start_time_unix;
+    const end = window.end_time_unix;
+    if (
+      typeof start === 'number' &&
+      typeof end === 'number' &&
+      Number.isFinite(start) &&
+      Number.isFinite(end) &&
+      end >= start
+    ) {
+      return { start, end };
+    }
+  }
+  return null;
+}
+
+const ROLE_ORDER: Record<GpuPowerRole, number> = { prefill: 0, decode: 1 };
+
+function roleRank(role: GpuPowerRole | undefined): number {
+  return role ? ROLE_ORDER[role] : 2;
+}
+
+function compareText(a: string, b: string): number {
+  if (a < b) return -1;
+  return a > b ? 1 : 0;
+}
+
+/** Prefill, then decode, then unassigned; within a role by hostname, then gpu_index. */
+function orderDevices(devices: readonly GpuPowerDevice[], byId: ReadonlyMap<string, Device>) {
+  return devices.toSorted((a, b) => {
+    const rank = roleRank(a.role) - roleRank(b.role);
+    if (rank !== 0) return rank;
+    const deviceA = byId.get(a.id)!;
+    const deviceB = byId.get(b.id)!;
+    return compareText(deviceA.hostname, deviceB.hostname) || deviceA.gpuIndex - deviceB.gpuIndex;
+  });
+}
+
+function basename(entryName: string): string {
+  return entryName.slice(entryName.lastIndexOf('/') + 1);
+}
+
+/**
+ * One series per validation file that has a window and samples within
+ * `BUNDLE_WINDOW_PAD_SECONDS` of it. Rows follow `devices`, ordered prefill,
+ * decode, unassigned (hostname, then gpu_index inside a role); `gpus` are the
+ * row indices `0..n-1`. Roles come from the validation's `per_gpu_role`, else
+ * the manifest's `expected_devices`. Malformed JSON skips that file; a
+ * missing or empty `samples.csv` yields `[]`. Output is ordered by window start.
+ */
+export function cutPowerAuditBundle(
+  artifact: string,
+  files: ReadonlyMap<string, string>,
+): GpuPowerSeries[] {
+  const samplesText = files.get(BUNDLE_SAMPLES_ENTRY);
+  if (samplesText === undefined) return [];
+  const { samples, devices } = parseSamples(samplesText);
+  if (samples.length === 0) return [];
+  const fallbackRoles = manifestRoles(parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY)));
+
+  const cut: { start: number; series: GpuPowerSeries }[] = [];
+  for (const [entryName, text] of files) {
+    if (!VALIDATION_ENTRY.test(entryName)) continue;
+    const validation = parseJsonObject(text);
+    if (!validation) continue;
+    const window = validationWindow(validation);
+    if (!window) continue;
+
+    const lo = window.start - BUNDLE_WINDOW_PAD_SECONDS;
+    const hi = window.end + BUNDLE_WINDOW_PAD_SECONDS;
+    const inRange = samples.filter((sample) => sample.time >= lo && sample.time <= hi);
+    if (inRange.length === 0) continue;
+
+    const explicitRoles = isRecord(validation.per_gpu_role) ? validation.per_gpu_role : {};
+    const present = [...new Set(inRange.map((sample) => sample.deviceId))].map((id) => {
+      const device = devices.get(id)!;
+      const role =
+        asRole(explicitRoles[id]) ??
+        fallbackRoles.get(manifestSlot(device.hostname, device.gpuIndex));
+      return role ? { id, role } : { id };
+    });
+    const ordered = orderDevices(present, devices);
+    const rowOf = new Map(ordered.map((device, row) => [device.id, row]));
+
+    const rows: GpuMetricRow[] = inRange.map((sample) => ({
+      timestamp: String(sample.time),
+      index: rowOf.get(sample.deviceId)!,
+      power: sample.power,
+      temperature: 0,
+      smClock: 0,
+      memClock: 0,
+      gpuUtil: 0,
+      memUtil: 0,
+    }));
+    const series = bucketPowerSeries(artifact, rows);
+    if (!series) continue;
+    // The synthetic `index` is the device's position in `ordered`, so each
+    // bucketed row maps back to its device; `gpus` becomes plain row indices.
+    cut.push({
+      start: window.start,
+      series: {
+        ...series,
+        artifact,
+        source: basename(entryName),
+        gpus: series.gpus.map((_, row) => row),
+        devices: series.gpus.map((row) => ordered[row]),
+      },
+    });
+  }
+  return cut
+    .toSorted((a, b) => a.start - b.start || compareText(a.series.source!, b.series.source!))
+    .map((entry) => entry.series);
+}
diff --git a/packages/app/src/components/gpu-power/power-series.test.ts b/packages/app/src/components/gpu-power/power-series.test.ts
new file mode 100644
index 000000000..e20146c09
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-series.test.ts
@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  bucketPowerSeries,
+  bucketTimeMs,
+  meanPowerAt,
+  parseTelemetryTimestampUtc,
+  sumPowerAt,
+  type GpuPowerSeries,
+} from './power-series';
+import type { GpuMetricRow } from './types';
+
+function row(timestamp: string, index: number, power: number): GpuMetricRow {
+  return {
+    timestamp,
+    index,
+    power,
+    temperature: 40,
+    smClock: 1,
+    memClock: 1,
+    gpuUtil: 0,
+    memUtil: 0,
+  };
+}
+
+describe('parseTelemetryTimestampUtc', () => {
+  it('reads runner nvidia-smi timestamps as UTC regardless of the browser zone', () => {
+    // 2026-09-12 20:19:57.158Z; a local-time parse would shift by the host offset.
+    expect(parseTelemetryTimestampUtc('2026/09/12 20:19:57.158')).toBe(
+      Date.UTC(2026, 8, 12, 20, 19, 57, 158),
+    );
+    expect(parseTelemetryTimestampUtc('2026-09-12 20:19:57')).toBe(
+      Date.UTC(2026, 8, 12, 20, 19, 57, 0),
+    );
+  });
+
+  it('accepts ISO strings with a zone and numeric epochs', () => {
+    expect(parseTelemetryTimestampUtc('2026-09-12T20:19:57.158Z')).toBe(
+      Date.UTC(2026, 8, 12, 20, 19, 57, 158),
+    );
+    expect(parseTelemetryTimestampUtc('1789244397.158')).toBe(1789244397158);
+    expect(parseTelemetryTimestampUtc('1789244397158')).toBe(1789244397158);
+    expect(parseTelemetryTimestampUtc('N/A')).toBeNull();
+  });
+});
+
+describe('bucketPowerSeries', () => {
+  it('aligns every GPU on one-second buckets and marks missing samples null', () => {
+    const rows = [
+      row('2026/09/12 20:20:41.817', 0, 194.4),
+      row('2026/09/12 20:20:41.820', 1, 192.4),
+      row('2026/09/12 20:20:42.816', 0, 300),
+      // GPU 1 skipped this tick; GPU 0 sampled twice in the next one.
+      row('2026/09/12 20:20:43.815', 0, 400),
+      row('2026/09/12 20:20:43.900', 0, 500),
+      row('2026/09/12 20:20:43.818', 1, 350),
+    ];
+    const series = bucketPowerSeries('gpu_metrics_test', rows);
+    expect(series).not.toBeNull();
+    expect(series!.startMs).toBe(Date.UTC(2026, 8, 12, 20, 20, 41));
+    expect(series!.bucketSeconds).toBe(1);
+    expect(series!.gpus).toEqual([0, 1]);
+    expect(series!.t).toEqual([0, 1, 2]);
+    expect(series!.power).toEqual([
+      [194.4, 300, 450],
+      [192.4, null, 350],
+    ]);
+    expect(meanPowerAt(series!, 1)).toBe(300);
+    expect(meanPowerAt(series!, 2)).toBe(400);
+    expect(bucketTimeMs(series!, 2)).toBe(Date.UTC(2026, 8, 12, 20, 20, 43));
+  });
+
+  it('omits empty buckets so long gaps do not pad the payload', () => {
+    const series = bucketPowerSeries('gpu_metrics_gap', [
+      row('2026/09/12 20:00:00.000', 0, 100),
+      row('2026/09/12 20:00:10.000', 0, 200),
+    ]);
+    expect(series!.t).toEqual([0, 10]);
+    expect(series!.power).toEqual([[100, 200]]);
+  });
+
+  it('drops unparseable rows and returns null when nothing remains', () => {
+    expect(bucketPowerSeries('gpu_metrics_empty', [row('N/A', 0, 100)])).toBeNull();
+    expect(
+      bucketPowerSeries('gpu_metrics_empty', [row('2026/09/12 20:00:00', 0, Number.NaN)]),
+    ).toBeNull();
+    expect(() => bucketPowerSeries('x', [], 0)).toThrow(RangeError);
+  });
+});
+
+describe('sumPowerAt', () => {
+  const series: GpuPowerSeries = {
+    artifact: 'power_audit_sweep',
+    startMs: Date.UTC(2026, 8, 12, 20, 0, 0),
+    bucketSeconds: 1,
+    gpus: [0, 1, 2],
+    t: [0, 1, 2],
+    power: [
+      [100, null, 300],
+      [50, 60, null],
+      [10, null, null],
+    ],
+  };
+
+  it('sums a pool only when every one of its rows has a sample in the bucket', () => {
+    expect(sumPowerAt(series, [0, 1, 2], 0)).toBe(160);
+    expect(sumPowerAt(series, [1, 2], 0)).toBe(60);
+    expect(sumPowerAt(series, [1], 1)).toBe(60);
+  });
+
+  it('returns null for a partial pool, an unsampled bucket, an empty pool or an unknown row', () => {
+    // GPU 0 and 2 have no sample in bucket 1: a partial sum would read as a dip.
+    expect(sumPowerAt(series, [0, 1, 2], 1)).toBeNull();
+    expect(sumPowerAt(series, [0, 1], 2)).toBeNull();
+    expect(sumPowerAt(series, [0, 2], 1)).toBeNull();
+    expect(sumPowerAt(series, [], 0)).toBeNull();
+    expect(sumPowerAt(series, [7], 0)).toBeNull();
+  });
+});
diff --git a/packages/app/src/components/gpu-power/power-series.ts b/packages/app/src/components/gpu-power/power-series.ts
new file mode 100644
index 000000000..a05b0376d
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-series.ts
@@ -0,0 +1,180 @@
+/**
+ * Compact per-GPU power series for the PowerX timeline.
+ *
+ * A `gpu_metrics_<RESULT_FILENAME>` artifact carries ~1 Hz samples for every
+ * GPU of one benchmark config (server start, warmup, and the measured window).
+ * The raw rows are heavy (a 25-config run is ~27 MB of JSON), so the API can
+ * return this columnar shape instead: one row of watts per GPU, aligned on
+ * fixed-width time buckets, with `null` where a GPU had no sample.
+ *
+ * Runner timestamps are UTC wall clock (`2026/09/12 20:19:57.158`); the
+ * validated measurement window in `power_audit` is UTC epoch seconds, so the
+ * two line up without a timezone guess.
+ */
+import type { GpuMetricRow, GpuPowerRunInfo } from './types';
+
+/** Worker role a GPU served, when the collector's manifest assigns one. */
+export type GpuPowerRole = 'prefill' | 'decode';
+
+export interface GpuPowerDevice {
+  /**
+   * Producer device identifier: the nvidia-smi / amd-smi index (`"3"`) for
+   * `gpu_metrics_*` CSVs, `<hostname>/<GPU-uuid>` for DCGM power-audit
+   * bundles — the same form as `power_audit.observed_gpu_ids` on the row.
+   */
+  id: string;
+  role?: GpuPowerRole;
+}
+
+export interface GpuPowerSeries {
+  /** GitHub artifact name: `gpu_metrics_<RESULT_FILENAME>` or `power_audit_<RESULT_FILENAME>`. */
+  artifact: string;
+  /**
+   * Basename of the `power_validation_*.json` this series belongs to, for
+   * series cut from a power-audit bundle (one bundle holds a whole
+   * concurrency sweep). Absent for `gpu_metrics_*` series, whose artifact
+   * already names one config.
+   */
+  source?: string;
+  /** UTC epoch milliseconds of bucket 0. */
+  startMs: number;
+  /** Bucket width in seconds. */
+  bucketSeconds: number;
+  /** GPU indices, one per row of `power`, ascending. */
+  gpus: number[];
+  /** Seconds since `startMs` for each bucket, ascending. */
+  t: number[];
+  /** Watts per GPU (outer) per bucket (inner); `null` when no sample landed in the bucket. */
+  power: (number | null)[][];
+  /** One entry per row of `power` when the collector reports device identity or roles. */
+  devices?: GpuPowerDevice[];
+}
+
+export interface GpuPowerSeriesResponse {
+  runInfo: GpuPowerRunInfo;
+  series: GpuPowerSeries[];
+}
+
+const RUNNER_TIMESTAMP =
+  /^(?<y>\d{4})[/-](?<mo>\d{2})[/-](?<d>\d{2})[ T](?<h>\d{2}):(?<mi>\d{2}):(?<s>\d{2})(?:\.(?<ms>\d{1,6}))?$/u;
+
+/**
+ * Parses a runner telemetry timestamp as UTC epoch milliseconds.
+ *
+ * nvidia-smi / amd-smi write `YYYY/MM/DD HH:MM:SS.mmm` without a zone; the
+ * collectors run in UTC, and `new Date(...)` would read that as browser local
+ * time, so the digits are assembled explicitly. ISO strings with a zone and
+ * numeric epochs (seconds or milliseconds) are accepted as-is.
+ */
+export function parseTelemetryTimestampUtc(raw: string): number | null {
+  const text = raw.trim();
+  const match = RUNNER_TIMESTAMP.exec(text);
+  if (match?.groups) {
+    const { y, mo, d, h, mi, s, ms } = match.groups;
+    const millis = ms ? Math.round(Number(`0.${ms}`) * 1000) : 0;
+    return Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s), millis);
+  }
+  if (/^\d+(?:\.\d+)?$/u.test(text)) {
+    const numeric = Number(text);
+    return numeric < 1e12 ? Math.round(numeric * 1000) : Math.round(numeric);
+  }
+  const parsed = Date.parse(text);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+/**
+ * Buckets raw per-GPU rows into the compact series. Samples of one GPU that
+ * share a bucket are averaged; buckets nobody sampled are omitted from `t`.
+ * Returns `null` when no row carries a parseable timestamp.
+ */
+export function bucketPowerSeries(
+  artifact: string,
+  rows: readonly GpuMetricRow[],
+  bucketSeconds = 1,
+): GpuPowerSeries | null {
+  if (!(bucketSeconds > 0)) throw new RangeError('bucketSeconds must be positive');
+  const bucketMs = bucketSeconds * 1000;
+  let startMs = Number.POSITIVE_INFINITY;
+  const parsed: { ms: number; gpu: number; power: number }[] = [];
+  for (const row of rows) {
+    if (!Number.isFinite(row.power) || !Number.isInteger(row.index)) continue;
+    const ms = parseTelemetryTimestampUtc(row.timestamp);
+    if (ms === null) continue;
+    parsed.push({ ms, gpu: row.index, power: row.power });
+    if (ms < startMs) startMs = ms;
+  }
+  if (parsed.length === 0) return null;
+  startMs = Math.floor(startMs / bucketMs) * bucketMs;
+
+  const gpus = [...new Set(parsed.map((sample) => sample.gpu))].toSorted((a, b) => a - b);
+  const gpuRow = new Map(gpus.map((gpu, row) => [gpu, row]));
+  // bucket index -> per GPU [sum, count]
+  const buckets = new Map<number, [number, number][]>();
+  for (const sample of parsed) {
+    const bucket = Math.floor((sample.ms - startMs) / bucketMs);
+    let cells = buckets.get(bucket);
+    if (!cells) {
+      cells = gpus.map(() => [0, 0]);
+      buckets.set(bucket, cells);
+    }
+    const cell = cells[gpuRow.get(sample.gpu)!];
+    cell[0] += sample.power;
+    cell[1] += 1;
+  }
+  const bucketIndices = [...buckets.keys()].toSorted((a, b) => a - b);
+  const power: (number | null)[][] = gpus.map(() =>
+    Array.from({ length: bucketIndices.length }, (): number | null => null),
+  );
+  bucketIndices.forEach((bucket, column) => {
+    const cells = buckets.get(bucket)!;
+    cells.forEach(([sum, count], row) => {
+      power[row][column] = count > 0 ? Math.round((sum / count) * 100) / 100 : null;
+    });
+  });
+  return {
+    artifact,
+    startMs,
+    bucketSeconds,
+    gpus,
+    t: bucketIndices.map((bucket) => bucket * bucketSeconds),
+    power,
+  };
+}
+
+/** Mean watts across the GPUs that have a sample in bucket `column`, or `null`. */
+export function meanPowerAt(series: GpuPowerSeries, column: number): number | null {
+  let sum = 0;
+  let count = 0;
+  for (const row of series.power) {
+    const value = row[column];
+    if (value === null || value === undefined) continue;
+    sum += value;
+    count += 1;
+  }
+  return count > 0 ? sum / count : null;
+}
+
+/**
+ * Summed watts over `rows` in bucket `column`, or `null` unless EVERY row has
+ * a sample: a pool total with a device missing would read as a dip against
+ * the pool's TDP, so the bucket is left as a gap instead.
+ */
+export function sumPowerAt(
+  series: GpuPowerSeries,
+  rows: readonly number[],
+  column: number,
+): number | null {
+  if (rows.length === 0) return null;
+  let sum = 0;
+  for (const row of rows) {
+    const value = series.power[row]?.[column];
+    if (value === null || value === undefined) return null;
+    sum += value;
+  }
+  return sum;
+}
+
+/** UTC epoch milliseconds of bucket `column`. */
+export function bucketTimeMs(series: GpuPowerSeries, column: number): number {
+  return series.startMs + series.t[column] * 1000;
+}
diff --git a/packages/app/src/components/inference/InferenceContext.tsx b/packages/app/src/components/inference/InferenceContext.tsx
index c8c62ea18..c18e3d1b8 100644
--- a/packages/app/src/components/inference/InferenceContext.tsx
+++ b/packages/app/src/components/inference/InferenceContext.tsx
@@ -36,6 +36,7 @@ import type {
   InferenceDataContextType,
   InferenceDisplayContextType,
   InferenceFiltersContextType,
+  PowerCompare,
   TokenRevenuePriceSource,
 } from '@/components/inference/types';
 import { resolveMetricConfigKey } from '@/components/inference/metric-registry';
@@ -55,6 +56,14 @@ import {
   useUrlStateSync,
 } from '@/hooks/useChartContext';
 import { useUrlState } from '@/hooks/useUrlState';
+import { serializePerfRulers } from '@/lib/d3-chart/layers/perf-ruler';
+import { parsePowerCompare } from '@/components/inference/utils/power-compare';
+import {
+  PERSISTED_PERF_RULER_CHART_ID,
+  PerfRulerStoreContext,
+  persistedPerfRulerAxisKey,
+  usePerfRulerStoreValue,
+} from '@/components/inference/perf-ruler-store';
 import { useParetoHighlightToggle } from './hooks/useParetoHighlightToggle';
 import { useOpenRouterPricing } from '@/hooks/api/use-openrouter-pricing';
 import { DEFAULT_Y_AXIS_METRIC } from '@/lib/url-state';
@@ -477,6 +486,12 @@ export function InferenceProvider({
   const [scaleType, setScaleType] = useState<'auto' | 'linear' | 'log'>(
     () => (getUrlParam('i_scale') as 'auto' | 'linear' | 'log') || 'auto',
   );
+  // Comparison series on a gated power metric (`i_pcompare`). Kept while the
+  // metric changes: a key without a common axis simply yields no siblings, and
+  // the Measured controls say so, so a link's intent survives a detour.
+  const [powerCompare, setPowerCompare] = useState<PowerCompare>(() =>
+    parsePowerCompare(getUrlParam('i_pcompare')),
+  );
 
   // ── Quick filters (vendor / framework / deployment / mtp-stp / power tier) ──
   // Coarse pre-filters applied to the point set. Empty = no constraint.
@@ -769,6 +784,7 @@ export function InferenceProvider({
       !isUnofficialRun &&
       !hasExplicitRunSelection &&
       selectedRunDateRev === 0,
+    powerCompare,
   );
 
   // For GPU comparison date picker — use shared availability data from global filters
@@ -1034,6 +1050,21 @@ export function InferenceProvider({
   const refreshing = !availabilityError && chartDataRefreshing;
   const error = availabilityError || workflowError || chartDataError;
 
+  // ── Perf rulers (persisted chart) ────────────────────────────────────────
+  // The axis identity follows the graph ChartDisplay renders as `chart-0`
+  // (picked by x mode, like `bestHwTypes` below), so an x-mode switch that
+  // swaps the rendered chart or its x units clears the rulers the same way
+  // the chart's own `usePerfRulerAxisReset` does for local state.
+  const perfRulerStore = usePerfRulerStoreValue(
+    PERSISTED_PERF_RULER_CHART_ID,
+    getUrlParam('i_rulers'),
+    persistedPerfRulerAxisKey(graphs, selectedXAxisMode, selectedYAxisMetric),
+  );
+  const iRulersStr = useMemo(
+    () => serializePerfRulers(perfRulerStore.state),
+    [perfRulerStore.state],
+  );
+
   // ── Toggle sets ───────────────────────────────────────────────────────────
 
   const {
@@ -1600,6 +1631,8 @@ export function InferenceProvider({
       i_disagg: quickFilterDeployment.join(','),
       i_spec: quickFilterSpec.join(','),
       i_power: quickFilterPower.join(','),
+      i_rulers: iRulersStr,
+      i_pcompare: powerCompare === 'none' ? '' : powerCompare,
     },
     [
       selectedYAxisMetric,
@@ -1633,6 +1666,8 @@ export function InferenceProvider({
       quickFilterDeployment,
       quickFilterSpec,
       quickFilterPower,
+      iRulersStr,
+      powerCompare,
     ],
   );
 
@@ -1848,6 +1883,7 @@ export function InferenceProvider({
       selectedE2eXAxisMetric,
       selectedXAxisMode,
       scaleType,
+      powerCompare,
       isLegendExpanded,
       hideNonOptimal,
       showAllMeasurements,
@@ -1875,6 +1911,7 @@ export function InferenceProvider({
       selectedE2eXAxisMetric,
       selectedXAxisMode,
       scaleType,
+      powerCompare,
       isLegendExpanded,
       hideNonOptimal,
       showAllMeasurements,
@@ -1911,6 +1948,7 @@ export function InferenceProvider({
     setSelectedXAxisMetric,
     setSelectedXAxisMode: handleSetXAxisMode,
     setScaleType,
+    setPowerCompare,
     setQuickFilterVendors,
     setQuickFilterFrameworks,
     setQuickFilterDeployment,
@@ -1948,7 +1986,9 @@ export function InferenceProvider({
         display={displayValue}
         actions={actionsValue}
       >
-        {children}
+        <PerfRulerStoreContext.Provider value={perfRulerStore}>
+          {children}
+        </PerfRulerStoreContext.Provider>
       </InferenceContextsProvider>
       <EngineComparisonConflictToast
         detail={isUnofficialRun ? null : engineConflict}
diff --git a/packages/app/src/components/inference/agentic-point/point-summary.test.ts b/packages/app/src/components/inference/agentic-point/point-summary.test.ts
index 4dbfd8288..63d31ce6c 100644
--- a/packages/app/src/components/inference/agentic-point/point-summary.test.ts
+++ b/packages/app/src/components/inference/agentic-point/point-summary.test.ts
@@ -110,6 +110,25 @@ describe('PointSummary', () => {
     expect(html).toContain('vLLM Router 0.1.14');
   });
 
+  it('links an agentic point to its configuration on the Prefix Cache Reuse tab', () => {
+    const html = renderToStaticMarkup(
+      createElement(PointSummary, { meta: meta({ model: 'dsr1', disagg: false }) }),
+    );
+
+    expect(html).toContain('Prefix cache reuse for this config');
+    expect(html).toContain(
+      'href="/cache-reuse?g_model=DeepSeek-R1-0528&amp;i_seq=agentic-traces&amp;i_prec=fp8&amp;c_cfg=gb200_dynamo-vllm"',
+    );
+  });
+
+  it('offers no cache-reuse link for a fixed-sequence point', () => {
+    const html = renderToStaticMarkup(
+      createElement(PointSummary, { meta: meta({ benchmark_type: 'single_turn' }) }),
+    );
+
+    expect(html).not.toContain('cache-reuse-link');
+  });
+
   it('renders runtime metadata labels in Simplified Chinese on /zh', () => {
     localeState.pathname = '/zh/inference/agentic/206885';
     const html = renderToStaticMarkup(
diff --git a/packages/app/src/components/inference/agentic-point/point-summary.tsx b/packages/app/src/components/inference/agentic-point/point-summary.tsx
index 99c10cf2b..7a38d672b 100644
--- a/packages/app/src/components/inference/agentic-point/point-summary.tsx
+++ b/packages/app/src/components/inference/agentic-point/point-summary.tsx
@@ -7,6 +7,7 @@ import { frameworkFamily } from '@/lib/framework-family';
 import type { Locale } from '@/lib/i18n';
 import { isKvOffloadEnabled } from '@/lib/kv-offload';
 import { useLocale } from '@/lib/use-locale';
+import { CacheReuseLink } from '@/components/inference/ui/CacheReuseLink';
 import {
   offloadTypeLabel,
   versionedComponentLabel,
@@ -91,16 +92,24 @@ export function PointSummary({ meta }: { meta: PointMeta }) {
           {!meta.disagg && meta.is_multinode ? ` · ${t.multiNodeAggregate}` : ''}
           {meta.spec_method && meta.spec_method !== 'none' ? ` · spec=${meta.spec_method}` : ''}
         </p>
-        {meta.run_url && (
-          <a
-            href={meta.run_url}
-            target="_blank"
-            rel="noopener noreferrer"
-            className="text-xs text-muted-foreground hover:text-foreground underline"
-          >
-            {t.githubRun}
-          </a>
-        )}
+        <div className="flex flex-wrap items-baseline justify-end gap-x-4 gap-y-1">
+          {meta.benchmark_type === 'agentic_traces' && (
+            <CacheReuseLink
+              point={meta}
+              className="text-xs text-muted-foreground hover:text-foreground underline"
+            />
+          )}
+          {meta.run_url && (
+            <a
+              href={meta.run_url}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="text-xs text-muted-foreground hover:text-foreground underline"
+            >
+              {t.githubRun}
+            </a>
+          )}
+        </div>
       </div>
       <div className="grid grid-cols-2 sm:grid-cols-3 lg:grid-cols-6 gap-3">
         <MetaLine label={t.offloadType} value={offloadDisplay(meta, locale)} />
diff --git a/packages/app/src/components/inference/axis-metric-explanations.ts b/packages/app/src/components/inference/axis-metric-explanations.ts
index 220703207..5ce643e70 100644
--- a/packages/app/src/components/inference/axis-metric-explanations.ts
+++ b/packages/app/src/components/inference/axis-metric-explanations.ts
@@ -431,6 +431,116 @@ export const METRIC_EXPLANATIONS: Record<MetricKey, MetricExplanation> = {
       zh: '% TDP = 每芯片实测平均功耗（W）÷ 额定 TDP（W）× 100',
     },
   },
+  measuredPowerTimeline: {
+    description: {
+      en:
+        `The per-second accelerator power samples behind each measured average, drawn over ` +
+        `the whole benchmark job (server start, warmup, and the validated measurement window, ` +
+        `which is emphasized). One trace per config, mean of its GPUs by default; the rated TDP ` +
+        `is a dashed reference per hardware. Configs whose telemetry artifact is missing are ` +
+        `listed under the chart rather than estimated.${MEASURED_TIER_NOTE_EN}`,
+      zh:
+        `每个实测平均值背后的逐秒加速器功耗采样，覆盖整个基准测试任务（服务启动、warmup ` +
+        `以及被突出显示的有效测量窗口）。每个配置一条曲线，默认取其 GPU 的平均值；` +
+        `每种硬件的额定 TDP 以虚线作为参考。缺少遥测产物的配置会列在图表下方，而不会用估算值代替。${
+          MEASURED_TIER_NOTE_ZH
+        }`,
+    },
+    formula: {
+      en: 'W(t) = mean over GPUs of the sampled power draw in each one-second bucket',
+      zh: 'W(t) = 每个一秒时间桶内各 GPU 功耗采样值的平均',
+    },
+  },
+  gpuProvisionedWatts: {
+    description: {
+      en:
+        'Rated accelerator TDP from the hardware registry, shown as a flat per-chip value so ' +
+        'measured power can be read against the GPU-only provisioning boundary. It does not ' +
+        'depend on the run.',
+      zh:
+        '取硬件注册表中的加速器额定 TDP，以每芯片恒定值显示，用于对照 GPU 侧的额定供电边界与实测功耗。' +
+        '该值与具体运行无关。',
+    },
+    formula: {
+      en: 'W/GPU = rated TDP (W)',
+      zh: 'W/GPU = 额定 TDP（W）',
+    },
+  },
+  gpuProvisionedJPerOutputToken: {
+    description: {
+      en:
+        'Energy per output token if every allocated accelerator drew exactly its rated TDP for ' +
+        'the whole run. Disaggregated deployments count prefill and decode GPUs together, so ' +
+        'this is the GPU-only provisioning boundary the measured J/token can be compared against.',
+      zh:
+        '假设所有已分配加速器在整个运行中恒以额定 TDP 耗电时的每输出 token 能耗。' +
+        '分离式部署将 prefill 与 decode GPU 一并计入，因此它是可与实测 J/token 对照的 GPU 侧额定边界。',
+    },
+    formula: {
+      en: 'J/tok = rated TDP (W) × allocated GPUs ÷ total output tokens per second',
+      zh: 'J/tok = 额定 TDP（W）× 已分配 GPU 数 ÷ 总输出 token 吞吐（tok/s）',
+    },
+  },
+  utilityProvisionedWatts: {
+    description: {
+      en:
+        'All-in provisioned power per chip from the hardware registry: the utility-side capacity ' +
+        'a data center reserves for one accelerator including host, networking, cooling and ' +
+        'power-conversion overheads. It is a flat value independent of the run.',
+      zh:
+        '取硬件注册表中的每芯片全电源配置功耗：数据中心为单张加速器预留的电源侧容量，' +
+        '包含主机、网络、散热与电源转换开销。该值为恒定值，与运行无关。',
+    },
+    formula: {
+      en: 'W/GPU = all-in provisioned power per GPU (kW) × 1000',
+      zh: 'W/GPU = 每 GPU 全电源配置功耗（kW）× 1000',
+    },
+  },
+  utilityProvisionedJPerOutputToken: {
+    description: {
+      en:
+        'Energy per output token at the all-in provisioned power boundary, normalized by every ' +
+        'allocated accelerator. It differs from the public All-in Provisioned J per Output Token ' +
+        'metric only for disaggregated runs, where that metric normalizes by decode GPUs alone.',
+      zh:
+        '在全电源配置边界下的每输出 token 能耗，按全部已分配加速器归一。' +
+        '仅在分离式运行中与公开的 All-in Provisioned J per Output Token 指标不同，后者只按 decode GPU 归一。',
+    },
+    formula: {
+      en: 'J/tok = all-in provisioned power per GPU (W) × allocated GPUs ÷ total output tokens per second',
+      zh: 'J/tok = 每 GPU 全电源配置功耗（W）× 已分配 GPU 数 ÷ 总输出 token 吞吐（tok/s）',
+    },
+  },
+  utilityModeledWatts: {
+    description: {
+      en:
+        'Modeled facility power per allocated accelerator: measured GPU power is scaled to chassis ' +
+        'AC by the system power model and then multiplied once by PUE. Only hardware with a known ' +
+        'eight-GPU chassis profile on 8k1k runs is supported; NVL72 systems show no value.',
+      zh:
+        '每已分配加速器的数据中心建模功耗：先由系统功耗模型将 GPU 实测功耗换算为机箱交流功耗，再乘以一次 PUE。' +
+        '仅支持在 8k1k 运行中具有已知八卡机箱模型的硬件；NVL72 系统不显示数值。',
+    },
+    formula: {
+      en: 'W/GPU = modeled chassis AC power (W) × PUE ÷ allocated GPUs',
+      zh: 'W/GPU = 机箱交流建模功耗（W）× PUE ÷ 已分配 GPU 数',
+    },
+  },
+  utilityModeledJPerOutputToken: {
+    description: {
+      en:
+        'Measured energy per output token scaled to the modeled facility boundary, so its ratio to ' +
+        'measured GPU energy equals the ratio of modeled facility power to measured GPU power. ' +
+        'Missing where the system power model or validated measured power is unavailable.',
+      zh:
+        '将实测每输出 token 能耗按建模的数据中心边界缩放，其与 GPU 实测能耗之比等于数据中心建模功耗与 GPU 实测功耗之比。' +
+        '系统功耗模型或通过验证的实测功耗缺失时不显示。',
+    },
+    formula: {
+      en: 'J/tok = measured J per output token × modeled facility W per GPU ÷ measured W per GPU',
+      zh: 'J/tok = 实测每输出 token 能耗 × 每 GPU 数据中心建模功耗（W）÷ 每 GPU 实测功耗（W）',
+    },
+  },
 };
 
 /**
diff --git a/packages/app/src/components/inference/hooks/useChartData.ts b/packages/app/src/components/inference/hooks/useChartData.ts
index fecdfcd0f..7edd3955d 100644
--- a/packages/app/src/components/inference/hooks/useChartData.ts
+++ b/packages/app/src/components/inference/hooks/useChartData.ts
@@ -11,6 +11,7 @@ import type {
   ChartDefinition,
   HardwareConfig,
   InferenceData,
+  PowerCompare,
   RenderableGraph,
   TokenRevenuePricing,
   TokenRevenuePriceSource,
@@ -21,6 +22,7 @@ import {
   usesTokenSalePricing,
 } from '@/components/inference/token-revenue';
 import { partitionChartDataByLimits } from '@/components/inference/utils';
+import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
 import {
   parseComparisonEntry,
   resolveComparisonEntries,
@@ -270,6 +272,8 @@ export function useChartData(
   tcoBasis: TcoBasis = DEFAULT_TCO_BASIS,
   /** Opt-in from the inference page only; explicit date/run/history views opt out. */
   allowDefaultRunPreference = false,
+  /** Sibling boundary / role series appended to a gated power metric (`i_pcompare`). */
+  powerCompare: PowerCompare = 'none',
 ) {
   // When the selected date is the latest available, use '' (empty string) to match
   // the initial no-date query key, reusing the eagerly-fetched benchmarks from the
@@ -692,8 +696,14 @@ export function useChartData(
         );
         const hasMetric = metricData.length > 0;
         const isTtftX = typeof xAxisField === 'string' && xAxisField.endsWith('_ttft');
+        // Comparison clones are appended after the remap so they share the
+        // base point's x and differ only in y and `powerVariant`.
         const mappedData = hasMetric
-          ? metricData.map((d) => remapInferencePoint(d, metricKey, xAxisField))
+          ? expandPowerCompareSeries(
+              metricData.map((d) => remapInferencePoint(d, metricKey, xAxisField)),
+              selectedYAxisMetric,
+              powerCompare,
+            )
           : [];
 
         const isAgentic = selectedSequence === Sequence.AgenticTraces;
@@ -730,6 +740,7 @@ export function useChartData(
     compareGpuPair,
     selectedPercentile,
     quickFilters,
+    powerCompare,
   ]);
 
   // Points that pass every scope filter but NOT the y-metric coverage filter.
diff --git a/packages/app/src/components/inference/measured-metric-config.test.ts b/packages/app/src/components/inference/measured-metric-config.test.ts
index 47c356f22..f7b4de74c 100644
--- a/packages/app/src/components/inference/measured-metric-config.test.ts
+++ b/packages/app/src/components/inference/measured-metric-config.test.ts
@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'vitest';
 
-import { MEASURED_ENERGY_METRIC_CONFIG_KEYS, METRIC_CONFIG_KEYS } from './metric-registry';
+import {
+  MEASURED_ENERGY_METRIC_CONFIG_KEYS,
+  METRIC_CONFIG_KEYS,
+  POWER_BASIS_METRIC_CONFIG_KEYS,
+} from './metric-registry';
+import { POWER_BASES } from '@/lib/power-basis';
 import {
   changeMeasuredMetricConfig,
   getMeasuredMetricConfig,
@@ -18,10 +23,23 @@ describe('measured metric configuration', () => {
     },
   );
 
+  it.each(POWER_BASIS_METRIC_CONFIG_KEYS)('round-trips the power-boundary metric %s', (key) => {
+    const config = getMeasuredMetricConfig(key);
+    expect(config).toBeDefined();
+    expect(config?.basis).not.toBe('gpu-measured');
+    expect(changeMeasuredMetricConfig(key, {})).toBe(key);
+    expect(changeMeasuredMetricConfig('y_tpPerGpu', config!)).toBe(key);
+  });
+
   it('does not group unrelated metrics or unknown persisted values', () => {
     const grouped = METRIC_CONFIG_KEYS.filter((key) => getMeasuredMetricConfig(key));
-    expect(grouped).toHaveLength(13);
-    expect(new Set(grouped)).toEqual(new Set(MEASURED_ENERGY_METRIC_CONFIG_KEYS));
+    expect(grouped).toHaveLength(20);
+    expect(new Set(grouped)).toEqual(
+      new Set([...MEASURED_ENERGY_METRIC_CONFIG_KEYS, ...POWER_BASIS_METRIC_CONFIG_KEYS]),
+    );
+    for (const key of MEASURED_ENERGY_METRIC_CONFIG_KEYS) {
+      expect(getMeasuredMetricConfig(key)?.basis, key).toBe('gpu-measured');
+    }
     expect(getMeasuredMetricConfig('y_modeledChassisPowerPerGpu')).toBeUndefined();
     expect(getMeasuredMetricConfig('y_removedMetric')).toBeUndefined();
     expect(getMeasuredMetricConfig('')).toBeUndefined();
@@ -42,6 +60,7 @@ describe('measured metric configuration', () => {
   it('keeps fleet percentiles, role averages and TDP normalization distinct', () => {
     expect(getMeasuredMetricConfig('y_measuredP90Power')).toEqual({
       family: 'power',
+      basis: 'gpu-measured',
       scope: 'all',
       statistic: 'p90',
       display: 'watts',
@@ -69,6 +88,36 @@ describe('measured metric configuration', () => {
     ).toBe('y_measuredDecodeAvgPower');
   });
 
+  it('offers the telemetry timeline only for the whole-deployment average', () => {
+    expect(getMeasuredMetricConfig('y_measuredPowerTimeline')).toEqual({
+      family: 'power',
+      basis: 'gpu-measured',
+      scope: 'all',
+      statistic: 'average',
+      display: 'timeline',
+    });
+    expect(changeMeasuredMetricConfig('y_measuredAvgPower', { display: 'timeline' })).toBe(
+      'y_measuredPowerTimeline',
+    );
+    expect(changeMeasuredMetricConfig('y_measuredPowerPercentTdp', { display: 'timeline' })).toBe(
+      'y_measuredPowerTimeline',
+    );
+    // Percentiles and role scopes have no per-second trace; they fall back to watts.
+    expect(changeMeasuredMetricConfig('y_measuredPowerTimeline', { statistic: 'p90' })).toBe(
+      'y_measuredP90Power',
+    );
+    expect(changeMeasuredMetricConfig('y_measuredPowerTimeline', { scope: 'prefill' })).toBe(
+      'y_measuredPrefillAvgPower',
+    );
+    expect(changeMeasuredMetricConfig('y_measuredP75Power', { display: 'timeline' })).toBe(
+      'y_measuredP75Power',
+    );
+    // Leaving the timeline for energy and coming back lands on the family default.
+    expect(changeMeasuredMetricConfig('y_measuredPowerTimeline', { family: 'energy' })).toBe(
+      'y_measuredJPerOutputToken',
+    );
+  });
+
   it('changes the energy denominator without silently attributing whole-run energy to a role', () => {
     expect(changeMeasuredMetricConfig('y_measuredJPerOutputToken', { denominator: 'input' })).toBe(
       'y_measuredJPerInputToken',
@@ -78,6 +127,7 @@ describe('measured metric configuration', () => {
     );
     expect(getMeasuredMetricConfig('y_measuredPrefillJPerInputToken')).toEqual({
       family: 'energy',
+      basis: 'gpu-measured',
       scope: 'prefill',
       denominator: 'input',
       unit: 'joules',
@@ -110,4 +160,93 @@ describe('measured metric configuration', () => {
       changeMeasuredMetricConfig('y_measuredPrefillJPerInputToken', { unit: 'wattHours' }),
     ).toBe('y_measuredPrefillJPerInputToken');
   });
+
+  it('keeps the existing share-link defaults on the GPU-measured boundary', () => {
+    expect(getMeasuredMetricConfig(MEASURED_METRIC_DEFAULTS.power)?.basis).toBe('gpu-measured');
+    expect(getMeasuredMetricConfig(MEASURED_METRIC_DEFAULTS.energy)?.basis).toBe('gpu-measured');
+    expect(POWER_BASES[0]).toBe('gpu-measured');
+  });
+
+  it('snaps a boundary change to that boundary’s canonical combination', () => {
+    // The P90 statistic has no provisioned counterpart: choosing the boundary
+    // moves to its whole-deployment average watts.
+    expect(changeMeasuredMetricConfig('y_measuredP90Power', { basis: 'gpu-provisioned' })).toBe(
+      'y_gpuProvisionedWatts',
+    );
+    expect(
+      changeMeasuredMetricConfig('y_measuredPowerPercentTdp', { basis: 'utility-provisioned' }),
+    ).toBe('y_utilityProvisionedWatts');
+    expect(
+      changeMeasuredMetricConfig('y_measuredDecodeAvgPower', { basis: 'utility-modeled' }),
+    ).toBe('y_utilityModeledWatts');
+    // Role- and query-scoped energy snap to joules per output token.
+    expect(
+      changeMeasuredMetricConfig('y_measuredPrefillJPerInputToken', { basis: 'utility-modeled' }),
+    ).toBe('y_utilityModeledJPerOutputToken');
+    expect(
+      changeMeasuredMetricConfig('y_measuredWhPerSuccessfulQuery', { basis: 'gpu-provisioned' }),
+    ).toBe('y_gpuProvisionedJPerOutputToken');
+    // Boundary-to-boundary moves stay within the family.
+    expect(
+      changeMeasuredMetricConfig('y_gpuProvisionedWatts', { basis: 'utility-provisioned' }),
+    ).toBe('y_utilityProvisionedWatts');
+    expect(
+      changeMeasuredMetricConfig('y_utilityModeledJPerOutputToken', { basis: 'gpu-provisioned' }),
+    ).toBe('y_gpuProvisionedJPerOutputToken');
+    // A boundary requested together with other dimensions wins over them.
+    expect(
+      changeMeasuredMetricConfig('y_measuredAvgPower', {
+        basis: 'utility-modeled',
+        statistic: 'p90',
+      }),
+    ).toBe('y_utilityModeledWatts');
+  });
+
+  it('returns to GPU-measured telemetry from a boundary', () => {
+    expect(changeMeasuredMetricConfig('y_gpuProvisionedWatts', { basis: 'gpu-measured' })).toBe(
+      'y_measuredAvgPower',
+    );
+    expect(
+      changeMeasuredMetricConfig('y_utilityProvisionedJPerOutputToken', { basis: 'gpu-measured' }),
+    ).toBe('y_measuredJPerOutputToken');
+    // Every other dimension exists only for telemetry, so changing one from a
+    // boundary lands on the nearest GPU-measured key rather than a dead end.
+    expect(changeMeasuredMetricConfig('y_utilityModeledWatts', { statistic: 'p75' })).toBe(
+      'y_measuredP75Power',
+    );
+    expect(changeMeasuredMetricConfig('y_gpuProvisionedWatts', { scope: 'decode' })).toBe(
+      'y_measuredDecodeAvgPower',
+    );
+    expect(changeMeasuredMetricConfig('y_utilityProvisionedWatts', { display: 'tdp' })).toBe(
+      'y_measuredPowerPercentTdp',
+    );
+    expect(
+      changeMeasuredMetricConfig('y_utilityModeledJPerOutputToken', { denominator: 'query' }),
+    ).toBe('y_measuredJPerSuccessfulQuery');
+    expect(changeMeasuredMetricConfig('y_gpuProvisionedJPerOutputToken', { scope: 'decode' })).toBe(
+      'y_measuredDecodeJPerOutputToken',
+    );
+    // Re-selecting the canonical value is still a dimension change and leaves the boundary.
+    expect(changeMeasuredMetricConfig('y_utilityModeledWatts', { statistic: 'average' })).toBe(
+      'y_measuredAvgPower',
+    );
+    expect(changeMeasuredMetricConfig('y_gpuProvisionedJPerOutputToken', { unit: 'joules' })).toBe(
+      'y_measuredJPerOutputToken',
+    );
+  });
+
+  it('keeps the boundary across a family switch', () => {
+    expect(changeMeasuredMetricConfig('y_utilityProvisionedWatts', { family: 'energy' })).toBe(
+      'y_utilityProvisionedJPerOutputToken',
+    );
+    expect(changeMeasuredMetricConfig('y_gpuProvisionedJPerOutputToken', { family: 'power' })).toBe(
+      'y_gpuProvisionedWatts',
+    );
+    expect(
+      changeMeasuredMetricConfig('y_tokensPerDollarH', {
+        family: 'energy',
+        basis: 'utility-modeled',
+      }),
+    ).toBe('y_utilityModeledJPerOutputToken');
+  });
 });
diff --git a/packages/app/src/components/inference/measured-metric-config.ts b/packages/app/src/components/inference/measured-metric-config.ts
index 555fbef2e..ff28546be 100644
--- a/packages/app/src/components/inference/measured-metric-config.ts
+++ b/packages/app/src/components/inference/measured-metric-config.ts
@@ -1,17 +1,27 @@
+import type { PowerBasis } from '@/lib/power-basis';
 import type { MetricConfigKey } from './metric-registry';
 
 export type MeasuredMetricFamily = 'power' | 'energy';
 type MeasuredScope = 'all' | 'prefill' | 'decode';
+/**
+ * How whole-deployment average power is shown: per-chip watts, percent of
+ * TDP, or the per-second telemetry trace behind the average (`timeline`, which
+ * ChartDisplay renders with `PowerTimeline` instead of the scatter chart).
+ */
+export type MeasuredPowerDisplay = 'watts' | 'tdp' | 'timeline';
 
 export type MeasuredMetricConfig =
   | {
       family: 'power';
+      /** Power boundary the key plots; only `gpu-measured` publishes the other dimensions. */
+      basis: PowerBasis;
       scope: MeasuredScope;
       statistic: 'average' | 'p75' | 'p90';
-      display: 'watts' | 'tdp';
+      display: MeasuredPowerDisplay;
     }
   | {
       family: 'energy';
+      basis: PowerBasis;
       scope: MeasuredScope;
       denominator: 'input' | 'output' | 'total' | 'query';
       unit: 'joules' | 'wattHours';
@@ -19,9 +29,10 @@ export type MeasuredMetricConfig =
 
 export type MeasuredMetricConfigChange = Partial<{
   family: MeasuredMetricFamily;
+  basis: PowerBasis;
   scope: MeasuredScope;
   statistic: 'average' | 'p75' | 'p90';
-  display: 'watts' | 'tdp';
+  display: MeasuredPowerDisplay;
   denominator: 'input' | 'output' | 'total' | 'query';
   unit: 'joules' | 'wattHours';
 }>;
@@ -31,51 +42,78 @@ export const MEASURED_METRIC_DEFAULTS = {
   energy: 'y_measuredJPerOutputToken',
 } as const satisfies Record<MeasuredMetricFamily, MetricConfigKey>;
 
+const measured = { basis: 'gpu-measured' } as const;
+
 // Presentation settings resolve to existing metrics; they do not own chart state.
 const MEASURED_METRIC_CONFIGS: readonly (readonly [MetricConfigKey, MeasuredMetricConfig])[] = [
-  ['y_measuredAvgPower', { family: 'power', scope: 'all', statistic: 'average', display: 'watts' }],
-  ['y_measuredP75Power', { family: 'power', scope: 'all', statistic: 'p75', display: 'watts' }],
-  ['y_measuredP90Power', { family: 'power', scope: 'all', statistic: 'p90', display: 'watts' }],
+  [
+    'y_measuredAvgPower',
+    { family: 'power', ...measured, scope: 'all', statistic: 'average', display: 'watts' },
+  ],
+  [
+    'y_measuredP75Power',
+    { family: 'power', ...measured, scope: 'all', statistic: 'p75', display: 'watts' },
+  ],
+  [
+    'y_measuredP90Power',
+    { family: 'power', ...measured, scope: 'all', statistic: 'p90', display: 'watts' },
+  ],
   [
     'y_measuredPrefillAvgPower',
-    { family: 'power', scope: 'prefill', statistic: 'average', display: 'watts' },
+    { family: 'power', ...measured, scope: 'prefill', statistic: 'average', display: 'watts' },
   ],
   [
     'y_measuredDecodeAvgPower',
-    { family: 'power', scope: 'decode', statistic: 'average', display: 'watts' },
+    { family: 'power', ...measured, scope: 'decode', statistic: 'average', display: 'watts' },
   ],
   [
     'y_measuredPowerPercentTdp',
-    { family: 'power', scope: 'all', statistic: 'average', display: 'tdp' },
+    { family: 'power', ...measured, scope: 'all', statistic: 'average', display: 'tdp' },
+  ],
+  [
+    'y_measuredPowerTimeline',
+    { family: 'power', ...measured, scope: 'all', statistic: 'average', display: 'timeline' },
   ],
   [
     'y_measuredJPerInputToken',
-    { family: 'energy', scope: 'all', denominator: 'input', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'all', denominator: 'input', unit: 'joules' },
   ],
   [
     'y_measuredJPerOutputToken',
-    { family: 'energy', scope: 'all', denominator: 'output', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'all', denominator: 'output', unit: 'joules' },
   ],
   [
     'y_measuredJPerTotalToken',
-    { family: 'energy', scope: 'all', denominator: 'total', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'all', denominator: 'total', unit: 'joules' },
   ],
   [
     'y_measuredPrefillJPerInputToken',
-    { family: 'energy', scope: 'prefill', denominator: 'input', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'prefill', denominator: 'input', unit: 'joules' },
   ],
   [
     'y_measuredDecodeJPerOutputToken',
-    { family: 'energy', scope: 'decode', denominator: 'output', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'decode', denominator: 'output', unit: 'joules' },
   ],
   [
     'y_measuredJPerSuccessfulQuery',
-    { family: 'energy', scope: 'all', denominator: 'query', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'all', denominator: 'query', unit: 'joules' },
   ],
   [
     'y_measuredWhPerSuccessfulQuery',
-    { family: 'energy', scope: 'all', denominator: 'query', unit: 'wattHours' },
+    { family: 'energy', ...measured, scope: 'all', denominator: 'query', unit: 'wattHours' },
   ],
+  // Derived boundaries publish one canonical combination per family: whole
+  // deployment, average watts, joules per output token (lib/power-basis.ts).
+  ...(
+    [
+      ['gpu-provisioned', 'y_gpuProvisionedWatts', 'y_gpuProvisionedJPerOutputToken'],
+      ['utility-provisioned', 'y_utilityProvisionedWatts', 'y_utilityProvisionedJPerOutputToken'],
+      ['utility-modeled', 'y_utilityModeledWatts', 'y_utilityModeledJPerOutputToken'],
+    ] as const satisfies readonly (readonly [PowerBasis, MetricConfigKey, MetricConfigKey])[]
+  ).flatMap(([basis, watts, energy]): (readonly [MetricConfigKey, MeasuredMetricConfig])[] => [
+    [watts, { family: 'power', basis, scope: 'all', statistic: 'average', display: 'watts' }],
+    [energy, { family: 'energy', basis, scope: 'all', denominator: 'output', unit: 'joules' }],
+  ]),
 ];
 
 export function getMeasuredMetricConfig(metric: string): MeasuredMetricConfig | undefined {
@@ -83,6 +121,8 @@ export function getMeasuredMetricConfig(metric: string): MeasuredMetricConfig |
   return config ? { ...config } : undefined;
 }
 
+const OTHER_DIMENSIONS = ['scope', 'statistic', 'display', 'denominator', 'unit'] as const;
+
 export function changeMeasuredMetricConfig(
   metric: string,
   change: MeasuredMetricConfigChange,
@@ -93,6 +133,21 @@ export function changeMeasuredMetricConfig(
     current?.family === family
       ? current
       : getMeasuredMetricConfig(MEASURED_METRIC_DEFAULTS[family])!;
+  // Choosing a derived boundary snaps the other dimensions to its canonical
+  // combination. Changing any of those dimensions while on a derived boundary
+  // returns to GPU-measured telemetry, the only basis that publishes variants,
+  // so every control change lands on a real key. A family switch keeps the
+  // boundary: the metric key is what carries it.
+  const changesOtherDimension = OTHER_DIMENSIONS.some((key) => change[key] !== undefined);
+  const basis =
+    change.basis ?? (changesOtherDimension ? 'gpu-measured' : (current ?? config).basis);
+  if (basis !== 'gpu-measured') {
+    return (
+      MEASURED_METRIC_CONFIGS.find(
+        ([, candidate]) => candidate.family === family && candidate.basis === basis,
+      )?.[0] ?? MEASURED_METRIC_DEFAULTS[family]
+    );
+  }
   let scope = change.scope ?? config.scope;
 
   if (config.family === 'power') {
@@ -103,6 +158,7 @@ export function changeMeasuredMetricConfig(
       MEASURED_METRIC_CONFIGS.find(
         ([, candidate]) =>
           candidate.family === 'power' &&
+          candidate.basis === 'gpu-measured' &&
           candidate.scope === scope &&
           candidate.statistic === statistic &&
           candidate.display === display,
@@ -123,6 +179,7 @@ export function changeMeasuredMetricConfig(
     MEASURED_METRIC_CONFIGS.find(
       ([, candidate]) =>
         candidate.family === 'energy' &&
+        candidate.basis === 'gpu-measured' &&
         candidate.scope === scope &&
         candidate.denominator === denominator &&
         candidate.unit === unit,
diff --git a/packages/app/src/components/inference/measured-power-direction.test.ts b/packages/app/src/components/inference/measured-power-direction.test.ts
index 44d2e4ff0..790df173f 100644
--- a/packages/app/src/components/inference/measured-power-direction.test.ts
+++ b/packages/app/src/components/inference/measured-power-direction.test.ts
@@ -3,6 +3,11 @@ import { describe, it, expect } from 'vitest';
 import chartDefinitions from '@/components/inference/metric-registry';
 import type { ChartDefinition, InferenceData } from '@/components/inference/types';
 import { sortRowsByYMetric } from '@/components/inference/ui/inference-table-sort';
+import {
+  isMeasuredPowerCurveMetric,
+  isPowerCurveMetric,
+  upperPowerEnvelope,
+} from '@/components/inference/utils/powerCurves';
 import {
   isFrontierEligible,
   paretoFrontForDirection,
@@ -29,6 +34,24 @@ const MEASURED_POWER_METRICS = [
   'y_measuredPrefillAvgPower',
   'y_measuredDecodeAvgPower',
   'y_measuredPowerPercentTdp',
+  // Derived power boundaries share the watts semantics: the declared corner
+  // drives the ascending table sort, while the chart itself draws the upper
+  // power envelope (asserted separately below), exactly like measured watts.
+  'y_gpuProvisionedWatts',
+  'y_utilityProvisionedWatts',
+  'y_utilityModeledWatts',
+] as const;
+
+const BASIS_WATT_METRICS = [
+  'y_gpuProvisionedWatts',
+  'y_utilityProvisionedWatts',
+  'y_utilityModeledWatts',
+] as const;
+
+const BASIS_ENERGY_METRICS = [
+  'y_gpuProvisionedJPerOutputToken',
+  'y_utilityProvisionedJPerOutputToken',
+  'y_utilityModeledJPerOutputToken',
 ] as const;
 
 const QUERY_ENERGY_METRICS = [
@@ -165,6 +188,46 @@ describe('measured-power Pareto direction', () => {
     }
   });
 
+  it.each(BASIS_ENERGY_METRICS)('%s is bilingual and lower-is-better', (metric) => {
+    expect(declaredDirection(interactivityDef, metric)).toBe('lower_right');
+    expect(declaredDirection(e2eDef, metric)).toBe('lower_left');
+    for (const chartDef of [interactivityDef, e2eDef]) {
+      expect(chartDef[metric]).toMatch(/\.y$/u);
+      expect(chartDef[`${metric}_label`]).toBeTruthy();
+      expect(chartDef[`${metric}_labelZh`]).toBeTruthy();
+    }
+    // Energy uses the Pareto corner, not the power envelope: the dominated
+    // sweep points drop out just as they do for measured joules.
+    expect(frontierConcs(interactivityDef, metric)).toEqual([1, 32]);
+    expect(frontierConcs(e2eDef, metric)).toEqual([256, 32]);
+  });
+
+  describe.each(BASIS_WATT_METRICS)('%s', (metric) => {
+    it('draws the upper power envelope, not the Pareto corner, like measured watts', () => {
+      // ScatterGraph/GPUGraph pick the curve by `isPowerCurveMetric`; a watt
+      // boundary that misses that set would hide every dominated sweep point
+      // under Optimal Only and, for a flat TDP series, collapse to one marker.
+      expect(isPowerCurveMetric(metric)).toBe(true);
+      expect(isPowerCurveMetric('y_measuredAvgPower')).toBe(true);
+      // Envelope-locked like measured watts: with Optimal Only on, a Pareto
+      // corner would keep one marker and draw no curve for a flat TDP series.
+      expect(isMeasuredPowerCurveMetric(metric)).toBe(true);
+      expect(isMeasuredPowerCurveMetric('y_modeledChassisPowerPerGpu')).toBe(false);
+      expect(isMeasuredPowerCurveMetric('y_measuredAvgPower')).toBe(true);
+
+      const metricField = (interactivityDef[metric] as string).replace(/\.y$/u, '');
+      const envelope = upperPowerEnvelope(sweepPoints(metricField), true).map((p) => p.conc);
+      // The 1400 W conc 8 peak survives on the envelope; the Pareto corner drops it.
+      expect(envelope).toContain(8);
+      expect(frontierConcs(interactivityDef, metric)).not.toContain(8);
+    });
+  });
+
+  it.each(BASIS_ENERGY_METRICS)('%s stays off the power-envelope path', (metric) => {
+    expect(isPowerCurveMetric(metric)).toBe(false);
+    expect(isMeasuredPowerCurveMetric(metric)).toBe(false);
+  });
+
   it('keeps %TDP bilingual while using the same per-hardware frontier as watts', () => {
     // A fixed hardware TDP rescales watts without changing dominance within
     // that hardware series. The shared sweep tests above exercise both axes.
diff --git a/packages/app/src/components/inference/metric-registry.test.ts b/packages/app/src/components/inference/metric-registry.test.ts
index 28045728e..c2944fa84 100644
--- a/packages/app/src/components/inference/metric-registry.test.ts
+++ b/packages/app/src/components/inference/metric-registry.test.ts
@@ -10,6 +10,7 @@ import {
   isBenchmarkMetricKey,
   isMeasuredEnergyConfigKey,
   isModeledSystemPowerConfigKey,
+  isPowerBasisConfigKey,
   isRoleLocalMeasuredEnergyConfigKey,
   MEASURED_ENERGY_METRIC_CONFIG_KEYS,
   METRIC_CONFIG_KEYS,
@@ -19,9 +20,11 @@ import {
   metricCostTier,
   metricForCostTier,
   metricOptionTitle,
+  POWER_BASIS_METRIC_CONFIG_KEYS,
   resolveMetricConfigKey,
   tokenMetricTypeForConfigKey,
 } from './metric-registry';
+import { POWER_BASIS_FIELDS } from '@/lib/power-basis';
 import type { YAxisMetricKey } from './types';
 
 describe('metric registry', () => {
@@ -39,6 +42,10 @@ describe('metric registry', () => {
     expect(e2e.y_costh_roofline).toBe('lower_left');
     expect(interactivity.y_measuredPowerPercentTdp_roofline).toBe('lower_right');
     expect(e2e.y_measuredPowerPercentTdp_roofline).toBe('lower_left');
+    for (const key of POWER_BASIS_METRIC_CONFIG_KEYS) {
+      expect(interactivity[`${key}_roofline`], key).toBe('lower_right');
+      expect(e2e[`${key}_roofline`], key).toBe('lower_left');
+    }
   });
 
   it('preserves metric-specific x overrides and bilingual labels', () => {
@@ -210,7 +217,52 @@ describe('metric registry', () => {
     );
 
     const measuredGroup = METRIC_CONTROL_GROUPS.find((group) => group.label === 'Measured Energy');
-    expect(measuredGroup?.metrics).toBe(MEASURED_ENERGY_METRIC_CONFIG_KEYS);
+    expect(measuredGroup?.gated).toBe(true);
+    expect(measuredGroup?.metrics).toEqual([
+      ...MEASURED_ENERGY_METRIC_CONFIG_KEYS,
+      ...POWER_BASIS_METRIC_CONFIG_KEYS,
+    ]);
+  });
+
+  it('files the derived power boundaries under the gate without a telemetry tier', () => {
+    // Every derived field lib/power-basis.ts can emit is selectable from the
+    // gated group, and none of them is mistaken for runner telemetry.
+    const basisFields = Object.values(POWER_BASIS_FIELDS).flatMap((fields) =>
+      Object.values(fields).map((field) => `y_${field}`),
+    );
+    expect([...POWER_BASIS_METRIC_CONFIG_KEYS].toSorted()).toEqual(basisFields.toSorted());
+    for (const key of POWER_BASIS_METRIC_CONFIG_KEYS) {
+      expect(key, key).not.toMatch(/^y_measured/u);
+      expect(isPowerBasisConfigKey(key), key).toBe(true);
+      expect(isMeasuredEnergyConfigKey(key), key).toBe(false);
+      expect(isModeledSystemPowerConfigKey(key), key).toBe(false);
+      expect(resolveMetricConfigKey(key), key).toBe(key);
+      const metric = METRIC_REGISTRY[key.slice(2) as keyof typeof METRIC_REGISTRY];
+      expect(chartDefinitions[0][key], key).toBe(metric.field);
+      expect(metric.labelZh, key).toMatch(/\p{Script=Han}/u);
+      expect(metric.titleZh, key).toMatch(/\p{Script=Han}/u);
+    }
+    for (const key of MEASURED_ENERGY_METRIC_CONFIG_KEYS) {
+      expect(isPowerBasisConfigKey(key), key).toBe(false);
+    }
+    expect(isPowerBasisConfigKey('y_modeledChassisPowerPerGpu')).toBe(false);
+    expect(isPowerBasisConfigKey('y_jOutput')).toBe(false);
+    // Watts keys stay token-agnostic; energy keys are output-token metrics, so
+    // the output-capable point filter admits them.
+    expect(tokenMetricTypeForConfigKey('y_utilityProvisionedWatts')).toBe('total');
+    expect(tokenMetricTypeForConfigKey('y_utilityProvisionedJPerOutputToken')).toBe('output');
+    expect(tokenMetricTypeForConfigKey('y_utilityModeledJPerOutputToken')).toBe('output');
+  });
+
+  it('keeps the all-GPU utility energy distinguishable from the per-decode-GPU jOutput', () => {
+    const labels = [
+      METRIC_REGISTRY.jOutput.label,
+      METRIC_REGISTRY.utilityProvisionedJPerOutputToken.label,
+      METRIC_REGISTRY.jOutput.labelZh,
+      METRIC_REGISTRY.utilityProvisionedJPerOutputToken.labelZh,
+    ];
+    expect(new Set(labels).size).toBe(labels.length);
+    expect(METRIC_REGISTRY.utilityProvisionedJPerOutputToken.title).toContain('all GPUs');
   });
 
   it('classifies measured-energy config keys', () => {
diff --git a/packages/app/src/components/inference/metric-registry.ts b/packages/app/src/components/inference/metric-registry.ts
index ccba918b1..9687c561d 100644
--- a/packages/app/src/components/inference/metric-registry.ts
+++ b/packages/app/src/components/inference/metric-registry.ts
@@ -386,6 +386,80 @@ export const METRIC_REGISTRY = {
     titleZh: '实测平均功耗占 TDP 百分比',
     polarity: 'lower',
   },
+  // The per-second telemetry behind `measuredAvgPower`. The field aliases the
+  // same average so the table view, availability panel, and share links keep
+  // working; ChartDisplay swaps the scatter chart for `PowerTimeline`, which
+  // fetches each point's `gpu_metrics_*` artifact and draws the trace. The
+  // label leads with "Measured Average Power", like the %TDP display, so a
+  // "Measured Power" search still finds only the family option.
+  measuredPowerTimeline: {
+    field: 'measuredPowerTimeline.y',
+    label: 'Measured Average Power per Chip over Time (W)',
+    labelZh: '每芯片实测平均功耗时间线（W）',
+    title: 'Measured Average Power per Chip over Time',
+    titleZh: '每芯片实测平均功耗时间线',
+    polarity: 'lower',
+  },
+  // Power boundaries beyond GPU-measured telemetry (`lib/power-basis.ts`).
+  // Each boundary publishes W per allocated GPU and J per output token; the
+  // Boundary select in the Measured controls resolves to these keys, so the
+  // metric key alone carries the boundary in share links. Keys deliberately
+  // lack the `measured` prefix: they are spec constants or model output, not
+  // telemetry, so the telemetry-only decorations must not treat them as such.
+  gpuProvisionedWatts: {
+    field: 'gpuProvisionedWatts.y',
+    label: 'GPU Provisioned Power per Chip (TDP, W)',
+    labelZh: '每芯片 GPU 额定功耗（TDP，W）',
+    title: 'GPU Provisioned Power per Chip (TDP)',
+    titleZh: '每芯片 GPU 额定功耗（TDP）',
+    polarity: 'lower',
+  },
+  gpuProvisionedJPerOutputToken: {
+    field: 'gpuProvisionedJPerOutputToken.y',
+    label: 'GPU Provisioned J per Output Token (TDP, J/tok)',
+    labelZh: '每输出 token GPU 额定能耗（TDP，J/tok）',
+    title: 'GPU Provisioned Joules per Output Token (TDP)',
+    titleZh: '每输出 token GPU 额定焦耳能耗（TDP）',
+    polarity: 'lower',
+  },
+  utilityProvisionedWatts: {
+    field: 'utilityProvisionedWatts.y',
+    label: 'Utility Provisioned Power per Chip (all-in, W)',
+    labelZh: '每芯片全电源配置功耗（all-in，W）',
+    title: 'Utility Provisioned Power per Chip (all-in)',
+    titleZh: '每芯片全电源配置功耗（all-in）',
+    polarity: 'lower',
+  },
+  // Unlike the ungated `jOutput`, which divides by output tokens per decode
+  // GPU, this normalizes by every allocated GPU (prefill + decode).
+  utilityProvisionedJPerOutputToken: {
+    field: 'utilityProvisionedJPerOutputToken.y',
+    label: 'Utility Provisioned J per Output Token, all GPUs (all-in, J/tok)',
+    labelZh: '每输出 token 全电源配置能耗，按全部 GPU 归一（all-in，J/tok）',
+    title: 'Utility Provisioned Joules per Output Token, all GPUs (all-in)',
+    titleZh: '每输出 token 全电源配置焦耳能耗，按全部 GPU 归一（all-in）',
+    polarity: 'lower',
+  },
+  // zh vocabulary shared with the Boundary select, its help text and the chart
+  // caption: B3 “全电源配置” (as the ungated jOutput/jTotal already say for
+  // all-in), B4 “数据中心建模” (measured GPU power carried through the chassis
+  // model to the utility meter).
+  utilityModeledWatts: {
+    field: 'utilityModeledWatts.y',
+    label: 'Utility Modeled Power per Chip (PUE, W)',
+    labelZh: '每芯片数据中心建模功耗（含 PUE，W）',
+    title: 'Utility Modeled Power per Chip (PUE)',
+    titleZh: '每芯片数据中心建模功耗（含 PUE）',
+    polarity: 'lower',
+  },
+  utilityModeledJPerOutputToken: {
+    field: 'utilityModeledJPerOutputToken.y',
+    label: 'Utility Modeled J per Output Token (PUE, J/tok)',
+    labelZh: '每输出 token 数据中心建模能耗（含 PUE，J/tok）',
+    title: 'Utility Modeled Joules per Output Token (PUE)',
+    titleZh: '每输出 token 数据中心建模焦耳能耗（含 PUE）',
+    polarity: 'lower',
+  },
 } as const satisfies Record<string, MetricDefinition>;
 
 export type MetricKey = keyof typeof METRIC_REGISTRY;
@@ -597,6 +671,7 @@ export const MEASURED_ENERGY_METRIC_CONFIG_KEYS = [
   'y_measuredJPerSuccessfulQuery',
   'y_measuredWhPerSuccessfulQuery',
   'y_measuredPowerPercentTdp',
+  'y_measuredPowerTimeline',
 ] as const satisfies readonly MetricConfigKey[];
 
 const MEASURED_ENERGY_METRIC_CONFIG_KEY_SET: ReadonlySet<string> = new Set(
@@ -618,6 +693,31 @@ export function isRoleLocalMeasuredEnergyConfigKey(configKey: string): boolean {
   return ROLE_LOCAL_MEASURED_ENERGY_METRIC_CONFIG_KEY_SET.has(configKey);
 }
 
+/**
+ * The derived power-boundary y-axes (GPU provisioned, utility provisioned,
+ * utility modeled) that share the gated Measured Energy group and its
+ * Boundary select. They are kept out of `MEASURED_ENERGY_METRIC_CONFIG_KEYS`
+ * on purpose: spec constants and model output carry no telemetry tier, so the
+ * legacy-power ring, tier tooltip line, and footer key do not apply to them.
+ */
+export const POWER_BASIS_METRIC_CONFIG_KEYS = [
+  'y_gpuProvisionedWatts',
+  'y_gpuProvisionedJPerOutputToken',
+  'y_utilityProvisionedWatts',
+  'y_utilityProvisionedJPerOutputToken',
+  'y_utilityModeledWatts',
+  'y_utilityModeledJPerOutputToken',
+] as const satisfies readonly MetricConfigKey[];
+
+const POWER_BASIS_METRIC_CONFIG_KEY_SET: ReadonlySet<string> = new Set(
+  POWER_BASIS_METRIC_CONFIG_KEYS,
+);
+
+/** Whether a y-axis config key plots a derived power boundary (B2–B4). */
+export function isPowerBasisConfigKey(configKey: string): boolean {
+  return POWER_BASIS_METRIC_CONFIG_KEY_SET.has(configKey);
+}
+
 export const MODELED_SYSTEM_POWER_METRIC_CONFIG_KEY = 'y_modeledChassisPowerPerGpu';
 
 /** Whether a y-axis config key plots the modeled chassis AC power metric. */
@@ -671,10 +771,13 @@ export const METRIC_CONTROL_GROUPS: readonly MetricControlGroup[] = [
   // Runner power telemetry and the chassis model built on it are still being
   // validated, so both groups stay behind the ↑↑↓↓ feature gate until the
   // measurements are stable enough to publish.
+  // The derived boundaries ride along so the same gate and the same
+  // shared-URL exception (a gated metric selected by `i_metric` still renders
+  // while locked) apply to them.
   {
     label: 'Measured Energy',
     labelZh: '实测能耗',
-    metrics: MEASURED_ENERGY_METRIC_CONFIG_KEYS,
+    metrics: [...MEASURED_ENERGY_METRIC_CONFIG_KEYS, ...POWER_BASIS_METRIC_CONFIG_KEYS],
     gated: true,
   },
   {
diff --git a/packages/app/src/components/inference/perf-ruler-store.test.ts b/packages/app/src/components/inference/perf-ruler-store.test.ts
new file mode 100644
index 000000000..22e50d0e8
--- /dev/null
+++ b/packages/app/src/components/inference/perf-ruler-store.test.ts
@@ -0,0 +1,246 @@
+// @vitest-environment jsdom
+import { act, createElement } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { track } from '@/lib/analytics';
+import { perfRulerAxisMetricKey } from '@/hooks/usePerfRulerAxisReset';
+import {
+  EMPTY_PERF_RULER_STATE,
+  nextPerfRulerState,
+  serializePerfRulers,
+} from '@/lib/d3-chart/layers/perf-ruler';
+
+import {
+  type PerfRulerStore,
+  PerfRulerStoreContext,
+  persistedPerfRulerAxisKey,
+  usePerfRulerStore,
+  usePerfRulerStoreValue,
+} from './perf-ruler-store';
+
+vi.mock('@/lib/analytics', () => ({ track: vi.fn() }));
+
+// `graphs` is always [interactivity, e2e]; ChartDisplay renders the e2e
+// graph as chart-0 for every non-interactivity x mode.
+const graphs = (e2eXField: string) => [
+  { chartDefinition: { chartType: 'interactivity', x_scale_field: 'p90_intvty' } },
+  { chartDefinition: { chartType: 'e2e', x_scale_field: e2eXField } },
+];
+
+describe('persisted perf-ruler store', () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  const CURVE_A = 'roofline-b200_trt_fp8';
+  const CURVE_B = 'roofline-mi355x_sglang_fp4';
+  const OVERLAY = 'overlay-roofline-h100_vllm_fp8_run1';
+  const AXIS = perfRulerAxisMetricKey('p90_e2el', 'y_totalTokensPerDollarTco');
+
+  interface Harness {
+    store: () => PerfRulerStore;
+    rerender: (axisMetricKey: string | null) => void;
+  }
+
+  /**
+   * Hosts the store hook the way `InferenceProvider` does and reads it back
+   * through `usePerfRulerStore`, so the test observes what a chart mounted
+   * under the provider observes.
+   */
+  function mountStore(
+    initialSerialized: string | undefined,
+    axisMetricKey: string | null,
+  ): Harness {
+    let latest!: PerfRulerStore;
+    let axisKey = axisMetricKey;
+    const Consumer = () => {
+      latest = usePerfRulerStore()!;
+      return null;
+    };
+    function Host() {
+      const store = usePerfRulerStoreValue('chart-0', initialSerialized, axisKey);
+      return createElement(
+        PerfRulerStoreContext.Provider,
+        { value: store },
+        createElement(Consumer),
+      );
+    }
+    const render = () => act(() => root.render(createElement(Host)));
+    render();
+    return {
+      store: () => latest,
+      rerender: (next) => {
+        axisKey = next;
+        render();
+      },
+    };
+  }
+
+  beforeEach(() => {
+    vi.mocked(track).mockClear();
+    container = document.createElement('div');
+    document.body.append(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+  });
+
+  it('is absent outside the provider so charts fall back to local state', () => {
+    let seen: PerfRulerStore | undefined | null = null;
+    const Consumer = () => {
+      seen = usePerfRulerStore();
+      return null;
+    };
+    act(() => root.render(createElement(Consumer)));
+    expect(seen).toBeUndefined();
+  });
+
+  it('parses the share link into pending rulers and commits nothing until curves exist', () => {
+    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B};120|${CURVE_A}|${OVERLAY}`, null);
+    expect(h.store().chartId).toBe('chart-0');
+    expect(h.store().state).toBe(EMPTY_PERF_RULER_STATE);
+    expect(h.store().pending).toEqual([
+      { id: 1, curveA: CURVE_A, curveB: CURVE_B, isoX: 41.5 },
+      { id: 2, curveA: CURVE_A, curveB: OVERLAY, isoX: 120 },
+    ]);
+    expect(serializePerfRulers(h.store().state)).toBe('');
+    expect(track).not.toHaveBeenCalled();
+  });
+
+  it('starts with no pending rulers when the link carries none or only garbage', () => {
+    expect(mountStore(undefined, null).store().pending).toBeNull();
+    act(() => root.unmount());
+    root = createRoot(container);
+    expect(mountStore('not-a-ruler', null).store().pending).toBeNull();
+  });
+
+  it('commits resolved rulers with fresh ids, keeps the rest pending, and reports the link once', () => {
+    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B};120|${CURVE_A}|${OVERLAY}`, AXIS);
+    // A ruler placed by hand before the link's curves resolved keeps its id.
+    act(() => {
+      h.store().setState((prev) => nextPerfRulerState(prev, { curve: 'x', isoX: 5 }));
+      h.store().setState((prev) => nextPerfRulerState(prev, { curve: 'y', isoX: 5 }));
+    });
+    expect(h.store().state.rulers.map((ruler) => ruler.id)).toEqual([1]);
+
+    const [official, overlay] = h.store().pending!;
+    act(() => h.store().commitPending([{ ...official, isoX: 42 }], [overlay]));
+    expect(h.store().state.rulers).toEqual([
+      { id: 1, curveA: 'x', curveB: 'y', isoX: 5 },
+      { id: 2, curveA: CURVE_A, curveB: CURVE_B, isoX: 42 },
+    ]);
+    expect(h.store().state.nextId).toBe(3);
+    expect(h.store().pending).toEqual([overlay]);
+    // One opened link is one restore: the event carries the number of
+    // rulers the link held, even though the curves resolve in two passes.
+    expect(track).toHaveBeenCalledTimes(1);
+    expect(track).toHaveBeenCalledWith('interactivity_perf_ruler_shared_load', { count: 2 });
+    expect(serializePerfRulers(h.store().state)).toBe(`5|x|y;42|${CURVE_A}|${CURVE_B}`);
+
+    act(() => h.store().commitPending([overlay], null));
+    expect(h.store().pending).toBeNull();
+    expect(h.store().state.rulers.map((ruler) => ruler.curveB)).toEqual(['y', CURVE_B, OVERLAY]);
+    expect(track).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not report a restore when only unmeasurable rulers were dropped', () => {
+    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B}`, AXIS);
+    act(() => h.store().commitPending([], null));
+    expect(h.store().pending).toBeNull();
+    expect(h.store().state).toBe(EMPTY_PERF_RULER_STATE);
+    expect(track).not.toHaveBeenCalled();
+  });
+
+  it('keeps share-link rulers through the first chart definition but resets on an axis change', () => {
+    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B}`, null);
+    // The first data arriving (null → key) is not an axis change.
+    h.rerender(AXIS);
+    expect(h.store().pending).toHaveLength(1);
+    // Loading a new data set (key → null → same key) is not one either.
+    h.rerender(null);
+    h.rerender(AXIS);
+    expect(h.store().pending).toHaveLength(1);
+
+    act(() => h.store().commitPending(h.store().pending!, null));
+    act(() => h.store().setState((prev) => nextPerfRulerState(prev, { curve: 'x', isoX: 5 })));
+    expect(h.store().state.rulers).toHaveLength(1);
+    expect(h.store().state.draft).not.toBeNull();
+
+    // Placed on the old axes: committed rulers, the draft, and anything still
+    // pending are gone once the y metric changes.
+    h.rerender(perfRulerAxisMetricKey('p90_e2el', 'y_tpPerGpu'));
+    expect(h.store().state.rulers).toEqual([]);
+    expect(h.store().state.draft).toBeNull();
+    expect(h.store().state.nextId).toBe(2);
+    expect(h.store().pending).toBeNull();
+    expect(serializePerfRulers(h.store().state)).toBe('');
+  });
+
+  it('discards pending rulers on an axis change even before any commit', () => {
+    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B}`, AXIS);
+    h.rerender(perfRulerAxisMetricKey('p90_ttft', 'y_totalTokensPerDollarTco'));
+    expect(h.store().pending).toBeNull();
+  });
+
+  it('discardPending drops the link rulers without touching committed ones', () => {
+    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B};9|${CURVE_A}|${OVERLAY}`, AXIS);
+    const [official, overlay] = h.store().pending!;
+    act(() => h.store().commitPending([official], [overlay]));
+    const committed = h.store().state;
+    act(() => h.store().discardPending());
+    expect(h.store().pending).toBeNull();
+    expect(h.store().state).toBe(committed);
+  });
+
+  describe('persistedPerfRulerAxisKey (axis identity of the rendered chart)', () => {
+    const Y = 'y_totalTokensPerDollarTco';
+
+    it('is null until a graph exists', () => {
+      expect(persistedPerfRulerAxisKey([], 'interactivity', Y)).toBeNull();
+    });
+
+    it('follows the graph the x mode renders, not graphs[0]', () => {
+      const interactivity = persistedPerfRulerAxisKey(graphs('p90_e2el'), 'interactivity', Y);
+      const e2e = persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', Y);
+      const ttft = persistedPerfRulerAxisKey(graphs('p90_ttft'), 'ttft', Y);
+      expect(new Set([interactivity, e2e, ttft]).size).toBe(3);
+      // A stable mode and data set keep the identity, so rulers survive
+      // reloads, legend toggles, and date changes.
+      expect(persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', Y)).toBe(e2e);
+    });
+
+    it('changes with the percentile and the y metric', () => {
+      const base = persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', Y);
+      expect(persistedPerfRulerAxisKey(graphs('p99_e2el'), 'e2e', Y)).not.toBe(base);
+      expect(persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', 'y_tpPerGpu')).not.toBe(base);
+    });
+
+    it('treats a derived agentic x mode as its own axis even when the e2e field is unchanged', () => {
+      // ChartDisplay overrides the e2e graph's x field for derived modes
+      // locally; the provider's definition still says p90_e2el.
+      expect(
+        persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e-normalized-interactivity', Y),
+      ).not.toBe(persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', Y));
+    });
+
+    it('falls back to the first graph when no graph matches the mode', () => {
+      // Mirrors ChartDisplay's `visibleGraphs` fallback: with only an
+      // interactivity graph, chart-0 renders it in every mode.
+      const only = [graphs('p90_e2el')[0]];
+      const key = persistedPerfRulerAxisKey(only, 'e2e', Y);
+      expect(key).not.toBeNull();
+      expect(persistedPerfRulerAxisKey(only, 'e2e', 'y_tpPerGpu')).not.toBe(key);
+    });
+  });
+
+  it('keeps the store identity stable across unrelated rerenders', () => {
+    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B}`, AXIS);
+    const before = h.store();
+    h.rerender(AXIS);
+    expect(h.store()).toBe(before);
+    expect(h.store().setState).toBe(before.setState);
+  });
+});
diff --git a/packages/app/src/components/inference/perf-ruler-store.ts b/packages/app/src/components/inference/perf-ruler-store.ts
new file mode 100644
index 000000000..98bbfd692
--- /dev/null
+++ b/packages/app/src/components/inference/perf-ruler-store.ts
@@ -0,0 +1,179 @@
+'use client';
+
+import {
+  type Dispatch,
+  type SetStateAction,
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+import { track } from '@/lib/analytics';
+import { perfRulerAxisMetricKey } from '@/hooks/usePerfRulerAxisReset';
+import {
+  EMPTY_PERF_RULER_STATE,
+  MAX_PERF_RULERS,
+  type PerfRulerMeasurement,
+  type PerfRulerState,
+  clearPerfRulers,
+  parsePerfRulers,
+} from '@/lib/d3-chart/layers/perf-ruler';
+
+/**
+ * @file perf-ruler-store.ts
+ * @description Provider-owned Perf Ruler state for the primary inference
+ * chart, so completed rulers persist in share links (`i_rulers`). Lives
+ * beside `InferenceContext` rather than inside it so `ScatterGraph` can
+ * consume the store without importing the (heavily mocked) provider module.
+ */
+
+/**
+ * The chart instance whose Perf Rulers persist in share links. `ChartDisplay`
+ * mounts the primary chart as `chart-${graphIndex}` and only graph 0 is ever
+ * visible; the replay chart (`replay-chart-0`) draws interpolated frames of
+ * the same curves and must NOT bind, or every ruler would render twice and
+ * the replay's prune pass could delete rulers the main chart still shows.
+ */
+export const PERSISTED_PERF_RULER_CHART_ID = 'chart-0';
+
+/**
+ * Perf-ruler store for the persisted chart. Lives in its own context rather
+ * than the Display domain so a ruler commit does not rerender every display
+ * consumer, and so harnesses that mount `InferenceContextsProvider` with
+ * static mock values (no store) keep the chart's component-local fallback.
+ *
+ * `state` holds COMMITTED rulers: the D3 layer renders them and `i_rulers`
+ * serializes them. `pending` holds rulers parsed from the share link whose
+ * curves may not have been drawn yet — data, `i_gpus`, comparison dates,
+ * and `?unofficialrun=` overlays all arrive after the chart's first draw,
+ * and the chart prunes any committed ruler whose curve path is absent from
+ * the DOM. The chart therefore commits a pending ruler only once BOTH of
+ * its curve paths exist (see the perf-ruler decoration effect in
+ * ScatterGraph); rulers whose curves never appear stay pending, invisible
+ * and unserialized, until an axis change or an explicit clear discards them.
+ */
+export interface PerfRulerStore {
+  chartId: string;
+  state: PerfRulerState;
+  setState: Dispatch<SetStateAction<PerfRulerState>>;
+  pending: readonly PerfRulerMeasurement[] | null;
+  /**
+   * Commit share-link rulers whose curves now exist (`resolved`, iso-x
+   * already clamped to the pair's overlap) and keep `remaining` pending.
+   */
+  commitPending: (
+    resolved: readonly PerfRulerMeasurement[],
+    remaining: readonly PerfRulerMeasurement[] | null,
+  ) => void;
+  /** Drop share-link rulers that were never committed (toggle-off, clear). */
+  discardPending: () => void;
+}
+
+/**
+ * Axis identity of the chart `ChartDisplay` renders as `chart-0`, for the
+ * store's axis reset. `graphs` is always `[interactivity, e2e]`, but
+ * ChartDisplay shows the e2e graph for every non-interactivity x mode
+ * (`visibleGraphs`), so the rendered chart — not `graphs[0]` — is what the
+ * rulers were placed on. The x mode itself is part of the identity as well:
+ * the derived agentic modes (e2e-normalized interactivity, …) override the
+ * e2e graph's `x_scale_field` inside ChartDisplay only, so here the same
+ * definition still reads `<pctl>_e2el` for those modes. Percentile changes
+ * are already encoded in `x_scale_field`. Null while no graph exists.
+ */
+export function persistedPerfRulerAxisKey(
+  graphs: readonly { chartDefinition: { chartType: string; x_scale_field: string } }[],
+  xAxisMode: string,
+  yAxisMetric: string,
+): string | null {
+  const wantedType = xAxisMode === 'interactivity' ? 'interactivity' : 'e2e';
+  const graph =
+    graphs.find((candidate) => candidate.chartDefinition.chartType === wantedType) ?? graphs[0];
+  if (!graph) return null;
+  return perfRulerAxisMetricKey(`${xAxisMode}:${graph.chartDefinition.x_scale_field}`, yAxisMetric);
+}
+
+/** Provided by `InferenceProvider`; exported for chart component tests. */
+export const PerfRulerStoreContext = createContext<PerfRulerStore | undefined>(undefined);
+
+/** The persisted-ruler store, or undefined outside `InferenceProvider`. */
+export function usePerfRulerStore(): PerfRulerStore | undefined {
+  return useContext(PerfRulerStoreContext);
+}
+
+/**
+ * Owns the persisted perf-ruler state. Exported so component tests can host a
+ * real store around a chart without the full provider.
+ *
+ * `axisMetricKey` is the persisted chart's axis identity
+ * ({@link persistedPerfRulerAxisKey}), or null while no chart definition exists.
+ * The axis reset runs HERE, not through `usePerfRulerAxisReset` in the chart:
+ * that hook adjusts state during the chart's render, which is only legal for
+ * the chart's own state — updating a provider's state from a child's render
+ * is a React error. Same semantics: a change of either axis metric clears
+ * committed rulers (redrawn curves would give a ratio nobody placed) and
+ * discards pending ones (they were placed on the old axes). The null → key
+ * transition on first data is not a change, so share-link rulers survive
+ * the load; the x-mode fallback for fixed sequences also settles before any
+ * chart definition exists.
+ */
+export function usePerfRulerStoreValue(
+  chartId: string,
+  initialSerialized: string | undefined,
+  axisMetricKey: string | null,
+): PerfRulerStore {
+  const [state, setState] = useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
+  const [pending, setPending] = useState<readonly PerfRulerMeasurement[] | null>(() => {
+    const parsed = parsePerfRulers(initialSerialized).rulers;
+    return parsed.length > 0 ? parsed : null;
+  });
+  // `interactivity_perf_ruler_shared_load` fires once per store — once per
+  // opened link — with the number of rulers the link carried, the first time
+  // any of them renders. Rulers commit per curve arrival (below), so a
+  // per-commit event would count one link several times with partial counts.
+  const linkRulerCountRef = useRef(pending?.length ?? 0);
+  const sharedLoadReportedRef = useRef(false);
+
+  const [appliedAxisMetricKey, setAppliedAxisMetricKey] = useState(axisMetricKey);
+  if (axisMetricKey !== null && axisMetricKey !== appliedAxisMetricKey) {
+    setAppliedAxisMetricKey(axisMetricKey);
+    if (appliedAxisMetricKey !== null) {
+      setState(clearPerfRulers);
+      setPending(null);
+    }
+  }
+
+  const commitPending = useCallback(
+    (
+      resolved: readonly PerfRulerMeasurement[],
+      remaining: readonly PerfRulerMeasurement[] | null,
+    ) => {
+      if (resolved.length > 0) {
+        setState((prev) => {
+          // Fresh ids from the live counter: a ruler placed by hand before the
+          // share-link rulers resolved must keep its own join key.
+          const rulers = [
+            ...prev.rulers,
+            ...resolved.map((ruler, index) => ({ ...ruler, id: prev.nextId + index })),
+          ];
+          while (rulers.length > MAX_PERF_RULERS) rulers.shift();
+          return { rulers, draft: prev.draft, nextId: prev.nextId + resolved.length };
+        });
+        if (!sharedLoadReportedRef.current) {
+          sharedLoadReportedRef.current = true;
+          track('interactivity_perf_ruler_shared_load', { count: linkRulerCountRef.current });
+        }
+      }
+      setPending(remaining);
+    },
+    [],
+  );
+  const discardPending = useCallback(() => setPending(null), []);
+
+  return useMemo(
+    () => ({ chartId, state, setState, pending, commitPending, discardPending }),
+    [chartId, state, pending, commitPending, discardPending],
+  );
+}
diff --git a/packages/app/src/components/inference/types.ts b/packages/app/src/components/inference/types.ts
index 5a74eeb2c..b91759d2b 100644
--- a/packages/app/src/components/inference/types.ts
+++ b/packages/app/src/components/inference/types.ts
@@ -6,6 +6,7 @@ import type { Model, Sequence } from '@/lib/data-mappings';
 import type { PowerTier } from '@/lib/power-tier';
 import type { SystemPowerEstimate } from '@/lib/modeled-system-power';
 import type { MetricKey } from './metric-registry';
+import type { PowerBasis } from '@/lib/power-basis';
 
 export type { WorkerPower };
 
@@ -347,8 +348,67 @@ export interface InferenceData extends Partial<Omit<AggDataEntry, AggDataConflic
   measuredJPerSuccessfulQuery?: { y: number; roof: boolean };
   measuredWhPerSuccessfulQuery?: { y: number; roof: boolean };
   measuredPowerPercentTdp?: { y: number; roof: boolean };
+  /** Alias of `measuredAvgPower` selecting the per-second telemetry timeline view. */
+  measuredPowerTimeline?: { y: number; roof: boolean };
+  /**
+   * Prefill pool energy per OUTPUT token for disaggregated rows:
+   * `prefill_joules_per_input_token` × (J/out ÷ J/in), i.e. carried onto the
+   * output-token axis by the served input:output ratio so it adds to
+   * `measuredDecodeJPerOutputToken` (utils/role-energy.ts, PowerX Figure 7).
+   */
+  reconstructedPrefillJPerOutputToken?: { y: number; roof: boolean };
+  /**
+   * Set on the clones a power comparison (`i_pcompare`) appends to the chart:
+   * which boundary or worker role this point's `y` came from. Base points of
+   * the selected metric never carry it (utils/power-compare.ts).
+   */
+  powerVariant?: PowerVariant;
+
+  // Power boundaries beyond the GPU-measured telemetry above (B1). Each pair is
+  // W per allocated GPU plus J per successful output token, normalized by every
+  // allocated GPU (prefill + decode for disaggregation). Emitted only when the
+  // value is finite and positive; see lib/power-basis.ts and
+  // docs/data-transforms.md "Power boundaries".
+  /** B2 W/GPU: HW_REGISTRY tdp. */
+  gpuProvisionedWatts?: { y: number; roof: boolean };
+  /** B2 J/out: tdp × N_alloc ÷ total output tok/s. */
+  gpuProvisionedJPerOutputToken?: { y: number; roof: boolean };
+  /** B3 W/GPU: HW_REGISTRY all-in power (kW × 1000). */
+  utilityProvisionedWatts?: { y: number; roof: boolean };
+  /**
+   * B3 J/out: all-in W × N_alloc ÷ total output tok/s. Unlike `jOutput`, which
+   * divides one decode GPU's all-in W by that GPU's output, this counts every
+   * allocated GPU, so it is (P + D) / D × `jOutput` on disaggregated rows.
+   */
+  utilityProvisionedJPerOutputToken?: { y: number; roof: boolean };
+  /** B4 W/GPU: modeled deployment facility watts (chassis AC × PUE, applied once) ÷ measured GPUs. */
+  utilityModeledWatts?: { y: number; roof: boolean };
+  /** B4 J/out: B1 `joules_per_output_token` × (B4 W ÷ B1 W); inherits B1's token denominator. */
+  utilityModeledJPerOutputToken?: { y: number; roof: boolean };
 }
 
+/**
+ * Sibling series the gated power charts can overlay on the selected metric:
+ * every boundary (PowerX Figures 2/3) or every worker role (Figures 6/7).
+ * Rides on the `i_pcompare` URL parameter; `none` draws the metric alone.
+ */
+export type PowerCompare = 'none' | 'boundaries' | 'roles';
+/** Worker-pool scope of a measured figure. */
+export type PowerRole = 'all' | 'prefill' | 'decode';
+/** Identity of one comparison series: a boundary or a role. */
+export type PowerVariant = { kind: 'basis'; id: PowerBasis } | { kind: 'role'; id: PowerRole };
+
+/** InferenceData keys carrying the B2–B4 power-boundary readings. */
+export type PowerBasisFieldKey =
+  | 'gpuProvisionedWatts'
+  | 'gpuProvisionedJPerOutputToken'
+  | 'utilityProvisionedWatts'
+  | 'utilityProvisionedJPerOutputToken'
+  | 'utilityModeledWatts'
+  | 'utilityModeledJPerOutputToken';
+
+export type { PowerBasis } from '@/lib/power-basis';
+
 /** Why a chart-ready point was intentionally excluded from the visible plot. */
 export type ChartClipReason = 'cost' | 'latency';
 
@@ -654,6 +714,8 @@ export interface InferenceDisplayContextType {
   selectedE2eXAxisMetric: string | null;
   selectedXAxisMode: 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity';
   scaleType: 'auto' | 'linear' | 'log';
+  /** Comparison series overlaid on a gated power metric (`i_pcompare`). */
+  powerCompare: PowerCompare;
   isLegendExpanded: boolean;
   hideNonOptimal: boolean;
   showAllMeasurements: boolean;
@@ -699,6 +761,7 @@ export interface InferenceActionsContextType {
     mode: 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity',
   ) => void;
   setScaleType: (type: 'auto' | 'linear' | 'log') => void;
+  setPowerCompare: (mode: PowerCompare) => void;
   setQuickFilterVendors: (vendors: string[]) => void;
   setQuickFilterFrameworks: (frameworks: string[]) => void;
   setQuickFilterDeployment: (modes: DeploymentMode[]) => void;
diff --git a/packages/app/src/components/inference/ui/CacheReuseLink.tsx b/packages/app/src/components/inference/ui/CacheReuseLink.tsx
new file mode 100644
index 000000000..4c7c213ec
--- /dev/null
+++ b/packages/app/src/components/inference/ui/CacheReuseLink.tsx
@@ -0,0 +1,36 @@
+'use client';
+
+import Link from 'next/link';
+
+import type { PointMeta } from '@/hooks/api/use-trace-server-metrics';
+import { track } from '@/lib/analytics';
+import { cacheReuseHref } from '@/lib/cache-reuse-link';
+import { useLocale } from '@/lib/use-locale';
+
+const STRINGS = {
+  en: { chart: 'Prefix cache reuse →', point: 'Prefix cache reuse for this config →' },
+  zh: { chart: '前缀缓存复用 →', point: '查看此配置的前缀缓存复用 →' },
+} as const;
+
+/** Agentic-only link into the Prefix Cache Reuse tab, from the chart footer or a point. */
+export function CacheReuseLink({ point, className }: { point?: PointMeta; className?: string }) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  return (
+    <Link
+      href={cacheReuseHref(locale, point)}
+      data-testid="cache-reuse-link"
+      className={
+        className ?? 'text-xs leading-5 text-muted-foreground underline hover:text-foreground'
+      }
+      onClick={() =>
+        track('inference_cache_reuse_link_clicked', {
+          from: point ? 'point' : 'chart',
+          ...(point ? { id: point.id } : {}),
+        })
+      }
+    >
+      {point ? t.point : t.chart}
+    </Link>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/ChartControls.tsx b/packages/app/src/components/inference/ui/ChartControls.tsx
index 1f896701a..726a6918c 100644
--- a/packages/app/src/components/inference/ui/ChartControls.tsx
+++ b/packages/app/src/components/inference/ui/ChartControls.tsx
@@ -61,6 +61,7 @@ import { MetricExplanation } from './MetricExplanation';
 import { PowerMetricAvailability } from './PowerMetricAvailability';
 import { MeasuredMetricControls } from './MeasuredMetricControls';
 import {
+  changeMeasuredMetricConfig,
   getMeasuredMetricConfig,
   MEASURED_METRIC_DEFAULTS,
   type MeasuredMetricFamily,
@@ -96,7 +97,7 @@ const STRINGS = {
     gpuConfig: 'Chip Config',
     gpuConfigTooltip:
       'Select up to 4 chip configurations to compare their historical performance over time. This allows for tracking how software updates may affect specific hardware.',
-    gpuConfigPlaceholder: 'Select a Chip Config for comparison',
+    gpuConfigPlaceholder: 'Select Chip Config',
     comparisonDateRange: 'Comparison Date Range',
     comparisonDateRangeTooltip:
       'Select the start and end dates for the historical comparison. The chart will show performance data for the selected chip configs across this time range.',
@@ -140,7 +141,7 @@ const STRINGS = {
     gpuConfig: '芯片配置',
     gpuConfigTooltip:
       '最多选择 4 个芯片配置以对比其历史性能趋势。可用于追踪软件更新对特定硬件的影响。',
-    gpuConfigPlaceholder: '选择芯片配置进行对比',
+    gpuConfigPlaceholder: '选择芯片配置',
     comparisonDateRange: '对比日期范围',
     comparisonDateRangeTooltip:
       '选择历史对比的起止日期。图表将展示所选芯片配置在此时间范围内的性能数据。',
@@ -230,6 +231,7 @@ export default function ChartControls({
     selectedXAxisMetric,
     selectedXAxisMode,
     scaleType,
+    powerCompare,
   } = useInferenceDisplay();
   const {
     setSelectedModel,
@@ -242,6 +244,7 @@ export default function ChartControls({
     setSelectedDateRange,
     setSelectedXAxisMetric,
     setScaleType,
+    setPowerCompare,
   } = useInferenceActions();
 
   // Y-axis options come from the canonical registry and need no API data.
@@ -335,10 +338,14 @@ export default function ChartControls({
         if (!config) return [option];
         if (seen.has(config.family)) return [];
         seen.add(config.family);
+        // Keep the selected boundary (and other dimensions) when hopping between
+        // the power and energy families; fall back to the family default otherwise.
         const value =
           selectedConfig?.family === config.family
             ? selectedYAxisMetric
-            : MEASURED_METRIC_DEFAULTS[config.family];
+            : selectedConfig
+              ? changeMeasuredMetricConfig(selectedYAxisMetric, { family: config.family })
+              : MEASURED_METRIC_DEFAULTS[config.family];
         return [
           {
             value,
@@ -571,6 +578,8 @@ export default function ChartControls({
                   <MeasuredMetricControls
                     metric={selectedYAxisMetric}
                     onChange={handleYAxisMetricChange}
+                    compare={powerCompare}
+                    onCompareChange={setPowerCompare}
                   />
                   <div className="col-span-full">
                     <PowerMetricAvailability
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index 39f8b6ce2..7bb22f900 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -14,6 +14,9 @@ import chartDefinitions, {
   type MetricKey,
 } from '@/components/inference/metric-registry';
 import { metricRowLabel } from '@/components/inference/axis-metric-explanations';
+import { getMeasuredMetricConfig } from '@/components/inference/measured-metric-config';
+import { AIR_COOLED_SYSTEM_PUE } from '@/lib/modeled-system-power';
+import { SYSTEM_POWER_MODEL_REVISION } from '@/lib/system-power-model';
 import {
   applyTokenRevenuePricing,
   cachedInputPricePerMillion,
@@ -46,6 +49,7 @@ import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
 import { bestSeriesPerSku } from '@/components/inference/utils/best-series-per-sku';
 import InferenceTable from '@/components/inference/ui/InferenceTable';
 import ScatterGraph from '@/components/inference/ui/ScatterGraph';
+import PowerTimeline from '@/components/inference/ui/PowerTimeline';
 import { Card } from '@/components/ui/card';
 import { ChartButtons } from '@/components/ui/chart-buttons';
 import { ShareButton } from '@/components/ui/share-button';
@@ -92,6 +96,7 @@ import { useLocale } from '@/lib/use-locale';
 
 import { ATOM_FOOTNOTE_MARKER, AtomEngineFootnote } from '@/components/ui/atom-engine-footnote';
 import { AgenticOptimizationNote } from '@/components/inference/ui/AgenticOptimizationNote';
+import { CacheReuseLink } from '@/components/inference/ui/CacheReuseLink';
 import { OffloadHaloLegendKey } from '@/components/inference/ui/OffloadHaloLegendKey';
 import { LegacyPowerLegendKey } from '@/components/inference/ui/LegacyPowerLegendKey';
 import { ActiveQuickFilters } from '@/components/inference/ui/ActiveQuickFilters';
@@ -139,6 +144,17 @@ const STRINGS = {
       'No benchmark data matches the current model, scenario, and filter selection. Adjust the filters above to see results.',
     noSystemPowerData:
       'No system-power estimates are available for this selection. Choose 8K / 1K with validated GPU telemetry, supported hardware, and known eight-GPU chassis placement. Measured GPU power remains available separately where telemetry exists.',
+    noUtilityModeledData:
+      'No utility modeled values are available for this selection. The utility modeled boundary needs 8K / 1K, validated GPU telemetry, and hardware covered by the chassis power model (not NVL72 systems). Choose another boundary to keep the points.',
+    // Boundary disclosures for the derived power axes (lib/power-basis.ts).
+    // Formulas in words; constants named so a screenshot records its method.
+    powerBasisAssumptions: {
+      'gpu-provisioned':
+        'GPU provisioned boundary · Watts are the rated TDP per GPU from the hardware registry, so the power curve is flat per hardware. Joules per output token = TDP × allocated GPUs ÷ whole-deployment output tok/s; disaggregated configurations count prefill and decode GPUs together. Hardware without a published TDP is omitted.',
+      'utility-provisioned':
+        'Utility provisioned boundary · Watts are the all-in provisioned utility power per GPU from the hardware registry (SemiAnalysis Datacenter Industry Model), so the power curve is flat per hardware. Joules per output token = all-in W × allocated GPUs ÷ whole-deployment output tok/s; disaggregated configurations count prefill and decode GPUs together, unlike the ungated All-in Provisioned J per Output Token, which divides per decode GPU.',
+      'utility-modeled': `Utility modeled boundary · Measured GPU power carried through the modeled chassis (CPU, DRAM, platform, PSU losses) to the utility meter: modeled chassis AC × PUE ${AIR_COOLED_SYSTEM_PUE} (air-cooled, applied once), divided by the measured GPUs; joules per output token scale measured joules by the same ratio. Chassis power model revision ${SYSTEM_POWER_MODEL_REVISION.slice(0, 7)}. Available for 8K / 1K with validated telemetry on supported hardware only; NVL72 systems (GB200, GB300) and points without values are omitted.`,
+    },
     vsTtft: (word: string) => `vs. ${word} Time To First Token`,
     vsE2eLatency: (pctl?: string) =>
       pctl ? `vs. ${pctl} End-to-end Latency` : 'vs. End-to-end Latency',
@@ -165,6 +181,15 @@ const STRINGS = {
     noChartData: '当前模型、场景与筛选条件下没有匹配的基准测试数据。请调整上方筛选条件查看结果。',
     noSystemPowerData:
       '当前选择没有可用的系统功耗估算。请选择 8K / 1K 场景；估算仅覆盖 GPU 遥测已验证、硬件受支持、八卡机箱位置已知的运行。存在遥测数据时，仍可单独查看 GPU 实测功耗。',
+    noUtilityModeledData:
+      '当前选择没有可用的数据中心建模数值。该边界需要 8K / 1K 场景、已验证的 GPU 遥测，且硬件在机箱功耗模型覆盖范围内（不含 NVL72 系统）。可切换到其他功耗边界以保留数据点。',
+    powerBasisAssumptions: {
+      'gpu-provisioned':
+        'GPU 额定边界 · 功率取硬件注册表中每 GPU 的额定 TDP，因此每种硬件的功率曲线为水平线。每输出 token 能耗 = TDP × 分配的 GPU 数 ÷ 整个部署的输出 tok/s；分离式配置将 prefill 与 decode GPU 一并计入。未公布 TDP 的硬件不绘制。',
+      'utility-provisioned':
+        '全电源配置边界 · 功率取硬件注册表中每 GPU 的全电源配置（all-in）市电功率（来源：SemiAnalysis Datacenter Industry Model），因此每种硬件的功率曲线为水平线。每输出 token 能耗 = all-in 功率 × 分配的 GPU 数 ÷ 整个部署的输出 tok/s；分离式配置将 prefill 与 decode GPU 一并计入，这与未加门控的“每输出 token 全电源配置能耗”按 decode GPU 计算不同。',
+      'utility-modeled': `数据中心建模边界 · 将 GPU 实测功耗经机箱功耗模型（CPU、DRAM、平台开销、PSU 损耗）推算至市电侧：机箱交流功耗估算 × PUE ${AIR_COOLED_SYSTEM_PUE}（风冷，仅应用一次），再除以实测 GPU 数；每输出 token 能耗按同一比例放大实测能耗。机箱功耗模型版本 ${SYSTEM_POWER_MODEL_REVISION.slice(0, 7)}。仅适用于 8K / 1K、遥测已验证且硬件受支持的运行；NVL72 系统（GB200、GB300）及缺少数值的数据点不绘制。`,
+    },
     vsTtft: (word: string) => `vs. ${word === 'Median' ? '中位' : word} 首 token 延迟（TTFT）`,
     vsE2eLatency: (pctl?: string) => (pctl ? `vs. ${pctl} 端到端延迟` : 'vs. 端到端延迟'),
   },
@@ -290,9 +315,19 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     selectedXAxisMode,
     tokenRevenuePricing,
     showLineLabels,
+    powerCompare,
   } = useInferenceDisplay();
   const { setSelectedDates, setSelectedDatesFromRunExpansion, setIsLegendExpanded } =
     useInferenceActions();
+  // The metric key carries the power boundary; the caption discloses it for
+  // the derived boundaries (there is no separate URL param).
+  const selectedPowerBasis = getMeasuredMetricConfig(selectedYAxisMetric)?.basis;
+  // The Measured Power "Timeline" display swaps the scatter body for the
+  // per-second telemetry traces (PowerTimeline); table view and captions are
+  // unchanged because the metric key aliases the measured average.
+  const selectedMeasuredConfig = getMeasuredMetricConfig(selectedYAxisMetric);
+  const isPowerTimeline =
+    selectedMeasuredConfig?.family === 'power' && selectedMeasuredConfig.display === 'timeline';
   const selectedBenchmarkType: 'single_turn' | 'agentic_traces' =
     selectedSequence === Sequence.AgenticTraces ? 'agentic_traces' : 'single_turn';
   const workflowInfoBenchmarkType =
@@ -455,6 +490,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
           selectedPercentile,
           tcoBasis,
           selectedXAxisMode,
+          powerCompare,
         },
       );
 
@@ -504,6 +540,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     selectedXAxisMetric,
     selectedE2eXAxisMetric,
     selectedPercentile,
+    powerCompare,
     selectedXAxisMode,
     tokenRevenuePricing,
     tcoBasis,
@@ -824,7 +861,9 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
               <p className="max-w-md text-center text-sm text-muted-foreground">
                 {isModeledSystemPowerConfigKey(selectedYAxisMetric)
                   ? t.noSystemPowerData
-                  : t.noChartData}
+                  : selectedPowerBasis === 'utility-modeled'
+                    ? t.noUtilityModeledData
+                    : t.noChartData}
               </p>
             </Card>,
           ]
@@ -883,6 +922,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                     {hasOffloadHalo && <OffloadHaloLegendKey />}
                     {hasLegacyPowerPoints && <LegacyPowerLegendKey />}
                     {isAgenticSequence && <AgenticOptimizationNote />}
+                    {isAgenticSequence && !minimalChrome && <CacheReuseLink />}
                     {hasAtomSeries && (
                       <AtomEngineFootnote className="min-w-0 flex-[1_1_24rem] text-xs leading-5" />
                     )}
@@ -1011,6 +1051,8 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                               {getSequenceLabel(graph.sequence as Sequence, locale)}{' '}
                               {metricChartTitle(graph.chartDefinition, selectedYAxisMetric, locale)}{' '}
                               {(() => {
+                                // The timeline's x axis is time, not the scatter x metric.
+                                if (isPowerTimeline) return null;
                                 const xField = graph.chartDefinition.x_scale_field;
                                 if (xField?.endsWith('_ttft')) {
                                   const percentile = xField.replace(/_ttft$/u, '');
@@ -1138,6 +1180,15 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                               {t.systemPowerAssumptions}
                             </p>
                           )}
+                          {selectedPowerBasis && selectedPowerBasis !== 'gpu-measured' && (
+                            <p
+                              className="mb-2 text-xs text-muted-foreground"
+                              data-testid="power-basis-assumptions"
+                              data-power-basis={selectedPowerBasis}
+                            >
+                              {t.powerBasisAssumptions[selectedPowerBasis]}
+                            </p>
+                          )}
                           {isUnofficialRun &&
                             selectedXAxisMode === 'e2e-normalized-interactivity' && (
                               <p className="mb-2 text-xs text-muted-foreground">
@@ -1187,11 +1238,42 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                         );
                       }
 
+                      if (isPowerTimeline) {
+                        return (
+                          <div className="relative">
+                            <PowerTimeline
+                              chartId={`chart-${graphIndex}`}
+                              // Display limits clip outliers from the scatter domain; the
+                              // timeline draws every measured config, so restore them.
+                              data={[
+                                ...graph.data,
+                                ...(graph.clippedData ?? []).map((entry) => entry.point),
+                              ]}
+                              overlayData={
+                                selectUnofficialOverlayForMode(
+                                  selectedXAxisMode,
+                                  graph.chartDefinition.chartType,
+                                  overlayDataByChartType,
+                                ) ?? undefined
+                              }
+                              yLabel={metricLabel(
+                                graph.chartDefinition,
+                                selectedYAxisMetric,
+                                locale,
+                              )}
+                              caption={chartCaption}
+                            />
+                          </div>
+                        );
+                      }
+
                       return isGpuComparison ? (
                         <GPUGraph
                           chartId={`chart-${graphIndex}`}
                           modelLabel={graph.model}
-                          data={graph.data}
+                          // Date comparison draws one hardware across runs; the
+                          // boundary / role siblings are a same-run overlay only.
+                          data={graph.data.filter((point) => !point.powerVariant)}
                           xLabel={resolvedXLabel}
                           yLabel={metricLabel(graph.chartDefinition, selectedYAxisMetric, locale)}
                           chartDefinition={graph.chartDefinition}
diff --git a/packages/app/src/components/inference/ui/GPUGraph.tsx b/packages/app/src/components/inference/ui/GPUGraph.tsx
index 01fc782eb..f5cb0c7e4 100644
--- a/packages/app/src/components/inference/ui/GPUGraph.tsx
+++ b/packages/app/src/components/inference/ui/GPUGraph.tsx
@@ -48,6 +48,7 @@ import {
   chartFrontier,
   upperPowerEnvelope,
   isPowerCurveMetric,
+  isPowerGaugeSeries,
   isMeasuredPowerCurveMetric,
 } from '@/components/inference/utils/powerCurves';
 import type {
@@ -443,10 +444,20 @@ const GPUGraph = React.memo(
       if (!powerEnvelopeMode) return paretoRooflines;
       const result: Record<string, InferenceData[]> = {};
       for (const [key, points] of Object.entries(groupedData)) {
-        result[key] = upperPowerEnvelope(points, chartDefinition.chartType !== 'e2e');
+        result[key] = upperPowerEnvelope(
+          points,
+          chartDefinition.chartType !== 'e2e',
+          isPowerGaugeSeries(selectedYAxisMetric, points[0]),
+        );
       }
       return result;
-    }, [powerEnvelopeMode, groupedData, paretoRooflines, chartDefinition.chartType]);
+    }, [
+      powerEnvelopeMode,
+      groupedData,
+      paretoRooflines,
+      chartDefinition.chartType,
+      selectedYAxisMetric,
+    ]);
 
     const boundaryPointKeys = useMemo(() => {
       const keys = new Set<string>();
diff --git a/packages/app/src/components/inference/ui/InferenceTable.tsx b/packages/app/src/components/inference/ui/InferenceTable.tsx
index b6cdafa7e..3e6ce68f9 100644
--- a/packages/app/src/components/inference/ui/InferenceTable.tsx
+++ b/packages/app/src/components/inference/ui/InferenceTable.tsx
@@ -7,6 +7,7 @@ import { type DataTableColumn, DataTable } from '@/components/ui/data-table';
 import { chipCounts } from '@/lib/chip-counts';
 import { getNestedYValue, metricLabel, xAxisLabel } from '@/lib/chart-utils';
 import { isModeledSystemPowerConfigKey } from '@/components/inference/metric-registry';
+import { inferPowerCompare, powerSeriesLabel } from '@/components/inference/utils/power-compare';
 import { sortRowsByYMetric } from '@/components/inference/ui/inference-table-sort';
 import { type Precision, getPrecisionLabel } from '@/lib/data-mappings';
 import { getDisplayLabel } from '@/lib/utils';
@@ -43,6 +44,7 @@ export function inferenceTableHeaderLabels(
     physicalChips: locale === 'zh' ? '物理芯片数' : 'Physical Chips',
     configuredChips: locale === 'zh' ? '配置中的芯片数' : 'Configured Chip Count',
     concurrency: locale === 'zh' ? '并发数' : 'Conc',
+    series: locale === 'zh' ? '系列' : 'Series',
     yMetric: metricLabel(chartDefinition, selectedYAxisMetric, locale),
     xMetric: xAxisLabel(chartDefinition, locale),
     throughput: locale === 'zh' ? '单芯片吞吐量 (tok/s)' : 'Throughput/Chip (tok/s)',
@@ -66,6 +68,9 @@ export default function InferenceTable({
     () => sortRowsByYMetric(data, chartDefinition, selectedYAxisMetric),
     [data, chartDefinition, selectedYAxisMetric],
   );
+  // Boundary / role clones (`i_pcompare`) share every config column with their
+  // base row; the series column is what tells them apart.
+  const powerCompare = useMemo(() => inferPowerCompare(data), [data]);
 
   const columns = useMemo<DataTableColumn<InferenceData>[]>(
     () => [
@@ -85,6 +90,19 @@ export default function InferenceTable({
         className: 'whitespace-nowrap',
         importance: 'key',
       },
+      ...(powerCompare === 'none'
+        ? []
+        : [
+            {
+              header: headers.series,
+              cell: (row: InferenceData) =>
+                powerSeriesLabel(row, selectedYAxisMetric, powerCompare, locale),
+              sortValue: (row: InferenceData) =>
+                powerSeriesLabel(row, selectedYAxisMetric, powerCompare, locale),
+              className: 'whitespace-nowrap',
+              importance: 'key' as const,
+            },
+          ]),
       {
         header: headers.tensorParallelism,
         align: 'right',
@@ -151,7 +169,7 @@ export default function InferenceTable({
         importance: 'key',
       },
     ],
-    [yPath, headers, showModeledPower],
+    [yPath, headers, showModeledPower, powerCompare, selectedYAxisMetric, locale],
   );
 
   return (
diff --git a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
index 46f0600eb..da5068e02 100644
--- a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
+++ b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
@@ -7,15 +7,24 @@ import {
   SelectTrigger,
   SelectValue,
 } from '@/components/ui/select';
+import { track } from '@/lib/analytics';
+import { POWER_BASES, POWER_BASIS_LABELS, type PowerBasis } from '@/lib/power-basis';
 import { useLocale } from '@/lib/use-locale';
 import {
   changeMeasuredMetricConfig,
   getMeasuredMetricConfig,
   type MeasuredMetricConfigChange,
 } from '../measured-metric-config';
+import type { PowerCompare } from '../types';
+import { POWER_COMPARE_MODES, powerCompareAvailable } from '../utils/power-compare';
 
 const STRINGS = {
   en: {
+    basis: 'Boundary',
+    basisHelp:
+      'Where power is counted. GPU measured: runner telemetry from the GPU boards. GPU provisioned: rated TDP per GPU. Utility provisioned: all-in provisioned utility power per GPU. Utility modeled: measured GPU power carried through the modeled chassis to the utility meter with PUE. Points without a value for the chosen boundary are omitted, never replaced with an estimate.',
+    basisHint:
+      'Derived boundaries report whole-deployment average power and joules per output token. Changing another setting returns to GPU measured.',
     scope: 'Scope',
     scopeHelp:
       'All GPUs measures the whole deployment. Prefill and decode select only GPUs serving that role.',
@@ -29,7 +38,8 @@ const STRINGS = {
     roleHint: 'Prefill and decode power support Average only.',
     display: 'Display',
     displayHelp:
-      'Power per chip in watts, or average power as a percentage of chip TDP. Percent of TDP is available for the all-GPU average only.',
+      'Power per chip in watts, average power as a percentage of chip TDP, or the per-second telemetry timeline behind the average. Percent of TDP and Timeline are available for the all-GPU average only.',
+    timeline: 'Timeline',
     denominator: 'Per',
     denominatorHelp:
       'Choose the energy denominator. All-GPU energy per input or output token includes the whole deployment; role energy is selected separately under Scope.',
@@ -40,8 +50,20 @@ const STRINGS = {
     unit: 'Unit',
     unitHelp:
       'Energy is shown in joules. Energy per successful query can also be shown in watt-hours.',
+    compare: 'Compare',
+    compareHelp:
+      'Overlay sibling series on the same points, in the hardware colour with a dash per series. All boundaries: GPU measured, GPU provisioned, utility provisioned and utility modeled. Prefill vs decode: each worker pool next to the whole deployment; on the energy axis the prefill pool is carried onto the output-token axis by the served input:output ratio. Available for the whole-deployment average W/chip and J per output token.',
+    compareNone: 'Off',
+    compareBoundaries: 'All boundaries',
+    compareRoles: 'Prefill vs decode',
+    compareUnavailable:
+      'The comparison is paused for this setting: it needs the whole-deployment average W/chip or J per output token.',
   },
   zh: {
+    basis: '功耗边界',
+    basisHelp:
+      '选择功耗的计量边界。GPU 实测：来自 GPU 板卡的运行器遥测；GPU 额定：每 GPU 的额定 TDP；全电源配置：每 GPU 的全电源配置（all-in）市电功率；数据中心建模：将 GPU 实测功耗经机箱功耗模型推算至市电侧并计入 PUE。所选边界缺少数值的数据点将被省略，不会用估算值替代。',
+    basisHint: '推导边界仅提供整个部署的平均功耗和每输出 token 能耗；更改其他设置将返回 GPU 实测。',
     scope: '统计范围',
     scopeHelp: '全部 GPU 对应整个部署；预填充和解码仅统计承担相应任务的 GPU。',
     all: '全部 GPU',
@@ -54,7 +76,8 @@ const STRINGS = {
     roleHint: '预填充和解码功率仅支持平均值。',
     display: '显示方式',
     displayHelp:
-      '显示单芯片功率（瓦），或平均功率占芯片 TDP 的百分比。TDP 百分比仅支持全部 GPU 的平均功率。',
+      '显示单芯片功率（瓦）、平均功率占芯片 TDP 的百分比，或平均值背后的逐秒遥测时间线。TDP 百分比和时间线仅支持全部 GPU 的平均功率。',
+    timeline: '时间线',
     denominator: '能耗分母',
     denominatorHelp:
       '选择能耗的分母。按输入或输出 token 归一化的全部 GPU 能耗仍包含整个部署；预填充或解码能耗需在统计范围中单独选择。',
@@ -64,22 +87,44 @@ const STRINGS = {
     query: '成功请求',
     unit: '单位',
     unitHelp: '能耗以焦耳显示；每个成功请求的能耗也可显示为瓦时。',
+    compare: '对比',
+    compareHelp:
+      '在同一批数据点上叠加同源系列：颜色仍按硬件区分，每个系列用不同虚线表示。全部边界：GPU 实测、GPU 额定、全电源配置、数据中心建模；预填充 vs 解码：各 worker 池与整个部署并列，能耗轴上的预填充能耗按实际服务的输入/输出 token 比折算到每输出 token。仅适用于整个部署的平均 W/芯片和每输出 token 能耗。',
+    compareNone: '关闭',
+    compareBoundaries: '全部边界',
+    compareRoles: '预填充 vs 解码',
+    compareUnavailable: '当前设置下对比已暂停：需要整个部署的平均 W/芯片或每输出 token 能耗。',
   },
 } as const;
 
 export function MeasuredMetricControls({
   metric,
   onChange,
+  compare = 'none',
+  onCompareChange,
 }: {
   metric: string;
   onChange: (metric: string) => void;
+  /** Comparison series overlaid on the metric (`i_pcompare`). */
+  compare?: PowerCompare;
+  onCompareChange?: (mode: PowerCompare) => void;
 }) {
-  const t = STRINGS[useLocale()];
+  const locale = useLocale();
+  const t = STRINGS[locale];
   const config = getMeasuredMetricConfig(metric);
   if (!config) return null;
+  const compareLabels: Record<PowerCompare, string> = {
+    none: t.compareNone,
+    boundaries: t.compareBoundaries,
+    roles: t.compareRoles,
+  };
+  const compareActive = compare !== 'none';
+  const compareApplies = powerCompareAvailable(metric, compare);
   const change = (next: MeasuredMetricConfigChange) =>
     onChange(changeMeasuredMetricConfig(metric, next));
+  const basisId = `measured-${config.family}-basis`;
   const scopeId = `measured-${config.family}-scope`;
+  const derivedBasis = config.basis !== 'gpu-measured';
   const roleScope =
     config.family === 'energy'
       ? config.denominator === 'input'
@@ -91,9 +136,31 @@ export function MeasuredMetricControls({
 
   return (
     <div
-      className="col-span-full grid min-w-0 gap-3 sm:grid-cols-3"
+      className="col-span-full grid min-w-0 grid-cols-[repeat(auto-fit,minmax(min(100%,12rem),1fr))] gap-3"
       data-testid="measured-metric-controls"
     >
+      <div className="flex min-w-0 flex-col gap-1.5">
+        <LabelWithTooltip htmlFor={basisId} label={t.basis} tooltip={t.basisHelp} />
+        <Select
+          value={config.basis}
+          onValueChange={(value) => {
+            const basis = value as PowerBasis;
+            track('inference_power_basis_changed', { basis, family: config.family });
+            change({ basis });
+          }}
+        >
+          <SelectTrigger id={basisId} data-testid={basisId} className="w-full">
+            <SelectValue />
+          </SelectTrigger>
+          <SelectContent portalled={false}>
+            {POWER_BASES.map((basis) => (
+              <SelectItem key={basis} value={basis} data-value={basis}>
+                {POWER_BASIS_LABELS[basis][locale]}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
       {config.family === 'energy' && (
         <div className="flex min-w-0 flex-col gap-1.5">
           <LabelWithTooltip
@@ -159,7 +226,7 @@ export function MeasuredMetricControls({
               role="group"
               size="default"
               className="w-full"
-              buttonClassName="flex-1 justify-center"
+              buttonClassName="min-w-max flex-auto justify-center"
               ariaLabel={t.statistic}
               value={config.statistic}
               onValueChange={(statistic) => change({ statistic })}
@@ -204,6 +271,13 @@ export function MeasuredMetricControls({
                 >
                   % TDP
                 </SelectItem>
+                <SelectItem
+                  value="timeline"
+                  data-value="timeline"
+                  disabled={config.scope !== 'all' || config.statistic !== 'average'}
+                >
+                  {t.timeline}
+                </SelectItem>
               </SelectContent>
             </Select>
           </div>
@@ -237,6 +311,59 @@ export function MeasuredMetricControls({
           </Select>
         </div>
       )}
+      {onCompareChange && (
+        <div className="flex min-w-0 flex-col gap-1.5">
+          <LabelWithTooltip
+            htmlFor="measured-power-compare"
+            label={t.compare}
+            tooltip={t.compareHelp}
+          />
+          <Select
+            value={compare}
+            onValueChange={(value) => {
+              const mode = value as PowerCompare;
+              track('inference_power_compare_changed', { mode, family: config.family });
+              onCompareChange(mode);
+            }}
+          >
+            <SelectTrigger
+              id="measured-power-compare"
+              data-testid="measured-power-compare"
+              className="w-full"
+            >
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent portalled={false}>
+              {POWER_COMPARE_MODES.map((mode) => (
+                <SelectItem
+                  key={mode}
+                  value={mode}
+                  data-value={mode}
+                  disabled={!powerCompareAvailable(metric, mode)}
+                >
+                  {compareLabels[mode]}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        </div>
+      )}
+      {derivedBasis && (
+        <p
+          className="col-span-full text-xs text-muted-foreground"
+          data-testid="measured-basis-hint"
+        >
+          {t.basisHint}
+        </p>
+      )}
+      {compareActive && !compareApplies && (
+        <p
+          className="col-span-full text-xs text-muted-foreground"
+          data-testid="measured-compare-hint"
+        >
+          {t.compareUnavailable}
+        </p>
+      )}
     </div>
   );
 }
diff --git a/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx b/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
index a3dd548b0..cad29732b 100644
--- a/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
+++ b/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
@@ -2,8 +2,16 @@
 
 import { useMemo } from 'react';
 import { useInferenceData, useInferenceFilters } from '../InferenceContext';
-import { isMeasuredEnergyConfigKey, metricOptionTitle, type MetricKey } from '../metric-registry';
+import {
+  isMeasuredEnergyConfigKey,
+  isPowerBasisConfigKey,
+  metricOptionTitle,
+  POWER_BASIS_METRIC_CONFIG_KEYS,
+  type MetricKey,
+} from '../metric-registry';
+import { getMeasuredMetricConfig } from '../measured-metric-config';
 import type { InferenceData } from '../types';
+import { powerBasisNormalization } from '@/lib/power-basis';
 import { matchesQuickFilters } from '../utils/quickFilters';
 import {
   powerMetricAvailability,
@@ -33,6 +41,17 @@ const STRINGS = {
       ambiguous: 'Whole-deployment energy schema unavailable',
       missing: 'Metric not reported',
     },
+    basisLabels: {
+      available: 'Value available',
+      noSpec: 'No published spec for this hardware',
+      noThroughput: 'No output throughput reported',
+      noNormalization: 'Whole-deployment GPU count unavailable for this disaggregated row',
+      noTelemetry: 'No validated GPU telemetry',
+      invalid: 'Validation failed',
+      modelWorkload: 'Chassis model covers 8K / 1K only',
+      modelHardware: 'Hardware not in the chassis power model',
+      modelUnsupported: 'Chassis model unsupported for this deployment',
+    },
     note: 'A missing verdict does not establish age or validity. Prefill/decode metrics measure separate worker pools. Missing values are never replaced with zero or TDP estimates.',
     all: 'Availability of all measured metrics',
     evidence: 'Selected metric: source details',
@@ -54,6 +73,17 @@ const STRINGS = {
       ambiguous: '缺少整个部署的能耗 schema',
       missing: '未提供此指标',
     },
+    basisLabels: {
+      available: '有数值',
+      noSpec: '该硬件没有公开的规格参数',
+      noThroughput: '未报告输出吞吐量',
+      noNormalization: '无法确定该分离式部署的 GPU 总数',
+      noTelemetry: '没有已验证的 GPU 遥测',
+      invalid: '验证失败',
+      modelWorkload: '机箱功耗模型仅覆盖 8K / 1K',
+      modelHardware: '硬件不在机箱功耗模型范围内',
+      modelUnsupported: '机箱功耗模型不支持此部署',
+    },
     note: '缺少验证结论不能判断数据新旧或有效性。prefill/decode 指标仅衡量独立 worker 池。缺失值不会被替换为零或 TDP 估算值。',
     all: '所有实测指标的可用性',
     evidence: '当前指标的来源详情',
@@ -61,6 +91,99 @@ const STRINGS = {
   },
 } as const;
 
+/**
+ * Why a point lacks a derived power boundary (lib/power-basis.ts). Provisioned
+ * boundaries are spec constants, so their watts exist for any registered
+ * hardware and their energy additionally needs output throughput plus, for
+ * disaggregated rows, the whole-deployment GPU count that
+ * `powerBasisNormalization` recovers only for fixed-sequence runs with integer
+ * prefill/decode counts. The modeled boundary is measured telemetry carried
+ * through the chassis model, so it inherits the telemetry verdict and the
+ * model's own unsupported reasons.
+ */
+export type PowerBasisAvailabilityState =
+  | 'available'
+  | 'noSpec'
+  | 'noThroughput'
+  | 'noNormalization'
+  | 'noTelemetry'
+  | 'invalid'
+  | 'modelWorkload'
+  | 'modelHardware'
+  | 'modelUnsupported';
+
+const POWER_BASIS_AVAILABILITY_STATES: readonly PowerBasisAvailabilityState[] = [
+  'available',
+  'noSpec',
+  'noThroughput',
+  'noNormalization',
+  'noTelemetry',
+  'invalid',
+  'modelWorkload',
+  'modelHardware',
+  'modelUnsupported',
+];
+
+const hasFiniteValue = (point: InferenceData, key: MetricKey): boolean => {
+  const value = point[key];
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'y' in value &&
+    typeof value.y === 'number' &&
+    Number.isFinite(value.y)
+  );
+};
+
+export function powerBasisState(
+  point: InferenceData,
+  configKey: string,
+): PowerBasisAvailabilityState {
+  const key = configKey.replace(/^y_/u, '') as MetricKey;
+  if (hasFiniteValue(point, key)) return 'available';
+  const config = getMeasuredMetricConfig(configKey);
+  if (config?.basis === 'utility-modeled') {
+    if (point.power_valid === 0) return 'invalid';
+    const model = point.modeledSystemPower;
+    if (model?.status === 'unsupported') {
+      if (model.reason === 'workload') return 'modelWorkload';
+      if (model.reason === 'hardware') return 'modelHardware';
+      if (model.reason === 'telemetry') return 'noTelemetry';
+      return 'modelUnsupported';
+    }
+    // A supported model without a plotted value means B1 is absent (B4 follows B1).
+    return 'noTelemetry';
+  }
+  // Provisioned energy needs the watts sibling plus the whole-deployment
+  // normalization; the same helper that withheld the value says which half is
+  // missing, so the explanation cannot drift from the formula.
+  const wattsKey = (
+    config?.basis === 'gpu-provisioned' ? 'gpuProvisionedWatts' : 'utilityProvisionedWatts'
+  ) satisfies MetricKey;
+  if (!hasFiniteValue(point, wattsKey)) return 'noSpec';
+  const perGpu = point.output_tput_per_gpu;
+  if (typeof perGpu !== 'number' || !Number.isFinite(perGpu) || perGpu <= 0) return 'noThroughput';
+  // Throughput exists, so only the disaggregated GPU count can be missing.
+  // Chart points may lack the counts an aggregate entry always has; an
+  // unknown count is exactly the "unavailable" case the helper reports.
+  const { allocatedGpus } = powerBasisNormalization({
+    output_tput_per_gpu: perGpu,
+    disagg: point.disagg ?? false,
+    benchmark_type: point.benchmark_type,
+    num_prefill_gpu: point.num_prefill_gpu ?? Number.NaN,
+    num_decode_gpu: point.num_decode_gpu ?? Number.NaN,
+  });
+  return allocatedGpus === null ? 'noNormalization' : 'noThroughput';
+}
+
+function powerBasisAvailability(points: readonly InferenceData[], metric: string) {
+  const counts = Object.fromEntries(
+    POWER_BASIS_AVAILABILITY_STATES.map((state) => [state, 0]),
+  ) as Record<PowerBasisAvailabilityState, number>;
+  for (const point of points) counts[powerBasisState(point, metric)]++;
+  return { metric, counts, available: counts.available, total: points.length };
+}
+
 export function PowerMetricAvailabilityPanel({
   points,
   metric,
@@ -74,16 +197,35 @@ export function PowerMetricAvailabilityPanel({
 }) {
   const locale = useLocale();
   const t = STRINGS[locale];
-  const availability = useMemo(() => powerMetricAvailability(points), [points]);
+  const availability = useMemo(
+    () => [
+      ...powerMetricAvailability(points),
+      ...POWER_BASIS_METRIC_CONFIG_KEYS.map((key) => powerBasisAvailability(points, key)),
+    ],
+    [points],
+  );
   const selected = availability.find((entry) => entry.metric === metric);
   if (!selected) return null;
+  const isBasis = isPowerBasisConfigKey(metric);
+  const stateOf = (point: InferenceData) =>
+    isBasis ? powerBasisState(point, metric) : powerMetricState(point, metric);
+  // The two dictionaries overlap on `invalid`; the selected metric, not the
+  // key, decides which copy applies so the measured strings stay untouched.
+  const labelOf = (state: PowerAvailabilityState | PowerBasisAvailabilityState) =>
+    isBasis
+      ? t.basisLabels[state as PowerBasisAvailabilityState]
+      : t.labels[state as PowerAvailabilityState];
   const sources = new Map<
     string,
-    { point: InferenceData; state: PowerAvailabilityState; count: number }
+    {
+      point: InferenceData;
+      state: PowerAvailabilityState | PowerBasisAvailabilityState;
+      count: number;
+    }
   >();
   for (const point of points) {
-    const state = powerMetricState(point, metric);
-    if (state === 'strict') continue;
+    const state = stateOf(point);
+    if (state === 'strict' || state === 'available') continue;
     const key = JSON.stringify([point.hwKey, point.run_url, state, point.power_invalid_reasons]);
     const group = sources.get(key);
     if (group) group.count++;
@@ -108,7 +250,10 @@ export function PowerMetricAvailabilityPanel({
           <p>
             {Object.entries(selected.counts)
               .filter(([, count]) => count > 0)
-              .map(([state, count]) => `${t.labels[state as PowerAvailabilityState]}: ${count}`)
+              .map(
+                ([state, count]) =>
+                  `${labelOf(state as PowerAvailabilityState | PowerBasisAvailabilityState)}: ${count}`,
+              )
               .join(' · ')}
           </p>
           <details
@@ -139,7 +284,7 @@ export function PowerMetricAvailabilityPanel({
               <ul className="mt-2 max-h-48 space-y-2 overflow-auto">
                 {[...sources.values()].map(({ point, state, count }, index) => (
                   <li key={index}>
-                    {point.hwKey}: {t.labels[state]} ({count})
+                    {point.hwKey}: {labelOf(state)} ({count})
                     {point.power_invalid_reasons?.length
                       ? ` · ${point.power_invalid_reasons.join(', ')}`
                       : ''}
@@ -221,7 +366,7 @@ export function PowerMetricAvailability({
     quickFilters,
     compareGpuPair,
   ]);
-  if (!isMeasuredEnergyConfigKey(metric)) return null;
+  if (!isMeasuredEnergyConfigKey(metric) && !isPowerBasisConfigKey(metric)) return null;
   return (
     <PowerMetricAvailabilityPanel
       points={points}
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
new file mode 100644
index 000000000..316d15d26
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -0,0 +1,1469 @@
+'use client';
+
+/**
+ * PowerX "Timeline" display: the per-second GPU power behind each measured
+ * average, drawn over the whole benchmark job.
+ *
+ * ChartDisplay renders this instead of ScatterGraph when the Measured Power
+ * Display control is `timeline` (`y_measuredPowerTimeline`). The point set is
+ * the same as the Measured Avg Power axis; each point's `power_audit.source`
+ * names its `gpu_metrics_*` artifact — or, for disaggregated Slurm / Dynamo
+ * rows, its validation file inside a `power_audit_*` bundle — which
+ * `/api/gpu-metrics?series=power` returns as one-second per-GPU buckets
+ * (`components/gpu-power/power-series.ts`).
+ *
+ * One trace per config, coloured by hardware (official) or by run (unofficial
+ * overlay). The validated measurement window is emphasized; the rest of the
+ * job (server start, warmup) is drawn faint. Rated TDP is a dashed reference
+ * per hardware; the all-in provisioned line is opt-in because it would halve
+ * the vertical resolution of the traces.
+ *
+ * Pool mode (bundle series carry worker roles) sums each prefill / decode pool
+ * instead, against pool-sized TDP references, so a disaggregated deployment
+ * reads as two lines on a watts axis. A pinned scatter tooltip can deep-link
+ * here focused on one config (`requestPowerTraceFocus`).
+ */
+import * as d3 from 'd3';
+import { useQueries } from '@tanstack/react-query';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
+
+import {
+  bucketTimeMs,
+  meanPowerAt,
+  sumPowerAt,
+  type GpuPowerSeries,
+  type GpuPowerSeriesResponse,
+} from '@/components/gpu-power/power-series';
+import ChartLegend, { type LegendSwitchConfig } from '@/components/ui/chart-legend';
+import { SegmentedToggle } from '@/components/ui/segmented-toggle';
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
+import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
+import { useThemeColors } from '@/hooks/useThemeColors';
+import { track } from '@/lib/analytics';
+import { computeToggle } from '@/lib/toggle-set';
+import { getModelSortIndex } from '@/lib/constants';
+import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import type { LayerConfig, RenderContext, ZoomContext } from '@/lib/d3-chart/D3Chart/types';
+import { lttbDownsample } from '@/lib/d3-chart/downsample';
+import { CHART_FONT_SANS, CHART_TYPE, px } from '@/lib/d3-chart/typography';
+import { overlayRunColor, overlayRunIndex } from '@/lib/overlay-run-style';
+import { useLocale } from '@/lib/use-locale';
+import { getDisplayLabel } from '@/lib/utils';
+
+import {
+  useInferenceActions,
+  useInferenceData,
+  useInferenceDisplay,
+  useInferenceFilters,
+} from '../InferenceContext';
+import type { InferenceData, OverlayData } from '../types';
+import { powerVariantDash } from '../utils/power-compare';
+import {
+  allGpuPool,
+  consumePowerTraceFocus,
+  groupPoolsBySize,
+  joinPowerTimeline,
+  planPowerTimelineRequests,
+  prioritizeRun,
+  prioritizeRuns,
+  referenceLabelSlots,
+  runIdFromUrl,
+  traceConfigLabel,
+  traceKeyRunId,
+  tracePools,
+  windowPhase,
+  type MissingTrace,
+  type MissingTraceReason,
+  type PoolSizeGroup,
+  type PowerPool,
+  type PowerPoolRole,
+  type PowerTimelineRequest,
+  type PowerTimelineTrace,
+  type WindowPhase,
+} from '../utils/powerTimeline';
+
+/** Distinct workflow runs fetched per chart; each is one GitHub artifact sweep. */
+export const POWER_TIMELINE_MAX_RUNS = 4;
+/** Hover targets per trace after LTTB; paths keep every bucket. */
+const HIT_POINTS_PER_TRACE = 200;
+/** Above this many visible traces the `c<conc>` end labels would only overlap. */
+const MAX_LABELED_TRACES = 40;
+/** Up to this many undrawn configs are named individually; beyond, per hardware. */
+const MAX_LISTED_MISSING = 8;
+const CHART_HEIGHT = 600;
+const MARGIN = { top: 24, right: 84, bottom: 60, left: 64 };
+
+const STRINGS = {
+  en: {
+    timeAxis: 'Time axis',
+    wall: 'Wall clock (UTC)',
+    elapsed: 'Since start',
+    xWall: 'Time (UTC)',
+    xElapsed: 'Time since telemetry start (m:ss)',
+    perGpu: 'One line per GPU',
+    perGpuHelp: 'Draw every GPU of a config instead of the mean across its GPUs.',
+    pools: 'Prefill / decode pools',
+    poolsHelp:
+      'One line per worker-role pool: the summed board power of the prefill GPUs and of the decode GPUs of a config. Dashed references are pool size × rated TDP.',
+    utilityLines: 'All-in provisioned lines',
+    utilityHelp:
+      'Dashed reference at the all-in provisioned utility power per GPU from the hardware registry (SemiAnalysis Datacenter Industry Model). Off by default because it compresses the traces.',
+    loading: (runs: number) =>
+      `Loading GPU telemetry for ${runs} run${runs === 1 ? '' : 's'}… (GitHub artifacts, may take a minute)`,
+    loadError: (runId: string, message: string) => `Run ${runId}: ${message}`,
+    missing: (missing: number, total: number) =>
+      `${missing} of ${total} measured configs have no telemetry trace and are not drawn.`,
+    missingReason: {
+      'no-source': (count: number) =>
+        `${count} predate per-config telemetry provenance in the benchmark row`,
+      'no-run': (count: number) => `${count} carry no workflow run`,
+      'run-not-fetched': (count: number) => `${count} come from runs that were not loaded`,
+      'not-in-run': (count: number) =>
+        `${count} have no gpu_metrics artifact or power-audit bundle in their run (expired, or another collector)`,
+    } satisfies Record<MissingTraceReason, (count: number) => string>,
+    missingUndrawn: 'Not drawn',
+    noTraces:
+      'No telemetry traces for the visible hardware. Enable a series in the legend or choose another date.',
+    noArtifacts:
+      'These points predate per-config telemetry artifacts, so no timeline is available for them.',
+    droppedRuns: (runs: number) =>
+      `Telemetry from ${runs} more run${runs === 1 ? '' : 's'} was not loaded (limit ${POWER_TIMELINE_MAX_RUNS} runs per chart).`,
+    telemetry: 'Telemetry',
+    method:
+      'One-second means of per-GPU board power (nvidia-smi / amd-smi, or DCGM on Slurm / Dynamo runs) over the whole benchmark job; the emphasized segment is the validated window behind the measured average. Dashed lines: rated TDP per hardware from the hardware registry.',
+    methodPools:
+      'In pool mode each line is the summed power of one worker-role pool (prefill or decode GPUs) and the dashed references are pool size × rated TDP.',
+    instructions:
+      'Shift+Scroll to zoom horizontally · Drag to pan · Double-click to reset · Click a point to pin tooltip',
+    dismiss: 'Click elsewhere to dismiss',
+    phase: {
+      before: 'Before window (startup / warmup)',
+      window: 'Measurement window',
+      after: 'After window',
+      unknown: 'Window not recorded',
+    } satisfies Record<WindowPhase, string>,
+    meanPerGpu: 'Mean per GPU',
+    gpus: (count: number) => `${count} GPU${count === 1 ? '' : 's'}`,
+    min: 'min',
+    max: 'max',
+    validated: 'Validated average',
+    sinceStart: 'since start',
+    tdp: 'TDP',
+    allIn: 'all-in',
+    poolShort: { prefill: 'prefill', decode: 'decode', all: 'all GPUs' } satisfies Record<
+      PowerPoolRole,
+      string
+    >,
+    yPool: 'GPU pool power (W)',
+    pool: 'Pool',
+    poolPower: 'Pool power',
+    poolTdp: 'pool TDP',
+    focused: (label: string) => `Focused on ${label}`,
+    showAll: 'Show all',
+    unofficialRun: 'Unofficial run',
+    branch: 'Branch',
+    viewWorkflow: 'View workflow run',
+  },
+  zh: {
+    timeAxis: '时间轴',
+    wall: '实际时刻（UTC）',
+    elapsed: '相对起点',
+    xWall: '时间（UTC）',
+    xElapsed: '距遥测开始的时间（分:秒）',
+    perGpu: '每个 GPU 一条线',
+    perGpuHelp: '绘制配置中每个 GPU 的曲线，而不是各 GPU 的平均值。',
+    pools: '预填充 / 解码 GPU 池',
+    poolsHelp:
+      '按 worker 角色分池绘制：每条线是同一配置中预填充 GPU 或解码 GPU 的板卡功耗之和。虚线参考为池内 GPU 数量 × 额定 TDP。',
+    utilityLines: '全电源配置参考线',
+    utilityHelp:
+      '按硬件注册表中每 GPU 的全电源配置（all-in）市电功率绘制虚线参考（SemiAnalysis 数据中心行业模型）。默认关闭，因为它会压缩曲线的纵向分辨率。',
+    loading: (runs: number) =>
+      `正在加载 ${runs} 个运行的 GPU 遥测数据……（GitHub 产物，可能需要约一分钟）`,
+    loadError: (runId: string, message: string) => `运行 ${runId}：${message}`,
+    missing: (missing: number, total: number) =>
+      `${total} 个有实测值的配置中有 ${missing} 个没有遥测曲线，未绘制。`,
+    missingReason: {
+      'no-source': (count: number) => `${count} 个的基准测试行早于按配置记录的遥测来源`,
+      'no-run': (count: number) => `${count} 个没有工作流运行信息`,
+      'run-not-fetched': (count: number) => `${count} 个来自未加载的运行`,
+      'not-in-run': (count: number) =>
+        `${count} 个在其运行中没有 gpu_metrics 产物或 power-audit 数据包（产物已过期，或使用其他采集器）`,
+    } satisfies Record<MissingTraceReason, (count: number) => string>,
+    missingUndrawn: '未绘制',
+    noTraces: '当前可见硬件没有遥测曲线。请在图例中启用一个系列或选择其他日期。',
+    noArtifacts: '这些数据点早于按配置上传的遥测产物，因此没有可用的时间线。',
+    droppedRuns: (runs: number) =>
+      `另有 ${runs} 个运行的遥测数据未加载（每张图表最多 ${POWER_TIMELINE_MAX_RUNS} 个运行）。`,
+    telemetry: '遥测来源',
+    method:
+      '整个基准测试任务期间每个 GPU 板卡功耗（nvidia-smi / amd-smi，Slurm / Dynamo 运行为 DCGM）的一秒平均值；加粗段为实测平均值所依据的有效测量窗口。虚线：硬件注册表中各硬件的额定 TDP。',
+    methodPools:
+      '在 GPU 池模式下，每条线是一个 worker 角色池（预填充或解码 GPU）的功耗总和，虚线参考为池内 GPU 数量 × 额定 TDP。',
+    instructions: 'Shift+滚轮横向缩放 · 拖动平移 · 双击重置 · 点击数据点固定提示框',
+    dismiss: '点击其他区域关闭',
+    phase: {
+      before: '测量窗口之前（启动 / warmup）',
+      window: '测量窗口内',
+      after: '测量窗口之后',
+      unknown: '未记录测量窗口',
+    } satisfies Record<WindowPhase, string>,
+    meanPerGpu: '每 GPU 平均',
+    gpus: (count: number) => `${count} 个 GPU`,
+    min: '最小',
+    max: '最大',
+    validated: '有效平均值',
+    sinceStart: '距起点',
+    tdp: 'TDP',
+    allIn: 'all-in',
+    poolShort: { prefill: '预填充', decode: '解码', all: '全部 GPU' } satisfies Record<
+      PowerPoolRole,
+      string
+    >,
+    yPool: 'GPU 池功耗（W）',
+    pool: 'GPU 池',
+    poolPower: '池功耗',
+    poolTdp: '池 TDP',
+    focused: (label: string) => `聚焦：${label}`,
+    showAll: '显示全部',
+    unofficialRun: '非官方运行',
+    branch: '分支',
+    viewWorkflow: '查看工作流运行',
+  },
+} as const;
+
+type XMode = 'wall' | 'elapsed';
+type LineMode = 'mean' | 'gpu' | 'pool';
+
+interface TimelineSample {
+  trace: PowerTimelineTrace;
+  color: string;
+  overlayIndex: number | null;
+  column: number;
+  timeMs: number;
+  /** Data-space x for the active mode: epoch ms (wall) or seconds (elapsed). */
+  x: number;
+  /** Mean watts across the GPUs sampled in the bucket; the pool's summed watts in pool mode. */
+  y: number;
+  min: number;
+  max: number;
+  /** GPUs with a sample in the bucket (inside the pool, in pool mode). */
+  gpuCount: number;
+  phase: WindowPhase;
+  /** The pool this sample sums and its device count, in pool mode. */
+  pool?: { role: PowerPoolRole; gpuCount: number };
+}
+
+interface TracePoint {
+  x: number;
+  y: number | null;
+}
+
+interface TracePath {
+  id: string;
+  traceKey: string;
+  hwKey: string;
+  overlayIndex: number | null;
+  color: string;
+  segment: 'full' | 'window';
+  width: number;
+  opacity: number;
+  points: TracePoint[];
+  /** Worker-role pool the line sums, in pool mode. */
+  pool?: PowerPoolRole;
+}
+
+interface ReferenceLine {
+  id: string;
+  watts: number;
+  label: string;
+  color: string;
+  kind: 'tdp' | 'utility';
+  /** Pools the line is sized for, in pool mode (roles sharing one GPU count). */
+  pools?: PowerPoolRole[];
+}
+
+/** Vertical distance between stacked reference labels that share a watts value. */
+const REFERENCE_LABEL_ROW = 13;
+
+interface TraceLabel {
+  /** Join key: the trace key, plus the pool role in pool mode. */
+  id: string;
+  traceKey: string;
+  hwKey: string;
+  pool?: PowerPoolRole;
+  color: string;
+  text: string;
+  x: number;
+  y: number;
+}
+
+interface DrawModel {
+  paths: TracePath[];
+  labels: TraceLabel[];
+}
+
+export interface PowerTimelineProps {
+  chartId: string;
+  /** Official points of the chart (display-limit clipped points restored). */
+  data: InferenceData[];
+  overlayData?: OverlayData;
+  yLabel: string;
+  caption?: React.ReactNode;
+}
+
+async function fetchPowerSeries(
+  request: PowerTimelineRequest,
+  signal: AbortSignal,
+): Promise<GpuPowerSeriesResponse> {
+  const params = new URLSearchParams({ runId: request.runId, series: 'power' });
+  if (request.prefix) params.set('prefix', request.prefix);
+  const response = await fetch(`/api/gpu-metrics?${params.toString()}`, {
+    cache: 'no-store',
+    signal,
+  });
+  const body = (await response.json()) as GpuPowerSeriesResponse | { error: string };
+  if (!response.ok) {
+    throw new Error('error' in body ? body.error : `HTTP ${response.status}`);
+  }
+  return body as GpuPowerSeriesResponse;
+}
+
+function formatElapsed(totalSeconds: number): string {
+  const seconds = Math.max(0, Math.round(totalSeconds));
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = seconds % 60;
+  const mm = h > 0 ? String(m).padStart(2, '0') : String(m);
+  return `${h > 0 ? `${h}:` : ''}${mm}:${String(s).padStart(2, '0')}`;
+}
+
+const formatUtcClock = d3.utcFormat('%H:%M:%S');
+const formatUtcDate = d3.utcFormat('%Y-%m-%d');
+/** Pool sums run to thousands of watts; group the digits. */
+const formatWatts = d3.format(',.0f');
+
+function baseHardware(hwKey: string): string {
+  return hwKey.split('_')[0];
+}
+
+/**
+ * The pools a trace draws in pool mode: its worker-role pools, or every GPU as
+ * one pool when the collector assigned no roles (a single-node trace then shows
+ * its deployment total on the same axis).
+ */
+function drawnPools(series: GpuPowerSeries): PowerPool[] {
+  const pools = tracePools(series);
+  return pools.length > 0 ? pools : [allGpuPool(series)];
+}
+
+/** SVG dash of a pool line: per role from the comparison palette; `all` stays solid. */
+function poolDash(pool: PowerPoolRole): string | null {
+  const dash = powerVariantDash({ kind: 'role', id: pool });
+  return dash === '' ? null : dash;
+}
+
+interface TraceRow {
+  id: string;
+  pool?: PowerPoolRole;
+  values: (number | null)[];
+}
+
+/** One polyline's values per line mode: the GPU mean, each GPU, or each pool's sum. */
+function traceRows(series: GpuPowerSeries, lineMode: LineMode): TraceRow[] {
+  if (lineMode === 'gpu') {
+    return series.gpus.map((gpu, row) => ({ id: `gpu${gpu}`, values: series.power[row] }));
+  }
+  if (lineMode === 'pool') {
+    return drawnPools(series).map((pool) => ({
+      id: `pool:${pool.role}`,
+      pool: pool.role,
+      values: series.t.map((_, column) => sumPowerAt(series, pool.rows, column)),
+    }));
+  }
+  return [{ id: 'mean', values: series.t.map((_, column) => meanPowerAt(series, column)) }];
+}
+
+/** Builds the mean, per-GPU or per-pool polylines plus the window emphasis for one trace. */
+function tracePaths(
+  trace: PowerTimelineTrace,
+  color: string,
+  overlayIndex: number | null,
+  xMode: XMode,
+  lineMode: LineMode,
+): TracePath[] {
+  const { series } = trace;
+  const xOf = (column: number) =>
+    xMode === 'wall' ? bucketTimeMs(series, column) : series.t[column] - series.t[0];
+  const rows = traceRows(series, lineMode);
+  const faint = lineMode === 'gpu' ? 0.22 : 0.32;
+  const strong = lineMode === 'gpu' ? 0.85 : 1;
+  const widths = lineMode === 'gpu' ? [1, 1.5] : [1.25, 2.25];
+  const paths: TracePath[] = [];
+  for (const row of rows) {
+    const full: TracePoint[] = [];
+    const window: TracePoint[] = [];
+    row.values.forEach((value, column) => {
+      const point = { x: xOf(column), y: value };
+      full.push(point);
+      if (windowPhase(trace, bucketTimeMs(series, column)) === 'window') window.push(point);
+    });
+    paths.push({
+      id: `${trace.key}:${row.id}:full`,
+      traceKey: trace.key,
+      hwKey: trace.point.hwKey,
+      overlayIndex,
+      color,
+      segment: 'full',
+      width: widths[0],
+      opacity: faint,
+      points: full,
+      pool: row.pool,
+    });
+    if (window.length > 1) {
+      paths.push({
+        id: `${trace.key}:${row.id}:window`,
+        traceKey: trace.key,
+        hwKey: trace.point.hwKey,
+        overlayIndex,
+        color,
+        segment: 'window',
+        width: widths[1],
+        opacity: strong,
+        points: window,
+        pool: row.pool,
+      });
+    }
+  }
+  return paths;
+}
+
+/**
+ * Hover targets of one trace: one stream over all its GPUs (mean watts), or in
+ * pool mode one stream per pool (summed watts) so the tooltip can name the pool.
+ */
+function traceSamples(
+  trace: PowerTimelineTrace,
+  color: string,
+  overlayIndex: number | null,
+  xMode: XMode,
+  lineMode: LineMode,
+): TimelineSample[] {
+  const { series } = trace;
+  if (lineMode !== 'pool') {
+    const rows = series.power.map((_, row) => row);
+    return sampleRows(trace, color, overlayIndex, xMode, rows, undefined);
+  }
+  return drawnPools(series).flatMap((pool) =>
+    sampleRows(trace, color, overlayIndex, xMode, pool.rows, {
+      role: pool.role,
+      gpuCount: pool.rows.length,
+    }),
+  );
+}
+
+function sampleRows(
+  trace: PowerTimelineTrace,
+  color: string,
+  overlayIndex: number | null,
+  xMode: XMode,
+  rows: readonly number[],
+  pool: TimelineSample['pool'],
+): TimelineSample[] {
+  const { series } = trace;
+  const samples: TimelineSample[] = [];
+  for (let column = 0; column < series.t.length; column++) {
+    let sum = 0;
+    let count = 0;
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (const row of rows) {
+      const value = series.power[row]?.[column];
+      if (value === null || value === undefined) continue;
+      sum += value;
+      count += 1;
+      if (value < min) min = value;
+      if (value > max) max = value;
+    }
+    // A pool bucket missing a device is a gap, as in `sumPowerAt`, not a dip.
+    if (count === 0 || (pool && count < rows.length)) continue;
+    const timeMs = bucketTimeMs(series, column);
+    samples.push({
+      trace,
+      color,
+      overlayIndex,
+      column,
+      timeMs,
+      x: xMode === 'wall' ? timeMs : series.t[column] - series.t[0],
+      y: pool ? sum : sum / count,
+      min,
+      max,
+      gpuCount: count,
+      phase: windowPhase(trace, timeMs),
+      pool,
+    });
+  }
+  return lttbDownsample(
+    samples,
+    HIT_POINTS_PER_TRACE,
+    (sample) => sample.x,
+    (sample) => sample.y,
+  );
+}
+
+type AnyContinuousScale = d3.ScaleLinear<number, number>;
+
+function drawTraces(
+  group: d3.Selection<SVGGElement, unknown, null, undefined>,
+  xScale: AnyContinuousScale,
+  yScale: AnyContinuousScale,
+  model: DrawModel,
+  highlight: string | null,
+): void {
+  const line = d3
+    .line<TracePoint>()
+    .defined((point) => point.y !== null)
+    .x((point) => xScale(point.x))
+    .y((point) => yScale(point.y ?? 0))
+    .curve(d3.curveLinear);
+  const selection = group
+    .selectAll<SVGPathElement, TracePath>('path.power-trace')
+    .data(model.paths, (path) => path.id);
+  selection.exit().remove();
+  selection
+    .enter()
+    .append('path')
+    .attr('class', 'power-trace')
+    .attr('fill', 'none')
+    .attr('stroke-linejoin', 'round')
+    .attr('stroke-linecap', 'round')
+    .merge(selection)
+    .attr('data-trace-key', (path) => path.traceKey)
+    .attr('data-hw', (path) => path.hwKey)
+    .attr('data-segment', (path) => path.segment)
+    .attr('data-run-index', (path) => (path.overlayIndex === null ? null : path.overlayIndex))
+    .attr('data-pool', (path) => path.pool ?? null)
+    .attr('stroke-dasharray', (path) => (path.pool ? poolDash(path.pool) : null))
+    .attr('stroke', (path) => path.color)
+    .attr('stroke-width', (path) => path.width)
+    .attr('opacity', (path) => traceOpacity(path, highlight))
+    .attr('d', (path) => line(path.points));
+}
+
+function traceOpacity(path: TracePath, highlight: string | null): number {
+  if (highlight === null) return path.opacity;
+  return highlight === path.hwKey || highlight === path.traceKey
+    ? Math.min(1, path.opacity + 0.15)
+    : path.opacity * 0.15;
+}
+
+function drawLabels(
+  group: d3.Selection<SVGGElement, unknown, null, undefined>,
+  xScale: AnyContinuousScale,
+  yScale: AnyContinuousScale,
+  model: DrawModel,
+  plotWidth: number,
+  highlight: string | null,
+): void {
+  const selection = group
+    .selectAll<SVGTextElement, TraceLabel>('text.power-trace-label')
+    .data(model.labels, (label) => label.id);
+  selection.exit().remove();
+  selection
+    .enter()
+    .append('text')
+    .attr('class', 'power-trace-label')
+    .attr('font-family', CHART_FONT_SANS)
+    .attr('font-size', px(CHART_TYPE.dataLabel))
+    .attr('font-weight', '600')
+    .attr('dominant-baseline', 'middle')
+    .attr('pointer-events', 'none')
+    .merge(selection)
+    .attr('data-hw', (label) => label.hwKey)
+    .attr('data-pool', (label) => label.pool ?? null)
+    .attr('fill', (label) => label.color)
+    .attr('opacity', (label) =>
+      highlight === null || highlight === label.hwKey || highlight === label.traceKey ? 1 : 0.2,
+    )
+    .text((label) => label.text)
+    .each(function (label) {
+      const x = xScale(label.x);
+      const y = yScale(label.y);
+      // Sit just past the last sample; flip inside the plot near the right edge.
+      const overflow = x + 6 + label.text.length * 6.5 > plotWidth;
+      d3.select(this)
+        .attr('text-anchor', overflow ? 'end' : 'start')
+        .attr('x', overflow ? x - 6 : x + 6)
+        .attr('y', y);
+    });
+}
+
+function drawReferenceLines(
+  group: d3.Selection<SVGGElement, unknown, null, undefined>,
+  yScale: AnyContinuousScale,
+  width: number,
+  lines: ReferenceLine[],
+): void {
+  group.selectAll('.power-reference').remove();
+  const slots = referenceLabelSlots(lines);
+  lines.forEach((line, index) => {
+    const y = yScale(line.watts);
+    const g = group
+      .append('g')
+      .attr('class', 'power-reference')
+      .attr('data-reference', line.kind)
+      .attr('data-pool', line.pools?.join(' ') ?? null)
+      .attr('data-watts', line.watts);
+    g.append('line')
+      .attr('x1', 0)
+      .attr('x2', width)
+      .attr('y1', y)
+      .attr('y2', y)
+      .attr('stroke', line.color)
+      .attr('stroke-width', 1.25)
+      .attr('stroke-dasharray', line.kind === 'tdp' ? '6,4' : '2,4')
+      .attr('opacity', 0.9);
+    g.append('text')
+      .attr('x', width - 4)
+      .attr('y', y - 5 - slots[index] * REFERENCE_LABEL_ROW)
+      .attr('text-anchor', 'end')
+      .attr('fill', line.color)
+      .attr('font-family', CHART_FONT_SANS)
+      .attr('font-size', px(CHART_TYPE.annotation))
+      .attr('font-weight', '600')
+      .text(line.label);
+  });
+}
+
+/** Reasons, then the undrawn configs (named when few, counted per hardware when many). */
+function describeMissing(
+  missing: readonly MissingTrace[],
+  t: (typeof STRINGS)[keyof typeof STRINGS],
+  hardwareLabel: (point: InferenceData) => string,
+): string {
+  const reasons = new Map<MissingTraceReason, number>();
+  for (const { reason } of missing) reasons.set(reason, (reasons.get(reason) ?? 0) + 1);
+  const reasonText = [...reasons.entries()]
+    .map(([reason, count]) => t.missingReason[reason](count))
+    .join('; ');
+  let list: string;
+  if (missing.length <= MAX_LISTED_MISSING) {
+    list = missing
+      .map(({ point }) => `${hardwareLabel(point)} ${traceConfigLabel(point)}`)
+      .join(' · ');
+  } else {
+    const perHardware = new Map<string, number>();
+    for (const { point } of missing) {
+      const label = hardwareLabel(point);
+      perHardware.set(label, (perHardware.get(label) ?? 0) + 1);
+    }
+    list = [...perHardware.entries()].map(([label, count]) => `${label} ×${count}`).join(' · ');
+  }
+  return `${reasonText}. ${t.missingUndrawn}: ${list}`;
+}
+
+export default function PowerTimeline({
+  chartId,
+  data,
+  overlayData,
+  yLabel,
+  caption,
+}: PowerTimelineProps) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const { hardwareConfig, hwTypesWithData } = useInferenceData();
+  const { activeHwTypes, selectedPrecisions, quickFilters } = useInferenceFilters();
+  const { isLegendExpanded, highContrast } = useInferenceDisplay();
+  const { setBestPerSku, toggleHwType, setIsLegendExpanded } = useInferenceActions();
+  const {
+    unofficialRunInfos,
+    runIndexByUrl,
+    activeOverlayHwTypes,
+    localOfficialOverride,
+    setUnifiedOverlaySelection,
+  } = useUnofficialRun();
+
+  const [xModeChoice, setXModeChoice] = useState<XMode | null>(null);
+  const [lineMode, setLineMode] = useState<LineMode>('mean');
+  const [showUtility, setShowUtility] = useState(false);
+  const [highlight, setHighlight] = useState<string | null>(null);
+  /** Trace a "View power trace" deep link asked for, once the join has produced it. */
+  const [focusKey, setFocusKey] = useState<string | null>(null);
+  /** The deep-link request, read once on mount; `undefined` until read, `null` once honoured. */
+  const requestedFocusRef = useRef<string | null | undefined>(undefined);
+
+  // The chart's point list still carries every precision, quick-filtered rows
+  // and rows without a validated average (ScatterGraph applies those gates at
+  // draw time); only rows that plot on the measured-average axis for the
+  // current selection have a trace to look up.
+  const plotsHere = useCallback(
+    (point: InferenceData) =>
+      point.measuredPowerTimeline !== undefined &&
+      selectedPrecisions.includes(point.precision) &&
+      matchesQuickFilters(point, quickFilters),
+    [selectedPrecisions, quickFilters],
+  );
+  const measuredData = useMemo(() => data.filter(plotsHere), [data, plotsHere]);
+  const overlayPoints = useMemo(
+    () => (overlayData?.data ?? []).filter(plotsHere),
+    [overlayData, plotsHere],
+  );
+  const overlayPointSet = useMemo(() => new Set<InferenceData>(overlayPoints), [overlayPoints]);
+  const allPoints = useMemo(
+    () => [...measuredData, ...overlayPoints],
+    [measuredData, overlayPoints],
+  );
+
+  const hwKeysInData = useMemo(
+    () =>
+      [...new Set(measuredData.map((point) => point.hwKey))].toSorted(
+        (a, b) => getModelSortIndex(a) - getModelSortIndex(b) || a.localeCompare(b),
+      ),
+    [measuredData],
+  );
+  const stableHcKeys = useMemo(() => [...hwTypesWithData], [hwTypesWithData]);
+  const activeOfficialKeys = useMemo(() => [...activeHwTypes], [activeHwTypes]);
+  const { resolveColor, getCssColor } = useThemeColors({
+    highContrast,
+    identifiers: hwKeysInData,
+    activeKeys: activeOfficialKeys,
+    hcKeys: stableHcKeys,
+  });
+
+  // ── Telemetry fetch: one request per workflow run ──────────────────────────
+  const requests = useMemo(() => planPowerTimelineRequests(allPoints), [allPoints]);
+  // The deep-link request is read once, before planning, so its run is fetched
+  // even when the chart spans more runs than the cap.
+  if (requestedFocusRef.current === undefined) {
+    requestedFocusRef.current = consumePowerTraceFocus();
+  }
+  const focusRunRef = useRef(traceKeyRunId(requestedFocusRef.current));
+  // Overlay runs were requested explicitly (`?unofficialrun=`), so they take
+  // the cap's slots before official runs; the deep-linked run still goes first.
+  const overlayRunIds = useMemo(
+    () =>
+      new Set(
+        overlayPoints
+          .map((point) => runIdFromUrl(point.run_url))
+          .filter((runId): runId is string => runId !== null),
+      ),
+    [overlayPoints],
+  );
+  const fetchedRequests = useMemo(
+    () =>
+      prioritizeRun(prioritizeRuns(requests, overlayRunIds), focusRunRef.current).slice(
+        0,
+        POWER_TIMELINE_MAX_RUNS,
+      ),
+    [requests, overlayRunIds],
+  );
+  const droppedRuns = requests.length - fetchedRequests.length;
+  const queries = useQueries({
+    queries: fetchedRequests.map((request) => ({
+      queryKey: ['power-timeline', request.runId, request.prefix] as const,
+      queryFn: ({ signal }: { signal: AbortSignal }) => fetchPowerSeries(request, signal),
+      staleTime: 5 * 60_000,
+      retry: 1,
+    })),
+  });
+  const loadingRuns = queries.filter((query) => query.isPending).length;
+  const errors = fetchedRequests
+    .map((request, index) => ({ request, error: queries[index].error }))
+    .filter(
+      (entry): entry is { request: PowerTimelineRequest; error: Error } =>
+        entry.error instanceof Error,
+    );
+  const responses = useMemo(() => {
+    const map = new Map<string, GpuPowerSeriesResponse>();
+    fetchedRequests.forEach((request, index) => {
+      const response = queries[index].data;
+      if (response) map.set(request.runId, response);
+    });
+    return map;
+    // Query data objects are stable per fetch; deriving from them keeps the map memoised.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [fetchedRequests, ...queries.map((query) => query.data)]);
+
+  const { traces, missing } = useMemo(
+    () => joinPowerTimeline(allPoints, responses),
+    [allPoints, responses],
+  );
+  const hasAnyArtifact = requests.length > 0;
+
+  // Honour the deep link once its trace exists; a disaggregated trace opens in
+  // pool mode because its prefill / decode split is what the reader came for.
+  useEffect(() => {
+    const requested = requestedFocusRef.current;
+    if (!requested) return;
+    const trace = traces.find((entry) => entry.key === requested);
+    if (!trace) return;
+    requestedFocusRef.current = null;
+    setFocusKey(trace.key);
+    if (tracePools(trace.series).length > 0) setLineMode('pool');
+  }, [traces]);
+
+  useEffect(() => {
+    if (loadingRuns > 0 || responses.size === 0) return;
+    track('inference_power_timeline_loaded', {
+      traces: traces.length,
+      missing: missing.length,
+      runs: responses.size,
+    });
+  }, [loadingRuns, responses.size, traces.length, missing.length]);
+
+  // ── Visible traces and their colours ────────────────────────────────────────
+  const colorForTrace = useCallback(
+    (trace: PowerTimelineTrace): { color: string; overlayIndex: number | null } => {
+      if (overlayPointSet.has(trace.point)) {
+        const index = overlayRunIndex(trace.point.run_url ?? null, runIndexByUrl);
+        return { color: overlayRunColor(index), overlayIndex: index };
+      }
+      return { color: getCssColor(resolveColor(trace.point.hwKey)), overlayIndex: null };
+    },
+    [overlayPointSet, runIndexByUrl, getCssColor, resolveColor],
+  );
+  // Same visibility source as ScatterGraph: an overlay session may hold a
+  // local official selection that has not been written back to the filters.
+  const officialHwTypes = localOfficialOverride ?? activeHwTypes;
+  // With an overlay loaded the chart reads localOfficialOverride, so a legend
+  // click must write the unified selection the way ScatterGraph does; the
+  // context's toggleHwType would change activeHwTypes with no visible effect.
+  const handleToggleHwType = useCallback(
+    (key: string) => {
+      if (!overlayData) {
+        toggleHwType(key);
+        return;
+      }
+      setBestPerSku(false, { applySelection: false });
+      const official = new Set([...officialHwTypes].filter((hw) => hwTypesWithData.has(hw)));
+      setUnifiedOverlaySelection(
+        computeToggle(official, key, hwTypesWithData),
+        activeOverlayHwTypes,
+      );
+    },
+    [
+      overlayData,
+      toggleHwType,
+      setBestPerSku,
+      officialHwTypes,
+      hwTypesWithData,
+      setUnifiedOverlaySelection,
+      activeOverlayHwTypes,
+    ],
+  );
+  const visibleTraces = useMemo(
+    () =>
+      traces.filter((trace) =>
+        overlayPointSet.has(trace.point)
+          ? activeOverlayHwTypes.has(trace.point.hwKey)
+          : officialHwTypes.has(trace.point.hwKey),
+      ),
+    [traces, overlayPointSet, activeOverlayHwTypes, officialHwTypes],
+  );
+  // Focus follows visibility: hiding the focused hardware in the legend lifts
+  // the dimming and the chip instead of dimming everything with nothing lit.
+  const focusedTrace = useMemo(
+    () => visibleTraces.find((trace) => trace.key === focusKey) ?? null,
+    [visibleTraces, focusKey],
+  );
+  /** Legend hover wins over the deep-link focus while it lasts. */
+  const activeHighlight = highlight ?? focusedTrace?.key ?? null;
+  const visibleRunCount = useMemo(
+    () => new Set(visibleTraces.map((trace) => trace.runId)).size,
+    [visibleTraces],
+  );
+  const xMode: XMode = xModeChoice ?? (visibleRunCount <= 1 ? 'wall' : 'elapsed');
+
+  // The pools switch is offered only where a visible trace carries worker roles;
+  // pool mode left without one would draw deployment totals with no way back.
+  const hasPools = useMemo(
+    () => visibleTraces.some((trace) => tracePools(trace.series).length > 0),
+    [visibleTraces],
+  );
+  useEffect(() => {
+    if (lineMode === 'pool' && !hasPools && visibleTraces.length > 0) setLineMode('mean');
+  }, [lineMode, hasPools, visibleTraces.length]);
+
+  const model = useMemo<DrawModel>(() => {
+    const paths: TracePath[] = [];
+    const labels: TraceLabel[] = [];
+    for (const trace of visibleTraces) {
+      const { color, overlayIndex } = colorForTrace(trace);
+      const tracePathSet = tracePaths(trace, color, overlayIndex, xMode, lineMode);
+      paths.push(...tracePathSet);
+      if (visibleTraces.length > MAX_LABELED_TRACES) continue;
+      // One end label per trace; per pool in pool mode, so the role reads off the line.
+      const groups: { pool?: PowerPoolRole; paths: TracePath[] }[] =
+        lineMode === 'pool'
+          ? drawnPools(trace.series).map((pool) => ({
+              pool: pool.role,
+              paths: tracePathSet.filter((path) => path.pool === pool.role),
+            }))
+          : [{ paths: tracePathSet }];
+      for (const group of groups) {
+        const anchor =
+          group.paths.find((path) => path.segment === 'window') ??
+          group.paths.find((path) => path.segment === 'full');
+        const last = anchor?.points.filter((point) => point.y !== null).at(-1);
+        if (!last || last.y === null) continue;
+        labels.push({
+          id: group.pool ? `${trace.key}:${group.pool}` : trace.key,
+          traceKey: trace.key,
+          hwKey: trace.point.hwKey,
+          pool: group.pool,
+          color,
+          text: group.pool
+            ? `c${trace.point.conc} · ${t.poolShort[group.pool]}`
+            : `c${trace.point.conc}`,
+          x: last.x,
+          y: last.y,
+        });
+      }
+    }
+    return { paths, labels };
+  }, [visibleTraces, colorForTrace, xMode, lineMode, t]);
+
+  const samples = useMemo(
+    () =>
+      visibleTraces.flatMap((trace) => {
+        const { color, overlayIndex } = colorForTrace(trace);
+        return traceSamples(trace, color, overlayIndex, xMode, lineMode);
+      }),
+    [visibleTraces, colorForTrace, xMode, lineMode],
+  );
+
+  // Rated references: per hardware in mean / per-GPU modes; per (hardware,
+  // pool size) in pool mode, scaled to the pool so the summed line and its
+  // ceiling share the axis. Roles of one hardware that hold the same number
+  // of GPUs share a ceiling and draw as one line (`prefill / decode ×16`).
+  const referenceLines = useMemo<ReferenceLine[]>(() => {
+    const lines: ReferenceLine[] = [];
+    const pushLines = (base: string, color: string, pool?: PoolSizeGroup) => {
+      const specs = HW_REGISTRY[base];
+      if (!specs) return;
+      const label = specs.label ?? base.toUpperCase();
+      const size = pool?.size ?? 1;
+      const id = pool ? `${base}:${pool.roles.join('+')}:${pool.size}` : base;
+      const name = pool
+        ? `${label} ${pool.roles.map((role) => t.poolShort[role]).join(' / ')} ×${pool.size}`
+        : label;
+      if (specs.tdp > 0) {
+        lines.push({
+          id: `tdp:${id}`,
+          watts: specs.tdp * size,
+          label: `${name} ${t.tdp} ${specs.tdp * size} W`,
+          color,
+          kind: 'tdp',
+          pools: pool?.roles,
+        });
+      }
+      if (showUtility && specs.power > 0) {
+        const watts = pool ? Math.round(specs.power * 1000) * size : specs.power * 1000;
+        lines.push({
+          id: `utility:${id}`,
+          watts,
+          label: `${name} ${t.allIn} ${Math.round(watts)} W`,
+          color,
+          kind: 'utility',
+          pools: pool?.roles,
+        });
+      }
+    };
+    // First trace of a hardware sets the reference colour, as before.
+    const perBase = new Map<string, { color: string; pools: PowerPool[] }>();
+    for (const trace of visibleTraces) {
+      const base = baseHardware(trace.point.hwKey);
+      if (!perBase.has(base)) perBase.set(base, { color: colorForTrace(trace).color, pools: [] });
+      if (lineMode === 'pool') perBase.get(base)!.pools.push(...drawnPools(trace.series));
+    }
+    for (const [base, { color, pools }] of perBase) {
+      if (lineMode !== 'pool') {
+        pushLines(base, color);
+        continue;
+      }
+      for (const group of groupPoolsBySize(pools)) pushLines(base, color, group);
+    }
+    return lines;
+  }, [visibleTraces, colorForTrace, showUtility, lineMode, t]);
+
+  // ── Scales ─────────────────────────────────────────────────────────────────
+  const xDomain = useMemo<[number, number]>(() => {
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (const path of model.paths) {
+      if (path.segment !== 'full') continue;
+      for (const point of path.points) {
+        if (point.x < min) min = point.x;
+        if (point.x > max) max = point.x;
+      }
+    }
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+      return xMode === 'wall' ? [Date.UTC(2026, 0, 1), Date.UTC(2026, 0, 1, 0, 10)] : [0, 600];
+    }
+    return min === max ? [min, max + (xMode === 'wall' ? 60_000 : 60)] : [min, max];
+  }, [model.paths, xMode]);
+  const yDomain = useMemo<[number, number]>(() => {
+    let max = 0;
+    for (const path of model.paths) {
+      for (const point of path.points) if (point.y !== null && point.y > max) max = point.y;
+    }
+    for (const line of referenceLines) if (line.watts > max) max = line.watts;
+    return [0, max > 0 ? max * 1.06 : 100];
+  }, [model.paths, referenceLines]);
+
+  const xTickFormat = useMemo(() => {
+    if (xMode === 'elapsed') return (value: d3.AxisDomain) => formatElapsed(Number(value));
+    const span = xDomain[1] - xDomain[0];
+    const format = d3.utcFormat(span < 3 * 60_000 ? '%H:%M:%S' : '%H:%M');
+    return (value: d3.AxisDomain) =>
+      format(value instanceof Date ? value : new Date(Number(value)));
+  }, [xMode, xDomain]);
+
+  // ── Layers ─────────────────────────────────────────────────────────────────
+  const highlightRef = useRef(activeHighlight);
+  highlightRef.current = activeHighlight;
+  const layers = useMemo<LayerConfig<TimelineSample>[]>(
+    () => [
+      {
+        type: 'custom',
+        key: 'power-reference-lines',
+        render: (group, ctx) => {
+          drawReferenceLines(group, ctx.yScale as AnyContinuousScale, ctx.width, referenceLines);
+        },
+      },
+      {
+        type: 'custom',
+        key: 'power-traces',
+        render: (group, ctx: RenderContext) => {
+          drawTraces(
+            group,
+            ctx.xScale as AnyContinuousScale,
+            ctx.yScale as AnyContinuousScale,
+            model,
+            highlightRef.current,
+          );
+        },
+        onZoom: (group, ctx: ZoomContext) => {
+          drawTraces(
+            group,
+            ctx.newXScale as AnyContinuousScale,
+            ctx.newYScale as AnyContinuousScale,
+            model,
+            highlightRef.current,
+          );
+        },
+      },
+      {
+        type: 'point',
+        key: 'power-hit-points',
+        data: samples,
+        config: {
+          getCx: () => 0,
+          getCy: () => 0,
+          getX: (sample) => sample.x,
+          getY: (sample) => sample.y,
+          getColor: (sample) => sample.color,
+          getRadius: () => 2,
+          // Pool streams of one trace share columns; the role keeps their keys apart.
+          keyFn: (sample) =>
+            sample.pool
+              ? `${sample.trace.key}:${sample.pool.role}:${sample.column}`
+              : `${sample.trace.key}:${sample.column}`,
+          maxPoints: Number.POSITIVE_INFINITY,
+        },
+      },
+      {
+        type: 'custom',
+        key: 'power-trace-labels',
+        render: (group, ctx: RenderContext) => {
+          drawLabels(
+            group,
+            ctx.xScale as AnyContinuousScale,
+            ctx.yScale as AnyContinuousScale,
+            model,
+            ctx.width,
+            highlightRef.current,
+          );
+        },
+        onZoom: (group, ctx: ZoomContext) => {
+          drawLabels(
+            group,
+            ctx.newXScale as AnyContinuousScale,
+            ctx.newYScale as AnyContinuousScale,
+            model,
+            ctx.width,
+            highlightRef.current,
+          );
+        },
+      },
+    ],
+    [referenceLines, model, samples],
+  );
+
+  const onDisplayUpdate = useCallback(
+    (ctx: RenderContext) => {
+      const root = d3.select(ctx.layout.svg.node() as SVGSVGElement);
+      root
+        .selectAll<SVGPathElement, TracePath>('path.power-trace')
+        .attr('opacity', (path) => traceOpacity(path, activeHighlight));
+      root
+        .selectAll<SVGTextElement, TraceLabel>('text.power-trace-label')
+        .attr('opacity', (label) =>
+          activeHighlight === null ||
+          activeHighlight === label.hwKey ||
+          activeHighlight === label.traceKey
+            ? 1
+            : 0.2,
+        );
+    },
+    [activeHighlight],
+  );
+
+  const hardwareLabel = useCallback(
+    (point: InferenceData): string => {
+      const config = overlayPointSet.has(point)
+        ? overlayData?.hardwareConfig[point.hwKey]
+        : hardwareConfig[point.hwKey];
+      return config ? getDisplayLabel(config) : point.hwKey;
+    },
+    [overlayPointSet, overlayData, hardwareConfig],
+  );
+
+  const tooltipContent = useCallback(
+    (sample: TimelineSample, isPinned: boolean) => {
+      const { trace } = sample;
+      const point = trace.point;
+      const overlayInfo =
+        sample.overlayIndex === null ? null : unofficialRunInfos[sample.overlayIndex];
+      const tdp = HW_REGISTRY[baseHardware(point.hwKey)]?.tdp ?? 0;
+      const elapsed = formatElapsed((sample.timeMs - trace.series.startMs) / 1000);
+      const clock = `${formatUtcClock(new Date(sample.timeMs))} UTC`;
+      const time =
+        xMode === 'wall' ? `${clock} · +${elapsed} ${t.sinceStart}` : `+${elapsed} · ${clock}`;
+      const colon = locale === 'zh' ? '：' : ':';
+      const validated = point.measuredAvgPower?.y;
+      const { pool } = sample;
+      const readings = pool
+        ? `<div class="mt-1 text-muted-foreground">${t.pool}${colon} ${t.poolShort[pool.role]} · ${t.gpus(pool.gpuCount)}</div>
+        <div class="font-medium">${t.poolPower}${colon} ${formatWatts(sample.y)} W${
+          tdp > 0
+            ? ` <span class="text-muted-foreground">(${((sample.y / (tdp * pool.gpuCount)) * 100).toFixed(0)}% ${t.poolTdp})</span>`
+            : ''
+        }</div>
+        <div class="text-muted-foreground">${t.meanPerGpu}${colon} ${(sample.y / sample.gpuCount).toFixed(1)} W · ${t.min} ${sample.min.toFixed(1)} W · ${t.max} ${sample.max.toFixed(1)} W</div>`
+        : `<div class="mt-1 font-medium">${t.meanPerGpu}${colon} ${sample.y.toFixed(1)} W${
+            tdp > 0
+              ? ` <span class="text-muted-foreground">(${((sample.y / tdp) * 100).toFixed(0)}% ${t.tdp})</span>`
+              : ''
+          }</div>
+        <div class="text-muted-foreground">${t.gpus(sample.gpuCount)} · ${t.min} ${sample.min.toFixed(1)} W · ${t.max} ${sample.max.toFixed(1)} W</div>`;
+      return `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md backdrop-blur-sm" style="min-width: 210px; user-select: ${isPinned ? 'text' : 'none'}">
+        ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
+        <div class="font-semibold mb-1" style="color: ${sample.color}">${hardwareLabel(point)} · ${traceConfigLabel(point)}${
+          overlayInfo ? ` · ✕ ${overlayInfo.branch || `run ${overlayInfo.id}`}` : ''
+        }</div>
+        <div class="text-muted-foreground">${time}</div>
+        ${readings}
+        <div class="text-muted-foreground">${t.phase[sample.phase]}</div>
+        ${
+          typeof validated === 'number'
+            ? `<div class="text-muted-foreground">${t.validated}${colon} ${validated.toFixed(1)} W</div>`
+            : ''
+        }
+      </div>`;
+    },
+    [unofficialRunInfos, xMode, t, locale, hardwareLabel],
+  );
+
+  // ── Legend ─────────────────────────────────────────────────────────────────
+  const legendItems = useMemo(() => {
+    const overlayItems =
+      overlayData && unofficialRunInfos.length > 0
+        ? unofficialRunInfos
+            .map((info, index) => {
+              const hasPoints = overlayPoints.some(
+                (point) => overlayRunIndex(point.run_url ?? null, runIndexByUrl) === index,
+              );
+              if (!hasPoints) return null;
+              const branch = info.branch || `run ${info.id}`;
+              return {
+                name: `✕ unofficial-run-${info.id}`,
+                label: `✕ ${branch}`,
+                color: overlayRunColor(index),
+                title: `${t.unofficialRun}: ${branch}`,
+                isHighlighted: true,
+                hw: `overlay-run-${info.id}`,
+                isActive: true,
+                isRemovable: false,
+                onClick: () => {},
+                tooltip: (
+                  <div className="font-normal text-xs">
+                    <div className="text-red-500 font-semibold">{t.unofficialRun}</div>
+                    <div>
+                      {t.branch}: {branch}
+                    </div>
+                    {info.url && (
+                      <a
+                        href={info.url}
+                        target="_blank"
+                        rel="noopener noreferrer"
+                        className="underline"
+                      >
+                        {t.viewWorkflow}
+                      </a>
+                    )}
+                  </div>
+                ),
+              };
+            })
+            .filter((item): item is NonNullable<typeof item> => item !== null)
+        : [];
+    const officialItems = hwKeysInData
+      .filter((key) => hwTypesWithData.has(key) && hardwareConfig[key])
+      .map((key) => {
+        const config = hardwareConfig[key];
+        return {
+          name: config.name,
+          label: getDisplayLabel(config),
+          color: resolveColor(key),
+          title: config.gpu,
+          hw: key,
+          isActive: officialHwTypes.has(key),
+          onClick: () => {
+            handleToggleHwType(key);
+            track('latency_hw_type_toggled', { hw: key });
+          },
+          tooltip: null,
+        };
+      });
+    return [...overlayItems, ...officialItems];
+  }, [
+    overlayData,
+    unofficialRunInfos,
+    overlayPoints,
+    runIndexByUrl,
+    hwKeysInData,
+    hwTypesWithData,
+    hardwareConfig,
+    resolveColor,
+    officialHwTypes,
+    handleToggleHwType,
+    t,
+  ]);
+
+  // Per-GPU and pools are two views of the same lines, so either switch turns
+  // the other off; both fall back to the mean.
+  const chooseLineMode = (next: LineMode) => {
+    setLineMode(next);
+    track('inference_power_timeline_lines_changed', { lines: next });
+  };
+  const switches: LegendSwitchConfig[] = [
+    {
+      id: 'power-timeline-per-gpu',
+      label: t.perGpu,
+      checked: lineMode === 'gpu',
+      onCheckedChange: (checked) => chooseLineMode(checked ? 'gpu' : 'mean'),
+      infoTooltip: t.perGpuHelp,
+    },
+  ];
+  if (hasPools) {
+    switches.push({
+      id: 'power-timeline-pools',
+      label: t.pools,
+      checked: lineMode === 'pool',
+      onCheckedChange: (checked) => chooseLineMode(checked ? 'pool' : 'mean'),
+      infoTooltip: t.poolsHelp,
+    });
+  }
+  switches.push({
+    id: 'power-timeline-utility',
+    label: t.utilityLines,
+    checked: showUtility,
+    onCheckedChange: (checked) => {
+      setShowUtility(checked);
+      track('inference_power_timeline_utility_toggled', { enabled: checked });
+    },
+    infoTooltip: t.utilityHelp,
+  });
+
+  const legendElement = (
+    <ChartLegend
+      variant="sidebar"
+      legendItems={legendItems}
+      isLegendExpanded={isLegendExpanded}
+      onExpandedChange={(expanded) => {
+        setIsLegendExpanded(expanded);
+        track('latency_legend_expanded', { expanded });
+      }}
+      onItemHover={(id) => setHighlight(id)}
+      onItemHoverEnd={() => setHighlight(null)}
+      hideAtomFootnote
+      switches={switches}
+    />
+  );
+
+  const runInfos = useMemo(
+    () =>
+      fetchedRequests
+        .map((request) => responses.get(request.runId)?.runInfo)
+        .filter((info): info is NonNullable<typeof info> => Boolean(info)),
+    [fetchedRequests, responses],
+  );
+
+  const toolbar = (
+    <div
+      className="flex flex-wrap items-center justify-end gap-2 pb-1"
+      data-testid="power-timeline-toolbar"
+    >
+      <span className="text-xs text-muted-foreground">{t.timeAxis}</span>
+      <SegmentedToggle<XMode>
+        value={xMode}
+        ariaLabel={t.timeAxis}
+        role="group"
+        options={[
+          { value: 'wall', label: t.wall, testId: 'power-timeline-axis-wall' },
+          { value: 'elapsed', label: t.elapsed, testId: 'power-timeline-axis-elapsed' },
+        ]}
+        onValueChange={(mode) => {
+          setXModeChoice(mode);
+          track('inference_power_timeline_axis_changed', { mode });
+        }}
+      />
+    </div>
+  );
+
+  let emptyMessage: string | null = null;
+  if (loadingRuns > 0) emptyMessage = t.loading(loadingRuns);
+  else if (!hasAnyArtifact) emptyMessage = t.noArtifacts;
+  else if (visibleTraces.length === 0) emptyMessage = t.noTraces;
+
+  return (
+    <div className="relative flex flex-col gap-2" data-testid="power-timeline">
+      <D3Chart<TimelineSample>
+        key={`${chartId}-${xMode}-${lineMode}`}
+        chartId={chartId}
+        data={samples}
+        height={CHART_HEIGHT}
+        margin={MARGIN}
+        watermark={overlayData && overlayPoints.length > 0 ? 'unofficial' : 'logo'}
+        testId="power-timeline-chart-svg"
+        grabCursor
+        instructions={t.instructions}
+        xScale={
+          xMode === 'wall'
+            ? { type: 'time', domain: [new Date(xDomain[0]), new Date(xDomain[1])] }
+            : { type: 'linear', domain: xDomain }
+        }
+        yScale={{ type: 'linear', domain: yDomain, nice: true }}
+        xAxis={{
+          label: xMode === 'wall' ? t.xWall : t.xElapsed,
+          tickCount: 10,
+          tickFormat: xTickFormat,
+        }}
+        yAxis={{ label: lineMode === 'pool' ? t.yPool : yLabel, tickCount: 8 }}
+        layers={layers}
+        displayIdentity={activeHighlight ?? ''}
+        onDisplayUpdate={onDisplayUpdate}
+        zoom={{
+          enabled: true,
+          axes: 'x',
+          scaleExtent: [1, 60],
+          resetEventName: `power_timeline_zoom_reset_${chartId}`,
+        }}
+        tooltip={{
+          rulerType: 'crosshair',
+          content: tooltipContent,
+          getRulerX: (sample, xScale) => (xScale as AnyContinuousScale)(sample.x),
+          getRulerY: (sample, yScale) => yScale(sample.y),
+          onHoverStart: (selection) => {
+            selection.attr('r', 5).attr('stroke', 'white').attr('stroke-width', 1);
+          },
+          onHoverEnd: (selection) => {
+            selection.attr('r', 2).attr('stroke', 'none');
+          },
+          attachToLayer: 2,
+        }}
+        legendElement={legendElement}
+        caption={
+          <>
+            {caption}
+            {toolbar}
+          </>
+        }
+        noDataOverlay={
+          emptyMessage ? (
+            <div
+              className="absolute inset-0 flex items-center justify-center px-6 text-center text-sm text-muted-foreground"
+              data-testid="power-timeline-empty"
+              aria-live="polite"
+            >
+              {emptyMessage}
+            </div>
+          ) : undefined
+        }
+      />
+      <div
+        className="flex flex-col gap-1 px-1 text-xs text-muted-foreground"
+        data-testid="power-timeline-status"
+      >
+        {focusedTrace && (
+          <p
+            className="inline-flex items-center gap-2 self-start rounded-full border px-2 py-0.5"
+            data-testid="power-timeline-focus"
+          >
+            <span>
+              {t.focused(
+                `${hardwareLabel(focusedTrace.point)} · ${traceConfigLabel(focusedTrace.point)}`,
+              )}
+            </span>
+            <button
+              type="button"
+              className="underline decoration-dotted hover:text-foreground"
+              data-testid="power-timeline-focus-clear"
+              onClick={() => {
+                setFocusKey(null);
+                track('inference_power_timeline_focus_cleared');
+              }}
+            >
+              {t.showAll}
+            </button>
+          </p>
+        )}
+        {errors.map(({ request, error }) => (
+          <p key={request.runId} className="text-destructive" role="alert">
+            {t.loadError(request.runId, error.message)}
+          </p>
+        ))}
+        {droppedRuns > 0 && <p>{t.droppedRuns(droppedRuns)}</p>}
+        {loadingRuns === 0 && missing.length > 0 && traces.length > 0 && (
+          <p data-testid="power-timeline-missing">
+            {t.missing(missing.length, traces.length + missing.length)}{' '}
+            {describeMissing(missing, t, hardwareLabel)}
+          </p>
+        )}
+        {runInfos.length > 0 && (
+          <p data-testid="power-timeline-source">
+            {t.telemetry}:{' '}
+            {runInfos.map((info, index) => (
+              <React.Fragment key={info.id}>
+                {index > 0 && ' · '}
+                <a
+                  href={info.url}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  className="underline decoration-dotted"
+                >
+                  {`run ${info.id}`}
+                </a>
+                {info.createdAt ? ` (${formatUtcDate(new Date(info.createdAt))})` : ''}
+              </React.Fragment>
+            ))}
+          </p>
+        )}
+        <p>{t.method}</p>
+        {hasPools && <p>{t.methodPools}</p>}
+      </div>
+    </div>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 4f67e2fbe..04206c80f 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -16,6 +16,7 @@ import {
   useInferenceDisplay,
   useInferenceFilters,
 } from '@/components/inference/InferenceContext';
+import { usePerfRulerStore } from '@/components/inference/perf-ruler-store';
 import { useTraceAvailability } from '@/hooks/api/use-trace-availability';
 import { useLogAvailability } from '@/hooks/api/use-log-availability';
 import { computeToggle } from '@/hooks/useTogglableSet';
@@ -47,7 +48,13 @@ import { matchKnownConfigIssues, pointMatchesIssue } from '@/lib/known-issues';
 import { useLocale } from '@/lib/use-locale';
 import { getLineLabelVendorIcon } from '@/lib/vendor-logos';
 import { formatNumber, getDisplayLabel, updateRepoUrl } from '@/lib/utils';
-import { getInferenceHardwareConfig, getInferenceRunLabel } from '@/lib/inference-labels';
+import {
+  getInferenceHardwareConfig,
+  getInferenceRunLabel,
+  getOverlayLineLabel,
+  OVERLAY_LABEL_MARKER,
+  overlayRunTag,
+} from '@/lib/inference-labels';
 import { D3Chart } from '@/lib/d3-chart/D3Chart';
 import type {
   CustomLayerConfig,
@@ -75,6 +82,7 @@ import {
   renderPerfRulers,
   type PerfRulerEndInput,
   type PerfRulerGeometry,
+  type PerfRulerMeasurement,
   type PerfRulerRenderEntry,
   type PerfRulerState,
 } from '@/lib/d3-chart/layers/perf-ruler';
@@ -109,6 +117,7 @@ import {
   chartFrontier,
   upperPowerEnvelope,
   isPowerCurveMetric,
+  isPowerGaugeSeries,
   isMeasuredPowerCurveMetric,
 } from '@/components/inference/utils/powerCurves';
 import type {
@@ -116,17 +125,38 @@ import type {
   ClippedInferenceData,
   InferenceData,
   ScatterGraphProps,
+  PowerVariant,
 } from '@/components/inference/types';
 import {
   generateOverlayTooltipContent,
   generateTooltipContent,
 } from '@/components/inference/utils/tooltipUtils';
+import {
+  POWER_TIMELINE_METRIC_KEY,
+  requestPowerTraceFocus,
+  traceKeyForPoint,
+} from '@/components/inference/utils/powerTimeline';
 import { QuickFiltersDialog } from '@/components/inference/ui/QuickFiltersDialog';
 import { ScatterEmptyState } from '@/components/inference/ui/ScatterEmptyState';
 import {
   scatterPointConfigId,
   scatterPointJoinId,
+  parseScatterSeriesKey,
+  scatterSeriesKey,
 } from '@/components/inference/utils/point-identity';
+import {
+  flatSeriesValue,
+  inferPowerCompare,
+  lineLabelHardwareKey,
+  lineLabelSeriesId,
+  metricPlotsWatts,
+  powerCompareBase,
+  powerLineLabelSuffix,
+  powerVariantDash,
+  powerVariantId,
+  powerVariantLabel,
+  powerVariantsInData,
+} from '@/components/inference/utils/power-compare';
 import LegendPointsDialog from '@/components/inference/ui/LegendPointsDialog';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
 import { renderLegacyPowerRing } from '@/components/inference/utils/legacy-power-marker';
@@ -219,6 +249,32 @@ const optimalPointKey = (d: InferenceData): string =>
 const EMPTY_OVERLAY_DATA: InferenceData[] = [];
 const EMPTY_CLIPPED_DATA: ClippedInferenceData[] = [];
 
+/**
+ * Legend ids of the comparison-series rows (`i_pcompare`), distinct from
+ * hardware keys so the shared hover / toggle handlers can tell them apart.
+ */
+const POWER_VARIANT_LEGEND_PREFIX = 'power-variant:';
+/** Comparison clones sit behind the base series they annotate. */
+const POWER_VARIANT_POINT_OPACITY = 0.6;
+const pointOpacityForVariant = (d: InferenceData): number =>
+  d.powerVariant ? POWER_VARIANT_POINT_OPACITY : 1;
+/** Dash for a series key's variant id (`parseScatterSeriesKey().variant`). */
+const powerVariantDashById = (variantId: string | null | undefined): string =>
+  variantId ? (VARIANT_DASH_BY_ID.get(variantId) ?? '') : '';
+const VARIANT_DASH_BY_ID = new Map<string, string>(
+  (
+    [
+      ['basis', 'gpu-measured'],
+      ['basis', 'gpu-provisioned'],
+      ['basis', 'utility-provisioned'],
+      ['basis', 'utility-modeled'],
+      ['role', 'all'],
+      ['role', 'prefill'],
+      ['role', 'decode'],
+    ] as const
+  ).map(([kind, id]) => [id, powerVariantDash({ kind, id } as PowerVariant)]),
+);
+
 function setsEqual<T>(a: Set<T>, b: Set<T>): boolean {
   if (a.size !== b.size) return false;
   for (const value of a) {
@@ -531,6 +587,7 @@ const ScatterGraph = React.memo(
       setQuickFilterDeployment,
       setQuickFilterSpec,
       setQuickFilterPower,
+      setSelectedYAxisMetric,
     } = useInferenceActions();
     const paretoDirection = chartDefinition[`${selectedYAxisMetric}_roofline`] as
       | ParetoDirection
@@ -549,15 +606,28 @@ const ScatterGraph = React.memo(
         const groups = groupPointsByDate(points);
         if (showPowerEnvelope) {
           for (const [date, samples] of groups) {
-            groups.set(date, upperPowerEnvelope(samples, chartDefinition.chartType !== 'e2e'));
+            groups.set(
+              date,
+              upperPowerEnvelope(
+                samples,
+                chartDefinition.chartType !== 'e2e',
+                isPowerGaugeSeries(selectedYAxisMetric, samples[0]),
+              ),
+            );
           }
         }
         return groups;
       },
-      [showPowerEnvelope, chartDefinition.chartType],
+      [showPowerEnvelope, chartDefinition.chartType, selectedYAxisMetric],
     );
     const locale = useLocale();
     const legendT = SCATTER_STRINGS[locale];
+    // Comparison series (`i_pcompare`) switched off from the legend. Chart-local,
+    // like Optimal Only's point set: the URL carries the comparison, not which
+    // of its rows a reader hid while looking.
+    const [hiddenPowerVariants, setHiddenPowerVariants] = useState<ReadonlySet<string>>(
+      () => new Set(),
+    );
     const ephemeralUrlState = useEphemeralUrlState();
     const costLimit = chartDefinition.y_cost_limit ?? 0;
     const latencyLimit = chartDefinition.y_latency_limit ?? 0;
@@ -798,7 +868,7 @@ const ScatterGraph = React.memo(
       () =>
         data.reduce(
           (acc, point) => {
-            const key = `${point.hwKey}_${point.precision}`;
+            const key = scatterSeriesKey(point);
             if (!acc[key]) acc[key] = [];
             acc[key].push(point);
             return acc;
@@ -935,7 +1005,7 @@ const ScatterGraph = React.memo(
       }
       const buckets = new Map<string, Bucket>();
       const getBucket = (point: InferenceData) => {
-        const key = `${point.hwKey}|${point.precision}|${point.date}`;
+        const key = `${scatterSeriesKey(point)}|${point.date}`;
         let bucket = buckets.get(key);
         if (!bucket) {
           bucket = {
@@ -984,7 +1054,7 @@ const ScatterGraph = React.memo(
       const buckets = new Map<string, Bucket>();
       const getBucket = (point: InferenceData) => {
         const runIndex = overlayRunIndex(point.run_url ?? null, runIndexByUrl);
-        const key = `${point.hwKey}|${point.precision}|${point.date}|run${runIndex}`;
+        const key = `${scatterSeriesKey(point)}|${point.date}|run${runIndex}`;
         let bucket = buckets.get(key);
         if (!bucket) {
           bucket = {
@@ -1089,6 +1159,8 @@ const ScatterGraph = React.memo(
       interface Entry {
         hwKey: string;
         runIndex: number;
+        /** Comparison variant id for boundary / role clones, null for the run's base series. */
+        variant: string | null;
         points: InferenceData[];
       }
       if (processedOverlayData.length === 0) return {} as Record<string, Entry>;
@@ -1097,8 +1169,15 @@ const ScatterGraph = React.memo(
       const grouped = processedOverlayData.reduce(
         (acc, p) => {
           const runIndex = overlayRunIndex(p.run_url ?? null, runIndexByUrl);
-          const key = `${p.hwKey}_${p.precision}_run${runIndex}`;
-          if (!acc[key]) acc[key] = { hwKey: String(p.hwKey), runIndex, points: [] };
+          const key = `${scatterSeriesKey(p)}_run${runIndex}`;
+          if (!acc[key]) {
+            acc[key] = {
+              hwKey: String(p.hwKey),
+              runIndex,
+              variant: p.powerVariant?.id ?? null,
+              points: [],
+            };
+          }
           acc[key].points.push(p);
           return acc;
         },
@@ -1177,9 +1256,11 @@ const ScatterGraph = React.memo(
     // its X marker sitting on the dashed roofline and read as a pareto point.
     const isOverlayPointVisible = useCallback(
       (d: InferenceData) =>
+        !hiddenPowerVariants.has(powerVariantId(d.powerVariant)) &&
         (!hideNonOptimal || overlayOptimalPoints.has(d)) &&
         (!showPowerEnvelope || showAllMeasurements || overlayEnvelopePoints.has(d)),
       [
+        hiddenPowerVariants,
         hideNonOptimal,
         overlayOptimalPoints,
         showPowerEnvelope,
@@ -1214,6 +1295,44 @@ const ScatterGraph = React.memo(
     const { data: persistedLogAvailability } = useLogAvailability(persistedPointIds);
     const [fixedLogPointId, setFixedLogPointId] = useState<number | null>(null);
 
+    // "View power trace" on a pinned tooltip (official or overlay point): the
+    // same-tab click stays in-page — remember which trace to emphasise, switch
+    // the metric to the Timeline display, and let the anchor's href keep
+    // serving open-in-new-tab. Listeners are attached per pin because the
+    // tooltip HTML is replaced on every pin.
+    const attachPowerTraceAction = useCallback(
+      (tooltipEl: HTMLElement, d: InferenceData, overlay: boolean) => {
+        const action = tooltipEl.querySelector('[data-action="view-power-trace"]');
+        const traceKey = traceKeyForPoint(d);
+        if (!action || !traceKey) return;
+        action.addEventListener('click', (actionEvent) => {
+          actionEvent.stopPropagation();
+          // Modifier / auxiliary clicks keep the anchor's own behaviour: the
+          // href opens this chart's timeline in a new tab or window.
+          const mouse = actionEvent as MouseEvent;
+          if (
+            mouse.button !== 0 ||
+            mouse.metaKey ||
+            mouse.ctrlKey ||
+            mouse.shiftKey ||
+            mouse.altKey
+          ) {
+            return;
+          }
+          actionEvent.preventDefault();
+          requestPowerTraceFocus(traceKey);
+          chartRef.current?.dismissTooltip();
+          setSelectedYAxisMetric(POWER_TIMELINE_METRIC_KEY);
+          track('inference_power_trace_opened', {
+            hwKey: String(d.hwKey),
+            conc: d.conc,
+            overlay,
+          });
+        });
+      },
+      [setSelectedYAxisMetric],
+    );
+
     // --- Legend points table (per-series drill-down opened from the legend) ---
     const [pointsTableTarget, setPointsTableTarget] = useState<LegendPointsTarget | null>(null);
     const [quickFiltersOpen, setQuickFiltersOpen] = useState(false);
@@ -1248,6 +1367,7 @@ const ScatterGraph = React.memo(
         const pts = pointsData.filter(
           (p) =>
             p.hwKey === hwKey &&
+            !p.powerVariant &&
             selectedPrecisions.includes(p.precision) &&
             (!hideNonOptimal || optimalPointKeys.has(optimalPointKey(p))),
         );
@@ -1263,6 +1383,7 @@ const ScatterGraph = React.memo(
       const pts = processedOverlayData.filter(
         (p) =>
           overlayRunIndex(p.run_url ?? null, runIndexByUrl) === runIndex &&
+          !p.powerVariant &&
           activeOverlayHwTypes.has(p.hwKey as string) &&
           (!hideNonOptimal || overlayOptimalPoints.has(p)),
       );
@@ -1483,6 +1604,7 @@ const ScatterGraph = React.memo(
       (d: InferenceData) =>
         effectiveActiveHwTypes.has(d.hwKey as string) &&
         selectedPrecisions.includes(d.precision) &&
+        !hiddenPowerVariants.has(powerVariantId(d.powerVariant)) &&
         (!hideNonOptimal || optimalPointKeys.has(optimalPointKey(d))) &&
         (!showPowerEnvelope ||
           showAllMeasurements ||
@@ -1490,6 +1612,7 @@ const ScatterGraph = React.memo(
       [
         effectiveActiveHwTypes,
         selectedPrecisions,
+        hiddenPowerVariants,
         hideNonOptimal,
         optimalPointKeys,
         showPowerEnvelope,
@@ -1672,12 +1795,69 @@ const ScatterGraph = React.memo(
       getCssColor,
     ]);
 
+    // The comparison in effect and the base series' identity under it. The
+    // base is the selected metric's own series; deriving it from which variant
+    // no official point carries breaks when only an overlay carries the
+    // comparison, and line labels need the same answer as the legend rows.
+    const powerCompareMode = useMemo(() => {
+      const official = inferPowerCompare(pointsData);
+      return official === 'none' ? inferPowerCompare(processedOverlayData) : official;
+    }, [pointsData, processedOverlayData]);
+    const powerCompareBaseId = useMemo(
+      () => powerVariantId(powerCompareBase(selectedYAxisMetric, powerCompareMode)),
+      [selectedYAxisMetric, powerCompareMode],
+    );
+
+    // One legend row per comparison series present (base first). Rows toggle
+    // chart-local visibility and hover-highlight that series across hardware.
+    const powerVariantLegendItems = useMemo(() => {
+      const allPoints = [...pointsData, ...processedOverlayData];
+      const variants = powerVariantsInData(allPoints, selectedYAxisMetric);
+      const baseId = powerCompareBaseId;
+      return variants.map((variant) => {
+        const id = powerVariantId(variant);
+        const legendId = `${POWER_VARIANT_LEGEND_PREFIX}${id}`;
+        const isBase = id === baseId;
+        return {
+          name: legendId,
+          hw: legendId,
+          label: powerVariantLabel(variant, locale),
+          color: 'var(--foreground)',
+          // The base series is solid, like its points; siblings carry their dash.
+          lineDasharray: isBase ? '1 0' : powerVariantDash(variant) || '1 0',
+          isActive: !hiddenPowerVariants.has(isBase ? '' : id),
+          isRemovable: false,
+          onClick: () => {
+            const key = isBase ? '' : id;
+            setHiddenPowerVariants((prev) => {
+              const next = new Set(prev);
+              if (next.has(key)) next.delete(key);
+              else next.add(key);
+              return next;
+            });
+            track('inference_power_compare_series_toggled', {
+              series: id,
+              visible: hiddenPowerVariants.has(key),
+            });
+          },
+        };
+      });
+    }, [
+      pointsData,
+      processedOverlayData,
+      selectedYAxisMetric,
+      powerCompareBaseId,
+      locale,
+      hiddenPowerVariants,
+    ]);
+
     const powerTierCounts = useMemo(() => {
-      const officialTotal = pointsData.filter((point) =>
-        selectedPrecisions.includes(point.precision),
+      // Comparison clones re-plot the same measurements; count each once.
+      const officialTotal = pointsData.filter(
+        (point) => !point.powerVariant && selectedPrecisions.includes(point.precision),
       );
-      const overlayTotal = processedOverlayData.filter((point) =>
-        selectedPrecisions.includes(point.precision),
+      const overlayTotal = processedOverlayData.filter(
+        (point) => !point.powerVariant && selectedPrecisions.includes(point.precision),
       );
       const officialVisible = officialTotal.filter(isPointVisible);
       const overlayVisible = overlayTotal.filter(
@@ -1702,9 +1882,13 @@ const ScatterGraph = React.memo(
         const hw = el.dataset.hwKey;
         const prec = el.dataset.precision;
         if (hw === null || hw === undefined || prec === null || prec === undefined) return false;
-        return effectiveActiveHwTypes.has(hw) && selectedPrecisions.includes(prec);
+        return (
+          effectiveActiveHwTypes.has(hw) &&
+          selectedPrecisions.includes(prec) &&
+          !hiddenPowerVariants.has(el.dataset.powerVariant ?? '')
+        );
       },
-      [effectiveActiveHwTypes, selectedPrecisions],
+      [effectiveActiveHwTypes, selectedPrecisions, hiddenPowerVariants],
     );
 
     // --- Interaction state ref ---
@@ -1721,6 +1905,7 @@ const ScatterGraph = React.memo(
       isPointVisible,
       isOverlayPointVisible,
       effectiveActiveHwTypes,
+      hiddenPowerVariants,
       selectedPrecisions,
       activeOverlayHwTypes,
       getCssColor,
@@ -1733,6 +1918,7 @@ const ScatterGraph = React.memo(
       isPointVisible,
       isOverlayPointVisible,
       effectiveActiveHwTypes,
+      hiddenPowerVariants,
       selectedPrecisions,
       activeOverlayHwTypes,
       getCssColor,
@@ -1751,17 +1937,39 @@ const ScatterGraph = React.memo(
     // the curves' rendered paths at the iso-x — neither end needs to be a
     // data point. Multiple rulers accumulate (capped in the pure module);
     // completing one immediately allows starting the next.
-    const [preferPerfRulerMode, setPerfRulerMode] = useState(false);
+    //
+    // The primary chart's rulers live in the InferenceProvider store so they
+    // ride along in share links (`i_rulers`) and survive a remount (table
+    // view toggle). Every other instance — the replay chart, which draws the
+    // same curve classes, and harnesses mounted without the provider — keeps
+    // component-local state. Both paths share one `[state, setState]` pair
+    // below, so the reducers, refs, and draw passes are path-agnostic.
+    const perfRulerStore = usePerfRulerStore();
+    const persistedRulers = perfRulerStore?.chartId === chartId ? perfRulerStore : undefined;
+    // Rulers only render while the mode is on (and the mode-off effect below
+    // clears them), so restored share-link rulers — pending or already
+    // committed by a previous mount — switch the mode on for this instance.
+    const [preferPerfRulerMode, setPerfRulerMode] = useState(
+      () =>
+        persistedRulers !== undefined &&
+        (persistedRulers.pending !== null || persistedRulers.state.rulers.length > 0),
+    );
     const perfRulerMode = preferPerfRulerMode && (!showPowerEnvelope || isMeasuredPowerAxis);
-    const [perfRulerState, setPerfRulerState] = useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
+    const [localPerfRulerState, setLocalPerfRulerState] =
+      useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
+    const perfRulerState = persistedRulers ? persistedRulers.state : localPerfRulerState;
+    const setPerfRulerState = persistedRulers ? persistedRulers.setState : setLocalPerfRulerState;
     // Changing the x- or y-axis metric (including the x percentile, which
     // `x_scale_field` encodes) clears every ruler: the curves are redrawn
     // in different units, so a ruler that persisted would measure a ratio
     // the user never placed. Runs before the draw pass so no stale ruler
-    // ever paints over the new curves.
+    // ever paints over the new curves. Render-time adjustment is only legal
+    // for this component's own state, so the hook targets the local state;
+    // the store applies the same reset to persisted rulers inside the
+    // provider (see usePerfRulerStoreValue).
     usePerfRulerAxisReset(
       perfRulerAxisMetricKey(chartDefinition.x_scale_field, selectedYAxisMetric),
-      setPerfRulerState,
+      setLocalPerfRulerState,
     );
     // Draw passes read mode/state through refs so toggling off clears the
     // rulers in the same pre-paint layout pass — lines/labels must never
@@ -1827,6 +2035,51 @@ const ScatterGraph = React.memo(
       [],
     );
 
+    // Share-link rulers commit only once BOTH curve paths are in the DOM —
+    // otherwise the prune pass would eat them before their data (i_gpus,
+    // comparison dates, overlay runs) has arrived. Hidden curves (opacity 0)
+    // count as present, like for prune. The iso-x is clamped to the pair's
+    // overlap through the drawn paths, so a rounded or since-shifted iso-x
+    // still renders; a pair with disjoint spans can never be measured on
+    // these axes and is dropped. This runs from the draw pass rather than a
+    // React effect: the chart first draws in a D3Chart-local re-render
+    // (dimensions are measured after mount), which re-renders nothing here,
+    // so an effect keyed on our props could miss the first draw and leave
+    // resolvable rulers pending for the rest of the session. The store is
+    // read through a ref for the same reason the draw passes read the ruler
+    // state through refs. Nothing commits while the mode is off (forced off
+    // by the power envelope, or switched off by the user) — the mode-off
+    // effect discards pending rulers, and the analytics event must not
+    // report a restore nobody saw. Draw passes can repeat before React has
+    // applied a commit, so the pending list handed over is remembered by
+    // identity and skipped until the store replaces it.
+    const persistedRulersRef = useRef(persistedRulers);
+    persistedRulersRef.current = persistedRulers;
+    const committedPendingRef = useRef<readonly PerfRulerMeasurement[] | null>(null);
+    const commitPendingPerfRulers = useCallback(
+      (zoomGroup: d3.Selection<SVGGElement, unknown, null, undefined>) => {
+        const store = persistedRulersRef.current;
+        const pending = store?.pending ?? null;
+        if (!store || !pending || !perfRulerModeRef.current) return;
+        if (committedPendingRef.current === pending) return;
+        const curveExists = (cls: string) => !zoomGroup.select(`.${CSS.escape(cls)}`).empty();
+        const resolved: PerfRulerMeasurement[] = [];
+        const remaining: PerfRulerMeasurement[] = [];
+        for (const ruler of pending) {
+          if (!curveExists(ruler.curveA) || !curveExists(ruler.curveB)) {
+            remaining.push(ruler);
+            continue;
+          }
+          const isoX = clampPerfRulerIsoXToOverlap(ruler.curveA, ruler.curveB, ruler.isoX);
+          if (isoX !== null) resolved.push({ ...ruler, isoX });
+        }
+        if (remaining.length === pending.length) return;
+        committedPendingRef.current = pending;
+        store.commitPending(resolved, remaining.length > 0 ? remaining : null);
+      },
+      [clampPerfRulerIsoXToOverlap],
+    );
+
     // Curve click (widened hit strokes): iso-x is the click's x pixel
     // through the CURRENT rendered x scale, stored in data space.
     const handlePerfRulerCurveClick = useCallback(
@@ -1855,7 +2108,7 @@ const ScatterGraph = React.memo(
       (point: InferenceData, source: 'official' | 'overlay') => {
         const ctx = perfRulerDrawCtxRef.current;
         if (!ctx) return;
-        const series = `${String(point.hwKey)}_${point.precision}`;
+        const series = scatterSeriesKey(point);
         const base =
           source === 'overlay'
             ? `overlay-roofline-${series}_run${overlayRunIndex(point.run_url ?? null, runIndexByUrl)}`
@@ -1885,8 +2138,12 @@ const ScatterGraph = React.memo(
     // the switch handler also clears synchronously, this covers
     // programmatic mode changes). `clearPerfRulers` bails out with the same
     // reference when there is nothing to clear.
+    // Share-link rulers still waiting for their curves go too — the user
+    // switched the tool off, so nothing should surface later.
     useEffect(() => {
-      if (!perfRulerMode) setPerfRulerState(clearPerfRulers);
+      if (perfRulerMode) return;
+      setPerfRulerState(clearPerfRulers);
+      persistedRulers?.discardPending();
     }, [perfRulerMode]);
 
     // Invisible widened hit strokes over every rendered roofline path
@@ -2036,6 +2293,7 @@ const ScatterGraph = React.memo(
       ) => {
         perfRulerDrawCtxRef.current = { zoomGroup, xScale, yScale, width, height };
         syncPerfRulerHitPaths(zoomGroup);
+        commitPendingPerfRulers(zoomGroup);
         const state = perfRulerStateRef.current;
         const entries: PerfRulerRenderEntry[] = [];
         if (perfRulerModeRef.current && state.rulers.length > 0) {
@@ -2089,7 +2347,7 @@ const ScatterGraph = React.memo(
         );
         if (!dragHandles.empty()) dragHandles.call(perfRulerDrag);
       },
-      [syncPerfRulerHitPaths, perfRulerDrag],
+      [syncPerfRulerHitPaths, commitPendingPerfRulers, perfRulerDrag],
     );
     drawPerfRulerRef.current = drawPerfRuler;
 
@@ -2123,16 +2381,29 @@ const ScatterGraph = React.memo(
         const svg = chartRef.current?.getSvgElement?.();
         if (!svg) return;
         const root = d3.select(svg);
+        // A comparison-series legend row highlights that boundary / role
+        // across every hardware instead of one hardware across series.
+        const variantId = hwKey.startsWith(POWER_VARIANT_LEGEND_PREFIX)
+          ? hwKey.slice(POWER_VARIANT_LEGEND_PREFIX.length)
+          : null;
+        const matchesPoint = (d: InferenceData) =>
+          variantId === null
+            ? String(d.hwKey) === hwKey
+            : powerVariantId(d.powerVariant) === variantId;
         root
           .selectAll<SVGGElement, InferenceData>('.dot-group')
           .style('opacity', (d) =>
-            isPointVisible(d) ? (String(d.hwKey) === hwKey ? 1 : 0.15) : 0,
+            isPointVisible(d) ? (matchesPoint(d) ? pointOpacityForVariant(d) : 0.15) : 0,
           );
         root
           .selectAll<SVGElement, unknown>('.roofline-path, .official-overflow-continuation')
           .style('opacity', function () {
             if (!isRooflineVisible(this)) return 0;
-            return this.dataset.hwKey === hwKey ? null : '0.15';
+            const matches =
+              variantId === null
+                ? this.dataset.hwKey === hwKey
+                : (this.dataset.powerVariant ?? '') === variantId;
+            return matches ? null : '0.15';
           });
         root
           .selectAll<SVGGElement, unknown>('.parallelism-label, .line-label')
@@ -2149,7 +2420,7 @@ const ScatterGraph = React.memo(
       const root = d3.select(svg);
       root
         .selectAll<SVGGElement, InferenceData>('.dot-group')
-        .style('opacity', (d) => (isPointVisible(d) ? 1 : 0));
+        .style('opacity', (d) => (isPointVisible(d) ? pointOpacityForVariant(d) : 0));
       root
         .selectAll<SVGElement, unknown>('.roofline-path, .official-overflow-continuation')
         .style('opacity', function () {
@@ -2162,9 +2433,16 @@ const ScatterGraph = React.memo(
             (this as SVGGElement).dataset,
             effectiveActiveHwTypes,
             selectedPrecisions,
+            activeOverlayHwTypes,
           );
         });
-    }, [isPointVisible, isRooflineVisible, effectiveActiveHwTypes, selectedPrecisions]);
+    }, [
+      isPointVisible,
+      isRooflineVisible,
+      effectiveActiveHwTypes,
+      selectedPrecisions,
+      activeOverlayHwTypes,
+    ]);
 
     // --- Zoom config ---
     const eventPrefix = chartDefinition.chartType === 'e2e' ? 'latency' : 'interactivity';
@@ -2311,10 +2589,12 @@ const ScatterGraph = React.memo(
               });
             });
           }
+          attachPowerTraceAction(tooltipEl, d, false);
         },
         attachToLayer: 1, // scatter layer is index 1 (after rooflines at 0)
       }),
       [
+        attachPowerTraceAction,
         xLabel,
         yLabel,
         selectedYAxisMetric,
@@ -2328,6 +2608,31 @@ const ScatterGraph = React.memo(
 
     // --- Layers ---
     const layers = useMemo((): LayerConfig<InferenceData>[] => {
+      // Line-label identity of one drawn series under a power comparison
+      // (`i_pcompare`): the base series keeps the hardware key, so pinned
+      // anchors and hover hooks keep working; a sibling is `<hw>::<variant>`.
+      const wattsAxis = metricPlotsWatts(selectedYAxisMetric);
+      const lineLabelIdentity = (hw: string, points: readonly InferenceData[]) => {
+        const variant = points[0]?.powerVariant;
+        const variantId = powerVariantId(variant);
+        const isBase = !variant || variantId === powerCompareBaseId;
+        return { variant, variantId, isBase, seriesId: lineLabelSeriesId(hw, variant, isBase) };
+      };
+      // A sibling's label says which series it is; a flat provisioned boundary
+      // (TDP, all-in) on a watts axis also states its value.
+      const lineLabelSuffix = (
+        identity: ReturnType<typeof lineLabelIdentity>,
+        points: readonly InferenceData[],
+      ) =>
+        powerLineLabelSuffix(identity.variant, {
+          isBase: identity.isBase,
+          locale,
+          flatWatts:
+            !identity.isBase && wattsAxis && identity.variant?.kind === 'basis'
+              ? flatSeriesValue(points.map((point) => point.y))
+              : null,
+        });
+
       // ── Layer 0: Rooflines + gradient labels (custom) ──
       const rooflineLayer: CustomLayerConfig = {
         type: 'custom',
@@ -2365,6 +2670,8 @@ const ScatterGraph = React.memo(
             key: string;
             hw: string;
             precision: string;
+            /** Comparison variant id (`i_pcompare`), '' for the base series. */
+            variant: string;
             points: InferenceData[];
             stroke: string;
             visible: boolean;
@@ -2373,10 +2680,11 @@ const ScatterGraph = React.memo(
           const activeGradientIds = new Set<string>();
 
           Object.entries(displayedRooflines).forEach(([key, pts]) => {
-            const hw = key.split('_').slice(0, -1).join('_');
-            const precision = key.split('_').pop()!;
+            const { hw, precision, variant } = parseScatterSeriesKey(key);
             const visible =
-              ir.effectiveActiveHwTypes.has(hw) && ir.selectedPrecisions.includes(precision);
+              ir.effectiveActiveHwTypes.has(hw) &&
+              ir.selectedPrecisions.includes(precision) &&
+              !ir.hiddenPowerVariants.has(variant ?? '');
             const baseStroke = ir.getCssColor(ir.resolveColor(hw));
 
             // Split into per-date sub-paths so the line never crosses dates.
@@ -2421,6 +2729,7 @@ const ScatterGraph = React.memo(
                 key: entryKey,
                 hw,
                 precision,
+                variant: variant ?? '',
                 points: datePoints,
                 stroke,
                 visible,
@@ -2448,9 +2757,12 @@ const ScatterGraph = React.memo(
             .attr('data-curve-kind', showPowerEnvelope ? 'power-envelope' : 'pareto')
             .attr('data-hw-key', (d) => d.hw)
             .attr('data-precision', (d) => d.precision)
+            .attr('data-power-variant', (d) => d.variant || null)
             .attr('fill', 'none')
             .attr('stroke', (d) => d.stroke)
             .attr('stroke-width', 2.5)
+            // Comparison siblings share the hardware colour; the dash tells them apart.
+            .attr('stroke-dasharray', (d) => powerVariantDashById(d.variant) || null)
             .attr('d', (d) => lineGen(d.points))
             .style('transition', 'opacity 150ms ease')
             .style('opacity', (d) => (d.visible ? 1 : 0));
@@ -2471,10 +2783,11 @@ const ScatterGraph = React.memo(
           if (showGradientLabels) {
             Object.entries(allPointLabelsByKey).forEach(([key, pointLabels]) => {
               if (pointLabels.length < 2) return;
-              const hw = key.split('_').slice(0, -1).join('_');
-              const precision = key.split('_').pop()!;
+              const { hw, precision, variant } = parseScatterSeriesKey(key);
               const visible =
-                ir.effectiveActiveHwTypes.has(hw) && ir.selectedPrecisions.includes(precision);
+                ir.effectiveActiveHwTypes.has(hw) &&
+                ir.selectedPrecisions.includes(precision) &&
+                !ir.hiddenPowerVariants.has(variant ?? '');
 
               const segments: { label: string; color: string; points: InferenceData[] }[] = [];
               let cur = {
@@ -2572,12 +2885,22 @@ const ScatterGraph = React.memo(
 
           // ── Line labels (run name along each roofline) ──
           let lineLabels: LineLabelPlacement[] = [];
+          // Comparison variant and label suffix per label key, for the text
+          // segments and the `data-power-variant` hook on each pill.
+          const lineLabelMeta = new Map<
+            string,
+            { variantId: string; suffix: string; runTag: string }
+          >();
           if (showLineLabels) {
             const multiPrecision = ir.selectedPrecisions.length > 1;
             const officialByGroup = new Map<string, (typeof entries)[number]>();
             for (const entry of entries) {
               if (!entry.visible) continue;
-              const groupKey = multiPrecision ? entry.key : entry.hw;
+              // One label per hardware and, under a power comparison, per
+              // sibling series: the measured line and its boundary / pool
+              // lines each say which one they are, instead of the longest
+              // line taking the hardware's only label.
+              const groupKey = multiPrecision ? entry.key : `${entry.hw}::${entry.variant}`;
               const previous = officialByGroup.get(groupKey);
               if (!previous || entry.points.length > previous.points.length) {
                 officialByGroup.set(groupKey, entry);
@@ -2586,39 +2909,59 @@ const ScatterGraph = React.memo(
 
             const officialSeries: LineLabelSeries<InferenceData>[] = [
               ...officialByGroup.values(),
-            ].map((entry) => ({
-              key: entry.key,
-              seriesId: entry.hw,
-              label: lineLabelText(
-                entry.hw,
-                entry.precision,
-                multiPrecision,
-                modelLabel,
-                entry.points,
-              ),
-              color: ir.getCssColor(ir.resolveColor(entry.hw)),
-              points: entry.points,
-              keepVisibleOnCollision: entry.points.length === 1,
-            }));
+            ].map((entry) => {
+              const identity = lineLabelIdentity(entry.hw, entry.points);
+              const suffix = lineLabelSuffix(identity, entry.points);
+              lineLabelMeta.set(entry.key, { variantId: identity.variantId, suffix, runTag: '' });
+              return {
+                key: entry.key,
+                seriesId: identity.seriesId,
+                label: `${lineLabelText(
+                  entry.hw,
+                  entry.precision,
+                  multiPrecision,
+                  modelLabel,
+                  entry.points,
+                )}${suffix}`,
+                color: ir.getCssColor(ir.resolveColor(entry.hw)),
+                points: entry.points,
+                keepVisibleOnCollision: entry.points.length === 1,
+              };
+            });
+            // Runs drawing the same hardware need a run tag on their pills.
+            const overlayRunsByHw = new Map<string, Set<number>>();
+            for (const group of Object.values(displayedOverlayRooflines)) {
+              if (!ir.activeOverlayHwTypes.has(group.hwKey)) continue;
+              if (!overlayRunsByHw.has(group.hwKey)) overlayRunsByHw.set(group.hwKey, new Set());
+              overlayRunsByHw.get(group.hwKey)!.add(group.runIndex);
+            }
             const overlaySeries: LineLabelSeries<InferenceData>[] = Object.entries(
               displayedOverlayRooflines,
             ).flatMap(([overlayKey, group]) => {
               if (!ir.activeOverlayHwTypes.has(group.hwKey)) return [];
               const info = unofficialRunInfos[group.runIndex];
               const precision = group.points[0]?.precision ?? '';
-              const runLabel = info
-                ? getInferenceRunLabel(`✕ ${info.branch || `run ${info.id}`}`, group.points)
-                : '';
+              const hardwareLabel = lineLabelText(
+                group.hwKey,
+                precision,
+                multiPrecision,
+                modelLabel,
+                group.points,
+              );
+              const sharesHardware = (overlayRunsByHw.get(group.hwKey)?.size ?? 0) > 1;
+              const runTag = info && sharesHardware ? overlayRunTag(info) : '';
               const label = info
-                ? multiPrecision
-                  ? `${runLabel} ${getPrecisionLabel(precision as Precision)}`
-                  : runLabel
-                : lineLabelText(group.hwKey, precision, multiPrecision, modelLabel, group.points);
+                ? getOverlayLineLabel(hardwareLabel, info, sharesHardware)
+                : hardwareLabel;
+              const identity = lineLabelIdentity(group.hwKey, group.points);
+              const suffix = lineLabelSuffix(identity, group.points);
+              const key = `overlay-${overlayKey}`;
+              lineLabelMeta.set(key, { variantId: identity.variantId, suffix, runTag });
               return [
                 {
-                  key: `overlay-${overlayKey}`,
-                  seriesId: group.hwKey,
-                  label,
+                  key,
+                  seriesId: identity.seriesId,
+                  label: `${label}${suffix}`,
                   color: overlayRunColor(group.runIndex),
                   points: group.points,
                 },
@@ -2641,16 +2984,19 @@ const ScatterGraph = React.memo(
             const labeledKeys = new Set(lineLabels.map((label) => label.key));
             for (const entry of entries) {
               if (labeledKeys.has(entry.key)) continue;
+              const identity = lineLabelIdentity(entry.hw, entry.points);
+              const suffix = lineLabelSuffix(identity, entry.points);
+              lineLabelMeta.set(entry.key, { variantId: identity.variantId, suffix, runTag: '' });
               lineLabels.push({
                 key: entry.key,
-                seriesId: entry.hw,
-                label: lineLabelText(
+                seriesId: identity.seriesId,
+                label: `${lineLabelText(
                   entry.hw,
                   entry.precision,
                   multiPrecision,
                   modelLabel,
                   entry.points,
-                ),
+                )}${suffix}`,
                 color: ir.getCssColor(ir.resolveColor(entry.hw)),
                 x: xScale(entry.points[0].x),
                 y: yScale(entry.points[0].y),
@@ -2667,20 +3013,35 @@ const ScatterGraph = React.memo(
           }
 
           renderLineLabels(zoomGroup, lineLabels, {
-            seriesAttribute: 'data-hw-key',
-            iconFor: (label) => getLineLabelVendorIcon(label.seriesId),
+            seriesAttribute: 'data-series-id',
+            iconFor: (label) => getLineLabelVendorIcon(lineLabelHardwareKey(label.seriesId)),
             configureGroup: (labelGroup, label) => {
               labelGroup
                 .attr('data-visible', label.visible ? '1' : '0')
+                // Legend hover and filter sync key labels by hardware alone;
+                // the variant names the comparison sibling ('' for the base).
+                .attr('data-hw-key', lineLabelHardwareKey(label.seriesId))
+                .attr('data-power-variant', lineLabelMeta.get(label.key)?.variantId ?? '')
                 .select('.ll-bg')
                 .attr('opacity', 0.95);
             },
             configureText: (text, label) => {
-              const config = getHardwareConfig(label.seriesId, modelLabel);
+              const config = getHardwareConfig(lineLabelHardwareKey(label.seriesId), modelLabel);
+              // Parse the hardware part without the variant suffix, which gets
+              // its own segment so the engine is still matched at the end.
+              const meta = lineLabelMeta.get(label.key);
+              const suffix = meta?.suffix ?? '';
+              const runTag = meta?.runTag ?? '';
+              let coreLabel = suffix ? label.label.slice(0, -suffix.length) : label.label;
+              if (runTag) coreLabel = coreLabel.slice(0, -runTag.length);
+              // Overlay pills lead with the run marker; the hardware behind it is
+              // parsed like an official pill so the GPU name stays bold.
+              const marker = coreLabel.startsWith(OVERLAY_LABEL_MARKER) ? OVERLAY_LABEL_MARKER : '';
+              coreLabel = coreLabel.slice(marker.length);
               const hardwareLabel = getDisplayLabel(config);
               const isHardwareLabel =
-                label.label === hardwareLabel || label.label.startsWith(`${config.label} `);
-              const remainingLabel = isHardwareLabel ? label.label.slice(config.label.length) : '';
+                coreLabel === hardwareLabel || coreLabel.startsWith(`${config.label} `);
+              const remainingLabel = isHardwareLabel ? coreLabel.slice(config.label.length) : '';
               // Use this curve's resolved suffix, not the generic hwKey label:
               // official and overlay curves can share a key but differ by run.
               const engineLabel =
@@ -2690,8 +3051,18 @@ const ScatterGraph = React.memo(
                 engineLabel && remainingLabel.endsWith(engineLabel)
                   ? remainingLabel.slice(0, -engineLabel.length)
                   : remainingLabel;
+              const markerSegments = marker
+                ? [{ className: 'll-marker', text: marker, fill: 'white', weight: '600' }]
+                : [];
+              const runSegments = runTag
+                ? [{ className: 'll-run', text: runTag, fill: '#d1d5db', weight: '400' }]
+                : [];
+              const variantSegments = suffix
+                ? [{ className: 'll-variant', text: suffix, fill: 'white', weight: '500' }]
+                : [];
               const segments = isHardwareLabel
                 ? [
+                    ...markerSegments,
                     { className: 'll-gpu', text: config.label, fill: 'white', weight: '700' },
                     ...(precisionLabel
                       ? [
@@ -2713,14 +3084,19 @@ const ScatterGraph = React.memo(
                           },
                         ]
                       : []),
+                    ...runSegments,
+                    ...variantSegments,
                   ]
                 : [
+                    ...markerSegments,
                     {
                       className: 'll-plain',
-                      text: label.label,
+                      text: coreLabel,
                       fill: 'white',
                       weight: '600',
                     },
+                    ...runSegments,
+                    ...variantSegments,
                   ];
               text
                 .selectAll<SVGTSpanElement, (typeof segments)[number]>('tspan')
@@ -2829,11 +3205,11 @@ const ScatterGraph = React.memo(
               { key: string; seriesId: string; points: InferenceData[] }
             >();
             for (const [key, points] of Object.entries(displayedRooflines)) {
-              const hardware = key.split('_').slice(0, -1).join('_');
-              const precision = key.split('_').pop()!;
+              const { hw: hardware, precision, variant } = parseScatterSeriesKey(key);
               if (
                 !ir.effectiveActiveHwTypes.has(hardware) ||
-                !ir.selectedPrecisions.includes(precision)
+                !ir.selectedPrecisions.includes(precision) ||
+                ir.hiddenPowerVariants.has(variant ?? '')
               ) {
                 continue;
               }
@@ -2841,12 +3217,12 @@ const ScatterGraph = React.memo(
               const singleDate = pointsByDate.size === 1;
               for (const [date, datePoints] of pointsByDate) {
                 const entryKey = singleDate ? key : `${key}__${encodeURIComponent(date)}`;
-                const groupKey = multiPrecision ? entryKey : hardware;
+                const groupKey = multiPrecision ? entryKey : `${hardware}::${variant ?? ''}`;
                 const previous = bestByGroup.get(groupKey);
                 if (!previous || datePoints.length > previous.points.length) {
                   bestByGroup.set(groupKey, {
                     key: entryKey,
-                    seriesId: hardware,
+                    seriesId: lineLabelIdentity(hardware, datePoints).seriesId,
                     points: datePoints,
                   });
                 }
@@ -2867,7 +3243,7 @@ const ScatterGraph = React.memo(
                 ? [
                     {
                       key: `overlay-${overlayKey}`,
-                      seriesId: group.hwKey,
+                      seriesId: lineLabelIdentity(group.hwKey, group.points).seriesId,
                       label: '',
                       color: '',
                       points: group.points,
@@ -2901,7 +3277,8 @@ const ScatterGraph = React.memo(
             interactionRef.current.getCssColor(
               interactionRef.current.resolveColor(d.hwKey as string),
             ),
-          getOpacity: (d) => (interactionRef.current.isPointVisible(d) ? 1 : 0),
+          getOpacity: (d) =>
+            interactionRef.current.isPointVisible(d) ? pointOpacityForVariant(d) : 0,
           getPointerEvents: (d) => (interactionRef.current.isPointVisible(d) ? 'auto' : 'none'),
           hideLabels: !showPointLabels || showGradientLabels,
           // Concurrency (C=) is appended only when the advanced
@@ -2911,6 +3288,7 @@ const ScatterGraph = React.memo(
           dataAttrs: {
             'hw-key': (d) => String(d.hwKey),
             precision: (d) => d.precision,
+            'power-variant': (d) => d.powerVariant?.id ?? '',
             // Lets the agentic coach mark pick an anchor out of the DOM
             // without knowing anything about React state.
             'benchmark-type': (d) => d.benchmark_type ?? '',
@@ -2989,6 +3367,7 @@ const ScatterGraph = React.memo(
                 points: InferenceData[];
                 stroke: string;
                 runIndex: number;
+                variant: string | null;
               }
               const ovEntries: OvEntry[] = [];
               Object.entries(displayedOverlayRooflines).forEach(([key, group]) => {
@@ -3000,6 +3379,7 @@ const ScatterGraph = React.memo(
                     // Color by run — same palette entry the legend uses, so they match.
                     stroke: overlayRunColor(group.runIndex),
                     runIndex: group.runIndex,
+                    variant: group.variant,
                   });
                 }
               });
@@ -3017,9 +3397,21 @@ const ScatterGraph = React.memo(
                 .attr('fill', 'none')
                 .attr('stroke', (d) => d.stroke)
                 .attr('stroke-width', 2)
-                .attr('stroke-dasharray', (d) => overlayRooflineDasharray(d.runIndex))
+                .attr('data-power-variant', (d) => d.variant)
+                // The run keeps its colour; a comparison sibling takes the
+                // variant dash so it reads like its official counterpart.
+                .attr('stroke-dasharray', (d) =>
+                  d.variant
+                    ? powerVariantDashById(d.variant)
+                    : overlayRooflineDasharray(d.runIndex),
+                )
                 .attr('d', (d) => lineGen(d.points))
-                .style('filter', null);
+                .style('filter', null)
+                // Comparison rows hidden from the legend (the decoration effect
+                // keeps this in step with later toggles).
+                .style('opacity', (d) =>
+                  interactionRef.current.hiddenPowerVariants.has(d.variant ?? '') ? 0 : null,
+                );
 
               // Overlay X-shape points — index-keyed so every point renders
               const overlayPoints = zoomGroup
@@ -3055,7 +3447,7 @@ const ScatterGraph = React.memo(
               overlayPoints.each(function (d) {
                 const visible = interactionRef.current.isOverlayPointVisible(d);
                 d3.select(this)
-                  .style('opacity', visible ? 1 : 0)
+                  .style('opacity', visible ? pointOpacityForVariant(d) : 0)
                   .style('pointer-events', visible ? 'auto' : 'none');
               });
               overlayPoints
@@ -3139,6 +3531,9 @@ const ScatterGraph = React.memo(
                     y: point.y,
                     overlay: true,
                   });
+                  // The shared helper has just rendered the pinned content into
+                  // this element and pinned it via `handle`.
+                  attachPowerTraceAction(ctx.tooltipElement, point, true);
                 },
               });
             },
@@ -3409,10 +3804,12 @@ const ScatterGraph = React.memo(
       xLabel,
       yLabel,
       selectedYAxisMetric,
+      powerCompareBaseId,
       isMeasuredEnergyAxis,
       chartDefinition,
       locale,
       drawPerfRuler,
+      attachPowerTraceAction,
     ]);
 
     // Layers handle for the decoration effect — lets it re-run individual
@@ -3491,7 +3888,9 @@ const ScatterGraph = React.memo(
       zoomGroup.selectAll<SVGGElement, InferenceData>('.dot-group').each(function (d) {
         const point = d3.select(this);
         const visible = ir.isPointVisible(d);
-        point.style('opacity', visible ? 1 : 0).style('pointer-events', visible ? 'auto' : 'none');
+        point
+          .style('opacity', visible ? pointOpacityForVariant(d) : 0)
+          .style('pointer-events', visible ? 'auto' : 'none');
         const color =
           (showGradientLabels && gradientColorByPoint.get(d)) ||
           ir.getCssColor(ir.resolveColor(d.hwKey as string));
@@ -3511,9 +3910,20 @@ const ScatterGraph = React.memo(
       zoomGroup.selectAll<SVGGElement, InferenceData>('.unofficial-overlay-pt').each(function (d) {
         const visible = ir.isOverlayPointVisible(d);
         d3.select(this)
-          .style('opacity', visible ? 1 : 0)
+          .style('opacity', visible ? pointOpacityForVariant(d) : 0)
           .style('pointer-events', visible ? 'auto' : 'none');
       });
+      // Overlay rooflines are only drawn for active overlay hardware; a
+      // comparison row hidden from the legend is the one visibility toggle
+      // they answer to here.
+      zoomGroup.selectAll<SVGPathElement, unknown>('.overlay-roofline-path').each(function () {
+        const roofline = d3.select(this);
+        if (ir.hiddenPowerVariants.has(this.dataset.powerVariant ?? '')) {
+          roofline.style('opacity', 0);
+        } else {
+          roofline.style('opacity', null);
+        }
+      });
 
       // Rooflines: visibility and solid-stroke recolor as direct writes. Keep
       // gradient url references intact and never touch animated path geometry.
@@ -3523,7 +3933,9 @@ const ScatterGraph = React.memo(
         if (!hw || !precision) return;
         const roofline = d3.select(this);
         const visible =
-          ir.effectiveActiveHwTypes.has(hw) && ir.selectedPrecisions.includes(precision);
+          ir.effectiveActiveHwTypes.has(hw) &&
+          ir.selectedPrecisions.includes(precision) &&
+          !ir.hiddenPowerVariants.has(this.dataset.powerVariant ?? '');
         roofline.style('opacity', visible ? 1 : 0);
         const stroke = roofline.attr('stroke');
         if (stroke && !stroke.startsWith('url(')) {
@@ -3557,6 +3969,7 @@ const ScatterGraph = React.memo(
             (this as SVGGElement).dataset,
             ir.effectiveActiveHwTypes,
             ir.selectedPrecisions,
+            ir.activeOverlayHwTypes,
           );
         });
     }, [
@@ -3715,7 +4128,9 @@ const ScatterGraph = React.memo(
       // brings a hidden ruler back); curves whose paths left the DOM
       // entirely are truly gone from the data, so prune each ruler (and the
       // draft) that references one. `prunePerfRulers` bails out with the
-      // same reference when nothing changed.
+      // same reference when nothing changed. Share-link rulers still
+      // pending are not state yet, so prune cannot touch them; drawPerfRuler
+      // above committed those whose curves now exist.
       setPerfRulerState((prev) =>
         prunePerfRulers(prev, (cls) => !display.zoomGroup.select(`.${CSS.escape(cls)}`).empty()),
       );
@@ -3977,6 +4392,9 @@ const ScatterGraph = React.memo(
                         )
                       : null,
                   })),
+                // Comparison series (`i_pcompare`): one dash-swatch row per
+                // boundary / role, toggling that series across every hardware.
+                ...powerVariantLegendItems,
               ]}
               disableActiveSort={false}
               isLegendExpanded={isLegendExpanded}
@@ -4141,7 +4559,10 @@ const ScatterGraph = React.memo(
                           // the pre-paint decoration effect then removes the rulers
                           // and the curve hit strokes before the next frame (no
                           // lingering lines after toggle-off).
-                          if (!checked) setPerfRulerState(clearPerfRulers);
+                          if (!checked) {
+                            setPerfRulerState(clearPerfRulers);
+                            persistedRulers?.discardPending();
+                          }
                           track('latency_perf_ruler_toggled', { enabled: checked });
                         },
                       },
@@ -4189,6 +4610,7 @@ const ScatterGraph = React.memo(
                             count: perfRulerState.rulers.length,
                           });
                           setPerfRulerState(clearPerfRulers);
+                          persistedRulers?.discardPending();
                         },
                       },
                     ]
diff --git a/packages/app/src/components/inference/ui/line-label-visibility.test.ts b/packages/app/src/components/inference/ui/line-label-visibility.test.ts
index 80e17b049..dab9546f6 100644
--- a/packages/app/src/components/inference/ui/line-label-visibility.test.ts
+++ b/packages/app/src/components/inference/ui/line-label-visibility.test.ts
@@ -53,6 +53,64 @@ describe('labelOpacityForActiveState', () => {
   });
 });
 
+describe('labelOpacityForActiveState with ?unofficialrun= overlays', () => {
+  const official = new Set(['gb200_dynamo-sglang']);
+  const overlay = new Set(['gb200_dynamo-sglang', 'gb300_dynamo-sglang']);
+  const precisions = ['fp8'];
+
+  it('keeps an overlay label whose hardware is active only in the overlay legend', () => {
+    expect(
+      labelOpacityForActiveState(
+        {
+          hwKey: 'gb300_dynamo-sglang',
+          lineKey: 'overlay-gb300_dynamo-sglang_fp8_run0',
+          visible: '1',
+        },
+        official,
+        precisions,
+        overlay,
+      ),
+    ).toBe(1);
+  });
+
+  it('hides an overlay label when its overlay hardware row is off, even if the official row is on', () => {
+    expect(
+      labelOpacityForActiveState(
+        {
+          hwKey: 'gb200_dynamo-sglang',
+          lineKey: 'overlay-gb200_dynamo-sglang_fp8_run1',
+          visible: '1',
+        },
+        official,
+        precisions,
+        new Set(['gb300_dynamo-sglang']),
+      ),
+    ).toBe(0);
+  });
+
+  it('leaves official labels on the official set and falls back to it without an overlay set', () => {
+    expect(
+      labelOpacityForActiveState(
+        { hwKey: 'gb300_dynamo-sglang', lineKey: 'gb300_dynamo-sglang_fp8', visible: '1' },
+        official,
+        precisions,
+        overlay,
+      ),
+    ).toBe(0);
+    expect(
+      labelOpacityForActiveState(
+        {
+          hwKey: 'gb300_dynamo-sglang',
+          lineKey: 'overlay-gb300_dynamo-sglang_fp8_run0',
+          visible: '1',
+        },
+        official,
+        precisions,
+      ),
+    ).toBe(0);
+  });
+});
+
 describe('labelOpacityForHover', () => {
   it('lights up the kept label for the hovered hardware', () => {
     expect(labelOpacityForHover({ hwKey: 'b300_sglang', visible: '1' }, 'b300_sglang')).toBe(1);
diff --git a/packages/app/src/components/inference/ui/line-label-visibility.ts b/packages/app/src/components/inference/ui/line-label-visibility.ts
index a8b34b810..9dfa8e878 100644
--- a/packages/app/src/components/inference/ui/line-label-visibility.ts
+++ b/packages/app/src/components/inference/ui/line-label-visibility.ts
@@ -25,6 +25,8 @@
 export interface LabelAttrs {
   /** `data-hw-key` — base hardware key, shared across a hw's curves. */
   hwKey?: string;
+  /** `data-line-key` — `overlay-…` marks an unofficial-run curve's label. */
+  lineKey?: string;
   /** `data-precision` — set on parallelism labels, absent on line labels. */
   precision?: string;
   /** `data-visible` — `'1'`/`'0'`; only line labels set this. */
@@ -50,16 +52,24 @@ export const labelOpacityForHover = (attrs: LabelAttrs, hoveredHwKey: string): 0
  * filter-change sync effect. Line labels (no precision) show when their
  * hardware is active **and** the render kept them; parallelism labels show when
  * their hardware is active and their precision is selected.
+ *
+ * An `?unofficialrun=` overlay curve answers to the overlay legend rows, not
+ * the official ones: its label follows `activeOverlayHwTypes`, so soloing an
+ * official hardware no longer hides the overlay pills of every other hardware
+ * (and hiding an official row keeps its overlay twin labelled).
  */
 export const labelOpacityForActiveState = (
   attrs: LabelAttrs,
   activeHwTypes: ReadonlySet<string>,
   selectedPrecisions: readonly string[],
+  activeOverlayHwTypes?: ReadonlySet<string>,
 ): 0 | 1 => {
   const { hwKey, precision } = attrs;
   if (!hwKey) return 0;
+  const isOverlay = attrs.lineKey?.startsWith('overlay-') ?? false;
+  const active = isOverlay && activeOverlayHwTypes ? activeOverlayHwTypes : activeHwTypes;
   if (!precision) {
-    return activeHwTypes.has(hwKey) && renderKept(attrs) ? 1 : 0;
+    return active.has(hwKey) && renderKept(attrs) ? 1 : 0;
   }
-  return activeHwTypes.has(hwKey) && selectedPrecisions.includes(precision) ? 1 : 0;
+  return active.has(hwKey) && selectedPrecisions.includes(precision) ? 1 : 0;
 };
diff --git a/packages/app/src/components/inference/utils.ts b/packages/app/src/components/inference/utils.ts
index 5284aac3b..1794cd585 100644
--- a/packages/app/src/components/inference/utils.ts
+++ b/packages/app/src/components/inference/utils.ts
@@ -8,8 +8,15 @@ import { getGpuSpecs, type TcoBasis } from '@/lib/constants';
 import chartDefinitions from '@/components/inference/metric-registry';
 import { resolveXAxisField } from '@/components/inference/utils/resolveXAxisField';
 import { remapInferencePoint } from '@/lib/chart-utils';
+import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
 
-import type { ChartDefinition, ClippedInferenceData, InferenceData, YAxisMetricKey } from './types';
+import type {
+  ChartDefinition,
+  ClippedInferenceData,
+  InferenceData,
+  PowerCompare,
+  YAxisMetricKey,
+} from './types';
 import type { XAxisMode } from './hooks/useChartData';
 
 /**
@@ -145,6 +152,7 @@ export function processOverlayChartData(
     selectedXAxisMode?: XAxisMode;
     restrictToNormalizedFrontier?: boolean;
     tcoBasis?: TcoBasis;
+    powerCompare?: PowerCompare;
   },
 ): InferenceData[] {
   return processOverlayChartDataWithClipping(
@@ -171,6 +179,8 @@ export function processOverlayChartDataWithClipping(
     selectedXAxisMode?: XAxisMode;
     restrictToNormalizedFrontier?: boolean;
     tcoBasis?: TcoBasis;
+    /** Sibling boundary / role series, mirroring the official path in useChartData. */
+    powerCompare?: PowerCompare;
   },
 ): ProcessedChartData {
   const chartDef = (chartDefinitions as ChartDefinition[]).find((d) => d.chartType === chartType);
@@ -222,9 +232,13 @@ export function processOverlayChartDataWithClipping(
   // for the natural axis and for agentic (long TTFTs are normal there).
   const isTtftX = xAxisField.endsWith('_ttft');
 
-  const processedData = sourceData
-    .filter((d) => metricKey in d)
-    .map((d) => remapInferencePoint(d, metricKey, xAxisField));
+  const processedData = expandPowerCompareSeries(
+    sourceData
+      .filter((d) => metricKey in d)
+      .map((d) => remapInferencePoint(d, metricKey, xAxisField)),
+    selectedYAxisMetric,
+    options?.powerCompare ?? 'none',
+  );
 
   // The normalized metric is derived from persisted request traces, which an
   // unofficial overlay does not have. An all-false canonical stamp prevents a
diff --git a/packages/app/src/components/inference/utils/best-series-per-sku.ts b/packages/app/src/components/inference/utils/best-series-per-sku.ts
index 6799b9631..2a35f0b9c 100644
--- a/packages/app/src/components/inference/utils/best-series-per-sku.ts
+++ b/packages/app/src/components/inference/utils/best-series-per-sku.ts
@@ -40,7 +40,9 @@ export function bestSeriesPerSku(points: InferenceData[], direction: Direction):
   const bySku = new Map<string, Map<string, InferenceData[]>>();
   const featured = new Set<string>();
   for (const point of points) {
-    if (!isFrontierEligible(point) || !Number.isFinite(point.y)) continue;
+    // Comparison clones re-plot the same configs at another boundary or role;
+    // the best series per SKU is judged on the selected metric alone.
+    if (point.powerVariant || !isFrontierEligible(point) || !Number.isFinite(point.y)) continue;
     const sku = baseSku(point);
     const key = String(point.hwKey);
     if (point.framework === 'tilert') featured.add(key);
diff --git a/packages/app/src/components/inference/utils/point-identity.test.ts b/packages/app/src/components/inference/utils/point-identity.test.ts
index 26d71f322..a53326170 100644
--- a/packages/app/src/components/inference/utils/point-identity.test.ts
+++ b/packages/app/src/components/inference/utils/point-identity.test.ts
@@ -2,7 +2,12 @@ import { describe, expect, it } from 'vitest';
 
 import type { InferenceData } from '@/components/inference/types';
 
-import { scatterPointConfigId, scatterPointJoinId } from './point-identity';
+import {
+  parseScatterSeriesKey,
+  scatterPointConfigId,
+  scatterPointJoinId,
+  scatterSeriesKey,
+} from './point-identity';
 
 const point = (overrides: Partial<InferenceData>): InferenceData =>
   ({
@@ -85,3 +90,26 @@ describe('scatterPointConfigId', () => {
     expect(scatterPointJoinId(undated, true)).toBe(scatterPointConfigId(undated));
   });
 });
+
+describe('scatterSeriesKey', () => {
+  it('keeps comparison clones in their own series and parses the key back', () => {
+    const base = point({});
+    const clone = point({ powerVariant: { kind: 'basis', id: 'gpu-provisioned' } });
+    expect(scatterSeriesKey(base)).toBe('h200_vllm_fp8');
+    expect(scatterSeriesKey(clone)).toBe('h200_vllm_fp8-v-gpu-provisioned');
+    expect(parseScatterSeriesKey('h200_vllm_fp8')).toEqual({
+      hw: 'h200_vllm',
+      precision: 'fp8',
+      variant: null,
+    });
+    expect(parseScatterSeriesKey('b200_sglang_mtp_fp4-v-utility-modeled')).toEqual({
+      hw: 'b200_sglang_mtp',
+      precision: 'fp4',
+      variant: 'utility-modeled',
+    });
+    // The variant is point identity too, so a clone never replaces its base in a D3 join.
+    expect(scatterPointConfigId(clone)).toBe(
+      `${scatterPointConfigId(base)}|variant-gpu-provisioned`,
+    );
+  });
+});
diff --git a/packages/app/src/components/inference/utils/point-identity.ts b/packages/app/src/components/inference/utils/point-identity.ts
index 2c975593e..0cc8bbed8 100644
--- a/packages/app/src/components/inference/utils/point-identity.ts
+++ b/packages/app/src/components/inference/utils/point-identity.ts
@@ -23,9 +23,47 @@ export function scatterPointConfigId(point: InferenceData): string {
   // Agentic series omit spec decoding from hwKey so one curve can mix methods.
   // It remains point identity to avoid collapsing overlapping MTP/STP results.
   key += agenticSpecDecodingKeySuffix(point);
+  // Comparison clones share every config field with their base point.
+  if (point.powerVariant) key += `|variant-${point.powerVariant.id}`;
   return key;
 }
 
+/**
+ * Comparison-series suffix inside a scatter series key. Letters, digits and
+ * dashes only, so the key stays a valid CSS class token (the perf ruler and
+ * `i_rulers` address rooflines by class) and needs no escaping.
+ */
+const SERIES_VARIANT_DELIMITER = '-v-';
+
+/**
+ * Identity of one drawn series: hardware key, precision and, on a power
+ * comparison, the boundary or role variant. Rooflines, frontiers, line labels
+ * and the perf ruler all key on this string.
+ */
+export function scatterSeriesKey(
+  point: Pick<InferenceData, 'hwKey' | 'precision' | 'powerVariant'>,
+): string {
+  const base = `${point.hwKey}_${point.precision}`;
+  return point.powerVariant ? `${base}${SERIES_VARIANT_DELIMITER}${point.powerVariant.id}` : base;
+}
+
+export interface ScatterSeriesIdentity {
+  hw: string;
+  precision: string;
+  /** Comparison variant id (`gpu-provisioned`, `prefill`, …) or null for the base series. */
+  variant: string | null;
+}
+
+/** Inverse of `scatterSeriesKey`; hardware keys may themselves contain underscores. */
+export function parseScatterSeriesKey(key: string): ScatterSeriesIdentity {
+  const delimiter = key.indexOf(SERIES_VARIANT_DELIMITER);
+  const core = delimiter === -1 ? key : key.slice(0, delimiter);
+  const variant = delimiter === -1 ? null : key.slice(delimiter + SERIES_VARIANT_DELIMITER.length);
+  const parts = core.split('_');
+  const precision = parts.pop() ?? '';
+  return { hw: parts.join('_'), precision, variant };
+}
+
 /**
  * Stable D3 join key for an official scatter point.
  *
diff --git a/packages/app/src/components/inference/utils/power-compare.test.ts b/packages/app/src/components/inference/utils/power-compare.test.ts
new file mode 100644
index 000000000..6b7c76153
--- /dev/null
+++ b/packages/app/src/components/inference/utils/power-compare.test.ts
@@ -0,0 +1,295 @@
+import { describe, expect, it } from 'vitest';
+
+import type {
+  InferenceData,
+  PowerBasis,
+  PowerRole,
+  PowerVariant,
+} from '@/components/inference/types';
+
+import {
+  expandPowerCompareSeries,
+  flatSeriesValue,
+  formatWatts,
+  inferPowerCompare,
+  lineLabelHardwareKey,
+  lineLabelSeriesId,
+  metricPlotsWatts,
+  parsePowerCompare,
+  powerCompareAvailable,
+  powerCompareBase,
+  powerCompareVariants,
+  powerLineLabel,
+  powerLineLabelSuffix,
+  powerSeriesLabel,
+  powerVariantDash,
+  powerVariantLabel,
+  powerVariantShortLabel,
+  powerVariantsInData,
+} from './power-compare';
+
+const metric = (y: number) => ({ y, roof: false });
+
+function point(overrides: Partial<InferenceData> = {}): InferenceData {
+  return {
+    x: 50,
+    y: 600,
+    hwKey: 'b200_sglang',
+    precision: 'fp8',
+    tp: 8,
+    conc: 64,
+    disagg: true,
+    measuredAvgPower: metric(600),
+    measuredPrefillAvgPower: metric(400),
+    measuredDecodeAvgPower: metric(700),
+    gpuProvisionedWatts: metric(1000),
+    utilityProvisionedWatts: metric(1710),
+    measuredJPerOutputToken: metric(7.9),
+    measuredDecodeJPerOutputToken: metric(6),
+    reconstructedPrefillJPerOutputToken: metric(1.975),
+    gpuProvisionedJPerOutputToken: metric(12),
+    ...overrides,
+  } as InferenceData;
+}
+
+describe('powerCompareVariants', () => {
+  it('adds the other three boundaries on the whole-deployment average watts and J per output token', () => {
+    expect(powerCompareVariants('y_measuredAvgPower', 'boundaries')).toEqual([
+      { variant: { kind: 'basis', id: 'gpu-provisioned' }, field: 'gpuProvisionedWatts' },
+      { variant: { kind: 'basis', id: 'utility-provisioned' }, field: 'utilityProvisionedWatts' },
+      { variant: { kind: 'basis', id: 'utility-modeled' }, field: 'utilityModeledWatts' },
+    ]);
+    // Selecting a derived boundary makes GPU measured one of the siblings.
+    expect(
+      powerCompareVariants('y_utilityProvisionedJPerOutputToken', 'boundaries').map(
+        (series) => series.field,
+      ),
+    ).toEqual([
+      'measuredJPerOutputToken',
+      'gpuProvisionedJPerOutputToken',
+      'utilityModeledJPerOutputToken',
+    ]);
+    expect(powerCompareBase('y_gpuProvisionedWatts', 'boundaries')).toEqual({
+      kind: 'basis',
+      id: 'gpu-provisioned',
+    });
+  });
+
+  it('adds the other worker roles, carrying prefill energy onto the output-token axis', () => {
+    expect(powerCompareVariants('y_measuredAvgPower', 'roles')).toEqual([
+      { variant: { kind: 'role', id: 'prefill' }, field: 'measuredPrefillAvgPower' },
+      { variant: { kind: 'role', id: 'decode' }, field: 'measuredDecodeAvgPower' },
+    ]);
+    expect(powerCompareVariants('y_measuredDecodeAvgPower', 'roles')).toEqual([
+      { variant: { kind: 'role', id: 'all' }, field: 'measuredAvgPower' },
+      { variant: { kind: 'role', id: 'prefill' }, field: 'measuredPrefillAvgPower' },
+    ]);
+    expect(powerCompareVariants('y_measuredJPerOutputToken', 'roles')).toEqual([
+      { variant: { kind: 'role', id: 'prefill' }, field: 'reconstructedPrefillJPerOutputToken' },
+      { variant: { kind: 'role', id: 'decode' }, field: 'measuredDecodeJPerOutputToken' },
+    ]);
+    expect(powerCompareBase('y_measuredDecodeJPerOutputToken', 'roles')).toEqual({
+      kind: 'role',
+      id: 'decode',
+    });
+  });
+
+  it('offers nothing where the metric has no common axis for the siblings', () => {
+    for (const [key, mode] of [
+      ['y_measuredP90Power', 'boundaries'],
+      ['y_measuredPowerPercentTdp', 'boundaries'],
+      ['y_measuredPowerTimeline', 'roles'],
+      ['y_measuredJPerInputToken', 'boundaries'],
+      ['y_measuredPrefillJPerInputToken', 'roles'],
+      ['y_measuredJPerSuccessfulQuery', 'roles'],
+      ['y_gpuProvisionedWatts', 'roles'],
+      ['y_tpPerGpu', 'boundaries'],
+    ] as const) {
+      expect(powerCompareVariants(key, mode)).toEqual([]);
+      expect(powerCompareBase(key, mode)).toBeNull();
+      expect(powerCompareAvailable(key, mode)).toBe(false);
+    }
+    expect(powerCompareAvailable('y_measuredP90Power', 'none')).toBe(true);
+    expect(powerCompareVariants('y_measuredAvgPower', 'none')).toEqual([]);
+  });
+});
+
+describe('expandPowerCompareSeries', () => {
+  it('clones each base point once per sibling that has a value and leaves the base untouched', () => {
+    const base = point();
+    const expanded = expandPowerCompareSeries([base], 'y_measuredAvgPower', 'boundaries');
+    expect(expanded[0]).toBe(base);
+    expect(expanded.slice(1).map((p) => [p.powerVariant?.id, p.y])).toEqual([
+      ['gpu-provisioned', 1000],
+      ['utility-provisioned', 1710],
+    ]);
+    // No modeled watts on this point → no utility-modeled clone, never a 0.
+    expect(expanded.some((p) => p.powerVariant?.id === 'utility-modeled')).toBe(false);
+    expect(expanded.slice(1).every((p) => p.hwKey === 'b200_sglang' && p.x === 50)).toBe(true);
+  });
+
+  it('stacks the reconstructed prefill energy against the decode pool on the energy axis', () => {
+    const expanded = expandPowerCompareSeries(
+      [point({ y: 7.9 })],
+      'y_measuredJPerOutputToken',
+      'roles',
+    );
+    expect(expanded.map((p) => [p.powerVariant?.id ?? 'base', p.y])).toEqual([
+      ['base', 7.9],
+      ['prefill', 1.975],
+      ['decode', 6],
+    ]);
+    expect(inferPowerCompare(expanded)).toBe('roles');
+    expect(powerVariantsInData(expanded, 'y_measuredJPerOutputToken')).toEqual([
+      { kind: 'role', id: 'all' },
+      { kind: 'role', id: 'prefill' },
+      { kind: 'role', id: 'decode' },
+    ]);
+  });
+
+  it('returns the points unchanged when the mode is off or inapplicable', () => {
+    const base = point();
+    expect(expandPowerCompareSeries([base], 'y_measuredAvgPower', 'none')).toEqual([base]);
+    expect(expandPowerCompareSeries([base], 'y_measuredP90Power', 'boundaries')).toEqual([base]);
+    expect(inferPowerCompare([base])).toBe('none');
+    expect(powerVariantsInData([base], 'y_measuredAvgPower')).toEqual([]);
+  });
+});
+
+describe('labels, dashes and URL values', () => {
+  it('parses only the two comparison modes from the URL', () => {
+    expect(parsePowerCompare('boundaries')).toBe('boundaries');
+    expect(parsePowerCompare('roles')).toBe('roles');
+    for (const value of ['', 'none', 'basis', null, undefined]) {
+      expect(parsePowerCompare(value)).toBe('none');
+    }
+  });
+
+  it('names series in both locales and keeps the base series solid', () => {
+    expect(powerVariantLabel({ kind: 'basis', id: 'gpu-provisioned' }, 'en')).toBe(
+      'GPU provisioned (TDP)',
+    );
+    expect(powerVariantLabel({ kind: 'role', id: 'prefill' }, 'zh')).toBe('预填充 GPU');
+    expect(powerVariantDash(undefined)).toBe('');
+    expect(powerVariantDash({ kind: 'role', id: 'all' })).toBe('');
+    expect(powerVariantDash({ kind: 'basis', id: 'gpu-provisioned' })).not.toBe('');
+    expect(powerVariantDash({ kind: 'role', id: 'decode' })).not.toBe(
+      powerVariantDash({ kind: 'role', id: 'prefill' }),
+    );
+  });
+
+  it('labels a base row by the selected metric and a clone by its variant', () => {
+    expect(powerSeriesLabel({}, 'y_measuredAvgPower', 'boundaries', 'en')).toBe('GPU measured');
+    expect(
+      powerSeriesLabel(
+        { powerVariant: { kind: 'basis', id: 'utility-modeled' } },
+        'y_measuredAvgPower',
+        'boundaries',
+        'zh',
+      ),
+    ).toBe('数据中心建模（含 PUE）');
+    expect(powerSeriesLabel({}, 'y_measuredAvgPower', 'none', 'en')).toBe('');
+  });
+});
+
+const basis = (id: PowerBasis): PowerVariant => ({ kind: 'basis', id });
+const role = (id: PowerRole): PowerVariant => ({ kind: 'role', id });
+
+describe('line labels', () => {
+  it('names every variant briefly in both locales', () => {
+    const cases: [PowerVariant, string, string][] = [
+      [basis('gpu-measured'), 'Measured', '实测'],
+      [basis('gpu-provisioned'), 'TDP', 'TDP'],
+      [basis('utility-provisioned'), 'All-in', '全站'],
+      [basis('utility-modeled'), 'PUE modeled', 'PUE 建模'],
+      [role('all'), 'All GPUs', '全部 GPU'],
+      [role('prefill'), 'Prefill GPUs', '预填充 GPU'],
+      [role('decode'), 'Decode GPUs', '解码 GPU'],
+    ];
+    for (const [variant, en, zh] of cases) {
+      expect(powerVariantShortLabel(variant, 'en')).toBe(en);
+      expect(powerVariantShortLabel(variant, 'zh')).toBe(zh);
+    }
+  });
+
+  it('formats watts as integer W below 1 kW and trimmed two-decimal kW above', () => {
+    expect(formatWatts(700)).toBe('700 W');
+    expect(formatWatts(999.6)).toBe('1000 W');
+    expect(formatWatts(1000)).toBe('1 kW');
+    expect(formatWatts(1200)).toBe('1.2 kW');
+    expect(formatWatts(1370)).toBe('1.37 kW');
+    expect(formatWatts(1400)).toBe('1.4 kW');
+    expect(formatWatts(1714.5)).toBe('1.71 kW');
+    expect(formatWatts(19200)).toBe('19.2 kW');
+    expect(formatWatts(100000)).toBe('100 kW');
+  });
+
+  it('leaves the base label alone and suffixes a sibling with its variant and flat watts', () => {
+    const label = 'B300 (SGLang)';
+    const tdp = basis('gpu-provisioned');
+    expect(powerLineLabel(label, undefined, { isBase: true, locale: 'en' })).toBe(label);
+    expect(powerLineLabel(label, null, { isBase: false, locale: 'en' })).toBe(label);
+    // A variant that is itself the base series keeps the plain label.
+    expect(powerLineLabel(label, tdp, { isBase: true, locale: 'en', flatWatts: 1200 })).toBe(label);
+    expect(powerLineLabel(label, tdp, { isBase: false, locale: 'en' })).toBe('B300 (SGLang) · TDP');
+    expect(powerLineLabel(label, tdp, { isBase: false, locale: 'en', flatWatts: 700 })).toBe(
+      'B300 (SGLang) · TDP 700 W',
+    );
+    expect(powerLineLabel(label, tdp, { isBase: false, locale: 'en', flatWatts: 1370 })).toBe(
+      'B300 (SGLang) · TDP 1.37 kW',
+    );
+    expect(
+      powerLineLabel(label, basis('utility-provisioned'), {
+        isBase: false,
+        locale: 'zh',
+        flatWatts: 19200,
+      }),
+    ).toBe('B300 (SGLang) · 全站 19.2 kW');
+    // Non-finite or null watts drop the value, never print NaN.
+    expect(powerLineLabel(label, tdp, { isBase: false, locale: 'en', flatWatts: null })).toBe(
+      'B300 (SGLang) · TDP',
+    );
+    expect(powerLineLabel(label, tdp, { isBase: false, locale: 'en', flatWatts: NaN })).toBe(
+      'B300 (SGLang) · TDP',
+    );
+    expect(powerLineLabel(label, role('decode'), { isBase: false, locale: 'en' })).toBe(
+      'B300 (SGLang) · Decode GPUs',
+    );
+    // The suffix alone is what the renderer splits into its own text segment.
+    expect(powerLineLabelSuffix(role('prefill'), { isBase: false, locale: 'zh' })).toBe(
+      ' · 预填充 GPU',
+    );
+    expect(powerLineLabelSuffix(role('prefill'), { isBase: true, locale: 'zh' })).toBe('');
+  });
+
+  it('detects a flat series within the relative tolerance', () => {
+    expect(flatSeriesValue([1200, 1200, 1200])).toBe(1200);
+    expect(flatSeriesValue([1000, 1004, 996])).toBe(1000);
+    expect(flatSeriesValue([1000, 1005])).toBe(1000);
+    expect(flatSeriesValue([1000, 1005.01])).toBeNull();
+    expect(flatSeriesValue([1000, 1005.01], 0.01)).toBe(1000);
+    expect(flatSeriesValue([600, 640, 710])).toBeNull();
+    expect(flatSeriesValue([])).toBeNull();
+    expect(flatSeriesValue([NaN, Infinity])).toBeNull();
+    expect(flatSeriesValue([NaN, 1200, 1200])).toBe(1200);
+    expect(flatSeriesValue([1200])).toBe(1200);
+  });
+
+  it('keeps the hardware key as the base series id and recovers it from a sibling id', () => {
+    const tdp = basis('gpu-provisioned');
+    expect(lineLabelSeriesId('b200_sglang', undefined, true)).toBe('b200_sglang');
+    expect(lineLabelSeriesId('b200_sglang', tdp, true)).toBe('b200_sglang');
+    expect(lineLabelSeriesId('b200_sglang', tdp, false)).toBe('b200_sglang::gpu-provisioned');
+    expect(lineLabelHardwareKey('b200_sglang::gpu-provisioned')).toBe('b200_sglang');
+    expect(lineLabelHardwareKey('b200_sglang')).toBe('b200_sglang');
+  });
+
+  it('only lets a watts axis state a flat boundary value', () => {
+    expect(metricPlotsWatts('y_measuredAvgPower')).toBe(true);
+    expect(metricPlotsWatts('y_gpuProvisionedWatts')).toBe(true);
+    expect(metricPlotsWatts('y_measuredDecodeAvgPower')).toBe(true);
+    expect(metricPlotsWatts('y_measuredPowerPercentTdp')).toBe(false);
+    expect(metricPlotsWatts('y_measuredJPerOutputToken')).toBe(false);
+    expect(metricPlotsWatts('y_tpPerGpu')).toBe(false);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/power-compare.ts b/packages/app/src/components/inference/utils/power-compare.ts
new file mode 100644
index 000000000..19300b8cd
--- /dev/null
+++ b/packages/app/src/components/inference/utils/power-compare.ts
@@ -0,0 +1,344 @@
+/**
+ * Comparison series for the gated measured-power charts (`i_pcompare`).
+ *
+ * The selected metric stays the chart's base series. A comparison adds sibling
+ * series drawn from the SAME points — one per other power boundary
+ * (`boundaries`, PowerX Figures 2/3) or per worker role (`roles`, Figures 6/7)
+ * — so ScatterGraph can draw them with the hardware's colour and a per-variant
+ * dash through its ordinary series pipeline (frontier, Optimal Only, tooltip,
+ * table, CSV, `?unofficialrun=` overlay). A variant point is a clone of its
+ * base point with `y` remapped and `powerVariant` set; base points are left
+ * untouched so a chart without comparison is byte-identical to before.
+ *
+ * Variants exist only where the metric names a whole-deployment average
+ * (W per chip) or J per output token, because those are the only quantities
+ * every boundary and role publishes on a common axis; everywhere else the
+ * comparison yields no series and the control says so.
+ */
+import type { Locale } from '@/lib/i18n';
+import {
+  POWER_BASES,
+  POWER_BASIS_FIELDS,
+  POWER_BASIS_LABELS,
+  type PowerBasis,
+} from '@/lib/power-basis';
+
+import { getMeasuredMetricConfig } from '../measured-metric-config';
+import type { InferenceData, PowerCompare, PowerRole, PowerVariant } from '../types';
+import { reconstructedRoleEnergy } from './role-energy';
+
+export const POWER_COMPARE_MODES = [
+  'none',
+  'boundaries',
+  'roles',
+] as const satisfies readonly PowerCompare[];
+
+export function parsePowerCompare(value: string | null | undefined): PowerCompare {
+  return value === 'boundaries' || value === 'roles' ? value : 'none';
+}
+
+/** Point fields a comparison series can plot; each is a `{ y, roof }` pair. */
+export type PowerSeriesField = keyof Pick<
+  InferenceData,
+  | 'measuredAvgPower'
+  | 'measuredPrefillAvgPower'
+  | 'measuredDecodeAvgPower'
+  | 'measuredJPerOutputToken'
+  | 'measuredDecodeJPerOutputToken'
+  | 'reconstructedPrefillJPerOutputToken'
+  | 'gpuProvisionedWatts'
+  | 'gpuProvisionedJPerOutputToken'
+  | 'utilityProvisionedWatts'
+  | 'utilityProvisionedJPerOutputToken'
+  | 'utilityModeledWatts'
+  | 'utilityModeledJPerOutputToken'
+>;
+
+export interface PowerCompareSeries {
+  variant: PowerVariant;
+  field: PowerSeriesField;
+}
+
+const ROLES = ['all', 'prefill', 'decode'] as const satisfies readonly PowerRole[];
+
+const ROLE_WATT_FIELDS: Record<PowerRole, PowerSeriesField> = {
+  all: 'measuredAvgPower',
+  prefill: 'measuredPrefillAvgPower',
+  decode: 'measuredDecodeAvgPower',
+};
+// Energy per output token per role. The prefill pool's own figure is per input
+// token; `reconstructedPrefillJPerOutputToken` carries it onto the output-token
+// axis (utils/role-energy.ts).
+const ROLE_ENERGY_FIELDS: Record<PowerRole, PowerSeriesField> = {
+  all: 'measuredJPerOutputToken',
+  prefill: 'reconstructedPrefillJPerOutputToken',
+  decode: 'measuredDecodeJPerOutputToken',
+};
+
+const ROLE_LABELS: Record<PowerRole, { en: string; zh: string }> = {
+  all: { en: 'All GPUs', zh: '全部 GPU' },
+  prefill: { en: 'Prefill GPUs', zh: '预填充 GPU' },
+  decode: { en: 'Decode GPUs', zh: '解码 GPU' },
+};
+
+/** SVG dash per variant; the base series and `all` stay solid. */
+const VARIANT_DASH: Record<string, string> = {
+  'gpu-measured': '',
+  'gpu-provisioned': '8 4',
+  'utility-provisioned': '3 3',
+  'utility-modeled': '10 3 2 3',
+  all: '',
+  prefill: '7 3',
+  decode: '2 3',
+};
+
+/**
+ * The quantity a metric key plots on the comparison's common axis, or null
+ * when the key is not a whole-deployment average W/chip or J per output token.
+ */
+function comparableQuantity(metric: string): 'watts' | 'energy' | null {
+  const config = getMeasuredMetricConfig(metric);
+  if (!config) return null;
+  if (config.family === 'power') {
+    return config.scope === 'all' && config.statistic === 'average' && config.display === 'watts'
+      ? 'watts'
+      : null;
+  }
+  return config.scope === 'all' && config.denominator === 'output' && config.unit === 'joules'
+    ? 'energy'
+    : null;
+}
+
+/**
+ * The base series' own identity under a comparison — the boundary or role the
+ * selected metric already plots — or null when the metric admits no comparison
+ * of that kind.
+ */
+export function powerCompareBase(metric: string, mode: PowerCompare): PowerVariant | null {
+  const config = getMeasuredMetricConfig(metric);
+  if (!config || mode === 'none') return null;
+  if (mode === 'boundaries') {
+    return comparableQuantity(metric) ? { kind: 'basis', id: config.basis } : null;
+  }
+  if (config.basis !== 'gpu-measured') return null;
+  if (config.family === 'power') {
+    return config.statistic === 'average' && config.display === 'watts'
+      ? { kind: 'role', id: config.scope }
+      : null;
+  }
+  // Role energy compares J per output token; a prefill J per input token axis
+  // has no decode counterpart.
+  return config.denominator === 'output' && config.unit === 'joules' && config.scope !== 'prefill'
+    ? { kind: 'role', id: config.scope }
+    : null;
+}
+
+/** The sibling series a comparison adds to the selected metric (never the base itself). */
+export function powerCompareVariants(metric: string, mode: PowerCompare): PowerCompareSeries[] {
+  const base = powerCompareBase(metric, mode);
+  const config = getMeasuredMetricConfig(metric);
+  if (!base || !config) return [];
+  if (base.kind === 'basis') {
+    const quantity = comparableQuantity(metric);
+    if (!quantity) return [];
+    return POWER_BASES.filter((basis) => basis !== base.id).map((basis) => ({
+      variant: { kind: 'basis', id: basis },
+      field:
+        basis === 'gpu-measured'
+          ? quantity === 'watts'
+            ? 'measuredAvgPower'
+            : 'measuredJPerOutputToken'
+          : POWER_BASIS_FIELDS[basis][quantity],
+    }));
+  }
+  const fields = config.family === 'power' ? ROLE_WATT_FIELDS : ROLE_ENERGY_FIELDS;
+  return ROLES.filter((role) => role !== base.id).map((role) => ({
+    variant: { kind: 'role', id: role },
+    field: fields[role],
+  }));
+}
+
+/** Whether choosing `mode` on `metric` draws anything. `none` is always available. */
+export function powerCompareAvailable(metric: string, mode: PowerCompare): boolean {
+  return mode === 'none' || powerCompareVariants(metric, mode).length > 0;
+}
+
+/**
+ * Appends one clone per comparison series to `points` (already remapped onto
+ * the selected metric). A point lacking a variant's field contributes nothing
+ * to that series — never a 0 — so the availability rules of each boundary and
+ * role carry through unchanged.
+ */
+export function expandPowerCompareSeries(
+  points: readonly InferenceData[],
+  metric: string,
+  mode: PowerCompare,
+): InferenceData[] {
+  const series = powerCompareVariants(metric, mode);
+  if (series.length === 0) return [...points];
+  const result: InferenceData[] = [...points];
+  for (const { variant, field } of series) {
+    for (const point of points) {
+      const value = point[field];
+      if (!value || !Number.isFinite(value.y)) continue;
+      result.push({ ...point, y: value.y, roof: value.roof, powerVariant: variant });
+    }
+  }
+  return result;
+}
+
+/** Comparison mode implied by the variants present in a rendered point set. */
+export function inferPowerCompare(points: readonly InferenceData[]): PowerCompare {
+  for (const point of points) {
+    if (point.powerVariant?.kind === 'basis') return 'boundaries';
+    if (point.powerVariant?.kind === 'role') return 'roles';
+  }
+  return 'none';
+}
+
+/** Distinct variants in draw order: the base first, then siblings in canonical order. */
+export function powerVariantsInData(
+  points: readonly InferenceData[],
+  metric: string,
+): PowerVariant[] {
+  const mode = inferPowerCompare(points);
+  if (mode === 'none') return [];
+  const present = new Set(points.map((point) => point.powerVariant?.id).filter(Boolean));
+  const base = powerCompareBase(metric, mode);
+  const ordered: PowerVariant[] =
+    mode === 'boundaries'
+      ? POWER_BASES.map((id) => ({ kind: 'basis', id }))
+      : ROLES.map((id) => ({ kind: 'role', id }));
+  return ordered.filter((variant) => variant.id === base?.id || present.has(variant.id));
+}
+
+export function powerVariantId(variant: PowerVariant | null | undefined): string {
+  return variant?.id ?? '';
+}
+
+export function powerVariantDash(variant: PowerVariant | null | undefined): string {
+  return variant ? VARIANT_DASH[variant.id] : '';
+}
+
+export function powerVariantLabel(variant: PowerVariant, locale: Locale): string {
+  return variant.kind === 'basis'
+    ? POWER_BASIS_LABELS[variant.id][locale]
+    : ROLE_LABELS[variant.id][locale];
+}
+
+/** Short boundary names for in-chart line labels; the legend keeps the full names. */
+const BASIS_SHORT_LABELS: Record<PowerBasis, { en: string; zh: string }> = {
+  'gpu-measured': { en: 'Measured', zh: '实测' },
+  'gpu-provisioned': { en: 'TDP', zh: 'TDP' },
+  'utility-provisioned': { en: 'All-in', zh: '全站' },
+  'utility-modeled': { en: 'PUE modeled', zh: 'PUE 建模' },
+};
+
+/** Suffix text a line label carries for one comparison series. */
+export function powerVariantShortLabel(variant: PowerVariant, locale: Locale): string {
+  return variant.kind === 'basis'
+    ? BASIS_SHORT_LABELS[variant.id][locale]
+    : ROLE_LABELS[variant.id][locale];
+}
+
+/** `700 W`, `1.37 kW`, `19.2 kW`: kilowatts from 1000 W, at most two decimals, zeros trimmed. */
+export function formatWatts(watts: number): string {
+  if (Math.abs(watts) >= 1000) {
+    return `${(watts / 1000).toFixed(2).replace(/\.?0+$/u, '')} kW`;
+  }
+  return `${Math.round(watts)} W`;
+}
+
+/**
+ * The value a series holds at every point, or null when it varies. A
+ * provisioned boundary (TDP, all-in) is one number per hardware, so its line
+ * label can state it instead of sending the reader to the axis. Non-finite
+ * values are ignored; an empty series is null.
+ */
+export function flatSeriesValue(values: readonly number[], relTolerance = 0.005): number | null {
+  const finite = values.filter((value) => Number.isFinite(value));
+  if (finite.length === 0) return null;
+  const first = finite[0];
+  const tolerance = Math.abs(first) * relTolerance;
+  return finite.every((value) => Math.abs(value - first) <= tolerance) ? first : null;
+}
+
+export interface PowerLineLabelOptions {
+  /** The selected metric's own series keeps the plain hardware label. */
+  isBase: boolean;
+  locale: Locale;
+  /** Shared watts of a flat series (`flatSeriesValue`), appended after the name. */
+  flatWatts?: number | null;
+}
+
+const LINE_LABEL_SUFFIX_SEPARATOR = ' · ';
+
+/** Suffix appended to a comparison sibling's line label; '' for the base series. */
+export function powerLineLabelSuffix(
+  variant: PowerVariant | null | undefined,
+  opts: PowerLineLabelOptions,
+): string {
+  if (opts.isBase || !variant) return '';
+  const watts =
+    typeof opts.flatWatts === 'number' && Number.isFinite(opts.flatWatts)
+      ? ` ${formatWatts(opts.flatWatts)}`
+      : '';
+  return `${LINE_LABEL_SUFFIX_SEPARATOR}${powerVariantShortLabel(variant, opts.locale)}${watts}`;
+}
+
+/**
+ * Line-label text for one drawn series: the hardware label alone for the base
+ * series, `<label> · <variant>` for a sibling, plus the flat watts when known.
+ */
+export function powerLineLabel(
+  baseLabel: string,
+  variant: PowerVariant | null | undefined,
+  opts: PowerLineLabelOptions,
+): string {
+  return `${baseLabel}${powerLineLabelSuffix(variant, opts)}`;
+}
+
+const LINE_LABEL_SERIES_DELIMITER = '::';
+
+/**
+ * Line-label series id: the hardware key for the base series (existing pinned
+ * anchors and hover hooks key on it) and `<hw>::<variant>` for a sibling.
+ */
+export function lineLabelSeriesId(
+  hw: string,
+  variant: PowerVariant | null | undefined,
+  isBase: boolean,
+): string {
+  return isBase || !variant ? hw : `${hw}${LINE_LABEL_SERIES_DELIMITER}${variant.id}`;
+}
+
+/** Inverse of `lineLabelSeriesId`: the hardware key behind a line-label series id. */
+export function lineLabelHardwareKey(seriesId: string): string {
+  const index = seriesId.indexOf(LINE_LABEL_SERIES_DELIMITER);
+  return index === -1 ? seriesId : seriesId.slice(0, index);
+}
+
+/** Whether `metric` plots watts per chip, so a flat boundary's label can state its value. */
+export function metricPlotsWatts(metric: string): boolean {
+  const config = getMeasuredMetricConfig(metric);
+  return config?.family === 'power' && config.display === 'watts';
+}
+
+/**
+ * Series label for a table or CSV row: the point's variant, or the base
+ * series' identity when the chart is comparing and this is a base point.
+ */
+export function powerSeriesLabel(
+  point: Pick<InferenceData, 'powerVariant'>,
+  metric: string,
+  mode: PowerCompare,
+  locale: Locale,
+): string {
+  const variant = point.powerVariant ?? powerCompareBase(metric, mode);
+  return variant ? powerVariantLabel(variant, locale) : '';
+}
+
+/** Prefill share of the reconstructed request energy for a role-energy point, in percent. */
+export function reconstructedPrefillShare(point: InferenceData): number | null {
+  return reconstructedRoleEnergy(point)?.prefillShare ?? null;
+}
diff --git a/packages/app/src/components/inference/utils/powerCurves.test.ts b/packages/app/src/components/inference/utils/powerCurves.test.ts
index a71f8bde2..21356f6b5 100644
--- a/packages/app/src/components/inference/utils/powerCurves.test.ts
+++ b/packages/app/src/components/inference/utils/powerCurves.test.ts
@@ -4,7 +4,13 @@ import type { InferenceData } from '@/components/inference/types';
 import { chartDefinitions } from '@/components/inference/metric-registry';
 import type { ParetoDirection } from '@/lib/chart-utils';
 
-import { chartFrontier, isPowerCurveMetric, upperPowerEnvelope } from './powerCurves';
+import {
+  chartFrontier,
+  isMeasuredPowerCurveMetric,
+  isPowerCurveMetric,
+  isPowerGaugeSeries,
+  upperPowerEnvelope,
+} from './powerCurves';
 
 function point(conc: number, x: number, y: number, overrides: Partial<InferenceData> = {}) {
   return {
@@ -70,6 +76,23 @@ describe('power chart semantics', () => {
     expect(chartFrontier(points, 'lower_right')).toEqual(points);
   });
 
+  it.each(['y_gpuProvisionedWatts', 'y_utilityProvisionedWatts', 'y_utilityModeledWatts'])(
+    'draws %s as an envelope-locked power gauge like measured watts',
+    (metric) => {
+      expect(isPowerCurveMetric(metric)).toBe(true);
+      expect(isMeasuredPowerCurveMetric(metric)).toBe(true);
+    },
+  );
+
+  it.each([
+    'y_gpuProvisionedJPerOutputToken',
+    'y_utilityProvisionedJPerOutputToken',
+    'y_utilityModeledJPerOutputToken',
+  ])('keeps %s on the energy Pareto frontier', (metric) => {
+    expect(isPowerCurveMetric(metric)).toBe(false);
+    expect(isMeasuredPowerCurveMetric(metric)).toBe(false);
+  });
+
   it('preserves the canonical agentic restriction on Pareto membership', () => {
     const canonical = point(8, 100, 1, { isOnNormalizedInteractivityFrontier: true });
     const nonCanonical = point(1, 200, 4, { isOnNormalizedInteractivityFrontier: false });
@@ -94,8 +117,12 @@ describe('upper power envelope', () => {
   it('mirrors the boundary for latency and resolves tied coordinates deterministically', () => {
     const fast = point(1, 1, 350);
     const middle = point(8, 2, 700);
+    const plateau = point(16, 3, 700);
     const slow = point(32, 4, 950);
-    const samples = [slow, point(16, 3, 700), point(4, 2, 500), middle, { ...middle }, fast];
+    // Measured watts: a tie at the running maximum is a repeat marker, so the
+    // plateau leaves the boundary and Optimal Only can collapse it; a repeated
+    // X keeps only its first vertex.
+    const samples = [slow, plateau, point(4, 2, 500), middle, { ...middle }, fast];
     expect(upperPowerEnvelope(samples, false)).toEqual([fast, middle, slow]);
     expect(
       upperPowerEnvelope(
@@ -103,6 +130,39 @@ describe('upper power envelope', () => {
         true,
       ).map((p) => p.y),
     ).toEqual([950, 700, 350]);
+    // A gauge keeps the plateau: it is part of the outer edge it draws.
+    expect(upperPowerEnvelope(samples, false, true)).toEqual([fast, middle, plateau, slow]);
+  });
+
+  it('keeps a flat provisioned series across its tested range only when asked to', () => {
+    // A TDP gauge is the same watts at every concurrency: with `keepTies` the
+    // boundary spans the sweep; the strict measured rule would collapse it to
+    // the first-sorted marker.
+    const flat = [point(1, 200, 1000), point(8, 120, 1000), point(64, 40, 1000)];
+    expect(upperPowerEnvelope(flat, true, true)).toEqual(flat.toReversed());
+    expect(upperPowerEnvelope(flat, false, true).map((p) => p.x)).toEqual([40, 120, 200]);
+    expect(upperPowerEnvelope(flat, true)).toEqual([flat[0]]);
+    expect(upperPowerEnvelope(flat, false)).toEqual([flat[2]]);
+  });
+
+  it('keeps ties only for provisioned and modelled gauge series', () => {
+    const measured = point(1, 200, 700);
+    const tdpClone = {
+      ...measured,
+      powerVariant: { kind: 'basis', id: 'gpu-provisioned' } as const,
+    };
+    const measuredClone = {
+      ...measured,
+      powerVariant: { kind: 'basis', id: 'gpu-measured' } as const,
+    };
+    const roleClone = { ...measured, powerVariant: { kind: 'role', id: 'decode' } as const };
+    expect(isPowerGaugeSeries('y_gpuProvisionedWatts', measured)).toBe(true);
+    expect(isPowerGaugeSeries('y_utilityModeledWatts', undefined)).toBe(true);
+    expect(isPowerGaugeSeries('y_measuredAvgPower', measured)).toBe(false);
+    expect(isPowerGaugeSeries('y_measuredAvgPower', tdpClone)).toBe(true);
+    expect(isPowerGaugeSeries('y_measuredAvgPower', measuredClone)).toBe(false);
+    expect(isPowerGaugeSeries('y_measuredAvgPower', roleClone)).toBe(false);
+    expect(isPowerGaugeSeries('y_gpuProvisionedWatts', roleClone)).toBe(false);
   });
 
   it('uses only finite positive coordinates and preserves singleton boundaries', () => {
diff --git a/packages/app/src/components/inference/utils/powerCurves.ts b/packages/app/src/components/inference/utils/powerCurves.ts
index 35146640a..13ac7209e 100644
--- a/packages/app/src/components/inference/utils/powerCurves.ts
+++ b/packages/app/src/components/inference/utils/powerCurves.ts
@@ -1,3 +1,4 @@
+import { isPowerBasisConfigKey } from '@/components/inference/metric-registry';
 import type { InferenceData } from '@/components/inference/types';
 import {
   isFrontierEligible,
@@ -15,14 +16,40 @@ const POWER_CURVE_METRICS: ReadonlySet<string> = new Set([
   'y_measuredDecodeAvgPower',
   'y_measuredPowerPercentTdp',
   'y_modeledChassisPowerPerGpu',
+  // Provisioned / modelled boundary gauges: same upper-envelope curve as measured watts.
+  'y_gpuProvisionedWatts',
+  'y_utilityProvisionedWatts',
+  'y_utilityModeledWatts',
 ]);
 
 export function isPowerCurveMetric(metric: string): boolean {
   return POWER_CURVE_METRICS.has(metric);
 }
 
+/**
+ * Power gauges whose curve is always the upper envelope and whose Optimal Only
+ * toggle only hides off-envelope markers: measured watts plus the provisioned /
+ * modelled boundary gauges that sit beside them. A Pareto corner would collapse
+ * a flat TDP series to one marker. The modelled chassis axis keeps its legacy
+ * Pareto behaviour.
+ */
 export function isMeasuredPowerCurveMetric(metric: string): boolean {
-  return isPowerCurveMetric(metric) && metric !== 'y_modeledChassisPowerPerGpu';
+  return (
+    isPowerCurveMetric(metric) &&
+    (metric !== 'y_modeledChassisPowerPerGpu' || isPowerBasisConfigKey(metric))
+  );
+}
+
+/**
+ * Whether a drawn series is a provisioned or modelled gauge rather than
+ * telemetry: a boundary axis, or a boundary comparison clone of one. Gauges
+ * keep envelope ties (see `upperPowerEnvelope`); measured series, the measured
+ * boundary clone and role clones stay on the strict envelope.
+ */
+export function isPowerGaugeSeries(metric: string, sample: InferenceData | undefined): boolean {
+  const variant = sample?.powerVariant;
+  if (variant) return variant.kind === 'basis' && variant.id !== 'gpu-measured';
+  return isPowerBasisConfigKey(metric);
 }
 
 /** No declared direction means there is no Pareto frontier to draw or filter by. */
@@ -45,14 +72,23 @@ export function chartFrontier(
 export function upperPowerEnvelope(
   points: readonly InferenceData[],
   maximizeX: boolean,
+  keepTies = false,
 ): InferenceData[] {
   const sorted = points
     .filter((point) => isFrontierEligible(point) && Number.isFinite(point.y) && point.y > 0)
     .sort((a, b) => (maximizeX ? b.x - a.x : a.x - b.x) || b.y - a.y);
+  // Measured telemetry keeps the strict envelope: a tie at the running maximum
+  // is a repeat marker that Optimal Only collapses. A provisioned or modelled
+  // gauge (`keepTies`) is flat by construction, so its ties stay on the
+  // boundary and the series draws across its tested x-range instead of one
+  // marker. Repeated X keeps only its first vertex so the smoothing never
+  // backtracks.
   let maxY = -Infinity;
+  let lastX = Number.NaN;
   const envelope = sorted.filter((point) => {
-    if (point.y <= maxY) return false;
+    if (point.y < maxY || (point.y === maxY && (!keepTies || point.x === lastX))) return false;
     maxY = point.y;
+    lastX = point.x;
     return true;
   });
   return maximizeX ? envelope.toReversed() : envelope;
diff --git a/packages/app/src/components/inference/utils/powerTimeline.test.ts b/packages/app/src/components/inference/utils/powerTimeline.test.ts
new file mode 100644
index 000000000..97b062a49
--- /dev/null
+++ b/packages/app/src/components/inference/utils/powerTimeline.test.ts
@@ -0,0 +1,421 @@
+import { describe, expect, it } from 'vitest';
+
+import type { GpuPowerSeriesResponse } from '@/components/gpu-power/power-series';
+import type { InferenceData } from '@/components/inference/types';
+
+import {
+  allGpuPool,
+  consumePowerTraceFocus,
+  joinPowerTimeline,
+  longestCommonPrefix,
+  groupPoolsBySize,
+  planPowerTimelineRequests,
+  prioritizeRun,
+  prioritizeRuns,
+  referenceLabelSlots,
+  requestPowerTraceFocus,
+  runIdFromUrl,
+  telemetryArtifactForPoint,
+  telemetrySourceForPoint,
+  traceConfigLabel,
+  traceKeyForPoint,
+  traceKeyRunId,
+  tracePools,
+  windowPhase,
+} from './powerTimeline';
+
+const RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34716669498';
+const NAME_A =
+  'qwen3.5_8k1k_fp8_sglang_tp4-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc16_b200-nscale-sl-1c68b810a44c3c71a187';
+const NAME_B =
+  'qwen3.5_8k1k_fp8_dynamo-sglang_prefill-tp4-pp1-dcp1-pcp1-ep1-dpfalse-nw1_decode-tp4-5b35252b29d80b104d11_sa-bench_isl_8192_osl_1024_conc1_gpus_8_ctx_4_gen_4';
+
+function point(overrides: Partial<InferenceData>): InferenceData {
+  return {
+    x: 1,
+    y: 1,
+    hwKey: 'b200_sglang',
+    tp: 4,
+    conc: 16,
+    precision: 'fp8',
+    date: '2026-09-12',
+    run_url: RUN_URL,
+    ...overrides,
+  } as InferenceData;
+}
+
+const runInfo: GpuPowerSeriesResponse['runInfo'] = {
+  id: 34716669498,
+  name: 'Run Sweep',
+  branch: 'main',
+  sha: 'abc',
+  createdAt: '2026-09-12T20:00:00Z',
+  url: RUN_URL,
+  conclusion: 'success',
+  status: 'completed',
+};
+
+describe('telemetryArtifactForPoint', () => {
+  it('maps the power-audit source to the gpu_metrics artifact of the same RESULT_FILENAME', () => {
+    expect(
+      telemetryArtifactForPoint({ power_audit: { source: `power_validation_${NAME_A}.json` } }),
+    ).toBe(`gpu_metrics_${NAME_A}`);
+    // A bundled path still resolves to the bare artifact name.
+    expect(
+      telemetryArtifactForPoint({
+        power_audit: { source: `artifacts/power_validation_${NAME_B}.json` },
+      }),
+    ).toBe(`gpu_metrics_${NAME_B}`);
+  });
+
+  it('returns null without an audit source or with a foreign file name', () => {
+    expect(telemetryArtifactForPoint({})).toBeNull();
+    expect(telemetryArtifactForPoint({ power_audit: {} })).toBeNull();
+    expect(telemetryArtifactForPoint({ power_audit: { source: 'agg_results.json' } })).toBeNull();
+  });
+});
+
+describe('planPowerTimelineRequests', () => {
+  it('groups artifacts per workflow run under their common RESULT_FILENAME prefix', () => {
+    const points = [
+      point({ power_audit: { source: `power_validation_${NAME_A}.json` } }),
+      point({ conc: 1, power_audit: { source: `power_validation_${NAME_B}.json` } }),
+      point({
+        run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/1',
+        power_audit: { source: 'power_validation_dsr1_1k1k_fp8_sglang_conc8_h200-x.json' },
+      }),
+      // No run URL: nothing to fetch.
+      point({ run_url: undefined, power_audit: { source: `power_validation_${NAME_A}.json` } }),
+      // No telemetry audit: nothing to fetch.
+      point({ conc: 2 }),
+    ];
+    expect(planPowerTimelineRequests(points)).toEqual([
+      {
+        runId: '1',
+        prefix: 'dsr1_1k1k_fp8_sglang_conc8_h200-x',
+        artifacts: ['gpu_metrics_dsr1_1k1k_fp8_sglang_conc8_h200-x'],
+      },
+      {
+        runId: '34716669498',
+        prefix: 'qwen3.5_8k1k_fp8_',
+        artifacts: [`gpu_metrics_${NAME_B}`, `gpu_metrics_${NAME_A}`],
+      },
+    ]);
+  });
+
+  it('exposes the helpers it is built from', () => {
+    expect(runIdFromUrl(RUN_URL)).toBe('34716669498');
+    expect(runIdFromUrl('https://example.com')).toBeNull();
+    expect(runIdFromUrl(undefined)).toBeNull();
+    expect(longestCommonPrefix(['abc_1', 'abc_2', 'abd'])).toBe('ab');
+    expect(longestCommonPrefix([])).toBe('');
+    expect(longestCommonPrefix(['solo'])).toBe('solo');
+  });
+});
+
+describe('joinPowerTimeline', () => {
+  const response: GpuPowerSeriesResponse = {
+    runInfo,
+    series: [
+      {
+        artifact: `gpu_metrics_${NAME_A}`,
+        startMs: Date.UTC(2026, 8, 12, 20, 19, 57),
+        bucketSeconds: 1,
+        gpus: [0, 1],
+        t: [0, 1, 2],
+        power: [
+          [190, 700, 710],
+          [188, 690, null],
+        ],
+      },
+    ],
+  };
+
+  it('attaches the fetched series and the audit window, and reports the rest as missing', () => {
+    const matched = point({
+      power_audit: {
+        source: `power_validation_${NAME_A}.json`,
+        window_start_unix: 1789244883.149,
+        window_end_unix: 1789244982.413,
+      },
+    });
+    const unmatched = point({
+      conc: 1,
+      disagg: true,
+      power_audit: { source: `power_validation_${NAME_B}.json` },
+    });
+    const noAudit = point({ conc: 2 });
+    const { traces, missing } = joinPowerTimeline(
+      [matched, unmatched, noAudit],
+      new Map([['34716669498', response]]),
+    );
+    expect(traces).toHaveLength(1);
+    expect(traces[0].key).toBe(`34716669498:${NAME_A}`);
+    expect(traces[0].series).toBe(response.series[0]);
+    expect(traces[0].windowStartMs).toBeCloseTo(1789244883149, 0);
+    expect(traces[0].windowEndMs).toBeCloseTo(1789244982413, 0);
+    expect(missing).toEqual([
+      { point: unmatched, reason: 'not-in-run' },
+      { point: noAudit, reason: 'no-source' },
+    ]);
+    // A run that was never loaded is reported as such, not as a missing artifact.
+    expect(joinPowerTimeline([matched], new Map()).missing).toEqual([
+      { point: matched, reason: 'run-not-fetched' },
+    ]);
+    expect(
+      joinPowerTimeline(
+        [point({ run_url: undefined, power_audit: matched.power_audit })],
+        new Map(),
+      ).missing[0].reason,
+    ).toBe('no-run');
+
+    expect(windowPhase(traces[0], 1789244883149 - 1)).toBe('before');
+    expect(windowPhase(traces[0], 1789244883149)).toBe('window');
+    expect(windowPhase(traces[0], 1789244982413 + 1)).toBe('after');
+    expect(traceConfigLabel(matched)).toBe('TP4 · c16');
+    expect(traceConfigLabel(unmatched)).toBe('PD · TP4 · c1');
+  });
+
+  it('treats a trace without a recorded window as unknown rather than emphasised', () => {
+    const noWindow = point({ power_audit: { source: `power_validation_${NAME_A}.json` } });
+    const { traces } = joinPowerTimeline([noWindow], new Map([['34716669498', response]]));
+    expect(traces[0].windowStartMs).toBeNull();
+    expect(windowPhase(traces[0], response.series[0].startMs)).toBe('unknown');
+  });
+});
+
+describe('trace identity helpers', () => {
+  it('names the validation file and the run-scoped trace key of a point', () => {
+    const audited = point({ power_audit: { source: `power_validation_${NAME_A}.json` } });
+    expect(telemetrySourceForPoint(audited)).toBe(`power_validation_${NAME_A}.json`);
+    // A path prefix is dropped: bundle-cut series carry the basename.
+    expect(
+      telemetrySourceForPoint({
+        power_audit: { source: `nested/power_validation_${NAME_B}.json` },
+      }),
+    ).toBe(`power_validation_${NAME_B}.json`);
+    expect(traceKeyForPoint(audited)).toBe(`34716669498:${NAME_A}`);
+  });
+
+  it('has no key without a run or an audit source', () => {
+    expect(traceKeyForPoint(point({ run_url: undefined, power_audit: { source: 'x.json' } }))).toBe(
+      null,
+    );
+    expect(traceKeyForPoint(point({ power_audit: { source: 'agg_results.json' } }))).toBeNull();
+    expect(telemetrySourceForPoint({})).toBeNull();
+  });
+});
+
+describe('joinPowerTimeline with bundle-cut series', () => {
+  const bundleSource = `power_validation_${NAME_B}.json`;
+  const artifactSeries: GpuPowerSeriesResponse['series'][number] = {
+    artifact: `gpu_metrics_${NAME_B}`,
+    startMs: 1,
+    bucketSeconds: 1,
+    gpus: [0],
+    t: [0],
+    power: [[1]],
+  };
+  const bundleSeries: GpuPowerSeriesResponse['series'][number] = {
+    artifact: 'power_audit_qwen3.5_8k1k_fp8_dynamo-sglang_prefill-tp4-5b35252b29d80b104d11',
+    source: bundleSource,
+    startMs: 2,
+    bucketSeconds: 1,
+    gpus: [0, 1],
+    t: [0],
+    power: [[2], [3]],
+    devices: [
+      { id: 'watchtower-navy-cn01/GPU-aaa', role: 'prefill' },
+      { id: 'watchtower-navy-cn01/GPU-bbb', role: 'decode' },
+    ],
+  };
+  const disagg = point({ conc: 1, disagg: true, power_audit: { source: bundleSource } });
+
+  it('matches a series by its validation-file source', () => {
+    const { traces, missing } = joinPowerTimeline(
+      [disagg],
+      new Map([['34716669498', { runInfo, series: [bundleSeries] }]]),
+    );
+    expect(missing).toEqual([]);
+    expect(traces[0].series).toBe(bundleSeries);
+    expect(traces[0].key).toBe(`34716669498:${NAME_B}`);
+  });
+
+  it('prefers the source match over a gpu_metrics artifact of the same name', () => {
+    const { traces } = joinPowerTimeline(
+      [disagg],
+      new Map([['34716669498', { runInfo, series: [artifactSeries, bundleSeries] }]]),
+    );
+    expect(traces[0].series).toBe(bundleSeries);
+  });
+
+  it('never joins a source-labelled series through its bundle artifact name', () => {
+    const foreign = { ...bundleSeries, source: 'power_validation_other_conc4.json' };
+    const { traces, missing } = joinPowerTimeline(
+      [disagg],
+      new Map([['34716669498', { runInfo, series: [foreign] }]]),
+    );
+    expect(traces).toEqual([]);
+    expect(missing).toEqual([{ point: disagg, reason: 'not-in-run' }]);
+  });
+});
+
+describe('worker-role pools', () => {
+  it('groups rows by role in prefill, decode order regardless of device order', () => {
+    const pools = tracePools({
+      power: [[1], [2], [3], [4], [5]],
+      devices: [
+        { id: 'h/GPU-0', role: 'decode' },
+        { id: 'h/GPU-1', role: 'prefill' },
+        { id: 'h/GPU-2', role: 'decode' },
+        // An unassigned device belongs to no pool.
+        { id: 'h/GPU-3' },
+        { id: 'h/GPU-4', role: 'prefill' },
+      ],
+    });
+    expect(pools).toEqual([
+      { role: 'prefill', rows: [1, 4] },
+      { role: 'decode', rows: [0, 2] },
+    ]);
+  });
+
+  it('yields only the roles present and nothing without roles', () => {
+    expect(
+      tracePools({
+        power: [[1], [2]],
+        devices: [
+          { id: 'a', role: 'decode' },
+          { id: 'b', role: 'decode' },
+        ],
+      }),
+    ).toEqual([{ role: 'decode', rows: [0, 1] }]);
+    expect(tracePools({ power: [[1], [2]], devices: [{ id: '0' }, { id: '1' }] })).toEqual([]);
+    expect(tracePools({ power: [[1], [2]] })).toEqual([]);
+    expect(tracePools({ power: [] })).toEqual([]);
+  });
+
+  it('folds every row into the all-GPU pool', () => {
+    expect(allGpuPool({ power: [[1], [2], [3]] })).toEqual({ role: 'all', rows: [0, 1, 2] });
+    expect(allGpuPool({ power: [] })).toEqual({ role: 'all', rows: [] });
+  });
+});
+
+describe('power trace focus handoff', () => {
+  it('hands the requested key to exactly one consumer', () => {
+    expect(consumePowerTraceFocus()).toBeNull();
+    requestPowerTraceFocus('34716669498:conc16');
+    expect(consumePowerTraceFocus()).toBe('34716669498:conc16');
+    expect(consumePowerTraceFocus()).toBeNull();
+  });
+
+  it('keeps only the latest request', () => {
+    requestPowerTraceFocus('first');
+    requestPowerTraceFocus('second');
+    expect(consumePowerTraceFocus()).toBe('second');
+    expect(consumePowerTraceFocus()).toBeNull();
+  });
+});
+
+describe('prioritizeRuns', () => {
+  const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
+    runId,
+    prefix: '',
+    artifacts: [],
+  }));
+
+  it('moves overlay runs ahead of official runs and keeps both orders', () => {
+    expect(prioritizeRuns(requests, new Set(['5', '3'])).map((request) => request.runId)).toEqual([
+      '3',
+      '5',
+      '1',
+      '2',
+      '4',
+    ]);
+  });
+
+  it('lets the deep-linked run lead the overlay runs', () => {
+    const ordered = prioritizeRun(prioritizeRuns(requests, new Set(['4', '5'])), '2');
+    expect(ordered.map((request) => request.runId)).toEqual(['2', '4', '5', '1', '3']);
+  });
+
+  it('returns the same array when nothing moves', () => {
+    expect(prioritizeRuns(requests, new Set())).toBe(requests);
+    expect(prioritizeRuns(requests, new Set(['9']))).toBe(requests);
+    expect(prioritizeRuns(requests, new Set(['1', '2']))).toBe(requests);
+    expect(prioritizeRuns(requests, new Set(['1', '2', '3', '4', '5']))).toBe(requests);
+  });
+});
+
+describe('prioritizeRun', () => {
+  const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
+    runId,
+    prefix: '',
+    artifacts: [],
+  }));
+
+  it('moves the deep-linked run to the front and keeps the rest in order', () => {
+    expect(prioritizeRun(requests, '5').map((request) => request.runId)).toEqual([
+      '5',
+      '1',
+      '2',
+      '3',
+      '4',
+    ]);
+    expect(prioritizeRun(requests, '3').map((request) => request.runId)).toEqual([
+      '3',
+      '1',
+      '2',
+      '4',
+      '5',
+    ]);
+  });
+
+  it('returns the same array when the run is first, unknown or absent', () => {
+    expect(prioritizeRun(requests, '1')).toBe(requests);
+    expect(prioritizeRun(requests, '9')).toBe(requests);
+    expect(prioritizeRun(requests, null)).toBe(requests);
+    expect(traceKeyRunId('34716669498:qwen_conc8')).toBe('34716669498');
+    expect(traceKeyRunId(null)).toBeNull();
+    expect(traceKeyRunId('')).toBeNull();
+  });
+});
+
+describe('groupPoolsBySize', () => {
+  it('merges pools of one hardware that share a GPU count and keeps pool order', () => {
+    expect(
+      groupPoolsBySize([
+        { role: 'decode', rows: [4, 5, 6, 7] },
+        { role: 'prefill', rows: [0, 1, 2, 3] },
+      ]),
+    ).toEqual([{ size: 4, roles: ['prefill', 'decode'] }]);
+  });
+
+  it('keeps pools of different sizes apart, smallest first, without duplicates', () => {
+    expect(
+      groupPoolsBySize([
+        { role: 'prefill', rows: [0, 1, 2, 3, 4, 5] },
+        { role: 'decode', rows: [6, 7] },
+        { role: 'prefill', rows: [8, 9, 10, 11, 12, 13] },
+        { role: 'all', rows: [0, 1] },
+      ]),
+    ).toEqual([
+      { size: 2, roles: ['all', 'decode'] },
+      { size: 6, roles: ['prefill'] },
+    ]);
+    expect(groupPoolsBySize([])).toEqual([]);
+  });
+});
+
+describe('referenceLabelSlots', () => {
+  it('stacks labels of lines that share a watts value and leaves others on the line', () => {
+    expect(
+      referenceLabelSlots([
+        { watts: 19200 },
+        { watts: 22400 },
+        { watts: 19200 },
+        { watts: 8000 },
+        { watts: 19200 },
+      ]),
+    ).toEqual([0, 0, 1, 0, 2]);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/powerTimeline.ts b/packages/app/src/components/inference/utils/powerTimeline.ts
new file mode 100644
index 000000000..937647f8c
--- /dev/null
+++ b/packages/app/src/components/inference/utils/powerTimeline.ts
@@ -0,0 +1,349 @@
+/**
+ * Joins chart points to the per-second GPU telemetry behind their measured
+ * average power (the PowerX "Timeline" display).
+ *
+ * Every validated row records its window in `power_audit`, whose `source` is
+ * `power_validation_<name>.json`. Two collectors publish the telemetry:
+ * - single-node runners upload one `gpu_metrics_<name>` CSV artifact per
+ *   config, so the source names the artifact exactly;
+ * - Slurm / Dynamo runners upload one `power_audit_<RESULT_FILENAME>` bundle per
+ *   sweep whose `LOGS/power/samples.csv` covers every concurrency; the API cuts
+ *   it into one series per `power_validation_*.json` it contains and labels
+ *   each with that `source`, so the same file name joins it to the row.
+ * Nothing is matched by hardware or concurrency; points whose telemetry is
+ * missing (expired artifact, another collector) are reported, not guessed.
+ */
+import type {
+  GpuPowerRole,
+  GpuPowerSeries,
+  GpuPowerSeriesResponse,
+} from '@/components/gpu-power/power-series';
+import type { InferenceData } from '@/components/inference/types';
+
+export const POWER_TIMELINE_METRIC_KEY = 'y_measuredPowerTimeline';
+const ARTIFACT_PREFIX = 'gpu_metrics_';
+const SOURCE_PATTERN = /^(?:.*\/)?power_validation_(?<name>.+)\.json$/u;
+
+interface AuditedPoint {
+  power_audit?: { source?: string } | null;
+}
+
+/** The `<name>` of a point's `power_validation_<name>.json` audit source. */
+export function telemetryNameForPoint(point: AuditedPoint): string | null {
+  const source = point.power_audit?.source;
+  if (!source) return null;
+  return SOURCE_PATTERN.exec(source)?.groups?.name ?? null;
+}
+
+/** `gpu_metrics_<RESULT_FILENAME>` for a point, from its power-audit source. */
+export function telemetryArtifactForPoint(point: AuditedPoint): string | null {
+  const name = telemetryNameForPoint(point);
+  return name ? `${ARTIFACT_PREFIX}${name}` : null;
+}
+
+/** Basename of a point's audit source, as a bundle-cut series carries it in `source`. */
+export function telemetrySourceForPoint(point: AuditedPoint): string | null {
+  const name = telemetryNameForPoint(point);
+  return name ? `power_validation_${name}.json` : null;
+}
+
+/**
+ * Stable identity of a point's trace: run id plus audit name. Unique within a
+ * chart because the audit name carries the config and the concurrency.
+ */
+export function traceKeyForPoint(point: AuditedPoint & { run_url?: string }): string | null {
+  const runId = runIdFromUrl(point.run_url);
+  const name = telemetryNameForPoint(point);
+  return runId && name ? `${runId}:${name}` : null;
+}
+
+/** Workflow run id from a GitHub Actions run URL. */
+export function runIdFromUrl(url: string | null | undefined): string | null {
+  return url?.match(/\/runs\/(?<runId>\d+)/u)?.groups?.runId ?? null;
+}
+
+export function longestCommonPrefix(values: readonly string[]): string {
+  if (values.length === 0) return '';
+  let prefix = values[0];
+  for (const value of values) {
+    let end = 0;
+    while (end < prefix.length && end < value.length && prefix[end] === value[end]) end++;
+    prefix = prefix.slice(0, end);
+    if (prefix === '') break;
+  }
+  return prefix;
+}
+
+export interface PowerTimelineRequest {
+  runId: string;
+  /** RESULT_FILENAME prefix shared by every wanted artifact of the run. */
+  prefix: string;
+  artifacts: string[];
+}
+
+/**
+ * One request per workflow run, narrowed to the common RESULT_FILENAME prefix
+ * of the points' artifacts so a sweep of other models is not downloaded.
+ * Points without a run URL or an audit source plan nothing.
+ */
+export function planPowerTimelineRequests(
+  points: readonly InferenceData[],
+): PowerTimelineRequest[] {
+  const byRun = new Map<string, Set<string>>();
+  for (const point of points) {
+    const runId = runIdFromUrl(point.run_url);
+    const artifact = telemetryArtifactForPoint(point);
+    if (!runId || !artifact) continue;
+    if (!byRun.has(runId)) byRun.set(runId, new Set());
+    byRun.get(runId)!.add(artifact);
+  }
+  return [...byRun.entries()]
+    .toSorted(([a], [b]) => a.localeCompare(b))
+    .map(([runId, artifacts]) => {
+      const names = [...artifacts].toSorted();
+      return {
+        runId,
+        prefix: longestCommonPrefix(names.map((name) => name.slice(ARTIFACT_PREFIX.length))),
+        artifacts: names,
+      };
+    });
+}
+
+/** Run id half of a trace key (`traceKeyForPoint`). */
+export function traceKeyRunId(key: string | null | undefined): string | null {
+  const runId = key?.split(':')[0];
+  return runId || null;
+}
+
+/**
+ * Moves the request for `runId` to the front so it survives the per-chart run
+ * cap; the order of the other requests is kept. Returns the same array when
+ * nothing needs moving.
+ */
+export function prioritizeRun(
+  requests: PowerTimelineRequest[],
+  runId: string | null,
+): PowerTimelineRequest[] {
+  const index = runId ? requests.findIndex((request) => request.runId === runId) : -1;
+  if (index <= 0) return requests;
+  return [requests[index], ...requests.slice(0, index), ...requests.slice(index + 1)];
+}
+
+/**
+ * Moves every request whose run is in `runIds` ahead of the others, keeping
+ * the relative order inside both groups. Unofficial-run overlays are loaded
+ * on purpose, so their telemetry must survive the per-chart run cap before
+ * official rows compete for the remaining slots. Returns the same array when
+ * nothing needs moving.
+ */
+export function prioritizeRuns(
+  requests: PowerTimelineRequest[],
+  runIds: ReadonlySet<string>,
+): PowerTimelineRequest[] {
+  if (runIds.size === 0) return requests;
+  const first = requests.filter((request) => runIds.has(request.runId));
+  if (first.length === 0 || first.length === requests.length) return requests;
+  const rest = requests.filter((request) => !runIds.has(request.runId));
+  const moved = first.some((request, index) => requests[index] !== request);
+  return moved ? [...first, ...rest] : requests;
+}
+
+export interface PowerTimelineTrace {
+  /** `traceKeyForPoint(point)`. */
+  key: string;
+  point: InferenceData;
+  runId: string;
+  series: GpuPowerSeries;
+  /** Validated measurement window (UTC ms) from `power_audit`, when recorded. */
+  windowStartMs: number | null;
+  windowEndMs: number | null;
+}
+
+/**
+ * Why a validated point has no trace:
+ * - `no-source`: the row predates `power_audit.source` (older schema), so no
+ *   artifact can be named;
+ * - `no-run`: no workflow run URL to look in;
+ * - `run-not-fetched`: its run is not among the loaded responses (over the
+ *   per-chart run limit, still loading, or the request failed);
+ * - `not-in-run`: the run was loaded but holds neither a matching
+ *   `gpu_metrics_*` artifact nor a power-audit bundle with the point's
+ *   validation file (expired, over the download cap, or another collector).
+ */
+export type MissingTraceReason = 'no-source' | 'no-run' | 'run-not-fetched' | 'not-in-run';
+
+export interface MissingTrace {
+  point: InferenceData;
+  reason: MissingTraceReason;
+}
+
+export interface PowerTimelineJoin {
+  traces: PowerTimelineTrace[];
+  /** Points with a validated average but no telemetry trace, with the reason. */
+  missing: MissingTrace[];
+}
+
+/** Attaches fetched series to points; order follows `points`. */
+export function joinPowerTimeline(
+  points: readonly InferenceData[],
+  responses: ReadonlyMap<string, GpuPowerSeriesResponse>,
+): PowerTimelineJoin {
+  const traces: PowerTimelineTrace[] = [];
+  const missing: MissingTrace[] = [];
+  for (const point of points) {
+    const runId = runIdFromUrl(point.run_url);
+    const name = telemetryNameForPoint(point);
+    if (!name) {
+      missing.push({ point, reason: 'no-source' });
+      continue;
+    }
+    if (!runId) {
+      missing.push({ point, reason: 'no-run' });
+      continue;
+    }
+    const response = responses.get(runId);
+    if (!response) {
+      missing.push({ point, reason: 'run-not-fetched' });
+      continue;
+    }
+    // A bundle-cut series names the point's validation file; a per-config
+    // CSV artifact names the config itself.
+    const source = `power_validation_${name}.json`;
+    const artifact = `${ARTIFACT_PREFIX}${name}`;
+    const series =
+      response.series.find((entry) => entry.source === source) ??
+      response.series.find((entry) => entry.source === undefined && entry.artifact === artifact);
+    if (!series) {
+      missing.push({ point, reason: 'not-in-run' });
+      continue;
+    }
+    const audit = point.power_audit;
+    traces.push({
+      key: `${runId}:${name}`,
+      point,
+      runId,
+      series,
+      windowStartMs: unixSecondsToMs(audit?.window_start_unix),
+      windowEndMs: unixSecondsToMs(audit?.window_end_unix),
+    });
+  }
+  return { traces, missing };
+}
+
+function unixSecondsToMs(seconds: number | undefined): number | null {
+  return typeof seconds === 'number' && Number.isFinite(seconds) ? seconds * 1000 : null;
+}
+
+/** Sample position relative to the validated window. */
+export type WindowPhase = 'before' | 'window' | 'after' | 'unknown';
+
+export function windowPhase(trace: PowerTimelineTrace, timeMs: number): WindowPhase {
+  if (trace.windowStartMs === null || trace.windowEndMs === null) return 'unknown';
+  if (timeMs < trace.windowStartMs) return 'before';
+  if (timeMs > trace.windowEndMs) return 'after';
+  return 'window';
+}
+
+/** Short config label: `TP8 · c64`, plus `PD` for disaggregated points. */
+export function traceConfigLabel(point: InferenceData): string {
+  const parts: string[] = [];
+  if (point.disagg) parts.push('PD');
+  if (typeof point.tp === 'number' && point.tp > 0) parts.push(`TP${point.tp}`);
+  parts.push(`c${point.conc}`);
+  return parts.join(' · ');
+}
+
+// ── Worker-role pools ────────────────────────────────────────────────────────
+
+export type PowerPoolRole = GpuPowerRole | 'all';
+
+export interface PowerPool {
+  role: PowerPoolRole;
+  /** Row indices into `series.power`, in series order. */
+  rows: number[];
+}
+
+const POOL_ORDER: readonly PowerPoolRole[] = ['all', 'prefill', 'decode'];
+
+/**
+ * The GPU pools of a series by worker role, in `prefill`, `decode` order —
+ * only the roles that have at least one device. A series whose collector
+ * assigns no roles yields no pools; callers fall back to `allGpuPool`.
+ */
+export function tracePools(series: Pick<GpuPowerSeries, 'devices' | 'power'>): PowerPool[] {
+  const rows = new Map<PowerPoolRole, number[]>();
+  series.devices?.forEach((device, row) => {
+    if (!device.role) return;
+    if (!rows.has(device.role)) rows.set(device.role, []);
+    rows.get(device.role)!.push(row);
+  });
+  return POOL_ORDER.filter((role) => rows.has(role)).map((role) => ({
+    role,
+    rows: rows.get(role)!,
+  }));
+}
+
+export interface PoolSizeGroup {
+  size: number;
+  roles: PowerPoolRole[];
+}
+
+/**
+ * Pools that hold the same number of GPUs share one rated ceiling, so their
+ * reference draws once, labelled `prefill / decode ×16`, instead of two labels
+ * printed over each other. Sizes ascending, roles in pool order, deduplicated.
+ */
+export function groupPoolsBySize(
+  pools: readonly Pick<PowerPool, 'role' | 'rows'>[],
+): PoolSizeGroup[] {
+  const bySize = new Map<number, Set<PowerPoolRole>>();
+  for (const pool of pools) {
+    if (!bySize.has(pool.rows.length)) bySize.set(pool.rows.length, new Set());
+    bySize.get(pool.rows.length)!.add(pool.role);
+  }
+  return [...bySize.entries()]
+    .toSorted(([a], [b]) => a - b)
+    .map(([size, roles]) => ({
+      size,
+      roles: POOL_ORDER.filter((role) => roles.has(role)),
+    }));
+}
+
+/**
+ * Label row for each reference line: lines at the same watts (different
+ * hardware with an equal pool ceiling) stack their labels upward, slot 0 on
+ * the line and slot n `n` rows above, instead of overprinting. Input order.
+ */
+export function referenceLabelSlots(lines: readonly { watts: number }[]): number[] {
+  const used = new Map<number, number>();
+  return lines.map((line) => {
+    const slot = used.get(line.watts) ?? 0;
+    used.set(line.watts, slot + 1);
+    return slot;
+  });
+}
+
+/** Every GPU of the series as one pool. */
+export function allGpuPool(series: Pick<GpuPowerSeries, 'power'>): PowerPool {
+  return { role: 'all', rows: series.power.map((_, row) => row) };
+}
+
+// ── Deep link from a pinned scatter tooltip ─────────────────────────────────
+//
+// "View power trace" on a pinned tooltip switches the metric to the Timeline
+// display; the timeline mounts afterwards and reads the requested trace here
+// so it can emphasise that config. Module state rather than URL state: the
+// focus is a one-shot gesture, and the share link stays `i_metric` alone.
+
+let pendingFocus: string | null = null;
+
+export function requestPowerTraceFocus(key: string): void {
+  pendingFocus = key;
+}
+
+/** The pending focus request, cleared on read. */
+export function consumePowerTraceFocus(): string | null {
+  const key = pendingFocus;
+  pendingFocus = null;
+  return key;
+}
diff --git a/packages/app/src/components/inference/utils/role-energy.test.ts b/packages/app/src/components/inference/utils/role-energy.test.ts
new file mode 100644
index 000000000..43f0ed13c
--- /dev/null
+++ b/packages/app/src/components/inference/utils/role-energy.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+
+import { reconstructedRoleEnergy } from './role-energy';
+
+// A disaggregated 8K/1K run: the deployment's energy over the window divided
+// by 8× more input than output tokens, so J/out ÷ J/in = 7.9 = the served ratio.
+const entry = {
+  disagg: true,
+  power_valid: 1,
+  power_metric_schema_version: 2,
+  joules_per_input_token: 1,
+  joules_per_output_token: 7.9,
+  prefill_joules_per_input_token: 0.25,
+  decode_joules_per_output_token: 6,
+};
+
+describe('reconstructedRoleEnergy', () => {
+  it('expresses prefill energy per output token with the served token ratio and sums the roles', () => {
+    expect(reconstructedRoleEnergy(entry)).toEqual({
+      prefill: 1.975,
+      decode: 6,
+      total: 7.975,
+      prefillShare: (100 * 1.975) / 7.975,
+    });
+  });
+
+  it('returns nothing unless the row is validated schema-2 disaggregated telemetry with every role figure', () => {
+    for (const overrides of [
+      { disagg: false },
+      { power_valid: 0 },
+      { power_valid: undefined },
+      { power_metric_schema_version: 1 },
+      { joules_per_input_token: 0 },
+      { joules_per_output_token: Number.NaN },
+      { prefill_joules_per_input_token: undefined },
+      { decode_joules_per_output_token: -1 },
+    ]) {
+      expect(reconstructedRoleEnergy({ ...entry, ...overrides })).toBeUndefined();
+    }
+  });
+});
diff --git a/packages/app/src/components/inference/utils/role-energy.ts b/packages/app/src/components/inference/utils/role-energy.ts
new file mode 100644
index 000000000..89e6b37f2
--- /dev/null
+++ b/packages/app/src/components/inference/utils/role-energy.ts
@@ -0,0 +1,64 @@
+/**
+ * Reconstructs how a disaggregated deployment's request energy splits between
+ * its prefill and decode pools (PowerX Figure 7).
+ *
+ * Schema-2 aggregate energy has one numerator: the deployment's energy over the
+ * validated window is divided by input tokens for `joules_per_input_token` and
+ * by output tokens for `joules_per_output_token`. Their ratio is therefore the
+ * input:output token ratio the benchmark actually served. Multiplying the
+ * prefill pool's J per input token by that ratio expresses the prefill energy
+ * per output token, on the same axis as the decode pool's J per output token.
+ * The two add up to the whole request's J per output token, which equals the
+ * deployment figure whenever the role energies partition the deployment energy.
+ *
+ * Nothing is estimated: every input is a same-window telemetry figure, and the
+ * result is `undefined` whenever one is missing, not validated, or not from a
+ * disaggregated deployment.
+ */
+export interface RoleEnergyInput {
+  disagg?: boolean;
+  power_valid?: number;
+  power_metric_schema_version?: number;
+  joules_per_input_token?: number;
+  joules_per_output_token?: number;
+  prefill_joules_per_input_token?: number;
+  decode_joules_per_output_token?: number;
+}
+
+export interface ReconstructedRoleEnergy {
+  /** Prefill pool energy per output token (J). */
+  prefill: number;
+  /** Decode pool energy per output token (J). */
+  decode: number;
+  /** Prefill + decode (J per output token). */
+  total: number;
+  /** Prefill share of the reconstructed total, in percent. */
+  prefillShare: number;
+}
+
+const positive = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isFinite(value) && value > 0;
+
+export function reconstructedRoleEnergy(
+  entry: RoleEnergyInput,
+): ReconstructedRoleEnergy | undefined {
+  if (!entry.disagg || entry.power_valid !== 1 || entry.power_metric_schema_version !== 2) {
+    return undefined;
+  }
+  const input = entry.joules_per_input_token;
+  const output = entry.joules_per_output_token;
+  const prefill = entry.prefill_joules_per_input_token;
+  const decode = entry.decode_joules_per_output_token;
+  if (!positive(input) || !positive(output) || !positive(prefill) || !positive(decode)) {
+    return undefined;
+  }
+  const prefillPerOutputToken = prefill * (output / input);
+  const total = prefillPerOutputToken + decode;
+  if (!positive(prefillPerOutputToken) || !positive(total)) return undefined;
+  return {
+    prefill: prefillPerOutputToken,
+    decode,
+    total,
+    prefillShare: (100 * prefillPerOutputToken) / total,
+  };
+}
diff --git a/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts b/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
new file mode 100644
index 000000000..1382c594e
--- /dev/null
+++ b/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
@@ -0,0 +1,184 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { HardwareConfig, InferenceData, OverlayData } from '@/components/inference/types';
+import {
+  generateGPUGraphTooltipContent,
+  generateOverlayTooltipContent,
+  generateTooltipContent,
+  showsPowerTraceAction,
+  type OverlayTooltipConfig,
+  type TooltipConfig,
+} from '@/components/inference/utils/tooltipUtils';
+
+// "View power trace" on pinned tooltips: the deep link from a measured-power
+// scatter point to its per-second telemetry on the Timeline display.
+
+const RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34716669498';
+const AUDIT_NAME =
+  'dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc64_b200-host-0123';
+const ACTION = 'data-action="view-power-trace"';
+
+const hardwareConfig = {
+  b200: {
+    name: 'b200',
+    label: 'B200',
+    suffix: '',
+    gpu: 'B200',
+    color: 'blue',
+    power: 1000,
+    costh: 5,
+    costr: 1.25,
+  },
+} as unknown as HardwareConfig;
+
+function measuredPoint(overrides: Partial<InferenceData> = {}): InferenceData {
+  return {
+    id: 980001,
+    date: '2026-09-01',
+    x: 60,
+    y: 600,
+    tp: 8,
+    conc: 64,
+    hwKey: 'b200',
+    precision: 'fp4',
+    benchmark_type: 'single_turn',
+    run_url: RUN_URL,
+    power_audit: { source: `power_validation_${AUDIT_NAME}.json` },
+    tpPerGpu: { y: 400, roof: false },
+    tpPerMw: { y: 50, roof: false },
+    costh: { y: 1, roof: false },
+    costr: { y: 1, roof: false },
+    costhi: { y: 1, roof: false },
+    costri: { y: 1, roof: false },
+    ...overrides,
+  } as InferenceData;
+}
+
+function config(overrides: Partial<TooltipConfig> = {}): TooltipConfig {
+  return {
+    data: measuredPoint(),
+    isPinned: true,
+    xLabel: 'Interactivity (tok/s/user)',
+    yLabel: 'Measured Power per Chip (W)',
+    selectedYAxisMetric: 'y_measuredAvgPower',
+    hardwareConfig,
+    ...overrides,
+  };
+}
+
+function overlayConfig(overrides: Partial<OverlayTooltipConfig> = {}): OverlayTooltipConfig {
+  return {
+    ...config({ data: measuredPoint({ id: 0 }) }),
+    overlayData: {
+      label: 'powerx-timeline',
+      hardwareConfig,
+      data: [],
+      runUrl: RUN_URL,
+    } as unknown as OverlayData,
+    ...overrides,
+  };
+}
+
+describe('showsPowerTraceAction', () => {
+  it('needs a measured metric other than the timeline and a resolvable trace key', () => {
+    const point = measuredPoint();
+    expect(showsPowerTraceAction(point, 'y_measuredAvgPower')).toBe(true);
+    expect(showsPowerTraceAction(point, 'y_measuredJPerOutputToken')).toBe(true);
+    expect(showsPowerTraceAction(point, 'y_measuredPowerTimeline')).toBe(false);
+    expect(showsPowerTraceAction(point, 'y_tpPerGpu')).toBe(false);
+    expect(
+      showsPowerTraceAction(measuredPoint({ power_audit: undefined }), 'y_measuredAvgPower'),
+    ).toBe(false);
+    expect(showsPowerTraceAction(measuredPoint({ run_url: undefined }), 'y_measuredAvgPower')).toBe(
+      false,
+    );
+  });
+});
+
+describe('View power trace tooltip action', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('renders on a pinned measured-power point, after the other point actions', () => {
+    const html = generateTooltipContent(config({ hasLog: true }));
+    expect(html).toContain(`<a ${ACTION}`);
+    expect(html).toContain('View power trace &rarr;');
+    expect(html.indexOf('data-action="view-logs"')).toBeLessThan(html.indexOf(ACTION));
+  });
+
+  it('is absent while hovering (not pinned)', () => {
+    expect(generateTooltipContent(config({ isPinned: false }))).not.toContain(ACTION);
+  });
+
+  it('is absent on non-measured metrics and on the timeline itself', () => {
+    expect(generateTooltipContent(config({ selectedYAxisMetric: 'y_tpPerGpu' }))).not.toContain(
+      ACTION,
+    );
+    expect(
+      generateTooltipContent(config({ selectedYAxisMetric: 'y_measuredPowerTimeline' })),
+    ).not.toContain(ACTION);
+  });
+
+  it('is absent when the point has no telemetry provenance', () => {
+    expect(
+      generateTooltipContent(config({ data: measuredPoint({ power_audit: undefined }) })),
+    ).not.toContain(ACTION);
+    expect(
+      generateTooltipContent(config({ data: measuredPoint({ run_url: undefined }) })),
+    ).not.toContain(ACTION);
+  });
+
+  it('renders alone for a point without persisted id, keeping charts/logs gated on the id', () => {
+    const html = generateTooltipContent(
+      config({ data: measuredPoint({ id: 0 }), hasLog: true, hasTrace: true }),
+    );
+    expect(html).toContain(ACTION);
+    expect(html).not.toContain('data-action="view-logs"');
+    expect(html).not.toContain('data-action="view-charts"');
+    expect(html).toContain('display: grid; gap: 6px; margin-top: 8px;');
+  });
+
+  it('renders on pinned overlay tooltips whose points carry id 0', () => {
+    const html = generateOverlayTooltipContent(overlayConfig());
+    expect(html).toContain(`<a ${ACTION}`);
+    expect(html).toContain('View power trace &rarr;');
+    expect(html).not.toContain('data-action="view-logs"');
+    expect(generateOverlayTooltipContent(overlayConfig({ isPinned: false }))).not.toContain(ACTION);
+    expect(
+      generateOverlayTooltipContent(overlayConfig({ selectedYAxisMetric: 'y_tpPerGpu' })),
+    ).not.toContain(ACTION);
+  });
+
+  it('uses the Chinese label on /zh tooltips', () => {
+    expect(generateTooltipContent(config({ locale: 'zh' }))).toContain('查看功耗曲线 &rarr;');
+    expect(generateOverlayTooltipContent(overlayConfig({ locale: 'zh' }))).toContain(
+      '查看功耗曲线 &rarr;',
+    );
+  });
+
+  it('falls back to "#" without a window and otherwise deep-links the current page to the timeline', () => {
+    expect(generateTooltipContent(config())).toContain(`${ACTION} href="#"`);
+
+    // The address bar is canonicalised by the share-link store: the default
+    // model and the stale metric go, unrelated params stay, the override wins.
+    vi.stubGlobal('window', {
+      location: new URL(
+        'http://localhost:3000/inference?g_model=DeepSeek-V4-Pro&i_metric=y_measuredAvgPower&utm_source=x',
+      ),
+    });
+    const html = generateTooltipContent(config());
+    const href = /data-action="view-power-trace" href="(?<href>[^"]+)"/u.exec(html)?.groups?.href;
+    expect(href).toBeDefined();
+    const url = new URL(href!);
+    expect(url.origin).toBe('http://localhost:3000');
+    expect(url.pathname).toBe('/inference');
+    expect(url.searchParams.get('utm_source')).toBe('x');
+    expect(url.searchParams.has('g_model')).toBe(false);
+    expect(url.searchParams.get('i_metric')).toBe('y_measuredPowerTimeline');
+  });
+
+  it('never renders on the GPU graph tooltip, which has no in-place timeline', () => {
+    expect(generateGPUGraphTooltipContent(config({ hasLog: true }))).not.toContain(ACTION);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/tooltipUtils.ts b/packages/app/src/components/inference/utils/tooltipUtils.ts
index 26626ed04..c770e731a 100644
--- a/packages/app/src/components/inference/utils/tooltipUtils.ts
+++ b/packages/app/src/components/inference/utils/tooltipUtils.ts
@@ -6,6 +6,7 @@ import { isPersistedBenchmarkId } from '@/lib/benchmark-id';
 import { frameworkFamily } from '@/lib/framework-family';
 import type { Locale } from '@/lib/i18n';
 import { isKvOffloadEnabled } from '@/lib/kv-offload';
+import { chartStateHref } from '@/lib/url-state';
 import { chipCounts } from '@/lib/chip-counts';
 import type { SystemPowerUnsupportedReason } from '@/lib/modeled-system-power';
 
@@ -14,6 +15,13 @@ import {
   isMeasuredEnergyConfigKey,
   isModeledSystemPowerConfigKey,
 } from '@/components/inference/metric-registry';
+import { getMeasuredMetricConfig } from '@/components/inference/measured-metric-config';
+import { powerVariantLabel } from '@/components/inference/utils/power-compare';
+import {
+  POWER_TIMELINE_METRIC_KEY,
+  traceKeyForPoint,
+} from '@/components/inference/utils/powerTimeline';
+import { reconstructedRoleEnergy } from '@/components/inference/utils/role-energy';
 import {
   meaningfulParallelismSize,
   parallelismLabel,
@@ -157,6 +165,8 @@ const TOOLTIP_STRINGS = {
     powerCertified: 'Validated (current PowerX method)',
     powerLegacy: 'Historical (not validated under the current method)',
     powerWithheld: 'Measured power withheld',
+    series: 'Series',
+    roleEnergyShare: 'Share of request energy',
   },
   zh: {
     dismiss: '点击其他区域关闭',
@@ -176,9 +186,39 @@ const TOOLTIP_STRINGS = {
     powerCertified: '已验证（采用当前 PowerX 方法）',
     powerLegacy: '历史测量（尚未按当前方法验证）',
     powerWithheld: '实测功耗未采信',
+    series: '系列',
+    roleEnergyShare: '在请求能耗中的占比',
   },
 } as const;
 
+/**
+ * Which comparison series (`i_pcompare`) a point belongs to, for the clones a
+ * boundary / role comparison appends. On the energy axis a role clone also
+ * reports its share of the reconstructed request energy (utils/role-energy.ts).
+ */
+const powerVariantHTML = (
+  d: InferenceData,
+  selectedYAxisMetric: string,
+  locale: Locale,
+): string => {
+  const variant = d.powerVariant;
+  if (!variant) return '';
+  const t = TOOLTIP_STRINGS[locale];
+  let html = tooltipLine(t.series, powerVariantLabel(variant, locale));
+  if (
+    variant.kind === 'role' &&
+    variant.id !== 'all' &&
+    getMeasuredMetricConfig(selectedYAxisMetric)?.family === 'energy'
+  ) {
+    const energy = reconstructedRoleEnergy(d);
+    if (energy) {
+      const share = variant.id === 'prefill' ? energy.prefillShare : 100 - energy.prefillShare;
+      html += tooltipLine(t.roleEnergyShare, `${share.toFixed(1)}%`);
+    }
+  }
+  return html;
+};
+
 const totalChipsHTML = (d: InferenceData, selectedYAxisMetric: string, locale: Locale): string => {
   const t = TOOLTIP_STRINGS[locale];
   const { physical, configured } = chipCounts(
@@ -496,39 +536,91 @@ const generateAgenticHTML = (d: InferenceData, locale: Locale): string => {
 };
 
 const ACTION_STRINGS = {
-  en: { charts: 'View charts', logs: 'View logs' },
-  zh: { charts: '查看图表', logs: '查看日志' },
+  en: { charts: 'View charts', logs: 'View logs', powerTrace: 'View power trace' },
+  zh: { charts: '查看图表', logs: '查看日志', powerTrace: '查看功耗曲线' },
 } as const;
 
-const pointDetailActionLink = (action: 'view-charts' | 'view-logs', href: string, label: string) =>
+type TooltipAction = 'view-charts' | 'view-logs' | 'view-power-trace';
+
+const pointDetailActionLink = (action: TooltipAction, href: string, label: string) =>
   `<a data-action="${action}" href="${href}" style="
     display: block; width: 100%; padding: 4px 8px; font-size: 11px; font-weight: 500;
     border: 1px solid var(--border); border-radius: 6px; cursor: pointer;
     background: var(--accent); color: var(--accent-foreground); text-align: center; text-decoration: none;
   ">${label} &rarr;</a>`;
 
-/** Point-detail links rendered only for persisted, pinned official points. */
-const viewActionsHTML = (
-  isPinned: boolean,
-  hasTraceData: boolean,
-  hasLogData: boolean,
-  pointId: number | undefined,
-  benchmarkType: string | undefined,
-  locale: Locale,
-): string => {
-  const isAgentic = benchmarkType === 'agentic_traces';
-  const showCharts = isAgentic && hasTraceData;
-  if (!isPinned || !isPersistedBenchmarkId(pointId) || (!showCharts && !hasLogData)) return '';
-  const prefix = locale === 'zh' ? '/zh' : '';
-  const agenticHref = agenticDetailHref(pointId, locale);
-  const logHref = isAgentic
-    ? `${agenticHref}${agenticHref.includes('?') ? '&' : '?'}view=logs`
-    : `${prefix}/inference/logs/${pointId}`;
+/**
+ * Whether a point on the measured-power / energy scatter can jump to its
+ * per-second telemetry on the Timeline display. Overlay points qualify too:
+ * the trace is keyed by run id and audit name, not by a persisted row id.
+ */
+export const showsPowerTraceAction = (
+  point: Pick<InferenceData, 'power_audit' | 'run_url'>,
+  selectedYAxisMetric: string,
+): boolean =>
+  selectedYAxisMetric !== POWER_TIMELINE_METRIC_KEY &&
+  getMeasuredMetricConfig(selectedYAxisMetric) !== undefined &&
+  traceKeyForPoint(point) !== null;
+
+/**
+ * Same-tab click is intercepted by the chart (in-page metric switch); the href
+ * keeps open-in-new-tab landing on the Timeline display of THIS chart. The
+ * address bar is stripped of chart state after load, so the share-link store
+ * is layered over the live location first (`chartStateHref`).
+ */
+const powerTraceHref = (): string =>
+  typeof window === 'undefined' ? '#' : chartStateHref({ i_metric: POWER_TIMELINE_METRIC_KEY });
+
+interface ViewActionsInput {
+  isPinned: boolean;
+  hasTraceData: boolean;
+  hasLogData: boolean;
+  point: InferenceData;
+  /**
+   * Metric the chart currently plots, when that chart can switch to the
+   * Timeline display in place (the scatter). Omitted by charts that cannot,
+   * so they never render a "View power trace" link nothing would handle.
+   */
+  powerTraceMetric?: string;
+  locale: Locale;
+}
+
+/**
+ * Point-detail links rendered only on pinned tooltips. "View charts" and
+ * "View logs" need a persisted row id (overlay points have none); "View power
+ * trace" needs only the run and audit source, so it works for overlays too.
+ */
+const viewActionsHTML = ({
+  isPinned,
+  hasTraceData,
+  hasLogData,
+  point,
+  powerTraceMetric,
+  locale,
+}: ViewActionsInput): string => {
+  if (!isPinned) return '';
   const t = ACTION_STRINGS[locale];
-  const actions = [
-    showCharts ? pointDetailActionLink('view-charts', agenticHref, t.charts) : '',
-    hasLogData ? pointDetailActionLink('view-logs', logHref, t.logs) : '',
-  ].filter(Boolean);
+  const actions: string[] = [];
+  const pointId = point.id;
+  const isAgentic = point.benchmark_type === 'agentic_traces';
+  const showCharts = isAgentic && hasTraceData;
+  if (isPersistedBenchmarkId(pointId) && (showCharts || hasLogData)) {
+    const prefix = locale === 'zh' ? '/zh' : '';
+    const agenticHref = agenticDetailHref(pointId, locale);
+    if (showCharts) {
+      actions.push(pointDetailActionLink('view-charts', agenticHref, t.charts));
+    }
+    if (hasLogData) {
+      const logHref = isAgentic
+        ? `${agenticHref}${agenticHref.includes('?') ? '&' : '?'}view=logs`
+        : `${prefix}/inference/logs/${pointId}`;
+      actions.push(pointDetailActionLink('view-logs', logHref, t.logs));
+    }
+  }
+  if (powerTraceMetric !== undefined && showsPowerTraceAction(point, powerTraceMetric)) {
+    actions.push(pointDetailActionLink('view-power-trace', powerTraceHref(), t.powerTrace));
+  }
+  if (actions.length === 0) return '';
   return `<div style="display: grid; gap: 6px; margin-top: 8px;">${actions.join('')}</div>`;
 };
 
@@ -711,6 +803,7 @@ export const generateTooltipContent = (config: TooltipConfig): string => {
           : ''
       }
       ${powerTierHTML(d, selectedYAxisMetric, locale)}
+      ${powerVariantHTML(d, selectedYAxisMetric, locale)}
       ${modeledSystemPowerHTML(d, selectedYAxisMetric, isPinned, locale)}
       ${totalChipsHTML(d, selectedYAxisMetric, locale)}
       ${generateParallelismHTML(d, locale)}
@@ -721,7 +814,14 @@ export const generateTooltipContent = (config: TooltipConfig): string => {
       ${generateAgenticHTML(d, locale)}
       ${generateWorkerPowerHTML(d, isPinned, locale)}
       ${runLinkHTML(runUrl, locale)}
-      ${viewActionsHTML(isPinned, Boolean(hasTrace), Boolean(config.hasLog), d.id, d.benchmark_type, locale)}
+      ${viewActionsHTML({
+        isPinned,
+        hasTraceData: Boolean(hasTrace),
+        hasLogData: Boolean(config.hasLog),
+        point: d,
+        powerTraceMetric: selectedYAxisMetric,
+        locale,
+      })}
     </div>
   `;
 };
@@ -755,6 +855,7 @@ export const generateOverlayTooltipContent = (config: OverlayTooltipConfig): str
       ${tooltipLine(xLabel, fmt(d.x))}
       ${tooltipLine(yLabel, fmt(d.y))}
       ${powerTierHTML(d, selectedYAxisMetric, locale)}
+      ${powerVariantHTML(d, selectedYAxisMetric, locale)}
       ${modeledSystemPowerHTML(d, selectedYAxisMetric, isPinned, locale)}
       ${totalChipsHTML(d, selectedYAxisMetric, locale)}
       ${generateParallelismHTML(d, locale)}
@@ -764,6 +865,14 @@ export const generateOverlayTooltipContent = (config: OverlayTooltipConfig): str
       ${powerWithheldHTML(d, locale)}
       ${generateAgenticHTML(d, locale)}
       ${generateWorkerPowerHTML(d, isPinned, locale)}
+      ${viewActionsHTML({
+        isPinned,
+        hasTraceData: false,
+        hasLogData: false,
+        point: d,
+        powerTraceMetric: selectedYAxisMetric,
+        locale,
+      })}
     </div>
   `;
 };
@@ -816,6 +925,7 @@ export const generateGPUGraphTooltipContent = (config: TooltipConfig): string =>
           : ''
       }
       ${powerTierHTML(d, selectedYAxisMetric, locale)}
+      ${powerVariantHTML(d, selectedYAxisMetric, locale)}
       ${modeledSystemPowerHTML(d, selectedYAxisMetric, isPinned, locale)}
       ${totalChipsHTML(d, selectedYAxisMetric, locale)}
       ${generateParallelismHTML(d, locale)}
@@ -826,7 +936,13 @@ export const generateGPUGraphTooltipContent = (config: TooltipConfig): string =>
       ${generateAgenticHTML(d, locale)}
       ${generateWorkerPowerHTML(d, isPinned, locale)}
       ${runLinkHTML(runUrl, locale)}
-      ${viewActionsHTML(isPinned, Boolean(hasTrace), Boolean(hasLog), d.id, d.benchmark_type, locale)}
+      ${viewActionsHTML({
+        isPinned,
+        hasTraceData: Boolean(hasTrace),
+        hasLogData: Boolean(hasLog),
+        point: d,
+        locale,
+      })}
     </div>
   `;
 };
diff --git a/packages/app/src/components/tab-nav.tsx b/packages/app/src/components/tab-nav.tsx
index fbc9066ad..a3ef979c4 100644
--- a/packages/app/src/components/tab-nav.tsx
+++ b/packages/app/src/components/tab-nav.tsx
@@ -47,6 +47,8 @@ const TAB_LABELS_EN: Record<DashboardRouteKey, string> = {
   historical: 'Historical Trends',
   calculator: 'TCO Calculator',
   fleet: 'Fleet Lifecycle',
+  'first-token': 'First-Token Limits',
+  'cache-reuse': 'Prefix Cache Reuse',
   'profit-estimator': 'Profit Estimator',
   'profit-estimator-per-gigawatt': 'Profit Estimator per GW',
   reliability: 'Reliability',
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 6f090ad9f..258ad7a6a 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -68,10 +68,10 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'ui-artifact-read',
     exclusionReason: {
-      en: 'UI-only PowerX explorer read for one run: the ingest-time telemetry digest when stored, otherwise the live GPU metric artifacts. Its payload shape is not a stable public contract.',
-      zh: '仅供 PowerX 探索界面按 run 读取：已入库时返回 ingest 阶段生成的 telemetry 摘要，否则回退到实时 GPU 指标制品。其返回结构不是稳定的公开契约。',
+      en: 'UI-only PowerX read for one run: the ingest-time telemetry digest when stored, otherwise the live GPU telemetry artifacts (raw `gpu_metrics_*` rows, or `series=power` one-second buckets for the PowerX timeline, also cut per validation window from `power_audit_*` bundles). Its payload shape is not a stable public contract.',
+      zh: '仅供 PowerX 界面按 run 读取：已入库时返回 ingest 阶段生成的 telemetry 摘要，否则回退到实时 GPU 遥测制品（`gpu_metrics_*` 原始行，或供 PowerX 时间线使用的 `series=power` 一秒分桶数据，后者也会按验证窗口从 `power_audit_*` bundle 中切分得到）。其返回结构不是稳定的公开契约。',
     },
-    sourceSha256: '01d604d77ea73e252f0934f88d14d0e229a803d1b9b1d72bd9756658c506b349',
+    sourceSha256: '4d387298f0311a91c319548119382646045fff6cccdf4e871adf89b39a6feee1',
   },
   {
     source: 'src/app/api/openapi.json/route.ts',
@@ -753,7 +753,10 @@ export const apiContractSourceDigests = [
     // Reviewed again for the release-date corrections: values inside
     // MODEL_RELEASE_DATES only. No published model name, alias, or parameter enum
     // is touched, and no endpoint exposes a release date, so the docs stand.
-    sourceSha256: 'bb58d43160c2b83ce61e7c34326a6d316fd751e435c6819f1991ed69e4f1b45c',
+    // Reviewed for the Qwen3.8-27B addition (InferenceX#3260): two new DB keys
+    // and display names plus their release dates. No published parameter enum
+    // or endpoint changes, so the docs stand.
+    sourceSha256: 'af1053b2ae94b50de51153153dd7a7e268e50bde3e5900310e44f2d8baa86f87',
     reviewArea: {
       en: 'Published benchmark and TCO model names, aliases, and parameter enums.',
       zh: '已发布基准与 TCO 模型名称、别名和参数枚举。',
diff --git a/packages/app/src/lib/benchmark-api-view.test.ts b/packages/app/src/lib/benchmark-api-view.test.ts
index c74397c99..e840244cc 100644
--- a/packages/app/src/lib/benchmark-api-view.test.ts
+++ b/packages/app/src/lib/benchmark-api-view.test.ts
@@ -48,6 +48,36 @@ describe('toCalculatorBenchmarkRows', () => {
     ]);
   });
 
+  it('keeps time to first token at the percentiles the calculator pages read', () => {
+    // The First-Token Limits page caps rows on TTFT through this same view;
+    // without these the page would have nothing to cap. p99 stays out like the
+    // other p99 latency metrics.
+    const [row] = toCalculatorBenchmarkRows(
+      [
+        {
+          benchmark_type: 'agentic_traces',
+          isl: null,
+          osl: null,
+          metrics: {
+            tput_per_gpu: 100,
+            median_ttft: 0.5,
+            p75_ttft: 0.9,
+            p90_ttft: 1.4,
+            p99_ttft: 6,
+            mean_ttft: 0.7,
+          },
+        },
+      ],
+      'agentic-traces',
+    );
+    expect(row.metrics).toEqual({
+      tput_per_gpu: 100,
+      median_ttft: 0.5,
+      p75_ttft: 0.9,
+      p90_ttft: 1.4,
+    });
+  });
+
   it('strips workers and the power audit provenance from the payload-trimmed view', () => {
     const [row] = toCalculatorBenchmarkRows(rows, '1k/1k');
     expect(row).not.toHaveProperty('workers');
diff --git a/packages/app/src/lib/benchmark-api-view.ts b/packages/app/src/lib/benchmark-api-view.ts
index c6ef2a8b4..4b1bd19d0 100644
--- a/packages/app/src/lib/benchmark-api-view.ts
+++ b/packages/app/src/lib/benchmark-api-view.ts
@@ -18,8 +18,10 @@ const CALCULATOR_METRIC_KEYS = new Set([
   // GB300 AgentX rows without a server measurement price cached input from the
   // trace's theoretical ceiling instead. See `pricingCacheHitRate`.
   'theoretical_cache_hit_rate',
+  // `ttft` feeds the First-Token Limits page, which reads this same view and
+  // caps rows on time to first token at the percentile `intvty` uses.
   ...['median', 'p75', 'p90'].flatMap((percentile) =>
-    ['intvty', 'itl', 'full_response_itl', 'e2el', 'ttlt'].map(
+    ['intvty', 'itl', 'full_response_itl', 'e2el', 'ttlt', 'ttft'].map(
       (metric) => `${percentile}_${metric}`,
     ),
   ),
diff --git a/packages/app/src/lib/cache-reuse-link.test.ts b/packages/app/src/lib/cache-reuse-link.test.ts
new file mode 100644
index 000000000..5ad6d2172
--- /dev/null
+++ b/packages/app/src/lib/cache-reuse-link.test.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+
+import type { PointMeta } from '@/hooks/api/use-trace-server-metrics';
+
+import { cacheReuseHref, pointHardwareKey } from './cache-reuse-link';
+
+const point: PointMeta = {
+  id: 206885,
+  hardware: 'b200',
+  framework: 'sglang',
+  model: 'glm5.2',
+  precision: 'fp4',
+  spec_method: 'none',
+  disagg: false,
+  is_multinode: false,
+  conc: 8,
+  offload_mode: 'on',
+  kv_offloading: 'dram',
+  kv_offload_backend: 'hicache',
+  kv_offload_backend_version: null,
+  kv_p2p_transfer: null,
+  router_name: null,
+  router_version: null,
+  isl: null,
+  osl: null,
+  benchmark_type: 'agentic_traces',
+  date: '2026-09-17',
+  run_url: null,
+  server_gpu_cache_hit_rate: 0.903,
+  server_cpu_cache_hit_rate: 0.06,
+};
+
+describe('cacheReuseHref', () => {
+  it('opens the tab under the reader locale and carries the chart state', () => {
+    expect(cacheReuseHref('en')).toBe('/cache-reuse');
+    expect(cacheReuseHref('zh')).toBe('/zh/cache-reuse');
+  });
+
+  it('pins a point to its own model, scenario, and configuration', () => {
+    const url = new URL(cacheReuseHref('zh', point), 'https://inferencex.test');
+    expect(url.pathname).toBe('/zh/cache-reuse');
+    expect(url.searchParams.get('g_model')).toBe('GLM-5.2');
+    expect(url.searchParams.get('i_seq')).toBe('agentic-traces');
+    expect(url.searchParams.get('i_prec')).toBe('fp4');
+    expect(url.searchParams.get('c_cfg')).toBe('b200_sglang');
+  });
+
+  it('leaves unknown model buckets and precisions to the store', () => {
+    const url = new URL(
+      cacheReuseHref('en', { ...point, model: 'mystery', precision: 'fp6' }),
+      'https://x.test',
+    );
+    expect(url.searchParams.has('g_model')).toBe(false);
+    expect(url.searchParams.has('i_prec')).toBe(false);
+    expect(url.searchParams.get('c_cfg')).toBe('b200_sglang');
+  });
+});
+
+describe('pointHardwareKey', () => {
+  it('resolves a disaggregated point to the same series key the chart uses', () => {
+    expect(
+      pointHardwareKey({ ...point, hardware: 'gb200', framework: 'dynamo-vllm', disagg: true }),
+    ).toBe('gb200_dynamo-vllm');
+  });
+
+  it('never folds the speculative method into an agentic key', () => {
+    expect(pointHardwareKey({ ...point, spec_method: 'mtp' })).toBe('b200_sglang');
+  });
+});
diff --git a/packages/app/src/lib/cache-reuse-link.ts b/packages/app/src/lib/cache-reuse-link.ts
new file mode 100644
index 000000000..2520071d8
--- /dev/null
+++ b/packages/app/src/lib/cache-reuse-link.ts
@@ -0,0 +1,45 @@
+import { DB_MODEL_TO_DISPLAY } from '@semianalysisai/inferencex-constants';
+
+import type { PointMeta } from '@/hooks/api/use-trace-server-metrics';
+import type { AggDataEntry } from '@/components/inference/types';
+import { getHardwareKey } from '@/lib/chart-utils';
+import { PRECISION_OPTIONS, Sequence } from '@/lib/data-mappings';
+import { localePath, type Locale } from '@/lib/i18n';
+import { withChartState } from '@/lib/url-state';
+
+/**
+ * In-app href for the Prefix Cache Reuse tab from an agentic chart or point.
+ *
+ * From the chart, the current filters ride along through `withChartState` so
+ * the tab opens on the same model, scenario, and precisions. From a point
+ * detail page the reader may have landed cold (no in-memory chart state), so
+ * the point's own model, precision, and configuration are written explicitly;
+ * they win over whatever the store still holds because `URLSearchParams.set`
+ * replaces. The precision must be pinned to one value: with several selected,
+ * the tab keys its groups as `hwKey__precision` and a bare `c_cfg` would miss.
+ */
+export function cacheReuseHref(locale: Locale, point?: PointMeta): string {
+  const href = withChartState(localePath('/cache-reuse', locale));
+  if (!point) return href;
+  const [path, search = ''] = href.split('?');
+  const params = new URLSearchParams(search);
+  const model = DB_MODEL_TO_DISPLAY[point.model];
+  if (model) params.set('g_model', model);
+  params.set('i_seq', Sequence.AgenticTraces);
+  if ((PRECISION_OPTIONS as readonly string[]).includes(point.precision)) {
+    params.set('i_prec', point.precision);
+  }
+  params.set('c_cfg', pointHardwareKey(point));
+  return `${path}?${params.toString()}`;
+}
+
+/** The chart-series key of a point, as the calculator groups it. */
+export function pointHardwareKey(point: PointMeta): string {
+  return getHardwareKey({
+    hw: point.hardware,
+    framework: point.framework,
+    disagg: point.disagg,
+    benchmark_type: point.benchmark_type,
+    spec_decoding: point.spec_method,
+  } as unknown as AggDataEntry);
+}
diff --git a/packages/app/src/lib/chart-utils.test.ts b/packages/app/src/lib/chart-utils.test.ts
index ecac454c6..70c43f710 100644
--- a/packages/app/src/lib/chart-utils.test.ts
+++ b/packages/app/src/lib/chart-utils.test.ts
@@ -889,6 +889,19 @@ describe('buildDerivedChartFields', () => {
     expect(historicalFields.measuredJPerTotalToken).toBeUndefined();
     expect(Object.keys(historicalFields)).toEqual(['tpPerGpu']);
   });
+
+  it('emits only the requested power-boundary fields and skips unavailable ones', () => {
+    // No output throughput and no telemetry: only the spec watts can be derived.
+    const historicalFields = buildDerivedChartFields(entry(), 'h100', [
+      'tpPerGpu',
+      'gpuProvisionedWatts',
+      'gpuProvisionedJPerOutputToken',
+      'utilityModeledWatts',
+    ]);
+
+    expect(Object.keys(historicalFields)).toEqual(['tpPerGpu', 'gpuProvisionedWatts']);
+    expect(historicalFields.gpuProvisionedWatts).toEqual({ y: 700, roof: false });
+  });
 });
 
 // ===========================================================================
@@ -985,6 +998,143 @@ describe('createChartDataPoint energy fields', () => {
   });
 });
 
+// ===========================================================================
+// createChartDataPoint — power-boundary fields (B2 GPU provisioned, B3 utility
+// provisioned, B4 utility modeled). Mock specs: tdp 700 W, power 700 "kW".
+// ===========================================================================
+const boundaryPoint = (e: AggDataEntry) =>
+  createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
+
+describe('createChartDataPoint power-boundary fields', () => {
+  // Eight measured GPUs (2 prefill + 6 decode) on two partially filled chassis:
+  // the model evaluates 16 GPUs, so only deploymentFacilityWatts ÷ gpuCount yields 877.5 W.
+  // Every other numerator/denominator pairing gives a different number.
+  const supportedModel = {
+    status: 'supported' as const,
+    hardware: 'h100',
+    modelRevision: 'test',
+    modelPath: 'test',
+    gpuCount: 8,
+    chassisCount: 2,
+    modeledGpuCount: 16,
+    measuredGpuWattsPerGpu: 500,
+    chassisAcWatts: 10_400,
+    chassisAcWattsPerGpu: 650,
+    facilityWatts: 13_520,
+    deploymentAcWatts: 5400,
+    deploymentFacilityWatts: 7020,
+    pue: 1.3,
+    telemetryBasis: 'validated-v2' as const,
+    topologyBasis: 'worker-hosts' as const,
+    chassisBasis: 'extrapolated' as const,
+  };
+  const validated = {
+    power_valid: 1,
+    power_metric_schema_version: 2,
+    avg_power_w: 500,
+    joules_per_output_token: 10,
+    modeledSystemPower: supportedModel,
+  };
+  it('emits all six boundary fields for a validated official row', () => {
+    const p = boundaryPoint(
+      entry({ output_tput_per_gpu: 400, benchmark_type: 'single_turn', ...validated }),
+    );
+    expect(p.gpuProvisionedWatts).toEqual({ y: 700, roof: false });
+    expect(p.gpuProvisionedJPerOutputToken?.y).toBeCloseTo(700 / 400, 10);
+    expect(p.utilityProvisionedWatts).toEqual({ y: 700_000, roof: false });
+    expect(p.utilityProvisionedJPerOutputToken?.y).toBeCloseTo(700_000 / 400, 10);
+    // B4 W = deployment facility ÷ measured GPUs; J scales B1 by B4 W ÷ B1 W.
+    expect(p.utilityModeledWatts).toEqual({ y: 877.5, roof: false });
+    expect(p.utilityModeledJPerOutputToken?.y).toBeCloseTo((10 * 877.5) / 500, 10);
+    // Existing measured (B1) fields are untouched by the new boundaries.
+    expect(p.measuredAvgPower).toEqual({ y: 500, roof: false });
+    expect(p.measuredJPerOutputToken).toEqual({ y: 10, roof: false });
+  });
+
+  // The ?unofficialrun= overlay seam (transformBenchmarkRows(rows, 'median',
+  // 'external') vs the official derivation) is asserted in power-basis.test.ts,
+  // where real BenchmarkRow fixtures and HW_REGISTRY specs are available.
+
+  it('omits provisioned energies when output throughput is missing, keeps spec watts and B1-scaled modeled energy', () => {
+    const p = boundaryPoint(
+      entry({ output_tput_per_gpu: 0, benchmark_type: 'single_turn', ...validated }),
+    );
+    expect(p.gpuProvisionedWatts?.y).toBe(700);
+    expect(p.utilityProvisionedWatts?.y).toBe(700_000);
+    expect(p.utilityModeledWatts?.y).toBe(877.5);
+    expect(p.gpuProvisionedJPerOutputToken).toBeUndefined();
+    expect(p.utilityProvisionedJPerOutputToken).toBeUndefined();
+    expect('gpuProvisionedJPerOutputToken' in p).toBe(false);
+    expect('utilityProvisionedJPerOutputToken' in p).toBe(false);
+    // Modeled energy inherits B1's token denominator, so it survives.
+    expect(p.utilityModeledJPerOutputToken?.y).toBeCloseTo(17.55, 10);
+  });
+
+  it('normalizes fixed-sequence disaggregated energy by all GPUs while jOutput stays per decode GPU', () => {
+    const p = boundaryPoint(
+      entry({
+        output_tput_per_gpu: 400,
+        disagg: true,
+        benchmark_type: 'single_turn',
+        num_prefill_gpu: 4,
+        num_decode_gpu: 4,
+      }),
+    );
+    expect(p.gpuProvisionedJPerOutputToken?.y).toBeCloseTo((700 * 8) / (400 * 4), 10);
+    expect(p.utilityProvisionedJPerOutputToken?.y).toBeCloseTo((700_000 * 8) / (400 * 4), 10);
+    expect(p.jOutput?.y).toBeCloseTo(700_000 / 400, 10);
+    expect(p.utilityProvisionedJPerOutputToken?.y).toBeCloseTo(2 * p.jOutput!.y, 10);
+
+    const agentic = boundaryPoint(
+      entry({
+        output_tput_per_gpu: 400,
+        disagg: true,
+        benchmark_type: 'agentic_traces',
+        num_prefill_gpu: 4,
+        num_decode_gpu: 4,
+      }),
+    );
+    expect(agentic.gpuProvisionedWatts?.y).toBe(700);
+    expect(agentic.gpuProvisionedJPerOutputToken).toBeUndefined();
+    expect(agentic.utilityProvisionedJPerOutputToken).toBeUndefined();
+  });
+
+  it('omits the modeled boundary without a supported model or without B1 watts', () => {
+    const unsupported = boundaryPoint(
+      entry({
+        output_tput_per_gpu: 400,
+        ...validated,
+        modeledSystemPower: { status: 'unsupported', reason: 'hardware', modelRevision: 'test' },
+      }),
+    );
+    expect(unsupported.utilityModeledWatts).toBeUndefined();
+    expect(unsupported.utilityModeledJPerOutputToken).toBeUndefined();
+    expect(unsupported.utilityProvisionedJPerOutputToken).toBeDefined();
+
+    // Admission belongs to the model, not to the schema marker: a validated
+    // unversioned single-node row the model accepted renders B4 alongside B1.
+    const legacy = boundaryPoint(
+      entry({ output_tput_per_gpu: 400, ...validated, power_metric_schema_version: undefined }),
+    );
+    expect(legacy.measuredAvgPower?.y).toBe(500);
+    expect(legacy.modeledChassisPowerPerGpu?.y).toBe(650);
+    expect(legacy.utilityModeledWatts?.y).toBe(877.5);
+    expect(legacy.utilityModeledJPerOutputToken?.y).toBeCloseTo(17.55, 10);
+
+    // B4 is B1 scaled to the meter, so it needs B1's watts even with a model.
+    const noB1 = boundaryPoint(
+      entry({ output_tput_per_gpu: 400, ...validated, avg_power_w: undefined }),
+    );
+    expect(noB1.measuredAvgPower).toBeUndefined();
+    expect(noB1.utilityModeledWatts).toBeUndefined();
+    expect(noB1.utilityModeledJPerOutputToken).toBeUndefined();
+
+    const noTelemetry = boundaryPoint(entry({ output_tput_per_gpu: 400 }));
+    expect(noTelemetry.utilityModeledWatts).toBeUndefined();
+    expect(noTelemetry.gpuProvisionedJPerOutputToken?.y).toBeCloseTo(1.75, 10);
+  });
+});
+
 // ===========================================================================
 // createChartDataPoint — measured power / energy fields (from runner telemetry)
 // ===========================================================================
@@ -1205,6 +1355,32 @@ describe('createChartDataPoint per-stage measured power fields', () => {
     expect(point.measuredDecodeJPerOutputToken).toBeDefined();
     expect(point.measuredDecodeJPerOutputToken!.y).toBe(0);
   });
+
+  it('carries the prefill pool energy onto the output-token axis for validated disaggregated rows', () => {
+    const e = entry({
+      disagg: true,
+      power_valid: 1,
+      power_metric_schema_version: 2,
+      joules_per_input_token: 0.3,
+      joules_per_output_token: 2.4,
+      prefill_joules_per_input_token: 0.1,
+      decode_joules_per_output_token: 1.6,
+    });
+    const point = createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
+    // 0.1 J/in × (2.4 ÷ 0.3 = 8 input tokens per output token) = 0.8 J/out,
+    // which with the decode pool's 1.6 J/out reconstructs the 2.4 J/out total.
+    expect(point.reconstructedPrefillJPerOutputToken!.y).toBeCloseTo(0.8, 12);
+    expect(point.reconstructedPrefillJPerOutputToken!.roof).toBe(false);
+    // Aggregate rows have no pools to split.
+    const aggregate = createChartDataPoint(
+      '2025-01-01',
+      entry({ ...e, disagg: false }),
+      'median_e2el',
+      'tput_per_gpu',
+      'h100',
+    );
+    expect(aggregate.reconstructedPrefillJPerOutputToken).toBeUndefined();
+  });
 });
 
 // ===========================================================================
diff --git a/packages/app/src/lib/chart-utils.ts b/packages/app/src/lib/chart-utils.ts
index e94032342..78b62b2d8 100644
--- a/packages/app/src/lib/chart-utils.ts
+++ b/packages/app/src/lib/chart-utils.ts
@@ -11,6 +11,7 @@ import type {
   AggDataEntry,
   ChartDefinition,
   InferenceData,
+  PowerBasisFieldKey,
   YAxisMetricKey,
 } from '@/components/inference/types';
 import {
@@ -20,6 +21,8 @@ import {
 import { DEFAULT_TCO_BASIS, getGpuSpecs, isKnownGpu, type TcoBasis } from '@/lib/constants';
 import { getVendor, type Vendor } from '@/lib/dynamic-colors';
 import type { Locale } from '@/lib/i18n';
+import { buildPowerBasisChartFields, type PowerBasisChartFields } from '@/lib/power-basis';
+import { reconstructedRoleEnergy } from '@/components/inference/utils/role-energy';
 
 // ---------------------------------------------------------------------------
 // High-contrast color generation (iwanthue — k-means in CIELab)
@@ -289,7 +292,13 @@ export function buildAvailabilityHwKey(
   return hwKey;
 }
 
-export type DerivedMetricKey = BenchmarkMetricKey;
+// Power-boundary fields are derived here before the registry exposes them as
+// axes; the union collapses once METRIC_REGISTRY carries the same keys. The
+// reconstructed prefill energy is a comparison-only series (never an axis).
+export type DerivedMetricKey =
+  | BenchmarkMetricKey
+  | PowerBasisFieldKey
+  | 'reconstructedPrefillJPerOutputToken';
 export type DerivedChartFields = Pick<InferenceData, DerivedMetricKey>;
 
 const chartMetric = (y: number): { y: number; roof: boolean } => ({ y, roof: false });
@@ -411,6 +420,11 @@ export function buildDerivedChartFields(
       hardwarePower && tputPerGpu ? (hardwarePower * 1000) / tputPerGpu : 0,
     );
   }
+  // jOutput keeps the historical per-GPU normalization: for disaggregated rows
+  // output_tput_per_gpu is per decode GPU, so this is all-in W of one decode GPU
+  // per output token and ignores the prefill pool. The power-boundary field
+  // utilityProvisionedJPerOutputToken uses the same all-in W but counts every
+  // allocated GPU, so the two differ on disaggregated rows by (P + D) / D.
   if (hardwarePower > 0 && wants('jOutput') && outputTputPerGpu) {
     fields.jOutput = chartMetric(hardwarePower ? (hardwarePower * 1000) / outputTputPerGpu : 0);
   }
@@ -426,6 +440,14 @@ export function buildDerivedChartFields(
     if (wants(key)) fields[key] = value;
   }
 
+  const powerBasis = buildPowerBasisChartFields(entry, specs);
+  for (const [key, value] of Object.entries(powerBasis) as [
+    keyof PowerBasisChartFields,
+    { y: number; roof: boolean },
+  ][]) {
+    if (wants(key)) fields[key] = value;
+  }
+
   if (wants('modeledChassisPowerPerGpu') && entry.modeledSystemPower?.status === 'supported') {
     fields.modeledChassisPowerPerGpu = chartMetric(entry.modeledSystemPower.chassisAcWattsPerGpu);
   }
@@ -521,6 +543,8 @@ type MeasuredPowerChartFields = Partial<
     | 'measuredJPerSuccessfulQuery'
     | 'measuredWhPerSuccessfulQuery'
     | 'measuredPowerPercentTdp'
+    | 'measuredPowerTimeline'
+    | 'reconstructedPrefillJPerOutputToken'
   >
 >;
 
@@ -530,8 +554,13 @@ function buildMeasuredPowerChartFields(
   tdpWatts: number,
 ): MeasuredPowerChartFields {
   return {
+    // The timeline axis aliases the validated average: the point set (and
+    // its table row) is the same, only the chart body changes.
     ...(typeof entry.avg_power_w === 'number'
-      ? { measuredAvgPower: chartMetric(entry.avg_power_w) }
+      ? {
+          measuredAvgPower: chartMetric(entry.avg_power_w),
+          measuredPowerTimeline: chartMetric(entry.avg_power_w),
+        }
       : {}),
     ...(typeof entry.p75_power_w === 'number' && Number.isFinite(entry.p75_power_w)
       ? { measuredP75Power: chartMetric(entry.p75_power_w) }
@@ -562,6 +591,14 @@ function buildMeasuredPowerChartFields(
     ...(typeof entry.decode_joules_per_output_token === 'number'
       ? { measuredDecodeJPerOutputToken: chartMetric(entry.decode_joules_per_output_token) }
       : {}),
+    // Prefill energy on the output-token axis, so the roles comparison can
+    // stack it against the decode pool (PowerX Figure 7).
+    ...(() => {
+      const roleEnergy = reconstructedRoleEnergy(entry);
+      return roleEnergy
+        ? { reconstructedPrefillJPerOutputToken: chartMetric(roleEnergy.prefill) }
+        : {};
+    })(),
     ...(typeof entry.joules_per_successful_query === 'number'
       ? {
           measuredJPerSuccessfulQuery: chartMetric(entry.joules_per_successful_query),
diff --git a/packages/app/src/lib/compare-slug.test.ts b/packages/app/src/lib/compare-slug.test.ts
index c5744203b..f3ab5a02a 100644
--- a/packages/app/src/lib/compare-slug.test.ts
+++ b/packages/app/src/lib/compare-slug.test.ts
@@ -274,6 +274,8 @@ describe('compareModelSeoName', () => {
     'minimax-m3': 'MiniMax M3',
     'minimax-m27': 'MiniMax M2.7',
     'qwen-3-8-flash-next': 'Qwen3.8-Flash-Next',
+    'qwen-3-8-27b': 'Qwen3.8-27B',
+    'qwen-3-8-27b-eager': 'Qwen3.8-27B Eager',
     'qwen-3-5': 'Qwen3.5',
     'gptoss-120b': 'gpt-oss-120b',
     'llama-3-3-70b': 'Llama 3.3 70B',
diff --git a/packages/app/src/lib/compare-slug.ts b/packages/app/src/lib/compare-slug.ts
index 59930956c..3619198c4 100644
--- a/packages/app/src/lib/compare-slug.ts
+++ b/packages/app/src/lib/compare-slug.ts
@@ -141,6 +141,22 @@ export const COMPARE_MODEL_SLUGS: CompareModelSlug[] = [
     label: 'Qwen 3.8 Flash Next 176B-A6B',
     seoName: 'Qwen3.8-Flash-Next',
   },
+  {
+    slug: 'qwen-3-8-27b',
+    displayName: 'Qwen3.8-27B',
+    dbKeys: ['qwen3.827b'],
+    // Dense 27B: total and active parameter counts coincide.
+    label: 'Qwen 3.8 27B',
+    seoName: 'Qwen3.8-27B',
+  },
+  {
+    slug: 'qwen-3-8-27b-eager',
+    displayName: 'Qwen3.8-27B-Eager',
+    dbKeys: ['qwen3.827beager'],
+    // Same checkpoint with CUDA graphs disabled; kept as its own bucket.
+    label: 'Qwen 3.8 27B (eager)',
+    seoName: 'Qwen3.8-27B Eager',
+  },
   {
     slug: 'qwen-3-5',
     displayName: 'Qwen-3.5-397B-A17B',
diff --git a/packages/app/src/lib/compare-ssr.ts b/packages/app/src/lib/compare-ssr.ts
index a1f8a346f..9365caa6f 100644
--- a/packages/app/src/lib/compare-ssr.ts
+++ b/packages/app/src/lib/compare-ssr.ts
@@ -49,6 +49,8 @@ export const KNOWN_MODELS = new Set([
   'gpt-oss-120b',
   'Qwen-3.5-397B-A17B',
   'Qwen3.8-Flash-Next',
+  'Qwen3.8-27B',
+  'Qwen3.8-27B-Eager',
   'Kimi-K2.5',
   'Kimi-K3',
   'MiniMax-M2.5',
diff --git a/packages/app/src/lib/csv-export-helpers.test.ts b/packages/app/src/lib/csv-export-helpers.test.ts
index b850da5b3..467115ae6 100644
--- a/packages/app/src/lib/csv-export-helpers.test.ts
+++ b/packages/app/src/lib/csv-export-helpers.test.ts
@@ -749,3 +749,33 @@ describe('historicalTrendToCsv (mirrors HistoricalTrendsDisplay export)', () =>
     expect(rows[1][headers.indexOf('Date')]).toBe('2025-01-15');
   });
 });
+
+describe('inferenceChartToCsv power comparison', () => {
+  it('names each row’s boundary or role only while comparison clones are present', () => {
+    const base = makePoint({
+      hwKey: 'b200_sglang',
+      measuredAvgPower: { y: 600, roof: false },
+    });
+    const clone = {
+      ...base,
+      y: 1000,
+      powerVariant: { kind: 'basis', id: 'gpu-provisioned' },
+    } as InferenceData;
+    const plain = inferenceChartToCsv([base], 'dsv4', '8k/1k', [], {
+      yHeader: 'Measured Power per Chip (W)',
+      yPath: 'measuredAvgPower.y',
+      xHeader: 'Interactivity (tok/s/user)',
+    });
+    expect(plain.headers).not.toContain('Power Series');
+
+    const { headers, rows } = inferenceChartToCsv([base, clone], 'dsv4', '8k/1k', [], {
+      yHeader: 'Measured Power per Chip (W)',
+      yPath: 'measuredAvgPower.y',
+      xHeader: 'Interactivity (tok/s/user)',
+    });
+    const column = headers.indexOf('Power Series');
+    expect(column).toBeGreaterThan(-1);
+    expect(rows.map((row) => row[column])).toEqual(['GPU measured', 'GPU provisioned (TDP)']);
+    expect(rows.every((row) => row.length === headers.length)).toBe(true);
+  });
+});
diff --git a/packages/app/src/lib/csv-export-helpers.ts b/packages/app/src/lib/csv-export-helpers.ts
index 576569af8..f4803a150 100644
--- a/packages/app/src/lib/csv-export-helpers.ts
+++ b/packages/app/src/lib/csv-export-helpers.ts
@@ -9,6 +9,7 @@
 
 import { METRIC_REGISTRY } from '@/components/inference/metric-registry';
 import type { InferenceData, TrendDataPoint } from '@/components/inference/types';
+import { inferPowerCompare, powerSeriesLabel } from '@/components/inference/utils/power-compare';
 import { chipCounts } from '@/lib/chip-counts';
 import type { SubmissionVolumeRow } from '@/lib/submissions-types';
 
@@ -57,6 +58,12 @@ export function inferenceChartToCsv(
   const islOsl = sequenceToIslOsl(sequence);
   const showModeledPower =
     displayedMetrics?.yPath === METRIC_REGISTRY.modeledChassisPowerPerGpu.field;
+  // A power comparison (`i_pcompare`) appends boundary / role clones of the
+  // plotted points; name each row's series so the export stays unambiguous.
+  const allPoints = [...data, ...overlayData];
+  const powerCompare = inferPowerCompare(allPoints);
+  const showPowerSeries = powerCompare !== 'none';
+  const plottedMetric = displayedMetrics ? `y_${displayedMetrics.yPath.split('.')[0]}` : '';
   const headers = [
     'Model',
     'ISL',
@@ -111,6 +118,7 @@ export function inferenceChartToCsv(
     'Physical Chips',
     'DP',
     ...(showModeledPower ? ['Configured Chip Count'] : []),
+    ...(showPowerSeries ? ['Power Series'] : []),
   ];
 
   const displayedColumns = displayedMetrics
@@ -128,7 +136,7 @@ export function inferenceChartToCsv(
     : [];
   headers.splice(10, 0, ...displayedColumns.map((column) => column.header));
 
-  const rows = [...data, ...overlayData]
+  const rows = allPoints
     .filter((d) => !d.hidden)
     .map((d) => {
       const chips = chipCounts(d, showModeledPower);
@@ -177,6 +185,7 @@ export function inferenceChartToCsv(
         chips.physical,
         d.dp ?? '',
         ...(showModeledPower ? [chips.configured] : []),
+        ...(showPowerSeries ? [powerSeriesLabel(d, plottedMetric, powerCompare, 'en')] : []),
       ];
       row.splice(10, 0, ...displayedColumns.map((column) => column.value(d)));
       return row;
diff --git a/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts b/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
index d50fe1573..428fcbf8f 100644
--- a/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
+++ b/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
@@ -16,10 +16,12 @@ import {
   isPerfRulerCurveVisible,
   movePerfRulerIsoX,
   nextPerfRulerState,
+  parsePerfRulers,
   pathXExtent,
   perfRulerCurveSet,
   prunePerfRulers,
   renderPerfRulers,
+  serializePerfRulers,
   type PerfRulerEndInput,
   type PerfRulerGeometry,
   type PerfRulerLabelLayoutOptions,
@@ -889,6 +891,132 @@ describe('perfRulerCurveSet', () => {
   });
 });
 
+// ── serializePerfRulers / parsePerfRulers (share links) ─────────────
+
+describe('serializePerfRulers / parsePerfRulers', () => {
+  const OFFICIAL_A = 'roofline-b200_trt_fp8';
+  const OFFICIAL_B = 'roofline-mi355x_sglang_fp4';
+  // Overlay curves carry the unofficial run index; power-envelope curves are
+  // split per date with the encoded date appended (`%2F` from a slash).
+  const OVERLAY = 'overlay-roofline-h100_vllm_fp8_run1__2026-09%2F11';
+
+  it('round-trips completed rulers, including overlay and date-scoped curve ids', () => {
+    const state = complete(
+      complete(EMPTY_PERF_RULER_STATE, OFFICIAL_A, OFFICIAL_B, 41.5),
+      OFFICIAL_A,
+      OVERLAY,
+      120,
+    );
+    const encoded = serializePerfRulers(state);
+    expect(encoded).toBe(`41.5|${OFFICIAL_A}|${OFFICIAL_B};120|${OFFICIAL_A}|${OVERLAY}`);
+    const parsed = parsePerfRulers(encoded);
+    expect(parsed.rulers).toEqual([
+      { id: 1, curveA: OFFICIAL_A, curveB: OFFICIAL_B, isoX: 41.5 },
+      { id: 2, curveA: OFFICIAL_A, curveB: OVERLAY, isoX: 120 },
+    ]);
+    expect(parsed.draft).toBeNull();
+    expect(parsed.nextId).toBe(3);
+  });
+
+  it('survives URLSearchParams encoding, which the share link applies', () => {
+    const state = complete(EMPTY_PERF_RULER_STATE, OFFICIAL_A, OVERLAY, 33);
+    const search = new URLSearchParams({ i_rulers: serializePerfRulers(state) });
+    const decoded = new URLSearchParams(search.toString()).get('i_rulers');
+    expect(parsePerfRulers(decoded).rulers).toEqual([
+      { id: 1, curveA: OFFICIAL_A, curveB: OVERLAY, isoX: 33 },
+    ]);
+  });
+
+  it('rounds the iso-x to four significant digits and never emits the draft', () => {
+    let state = complete(EMPTY_PERF_RULER_STATE, OFFICIAL_A, OFFICIAL_B, 123.456789);
+    state = nextPerfRulerState(state, { curve: OFFICIAL_B, isoX: 9 });
+    expect(state.draft).not.toBeNull();
+    expect(serializePerfRulers(state)).toBe(`123.5|${OFFICIAL_A}|${OFFICIAL_B}`);
+    expect(serializePerfRulers(complete(EMPTY_PERF_RULER_STATE, 'a', 'b', 0.00012346))).toBe(
+      '0.0001235|a|b',
+    );
+    expect(serializePerfRulers(complete(EMPTY_PERF_RULER_STATE, 'a', 'b', 98765))).toBe(
+      '98770|a|b',
+    );
+  });
+
+  it('serializes the empty state to the empty string so the param strips as default', () => {
+    expect(serializePerfRulers(EMPTY_PERF_RULER_STATE)).toBe('');
+    const drafted = nextPerfRulerState(EMPTY_PERF_RULER_STATE, { curve: 'a', isoX: 1 });
+    expect(serializePerfRulers(drafted)).toBe('');
+  });
+
+  it('returns the shared empty state for missing or entirely malformed input', () => {
+    expect(parsePerfRulers('')).toBe(EMPTY_PERF_RULER_STATE);
+    expect(parsePerfRulers(null)).toBe(EMPTY_PERF_RULER_STATE);
+    expect(parsePerfRulers(undefined)).toBe(EMPTY_PERF_RULER_STATE);
+    expect(parsePerfRulers('garbage')).toBe(EMPTY_PERF_RULER_STATE);
+    expect(parsePerfRulers(';;|')).toBe(EMPTY_PERF_RULER_STATE);
+  });
+
+  it('drops malformed entries and keeps the valid ones', () => {
+    const encoded = [
+      `NaN|${OFFICIAL_A}|${OFFICIAL_B}`, // non-numeric iso-x
+      `|${OFFICIAL_A}|${OFFICIAL_B}`, // missing iso-x
+      `12|${OFFICIAL_A}`, // missing curve B
+      `12||${OFFICIAL_B}`, // empty curve A
+      `12|${OFFICIAL_A}|${OFFICIAL_A}`, // a curve cannot be measured against itself
+      `12|${OFFICIAL_A}|${OFFICIAL_B}|extra`, // too many fields
+      `Infinity|${OFFICIAL_A}|${OFFICIAL_B}`,
+      `7.5|${OFFICIAL_A}|${OFFICIAL_B}`,
+    ].join(';');
+    expect(parsePerfRulers(encoded).rulers).toEqual([
+      { id: 1, curveA: OFFICIAL_A, curveB: OFFICIAL_B, isoX: 7.5 },
+    ]);
+  });
+
+  it('only accepts roofline identity classes as curve ids', () => {
+    const encoded = [
+      // The shared marker classes sit on EVERY roofline path: a ruler between
+      // them would land on whichever two paths come first in the DOM.
+      `10|roofline-path|overlay-roofline-path`,
+      `10|${OFFICIAL_A}|roofline-path`,
+      // Other nodes inside the zoom group are not curves.
+      `10|perf-ruler-hit|${OFFICIAL_A}`,
+      `10|dot-group|zoom-group`,
+      `10|${OFFICIAL_A}|roofline-`, // identity class needs a series
+      `10|${OFFICIAL_A}|roofline-b200 fp8`, // no whitespace in a class token
+      `10|${OFFICIAL_A}|${OVERLAY}`,
+    ].join(';');
+    expect(parsePerfRulers(encoded).rulers).toEqual([
+      { id: 1, curveA: OFFICIAL_A, curveB: OVERLAY, isoX: 10 },
+    ]);
+  });
+
+  it('caps at MAX_PERF_RULERS keeping the newest entries, like the click reducer', () => {
+    const encoded = Array.from(
+      { length: MAX_PERF_RULERS + 3 },
+      (_, index) => `${index + 1}|roofline-a${index}|roofline-b${index}`,
+    ).join(';');
+    const parsed = parsePerfRulers(encoded);
+    expect(parsed.rulers).toHaveLength(MAX_PERF_RULERS);
+    expect(parsed.rulers[0]).toEqual({
+      id: 1,
+      curveA: 'roofline-a3',
+      curveB: 'roofline-b3',
+      isoX: 4,
+    });
+    expect(parsed.rulers.at(-1)).toEqual({
+      id: MAX_PERF_RULERS,
+      curveA: `roofline-a${MAX_PERF_RULERS + 2}`,
+      curveB: `roofline-b${MAX_PERF_RULERS + 2}`,
+      isoX: MAX_PERF_RULERS + 3,
+    });
+    expect(parsed.nextId).toBe(MAX_PERF_RULERS + 1);
+  });
+
+  it('hands out ids a later click never reuses', () => {
+    const restored = parsePerfRulers(`10|roofline-a|roofline-b;20|roofline-c|roofline-d`);
+    const placed = complete(restored, 'e', 'f', 30);
+    expect(placed.rulers.map((ruler) => ruler.id)).toEqual([1, 2, 3]);
+  });
+});
+
 // ── pathXExtent ─────────────────────────────────────────────
 
 describe('pathXExtent', () => {
diff --git a/packages/app/src/lib/d3-chart/layers/perf-ruler.ts b/packages/app/src/lib/d3-chart/layers/perf-ruler.ts
index c44143529..ef13b2a1d 100644
--- a/packages/app/src/lib/d3-chart/layers/perf-ruler.ts
+++ b/packages/app/src/lib/d3-chart/layers/perf-ruler.ts
@@ -323,6 +323,72 @@ export function prunePerfRulers(
   return { ...prev, rulers, draft };
 }
 
+const PERF_RULER_URL_RULER_SEPARATOR = ';';
+const PERF_RULER_URL_FIELD_SEPARATOR = '|';
+/**
+ * Shape of a curve id the link may reference: one roofline path's identity
+ * class (`roofline-<series>` / `overlay-roofline-<series>`), never the shared
+ * `roofline-path` / `overlay-roofline-path` marker classes or any other node
+ * inside the zoom group — those match many paths, so a hand-edited link
+ * would draw a ruler between whichever two come first in DOM order.
+ */
+const PERF_RULER_CURVE_ID = /^(?:overlay-)?roofline-(?!path$)[\w%.-]+$/u;
+
+/**
+ * Share-link encoding of the COMPLETED rulers (`i_rulers`). One ruler per
+ * `;`, fields joined by `|`: `isoX|curveA|curveB`. Curve ids are the rendered
+ * roofline path identity classes (`roofline-<hwKey>_<precision>`,
+ * `overlay-roofline-<hwKey>_<precision>_run<N>`, optionally `__<encoded
+ * date>`), whose alphabet is `[A-Za-z0-9_%.-]`, so neither separator can
+ * appear inside one; `URLSearchParams` percent-encodes both on the wire.
+ * The iso-x is rounded to four significant digits to keep links short — a
+ * 0.05% shift on the x metric is far below the ruler's visual resolution.
+ * The draft is never serialized: it is an unfinished click, not a
+ * measurement. Empty state serializes to '' so the param strips as default.
+ */
+export function serializePerfRulers(state: PerfRulerState): string {
+  return state.rulers
+    .map((ruler) =>
+      [Number(ruler.isoX.toPrecision(4)), ruler.curveA, ruler.curveB].join(
+        PERF_RULER_URL_FIELD_SEPARATOR,
+      ),
+    )
+    .join(PERF_RULER_URL_RULER_SEPARATOR);
+}
+
+/**
+ * Inverse of {@link serializePerfRulers}. Malformed entries (wrong field
+ * count, non-numeric iso-x, identical curve ids, or ids that are not
+ * roofline identity classes) are dropped silently — a hand-edited or
+ * truncated link degrades to fewer rulers, never to an error. The list is capped at
+ * {@link MAX_PERF_RULERS} keeping the NEWEST (last-serialized) entries, the
+ * same end the click reducer drops from. Ids are reassigned 1..n with
+ * `nextId = n + 1`, so parsed rulers are valid D3 join keys and a ruler
+ * placed afterwards never collides. Returns {@link EMPTY_PERF_RULER_STATE}
+ * (same reference) for '', null, or an all-malformed value.
+ */
+export function parsePerfRulers(raw: string | null | undefined): PerfRulerState {
+  if (!raw) return EMPTY_PERF_RULER_STATE;
+  const parsed: Omit<PerfRulerMeasurement, 'id'>[] = [];
+  for (const entry of raw.split(PERF_RULER_URL_RULER_SEPARATOR)) {
+    const fields = entry.split(PERF_RULER_URL_FIELD_SEPARATOR);
+    if (fields.length !== 3) continue;
+    const [isoXField, curveA, curveB] = fields;
+    if (isoXField.trim() === '' || curveA === curveB) continue;
+    if (!PERF_RULER_CURVE_ID.test(curveA) || !PERF_RULER_CURVE_ID.test(curveB)) continue;
+    const isoX = Number(isoXField);
+    if (!Number.isFinite(isoX)) continue;
+    parsed.push({ curveA, curveB, isoX });
+  }
+  if (parsed.length === 0) return EMPTY_PERF_RULER_STATE;
+  const kept = parsed.slice(-MAX_PERF_RULERS);
+  return {
+    rulers: kept.map((ruler, index) => ({ id: index + 1, ...ruler })),
+    draft: null,
+    nextId: kept.length + 1,
+  };
+}
+
 /** Every curve referenced by any ruler or the draft (hit-halo styling). */
 export function perfRulerCurveSet(state: PerfRulerState): Set<string> {
   const curves = new Set<string>();
diff --git a/packages/app/src/lib/dashboard-routes.ts b/packages/app/src/lib/dashboard-routes.ts
index 4934ecde3..131e09a33 100644
--- a/packages/app/src/lib/dashboard-routes.ts
+++ b/packages/app/src/lib/dashboard-routes.ts
@@ -164,6 +164,26 @@ export const DASHBOARD_ROUTES = [
     providers: UNOFFICIAL_ONLY_DASHBOARD_PROVIDERS,
     shareParamScopes: ['g_', 'i_', 'c_'],
   },
+  {
+    key: 'first-token',
+    path: '/first-token',
+    canonicalPath: '/first-token',
+    navGroup: 'footer-only',
+    indexable: true,
+    localeMirrored: true,
+    providers: UNOFFICIAL_ONLY_DASHBOARD_PROVIDERS,
+    shareParamScopes: ['g_', 'i_', 'c_'],
+  },
+  {
+    key: 'cache-reuse',
+    path: '/cache-reuse',
+    canonicalPath: '/cache-reuse',
+    navGroup: 'footer-only',
+    indexable: true,
+    localeMirrored: true,
+    providers: UNOFFICIAL_ONLY_DASHBOARD_PROVIDERS,
+    shareParamScopes: ['g_', 'i_', 'c_'],
+  },
   {
     key: 'reliability',
     path: '/reliability',
diff --git a/packages/app/src/lib/data-mappings.ts b/packages/app/src/lib/data-mappings.ts
index 4d87b3c54..a13078c2c 100644
--- a/packages/app/src/lib/data-mappings.ts
+++ b/packages/app/src/lib/data-mappings.ts
@@ -7,6 +7,8 @@ export enum Model {
   GptOss = 'gpt-oss-120b',
   Qwen3_5 = 'Qwen-3.5-397B-A17B',
   Qwen3_8_Flash_Next = 'Qwen3.8-Flash-Next',
+  Qwen3_8_27B = 'Qwen3.8-27B',
+  Qwen3_8_27B_Eager = 'Qwen3.8-27B-Eager',
   Kimi_K2_5 = 'Kimi-K2.5',
   Kimi_K3 = 'Kimi-K3',
   MiniMax_M2_5 = 'MiniMax-M2.5',
@@ -231,6 +233,27 @@ const MODEL_CONFIG: Record<Model, ModelConfig> = {
     openRouterModelId: 'qwen/qwen3.8-flash',
     logo: 'qwen-color.svg',
   },
+  // Dense 27B (27B active) on the Qwen3.8 hybrid GDN backbone, served bf16 on
+  // one GPU with the RadixArk DSpark drafter (single-turn 1k1k, InferenceX#3260).
+  // Experimental until the first sweeps land on the official pipeline.
+  [Model.Qwen3_8_27B]: {
+    label: 'Qwen3.8 27B',
+    prefix: 'qwen3.827b',
+    category: 'experimental',
+    openRouterModelId: 'qwen/qwen3.8-27b',
+    logo: 'qwen-color.svg',
+  },
+  // The same checkpoint served with CUDA graphs disabled on both the target and
+  // the DSpark drafter (--enforce-eager, InferenceX#3262). A separate bucket so
+  // the eager and graph-captured points never overlap on one chart.
+  [Model.Qwen3_8_27B_Eager]: {
+    label: 'Qwen3.8 27B (eager)',
+    prefix: 'qwen3.827beager',
+    category: 'experimental',
+    // Same checkpoint, so the same public catalog id.
+    openRouterModelId: 'qwen/qwen3.8-27b',
+    logo: 'qwen-color.svg',
+  },
   [Model.GptOss]: {
     label: 'gpt-oss 120B',
     prefix: 'gptoss',
diff --git a/packages/app/src/lib/github-artifacts.test.ts b/packages/app/src/lib/github-artifacts.test.ts
index 4a80ae8a4..450623b48 100644
--- a/packages/app/src/lib/github-artifacts.test.ts
+++ b/packages/app/src/lib/github-artifacts.test.ts
@@ -8,6 +8,7 @@ import {
   fetchGithubRunArtifacts,
   getRunDate,
   normalizeGithubRunInfo,
+  readZipEntries,
   type GithubArtifact,
   type GithubWorkflowRun,
 } from './github-artifacts';
@@ -140,3 +141,25 @@ describe('extractZipEntries', () => {
     expect(parseErrors).toEqual(['bad.json']);
   });
 });
+
+describe('readZipEntries', () => {
+  it('decodes only the entries the predicate selects and skips directories', () => {
+    const zip = new AdmZip();
+    zip.addFile('LOGS/power/', Buffer.alloc(0));
+    zip.addFile('LOGS/power/samples.csv', Buffer.from('a,b\n1,2', 'utf8'));
+    zip.addFile('LOGS/big/results.json', Buffer.alloc(64 * 1024, 0x41));
+    zip.addFile('power_validation_x_conc8.json', Buffer.from('{"power_valid":true}', 'utf8'));
+
+    const files = readZipEntries(
+      zip.toBuffer(),
+      (name) => name === 'LOGS/power/samples.csv' || name.startsWith('power_validation_'),
+    );
+
+    expect([...files.keys()].toSorted()).toEqual([
+      'LOGS/power/samples.csv',
+      'power_validation_x_conc8.json',
+    ]);
+    expect(files.get('LOGS/power/samples.csv')).toBe('a,b\n1,2');
+    expect(files.get('power_validation_x_conc8.json')).toBe('{"power_valid":true}');
+  });
+});
diff --git a/packages/app/src/lib/github-artifacts.ts b/packages/app/src/lib/github-artifacts.ts
index 3fe278903..97d6ac01d 100644
--- a/packages/app/src/lib/github-artifacts.ts
+++ b/packages/app/src/lib/github-artifacts.ts
@@ -120,6 +120,24 @@ export function downloadGithubArtifact(url: string, token: string): Promise<Resp
   });
 }
 
+/**
+ * Decodes only the entries `predicate` selects, keyed by entry name. The rest
+ * of the archive stays compressed, so picking a few small files out of a
+ * multi-hundred-megabyte bundle costs the central directory, not the payload.
+ */
+export function readZipEntries(
+  buffer: Buffer,
+  predicate: (entryName: string) => boolean,
+): Map<string, string> {
+  const zip = new AdmZip(buffer);
+  const files = new Map<string, string>();
+  for (const entry of zip.getEntries()) {
+    if (entry.isDirectory || !predicate(entry.entryName)) continue;
+    files.set(entry.entryName, entry.getData().toString('utf8'));
+  }
+  return files;
+}
+
 export function extractZipEntries<T>(
   buffer: Buffer,
   extension: string,
diff --git a/packages/app/src/lib/glossary-zh.ts b/packages/app/src/lib/glossary-zh.ts
index 5c6d59415..015652e8c 100644
--- a/packages/app/src/lib/glossary-zh.ts
+++ b/packages/app/src/lib/glossary-zh.ts
@@ -146,13 +146,14 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
     term: '吞吐量',
     aliases: ['throughput', 'token 吞吐量', '总吞吐量'],
     plainEnglish: '吞吐量就是整个系统每秒一共能完成多少工作。',
-    definition: '吞吐量是推理系统在所有活跃请求上生成 token 的总速率。',
+    definition:
+      '吞吐量是系统处理各请求中 token 的速率。输出吞吐量只计生成的 token；总 token 吞吐量则按基准测试规定的统计口径，计入输入和输出 token。',
     explanation:
       'InferenceX 通常使用每芯片每秒 token 数进行归一化，便于比较不同规模的系统。提高批大小或并发往往能摊薄权重读取和计算成本，从而提高总吞吐量，但单个用户收到 token 的速度可能下降。',
     significance:
       '最大吞吐量不是完整的性能结论。某个点即使拥有最高 tok/s，也可能因为交互性过低而不适合实时产品；有效比较应在符合业务需求的延迟或交互性目标下进行。',
     benchmarkContext:
-      'InferenceX 将吞吐量与交互性放在完整并发扫描中共同展示，并用 Pareto 前沿剔除两个轴上都更差的运行点。',
+      'InferenceX 将吞吐量与交互性放在完整并发扫描中共同展示。Rubin AgentX 文章报告的是包含复用输入在内的总 token 吞吐量，不只是新生成的输出。因此，与只统计输出的结果比较前，必须先核对 token 口径。',
     measurement: { label: '常用单位', value: 'tok/s/chip' },
   },
   interactivity: {
@@ -165,7 +166,7 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
     significance:
       '不同产品需要不同运行点。语音和交互式编程要求较高 token 速率，离线摘要则可以牺牲交互性换取更高总吞吐量；在交互性不一致时比较硬件很容易得出误导性结论。',
     benchmarkContext:
-      'InferenceX 将 tok/s/user 与吞吐量或成本一起绘制，并在等交互性表格中沿各自 Pareto 前沿插值，以固定用户体验。由于该坐标轴不计入首 token 之前的等待，agentic 图表还提供端到端归一化交互性，用同一单位把 TTFT 一并纳入。',
+      'InferenceX 将 tok/s/user 与吞吐量或成本一起绘制。Rubin AgentX 文章用 P90 全响应 token 间延迟的倒数表示 P90 交互性。匹配这一速度不代表 TTFT 或端到端延迟也相同；端到端归一化交互性是另一项指标，会把开始输出前的等待计入。',
     measurement: { label: '常用单位', value: 'token/秒/用户（tok/s/user）' },
   },
   latency: {
@@ -253,7 +254,7 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
     explanation:
       '不同方案的并发点很少正好落在相同 tok/s/user。等交互性比较会在各自 Pareto 前沿上对共同目标插值，再比较该点的吞吐量、成本或效率。',
     significance:
-      '固定用户体验可以避免常见基准错误：某系统只有在让每个请求更慢时才达到更高吞吐量，却被错误地称为更快。',
+      '匹配流式输出速度，可以避免仅因系统以更慢的 token 速率服务更多请求，就把它称为更快。但这并未固定完整的用户体验：首 token 前的等待和整段响应耗时仍需单独比较。',
     benchmarkContext:
       'InferenceX 文章使用等交互性表格比较硬件、精度和软件；超出实测前沿的值会标记为不可达，而不会向观测区间之外外推。前沿始终建立在吞吐量与交互性之上，每百万 token 成本和每 token 焦耳则由插值得到的吞吐量推导，而不是各自单独做样条：它们都是每芯片常数除以吞吐量，单独插值会破坏两个 knot 之间的这一恒等关系。',
   },
@@ -297,7 +298,7 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
     significance:
       '芯片峰值 FLOPS 不能单独决定服务经济性；内存、网络、软件成熟度、数值精度和实际利用率都会影响最终比值。',
     benchmarkContext:
-      'InferenceX 在匹配交互性时比较基础设施 perf/$，并明确使用的 TCO 输入。该比值不能跨模型、序列长度、精度或延迟区间直接套用。每百万 token 成本以及总 token、输入 token 和输出 token 购买力轴都采用这套 TCO 经济性口径。',
+      'InferenceX 在匹配交互性时比较基础设施 perf/$，并注明 TCO 假设。Rubin 文章约 67 倍的结果限定于 170 TPS、自有成本口径及文中指定的 TRTLLM NVFP4 Dense 配置，并非适用于整个硬件世代的倍率。目标速度、对比引擎以及自有或租赁成本口径变化时，比值也会变化。',
   },
   'total-cost-of-ownership': {
     term: '总体拥有成本',
@@ -309,7 +310,7 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
     significance:
       'TCO 比标价更适合跨系统经济性比较，尤其是网络与电力基础设施不同的机架级产品；但它仍是模型，必须连同假设一起阅读。',
     benchmarkContext:
-      'InferenceX 将 SemiAnalysis AI Cloud 的 TCO 输入与实测 tok/s/chip 结合，从而把系统每小时成本与决定这一小时 token 产出的软件实现及工作负载特征分开考察。',
+      'InferenceX 将 SemiAnalysis AI Cloud 的 TCO 输入与实测 tok/s/chip 结合。Rubin 文章区分了两种口径：超大规模采购条件下的自有成本，包含硬件、网络、机房、电力和资本成本的摊销；以及客户支付的三年云服务预留价格。两者是可选的成本基础，不能相加；租赁价格还反映服务商的商业条款。',
   },
   'tokens-per-megawatt': {
     term: '每兆瓦 token 吞吐量',
@@ -321,7 +322,7 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
     significance:
       '电力供应往往是新增 AI 部署的硬约束。每兆瓦生成更多 token 的系统，即使单个加速器功耗更高，也能在相同电力配额下服务更多需求。',
     benchmarkContext:
-      '比较 tokens/MW 时必须匹配模型、工作负载、精度与交互性，否则高吞吐低交互点可能看似高效，却无法满足目标用户体验。每 token 能耗表达的是同一份供电预算折算到单位输出上的结果；在遥测可信的前提下，InferenceX 还会给出加速器的实测能耗。',
+      'Rubin 文章在相同 P90 交互性下比较每兆瓦市电容量对应的总 tok/s，且只在各引擎实测区间内插值。引用倍率时须保留引擎、精度、缓存和并行配置。配置的市电功率分母属于容量模型，与加速器实测功耗或能耗遥测不同。',
     measurement: { label: '常用单位', value: '每单位配置市电兆瓦的 token/秒' },
   },
   prefill: {
@@ -368,7 +369,7 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
       '前缀缓存会记住重复开头的处理结果，例如相同系统提示词，让模型下次可以跳过这部分工作。',
     definition: '当前多个请求以相同 token 序列开头时，前缀缓存会复用已有 KV 缓存状态。',
     explanation:
-      '重复系统提示词、共享文档或共同对话前缀在缓存仍可用时无需再次预填充。命中缓存可显著减少提示词计算与首 token 时间。',
+      '重复系统提示词、共享文档或共同对话前缀可以复用缓存状态。智能体会话持续增长时，前几轮的输出会成为后续输入，可复用前缀也随之增加。但实际命中仍要求相关状态尚未被淘汰且能够访问；缓存淘汰或子智能体的新上下文都可能带来新的 prefill。',
     significance:
       '具有重复前缀的生产工作负载可能明显快于随机 token 基准；收益取决于命中率、缓存容量、淘汰策略与请求能否路由到持有所需状态的节点。',
     benchmarkContext:
@@ -544,7 +545,7 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
     plainEnglish: 'NVLink 是 NVIDIA 芯片之间的高速公路，让多张芯片的协作远快于普通服务器网络。',
     definition: 'NVLink 是 NVIDIA 用于 scale-up 域内芯片直接数据传输的高带宽加速器互连。',
     explanation:
-      'NVSwitch 系统连接多个 NVLink 端点，使集体通信可覆盖八卡服务器，或在 NVL72 产品中覆盖 72 芯片机架级域；该带宽不同于连接独立系统的 InfiniBand/Ethernet。',
+      'NVSwitch 连接多个 NVLink 端点，使集合通信可以覆盖单节点或包含 72 颗芯片的机架级域。互连代际取决于平台：Blackwell NVL72 使用 NVLink 5，Rubin 文章则将 NVLink 6 Switch 列为 Vera Rubin 的组成部分。这种 scale-up 互连与系统之间的网络不同。',
     significance:
       '大型 TP，尤其是 Wide EP，会在每个生成 token 上交换数据。把通信留在 NVLink 上，可让机架级方案显著快于通过 scale-out 连接的相似芯片数量。',
     benchmarkContext:
@@ -1125,13 +1126,13 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
   },
   nvl72: {
     term: 'NVL72',
-    aliases: ['NVL72', 'GB200 NVL72', 'GB300 NVL72', '机架级系统'],
+    aliases: ['NVL72', 'GB200 NVL72', 'GB300 NVL72', 'Vera Rubin NVL72', '机架级系统'],
     plainEnglish:
       'NVL72 是一个机架，其中 72 个加速器共享同一张高速网络，因而更像一台大机器而不是一个集群。',
     definition:
       'NVL72 是 NVIDIA 的机架级系统，把 72 个加速器放进同一个 NVLink scale-up 域，而不是分散在多个八芯片节点中。',
     explanation:
-      '仪表板的规格数据记录为 NVLink 5.0、每颗芯片 900 GB/s 单向带宽、scale-up world size 为 72，并通过 NVSwitch 交换。常规节点把同样的带宽限定在八颗芯片之间，超出后就要退回更慢的 scale-out 网络，因此差别不在于原始速度，而在于换用另一种网络之前能触及多少颗芯片。',
+      'NVL72 描述的是 NVLink 域的规模，并不限定某一代芯片或固定带宽。GB200 和 GB300 使用 Blackwell 世代硬件及 NVLink 5；Vera Rubin 则组合 Rubin GPU、Vera CPU 和 NVLink 6 Switch。比较时应查看具体平台，不能把 Blackwell 规格套用到所有 NVL72 机架。',
     significance:
       '开销以集合通信为主的技术，在大规模 scale-up 域中经济性会发生变化。宽专家并行把专家分散到许多芯片上，每个 token 都要付出 all-to-all 流量；在 scale-up 带宽下这可以承受，在 scale-out 网络上往往不行。',
     benchmarkContext:
@@ -1494,7 +1495,7 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
   },
   tdp: {
     term: '热设计功耗',
-    aliases: ['TDP', '整卡功耗', '全部包含功耗'],
+    aliases: ['TDP', '热设计功率包络'],
     plainEnglish:
       'TDP 是芯片设计上可持续消耗并以热量形式散发的功率，是每份加速器规格表上的标题瓦数。',
     definition:
@@ -1504,7 +1505,7 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
     significance:
       '电力已成为 AI 扩建的硬约束，在许多市场甚至排在资本之前。每芯片 TDP 的持续上升迫使行业转向液冷，也让每瓦性能与每美元性能一样，成为比较芯片世代的主要维度。',
     benchmarkContext:
-      'InferenceX 用包含散热和基础设施开销的每芯片全部包含功耗来计算每 token 能耗和每兆瓦 token 数，PowerX 工作流正把这些指标从铭牌数值推向运行中的实测功耗。',
+      'Rubin 文章注明所测量产 SKU 的 TDP 为 2300 W，但设施吞吐量采用全口径市电功率归一化。TDP 既不是推理实测功耗，也不是设施总功耗。文中 DSX MaxLPS 部分讨论按工作负载规划供电，并将更细粒度的 PowerX 测量列为后续工作，没有把现有曲线当作实测功耗结果。',
   },
   pue: {
     term: '电源使用效率',
@@ -2308,6 +2309,166 @@ const translations: Readonly<Record<string, GlossaryTranslation>> = {
     benchmarkContext:
       'TPU-Sync DRAM offload 和 Mooncake Store 池化被列为 TPU InferenceX 预览的后续步骤，排在 AgentX TPU 结果之前。NVIDIA 和 AMD 的 AgentX 文章已经表明，KV 工作集大小和 offload 容量决定智能体负载的每 token 成本。',
   },
+  'multi-turn-inference': {
+    term: '多轮推理',
+    aliases: ['multi-turn inference', '多轮服务', '多轮工作负载'],
+    plainEnglish: '多轮会话会连续向模型发送相关请求，把之前的对话和工具结果带入后续提示词。',
+    definition: '多轮推理为一系列相关的模型请求提供服务，后续输入包含前几轮留下的状态或对话历史。',
+    explanation:
+      '智能体会话可能包含数十甚至数百轮。模型输出和工具结果会扩展下一轮提示词，因此大量输入可能已有可复用的缓存状态。工具执行和请求依赖关系还会改变工作到达服务器的时间。',
+    significance:
+      '相互独立的提示词序列无法重现这些依赖关系，也无法重现不断增长的缓存工作集。缓存淘汰会导致重复 prefill；即使总吞吐量较高，某次响应过慢仍可能推迟下一轮。',
+    benchmarkContext:
+      'Rubin 文章将多轮结构列为 AgentX 工作负载的主要特征。应在相同智能体场景内比较结果，不能直接套用固定长度、独立请求测试得出的排名。',
+  },
+  'subagent-bursts': {
+    term: '子智能体请求突发',
+    aliases: ['subagent bursts', 'sub-agent bursts', '智能体突发流量'],
+    plainEnglish:
+      '智能体同时启动多个短时运行的子任务，会突然增加请求量和服务器需要保存的新上下文。',
+    definition:
+      '子智能体请求突发是指主智能体启动多个下级任务，各自发出请求序列，从而在短时间内增加推理需求。',
+    explanation:
+      '主会话可能已有很长的可复用前缀，新分支却可能从全新上下文开始。这些分支会产生重叠的 prefill 和 decode 工作，并暂时扩大 KV cache 工作集。分支的启动时间和依赖关系与请求数量同样重要。',
+    significance:
+      '较高的平均缓存命中率可能掩盖某些时段大量新增的 prefill 需求。容量规划还需考虑突发时序、缓存淘汰，以及那些必须完成后主任务才能继续的分支延迟。',
+    benchmarkContext:
+      'Rubin 文章将子智能体突发、多轮会话、长上下文和高前缀复用共同列为工作负载特征。因此，AgentX 比较的是随时间变化的请求模式，而不是由相同提示词组成的恒定批次。',
+  },
+  'p90-interactivity': {
+    term: 'P90 交互性',
+    aliases: ['P90 interactivity', 'P90 TPS', 'P90 流式输出速度'],
+    plainEnglish: 'P90 交互性把较慢尾部的 token 间隔换算成输出速率，数值越高，流式输出越快。',
+    definition:
+      '在 Rubin AgentX 分析中，P90 交互性是 P90 全响应 token 间延迟的倒数，单位为每用户每秒 token 数。',
+    explanation:
+      '计算时先取延迟的 P90，再取倒数并换算单位。P90 全响应 token 间延迟为 10 毫秒时，对应 100 tok/s/user。这并不是 token 速率的第 90 百分位数，因为正数取倒数后，大小顺序会反转。',
+    significance:
+      '分位数和延迟定义共同决定比较采用的速度约束。该指标不包含开始输出前的等待；相同的 P90 交互性仍可能对应明显不同的首 token 时间和端到端延迟。',
+    benchmarkContext:
+      'Rubin 文章在相同 P90 交互性下比较各引擎的性能前沿，只在实测区间内插值。引用吞吐量、成本或功率归一化倍率时，必须保留目标速度与对比引擎。',
+    measurement: { label: '换算关系', value: 'P90 交互性 = 1000 / P90 全响应 ITL（毫秒）' },
+  },
+  'end-to-end-latency': {
+    term: '端到端延迟',
+    aliases: ['E2E latency', 'E2EL', '请求完成时间', 'P90 端到端延迟'],
+    plainEnglish: '端到端延迟是从提交模型请求到收完完整答案的时间，包含开始输出前的等待。',
+    definition: '请求端到端延迟衡量从提交请求到收到响应最后一个 token 之间的耗时。',
+    explanation:
+      '它包含首 token 时间及后续流式输出时长。即使 token 速率相同，更长的答案也需要更多时间，因此比较时须采用可比的输出长度分布。P90 端到端延迟是请求完成时间的第 90 百分位数，不能把各阶段单独计算的 P90 延迟相加得到。',
+    significance:
+      '智能体往往需要等到完整响应到达，才能执行工具或开始下一轮。仅有较快的流式输出无法限定这段等待。单次请求延迟也不同于完整智能体任务时长，后者可能包含多次模型调用和工具执行。',
+    benchmarkContext:
+      'Rubin 文章分别绘制 P90 端到端延迟和 P90 交互性。两者结合阅读，才能区分流式输出加快与排队、prefill 或整段响应耗时缩短。',
+    measurement: { label: '常用单位', value: '每个已完成请求的秒数' },
+  },
+  'cached-input-tokens': {
+    term: '缓存输入 token',
+    aliases: ['cached input tokens', '缓存提示词 token', '缓存读取 token'],
+    plainEnglish:
+      '缓存输入 token 是提示词中可以复用先前处理结果的部分，能减少再次读取同一内容的工作。',
+    definition:
+      '缓存输入 token 是通过复用已有模型状态处理的输入 token，无需为其重新执行完整 prefill。',
+    explanation:
+      '前几轮对话经常再次出现在后续提示词中。是否命中缓存取决于状态是否保留、请求路由和可用存储。服务商可能对缓存输入、未缓存输入和生成输出分别定价，收入计算也必须区分这三类 token。',
+    significance:
+      '缓存 token 仍属于已服务的工作负载，但它不代表与输出 token 相同的新增计算量或销售价值。潜在前缀复用比例、实测缓存命中率和缓存命中的售价，是不同的量。',
+    benchmarkContext:
+      'Rubin 文章在多项比较中使用总 token 吞吐量，并在经济性讨论中区分缓存输入、未缓存输入和输出价格。不能直接将总 token 倍率套用到仅针对输出的价格上估算收入。',
+  },
+  'billable-utilization': {
+    term: '可计费利用率',
+    aliases: ['billable utilization', '可计费容量利用率'],
+    plainEnglish: '可计费利用率表示在估算期间，有多少建模服务容量实际用于付费流量。',
+    definition: '可计费利用率是经济模型中假定用于产生收入的流量占可用服务容量的比例。',
+    explanation:
+      '基准测试确定某一运行点的 token 速率；换算成年收入时，还需假设这些容量长期能售出多少。容量闲置或需求不足会降低可计费产出，即使服务栈在有负载时能达到实测速率。',
+    significance:
+      '这一假设不同于 GPU 利用率遥测或模型 FLOPS 利用率。加速器繁忙并不能证明其工作能够计费，峰值吞吐量测量也不能证明全年都有足够的客户需求。',
+    benchmarkContext:
+      'Rubin 文章的年收入和建模利润示例采用 75 TPS、60% 利用率。引用结果时须同时保留这些假设，不能将其表述为实际收入或纯硬件性能测量。',
+    measurement: { label: '经济模型假设', value: '估算期间售出的服务容量比例（%）' },
+  },
+  'annual-revenue-per-gigawatt': {
+    term: '每吉瓦年收入',
+    aliases: ['annual revenue per gigawatt', '每 GW 收入', '每吉瓦市电容量年 token 收入'],
+    plainEnglish: '这项估算计算在固定一吉瓦数据中心市电容量下，一年的 token 销售可能带来多少收入。',
+    definition: '每吉瓦年收入是将一年的建模 token 销售收入归一化到一吉瓦全口径市电容量后的指标。',
+    explanation:
+      '先在指定交互性目标下，用利用率假设把功率归一化吞吐量换算为全年可计费 token 数；再分别对缓存输入、未缓存输入和输出应用各自价格，最后合计收入。吉瓦表示功率额度，年度则提供时间维度。',
+    significance:
+      '该指标把服务效率与电力受限的商业模型联系起来。它不仅取决于实测吞吐量，还取决于需求、价格、token 构成和利用率；扣除成本及适用的许可费后，才能讨论利润。',
+    benchmarkContext:
+      'Rubin 文章在 75 TPS、60% 利用率下展示年收入。每 GW 数值属于归一化估算，不能证明测试实际部署了一吉瓦设备，也不能证明预计 token 数已经售出。',
+    measurement: { label: '常用单位', value: '美元/市电吉瓦/年' },
+  },
+  'modeled-profit-per-gigawatt': {
+    term: '每吉瓦建模利润',
+    aliases: ['modeled profit per gigawatt', '每 GW 利润', '每吉瓦市电容量年建模利润'],
+    plainEnglish:
+      '该估算从一吉瓦市电容量对应的年度 token 收入中，扣除建模服务成本和适用的模型许可费。',
+    definition:
+      '每吉瓦建模利润是在年度 token 收入中扣除模型所包含的成本和许可费，再按一吉瓦全口径市电容量归一化的结果。',
+    explanation:
+      '该结果沿用收入模型的交互性、token 价格、缓存构成和利用率假设。计算费用使用选定的自有或租赁成本口径。如果模型许可费按收入比例收取，应基于收入计算，而不是先扣除计算费用后的余额。',
+    significance:
+      '这是具有明确口径的经济估算，并非经审计的企业净利润。模型之外的成本会影响实际利润；即使硬件基准性能不变，需求不足或 token 价格下降也会降低收益。',
+    benchmarkContext:
+      'Rubin 文章的 75 TPS 示例采用 60% 利用率，并假设采用 MIT 许可的 DeepSeek V4 Pro 无需模型许可费。将 GW 结果线性缩放到较小部署时，仍沿用这些假设，并非实测的集群利润。',
+    measurement: { label: '常用单位', value: '建模利润美元/市电吉瓦/年' },
+  },
+  'utility-power-budget': {
+    term: '市电功率预算',
+    aliases: ['utility power budget', '全口径市电功率', '数据中心电力额度'],
+    plainEnglish: '市电功率预算是整个数据中心可用的供电容量，包含为服务器供电和制冷的配套设备。',
+    definition: '市电功率预算是在市电接入边界，为 IT 设备和配套基础设施配置的设施供电容量。',
+    explanation:
+      '加速器 TDP 描述组件级设计包络。设施预算还需容纳主机、网络、电力转换、制冷以及口径内的其他开销。在计算能部署多少硬件或提供多少 token 吞吐量之前，必须统一说明系统边界。',
+    significance:
+      '如果一个系统只计算芯片功耗，另一个却计算市电功耗，效率比值就会失真。配置容量与运行实测功耗回答的也是不同问题：前者描述部署额度，后者描述特定负载下的消耗。',
+    benchmarkContext:
+      'Rubin 文章按市电 MW 归一化吞吐量，并按全口径市电 GW 归一化年度经济指标。DSX MaxLPS 部分讨论利用工作负载功耗画像，在该额度内增加硬件部署，而不是把 TDP 当作推理实测功耗。',
+  },
+  'dsx-maxlps': {
+    term: 'DSX MaxLPS',
+    aliases: ['NVIDIA DSX MaxLPS', '动态功率调配'],
+    plainEnglish:
+      'DSX MaxLPS 根据工作负载需求管理数据中心功率，以利用保守峰值供电规划下闲置的容量。',
+    definition:
+      'DSX MaxLPS 是 Rubin 文章讨论的 NVIDIA 功率管理方案，用于在受限的数据中心电力额度内动态管理功率。',
+    explanation:
+      '如果按所有加速器同时达到峰值功耗规划供电，而推理实际功耗低于设计包络，就会留下闲置容量。文章描述了对当前及代表性未来负载进行功耗分析，再在数据中心内调配功率，从而在现有电力容量内提高部署密度。',
+    significance:
+      '可获得的空间取决于实际负载行为和安全的功率控制策略。它不会使供电容量无限增长，也不保证增加加速器后在任何需求模式下都能维持延迟。功耗画像必须覆盖一个有利基准点之外的条件。',
+    benchmarkContext:
+      'Rubin 文章在讨论 MaxLPS 时提到后续 PowerX 集成，但没有在展示的 AgentX 曲线中单独测量 MaxLPS 的加速效果。因此，不能把这些结果解释成该功能贡献的直接测量。',
+  },
+  'vera-rubin': {
+    term: 'Vera Rubin',
+    aliases: ['Vera Rubin 平台', 'Rubin GPU', 'Vera CPU', 'VR NVL72'],
+    plainEnglish: 'Vera Rubin 是 NVIDIA 的平台，组合 Rubin GPU、Vera CPU 及配套的互连与网络组件。',
+    definition:
+      'Vera Rubin 是 NVIDIA 的平台，文章将其描述为 Rubin GPU、Vera CPU、NVLink 6 Switch、ConnectX-9、BlueField-4 和 Spectrum-6 六款产品的协同设计。',
+    explanation:
+      '平台名称涵盖的并不只有加速器。Rubin NVL72 文章评估了采用早期预发布 TensorRT-LLM 软件的完整服务配置，并注明量产 SKU 的 TDP 为 2300 W、每个计算托盘配有 1.5 TB CPU LPDDR5X，不能将所有已公布配置视为相同。',
+    significance:
+      '智能体性能取决于计算、内存容量、通信和服务软件的相互作用。实测优势不能只归因于单一组件；机架级结果也不能证明所有模型或延迟目标下都有同样的提升。',
+    benchmarkContext:
+      '将 Vera Rubin 与 GB300 或单节点系统比较时，应保留文章的模型、引擎、精度、工作负载及交互性目标。已发布结果对应一个软件快照，文中对后续提升的预期属于预测，而非测量。',
+  },
+  'extreme-co-design': {
+    term: '极致协同设计',
+    aliases: ['extreme co-design', '平台协同设计', '软硬件协同设计'],
+    plainEnglish: '协同设计把相互依赖的系统组件一起开发，减少其他环节的瓶颈对局部性能提升的抵消。',
+    definition:
+      '极致协同设计是 Rubin 文章使用的术语，指围绕目标工作负载，协调开发加速器、主机、互连和网络产品。',
+    explanation:
+      '更快的 GPU 仍可能等待内存、通信或请求调度。联合设计这些组件，会改变服务栈能够使用的资源。文章列出了六款协同产品：Rubin GPU、Vera CPU、NVLink 6 Switch、ConnectX-9、BlueField-4 和 Spectrum-6。',
+    significance:
+      '这一概念关注完整系统性能，而不只看峰值算力。它是一种架构设计方法，不是基准指标，也不是通过独立实验验证的某个吞吐量倍率的归因。',
+    benchmarkContext:
+      'AgentX 在多轮流量下测量最终软硬件配置。Rubin 文章并未分别改变六款产品来做控制变量实验，因此不能将实测增益分配给各组件，也不能据此确定通用的协同设计加速倍数。',
+  },
 };
 
 const entries = getAllGlossaryEntries().map((entry) => {
diff --git a/packages/app/src/lib/glossary.test.ts b/packages/app/src/lib/glossary.test.ts
index 88f8db199..ee7a16591 100644
--- a/packages/app/src/lib/glossary.test.ts
+++ b/packages/app/src/lib/glossary.test.ts
@@ -75,6 +75,57 @@ describe('glossary content', () => {
 
     expect(referencedArticles).toEqual(new Set(getAllPosts().map((post) => post.slug)));
   });
+
+  it.each([
+    'multi-turn-inference',
+    'subagent-bursts',
+    'p90-interactivity',
+    'end-to-end-latency',
+    'cached-input-tokens',
+    'billable-utilization',
+    'annual-revenue-per-gigawatt',
+    'modeled-profit-per-gigawatt',
+    'utility-power-budget',
+    'dsx-maxlps',
+    'vera-rubin',
+    'extreme-co-design',
+  ])(
+    'makes Rubin concept %s discoverable in both locales with its article and related terms',
+    (slug) => {
+      for (const entry of [getGlossaryEntry(slug), getZhGlossaryEntry(slug)]) {
+        expect(entry, slug).toBeDefined();
+        expect(entry?.articleSlugs).toContain('vera-rubin-nvl72-agentic-inference');
+        expect(entry?.relatedTerms.length).toBeGreaterThanOrEqual(3);
+      }
+      expect(getZhGlossaryEntry(slug)?.definition).not.toBe(getGlossaryEntry(slug)?.definition);
+    },
+  );
+
+  it('separates percentile streaming speed from response completion and normalized interactivity', () => {
+    const p90 = getGlossaryEntry('p90-interactivity')!;
+    expect(p90.measurement?.value).toContain('1000 / P90 full-response ITL (ms)');
+    expect(p90.relatedTerms).toContain('end-to-end-latency');
+    expect(getGlossaryEntry('interactivity')?.relatedTerms).toContain(p90.slug);
+    expect(getGlossaryEntry('end-to-end-latency')?.relatedTerms).toContain(
+      'e2e-normalized-interactivity',
+    );
+    expect(getZhGlossaryEntry(p90.slug)?.measurement?.value).toContain(
+      '1000 / P90 全响应 ITL（毫秒）',
+    );
+  });
+
+  it('keeps NVL72 platform generations and component versus facility power distinct', () => {
+    for (const lookup of [getGlossaryEntry, getZhGlossaryEntry]) {
+      const nvl72 = lookup('nvl72')!;
+      expect(nvl72.aliases).toContain('Vera Rubin NVL72');
+      expect(nvl72.explanation).toContain('NVLink 5');
+      expect(nvl72.explanation).toContain('NVLink 6');
+      expect(lookup('vera-rubin')?.relatedTerms).toContain(nvl72.slug);
+      expect(lookup('utility-power-budget')?.relatedTerms).toContain('tdp');
+    }
+    expect(getGlossaryEntry('tdp')?.aliases).not.toContain('all-in power');
+    expect(getZhGlossaryEntry('tdp')?.aliases).not.toContain('全部包含功耗');
+  });
 });
 
 describe('Chinese glossary content', () => {
diff --git a/packages/app/src/lib/glossary.ts b/packages/app/src/lib/glossary.ts
index 7f8e2135f..1bddc5b6e 100644
--- a/packages/app/src/lib/glossary.ts
+++ b/packages/app/src/lib/glossary.ts
@@ -236,16 +236,16 @@ const entries = [
     plainEnglish:
       'Throughput is how much total work the system gets done each second across everyone using it.',
     definition:
-      'Throughput is the total rate at which an inference system produces tokens across all active requests.',
+      'Throughput is the rate of token processing across requests. Output throughput counts generated tokens; total token throughput counts input and output tokens under the stated benchmark accounting.',
     explanation:
       'InferenceX commonly normalizes throughput as tokens per second per chip so systems of different sizes can be compared. Higher batching or concurrency often raises aggregate throughput because weight reads and compute are amortized across more requests, but individual users may receive tokens more slowly.',
     significance:
       'Maximum throughput captures only one operating point. A system can lead in tokens per second while operating at interactivity too low for a real-time product. The useful comparison is throughput at a latency or interactivity target appropriate to the workload.',
     benchmarkContext:
-      'On an InferenceX chart, throughput is read together with interactivity across the full concurrency sweep. The Pareto frontier removes operating points that are worse on both axes.',
+      'On an InferenceX chart, throughput is read together with interactivity across the full concurrency sweep. The Rubin AgentX article reports total token throughput, including reused input, rather than only newly generated output. Check the token accounting before comparing that curve with an output-only result.',
     measurement: { label: 'Typical unit', value: 'tokens/second/chip (tok/s/chip)' },
     relatedTerms: ['interactivity', 'concurrency', 'pareto-frontier', 'iso-interactivity'],
-    articleSlugs: [INFERENCEMAX, INFERENCEX_V2, SGLANG_056],
+    articleSlugs: [INFERENCEMAX, INFERENCEX_V2, SGLANG_056, VR_RUBIN_AGENTIC],
   },
   {
     slug: 'interactivity',
@@ -261,7 +261,7 @@ const entries = [
     significance:
       'Different products need different operating points. Voice and interactive coding demand high token rates, while offline summarization can trade interactivity for much more aggregate throughput. Comparing hardware at unmatched interactivity can therefore produce a misleading winner.',
     benchmarkContext:
-      'InferenceX plots tokens per second per user against throughput or cost. Iso-interactivity tables interpolate each system’s Pareto frontier at the same token rate so the comparison holds user experience constant. Because this axis ignores the wait before the first token, agentic charts also offer E2E Normalized Interactivity, which folds TTFT into the same unit.',
+      'InferenceX plots tokens per second per user against throughput or cost. The Rubin AgentX article uses the reciprocal of P90 full-response inter-token latency for P90 interactivity. Matching that speed does not match TTFT or end-to-end latency. E2E Normalized Interactivity is a separate metric that includes the initial wait.',
     measurement: { label: 'Typical unit', value: 'tokens/second/user (tok/s/user)' },
     relatedTerms: [
       'time-per-output-token',
@@ -269,8 +269,10 @@ const entries = [
       'iso-interactivity',
       'e2e-normalized-interactivity',
       'latency',
+      'p90-interactivity',
+      'end-to-end-latency',
     ],
-    articleSlugs: [INFERENCEMAX, INFERENCEX_V2, MI355X_KIMI, TILERT],
+    articleSlugs: [INFERENCEMAX, INFERENCEX_V2, MI355X_KIMI, TILERT, VR_RUBIN_AGENTIC],
   },
   {
     slug: 'latency',
@@ -399,11 +401,18 @@ const entries = [
     explanation:
       'Benchmark runs rarely land at identical tok/s/user values because each recipe has different concurrency points. An iso-interactivity comparison interpolates each Pareto frontier at a shared target and then compares throughput, cost, or efficiency there.',
     significance:
-      'Holding user experience constant avoids a common benchmark error: declaring a high-throughput system faster when it reaches that throughput only by serving every request more slowly.',
+      'Matching streaming speed avoids declaring a system faster merely because it serves more requests at a slower token rate. It does not hold the entire user experience constant: initial waiting time and total response duration still need separate comparisons.',
     benchmarkContext:
       'InferenceX articles use iso-interactivity tables for hardware, precision, and software comparisons. Values outside a measured frontier are marked unreachable and are not extrapolated beyond observed data. The frontier is always built on throughput against interactivity; cost per million tokens and joules per token are then derived from the interpolated throughput rather than splined on their own, because each is a per-chip constant divided by that throughput and splining it separately would break the identity between knots.',
     relatedTerms: ['interactivity', 'pareto-frontier', 'throughput', 'performance-per-dollar'],
-    articleSlugs: [B200_GLM5, B200_MINIMAX, B200_KIMI, GB300_DSV4, AGENTX_GLM_SGLANG],
+    articleSlugs: [
+      B200_GLM5,
+      B200_MINIMAX,
+      B200_KIMI,
+      GB300_DSV4,
+      AGENTX_GLM_SGLANG,
+      VR_RUBIN_AGENTIC,
+    ],
   },
   {
     slug: 'input-output-sequence-length',
@@ -465,7 +474,7 @@ const entries = [
     significance:
       'Peak chip FLOPS account for only part of serving economics. Memory, networking, software maturity, numerical precision, and achievable utilization all affect the measured output behind the ratio.',
     benchmarkContext:
-      'InferenceX compares infrastructure perf/$ at matched interactivity and names the TCO inputs used. Ratios should not be carried across different model, sequence-length, precision, or latency regimes. Cost per million tokens and the total, input, and output infrastructure purchasing-power axes express those TCO economics.',
+      'InferenceX compares infrastructure perf/$ at matched interactivity and names the TCO inputs used. The Rubin article’s approximately 67x result is scoped to 170 TPS, owning costs, and the specified TRTLLM NVFP4 Dense configurations. It is not a generation-wide multiplier: the ratio changes with the target, comparison engine, and owning versus rental cost basis.',
     relatedTerms: [
       'cost-per-million-tokens',
       'tokens-per-dollar',
@@ -480,6 +489,7 @@ const entries = [
       MI355X_GLM5,
       AGENTX_DSV4_MI355X_B200,
       TPU_IRONWOOD,
+      VR_RUBIN_AGENTIC,
     ],
   },
   {
@@ -496,14 +506,14 @@ const entries = [
     significance:
       'Using TCO instead of list price makes cross-system economics more realistic, especially for rack-scale products whose networking and power infrastructure differ. The result remains a model and should be read with its assumptions.',
     benchmarkContext:
-      'InferenceX combines SemiAnalysis AI Cloud TCO inputs with observed tok/s/chip. This separates hourly system cost from the software and workload behavior that determines how many tokens that hour produces.',
+      'InferenceX combines SemiAnalysis AI Cloud TCO inputs with observed tok/s/chip. The Rubin article distinguishes owning at large hyperscaler volume, including amortized hardware, networking, facilities, power, and capital costs, from the customer price of a three-year cloud reservation. These are alternative cost bases, not costs to add together; rental pricing also reflects the provider’s commercial terms.',
     relatedTerms: [
       'cost-per-million-tokens',
       'performance-per-dollar',
       'tokens-per-megawatt',
       'throughput',
     ],
-    articleSlugs: [INFERENCEMAX, INFERENCEX_V2, GB200_R1, VR_RUBIN, JALAPENO],
+    articleSlugs: [INFERENCEMAX, INFERENCEX_V2, GB200_R1, VR_RUBIN, JALAPENO, VR_RUBIN_AGENTIC],
   },
   {
     slug: 'tokens-per-megawatt',
@@ -519,7 +529,7 @@ const entries = [
     significance:
       'Power availability is often the binding constraint on new AI deployments. A system that produces more tokens per provisioned megawatt can serve more demand from the same utility allocation even if its individual accelerators draw more power.',
     benchmarkContext:
-      'Compare tokens/MW at the same model, workload shape, precision, and interactivity. Otherwise a high-throughput low-interactivity point can appear efficient while failing the target user experience. Energy per token expresses the same provisioned budget per unit of output, and InferenceX additionally reports measured accelerator energy where the telemetry is trustworthy.',
+      'The Rubin article compares total tok/s per utility MW at matched P90 interactivity, with interpolation only inside each engine’s measured range. Preserve the engine, precision, caching, and parallelism labels when quoting a ratio. The provisioned utility-power denominator is a capacity model, distinct from measured accelerator power or energy telemetry.',
     measurement: { label: 'Typical unit', value: 'tokens/second per provisioned utility MW' },
     relatedTerms: [
       'throughput',
@@ -527,8 +537,10 @@ const entries = [
       'interactivity',
       'total-cost-of-ownership',
       'performance-per-dollar',
+      'utility-power-budget',
+      'annual-revenue-per-gigawatt',
     ],
-    articleSlugs: [INFERENCEMAX, DEEPSEEK_V4, VR_RUBIN, JALAPENO],
+    articleSlugs: [INFERENCEMAX, DEEPSEEK_V4, VR_RUBIN, JALAPENO, VR_RUBIN_AGENTIC],
   },
   {
     slug: 'prefill',
@@ -607,7 +619,7 @@ const entries = [
     definition:
       'Prefix caching reuses KV-cache state when multiple requests begin with the same token sequence.',
     explanation:
-      'A repeated system prompt, shared document, or common conversation prefix can reuse cached states. A cache hit can reduce prompt computation and time to first token.',
+      'A repeated system prompt, shared document, or common conversation prefix can reuse cached states. In a growing agent session, earlier outputs become part of later inputs, increasing potential prefix reuse. Actual hits still depend on the state remaining available and reachable; eviction or fresh subagent contexts can require new prefill.',
     significance:
       'Production workloads with repeated prefixes may outperform synthetic random-token benchmarks. The benefit depends on hit rate, cache capacity, eviction policy, and whether requests route to workers that hold the needed state.',
     benchmarkContext:
@@ -619,8 +631,17 @@ const entries = [
       'prefill',
       'time-to-first-token',
       'nvidia-dynamo',
+      'multi-turn-inference',
+      'cached-input-tokens',
+    ],
+    articleSlugs: [
+      AGENTIC_WORKLOADS,
+      INFERENCEX_V2,
+      GB200_KIMI,
+      KIMI_K3,
+      AGENTX_V3,
+      VR_RUBIN_AGENTIC,
     ],
-    articleSlugs: [AGENTIC_WORKLOADS, INFERENCEX_V2, GB200_KIMI, KIMI_K3, AGENTX_V3],
   },
   {
     slug: 'disaggregated-inference',
@@ -890,13 +911,13 @@ const entries = [
     definition:
       'NVLink is NVIDIA’s high-bandwidth accelerator interconnect for moving data directly among chips within a scale-up domain.',
     explanation:
-      'NVSwitch systems connect multiple NVLink endpoints so collectives can span an eight-chip server or, in NVL72 products, a 72-chip rack-scale domain. That bandwidth is distinct from the InfiniBand or Ethernet fabric connecting separate systems.',
+      'NVSwitch systems connect multiple NVLink endpoints so collectives can span a node or a 72-chip rack-scale domain. The generation depends on the platform: Blackwell NVL72 uses NVLink 5, while the Rubin article identifies NVLink 6 Switch as part of Vera Rubin. This scale-up fabric is distinct from the networking used between systems.',
     significance:
       'Large TP and especially wide-EP groups exchange data at every generated token. Keeping those collectives on NVLink can make a rack-scale recipe faster than a similar chip count spread across scale-out links.',
     benchmarkContext:
       'InferenceX compares both node-level chips and NVL72 systems. Interpret the system topology and parallel group width before attributing the entire result to per-chip compute.',
     relatedTerms: ['scale-up-vs-scale-out', 'all-to-all', 'all-reduce', 'wide-expert-parallelism'],
-    articleSlugs: [GB200_R1, GB200_KIMI, INFERENCEX_V2, VR_RUBIN],
+    articleSlugs: [GB200_R1, GB200_KIMI, INFERENCEX_V2, VR_RUBIN, VR_RUBIN_AGENTIC],
   },
   {
     slug: 'quantization',
@@ -1773,14 +1794,14 @@ const entries = [
   {
     slug: 'nvl72',
     term: 'NVL72',
-    aliases: ['GB200 NVL72', 'GB300 NVL72', 'rack-scale system'],
+    aliases: ['GB200 NVL72', 'GB300 NVL72', 'Vera Rubin NVL72', 'rack-scale system'],
     category: 'Hardware',
     plainEnglish:
       'NVL72 is a rack where 72 accelerators share one high-speed fabric, so they behave more like a single large machine than a cluster.',
     definition:
       'NVL72 is a rack-scale NVIDIA system that places 72 accelerators in a single NVLink scale-up domain rather than in separate eight-chip nodes.',
     explanation:
-      'The dashboard specs record NVLink 5.0 at 900 GB/s per chip unidirectional across a scale-up world size of 72, switched through NVSwitch. A conventional node keeps that bandwidth among eight chips and falls back to slower scale-out networking beyond them, so the difference is not raw speed but how many chips are reachable before the fabric changes character.',
+      'NVL72 describes the size of the NVLink domain, not one fixed chip generation or bandwidth. GB200 and GB300 systems use Blackwell-generation hardware and NVLink 5; Vera Rubin pairs Rubin GPUs with Vera CPUs and NVLink 6 Switch. Compare the specific platform rather than applying Blackwell specifications to every NVL72 rack.',
     significance:
       'Techniques whose cost is dominated by collectives change economics inside a large domain. Wide expert parallelism spreads experts across many chips and pays all-to-all traffic for every token, which is tolerable at scale-up bandwidth and often is not across a scale-out fabric.',
     benchmarkContext:
@@ -1792,7 +1813,15 @@ const entries = [
       'all-to-all',
       'total-cost-of-ownership',
     ],
-    articleSlugs: [GB200_R1, GB300_DSV4, GB200_KIMI, VR_RUBIN, AGENTX_K3_ATOM, JALAPENO],
+    articleSlugs: [
+      GB200_R1,
+      GB300_DSV4,
+      GB200_KIMI,
+      VR_RUBIN,
+      AGENTX_K3_ATOM,
+      JALAPENO,
+      VR_RUBIN_AGENTIC,
+    ],
   },
   {
     slug: 'atom',
@@ -2330,7 +2359,7 @@ const entries = [
     slug: 'tdp',
     term: 'Thermal design power',
     abbreviation: 'TDP',
-    aliases: ['TDP', 'board power', 'all-in power'],
+    aliases: ['TDP', 'thermal power envelope'],
     category: 'Hardware',
     plainEnglish:
       'TDP is the sustained power a chip is designed to draw and shed as heat, the headline wattage on every accelerator spec sheet.',
@@ -2341,9 +2370,9 @@ const entries = [
     significance:
       'Power has become the binding constraint of AI buildout, ahead of capital in many markets. Rising per chip TDP forced the shift to liquid cooling and made performance per watt, not just performance per dollar, a primary axis for comparing silicon generations.',
     benchmarkContext:
-      'InferenceX derives energy per token and tokens per megawatt using per chip all in power figures that include cooling and infrastructure overhead above TDP, and the PowerX workstream is extending this from rated figures toward measured draw during runs.',
+      'The Rubin article specifies a 2300 W TDP production SKU but normalizes facility throughput with all-in utility power. TDP is neither measured inference draw nor total facility power. Its DSX MaxLPS discussion concerns workload-aware power provisioning; the article describes finer-grained PowerX measurements as upcoming rather than treating the displayed curves as measured-power results.',
     relatedTerms: ['energy-per-token', 'tokens-per-megawatt', 'pue', 'total-cost-of-ownership'],
-    articleSlugs: [INFERENCEX_V2, VR_RUBIN],
+    articleSlugs: [INFERENCEX_V2, VR_RUBIN, VR_RUBIN_AGENTIC],
   },
   {
     slug: 'pue',
@@ -3548,6 +3577,265 @@ const entries = [
     ],
     articleSlugs: [TPU_IRONWOOD, AGENTX_V3, AGENTIC_WORKLOADS],
   },
+  {
+    slug: 'multi-turn-inference',
+    term: 'Multi-turn inference',
+    aliases: ['multi-turn serving', 'multi-turn workload'],
+    category: 'Agentic inference',
+    plainEnglish:
+      'A multi-turn session sends several related requests to the model, carrying earlier conversation and tool results into later prompts.',
+    definition:
+      'Multi-turn inference serves a sequence of related model requests whose inputs include state or conversation history from earlier turns.',
+    explanation:
+      'In agentic workloads, a session may span tens or hundreds of turns. Generated output and tool results extend the next prompt, so much of its input may already have cached state. Tool execution and dependent requests also change when work reaches the server.',
+    significance:
+      'A sequence of independent prompts does not reproduce these dependencies or the growing cache working set. Cache eviction can force repeated prefill, while a slow response can delay the next turn even when aggregate throughput appears high.',
+    benchmarkContext:
+      'The Rubin article identifies multi-turn structure as a defining AgentX workload property. Compare these results with the same agentic scenario rather than transferring rankings from fixed-length, independent-request tests.',
+    relatedTerms: ['agentx', 'trace-replay', 'prefix-caching', 'long-context', 'subagent-bursts'],
+    articleSlugs: [VR_RUBIN_AGENTIC, AGENTX_V3],
+  },
+  {
+    slug: 'subagent-bursts',
+    term: 'Subagent bursts',
+    aliases: ['sub-agent bursts', 'bursty agent traffic'],
+    category: 'Agentic inference',
+    plainEnglish:
+      'An agent can launch several short-lived helpers together, suddenly adding requests and new context for the server to hold.',
+    definition:
+      'Subagent bursts are short periods of increased inference demand caused by an agent launching multiple subordinate tasks with their own request sequences.',
+    explanation:
+      'A parent session can have a long reusable prefix while its new branches start with fresh context. These branches create overlapping prefill and decode work and temporarily enlarge the KV-cache working set. Their start times and dependencies matter as much as their request count.',
+    significance:
+      'A high average cache-hit rate can hide periods of heavy new-prefill demand. Capacity planning must account for burst timing, cache eviction, and the latency of branches whose completion blocks the parent task.',
+    benchmarkContext:
+      'The Rubin article names subagent bursts alongside multi-turn sessions, long context, and high prefix reuse. AgentX comparisons therefore concern a time-varying request pattern, not a constant batch of identical prompts.',
+    relatedTerms: ['subagent', 'multi-turn-inference', 'concurrency', 'kv-cache', 'prefill'],
+    articleSlugs: [VR_RUBIN_AGENTIC, AGENTIC_WORKLOADS],
+  },
+  {
+    slug: 'p90-interactivity',
+    term: 'P90 interactivity',
+    aliases: ['P90 TPS', 'P90 token rate', 'P90 streaming speed'],
+    category: 'Benchmark metrics',
+    plainEnglish:
+      'P90 interactivity expresses a slower-tail streaming interval as a token rate, so higher values mean faster response streaming.',
+    definition:
+      'In the Rubin AgentX analysis, P90 interactivity is the reciprocal of P90 full-response inter-token latency, expressed in tokens per second per user.',
+    explanation:
+      'Take the P90 latency statistic first, then invert it with the appropriate unit conversion. A P90 full-response inter-token latency of 10 milliseconds corresponds to 100 tok/s/user. This is not the 90th percentile of token rates: reciprocation reverses the ordering of positive values.',
+    significance:
+      'The percentile and latency definition determine what speed target a comparison enforces. This metric excludes the initial wait before streaming; equal P90 interactivity can coexist with very different time to first token and end-to-end latency.',
+    benchmarkContext:
+      'The Rubin article compares engine-specific frontiers at matched P90 interactivity and interpolates only within measured ranges. Preserve the target and the comparison engine when citing its throughput, cost, or power ratios.',
+    measurement: {
+      label: 'Relationship',
+      value: 'P90 interactivity = 1000 / P90 full-response ITL (ms)',
+    },
+    relatedTerms: [
+      'interactivity',
+      'time-per-output-token',
+      'iso-interactivity',
+      'end-to-end-latency',
+    ],
+    articleSlugs: [VR_RUBIN_AGENTIC],
+  },
+  {
+    slug: 'end-to-end-latency',
+    term: 'End-to-end latency',
+    abbreviation: 'E2E latency',
+    aliases: ['E2EL', 'request completion time', 'P90 E2E latency'],
+    category: 'Benchmark metrics',
+    plainEnglish:
+      'End-to-end latency is the time from sending a model request until its complete answer has arrived, including the initial wait.',
+    definition:
+      'Request end-to-end latency measures elapsed time from request submission to receipt of the final response token.',
+    explanation:
+      'It includes time to first token and the subsequent streaming duration. Longer answers take longer even at the same token rate, so comparisons need compatible output-length distributions. P90 E2E latency is the 90th percentile of request completion times, not a sum of separately calculated P90 stage latencies.',
+    significance:
+      'Agents often wait for a complete response before executing a tool or starting a dependent turn. Fast streaming alone does not bound that wait. Request latency also differs from the duration of a whole agent task, which can include many model calls and tool executions.',
+    benchmarkContext:
+      'The Rubin article plots P90 E2E latency separately from P90 interactivity. Read both to distinguish improved streaming cadence from reduced queueing, prefill, or overall response time.',
+    measurement: { label: 'Typical unit', value: 'seconds per completed request' },
+    relatedTerms: [
+      'latency',
+      'time-to-first-token',
+      'p90-interactivity',
+      'e2e-normalized-interactivity',
+    ],
+    articleSlugs: [VR_RUBIN_AGENTIC],
+  },
+  {
+    slug: 'cached-input-tokens',
+    term: 'Cached input tokens',
+    aliases: ['cached prompt tokens', 'cache-read tokens'],
+    category: 'Serving',
+    plainEnglish:
+      'Cached input tokens are parts of a prompt whose earlier processing can be reused, reducing the work needed to read the prompt again.',
+    definition:
+      'Cached input tokens are input tokens served using reusable cached model state rather than recomputing their full prefill.',
+    explanation:
+      'Earlier conversation turns often reappear in later prompts. Whether those tokens hit the cache depends on retained state, routing, and available storage. A provider may price cached input separately from uncached input and generated output, so the three token classes must remain separate in revenue calculations.',
+    significance:
+      'A cached token still belongs to the served workload but does not imply the same new computation or sales value as an output token. Potential prefix reuse, measured cache-hit rate, and the price charged for a cache hit describe different quantities.',
+    benchmarkContext:
+      'The Rubin article uses total token throughput for several comparisons and distinguishes cached-input, uncached-input, and output prices in its economics discussion. A total-token multiplier cannot be applied directly to an output-only price to estimate revenue.',
+    relatedTerms: [
+      'prefix-caching',
+      'prefix-cache-hit-rate',
+      'throughput',
+      'annual-revenue-per-gigawatt',
+    ],
+    articleSlugs: [VR_RUBIN_AGENTIC, AGENTX_V3],
+  },
+  {
+    slug: 'billable-utilization',
+    term: 'Billable utilization',
+    aliases: ['billable capacity utilization', 'revenue utilization'],
+    category: 'Benchmark metrics',
+    plainEnglish:
+      'Billable utilization is the share of modeled serving capacity that is actually used for paid traffic over the period being estimated.',
+    definition:
+      'Billable utilization is the fraction of available serving capacity assumed to produce revenue-generating traffic in an economic model.',
+    explanation:
+      'A benchmark establishes a token rate at an operating point. Annualization then needs an assumption about how much of that capacity can be sold over time. Idle capacity and insufficient demand reduce billable output even if the serving stack can achieve its measured rate when loaded.',
+    significance:
+      'This assumption is distinct from GPU utilization telemetry or model FLOPS utilization. A busy accelerator does not prove that its work is billable, and a measured peak-throughput result does not establish year-round customer demand.',
+    benchmarkContext:
+      'The Rubin article’s annual revenue and modeled profit example uses 60% utilization at 75 TPS. Keep that assumption with the result rather than presenting the estimate as realized revenue or a hardware-only performance measurement.',
+    measurement: {
+      label: 'Economic assumption',
+      value: 'share of serving capacity sold over time (%)',
+    },
+    relatedTerms: [
+      'gpu-utilization',
+      'model-flops-utilization',
+      'annual-revenue-per-gigawatt',
+      'modeled-profit-per-gigawatt',
+    ],
+    articleSlugs: [VR_RUBIN_AGENTIC],
+  },
+  {
+    slug: 'annual-revenue-per-gigawatt',
+    term: 'Annual revenue per gigawatt',
+    aliases: ['revenue per GW', 'annual token revenue per utility GW'],
+    category: 'Benchmark metrics',
+    plainEnglish:
+      'This estimate asks how much token sales could earn in a year from a fixed gigawatt of datacenter utility power.',
+    definition:
+      'Annual revenue per gigawatt is modeled token-sales revenue over one year, normalized to one gigawatt of all-in utility power capacity.',
+    explanation:
+      'At a chosen interactivity target, convert power-normalized throughput into annual billable token volumes using the utilization assumption. Apply the respective prices to cached input, uncached input, and output volumes, then sum their revenue. A gigawatt is a power allocation; the year supplies the time dimension.',
+    significance:
+      'The result connects serving efficiency to a power-constrained business model. It depends on demand, prices, token mix, and utilization as well as measured throughput, and it does not show profit until costs and any license fees are deducted.',
+    benchmarkContext:
+      'The Rubin article presents annual revenue at 75 TPS and 60% utilization. Its per-GW values are normalized estimates, not evidence that a full gigawatt deployment was benchmarked or that the projected token volumes were sold.',
+    measurement: { label: 'Typical unit', value: 'USD per utility GW per year' },
+    relatedTerms: [
+      'tokens-per-megawatt',
+      'billable-utilization',
+      'cached-input-tokens',
+      'modeled-profit-per-gigawatt',
+      'utility-power-budget',
+    ],
+    articleSlugs: [VR_RUBIN_AGENTIC],
+  },
+  {
+    slug: 'modeled-profit-per-gigawatt',
+    term: 'Modeled profit per gigawatt',
+    aliases: ['profit per GW', 'annual modeled profit per utility GW'],
+    category: 'Benchmark metrics',
+    plainEnglish:
+      'This estimate subtracts modeled serving costs and applicable model-license fees from annual token revenue for a gigawatt of utility power.',
+    definition:
+      'Modeled profit per gigawatt is annual token revenue less the costs and license fees included in the model, normalized to an all-in utility gigawatt.',
+    explanation:
+      'The result inherits the revenue model’s interactivity, token prices, cache mix, and utilization assumptions. Compute expense uses the selected owning or rental cost basis. If a license fee is specified as a percentage of revenue, it is calculated on revenue rather than on the amount left after compute costs.',
+    significance:
+      'This is a defined economic estimate, not audited corporate net income. Costs outside the model can change realized profit, and weak demand or falling token prices can reduce earnings without changing the benchmark performance of the hardware.',
+    benchmarkContext:
+      'The Rubin article’s 75 TPS example assumes 60% utilization and no model-license fee for MIT-licensed DeepSeek V4 Pro. Its linear conversion from a GW to a smaller deployment holds the same assumptions; it is not a measured fleet-scale profit result.',
+    measurement: { label: 'Typical unit', value: 'modeled USD profit per utility GW per year' },
+    relatedTerms: [
+      'annual-revenue-per-gigawatt',
+      'billable-utilization',
+      'total-cost-of-ownership',
+      'utility-power-budget',
+    ],
+    articleSlugs: [VR_RUBIN_AGENTIC],
+  },
+  {
+    slug: 'utility-power-budget',
+    term: 'Utility power budget',
+    aliases: ['all-in utility power', 'provisioned utility power', 'datacenter power allocation'],
+    category: 'Hardware',
+    plainEnglish:
+      'A utility power budget is the electricity capacity available to the whole datacenter, including the equipment that powers and cools the servers.',
+    definition:
+      'A utility power budget is the provisioned facility power capacity available for IT equipment and supporting infrastructure at the utility boundary.',
+    explanation:
+      'Accelerator TDP covers a component-level design envelope. A facility budget must also accommodate hosts, networking, power conversion, cooling, and other included overhead. The system boundary must be stated consistently before using the budget to calculate how much hardware or token throughput fits.',
+    significance:
+      'Comparing one system at chip-only power with another at utility power biases the efficiency ratio. Provisioned capacity and measured operating draw also answer different questions: one describes the deployment allocation, while the other describes consumption during a specific workload.',
+    benchmarkContext:
+      'The Rubin article normalizes throughput per utility MW and annual economics per all-in utility GW. Its DSX MaxLPS discussion considers using workload power profiles to fit more hardware within that allocation without equating TDP to measured inference power.',
+    relatedTerms: ['tdp', 'pue', 'tokens-per-megawatt', 'dsx-maxlps'],
+    articleSlugs: [VR_RUBIN_AGENTIC],
+  },
+  {
+    slug: 'dsx-maxlps',
+    term: 'DSX MaxLPS',
+    aliases: ['NVIDIA DSX MaxLPS', 'dynamic power shifting'],
+    category: 'Software',
+    plainEnglish:
+      'DSX MaxLPS manages datacenter power around workload demand so operators can use capacity that conservative peak-power provisioning would leave unused.',
+    definition:
+      'DSX MaxLPS is NVIDIA’s power-management approach discussed in the Rubin article for dynamically managing power within a constrained datacenter allocation.',
+    explanation:
+      'Provisioning every accelerator for simultaneous peak draw can leave unused capacity when inference workloads consume less than their design envelopes. The article describes profiling current and representative future workloads, then steering power across the datacenter to support a denser deployment within the available power footprint.',
+    significance:
+      'The opportunity depends on actual workload behavior and safe power-control policies. It does not make utility capacity unlimited or guarantee that adding accelerators will preserve latency under every demand pattern. Workload profiles must cover conditions beyond one favorable benchmark point.',
+    benchmarkContext:
+      'The Rubin article describes MaxLPS alongside an upcoming PowerX integration. It does not isolate a measured MaxLPS speedup in the displayed AgentX curves, so those results should not be presented as a direct measurement of this feature’s contribution.',
+    relatedTerms: ['utility-power-budget', 'tdp', 'tokens-per-megawatt', 'energy-per-token'],
+    articleSlugs: [VR_RUBIN_AGENTIC],
+  },
+  {
+    slug: 'vera-rubin',
+    term: 'Vera Rubin',
+    aliases: ['Vera Rubin platform', 'Rubin GPU', 'Vera CPU', 'VR NVL72'],
+    category: 'Hardware',
+    plainEnglish:
+      'Vera Rubin is NVIDIA’s platform combining Rubin GPUs, Vera CPUs, and the interconnect and networking components around them.',
+    definition:
+      'Vera Rubin is the NVIDIA platform that the article describes as co-designed across Rubin GPU, Vera CPU, NVLink 6 Switch, ConnectX-9, BlueField-4, and Spectrum-6.',
+    explanation:
+      'The platform name covers more than an accelerator alone. The Rubin NVL72 article evaluates a complete serving configuration with early pre-release TensorRT-LLM software. It specifies a production SKU with 2300 W TDP and 1.5 TB of CPU LPDDR5X per compute tray, rather than treating every announced configuration as identical.',
+    significance:
+      'Agentic performance reflects the interaction of compute, memory capacity, communication, and serving software. A measured advantage cannot be assigned solely to one component, and a rack-level result does not establish an identical advantage for every model or latency target.',
+    benchmarkContext:
+      'Use the article’s model, engine, precision, workload, and interactivity target when comparing Vera Rubin with GB300 or single-node systems. The published results are a software snapshot; the article’s expectations for later gains are projections rather than measurements.',
+    relatedTerms: ['nvl72', 'nvlink', 'extreme-co-design', 'agentx', 'tensorrt-llm'],
+    articleSlugs: [VR_RUBIN_AGENTIC, VR_RUBIN],
+  },
+  {
+    slug: 'extreme-co-design',
+    term: 'Extreme co-design',
+    aliases: ['platform co-design', 'hardware-software co-design'],
+    category: 'Hardware',
+    plainEnglish:
+      'Co-design means developing connected parts of the system together so a gain in one part is not lost to a bottleneck elsewhere.',
+    definition:
+      'Extreme co-design is the Rubin article’s term for coordinated platform development across accelerator, host, interconnect, and networking products to serve the target workload.',
+    explanation:
+      'A faster GPU can still wait for memory, communication, or request scheduling. Designing these components together changes the resources available to the serving stack. The article names six coordinated products: Rubin GPU, Vera CPU, NVLink 6 Switch, ConnectX-9, BlueField-4, and Spectrum-6.',
+    significance:
+      'The concept directs attention to whole-system performance rather than peak compute alone. It is an architectural approach, not a benchmark metric or an experimentally isolated explanation for a particular throughput multiplier.',
+    benchmarkContext:
+      'AgentX measures the resulting hardware-and-software configuration under multi-turn traffic. The Rubin article’s comparison does not independently vary all six products, so it cannot allocate the measured gain to each component or establish a universal co-design speedup.',
+    relatedTerms: ['vera-rubin', 'nvlink', 'memory-bandwidth', 'inference-engine', 'agentx'],
+    articleSlugs: [VR_RUBIN_AGENTIC],
+  },
 ] as const satisfies readonly GlossaryEntry[];
 
 export type GlossaryPreview = Pick<
diff --git a/packages/app/src/lib/inference-labels.test.ts b/packages/app/src/lib/inference-labels.test.ts
index 0b2b64c6c..25658e580 100644
--- a/packages/app/src/lib/inference-labels.test.ts
+++ b/packages/app/src/lib/inference-labels.test.ts
@@ -1,17 +1,74 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { getHardwareConfig } from '@/lib/constants';
 import {
   getInferenceHardwareConfig,
   getInferenceRunLabel,
+  getOverlayLineLabel,
   getPointHardwareConfig,
   inferenceFrameworkLabelOverride,
+  shortRunTag,
 } from './inference-labels';
 
 const runUrl = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34926284365';
 const historicalUrl = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34926284364';
 const hwKey = 'mi355x_mori-sglang';
 
+describe('temporary DSpark UMBP run label', () => {
+  const dsparkUrl = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/35166686551';
+  const expiresAt = Date.parse('2026-10-09T01:32:00Z');
+
+  beforeEach(() => {
+    vi.spyOn(Date, 'now').mockReturnValue(Date.parse('2026-09-18T01:32:00Z'));
+  });
+  afterEach(() => vi.restoreAllMocks());
+
+  it.each([dsparkUrl, `${dsparkUrl}/attempts/1`, `${dsparkUrl}/attempts/5`])(
+    'labels the new run without changing identity: %s',
+    (url) => {
+      expect(inferenceFrameworkLabelOverride('mori-sglang', url)).toBe('MoRI UMBP SGLang');
+      expect(inferenceFrameworkLabelOverride('sglang-disagg', url)).toBe('MoRI UMBP SGLang');
+      expect(inferenceFrameworkLabelOverride('sglang', url)).toBeUndefined();
+      const config = getInferenceHardwareConfig(hwKey, undefined, [{ run_url: url }]);
+      expect(config.suffix).toBe('(MoRI UMBP SGLang)');
+      expect(config.name).toBe(getHardwareConfig(hwKey).name);
+      expect(getPointHardwareConfig({ hwKey, run_url: url }, config)).toEqual(config);
+      expect(getInferenceRunLabel('✕ dspark', [{ framework: 'mori-sglang', run_url: url }])).toBe(
+        '✕ dspark (MoRI UMBP SGLang)',
+      );
+    },
+  );
+
+  it('leaves neighboring run IDs and mixed historical points correctly labeled', () => {
+    for (const id of ['35166686550', '35166686552', '351666865510']) {
+      expect(
+        inferenceFrameworkLabelOverride('mori-sglang', dsparkUrl.replace('35166686551', id)),
+      ).toBeUndefined();
+    }
+    expect(
+      getInferenceHardwareConfig(hwKey, undefined, [
+        { run_url: dsparkUrl },
+        { run_url: historicalUrl },
+      ]).suffix,
+    ).toBe('(MoRI SGLang / MoRI UMBP SGLang)');
+  });
+
+  it('returns to the standard label at the exact cutoff in all shared display paths', () => {
+    vi.mocked(Date.now).mockReturnValue(expiresAt - 1);
+    expect(inferenceFrameworkLabelOverride('mori-sglang', dsparkUrl)).toBe('MoRI UMBP SGLang');
+    for (const now of [expiresAt, expiresAt + 1, expiresAt + 86_400_000]) {
+      vi.mocked(Date.now).mockReturnValue(now);
+      expect(inferenceFrameworkLabelOverride('mori-sglang', dsparkUrl)).toBeUndefined();
+      const point = { hwKey, framework: 'mori-sglang', run_url: dsparkUrl };
+      const generic = getHardwareConfig(hwKey);
+      expect(getInferenceHardwareConfig(hwKey, undefined, [point])).toBe(generic);
+      expect(getPointHardwareConfig(point, generic)).toBe(generic);
+      expect(getInferenceRunLabel('✕ dspark', [point])).toBe('✕ dspark');
+      expect(inferenceFrameworkLabelOverride('mori-sglang', runUrl)).toBe('MoRI UMBP SGLang');
+    }
+  });
+});
+
 describe('run-specific MoRI UMBP labels', () => {
   it('retains the unofficial marker and branch while labeling only the target overlay', () => {
     expect(
@@ -68,3 +125,36 @@ describe('run-specific MoRI UMBP labels', () => {
     expect(getInferenceHardwareConfig(hwKey, undefined, []).suffix).toBe('(MoRI SGLang)');
   });
 });
+
+describe('overlay line labels', () => {
+  const klaud = {
+    id: 35319969159,
+    branch: 'klaud/qwen3.5-fp8-gb300-dynamo-sglang-nightly-dev-cu13-20260918-20518d85',
+  };
+
+  it('names the hardware and leaves the branch to the legend when one run draws it', () => {
+    expect(getOverlayLineLabel('GB300 NVL72 (Dynamo SGLang)', klaud, false)).toBe(
+      '✕ GB300 NVL72 (Dynamo SGLang)',
+    );
+  });
+
+  it('adds a short run tag only when several runs draw the same hardware', () => {
+    expect(getOverlayLineLabel('GB200 NVL72 (Dynamo SGLang)', klaud, true)).toBe(
+      '✕ GB200 NVL72 (Dynamo SGLang) · …20260918-20518d85',
+    );
+    expect(getOverlayLineLabel('B300', { id: 31756025413, branch: 'main' }, true)).toBe(
+      '✕ B300 · main',
+    );
+  });
+
+  it.each([
+    ['main', 'main'],
+    ['feat/short-name', 'feat/short-name'],
+    ['release/2026-09-18-hotfix', '2026-09-18-hotfix'],
+    [klaud.branch, '…20260918-20518d85'],
+    ['', 'run 42'],
+    [null, 'run 42'],
+  ])('shortens branch %j to %j', (branch, expected) => {
+    expect(shortRunTag({ id: 42, branch })).toBe(expected);
+  });
+});
diff --git a/packages/app/src/lib/inference-labels.ts b/packages/app/src/lib/inference-labels.ts
index 81f92c485..c9da78643 100644
--- a/packages/app/src/lib/inference-labels.ts
+++ b/packages/app/src/lib/inference-labels.ts
@@ -7,18 +7,65 @@ interface RunProvenance {
   run_url?: string | null;
 }
 
+// Three-week recognition window, ending 2026-10-08 at 21:32 America/New_York.
+const UMBP_DSPARK_LABEL_EXPIRES_AT = Date.parse('2026-10-09T01:32:00Z');
+
 /** Display-only: never change framework/hardware keys used by filters and history. */
 export function inferenceFrameworkLabelOverride(
   framework: string,
   runUrl?: string | null,
 ): string | undefined {
-  return resolveFrameworkAlias(framework) === 'mori-sglang' &&
-    runIdFromRunUrl(runUrl) === '34926284365'
-    ? 'MoRI UMBP SGLang'
-    : undefined;
+  if (resolveFrameworkAlias(framework) !== 'mori-sglang') return undefined;
+  const runId = runIdFromRunUrl(runUrl);
+  const hasLabel =
+    runId === '34926284365' ||
+    (runId === '35166686551' && Date.now() < UMBP_DSPARK_LABEL_EXPIRES_AT);
+  return hasLabel ? 'MoRI UMBP SGLang' : undefined;
 }
 
 /** Keep unofficial-run identity/markers while making its special engine visible. */
+/** Leads every unofficial-run label, in line labels and legend rows alike. */
+export const OVERLAY_LABEL_MARKER = '✕ ';
+const RUN_TAG_MAX = 20;
+const RUN_TAG_TAIL = 17;
+
+export interface OverlayRunIdentity {
+  id: number | string;
+  branch?: string | null;
+}
+
+/**
+ * Short, still recognisable name for a run: the whole branch when it is short,
+ * else its last path segment, else the branch tail (klaud nightlies end in
+ * `<date>-<sha>`). Falls back to the run id when the branch is unknown.
+ */
+export function shortRunTag(run: OverlayRunIdentity): string {
+  const branch = run.branch?.trim() || `run ${run.id}`;
+  if (branch.length <= RUN_TAG_MAX) return branch;
+  const segment = branch.slice(branch.lastIndexOf('/') + 1);
+  if (segment.length > 0 && segment.length <= RUN_TAG_MAX) return segment;
+  return `…${branch.slice(-RUN_TAG_TAIL)}`;
+}
+
+/** ` · <tag>` appended to an overlay line label when other runs draw the same hardware. */
+export function overlayRunTag(run: OverlayRunIdentity): string {
+  return ` · ${shortRunTag(run)}`;
+}
+
+/**
+ * Line-label text for an unofficial-run curve. Pills name the hardware, not the
+ * branch: branch names run to 70+ characters and the legend already carries
+ * them. The run tag is added only when several overlay runs draw the same
+ * hardware, so the pills stay distinguishable.
+ */
+export function getOverlayLineLabel(
+  hardwareLabel: string,
+  run: OverlayRunIdentity,
+  sharesHardware: boolean,
+): string {
+  return `${OVERLAY_LABEL_MARKER}${hardwareLabel}${sharesHardware ? overlayRunTag(run) : ''}`;
+}
+
 export function getInferenceRunLabel(
   label: string,
   points: readonly (RunProvenance & { framework?: string })[],
diff --git a/packages/app/src/lib/power-basis.test.ts b/packages/app/src/lib/power-basis.test.ts
new file mode 100644
index 000000000..9f2bf53f1
--- /dev/null
+++ b/packages/app/src/lib/power-basis.test.ts
@@ -0,0 +1,444 @@
+import { describe, expect, it } from 'vitest';
+
+import type { BenchmarkRow } from '@/lib/api';
+import { rowToAggDataEntry, transformBenchmarkRows } from '@/lib/benchmark-transform';
+import { buildDerivedChartFields, getHardwareKey } from '@/lib/chart-utils';
+import { getGpuSpecs } from '@/lib/constants';
+import {
+  computePowerBasisFields,
+  modeledFacilityWattsPerGpu,
+  POWER_BASES,
+  POWER_BASIS_FIELDS,
+  POWER_BASIS_LABELS,
+  powerBasisNormalization,
+} from '@/lib/power-basis';
+
+// Qwen3.5 B200 c1, run 34175132645: actual rounded telemetry, eight GPUs
+// (same fixture as modeled-system-power.test.ts) plus an output rate.
+function row(overrides: Partial<BenchmarkRow> = {}): BenchmarkRow {
+  return {
+    id: 441192,
+    model: 'qwen3.5',
+    hardware: 'b200',
+    framework: 'sglang',
+    precision: 'fp8',
+    spec_method: 'none',
+    disagg: false,
+    is_multinode: false,
+    prefill_tp: 8,
+    prefill_ep: 1,
+    prefill_dp_attention: false,
+    prefill_num_workers: 0,
+    decode_tp: 8,
+    decode_ep: 1,
+    decode_dp_attention: false,
+    decode_num_workers: 0,
+    num_prefill_gpu: 8,
+    num_decode_gpu: 8,
+    benchmark_type: 'single_turn',
+    isl: 8192,
+    osl: 1024,
+    conc: 1,
+    offload_mode: 'off',
+    image: 'lmsysorg/sglang:v0.5.19-cu130',
+    date: '2026-09-08',
+    run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645/attempts/1',
+    metrics: {
+      power_valid: 1,
+      power_metric_schema_version: 2,
+      avg_power_w: 349.859,
+      avg_total_gpu_power_w: 2798.868,
+      total_gpu_energy_j: 120361.299,
+      joules_per_output_token: 12.937902,
+      tput_per_gpu: 270,
+      output_tput_per_gpu: 30,
+      pp: 1,
+      pcp_size: 1,
+      median_intvty: 100,
+    },
+    ...overrides,
+  };
+}
+
+/** Full official-path derivation for one row with real HW_REGISTRY specs. */
+function derive(source: BenchmarkRow) {
+  const entry = rowToAggDataEntry(source);
+  const hwKey = getHardwareKey(entry);
+  return { entry, hwKey, fields: buildDerivedChartFields(entry, hwKey) };
+}
+
+const y = (metric: { y: number } | undefined) => metric?.y;
+
+describe('computePowerBasisFields', () => {
+  // H200-like aggregate deployment: 8 GPUs at 50 output tok/s each.
+  const h200 = {
+    tdpWatts: 700,
+    utilityWatts: 1370,
+    allocatedGpus: 8,
+    totalOutputTokPerSec: 400,
+    measuredWatts: 350,
+    measuredJPerOutputToken: 7,
+    modeledFacilityWattsPerGpu: 650,
+  };
+
+  it('derives provisioned and modeled boundaries for an aggregate deployment', () => {
+    const values = computePowerBasisFields(h200);
+    expect(values).toMatchObject({
+      gpuProvisionedWatts: 700,
+      gpuProvisionedJPerOutputToken: 14,
+      utilityProvisionedWatts: 1370,
+      utilityModeledWatts: 650,
+      utilityModeledJPerOutputToken: 13,
+    });
+    expect(values.utilityProvisionedJPerOutputToken).toBeCloseTo(27.4, 10);
+  });
+
+  it('charges the prefill pool to every output token of a 4P+4D deployment', () => {
+    // GB200-like disaggregation: only 4 decode GPUs emit tokens (50 tok/s each),
+    // but all 8 allocated GPUs are provisioned, so J/token doubles versus a
+    // per-decode-GPU reading (1200 / 50 = 24).
+    const values = computePowerBasisFields({
+      tdpWatts: 1200,
+      utilityWatts: 1870,
+      allocatedGpus: 8,
+      totalOutputTokPerSec: 200,
+      measuredWatts: null,
+      measuredJPerOutputToken: null,
+      modeledFacilityWattsPerGpu: null,
+    });
+    expect(values.gpuProvisionedJPerOutputToken).toBe(48);
+    expect(values.utilityProvisionedJPerOutputToken).toBeCloseTo(74.8, 10);
+    expect(values.utilityModeledWatts).toBeNull();
+    expect(values.utilityModeledJPerOutputToken).toBeNull();
+  });
+
+  it('nulls only the boundaries whose inputs are unavailable', () => {
+    const noModel = computePowerBasisFields({ ...h200, modeledFacilityWattsPerGpu: null });
+    expect(noModel.utilityModeledWatts).toBeNull();
+    expect(noModel.utilityModeledJPerOutputToken).toBeNull();
+    expect(noModel.gpuProvisionedJPerOutputToken).toBe(14);
+    expect(noModel.utilityProvisionedJPerOutputToken).toBeCloseTo(27.4, 10);
+
+    // B4 is anchored on B1: without measured watts neither modeled value exists,
+    // even when a caller supplies a modeled W from elsewhere.
+    const noMeasured = computePowerBasisFields({
+      ...h200,
+      measuredWatts: null,
+      measuredJPerOutputToken: null,
+    });
+    expect(noMeasured.utilityModeledWatts).toBeNull();
+    expect(noMeasured.utilityModeledJPerOutputToken).toBeNull();
+    expect(noMeasured.gpuProvisionedWatts).toBe(700);
+    expect(noMeasured.utilityProvisionedWatts).toBe(1370);
+
+    const noMeasuredEnergy = computePowerBasisFields({ ...h200, measuredJPerOutputToken: null });
+    expect(noMeasuredEnergy.utilityModeledWatts).toBe(650);
+    expect(noMeasuredEnergy.utilityModeledJPerOutputToken).toBeNull();
+
+    const noThroughput = computePowerBasisFields({ ...h200, totalOutputTokPerSec: null });
+    expect(noThroughput.gpuProvisionedWatts).toBe(700);
+    expect(noThroughput.gpuProvisionedJPerOutputToken).toBeNull();
+    expect(noThroughput.utilityProvisionedJPerOutputToken).toBeNull();
+    expect(noThroughput.utilityModeledJPerOutputToken).toBe(13);
+  });
+
+  it.each([0, -1, NaN, Infinity])('never turns %s into a plotted value', (bad) => {
+    const values = computePowerBasisFields({
+      tdpWatts: bad,
+      utilityWatts: bad,
+      allocatedGpus: bad,
+      totalOutputTokPerSec: bad,
+      measuredWatts: bad,
+      measuredJPerOutputToken: bad,
+      modeledFacilityWattsPerGpu: bad,
+    });
+    expect(Object.values(values).every((v) => v === null)).toBe(true);
+  });
+});
+
+describe('powerBasisNormalization', () => {
+  it('keeps aggregate rows on the per-GPU ratio because N_alloc cancels', () => {
+    expect(
+      powerBasisNormalization({
+        output_tput_per_gpu: 50,
+        disagg: false,
+        benchmark_type: 'single_turn',
+        num_prefill_gpu: 8,
+        num_decode_gpu: 8,
+      }),
+    ).toEqual({ allocatedGpus: 1, totalOutputTokPerSec: 50 });
+  });
+
+  it('counts prefill GPUs and decode-only output for fixed-sequence disaggregation', () => {
+    const disagg = {
+      output_tput_per_gpu: 50,
+      disagg: true,
+      benchmark_type: 'single_turn',
+      num_prefill_gpu: 4,
+      num_decode_gpu: 4,
+    };
+    expect(powerBasisNormalization(disagg)).toEqual({
+      allocatedGpus: 8,
+      totalOutputTokPerSec: 200,
+    });
+    expect(powerBasisNormalization({ ...disagg, num_prefill_gpu: 0 })).toEqual({
+      allocatedGpus: null,
+      totalOutputTokPerSec: null,
+    });
+    expect(powerBasisNormalization({ ...disagg, benchmark_type: 'agentic_traces' })).toEqual({
+      allocatedGpus: null,
+      totalOutputTokPerSec: null,
+    });
+    expect(powerBasisNormalization({ ...disagg, output_tput_per_gpu: 0 })).toEqual({
+      allocatedGpus: null,
+      totalOutputTokPerSec: null,
+    });
+  });
+});
+
+describe('power boundaries through the derived-field builder', () => {
+  it('orders B3 ≥ B4 ≥ B1 and B2 ≥ B1 for watts and energy on real B200 telemetry', () => {
+    const { entry, fields } = derive(row());
+    const b1W = y(fields.measuredAvgPower)!;
+    const b2W = y(fields.gpuProvisionedWatts)!;
+    const b3W = y(fields.utilityProvisionedWatts)!;
+    const b4W = y(fields.utilityModeledWatts)!;
+    expect(b1W).toBe(349.859);
+    expect(b2W).toBe(getGpuSpecs('b200').tdp);
+    expect(b3W).toBe(getGpuSpecs('b200').power * 1000);
+    expect(b4W).toBeCloseTo(6288.4 / 8, 6);
+    expect(b3W).toBeGreaterThanOrEqual(b4W);
+    expect(b4W).toBeGreaterThanOrEqual(b1W);
+    expect(b2W).toBeGreaterThanOrEqual(b1W);
+
+    const b1J = y(fields.measuredJPerOutputToken)!;
+    const b2J = y(fields.gpuProvisionedJPerOutputToken)!;
+    const b3J = y(fields.utilityProvisionedJPerOutputToken)!;
+    const b4J = y(fields.utilityModeledJPerOutputToken)!;
+    expect(b1J).toBe(12.937902);
+    expect(b2J).toBeCloseTo(b2W / 30, 10);
+    expect(b3J).toBeCloseTo(b3W / 30, 10);
+    expect(b4J).toBeCloseTo((b1J * b4W) / b1W, 10);
+    expect(b3J).toBeGreaterThanOrEqual(b4J);
+    expect(b4J).toBeGreaterThanOrEqual(b1J);
+    expect(b2J).toBeGreaterThanOrEqual(b1J);
+
+    // B4 W ÷ B1 W is the facility-to-board ratio of the attached estimate.
+    const model = entry.modeledSystemPower;
+    expect(model?.status).toBe('supported');
+    if (model?.status !== 'supported') return;
+    expect(b4W / b1W).toBeCloseTo(model.deploymentFacilityWatts / (model.gpuCount * b1W), 10);
+  });
+
+  it('applies PUE exactly once: B4 W ÷ chassis AC per GPU equals the model PUE', () => {
+    const { entry, fields } = derive(row());
+    const model = entry.modeledSystemPower;
+    if (model?.status !== 'supported') throw new Error('fixture must be supported');
+    const chassisAcPerMeasuredGpu = model.chassisAcWatts / model.gpuCount;
+    expect(y(fields.utilityModeledWatts)! / chassisAcPerMeasuredGpu).toBeCloseTo(model.pue, 4);
+    expect(y(fields.utilityModeledWatts)! / y(fields.modeledChassisPowerPerGpu)!).toBeCloseTo(
+      model.pue,
+      4,
+    );
+  });
+
+  it('normalizes a fixed-sequence 4P+4D row by all eight GPUs while jOutput stays per decode GPU', () => {
+    const { entry, fields } = derive(
+      row({
+        hardware: 'gb200',
+        disagg: true,
+        prefill_tp: 4,
+        decode_tp: 4,
+        num_prefill_gpu: 4,
+        num_decode_gpu: 4,
+        metrics: { ...row().metrics, tput_per_gpu: 450, output_tput_per_gpu: 50 },
+      }),
+    );
+    const specs = getGpuSpecs('gb200');
+    expect(y(fields.gpuProvisionedJPerOutputToken)).toBeCloseTo((specs.tdp * 8) / (50 * 4), 10);
+    expect(y(fields.utilityProvisionedJPerOutputToken)).toBeCloseTo(
+      (specs.power * 1000 * 8) / (50 * 4),
+      10,
+    );
+    // Legacy all-in energy divides one decode GPU's power by that GPU's output.
+    expect(y(fields.jOutput)).toBeCloseTo((specs.power * 1000) / 50, 10);
+    expect(y(fields.utilityProvisionedJPerOutputToken)).toBeCloseTo(2 * y(fields.jOutput)!, 10);
+    // Telemetry is validated (B1 renders) but GB200 NVL72 has no chassis
+    // model, so the modeled boundary alone is absent.
+    expect(fields.measuredAvgPower).toBeDefined();
+    expect(entry.modeledSystemPower).toMatchObject({ status: 'unsupported', reason: 'hardware' });
+    expect(fields.utilityModeledWatts).toBeUndefined();
+    expect(fields.utilityModeledJPerOutputToken).toBeUndefined();
+  });
+
+  it('divides B4 by the measured GPU count, not the modeled chassis count, on a 4P+8D H200 deployment', () => {
+    // Two worker hosts, a half-filled prefill chassis and a full decode chassis:
+    // the model evaluates 16 GPUs (two chassis) while twelve are measured.
+    const { entry, fields } = derive(
+      row({
+        hardware: 'h200',
+        disagg: true,
+        is_multinode: true,
+        prefill_tp: 4,
+        decode_tp: 8,
+        num_prefill_gpu: 4,
+        num_decode_gpu: 8,
+        workers: [
+          {
+            role: 'prefill',
+            worker_idx: 0,
+            num_gpus: 4,
+            hosts: ['prefill-node'],
+            avg_power_w: 400,
+          },
+          { role: 'decode', worker_idx: 0, num_gpus: 8, hosts: ['decode-node'], avg_power_w: 300 },
+        ],
+        metrics: {
+          power_valid: 1,
+          power_metric_schema_version: 2,
+          avg_power_w: 4000 / 12,
+          avg_total_gpu_power_w: 4000,
+          prefill_avg_power_w: 400,
+          decode_avg_power_w: 300,
+          joules_per_output_token: 14,
+          tput_per_gpu: 450,
+          output_tput_per_gpu: 50,
+        },
+      }),
+    );
+    const model = entry.modeledSystemPower;
+    expect(model?.status).toBe('supported');
+    if (model?.status !== 'supported') return;
+    expect(model.gpuCount).toBe(12);
+    expect(model.modeledGpuCount).toBe(16);
+    expect(model.chassisBasis).toBe('extrapolated');
+
+    const b1W = y(fields.measuredAvgPower)!;
+    const b3W = y(fields.utilityProvisionedWatts)!;
+    const b4W = y(fields.utilityModeledWatts)!;
+    expect(b1W).toBeCloseTo(4000 / 12, 10);
+    expect(b4W).toBeCloseTo(model.deploymentFacilityWatts / model.gpuCount, 10);
+    expect(b4W).not.toBeCloseTo(model.facilityWatts / model.modeledGpuCount, 6);
+    expect(b4W).not.toBeCloseTo(model.facilityWatts / model.gpuCount, 6);
+    expect(b4W).not.toBeCloseTo(model.deploymentFacilityWatts / model.modeledGpuCount, 6);
+
+    const b1J = y(fields.measuredJPerOutputToken)!;
+    const b3J = y(fields.utilityProvisionedJPerOutputToken)!;
+    const b4J = y(fields.utilityModeledJPerOutputToken)!;
+    expect(b1J).toBe(14);
+    expect(b4J).toBeCloseTo((14 * b4W) / (4000 / 12), 10);
+    expect(b3J).toBeCloseTo(1.5 * y(fields.jOutput)!, 10);
+    expect(b3W).toBeGreaterThanOrEqual(b4W);
+    expect(b4W).toBeGreaterThanOrEqual(b1W);
+    expect(b3J).toBeGreaterThanOrEqual(b4J);
+    expect(b4J).toBeGreaterThanOrEqual(b1J);
+  });
+
+  it('omits the modeled boundary off the 8k/1k workload but keeps provisioned ones', () => {
+    const { fields } = derive(row({ isl: 1024, osl: 1024 }));
+    expect(fields.measuredAvgPower).toBeDefined();
+    expect(fields.utilityModeledWatts).toBeUndefined();
+    expect(fields.utilityModeledJPerOutputToken).toBeUndefined();
+    expect(y(fields.gpuProvisionedWatts)).toBe(getGpuSpecs('b200').tdp);
+    expect(fields.utilityProvisionedJPerOutputToken).toBeDefined();
+  });
+
+  it('omits the modeled boundary with B1 when telemetry is invalid, keeps provisioned ones', () => {
+    const invalid = derive(row({ metrics: { ...row().metrics, power_valid: 0 } })).fields;
+    expect(invalid.measuredAvgPower).toBeUndefined();
+    expect(invalid.utilityModeledWatts).toBeUndefined();
+    expect(invalid.utilityModeledJPerOutputToken).toBeUndefined();
+    expect(invalid.gpuProvisionedWatts).toBeDefined();
+    expect(invalid.utilityProvisionedWatts).toBeDefined();
+  });
+
+  it('renders the modeled boundary wherever B1 renders, including validated unversioned single-node rows', () => {
+    const { power_metric_schema_version: _schema, ...unversioned } = row().metrics;
+    const legacy = derive(row({ metrics: unversioned }));
+    const model = legacy.entry.modeledSystemPower;
+    expect(model).toMatchObject({
+      status: 'supported',
+      telemetryBasis: 'validated-unversioned-single-node',
+    });
+    if (model?.status !== 'supported') return;
+    expect(legacy.fields.measuredAvgPower).toBeDefined();
+    expect(legacy.fields.measuredJPerOutputToken).toBeDefined();
+    expect(
+      y(legacy.fields.utilityModeledWatts)! / y(legacy.fields.modeledChassisPowerPerGpu)!,
+    ).toBeCloseTo(model.pue, 4);
+    expect(y(legacy.fields.utilityModeledJPerOutputToken)).toBeCloseTo(
+      (y(legacy.fields.measuredJPerOutputToken)! * y(legacy.fields.utilityModeledWatts)!) /
+        y(legacy.fields.measuredAvgPower)!,
+      10,
+    );
+    // Same numbers as the versioned row: the schema marker changes admission, not the estimate.
+    expect(legacy.fields.utilityModeledWatts).toEqual(derive(row()).fields.utilityModeledWatts);
+  });
+
+  it('omits provisioned boundaries for hardware without registry specs', () => {
+    const { fields } = derive(row({ hardware: 'unlistedchip' }));
+    expect(fields.gpuProvisionedWatts).toBeUndefined();
+    expect(fields.gpuProvisionedJPerOutputToken).toBeUndefined();
+    expect(fields.utilityProvisionedWatts).toBeUndefined();
+    expect(fields.utilityProvisionedJPerOutputToken).toBeUndefined();
+  });
+
+  it('serves the same fields to ?unofficialrun= overlays through transformBenchmarkRows', () => {
+    const { chartData } = transformBenchmarkRows([row()], 'median', 'external');
+    const point = chartData[0][0];
+    const official = derive(row()).fields;
+    for (const basis of Object.values(POWER_BASIS_FIELDS)) {
+      expect(point[basis.watts]).toEqual(official[basis.watts]);
+      expect(point[basis.energy]).toEqual(official[basis.energy]);
+      expect(point[basis.watts]?.roof).toBe(false);
+    }
+  });
+
+  it('emits exactly the requested boundary fields for historical trends', () => {
+    const { entry, hwKey } = derive(row());
+    const requested = buildDerivedChartFields(entry, hwKey, [
+      'utilityModeledWatts',
+      'gpuProvisionedJPerOutputToken',
+    ]);
+    expect(Object.keys(requested).sort()).toEqual(
+      ['gpuProvisionedJPerOutputToken', 'utilityModeledWatts'].sort(),
+    );
+    const unavailable = buildDerivedChartFields(
+      rowToAggDataEntry(row({ hardware: 'gb200' })),
+      'gb200',
+      ['tpPerGpu', 'utilityModeledWatts'],
+    );
+    expect(Object.keys(unavailable)).toEqual(['tpPerGpu']);
+  });
+});
+
+describe('modeledFacilityWattsPerGpu', () => {
+  const supported = rowToAggDataEntry(row()).modeledSystemPower;
+
+  it('divides the deployment facility share by the measured GPU count', () => {
+    expect(modeledFacilityWattsPerGpu({ modeledSystemPower: supported })).toBeCloseTo(
+      6288.4 / 8,
+      6,
+    );
+  });
+
+  it('returns null without a supported model', () => {
+    expect(
+      modeledFacilityWattsPerGpu({
+        modeledSystemPower: { status: 'unsupported', reason: 'hardware', modelRevision: 'x' },
+      }),
+    ).toBeNull();
+    expect(modeledFacilityWattsPerGpu({ modeledSystemPower: undefined })).toBeNull();
+  });
+});
+
+describe('power basis registry', () => {
+  it('labels every basis in both locales and maps every derived basis to two fields', () => {
+    for (const basis of POWER_BASES) {
+      expect(POWER_BASIS_LABELS[basis].en.length).toBeGreaterThan(0);
+      expect(POWER_BASIS_LABELS[basis].zh.length).toBeGreaterThan(0);
+    }
+    const keys = Object.values(POWER_BASIS_FIELDS).flatMap((f) => [f.watts, f.energy]);
+    expect(new Set(keys).size).toBe(6);
+  });
+});
diff --git a/packages/app/src/lib/power-basis.ts b/packages/app/src/lib/power-basis.ts
new file mode 100644
index 000000000..034eeca2d
--- /dev/null
+++ b/packages/app/src/lib/power-basis.ts
@@ -0,0 +1,211 @@
+/**
+ * Power boundaries for one benchmark point, from the GPU board out to the
+ * utility meter. Pure numbers only — no React, DOM, or registry imports — so
+ * the derived-field builder, overlays, and tests share one formula set.
+ *
+ * | Basis                  | W / GPU                                          | J / output token                          |
+ * | ---------------------- | ------------------------------------------------ | ----------------------------------------- |
+ * | B1 gpu-measured        | `avg_power_w` (existing `measuredAvgPower`)      | `joules_per_output_token` (existing)      |
+ * | B2 gpu-provisioned     | `HW_REGISTRY.tdp`                                | W × N_alloc ÷ total output tok/s          |
+ * | B3 utility-provisioned | `HW_REGISTRY.power` × 1000                       | W × N_alloc ÷ total output tok/s          |
+ * | B4 utility-modeled     | modeled `deploymentFacilityWatts` ÷ `gpuCount`   | B1 J/out × (B4 W ÷ B1 W)                  |
+ *
+ * N_alloc counts every allocated GPU (prefill + decode for disaggregation);
+ * total output tok/s is the whole deployment's. B4 reuses the estimate that
+ * `modelSystemPower` already attached to the entry — PUE is applied exactly
+ * once inside that model, never here — and is withheld wherever B1 is.
+ * Unavailable values are `null`; callers omit the field rather than plotting 0.
+ */
+import type { AggDataEntry, InferenceData, PowerBasisFieldKey } from '@/components/inference/types';
+
+export const POWER_BASES = [
+  'gpu-measured',
+  'gpu-provisioned',
+  'utility-provisioned',
+  'utility-modeled',
+] as const;
+export type PowerBasis = (typeof POWER_BASES)[number];
+export type PowerQuantity = 'watts' | 'energy';
+
+export const POWER_BASIS_LABELS: Record<PowerBasis, { en: string; zh: string }> = {
+  'gpu-measured': { en: 'GPU measured', zh: 'GPU 实测' },
+  'gpu-provisioned': { en: 'GPU provisioned (TDP)', zh: 'GPU 额定（TDP）' },
+  'utility-provisioned': { en: 'Utility provisioned (all-in)', zh: '全电源配置（all-in）' },
+  'utility-modeled': { en: 'Utility modeled (PUE)', zh: '数据中心建模（含 PUE）' },
+};
+
+/** InferenceData keys per derived basis and quantity. B1 lives on the measured* fields. */
+export const POWER_BASIS_FIELDS: Record<
+  Exclude<PowerBasis, 'gpu-measured'>,
+  Record<PowerQuantity, PowerBasisFieldKey>
+> = {
+  'gpu-provisioned': {
+    watts: 'gpuProvisionedWatts',
+    energy: 'gpuProvisionedJPerOutputToken',
+  },
+  'utility-provisioned': {
+    watts: 'utilityProvisionedWatts',
+    energy: 'utilityProvisionedJPerOutputToken',
+  },
+  'utility-modeled': {
+    watts: 'utilityModeledWatts',
+    energy: 'utilityModeledJPerOutputToken',
+  },
+};
+
+export interface PowerBasisInput {
+  /** B2 W/GPU: HW_REGISTRY tdp. 0 means the spec is not yet available. */
+  tdpWatts: number | null;
+  /** B3 W/GPU: HW_REGISTRY all-in power, already in watts. */
+  utilityWatts: number | null;
+  /** Every GPU the deployment occupies (prefill + decode for disaggregation). */
+  allocatedGpus: number | null;
+  /** Whole-deployment successful output tokens per second. */
+  totalOutputTokPerSec: number | null;
+  /** B1 W/GPU from validated telemetry. */
+  measuredWatts: number | null;
+  /** B1 J/output token from the same telemetry window. */
+  measuredJPerOutputToken: number | null;
+  /**
+   * B4 W/GPU: modeled facility watts (PUE already applied) per measured GPU.
+   * B4 is a scaling of B1, so it is withheld whenever `measuredWatts` is null.
+   */
+  modeledFacilityWattsPerGpu: number | null;
+}
+
+export type PowerBasisValues = Record<PowerBasisFieldKey, number | null>;
+
+const positive = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isFinite(value) && value > 0;
+const count = (value: unknown): value is number => positive(value) && Number.isSafeInteger(value);
+const orNull = (value: number): number | null => (positive(value) ? value : null);
+
+/**
+ * Derives the B2–B4 boundary values from plain numbers. Any unavailable input
+ * yields `null` for the values that depend on it and leaves the rest intact.
+ */
+export function computePowerBasisFields(input: PowerBasisInput): PowerBasisValues {
+  const tdp = positive(input.tdpWatts) ? input.tdpWatts : null;
+  const utility = positive(input.utilityWatts) ? input.utilityWatts : null;
+  const measuredWatts = positive(input.measuredWatts) ? input.measuredWatts : null;
+  const measuredJ = positive(input.measuredJPerOutputToken) ? input.measuredJPerOutputToken : null;
+  // B4 is B1 carried out to the utility meter, so it follows B1's availability:
+  // no measured watts, no modeled boundary (B3 ≥ B4 ≥ B1 needs its anchor).
+  const modeled =
+    measuredWatts !== null && positive(input.modeledFacilityWattsPerGpu)
+      ? input.modeledFacilityWattsPerGpu
+      : null;
+
+  // Provisioned energy: GPU-seconds spent per output token by the whole
+  // deployment (N_alloc ÷ total tok/s) × W per GPU = J per output token.
+  const gpuSecondsPerOutputToken =
+    positive(input.allocatedGpus) && positive(input.totalOutputTokPerSec)
+      ? input.allocatedGpus / input.totalOutputTokPerSec
+      : null;
+  const provisionedEnergy = (watts: number | null) =>
+    watts !== null && gpuSecondsPerOutputToken !== null
+      ? orNull(watts * gpuSecondsPerOutputToken)
+      : null;
+
+  // Modeled energy scales the producer's same-window E/N by modeled ÷ measured W,
+  // so it inherits B1's token denominator instead of re-deriving one.
+  const modeledEnergy =
+    modeled !== null && measuredWatts !== null && measuredJ !== null
+      ? orNull((measuredJ * modeled) / measuredWatts)
+      : null;
+
+  return {
+    gpuProvisionedWatts: tdp,
+    gpuProvisionedJPerOutputToken: provisionedEnergy(tdp),
+    utilityProvisionedWatts: utility,
+    utilityProvisionedJPerOutputToken: provisionedEnergy(utility),
+    utilityModeledWatts: modeled,
+    utilityModeledJPerOutputToken: modeledEnergy,
+  };
+}
+
+type PowerBasisEntry = Pick<
+  AggDataEntry,
+  | 'output_tput_per_gpu'
+  | 'disagg'
+  | 'benchmark_type'
+  | 'num_prefill_gpu'
+  | 'num_decode_gpu'
+  | 'avg_power_w'
+  | 'joules_per_output_token'
+  | 'modeledSystemPower'
+>;
+
+/**
+ * Whole-deployment normalization for the provisioned energies. Aggregate rows
+ * already report output per allocated GPU, so N_alloc cancels and the ratio
+ * 1 GPU : per-GPU throughput is exact without trusting display counts (legacy
+ * ingest can encode TP × EP twice). Fixed-sequence disaggregated rows report
+ * output per decode GPU while the deployment also powers the prefill pool, so
+ * total output = per-GPU × decode GPUs and N_alloc = prefill + decode GPUs.
+ * Other disaggregated benchmark types are left out: whether AgentX throughput
+ * already divides by all GPUs is not verifiable in-app.
+ */
+export function powerBasisNormalization(
+  entry: Pick<
+    PowerBasisEntry,
+    'output_tput_per_gpu' | 'disagg' | 'benchmark_type' | 'num_prefill_gpu' | 'num_decode_gpu'
+  >,
+): Pick<PowerBasisInput, 'allocatedGpus' | 'totalOutputTokPerSec'> {
+  const perGpu = entry.output_tput_per_gpu;
+  const unavailable = { allocatedGpus: null, totalOutputTokPerSec: null };
+  if (!positive(perGpu)) return unavailable;
+  if (!entry.disagg) return { allocatedGpus: 1, totalOutputTokPerSec: perGpu };
+  if (entry.benchmark_type !== 'single_turn') return unavailable;
+  const prefill = entry.num_prefill_gpu;
+  const decode = entry.num_decode_gpu;
+  if (!count(prefill) || !count(decode)) return unavailable;
+  return { allocatedGpus: prefill + decode, totalOutputTokPerSec: perGpu * decode };
+}
+
+/**
+ * B4 W/GPU from the estimate `rowToAggDataEntry` attached. The model owns
+ * telemetry admission: `modelSystemPower` requires `power_valid === 1` plus
+ * schema v2, or the validated unversioned single-node producer it records as
+ * `telemetryBasis: 'validated-unversioned-single-node'`. That is the same
+ * population the app plots as B1 (`measuredAvgPower`) and as
+ * `modeledChassisPowerPerGpu`, so B4 renders exactly where they do. The public
+ * API's stricter `strictV2` row filter is not re-applied here; it is not
+ * applied to the chart's B1 either.
+ */
+export function modeledFacilityWattsPerGpu(
+  entry: Pick<PowerBasisEntry, 'modeledSystemPower'>,
+): number | null {
+  const model = entry.modeledSystemPower;
+  if (model?.status !== 'supported') return null;
+  if (!positive(model.deploymentFacilityWatts) || !count(model.gpuCount)) return null;
+  return orNull(model.deploymentFacilityWatts / model.gpuCount);
+}
+
+export type PowerBasisChartFields = Partial<Pick<InferenceData, PowerBasisFieldKey>>;
+
+/**
+ * Chart-shaped B2–B4 fields for one entry. Keys are present only for finite,
+ * positive values: the metric filters drop a point by `metricKey in point`,
+ * and the coordinate remap falls back to raw throughput when a key exists
+ * with an unusable value.
+ */
+export function buildPowerBasisChartFields(
+  entry: PowerBasisEntry,
+  specs: { tdp?: number; power?: number },
+): PowerBasisChartFields {
+  const values = computePowerBasisFields({
+    tdpWatts: specs.tdp ?? null,
+    utilityWatts: positive(specs.power) ? specs.power * 1000 : null,
+    ...powerBasisNormalization(entry),
+    measuredWatts: entry.avg_power_w ?? null,
+    measuredJPerOutputToken: entry.joules_per_output_token ?? null,
+    modeledFacilityWattsPerGpu: modeledFacilityWattsPerGpu(entry),
+  });
+  const fields: PowerBasisChartFields = {};
+  for (const key of Object.keys(values) as PowerBasisFieldKey[]) {
+    const y = values[key];
+    if (y !== null) fields[key] = { y, roof: false };
+  }
+  return fields;
+}
diff --git a/packages/app/src/lib/rankings.test.ts b/packages/app/src/lib/rankings.test.ts
index c42921555..149450aa2 100644
--- a/packages/app/src/lib/rankings.test.ts
+++ b/packages/app/src/lib/rankings.test.ts
@@ -67,7 +67,7 @@ describe('rankings registry', () => {
   it('has one page per (kind, model) pair', () => {
     const entries = getAllRankingPageEntries();
     expect(entries.length).toBe(RANKING_KINDS.length * INFERENCE_MODEL_SLUGS.length);
-    expect(entries.length).toBe(26);
+    expect(entries.length).toBe(30);
   });
 
   it('has unique, well-formed slugs', () => {
diff --git a/packages/app/src/lib/run-pages.test.ts b/packages/app/src/lib/run-pages.test.ts
index bb34f73f8..5e9368a9c 100644
--- a/packages/app/src/lib/run-pages.test.ts
+++ b/packages/app/src/lib/run-pages.test.ts
@@ -35,7 +35,7 @@ describe('run pages registry', () => {
   it('has one candidate per (model, chip) pair', () => {
     const entries = getAllRunPageEntries();
     expect(entries.length).toBe(INFERENCE_MODEL_SLUGS.length * getAllChipPages().length);
-    expect(entries.length).toBe(117);
+    expect(entries.length).toBe(135);
   });
 
   it('has unique, well-formed slugs', () => {
diff --git a/packages/app/src/lib/tab-meta-zh.ts b/packages/app/src/lib/tab-meta-zh.ts
index d52484d66..4b580fbb5 100644
--- a/packages/app/src/lib/tab-meta-zh.ts
+++ b/packages/app/src/lib/tab-meta-zh.ts
@@ -42,6 +42,16 @@ export const TAB_META_ZH: Record<DashboardRouteKey, { title: string; description
     description:
       '测算固定 AI 推理集群在整个生命周期内的经济性：按设施功率预算确定集群规模，并跟踪实测软件配置随时间改进带来的收入、成本与利润变化。',
   },
+  'first-token': {
+    title: '首 token 延迟约束',
+    description:
+      '在给定最低交互性下，按各档首 token 延迟（TTFT）上限，找出各芯片厂商成本最低的实测 AI 推理配置。仅使用实测数据，不做插值，适用于任意模型与工作负载。',
+  },
+  'cache-reuse': {
+    title: '前缀缓存复用',
+    description:
+      '查看 AI 推理配置在并发数上升时 prompt token 的来源：HBM 缓存命中、主机层缓存命中，还是重新计算。数据取自运行时实测的缓存计数，覆盖全部模型与芯片。',
+  },
   'profit-estimator': {
     title: '推理利润估算器',
     description:
@@ -115,6 +125,10 @@ export const TAB_INTRO_ZH: Record<DashboardRouteKey, string> = {
     '本页面提供吞吐量与总拥有成本（TCO）计算器：基于真实基准测试数据，估算不同芯片配置下 LLM 推理服务的每百万 token 成本与性价比。',
   fleet:
     '本页面提供集群生命周期经济性分析：按设施功率预算确定固定集群的规模，从模型发布之日起，基于历史基准测试中实测的软件配置改进，测算收入、成本、利润与回本时间。',
+  'first-token':
+    '本页面展示首 token 延迟约束下的成本对比：在选定的最低交互性下，按 2 s、5 s、10 s 等各档首 token 延迟（TTFT）上限，逐档找出各芯片厂商每百万 token 成本最低的实测配置，并标注最优配置与厂商间的成本差距。所有柱形均来自实际运行过的配置，不做插值，可直接追溯到对应的 GitHub Actions 运行记录。',
+  'cache-reuse':
+    '本页面展示前缀缓存复用情况：选定模型与配置后，按并发数逐档以堆叠柱形拆分 prompt token 的来源，分为芯片 HBM 缓存命中、主机层缓存命中与未复用（重新计算）三部分，并可叠加 trace 的理论上限。所有数值均来自运行时实测的缓存计数，可追溯到对应的 GitHub Actions 运行记录。',
   'profit-estimator':
     '本页面提供推理利润估算器：在选定的交互性与利用率下，按每芯片每小时计算各芯片的收入，并以堆叠柱形拆分为算力支出（TCO $/chip/hr）、模型实验室从收入中抽取的许可费，以及运营方所剩利润。',
   'profit-estimator-per-gigawatt':
@@ -148,6 +162,8 @@ export const TAB_LABELS_ZH: Record<DashboardRouteKey, string> = {
   historical: '历史趋势',
   calculator: 'TCO 计算器',
   fleet: '集群生命周期',
+  'first-token': '首 token 延迟约束',
+  'cache-reuse': '前缀缓存复用',
   'profit-estimator': '利润估算',
   'profit-estimator-per-gigawatt': '每吉瓦利润估算',
   reliability: '可靠性',
diff --git a/packages/app/src/lib/tab-meta.ts b/packages/app/src/lib/tab-meta.ts
index 95c368314..d1aa2e096 100644
--- a/packages/app/src/lib/tab-meta.ts
+++ b/packages/app/src/lib/tab-meta.ts
@@ -46,6 +46,16 @@ export const TAB_META: Record<DashboardRouteKey, { title: string; description: s
     description:
       'Project a fixed AI inference fleet across its life: size it against a facility power budget, then track revenue, cost, and margin as measured software configs improve over time.',
   },
+  'first-token': {
+    title: 'First-Token Limits',
+    description:
+      'Find the cheapest measured AI inference configuration per chip vendor under each time-to-first-token cap, at a minimum interactivity. Measured rows only, no interpolation, for any model and workload.',
+  },
+  'cache-reuse': {
+    title: 'Prefix Cache Reuse',
+    description:
+      'See where an AI inference configuration finds its prompt tokens as concurrency rises: HBM cache hits, host-tier cache hits, or recomputation. Measured runtime cache counters for every model and chip.',
+  },
   'profit-estimator': {
     title: 'Inference Profit Estimator',
     description:
diff --git a/packages/app/src/lib/url-state.test.ts b/packages/app/src/lib/url-state.test.ts
index 9fbd34e45..cfc114527 100644
--- a/packages/app/src/lib/url-state.test.ts
+++ b/packages/app/src/lib/url-state.test.ts
@@ -103,6 +103,16 @@ describe('PARAM_DEFAULTS', () => {
     expect(PARAM_DEFAULTS.i_revenue).toBe('normalized');
   });
 
+  it('has an empty default for perf rulers (none placed)', async () => {
+    const { PARAM_DEFAULTS } = await import('@/lib/url-state');
+    expect(PARAM_DEFAULTS.i_rulers).toBe('');
+  });
+
+  it('has an empty default for the power comparison (metric drawn alone)', async () => {
+    const { PARAM_DEFAULTS } = await import('@/lib/url-state');
+    expect(PARAM_DEFAULTS.i_pcompare).toBe('');
+  });
+
   it('has empty string defaults for legend-active params', async () => {
     const { PARAM_DEFAULTS } = await import('@/lib/url-state');
     expect(PARAM_DEFAULTS.i_active).toBe('');
@@ -141,6 +151,17 @@ describe('readUrlParams', () => {
     expect(params.i_seq).toBe('2k/4k');
   });
 
+  it('reads perf rulers decoded, with curve ids and separators intact', async () => {
+    const encoded = new URLSearchParams({
+      i_rulers: '41.5|roofline-b200_trt_fp8|overlay-roofline-h100_vllm_fp8_run1__2026-09%2F11',
+    }).toString();
+    setupWindow(`?${encoded}`);
+    const { readUrlParams } = await import('@/lib/url-state');
+    expect(readUrlParams().i_rulers).toBe(
+      '41.5|roofline-b200_trt_fp8|overlay-roofline-h100_vllm_fp8_run1__2026-09%2F11',
+    );
+  });
+
   it('reads the Internal TCO basis from the URL', async () => {
     setupWindow('?g_tco=internal');
     const { readUrlParams } = await import('@/lib/url-state');
@@ -370,6 +391,17 @@ describe('writeUrlParams + buildShareUrl', () => {
     expect(url).not.toContain('g_model');
   });
 
+  it('drops i_rulers from the share link once the last ruler is cleared', async () => {
+    setupWindow('?i_rulers=41.5%7Croofline-a%7Croofline-b', '/inference');
+    const { writeUrlParams, buildShareUrl } = await import('@/lib/url-state');
+    expect(buildShareUrl()).toContain('i_rulers=');
+
+    writeUrlParams({ i_rulers: '' });
+    await vi.advanceTimersByTimeAsync(200);
+
+    expect(buildShareUrl()).not.toContain('i_rulers');
+  });
+
   it('removes the revenue source instead of emitting an empty query param off-metric', async () => {
     setupWindow('?i_revenue=openrouter', '/inference');
     const { writeUrlParams, buildShareUrl } = await import('@/lib/url-state');
@@ -639,6 +671,28 @@ describe('buildShareUrl tab filtering', () => {
     expect(url).not.toContain('r_active');
   });
 
+  it('shares i_rulers on /inference and its compare routes but not on other tabs', async () => {
+    const rulers = '41.5|roofline-b200_trt_fp8|roofline-mi355x_sglang_fp4';
+    for (const pathname of ['/inference', '/zh/inference', '/compare/b200-vs-mi355x']) {
+      vi.resetModules();
+      setupWindow('', pathname);
+      const { writeUrlParams, buildShareUrl } = await import('@/lib/url-state');
+      writeUrlParams({ i_rulers: rulers });
+      await vi.advanceTimersByTimeAsync(200);
+      const url = buildShareUrl();
+      expect(url, pathname).toContain('i_rulers=');
+      expect(new URL(url).searchParams.get('i_rulers'), pathname).toBe(rulers);
+    }
+    for (const pathname of ['/evaluation', '/reliability']) {
+      vi.resetModules();
+      setupWindow('', pathname);
+      const { writeUrlParams, buildShareUrl } = await import('@/lib/url-state');
+      writeUrlParams({ i_rulers: rulers });
+      await vi.advanceTimersByTimeAsync(200);
+      expect(buildShareUrl(), pathname).not.toContain('i_rulers');
+    }
+  });
+
   it('includes e_active on /evaluation but not i_active or r_active', async () => {
     setupWindow('', '/evaluation');
     const { writeUrlParams, buildShareUrl } = await import('@/lib/url-state');
@@ -989,3 +1043,37 @@ describe('rememberChartStateInUrl — params this module does not own', () => {
     expect(params.has('unofficialrun')).toBe(false);
   });
 });
+
+describe('chartStateHref', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it('rebuilds the page URL from the chart state, canonical unofficial-run key and overrides', async () => {
+    setupWindow(
+      '?unofficialrun=31415926535&i_metric=y_tpPerGpu&utm_source=x',
+      '/inference',
+      '#chart',
+    );
+    const { chartStateHref, writeUrlParams } = await import('@/lib/url-state');
+    // A default value (i_prec) is not chart state and stays out of the link.
+    writeUrlParams({ g_model: 'Qwen-3.5-397B-A17B', i_metric: 'y_measuredAvgPower', i_prec: '' });
+
+    const url = new URL(chartStateHref({ i_metric: 'y_measuredPowerTimeline' }));
+    expect(url.origin).toBe('https://example.com');
+    expect(url.pathname).toBe('/inference');
+    expect(url.hash).toBe('#chart');
+    expect(url.searchParams.get('utm_source')).toBe('x');
+    expect(url.searchParams.get('g_model')).toBe('Qwen-3.5-397B-A17B');
+    expect(url.searchParams.has('i_prec')).toBe(false);
+    expect(url.searchParams.get('i_metric')).toBe('y_measuredPowerTimeline');
+    expect(url.searchParams.get('unofficialruns')).toBe('31415926535');
+    expect(url.searchParams.has('unofficialrun')).toBe(false);
+  });
+});
diff --git a/packages/app/src/lib/url-state.ts b/packages/app/src/lib/url-state.ts
index 1ebd9f9a4..aa13a5367 100644
--- a/packages/app/src/lib/url-state.ts
+++ b/packages/app/src/lib/url-state.ts
@@ -63,6 +63,12 @@ const URL_STATE_KEYS = [
   'i_spec',
   // Measured-power certification tiers ('certified' / 'legacy', comma-joined).
   'i_power',
+  // Completed Perf Rulers on the primary inference chart: `isoX|curveA|curveB`
+  // entries joined by `;` (see serializePerfRulers in d3-chart/layers/perf-ruler).
+  'i_rulers',
+  // Comparison series overlaid on a gated power metric: `boundaries` (every
+  // power boundary) or `roles` (prefill / decode pools). Empty = the metric alone.
+  'i_pcompare',
   // Exact serving-envelope pair behind an Overview 30-day comparison cell.
   'i_overview_current',
   'i_overview_baseline',
@@ -98,6 +104,13 @@ const URL_STATE_KEYS = [
   'c_rec',
   'c_life',
   'c_power',
+  // First-token limits: interactivity floor (tok/s/user) and the comma-joined
+  // TTFT cap ladder in seconds. Empty means the page's sequence-aware defaults.
+  'c_ivmin',
+  'c_ttft',
+  // Cache reuse: the configuration group plotted. Empty means the group with
+  // the most rows reporting cache tiers.
+  'c_cfg',
 ] as const;
 
 export type UrlStateKey = (typeof URL_STATE_KEYS)[number];
@@ -171,6 +184,8 @@ export const PARAM_DEFAULTS: Record<UrlStateKey, string> = {
   i_disagg: '',
   i_spec: '',
   i_power: '',
+  i_rulers: '',
+  i_pcompare: '',
   i_overview_current: '',
   i_overview_baseline: '',
   e_rundate: '',
@@ -194,6 +209,9 @@ export const PARAM_DEFAULTS: Record<UrlStateKey, string> = {
   c_oprice: '',
   c_life: '',
   c_power: 'provisioned',
+  c_ivmin: '',
+  c_ttft: '',
+  c_cfg: '',
   // Empty means the default y metric (margin).
   c_ly: '',
   c_ramp: DEFAULT_LIFECYCLE_RAMP_MONTHS,
@@ -483,6 +501,26 @@ export function rememberChartStateInUrl(): string {
   return chartParams.toString();
 }
 
+/**
+ * The current page's URL carrying its chart state plus `overrides`,
+ * canonicalised like `rememberChartStateInUrl`: chart params and both
+ * unofficial-run spellings are dropped from the live address bar before the
+ * store's state (and the overrides) are layered on. For anchors that must
+ * work with open-in-new-tab, where the in-memory state would otherwise be lost.
+ */
+export function chartStateHref(overrides: Record<string, string>): string {
+  const { origin, pathname, hash, search } = window.location;
+  const merged = new URLSearchParams(search);
+  for (const key of URL_STATE_KEYS) merged.delete(key);
+  // Collected first: deleting while iterating the params would skip entries.
+  const staleRunKeys = [...merged.keys()].filter((key) => UNOFFICIAL_RUN_PARAM_RE.test(key));
+  for (const key of staleRunKeys) merged.delete(key);
+  for (const [key, value] of collectTabParams()) merged.set(key, value);
+  for (const [key, value] of Object.entries(overrides)) merged.set(key, value);
+  const query = merged.toString();
+  return `${origin}${pathname}${query ? `?${query}` : ''}${hash}`;
+}
+
 /**
  * Append the current chart state to an outbound in-app href, so the page it
  * opens can link back to the chart the user left. Used for the agentic
diff --git a/packages/app/src/lib/video-alias-redirects.test.ts b/packages/app/src/lib/video-alias-redirects.test.ts
new file mode 100644
index 000000000..75b39818f
--- /dev/null
+++ b/packages/app/src/lib/video-alias-redirects.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+
+import { VIDEO_ALIAS_REDIRECTS, VIDEO_ROUTE_ALIASES } from './video-alias-redirects';
+
+describe('VIDEO_ALIAS_REDIRECTS', () => {
+  it('redirects every alias to /video in both locale trees', () => {
+    expect(VIDEO_ALIAS_REDIRECTS).toHaveLength(VIDEO_ROUTE_ALIASES.length * 2);
+
+    for (const alias of VIDEO_ROUTE_ALIASES) {
+      for (const prefix of ['', '/zh']) {
+        expect(VIDEO_ALIAS_REDIRECTS).toContainEqual({
+          source: `${prefix}/${alias}/:path*`,
+          destination: `${prefix}/video/:path*`,
+          permanent: true,
+        });
+      }
+    }
+  });
+
+  it('covers the /xvideo and /xxvideo vanity paths', () => {
+    const sources = VIDEO_ALIAS_REDIRECTS.map((redirect) => redirect.source);
+    expect(sources).toContain('/xvideo/:path*');
+    expect(sources).toContain('/xxvideo/:path*');
+    expect(sources).toContain('/zh/xvideo/:path*');
+    expect(sources).toContain('/zh/xxvideo/:path*');
+  });
+
+  it('never redirects the canonical video path to itself', () => {
+    for (const redirect of VIDEO_ALIAS_REDIRECTS) {
+      expect(redirect.source).not.toBe(redirect.destination);
+      expect(redirect.source).not.toMatch(/^(?:\/zh)?\/video\//);
+    }
+  });
+});
diff --git a/packages/app/src/lib/video-alias-redirects.ts b/packages/app/src/lib/video-alias-redirects.ts
new file mode 100644
index 000000000..d1203349d
--- /dev/null
+++ b/packages/app/src/lib/video-alias-redirects.ts
@@ -0,0 +1,25 @@
+interface VideoAliasRedirect {
+  source: string;
+  destination: string;
+  permanent: true;
+}
+
+/**
+ * Vanity aliases for the VideoGenX dashboard. `/video` stays the canonical
+ * home in both locale trees; the aliases 308-redirect there like the other
+ * alias tables in `next.config.ts`, so shared links keep working and search
+ * engines see one indexable URL. Query strings are carried automatically by
+ * Next's redirect handling.
+ */
+export const VIDEO_ROUTE_ALIASES = ['xvideo', 'xxvideo'] as const;
+
+const LOCALE_PREFIXES = ['', '/zh'] as const;
+
+export const VIDEO_ALIAS_REDIRECTS: readonly VideoAliasRedirect[] = LOCALE_PREFIXES.flatMap(
+  (prefix) =>
+    VIDEO_ROUTE_ALIASES.map((alias) => ({
+      source: `${prefix}/${alias}/:path*`,
+      destination: `${prefix}/video/:path*`,
+      permanent: true as const,
+    })),
+);
diff --git a/packages/app/timings.json b/packages/app/timings.json
index 98d6e58d1..2f1e8638d 100644
--- a/packages/app/timings.json
+++ b/packages/app/timings.json
@@ -44,6 +44,10 @@
       "spec": "cypress/e2e/blog.cy.ts",
       "duration": 5253
     },
+    {
+      "spec": "cypress/e2e/cache-reuse.cy.ts",
+      "duration": 4000
+    },
     {
       "spec": "cypress/e2e/calculator-overlay.cy.ts",
       "duration": 8785
@@ -128,6 +132,10 @@
       "spec": "cypress/e2e/evaluation-chart.cy.ts",
       "duration": 12735
     },
+    {
+      "spec": "cypress/e2e/first-token-limits.cy.ts",
+      "duration": 4000
+    },
     {
       "spec": "cypress/e2e/fixed-sequence-logs.cy.ts",
       "duration": 3002
@@ -228,6 +236,18 @@
       "spec": "cypress/e2e/performance.cy.ts",
       "duration": 2377
     },
+    {
+      "spec": "cypress/e2e/powerx-basis.cy.ts",
+      "duration": 3000
+    },
+    {
+      "spec": "cypress/e2e/powerx-timeline.cy.ts",
+      "duration": 24000
+    },
+    {
+      "spec": "cypress/e2e/powerx-compare.cy.ts",
+      "duration": 24000
+    },
     {
       "spec": "cypress/e2e/profit-estimator.cy.ts",
       "duration": 39450
diff --git a/packages/constants/src/models.ts b/packages/constants/src/models.ts
index 47fa5a7d5..10e159ed9 100644
--- a/packages/constants/src/models.ts
+++ b/packages/constants/src/models.ts
@@ -14,6 +14,13 @@ export const DB_MODEL_TO_DISPLAY: Record<string, string> = {
   // Qwen4-architecture preview, not a Qwen3.5 point release (GatedDeltaNet plus
   // Qwen Sparse Attention, 512 experts), so it gets its own display bucket.
   'qwen3.8next': 'Qwen3.8-Flash-Next',
+  // Qwen3.8-27B is the dense 27B member of the Qwen3.8 family (hybrid GDN linear
+  // attention, 48 of 64 layers), served bf16 with the RadixArk DSpark drafter.
+  // `qwen3.827beager` is the same checkpoint served with CUDA graphs disabled
+  // (--enforce-eager on target and drafter); it keeps its own DB bucket and
+  // display name so the two serving modes never collapse onto one chart point.
+  'qwen3.827b': 'Qwen3.8-27B',
+  'qwen3.827beager': 'Qwen3.8-27B-Eager',
   'kimik2.5': 'Kimi-K2.5',
   'kimik2.6': 'Kimi-K2.5',
   'kimik2.7-code': 'Kimi-K2.5',
@@ -158,6 +165,11 @@ export const MODEL_RELEASE_DATES: Record<string, string> = {
   // precedes the first sweep on 08-27. The model card itself states no date.
   // sweep: 2026-08-27 — day zero.
   'Qwen3.8-Flash-Next': '2026-08-26',
+  // Apache-2.0 weights at Qwen/Qwen3.8-27B: the Hugging Face repo was created
+  // 2026-08-05T08:22Z (its first commit) and last modified 2026-08-14. The eager
+  // bucket is the same checkpoint. sweep: 2026-09-18 (InferenceX#3260).
+  'Qwen3.8-27B': '2026-08-05',
+  'Qwen3.8-27B-Eager': '2026-08-05',
   // Bucket covers M2.5 and M2.7, so the date is M2.5's: announced 2026-02-12
   // with weights on Hugging Face, architecturally unchanged from M2 (230B/10B).
   // Was 2025-10-25, which is M2's launch, not M2.5's — `model-architectures.ts`
diff --git a/packages/db/src/etl/normalizers.ts b/packages/db/src/etl/normalizers.ts
index b8c20736e..437e8aa5f 100644
--- a/packages/db/src/etl/normalizers.ts
+++ b/packages/db/src/etl/normalizers.ts
@@ -102,6 +102,12 @@ export const MODEL_TO_KEY: Record<string, string> = {
   // PREFIX_ALIASES entry is needed.
   'Qwen/Qwen3.8-Flash-Next-FP8': 'qwen3.8next',
   'RadixArk/Qwen3.8-Flash-Next-NVFP4': 'qwen3.8next',
+  // Qwen3.8-27B (dense 27B, bf16). Both recipes serve this checkpoint and report
+  // `infmax_model_prefix` equal to their DB key (`qwen3.827b`, or `qwen3.827beager`
+  // for the --enforce-eager variant), so the prefix resolves first and this path
+  // entry only backs rows that lack the prefix. Seen in run 35362390175
+  // (H200, InferenceX#3263) and run 35359530151 (H100, InferenceX#3260).
+  'Qwen/Qwen3.8-27B': 'qwen3.827b',
   // Kimi-K2.5 / K2.6 / K2.7-Code (same architecture, distinct DB buckets)
   'moonshotai/Kimi-K2.5': 'kimik2.5',
   'moonshotai/Kimi-K2.6': 'kimik2.6',

From 598a8bef4a8ff5ee4db38b79701e8afc8756c47f Mon Sep 17 00:00:00 2001
From: Wenyao Gao <105094497+edwingao28@users.noreply.github.com>
Date: Sun, 20 Sep 2026 20:49:32 -0700
Subject: [PATCH 014/103] =?UTF-8?q?[PowerX]=20validate=20power=20evidence?=
 =?UTF-8?q?=20and=20preserve=20published=20curves=20/=20=E6=A0=A1=E9=AA=8C?=
 =?UTF-8?q?=E5=8A=9F=E8=80=97=E8=AF=81=E6=8D=AE=E5=B9=B6=E4=BF=9D=E6=8A=A4?=
 =?UTF-8?q?=E5=B7=B2=E5=8F=91=E5=B8=83=E6=9B=B2=E7=BA=BF=20(#1152)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat: enforce required PowerX publication coverage

中文：强制校验 PowerX 必需功耗点的入库与发布完整性。
按实际入库身份匹配并发点，保留过滤后的缺失检查，并核对 AgentX 数据库与 API 结果。

* fix: validate power evidence and preserve published curves

中文：校验必需功耗证据，并在入库前保护已发布曲线。版本化 manifest 绑定来源、物理 GPU、测量窗口和产物哈希；有意替换必须精确声明旧快照及移除点。
---
 .github/workflows/ingest-agentic-results.yml  |  12 +
 .github/workflows/ingest-results.yml          |   2 +
 docs/data-pipeline.md                         |  47 +-
 docs/fixtures/powerx-manifest-v2/README.md    | 101 ++++
 .../artifacts/agentic_golden/gpu_metrics.csv  |   3 +
 .../agentic_golden/gpu_metrics_identity.csv   |   2 +
 .../artifacts/agentic_golden/power_node.txt   |   1 +
 .../agentic_golden/power_validation.json      |  21 +
 .../artifacts/bmk_agentic_golden/agg.json     |  25 +
 .../changelog_metadata.json                   |   4 +
 .../sweep_manifest.json                       |  98 +++
 packages/db/src/etl/power-publication.test.ts |   8 +-
 packages/db/src/etl/power-publication.ts      |  36 +-
 .../src/etl/required-power-curve-db.test.ts   | 133 ++++
 .../db/src/etl/required-power-curve.test.ts   | 123 ++++
 packages/db/src/etl/required-power-curve.ts   | 287 +++++++++
 .../etl/required-power-publication.test.ts    | 572 +++++++++---------
 .../db/src/etl/required-power-publication.ts  | 520 +++++++++++++++-
 packages/db/src/ingest-ci-run.ts              |  27 +-
 .../db/src/preflight-power-publication.ts     |  36 ++
 packages/db/src/prepare-ci-artifacts.test.ts  |  90 +++
 packages/db/src/prepare-ci-artifacts.ts       |  11 +
 packages/db/src/verify-power-publication.ts   |   2 +-
 23 files changed, 1837 insertions(+), 324 deletions(-)
 create mode 100644 docs/fixtures/powerx-manifest-v2/README.md
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json
 create mode 100644 packages/db/src/etl/required-power-curve-db.test.ts
 create mode 100644 packages/db/src/etl/required-power-curve.test.ts
 create mode 100644 packages/db/src/etl/required-power-curve.ts
 create mode 100644 packages/db/src/preflight-power-publication.ts
 create mode 100644 packages/db/src/prepare-ci-artifacts.test.ts

diff --git a/.github/workflows/ingest-agentic-results.yml b/.github/workflows/ingest-agentic-results.yml
index b81cd68b0..3dcd23773 100644
--- a/.github/workflows/ingest-agentic-results.yml
+++ b/.github/workflows/ingest-agentic-results.yml
@@ -31,6 +31,11 @@ on:
         description: InferenceX Actions run ID to ingest
         required: true
         type: string
+      require-power:
+        description: Require the versioned PowerX manifest and all declared evidence
+        required: false
+        default: false
+        type: boolean
       run-attempt:
         description: InferenceX Actions run attempt to ingest
         required: false
@@ -85,6 +90,11 @@ on:
         description: InferenceX Actions run ID to ingest
         required: true
         type: string
+      require-power:
+        description: Require the versioned PowerX manifest and all declared evidence
+        required: false
+        default: false
+        type: boolean
       run-attempt:
         description: InferenceX Actions run attempt to ingest
         required: false
@@ -276,6 +286,7 @@ jobs:
             github.event.client_payload.run-id || inputs.run-id }}
           ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true || inputs.require-power == true }}
         run: bun run admin:db:prepare:ci
 
       - name: Run migrations
@@ -288,6 +299,7 @@ jobs:
           INGEST_RUN_ATTEMPT: ${{ steps.artifacts.outputs.merge-run-attempt }}
           INGEST_ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true || inputs.require-power == true }}
           UNMAPPED_ENTITIES_OUTPUT: ${{ github.workspace }}/unmapped-entities.json
           POWER_PUBLICATION_MANIFEST: ${{ github.workspace }}/power-publication.json
         run: bun run admin:db:ingest:ci
diff --git a/.github/workflows/ingest-results.yml b/.github/workflows/ingest-results.yml
index 04b253e34..d66e50a8f 100644
--- a/.github/workflows/ingest-results.yml
+++ b/.github/workflows/ingest-results.yml
@@ -60,6 +60,7 @@ jobs:
             github.event.client_payload.run-id }}
           ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true }}
         run: bun run admin:db:prepare:ci
 
       - name: Run migrations
@@ -75,6 +76,7 @@ jobs:
           INGEST_RUN_ATTEMPT: ${{ steps.artifacts.outputs.merge-run-attempt }}
           INGEST_ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true }}
           POWER_PUBLICATION_MANIFEST: ${{ github.workspace }}/power-publication.json
           UNMAPPED_ENTITIES_OUTPUT: ${{ github.workspace }}/unmapped-entities.json
         run: bun run admin:db:ingest:ci
diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index cf005cd11..65dfb67c6 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -84,23 +84,36 @@ must use the append-only contract below.
 
 ### Required Power Publication
 
-Ordinary sweeps that opt into `require-power` upload the producer's
-`required-power-sweep-manifest/sweep_manifest.json`. Before any CI ingest upsert,
-the app matches its required benchmark rows by recipe fingerprint, concurrency,
-and scenario/sequence lengths, then requires valid v2 power and positive energy.
-Disaggregated recipes also require both role energy measurements. Identical
-per-job and collected artifact copies are allowed; conflicting copies fail.
-Matching uses the ingest mapper's canonical identity, including AgentX `users`
-precedence over `conc`. After benchmark writes, any required point omitted by a
-purge or another filter fails the run; purged data is never restored to satisfy
-the declaration.
-
-The manifest must name the source run and head. A successful earlier attempt of
-that same run may supply the scope and retained points when failed jobs are
-rerun; ingestion logs both declared and current attempts. Sweeps without this
-optional manifest keep historical behavior. The separate PowerX publication
-receipt compares ingested 8K/1K and AgentX measurements with the database and
-public API after cache invalidation; it does not assert browser rendering.
+Required ordinary sweeps upload a versioned
+`required-power-sweep-manifest/sweep_manifest.json`. The [shared v2 fixture and
+contract](./fixtures/powerx-manifest-v2/README.md) bind the complete required
+matrix to source run/head/attempt, point identities, topology, exact measurement
+windows, physical node/GPU roles and hashed evidence. Both repositories test the
+same bytes. Unversioned required manifests fail closed; optional legacy bundles
+retain their existing behavior.
+
+Artifact preparation validates required evidence before workflow migrations.
+Required intent also travels in the dispatch payload, so losing both the manifest
+and changelog marker cannot downgrade an ordinary required dispatch. Ingestion
+repeats validation before workflow/config upserts, checks purges/backfills before
+writing, and projects the resulting published curves from base-table state. It
+models the actual latest-attempt, whole-curve and same-image append-only rules.
+An unexplained loss of an existing recipe or concurrency point rejects ingestion.
+Destructive replacement requires exact old-snapshot and lost-point identities in
+the manifest; the ordinary producer supplies no such permission.
+
+The source run and head must match. A successful earlier attempt of that same run
+may supply retained evidence when failed jobs are rerun; ingestion logs declared
+and current attempts. Required energy must be finite and positive. Missing,
+invalid and measured zero remain different values even though all fail this gate.
+Disaggregated deployments require physical evidence for both roles.
+
+This is pure preflight, not atomic publication. Schema migrations occur after
+artifact validation but before the curve check. Concurrent writers and failures
+during the existing per-file importer remain a risk; staging plus an atomic,
+serialized promotion is the follow-up described in the contract. The separate
+PowerX receipt still compares source measurements against the DB and exact-run
+API after ingestion. It does not prove latest-curve visibility or browser rendering.
 
 ### Append-Only Curve Extensions
 
diff --git a/docs/fixtures/powerx-manifest-v2/README.md b/docs/fixtures/powerx-manifest-v2/README.md
new file mode 100644
index 000000000..0075b4a13
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/README.md
@@ -0,0 +1,101 @@
+# PowerX source manifest v2
+
+This small, synthetic one-GPU AgentX bundle is copied byte-for-byte between
+InferenceX and InferenceX-app. It tests the file contract. It is **not** a GPU
+capture, hardware qualification or publication receipt.
+
+`artifacts/required-power-sweep-manifest/sweep_manifest.json` is the source
+manifest. Evidence paths are relative to `artifacts/`, include their GitHub
+artifact directory, and have SHA-256 hashes of the exact retained bytes.
+
+## Contract
+
+- `schema-version: 2` versions publication independently of measurement-row
+  `power_metric_schema_version: 2`. Unsupported or unversioned required bundles
+  fail closed; legacy optional bundles remain optional.
+- `run-id`, `run-attempt`, and `head` name the tested source. A later rerun may
+  retain successful earlier-attempt evidence from the same run and head. The
+  consumer compares these fields with GitHub source metadata, including on reuse.
+- `matrix` retains the ordinary planner declaration. Every required,
+  non-evaluation matrix point must occur exactly once in `points`.
+- `config_key` is the matrix entry's `exp-name`. `identity` binds model, hardware,
+  framework, precision, recipe fingerprint, workload/sequence and concurrency.
+  AgentX uses `agentic_traces` with null `isl`/`osl`; fixed sequence uses
+  `single_turn`. Full recipe details remain in the matrix and hashed aggregate.
+- `topology` declares aggregate versus P/D, single versus multi-node and physical
+  GPU counts. `devices` binds actual nodes and GPU UUIDs to aggregate, prefill or
+  decode roles with positive per-device energy. Both P/D roles are mandatory for
+  disaggregated deployments. A local GPU index alone is insufficient.
+- `measurement_window` contains finite Unix-second boundaries, with end after
+  start. The evidence must describe the same window.
+- `artifacts` contains confined relative paths, exact hashes and
+  `validation_state: "valid"`. Missing files, path escapes, invalid verdicts,
+  mismatched identities and invalid power reject required publication. Missing
+  and invalid values remain distinct from numeric zero. Required energy and
+  derived power must be strictly positive; measured zero fails that gate.
+
+## Publication intent
+
+Normal manifests emit `publication: {"mode":"incremental","replacement_scope":[]}`.
+Incremental means **no authorized loss**; it does not change existing whole-curve
+selection or automatically enable append-only. A complete refresh can pass by
+retaining all stable point identities. Recipe/image fingerprint changes may need
+a reviewed exact replacement.
+
+`mode: "replacement"` permits only explicit entries containing:
+
+- `curve_scope`: the canonical logical curve JSON identity;
+- `previous_snapshot_workflow_run_id`: the exact database snapshot superseded;
+- `removed_point_identities`: the exact set of lost stable identities.
+
+No wildcard, stale snapshot or broader permission is implied. The producer's
+ordinary path emits no destructive authorization. Authoring authorization needs
+explicitly reviewed replacement intent and current snapshot evidence.
+
+AgentX scope groups model/hardware/framework/precision/workload; AGG/P/D,
+parallelism, offload and recipe variants are points in that curve. Fixed-sequence
+scopes retain existing spec/disagg/offload boundaries. The consumer models latest
+attempts, whole snapshots and same-image append-only inheritance before its first
+publication write. Row counts or a stale materialized view cannot establish safety.
+
+## Remaining publication boundary
+
+Artifact validation runs before workflow migrations. Curve preflight runs before
+workflow/config/benchmark upserts. It is a pure preflight, not an atomic commit:
+concurrent writers and failures after the first write can still cause partial
+publication. Follow-up work must stage the complete run, recheck the base-table
+curve under a target-database publication lock, then atomically promote metadata
+and benchmark rows. Sidecar preparation belongs outside that transaction.
+Post-write DB/API checks remain necessary; exact-run equality alone does not prove
+latest-curve visibility.
+
+## Read-only fixture check in InferenceX-app
+
+From the repository root:
+
+```sh
+bun packages/db/src/preflight-power-publication.ts \
+  docs/fixtures/powerx-manifest-v2/artifacts 123 1 \
+  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+```
+
+This opens no database connection, dispatches no work and writes no files. It
+validates artifacts only; focused curve tests model previous published state.
+
+## 中文说明
+
+此目录是一份最小的合成 AgentX 样例，两个仓库保留完全相同的文件字节，
+用于测试 producer 与 consumer 的契约；它不是实机采集或生产发布证据。
+
+manifest schema v2 记录来源 run、attempt、测试 SHA、完整 matrix、逐点身份、
+测量窗口、实际 node/GPU UUID/角色及产物哈希。必需功耗路径拒绝缺失、损坏、
+不兼容或能量非正的证据；P/D 必须同时覆盖 prefill 和 decode。历史可选功耗
+路径保留兼容行为。数值 0 不会被改写为“缺失”，但不能通过正能量门槛。
+
+默认 incremental 只表示没有授权丢点，不会改变数据库整条曲线替换的语义。
+有意替换必须精确指定旧快照及全部移除点，不能使用通配或过期授权。AgentX
+的 AGG、P/D、offload 和配方属于同一条逻辑曲线，校验时必须一起比较。
+
+产物校验先于 migration；曲线校验先于发布数据写入。当前实现不是原子发布，
+仍需后续 staging、发布锁和事务性 promote 来处理并发及中途写入失败。
+DB/API 写后校验仍保留，exactRun 校验不能单独证明 latest 曲线完整可见。
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv
new file mode 100644
index 000000000..d39b2974a
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv
@@ -0,0 +1,3 @@
+timestamp, index, power.draw [W]
+2023/11/14 22:13:20.000, 0, 500
+2023/11/14 22:13:22.000, 0, 500
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv
new file mode 100644
index 000000000..139b5a261
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv
@@ -0,0 +1,2 @@
+index, uuid, pci.bus_id, name, driver_version
+0, GPU-golden, 00000000:01:00.0, NVIDIA H100, 000.00
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt
new file mode 100644
index 000000000..fb271d435
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt
@@ -0,0 +1 @@
+golden-node
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json
new file mode 100644
index 000000000..42d164cb2
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json
@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "power_valid": true,
+  "reasons": [],
+  "benchmark_window": {
+    "start_time_unix": 1700000000,
+    "end_time_unix": 1700000002
+  },
+  "expected_gpu_count": 1,
+  "observed_gpu_count": 1,
+  "observed_gpu_ids": ["0"],
+  "per_gpu_energy_j": {
+    "0": 1000
+  },
+  "metrics": {
+    "avg_power_w": 500,
+    "avg_total_gpu_power_w": 500,
+    "total_gpu_energy_j": 1000,
+    "joules_per_output_token": 2
+  }
+}
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json b/docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json
new file mode 100644
index 000000000..98df7c14b
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json
@@ -0,0 +1,25 @@
+{
+  "infmax_model_prefix": "qwen3.5",
+  "hw": "h100",
+  "framework": "sglang",
+  "precision": "fp8",
+  "recipe_fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "scenario_type": "agentic-coding",
+  "conc": 1,
+  "users": 1,
+  "tp": 1,
+  "ep": 1,
+  "dp_attention": false,
+  "disagg": false,
+  "is_multinode": false,
+  "num_gpus": 1,
+  "image": "example/serving:golden",
+  "power_valid": 1,
+  "power_metric_schema_version": 2,
+  "avg_power_w": 500,
+  "avg_total_gpu_power_w": 500,
+  "total_gpu_energy_j": 1000,
+  "joules_per_output_token": 2,
+  "output_tput_per_gpu": 250,
+  "median_intvty": 50
+}
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json b/docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json
new file mode 100644
index 000000000..af53bb83d
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json
@@ -0,0 +1,4 @@
+{
+  "require-power": true,
+  "entries": []
+}
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json b/docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json
new file mode 100644
index 000000000..f51df0546
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json
@@ -0,0 +1,98 @@
+{
+  "schema-version": 2,
+  "head": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "run-id": 123,
+  "run-attempt": 1,
+  "full-sweep": false,
+  "matrix": {
+    "single_node": {
+      "agentic": [
+        {
+          "exp-name": "golden",
+          "model-prefix": "qwen3.5",
+          "model": "Qwen/Qwen3.5",
+          "runner": "h100",
+          "framework": "sglang",
+          "precision": "fp8",
+          "recipe-fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "conc": [1],
+          "require-power": true,
+          "scenario-type": "agentic-coding",
+          "disagg": false,
+          "num-gpus": 1,
+          "tp": 1,
+          "ep": 1,
+          "image": "example/serving:golden"
+        }
+      ]
+    },
+    "multi_node": {}
+  },
+  "publication": {
+    "mode": "incremental",
+    "replacement_scope": []
+  },
+  "points": [
+    {
+      "config_key": "golden",
+      "identity": {
+        "model": "qwen3.5",
+        "hardware": "h100",
+        "framework": "sglang",
+        "precision": "fp8",
+        "recipe_fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "benchmark_type": "agentic_traces",
+        "isl": null,
+        "osl": null,
+        "concurrency": 1
+      },
+      "topology": {
+        "disagg": false,
+        "is_multinode": false,
+        "num_gpus": 1,
+        "tp": 1,
+        "ep": 1,
+        "dp_attention": false
+      },
+      "measurement_window": {
+        "start_time_unix": 1700000000,
+        "end_time_unix": 1700000002
+      },
+      "devices": [
+        {
+          "node": "golden-node",
+          "gpu_uuid": "GPU-golden",
+          "role": "aggregate",
+          "energy_j": 1000
+        }
+      ],
+      "artifacts": [
+        {
+          "path": "agentic_golden/gpu_metrics.csv",
+          "sha256": "f42dee832f8d837142be9d4dc5fbbf8462c02846f06e66edfce659b8b20943db",
+          "validation_state": "valid"
+        },
+        {
+          "path": "agentic_golden/gpu_metrics_identity.csv",
+          "sha256": "a4364a0d4050078b9cba24c7e695fbed658fabb1d48e61a3da8f61b8ec873627",
+          "validation_state": "valid"
+        },
+        {
+          "path": "agentic_golden/power_node.txt",
+          "sha256": "114aa18bee3688c0e6040020ad0230472645541372b88a54253116fd9c2148e6",
+          "validation_state": "valid"
+        },
+        {
+          "path": "agentic_golden/power_validation.json",
+          "sha256": "c00687e7239fd172aa15f60c8d967294a0fa623984d0eaeeb5222424b6335d94",
+          "validation_state": "valid"
+        },
+        {
+          "path": "bmk_agentic_golden/agg.json",
+          "sha256": "56e3377ae12402eec61e25e2f9a0480ab228048a29d32c35cb8d438d50ea2faa",
+          "validation_state": "valid"
+        }
+      ]
+    }
+  ]
+}
diff --git a/packages/db/src/etl/power-publication.test.ts b/packages/db/src/etl/power-publication.test.ts
index f223a07a4..b31ce0f98 100644
--- a/packages/db/src/etl/power-publication.test.ts
+++ b/packages/db/src/etl/power-publication.test.ts
@@ -37,7 +37,7 @@ function expected(overrides = {}) {
     'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/123/attempts/2',
     { path: 'bmk_qwen3.5/results.json', sha256: 'abc' },
   );
-  if (!point) throw new Error('Fixture must be 8K/1K');
+  if (!point) throw new Error('Fixture must belong to a supported PowerX workload');
   return point;
 }
 function actual(point = expected()): PublishedPowerRow {
@@ -51,6 +51,12 @@ function actual(point = expected()): PublishedPowerRow {
 }
 
 describe('PowerX publication', () => {
+  it('keeps required 1K/1K measurements in the publication receipt', () => {
+    const point = expected({ isl: 1024, joules_per_output_token: 2.5 });
+    expect(point.identity).toMatchObject({ benchmark_type: 'single_turn', isl: 1024, osl: 1024 });
+    expect(verifyPowerPublication([point], [actual(point)], 'database')).toEqual([]);
+    expect(verifyPowerPublication([point], [], 'public API')[0]).toContain('found 0');
+  });
   it('verifies AgentX source identity, nullable sequences, energy and audit through DB/API', () => {
     const point = expected({
       scenario_type: 'agentic-coding',
diff --git a/packages/db/src/etl/power-publication.ts b/packages/db/src/etl/power-publication.ts
index d2ed10c14..5009468be 100644
--- a/packages/db/src/etl/power-publication.ts
+++ b/packages/db/src/etl/power-publication.ts
@@ -52,20 +52,22 @@ export interface PublishedPowerRow extends Record<string, unknown> {
   metrics: Record<string, number>;
 }
 
+export function stablePowerPointIdentity(row: Record<string, unknown>): string {
+  return JSON.stringify(
+    IDENTITY_FIELDS.filter((key) => key !== 'image' && key !== 'run_url').map(
+      (key) => row[key] ?? null,
+    ),
+  );
+}
+
 export function publicationIdentity(row: Record<string, unknown>): string {
   return JSON.stringify(IDENTITY_FIELDS.map((key) => row[key] ?? null));
 }
 
-export function powerPublicationPoint(
+export function benchmarkPublicationIdentity(
   row: BenchmarkParams,
-  runUrl: string,
-  artifact: PowerPublicationPoint['artifact'],
-): PowerPublicationPoint | null {
-  if (
-    row.benchmarkType !== 'agentic_traces' &&
-    (row.benchmarkType !== 'single_turn' || row.isl !== 8192 || row.osl !== 1024)
-  )
-    return null;
+  runUrl = '',
+): Record<string, unknown> {
   const identity: Record<string, unknown> = Object.fromEntries(
     Object.entries(CONFIG_FIELDS).map(([source, target]) => [
       target,
@@ -82,6 +84,22 @@ export function powerPublicationPoint(
     image: row.image,
     run_url: runUrl,
   });
+  return identity;
+}
+
+export function powerPublicationPoint(
+  row: BenchmarkParams,
+  runUrl: string,
+  artifact: PowerPublicationPoint['artifact'],
+): PowerPublicationPoint | null {
+  if (
+    row.benchmarkType !== 'agentic_traces' &&
+    (row.benchmarkType !== 'single_turn' ||
+      (row.isl !== 1024 && row.isl !== 8192) ||
+      row.osl !== 1024)
+  )
+    return null;
+  const identity = benchmarkPublicationIdentity(row, runUrl);
   return {
     identity,
     metrics: Object.fromEntries(
diff --git a/packages/db/src/etl/required-power-curve-db.test.ts b/packages/db/src/etl/required-power-curve-db.test.ts
new file mode 100644
index 000000000..a5ec3da12
--- /dev/null
+++ b/packages/db/src/etl/required-power-curve-db.test.ts
@@ -0,0 +1,133 @@
+import { PGlite } from '@electric-sql/pglite';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { beforeAll, beforeEach, afterAll, describe, it, expect } from 'vitest';
+import type { DbClient } from '../connection';
+import { preflightRequiredPowerCurves } from './required-power-curve';
+import { getLatestBenchmarks } from '../queries/benchmarks';
+let db: PGlite;
+const sql: DbClient = async (strings, ...values) => {
+  const query = strings.reduce((text, part, index) => text + (index ? `$${index}` : '') + part, '');
+  const result = await db.query<Record<string, unknown>>(query, values);
+  return result.rows;
+};
+const golden = path.resolve(
+  import.meta.dirname,
+  '../../../../docs/fixtures/powerx-manifest-v2/artifacts',
+);
+const source = { runId: 123, runAttempt: 1, headSha: 'b'.repeat(40) };
+const options = { date: '2026-09-16', runStartedAt: '2026-09-16T00:00:00Z', appendOnly: false };
+beforeAll(async () => {
+  db = await PGlite.create();
+  const dir = new URL('../../migrations/', import.meta.url);
+  for (const file of fs
+    .readdirSync(dir)
+    .filter((name) => name.endsWith('.sql'))
+    .sort())
+    await db.exec(fs.readFileSync(new URL(file, dir), 'utf8'));
+}, 20000);
+afterAll(async () => {
+  await db?.close();
+});
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, prefill_ep, decode_tp, decode_ep, num_prefill_gpu, num_decode_gpu)
+      VALUES (1, 'qwen3.5', 'h100', 'sglang', 'fp8', 'none', false, 1,1,1,1,1,1);
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, date, created_at, run_started_at)
+      VALUES (1, 111, 1, 'previous', '2026-09-15', '2026-09-15T00:00:00Z', '2026-09-15T00:00:00Z');`);
+});
+async function addPoint(conc: number, image = 'example/serving:golden') {
+  await sql`INSERT INTO benchmark_results (config_id, workflow_run_id, date, benchmark_type, isl, osl, conc, offload_mode, recipe_fingerprint, image, metrics)
+    VALUES (1,1,'2026-09-15','agentic_traces',NULL,NULL,${conc},'off',${'a'.repeat(64)},${image},'{}')`;
+}
+describe('read-only required-power DB preflight', () => {
+  it('rejects partial refresh from base tables before any write, even with a stale latest view', async () => {
+    await addPoint(1);
+    await addPoint(64);
+    const before = await sql`SELECT count(*)::int AS n FROM benchmark_results`;
+    await expect(preflightRequiredPowerCurves(sql, golden, source, options)).rejects.toThrow(
+      'shrink',
+    );
+    expect(await sql`SELECT count(*)::int AS n FROM benchmark_results`).toEqual(before);
+    expect(await sql`SELECT count(*)::int AS n FROM workflow_runs`).toEqual([{ n: 1 }]);
+    const published = await getLatestBenchmarks(sql, 'qwen3.5', '9999-12-31');
+    expect(published.map((row) => row.conc)).toEqual([1, 64]);
+  });
+  it('accepts complete incoming point coverage', async () => {
+    await addPoint(1);
+    await expect(
+      preflightRequiredPowerCurves(sql, golden, source, options),
+    ).resolves.toBeUndefined();
+    expect(await sql`SELECT count(*)::int AS n FROM workflow_runs`).toEqual([{ n: 1 }]);
+  });
+  it('inherits same-image append-only state but rejects a changed image', async () => {
+    await addPoint(1);
+    await addPoint(64);
+    await expect(
+      preflightRequiredPowerCurves(sql, golden, source, { ...options, appendOnly: true }),
+    ).resolves.toBeUndefined();
+    await sql`UPDATE benchmark_results SET image='old-image'`;
+    await expect(
+      preflightRequiredPowerCurves(sql, golden, source, { ...options, appendOnly: true }),
+    ).rejects.toThrow('shrink');
+  });
+  it('detects retry removal from a scope omitted entirely by incoming artifacts', async () => {
+    await sql`UPDATE workflow_runs SET github_run_id=123`;
+    await sql`UPDATE configs SET hardware='h200'`;
+    await addPoint(64);
+    await expect(
+      preflightRequiredPowerCurves(sql, golden, { ...source, runAttempt: 2 }, options),
+    ).rejects.toThrow('shrink');
+    expect(await sql`SELECT count(*)::int AS n FROM workflow_runs`).toEqual([{ n: 1 }]);
+  });
+  it('protects optional fixed workloads outside the power receipt whitelist', async () => {
+    await sql`INSERT INTO benchmark_results (config_id,workflow_run_id,date,benchmark_type,isl,osl,conc,offload_mode,recipe_fingerprint,image,metrics)
+      VALUES (1,1,'2026-09-15','single_turn',4096,1024,1,'off',${'c'.repeat(64)},'example/serving:golden','{}'),
+      (1,1,'2026-09-15','single_turn',4096,1024,8,'off',${'c'.repeat(64)},'example/serving:golden','{}')`;
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-optional-'));
+    try {
+      fs.cpSync(golden, dir, { recursive: true });
+      fs.mkdirSync(path.join(dir, 'results_optional'));
+      const row = JSON.parse(
+        fs.readFileSync(path.join(golden, 'bmk_agentic_golden/agg.json'), 'utf8'),
+      );
+      delete row.scenario_type;
+      delete row.users;
+      Object.assign(row, { isl: 4096, osl: 1024, recipe_fingerprint: 'c'.repeat(64) });
+      fs.writeFileSync(path.join(dir, 'results_optional/extra.json'), JSON.stringify(row));
+      await expect(preflightRequiredPowerCurves(sql, dir, source, options)).rejects.toThrow(
+        'shrink',
+      );
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+  it('models mixed dates on same-attempt upserts instead of overlooking a newer snapshot', async () => {
+    await sql`UPDATE workflow_runs SET github_run_id=123`;
+    await addPoint(1);
+    await sql`UPDATE benchmark_results SET date='2026-09-10'`;
+    await sql`INSERT INTO workflow_runs (id,github_run_id,run_attempt,name,date,created_at,run_started_at)
+      VALUES (2,222,1,'competing','2026-09-12','2026-09-12T00:00:00Z','2026-09-12T00:00:00Z')`;
+    await sql`INSERT INTO benchmark_results (config_id,workflow_run_id,date,benchmark_type,isl,osl,conc,offload_mode,recipe_fingerprint,image,metrics)
+      VALUES (1,2,'2026-09-12','agentic_traces',NULL,NULL,8,'off',${'a'.repeat(64)},'example/serving:golden','{}')`;
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-dates-'));
+    try {
+      fs.cpSync(golden, dir, { recursive: true });
+      fs.mkdirSync(path.join(dir, 'results_optional'));
+      const row = JSON.parse(
+        fs.readFileSync(path.join(golden, 'bmk_agentic_golden/agg.json'), 'utf8'),
+      );
+      Object.assign(row, { conc: 4, users: 4 });
+      fs.writeFileSync(path.join(dir, 'results_optional/extra.json'), JSON.stringify(row));
+      await expect(preflightRequiredPowerCurves(sql, dir, source, options)).rejects.toThrow(
+        'shrink',
+      );
+      const published = await getLatestBenchmarks(sql, 'qwen3.5', '9999-12-31');
+      expect(published.map((point) => point.conc)).toEqual([8]);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/packages/db/src/etl/required-power-curve.test.ts b/packages/db/src/etl/required-power-curve.test.ts
new file mode 100644
index 000000000..b94378c09
--- /dev/null
+++ b/packages/db/src/etl/required-power-curve.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest';
+import {
+  assertCurvePreserved,
+  publishedCurve,
+  type CurvePoint,
+  type CurvePublication,
+} from './required-power-curve';
+import { powerPublicationPoint, stablePowerPointIdentity } from './power-publication';
+import { verifyRequiredPowerArtifacts } from './required-power-publication';
+import path from 'node:path';
+const golden = path.resolve(
+  import.meta.dirname,
+  '../../../../docs/fixtures/powerx-manifest-v2/artifacts',
+);
+const benchmark = verifyRequiredPowerArtifacts(golden, {
+  runId: 123,
+  runAttempt: 1,
+  headSha: 'b'.repeat(40),
+})[0];
+const identity = powerPublicationPoint(benchmark, '', { path: '', sha256: '' })!.identity;
+const policy: CurvePublication = { mode: 'incremental', replacement_scope: [] };
+function point(run: number, conc: number, extra: Partial<CurvePoint> = {}): CurvePoint {
+  return {
+    identity: { ...identity, conc },
+    image: 'same-image',
+    workflowRunId: run,
+    githubRunId: run,
+    runAttempt: 1,
+    date: `2026-09-${run.toString().padStart(2, '0')}`,
+    runStartedAt: null,
+    appendOnly: false,
+    ...extra,
+  };
+}
+describe('pure projected publication curve', () => {
+  it('rejects the old partial-sweep regression without altering input rows', () => {
+    const old = [
+      point(1, 1),
+      point(1, 16),
+      point(1, 64, {
+        identity: { ...identity, conc: 64, disagg: true, recipe_fingerprint: 'split-recipe' },
+      }),
+    ];
+    const proposed = [...old, point(2, 1)];
+    expect(() => assertCurvePreserved(old, proposed, policy)).toThrow('shrink');
+    expect([...publishedCurve(old).values()][0]).toHaveLength(3);
+  });
+  it('accepts a complete refresh and unrelated curve additions', () => {
+    const old = [point(1, 1), point(1, 16)];
+    expect(() =>
+      assertCurvePreserved(old, [...old, point(2, 1), point(2, 16)], policy),
+    ).not.toThrow();
+    expect(() =>
+      assertCurvePreserved(
+        old,
+        [...old, point(2, 1, { identity: { ...identity, hardware: 'h200' } })],
+        policy,
+      ),
+    ).not.toThrow();
+  });
+  it.each([null, 'new-image'])(
+    'does not inherit append-only history with incompatible image %s',
+    (image) => {
+      const old = [point(1, 1), point(1, 16)];
+      expect(() =>
+        assertCurvePreserved(old, [...old, point(2, 32, { appendOnly: true, image })], policy),
+      ).toThrow('shrink');
+    },
+  );
+  it('inherits only an uninterrupted same-image append-only chain', () => {
+    const old = [point(1, 1), point(1, 16), point(2, 32, { appendOnly: true })];
+    expect([...publishedCurve(old).values()][0].map((row) => row.identity.conc)).toEqual([
+      32, 1, 16,
+    ]);
+    expect(() =>
+      assertCurvePreserved(old, [...old, point(3, 64, { appendOnly: true })], policy),
+    ).not.toThrow();
+    expect(() => assertCurvePreserved(old, [...old, point(3, 64)], policy)).toThrow('shrink');
+  });
+  it('permits only the exact removed identities of the observed snapshot', () => {
+    const old = [point(1, 1), point(1, 16)];
+    const proposed = [...old, point(2, 1)];
+    const replacement: CurvePublication = {
+      mode: 'replacement',
+      replacement_scope: [
+        {
+          curve_scope: [...publishedCurve(old).keys()][0],
+          previous_snapshot_workflow_run_id: 1,
+          removed_point_identities: [stablePowerPointIdentity(old[1].identity)],
+        },
+      ],
+    };
+    expect(() => assertCurvePreserved(old, proposed, replacement)).not.toThrow();
+    for (const altered of [
+      { ...replacement.replacement_scope[0], previous_snapshot_workflow_run_id: 99 },
+      { ...replacement.replacement_scope[0], removed_point_identities: ['*'] },
+      { ...replacement.replacement_scope[0], curve_scope: '*' },
+    ])
+      expect(() =>
+        assertCurvePreserved(old, proposed, { mode: 'replacement', replacement_scope: [altered] }),
+      ).toThrow('shrink');
+  });
+  it('treats topology and offload as point identity inside one AgentX curve', () => {
+    const old = [point(1, 1)];
+    for (const altered of [
+      { prefill_tp: 2 },
+      { offload_mode: 'on' },
+      { recipe_fingerprint: 'other-recipe' },
+    ]) {
+      expect(() =>
+        assertCurvePreserved(
+          old,
+          [...old, point(2, 1, { identity: { ...identity, ...altered } })],
+          policy,
+        ),
+      ).toThrow('shrink');
+    }
+  });
+  it('does not let an older run replace newer curve state', () => {
+    const old = [point(2, 1), point(2, 16)];
+    expect(() => assertCurvePreserved(old, [...old, point(1, 1)], policy)).not.toThrow();
+  });
+});
diff --git a/packages/db/src/etl/required-power-curve.ts b/packages/db/src/etl/required-power-curve.ts
new file mode 100644
index 000000000..1b2cdfbfa
--- /dev/null
+++ b/packages/db/src/etl/required-power-curve.ts
@@ -0,0 +1,287 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  benchmarkCurveScope,
+  type BenchmarkCurveInput,
+} from '@semianalysisai/inferencex-constants';
+import type { DbClient } from '../connection';
+import type { Sql } from './db-utils';
+import { REQUIRED_POWER_MANIFEST } from '../lib/ci-artifact-preparation';
+import { mapBenchmarkRow, type BenchmarkParams } from './benchmark-mapper';
+import { configCacheKey, type ConfigParams } from './config-cache';
+import { benchmarkPublicationIdentity, stablePowerPointIdentity } from './power-publication';
+import {
+  assertRequiredPowerPointsRetained,
+  verifyRequiredPowerArtifacts,
+  type RequiredPowerSource,
+} from './required-power-publication';
+import {
+  applyBenchmarkPointBackfill,
+  isBenchmarkPointPurged,
+  recordBackfilledPointIdentity,
+} from './run-overrides';
+import { createSkipTracker } from './skip-tracker';
+
+export interface CurvePoint {
+  identity: Record<string, unknown>;
+  image: string | null;
+  workflowRunId: number;
+  githubRunId: number;
+  runAttempt: number;
+  date: string;
+  runStartedAt: string | null;
+  appendOnly: boolean;
+}
+export interface CurveReplacement {
+  curve_scope: string;
+  previous_snapshot_workflow_run_id: number;
+  removed_point_identities: string[];
+}
+export interface CurvePublication {
+  mode: 'incremental' | 'replacement';
+  replacement_scope: CurveReplacement[];
+}
+
+function scope(point: CurvePoint): string {
+  return benchmarkCurveScope(point.identity as unknown as BenchmarkCurveInput);
+}
+
+/** Mirrors migration 014: latest attempt, scope-level snapshots and same-image append chains. */
+export function publishedCurve(points: readonly CurvePoint[]): Map<string, CurvePoint[]> {
+  const latestAttempts = new Map<number, number>();
+  for (const point of points)
+    latestAttempts.set(
+      point.githubRunId,
+      Math.max(latestAttempts.get(point.githubRunId) ?? 0, point.runAttempt),
+    );
+  const scopes = new Map<string, Map<string, CurvePoint[]>>();
+  for (const point of points) {
+    if (point.runAttempt !== latestAttempts.get(point.githubRunId)) continue;
+    const key = scope(point);
+    const runs = scopes.get(key) ?? new Map<string, CurvePoint[]>();
+    const runDate = JSON.stringify([point.workflowRunId, point.date]);
+    runs.set(runDate, [...(runs.get(runDate) ?? []), point]);
+    scopes.set(key, runs);
+  }
+  const result = new Map<string, CurvePoint[]>();
+  for (const [key, runs] of scopes) {
+    const ranked = [...runs.values()].sort(
+      (a, b) =>
+        b[0].date.localeCompare(a[0].date) ||
+        (b[0].runStartedAt ? Date.parse(b[0].runStartedAt) : -Infinity) -
+          (a[0].runStartedAt ? Date.parse(a[0].runStartedAt) : -Infinity) ||
+        b[0].workflowRunId - a[0].workflowRunId,
+    );
+    const rootImage = ranked[0][0].image;
+    const uniformImage = (rows: CurvePoint[]) =>
+      rootImage !== null && rows.every((row) => row.image === rootImage);
+    const selected = new Map<string, CurvePoint>();
+    for (let index = 0; index < ranked.length; index++) {
+      const current = ranked[index];
+      // SQL groups run/date for ranking, then joins every point in that run/scope.
+      for (const point of [...runs.values()]
+        .flat()
+        .filter((candidate) => candidate.workflowRunId === current[0].workflowRunId)) {
+        const id = stablePowerPointIdentity(point.identity);
+        if (!selected.has(id)) selected.set(id, point);
+      }
+      if (
+        !current[0].appendOnly ||
+        !uniformImage(current) ||
+        !ranked[index + 1] ||
+        !uniformImage(ranked[index + 1])
+      )
+        break;
+    }
+    result.set(key, [...selected.values()]);
+  }
+  return result;
+}
+
+function canonical(entries: CurveReplacement[]): string {
+  return JSON.stringify(
+    entries
+      .map((entry) => {
+        if (
+          typeof entry.curve_scope !== 'string' ||
+          !Number.isSafeInteger(entry.previous_snapshot_workflow_run_id) ||
+          !Array.isArray(entry.removed_point_identities) ||
+          entry.removed_point_identities.some((id) => typeof id !== 'string')
+        )
+          throw new Error('Required power: invalid exact replacement scope');
+        return { ...entry, removed_point_identities: [...entry.removed_point_identities].sort() };
+      })
+      .sort((a, b) => a.curve_scope.localeCompare(b.curve_scope)),
+  );
+}
+
+/** Exact lost identities bind any destructive authorization to one observed snapshot. */
+export function assertCurvePreserved(
+  existing: readonly CurvePoint[],
+  proposed: readonly CurvePoint[],
+  publication: CurvePublication,
+): void {
+  if (
+    !publication ||
+    !['incremental', 'replacement'].includes(publication.mode) ||
+    !Array.isArray(publication.replacement_scope)
+  )
+    throw new Error('Required power: invalid curve publication policy');
+  const before = publishedCurve(existing);
+  const after = publishedCurve(proposed);
+  const losses: CurveReplacement[] = [];
+  for (const [key, oldPoints] of before) {
+    const next = new Set(
+      (after.get(key) ?? []).map((point) => stablePowerPointIdentity(point.identity)),
+    );
+    const removed = oldPoints
+      .map((point) => stablePowerPointIdentity(point.identity))
+      .filter((identity) => !next.has(identity))
+      .sort();
+    if (removed.length > 0)
+      losses.push({
+        curve_scope: key,
+        previous_snapshot_workflow_run_id: oldPoints[0].workflowRunId,
+        removed_point_identities: removed,
+      });
+  }
+  if (publication.mode === 'incremental' && publication.replacement_scope.length > 0)
+    throw new Error('Required power: incremental publication cannot authorize replacement');
+  if (
+    (losses.length > 0 && publication.mode !== 'replacement') ||
+    canonical(losses) !== canonical(publication.replacement_scope)
+  )
+    throw new Error(
+      `Required power: publication would shrink the existing curve; exact replacement_scope required: ${JSON.stringify(losses)}`,
+    );
+}
+
+/** Read-only preflight; no config/workflow upsert, migration, or materialized-view refresh. */
+export async function preflightRequiredPowerCurves(
+  sql: DbClient | Sql,
+  root: string,
+  source: RequiredPowerSource,
+  options: { date: string; runStartedAt: string | null; appendOnly: boolean },
+): Promise<void> {
+  const required = verifyRequiredPowerArtifacts(root, source);
+  if (required.length === 0) return;
+  const manifest = JSON.parse(
+    fs.readFileSync(path.join(root, REQUIRED_POWER_MANIFEST, 'sweep_manifest.json'), 'utf8'),
+  );
+  const configs = await sql`SELECT * FROM configs`;
+  const configIds = new Map(
+    configs.map((row) => [
+      configCacheKey({
+        hardware: row.hardware,
+        framework: row.framework,
+        model: row.model,
+        precision: row.precision,
+        specMethod: row.spec_method,
+        disagg: row.disagg,
+        isMultinode: row.is_multinode,
+        prefillTp: row.prefill_tp,
+        prefillEp: row.prefill_ep,
+        prefillDpAttn: row.prefill_dp_attention,
+        prefillNumWorkers: row.prefill_num_workers,
+        decodeTp: row.decode_tp,
+        decodeEp: row.decode_ep,
+        decodeDpAttn: row.decode_dp_attention,
+        decodeNumWorkers: row.decode_num_workers,
+        numPrefillGpu: row.num_prefill_gpu,
+        numDecodeGpu: row.num_decode_gpu,
+      } as ConfigParams),
+      Number(row.id),
+    ]),
+  );
+  const incoming = new Map<string, BenchmarkParams>();
+  const backfilled = new Map<string, string>();
+  for (const name of fs.readdirSync(root)) {
+    if (
+      (!name.startsWith('bmk_') && !name.startsWith('results_')) ||
+      !fs.statSync(path.join(root, name)).isDirectory()
+    )
+      continue;
+    for (const file of fs
+      .readdirSync(path.join(root, name))
+      .filter((candidateName) => candidateName.endsWith('.json'))) {
+      const data = JSON.parse(fs.readFileSync(path.join(root, name, file), 'utf8'));
+      for (const raw of Array.isArray(data) ? data : [data]) {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
+        const mapped = mapBenchmarkRow(raw, createSkipTracker(), undefined, source.runId);
+        if (!mapped) continue;
+        // A config not present yet cannot match a config-id-scoped purge/backfill.
+        const point = { ...mapped, configId: configIds.get(configCacheKey(mapped.config)) ?? -1 };
+        if (isBenchmarkPointPurged(source.runId, source.runAttempt, point)) continue;
+        const applied = applyBenchmarkPointBackfill(source.runId, source.runAttempt, point);
+        recordBackfilledPointIdentity(backfilled, applied.sourceIdentity, applied.desiredIdentity);
+        incoming.set(
+          stablePowerPointIdentity(benchmarkPublicationIdentity(applied.point)),
+          applied.point,
+        );
+      }
+    }
+  }
+  assertRequiredPowerPointsRetained(required, [...incoming.values()]);
+  const models = [...new Set([...incoming.values()].map((point) => point.config.model))];
+  const rows = await sql`
+    SELECT c.*, br.benchmark_type, br.isl, br.osl, br.conc, br.offload_mode,
+      br.recipe_fingerprint, br.image, br.date::text AS point_date,
+      wr.id AS workflow_run_id, wr.github_run_id, wr.run_attempt,
+      wr.run_started_at::text, wr.append_only
+    FROM benchmark_results br
+    JOIN configs c ON c.id = br.config_id
+    JOIN latest_workflow_runs wr ON wr.id = br.workflow_run_id
+    WHERE br.error IS NULL AND (c.model = ANY(${models}) OR wr.github_run_id = ${source.runId})`;
+  const stored = rows.map((row): CurvePoint => ({
+    identity: row,
+    image: row.image as string | null,
+    workflowRunId: Number(row.workflow_run_id),
+    githubRunId: Number(row.github_run_id),
+    runAttempt: Number(row.run_attempt),
+    date: String(row.point_date),
+    runStartedAt: row.run_started_at as string | null,
+    appendOnly: Boolean(row.append_only),
+  }));
+  const attempts =
+    await sql`SELECT id, run_attempt FROM workflow_runs WHERE github_run_id = ${source.runId}`;
+  const sameAttempt = attempts.find((row) => Number(row.run_attempt) === source.runAttempt);
+  // New serial IDs sort after stored IDs. A concurrent ingest is outside this pure preflight boundary.
+  const workflowRunId = sameAttempt ? Number(sameAttempt.id) : Number.MAX_SAFE_INTEGER;
+  const newPoints = [...incoming.values()].map((point): CurvePoint => ({
+    identity: benchmarkPublicationIdentity(point),
+    image: point.image,
+    workflowRunId,
+    githubRunId: source.runId,
+    runAttempt: source.runAttempt,
+    date:
+      stored.find(
+        (existing) =>
+          existing.workflowRunId === workflowRunId &&
+          stablePowerPointIdentity(existing.identity) ===
+            stablePowerPointIdentity(benchmarkPublicationIdentity(point)),
+      )?.date ?? options.date,
+    runStartedAt: options.runStartedAt,
+    appendOnly: options.appendOnly,
+  }));
+  const touched = new Set(
+    [...newPoints, ...stored.filter((point) => point.githubRunId === source.runId)].map(scope),
+  );
+  const existing = stored.filter((point) => touched.has(scope(point)));
+  const maxAttempt = Math.max(source.runAttempt, ...attempts.map((row) => Number(row.run_attempt)));
+  const changedIds = new Set(newPoints.map((point) => stablePowerPointIdentity(point.identity)));
+  const proposed = existing
+    .filter(
+      (point) =>
+        point.githubRunId !== source.runId ||
+        (point.runAttempt === maxAttempt &&
+          (source.runAttempt !== maxAttempt ||
+            !changedIds.has(stablePowerPointIdentity(point.identity)))),
+    )
+    .map((point) =>
+      point.githubRunId === source.runId && point.runAttempt === source.runAttempt
+        ? { ...point, runStartedAt: options.runStartedAt, appendOnly: options.appendOnly }
+        : point,
+    );
+  if (source.runAttempt === maxAttempt) proposed.push(...newPoints);
+  assertCurvePreserved(existing, proposed, manifest.publication);
+}
diff --git a/packages/db/src/etl/required-power-publication.test.ts b/packages/db/src/etl/required-power-publication.test.ts
index b51b8e526..7ad044559 100644
--- a/packages/db/src/etl/required-power-publication.test.ts
+++ b/packages/db/src/etl/required-power-publication.test.ts
@@ -1,314 +1,322 @@
+import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
-import agenticMatrix from './__fixtures__/required-power-agentic-matrix.json';
 import {
   assertRequiredPowerPointsRetained,
   verifyRequiredPowerArtifacts,
-  verifyRequiredPowerPublication,
 } from './required-power-publication';
-import {
-  isBenchmarkPointPurged,
-  PURGED_BENCHMARK_POINTS,
-  type PurgedBenchmarkPoint,
-} from './run-overrides';
 
-// Ordinary planner output for Qwen3.5/H100 8K1K; fingerprints include the full recipe.
-const fingerprint = 'fa0645b4dec181eafda7472c891e90d9a5bf7bad7ee764aa0fdcc41ff841adf1';
-const source = { runId: 123, runAttempt: 2, headSha: 'abc123' };
-const required = {
-  'recipe-fingerprint': fingerprint,
-  conc: 1,
-  isl: 8192,
-  osl: 1024,
-  'require-power': true,
-};
-const row = {
-  infmax_model_prefix: 'qwen3.5',
-  hw: 'h100',
-  framework: 'sglang',
-  precision: 'fp8',
-  recipe_fingerprint: fingerprint,
-  conc: 1,
-  isl: 8192,
-  osl: 1024,
-  tp: 8,
-  ep: 1,
-  power_valid: 1,
-  power_metric_schema_version: 2,
-  avg_power_w: 500,
-  avg_total_gpu_power_w: 4000,
-  total_gpu_energy_j: 8000,
-  joules_per_output_token: 2,
-};
-const manifest = (entries = [required]) => ({
-  head: source.headSha,
-  'run-id': source.runId,
-  'run-attempt': source.runAttempt,
-  // full-sweep is a Klaud policy field: fail-fast runs may legitimately set it false.
-  'full-sweep': false,
-  matrix: {
-    single_node: { '8k1k': entries },
-    multi_node: {},
-    evals: [{ ...required, 'eval-only': true }],
-  },
-});
-const artifacts = (rows: unknown[] = [row]) => [{ path: 'bmk_qwen/agg.json', rows }];
+const golden = path.resolve(
+  import.meta.dirname,
+  '../../../../docs/fixtures/powerx-manifest-v2/artifacts',
+);
+const source = { runId: 123, runAttempt: 1, headSha: 'b'.repeat(40) };
 const dirs: string[] = [];
+function fixture() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-contract-'));
+  dirs.push(dir);
+  fs.cpSync(golden, dir, { recursive: true });
+  return dir;
+}
+function json(dir: string, file: string): any {
+  return JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+}
+function write(dir: string, file: string, value: unknown) {
+  fs.writeFileSync(path.join(dir, file), JSON.stringify(value));
+}
+const manifestPath = 'required-power-sweep-manifest/sweep_manifest.json';
+const benchmarkPath = 'bmk_agentic_golden/agg.json';
+const auditPath = 'agentic_golden/power_validation.json';
+function changeManifest(dir: string, edit: (manifest: any) => void) {
+  const manifest = json(dir, manifestPath);
+  edit(manifest);
+  write(dir, manifestPath, manifest);
+}
+function changeArtifact(dir: string, file: string, edit: (value: any) => void) {
+  const value = json(dir, file);
+  edit(value);
+  write(dir, file, value);
+  changeManifest(dir, (manifest) => {
+    for (const point of manifest.points)
+      for (const artifact of point.artifacts)
+        if (artifact.path === file)
+          artifact.sha256 = createHash('sha256')
+            .update(fs.readFileSync(path.join(dir, file)))
+            .digest('hex');
+  });
+}
+function multinodeFixture() {
+  const dir = fixture();
+  const extras: Record<string, unknown> = {
+    'power_audit_golden/power/samples.csv':
+      'timestamp_unix,hostname,gpu_uuid,power_w\n1700000000,prefill,GPU-p,200\n',
+    'power_audit_golden/power/manifest.json': { status: 'complete', publication_valid: true },
+    'power_audit_golden/power/windows/point.json': {
+      benchmark_start_time_unix: 1700000000,
+      benchmark_end_time_unix: 1700000002,
+    },
+  };
+  for (const [file, value] of Object.entries(extras)) {
+    fs.mkdirSync(path.dirname(path.join(dir, file)), { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, file),
+      typeof value === 'string' ? value : JSON.stringify(value),
+    );
+  }
+  changeArtifact(dir, benchmarkPath, (row) =>
+    Object.assign(row, {
+      disagg: true,
+      is_multinode: true,
+      num_gpus: 2,
+      num_prefill_gpu: 1,
+      num_decode_gpu: 1,
+      prefill_gpu_energy_j: 400,
+      decode_gpu_energy_j: 600,
+      prefill_joules_per_input_token: 1,
+      decode_joules_per_output_token: 1,
+    }),
+  );
+  changeArtifact(dir, auditPath, (audit) =>
+    Object.assign(audit, {
+      expected_gpu_count: 2,
+      observed_gpu_count: 2,
+      per_gpu_energy_j: { 'prefill/GPU-p': 400, 'decode/GPU-d': 600 },
+      per_gpu_role: { 'prefill/GPU-p': 'prefill', 'decode/GPU-d': 'decode' },
+    }),
+  );
+  changeManifest(dir, (manifest) => {
+    const entry = manifest.matrix.single_node.agentic[0];
+    Object.assign(entry, { disagg: true, 'num-gpus': 2, 'node-count': 2 });
+    manifest.matrix = { single_node: {}, multi_node: { agentic: [entry] } };
+    const point = manifest.points[0];
+    Object.assign(point.topology, {
+      disagg: true,
+      is_multinode: true,
+      num_gpus: 2,
+      num_prefill_gpu: 1,
+      num_decode_gpu: 1,
+    });
+    point.devices = [
+      { node: 'prefill', gpu_uuid: 'GPU-p', role: 'prefill', energy_j: 400 },
+      { node: 'decode', gpu_uuid: 'GPU-d', role: 'decode', energy_j: 600 },
+    ];
+    for (const file of Object.keys(extras))
+      point.artifacts.push({
+        path: file,
+        sha256: createHash('sha256')
+          .update(fs.readFileSync(path.join(dir, file)))
+          .digest('hex'),
+        validation_state: 'valid',
+      });
+  });
+  return dir;
+}
 afterEach(() => {
   for (const dir of dirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
 });
 
-describe('required power publication preflight', () => {
-  it('matches the canonical AgentX users value instead of a conflicting raw conc', () => {
-    const scope = {
-      ...manifest(),
-      matrix: { single_node: { agentic: [required] }, multi_node: {} },
-    };
-    const conflicting = { ...row, scenario_type: 'agentic-coding', conc: 1, users: 2 };
-    expect(() => verifyRequiredPowerPublication(scope, artifacts([conflicting]), source)).toThrow(
-      'missing benchmark point',
+describe('required power publication contract', () => {
+  it('accepts the shared producer golden fixture and an earlier declared attempt of the same head', () => {
+    expect(verifyRequiredPowerArtifacts(golden, source, true)).toMatchObject([
+      { conc: 1, benchmarkType: 'agentic_traces', metrics: { total_gpu_energy_j: 1000 } },
+    ]);
+    expect(verifyRequiredPowerArtifacts(golden, { ...source, runAttempt: 2 }, true)).toHaveLength(
+      1,
     );
-    expect(
-      verifyRequiredPowerPublication(
-        scope,
-        artifacts([{ ...conflicting, conc: 2, users: 1 }]),
-        source,
-      ),
-    ).toHaveLength(1);
   });
-
-  it('accepts exact ordinary source points, including fail-fast manifests and identical aggregate copies', () => {
-    expect(
-      verifyRequiredPowerPublication(
-        manifest(),
-        [...artifacts(), { path: 'results_bmk/agg_bmk.json', rows: [{ ...row }] }],
-        source,
-      ),
-    ).toHaveLength(1);
+  it('fails missing required manifests even when changelog metadata is also missing', () => {
+    const dir = fixture();
+    fs.rmSync(path.join(dir, 'required-power-sweep-manifest'), { recursive: true });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('sweep manifest missing');
+    fs.rmSync(path.join(dir, 'changelog-metadata'), { recursive: true });
+    expect(() => verifyRequiredPowerArtifacts(dir, source, true)).toThrow('sweep manifest missing');
+    expect(verifyRequiredPowerArtifacts(dir, source)).toEqual([]);
   });
-
-  it('fails required coverage after a point purge even when an optional point is retained', () => {
-    const requiredPoints = verifyRequiredPowerPublication(manifest(), artifacts(), source);
-    const candidates = [requiredPoints[0], { ...requiredPoints[0], conc: 2 }];
-    const purged: PurgedBenchmarkPoint = {
-      githubRunId: source.runId,
-      runAttempt: source.runAttempt,
-      configId: 999999,
-      benchmarkType: 'single_turn',
-      isl: 8192,
-      osl: 1024,
-      conc: 1,
-      offloadMode: 'off',
-      recipeFingerprint: fingerprint,
-    };
-    const registry = PURGED_BENCHMARK_POINTS as PurgedBenchmarkPoint[];
-    registry.push(purged);
-    try {
-      const retained = candidates.filter(
-        (point) =>
-          !isBenchmarkPointPurged(source.runId, source.runAttempt, {
-            ...point,
-            configId: purged.configId,
-          }),
-      );
-      expect(retained.map((point) => point.conc)).toEqual([2]);
-      expect(() => assertRequiredPowerPointsRetained(requiredPoints, retained)).toThrow(
-        'missing benchmark point after ingest',
-      );
-      expect(isBenchmarkPointPurged(source.runId, source.runAttempt, purged)).toBe(true);
-      expect(() => assertRequiredPowerPointsRetained([], retained)).not.toThrow();
-    } finally {
-      registry.splice(registry.indexOf(purged), 1);
-    }
+  it.each([undefined, 1, 3, '2'])(
+    'rejects missing or incompatible manifest version %s',
+    (version) => {
+      const dir = fixture();
+      changeManifest(dir, (manifest) => {
+        manifest['schema-version'] = version;
+      });
+      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('schema-version');
+    },
+  );
+  it.each(['agentic_golden/gpu_metrics.csv', auditPath, benchmarkPath])(
+    'rejects missing required artifact %s',
+    (file) => {
+      const dir = fixture();
+      fs.unlinkSync(path.join(dir, file));
+      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing required artifact');
+    },
+  );
+  it('rejects hash mismatches and explicit invalid evidence', () => {
+    const dir = fixture();
+    fs.appendFileSync(path.join(dir, 'agentic_golden/gpu_metrics.csv'), '\n');
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('hash');
+    const invalid = fixture();
+    changeManifest(invalid, (manifest) => {
+      manifest.points[0].artifacts[0].validation_state = 'invalid';
+    });
+    expect(() => verifyRequiredPowerArtifacts(invalid, source)).toThrow('validation');
   });
-
-  it('accepts retained aggregate copies but cannot replace a filtered required point with another identity', () => {
-    const requiredPoints = verifyRequiredPowerPublication(manifest(), artifacts(), source);
-    expect(() =>
-      assertRequiredPowerPointsRetained(requiredPoints, [
-        requiredPoints[0],
-        { ...requiredPoints[0] },
-      ]),
-    ).not.toThrow();
-    expect(() =>
-      assertRequiredPowerPointsRetained(requiredPoints, [
-        { ...requiredPoints[0], recipeFingerprint: 'other-recipe' },
-      ]),
-    ).toThrow('missing benchmark point after ingest');
+  it.each([undefined, null, 0, -1, '1000'])(
+    'rejects missing, invalid and measured nonpositive energy separately: %s',
+    (energy) => {
+      const dir = fixture();
+      changeArtifact(dir, benchmarkPath, (rows) => {
+        rows.total_gpu_energy_j = energy;
+      });
+      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow(
+        'total_gpu_energy_j must be finite and positive',
+      );
+    },
+  );
+  it('does not replace canonical AgentX users with a conflicting raw conc', () => {
+    const dir = fixture();
+    changeArtifact(dir, benchmarkPath, (rows) => {
+      rows.conc = 1;
+      rows.users = 2;
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing benchmark point');
   });
-
-  it('fails before ingestion when any declared concurrency, fingerprint or scenario is missing', () => {
-    for (const candidate of [
-      [],
-      [{ ...row, conc: 2 }],
-      [{ ...row, recipe_fingerprint: '' }],
-      [{ ...row, isl: 1024 }],
+  it.each(['model', 'hardware', 'framework', 'precision'])(
+    'rejects substituted %s identity',
+    (field) => {
+      const dir = fixture();
+      changeManifest(dir, (manifest) => {
+        manifest.points[0].identity[field] = 'other';
+      });
+      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow(`${field} identity differs`);
+    },
+  );
+  it('rejects absent physical GPU, duplicate physical GPU, and changed measurement boundaries', () => {
+    for (const edit of [
+      (point: any) => {
+        point.devices = [];
+      },
+      (point: any) => {
+        point.devices[0].gpu_uuid = '0';
+      },
+      (point: any) => {
+        point.measurement_window.end_time_unix += 1;
+      },
     ]) {
-      expect(() =>
-        verifyRequiredPowerPublication(manifest(), artifacts(candidate), source),
-      ).toThrow('missing benchmark point');
+      const dir = fixture();
+      changeManifest(dir, (manifest) => edit(manifest.points[0]));
+      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('Required power:');
     }
   });
-
-  it('does not retroactively require optional matrix points or legacy results', () => {
-    const scope = manifest([required, { ...required, conc: 2, 'require-power': false }]);
-    expect(
-      verifyRequiredPowerPublication(scope, artifacts([row, { conc: 2, power_valid: 0 }]), source),
-    ).toHaveLength(1);
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'required-power-'));
-    dirs.push(dir);
-    expect(verifyRequiredPowerArtifacts(dir, { ...source, headSha: null })).toHaveLength(0);
+  it('requires both prefill and decode physical evidence and matching role energy', () => {
+    const dir = multinodeFixture();
+    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
+    changeManifest(dir, (manifest) => {
+      manifest.points[0].devices.pop();
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing physical GPU');
+    const mismatched = multinodeFixture();
+    changeArtifact(mismatched, benchmarkPath, (row) => {
+      row.prefill_gpu_energy_j = 100;
+    });
+    expect(() => verifyRequiredPowerArtifacts(mismatched, source)).toThrow(
+      'prefill energy differs',
+    );
   });
-
-  it.each([
-    { power_valid: 0 },
-    { power_valid: '1' },
-    { power_metric_schema_version: '2' },
-    { avg_power_w: 0 },
-    { avg_total_gpu_power_w: -1 },
-    { total_gpu_energy_j: NaN },
-    { joules_per_output_token: Infinity },
-    { joules_per_output_token: undefined },
-    { benchmark_outcome: { status: 'failed' } },
-  ])('rejects invalid required measurements: %j', (change) => {
-    expect(() =>
-      verifyRequiredPowerPublication(manifest(), artifacts([{ ...row, ...change }]), source),
-    ).toThrow('Required power:');
+  it('normalizes producer dp-attn strings and binds nested planned role topology', () => {
+    const dir = fixture();
+    changeArtifact(dir, benchmarkPath, (row) => {
+      row.dp_attention = 'false';
+    });
+    changeManifest(dir, (manifest) => {
+      manifest.points[0].topology.dp_attention = 'false';
+      manifest.matrix.single_node.agentic[0]['dp-attn'] = false;
+    });
+    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
+    const split = multinodeFixture();
+    changeManifest(split, (manifest) => {
+      manifest.matrix.multi_node.agentic[0].prefill = { tp: 8, 'num-worker': 1 };
+    });
+    expect(() => verifyRequiredPowerArtifacts(split, source)).toThrow(
+      'prefill_tp topology differs from required matrix',
+    );
   });
-
-  it('rejects conflicting copies and duplicate rows inside either source or aggregate file', () => {
-    expect(() =>
-      verifyRequiredPowerPublication(
-        manifest(),
-        [...artifacts(), { path: 'results_bmk/agg.json', rows: [{ ...row, avg_power_w: 501 }] }],
-        source,
-      ),
-    ).toThrow('conflicting');
-    expect(() => verifyRequiredPowerPublication(manifest(), artifacts([row, row]), source)).toThrow(
-      'duplicate',
+  it('supports fixed-window sidecar names and AMD physical UUID artifacts', () => {
+    const dir = fixture();
+    fs.renameSync(
+      path.join(dir, auditPath),
+      path.join(dir, 'agentic_golden/power_validation_conc1.json'),
     );
-    expect(() =>
-      verifyRequiredPowerPublication(
-        manifest(),
-        [...artifacts(), { path: 'results_bmk/agg.json', rows: [row, row] }],
-        source,
-      ),
-    ).toThrow('duplicate');
+    fs.unlinkSync(path.join(dir, 'agentic_golden/gpu_metrics_identity.csv'));
+    const amdPath = 'agentic_golden/gpu_metrics_devices.json';
+    write(dir, amdPath, { devices: [{ gpu: 0, uuid: 'amd-physical-uuid' }] });
+    changeManifest(dir, (manifest) => {
+      const point = manifest.points[0];
+      point.devices[0].gpu_uuid = 'amd-physical-uuid';
+      point.artifacts = point.artifacts.filter(
+        (artifact: any) => !artifact.path.endsWith('gpu_metrics_identity.csv'),
+      );
+      point.artifacts.find((artifact: any) => artifact.path === auditPath).path =
+        'agentic_golden/power_validation_conc1.json';
+      point.artifacts.push({
+        path: amdPath,
+        sha256: createHash('sha256')
+          .update(fs.readFileSync(path.join(dir, amdPath)))
+          .digest('hex'),
+        validation_state: 'valid',
+      });
+    });
+    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
   });
-
-  it('rejects stale source run, attempt or head, an empty scope, and duplicate planned points', () => {
-    for (const changed of [
-      { runId: 999 },
-      { runAttempt: 1 },
-      { headSha: 'stale' },
-      { headSha: null },
-    ])
-      expect(() =>
-        verifyRequiredPowerPublication(manifest(), artifacts(), { ...source, ...changed }),
-      ).toThrow('manifest source');
-    expect(() => verifyRequiredPowerPublication(manifest([]), [], source)).toThrow('no required');
-    expect(() =>
-      verifyRequiredPowerPublication(manifest([required, required]), artifacts(), source),
-    ).toThrow('duplicate matrix');
+  it('rejects invalid sidecar verdict and device energy disagreement despite valid hashes', () => {
+    const dir = fixture();
+    changeArtifact(dir, auditPath, (audit) => {
+      audit.power_valid = false;
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('invalid audit');
+    const other = fixture();
+    changeManifest(other, (manifest) => {
+      manifest.points[0].devices[0].energy_j = 2;
+    });
+    expect(() => verifyRequiredPowerArtifacts(other, source)).toThrow('differs from audit');
   });
-
-  it('reuses the declared scope from a successful earlier attempt of the same run and head', () => {
-    expect(
-      verifyRequiredPowerPublication({ ...manifest(), 'run-attempt': 1 }, artifacts(), source),
-    ).toHaveLength(1);
+  it('rejects duplicate points, required matrix omissions, wrong source, and paths outside the artifact root', () => {
+    const edits = [
+      (manifest: any) => {
+        manifest.points.push(manifest.points[0]);
+      },
+      (manifest: any) => {
+        manifest.matrix.single_node.agentic[0].conc = [1, 2];
+      },
+      (manifest: any) => {
+        manifest['run-id'] = 999;
+      },
+      (manifest: any) => {
+        manifest.points[0].artifacts[0].path = '../secret';
+      },
+    ];
+    for (const edit of edits) {
+      const dir = fixture();
+      changeManifest(dir, edit);
+      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('Required power:');
+    }
   });
-
-  it('expands real ordinary AgentX planner concurrency arrays and fixed-sequence batches', () => {
-    // First B200 recipe from the ordinary Kimi K3 required-power planner, 2026-09-13.
-    const entry = agenticMatrix.multi_node.agentic[0];
-    expect(
-      verifyRequiredPowerPublication(
-        { ...manifest(), matrix: agenticMatrix },
-        artifacts([
-          {
-            ...row,
-            infmax_model_prefix: 'kimik3',
-            hw: 'b200',
-            framework: 'dynamo-vllm',
-            precision: 'fp4',
-            recipe_fingerprint: entry['recipe-fingerprint'],
-            conc: entry.conc[0],
-            scenario_type: 'agentic-coding',
-          },
-        ]),
-        source,
-      ),
-    ).toHaveLength(1);
-    const fixedMatrix = {
-      single_node: {},
-      multi_node: { '8k1k': [{ ...required, conc: [1, 2, 4] }] },
-    };
-    expect(
-      verifyRequiredPowerPublication(
-        { ...manifest(), matrix: fixedMatrix },
-        artifacts([1, 2, 4].map((conc) => ({ ...row, conc }))),
-        source,
-      ),
-    ).toHaveLength(3);
-    expect(() =>
-      verifyRequiredPowerPublication({ ...manifest(), matrix: fixedMatrix }, artifacts(), source),
-    ).toThrow('missing benchmark');
+  it('accepts identical aggregate copies but rejects conflicting duplicate rows', () => {
+    const dir = fixture();
+    fs.mkdirSync(path.join(dir, 'results_bmk'));
+    fs.copyFileSync(path.join(dir, benchmarkPath), path.join(dir, 'results_bmk/agg.json'));
+    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
+    const rows = json(dir, benchmarkPath);
+    rows.avg_power_w = 501;
+    write(dir, 'results_bmk/agg.json', rows);
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('conflicting');
   });
-
-  it('accepts AgentX and requires both energy roles only for a declared disaggregated recipe', () => {
-    const scope = manifest();
-    const agentic = { ...required, 'scenario-type': 'agentic-coding', disagg: true };
-    const agenticManifest = {
-      ...scope,
-      matrix: { single_node: {}, multi_node: { agentic: [agentic] } },
-    };
-    const split = {
-      ...row,
-      isl: undefined,
-      osl: undefined,
-      scenario_type: 'agentic-coding',
-      disagg: true,
-      prefill_gpu_energy_j: 3000,
-      decode_gpu_energy_j: 5000,
-      prefill_joules_per_input_token: 1,
-      decode_joules_per_output_token: 1.25,
-    };
-    expect(
-      verifyRequiredPowerPublication(agenticManifest, artifacts([split]), source),
-    ).toHaveLength(1);
+  it('retains every required identity after local purges and backfills', () => {
+    const required = verifyRequiredPowerArtifacts(golden, source);
     expect(() =>
-      verifyRequiredPowerPublication(
-        agenticManifest,
-        artifacts([{ ...split, decode_gpu_energy_j: undefined }]),
-        source,
-      ),
-    ).toThrow('decode_gpu_energy_j');
-    const aggregate = {
-      ...agenticManifest,
-      matrix: { single_node: {}, multi_node: { agentic: [{ ...agentic, disagg: false }] } },
-    };
-    expect(
-      verifyRequiredPowerPublication(
-        aggregate,
-        artifacts([{ ...row, scenario_type: 'agentic-coding' }]),
-        source,
-      ),
-    ).toHaveLength(1);
-  });
-
-  it('reads the producer artifact and checks all rows before the ingest entry point writes', () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'required-power-'));
-    dirs.push(dir);
-    fs.mkdirSync(path.join(dir, 'required-power-sweep-manifest'));
-    fs.writeFileSync(
-      path.join(dir, 'required-power-sweep-manifest', 'sweep_manifest.json'),
-      JSON.stringify(manifest()),
-    );
-    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing benchmark');
-    fs.mkdirSync(path.join(dir, 'bmk_qwen'));
-    fs.writeFileSync(path.join(dir, 'bmk_qwen', 'agg.json'), JSON.stringify(row));
-    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
+      assertRequiredPowerPointsRetained(required, [{ ...required[0], conc: 2 }]),
+    ).toThrow('missing benchmark point');
+    expect(() => assertRequiredPowerPointsRetained(required, required)).not.toThrow();
   });
 });
diff --git a/packages/db/src/etl/required-power-publication.ts b/packages/db/src/etl/required-power-publication.ts
index 170b3e926..d8f995b8a 100644
--- a/packages/db/src/etl/required-power-publication.ts
+++ b/packages/db/src/etl/required-power-publication.ts
@@ -1,9 +1,11 @@
 import fs from 'node:fs';
+import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { mapBenchmarkRow, type BenchmarkParams } from './benchmark-mapper';
 import { createSkipTracker } from './skip-tracker';
-import { REQUIRED_POWER_MANIFEST } from '../lib/ci-artifact-preparation';
+import { configCacheKey } from './config-cache';
+import { CHANGELOG_ARTIFACT_NAME, REQUIRED_POWER_MANIFEST } from '../lib/ci-artifact-preparation';
 
 type JsonRow = Record<string, unknown>;
 export interface RequiredPowerSource {
@@ -14,6 +16,7 @@ export interface RequiredPowerSource {
 export interface BenchmarkArtifactRows {
   path: string;
   rows: unknown[];
+  contents?: Buffer | string;
 }
 
 function object(value: unknown, label: string): JsonRow {
@@ -45,11 +48,24 @@ export function assertRequiredPowerPointsRetained(
   required: readonly BenchmarkParams[],
   retained: readonly BenchmarkParams[],
 ): void {
-  const present = new Set(retained.map(mappedIdentity));
+  const retainedIdentity = (row: BenchmarkParams) =>
+    JSON.stringify([configCacheKey(row.config), row.offloadMode, mappedIdentity(row)]);
+  const present = new Map(retained.map((row) => [retainedIdentity(row), row]));
   for (const row of required) {
-    const key = mappedIdentity(row);
+    const key = retainedIdentity(row);
     if (!present.has(key))
       throw new Error(`Required power: missing benchmark point after ingest ${key}`);
+    const actual = present.get(key)!;
+    for (const field of [
+      'power_valid',
+      'power_metric_schema_version',
+      'avg_power_w',
+      'avg_total_gpu_power_w',
+      'total_gpu_energy_j',
+      'joules_per_output_token',
+    ])
+      if (actual.metrics[field] !== row.metrics[field])
+        throw new Error(`Required power: ${field} changed before ingest for ${key}`);
   }
 }
 
@@ -60,20 +76,52 @@ export function verifyRequiredPowerPublication(
   source: RequiredPowerSource,
 ): BenchmarkParams[] {
   const manifest = object(manifestValue, 'sweep manifest');
+  if (manifest['schema-version'] !== 2)
+    throw new Error('Required power: incompatible manifest schema-version (expected 2)');
+  const publication = object(manifest.publication, 'publication policy');
+  if (
+    !['incremental', 'replacement'].includes(String(publication.mode)) ||
+    !Array.isArray(publication.replacement_scope) ||
+    (publication.mode === 'incremental' && publication.replacement_scope.length > 0)
+  )
+    throw new Error('Required power: invalid publication policy');
+  const replacementScopes = new Set<string>();
+  for (const value of publication.replacement_scope) {
+    const replacement = object(value, 'exact replacement scope');
+    if (
+      typeof replacement.curve_scope !== 'string' ||
+      !replacement.curve_scope ||
+      replacementScopes.has(replacement.curve_scope) ||
+      !Number.isSafeInteger(replacement.previous_snapshot_workflow_run_id) ||
+      Number(replacement.previous_snapshot_workflow_run_id) <= 0 ||
+      !Array.isArray(replacement.removed_point_identities) ||
+      replacement.removed_point_identities.length === 0 ||
+      replacement.removed_point_identities.some((id) => typeof id !== 'string' || !id) ||
+      new Set(replacement.removed_point_identities).size !==
+        replacement.removed_point_identities.length
+    )
+      throw new Error('Required power: invalid exact replacement scope');
+    replacementScopes.add(replacement.curve_scope);
+  }
   const declaredAttempt = manifest['run-attempt'];
   if (
     manifest['run-id'] !== source.runId ||
+    !Number.isSafeInteger(source.runId) ||
+    source.runId <= 0 ||
+    !Number.isSafeInteger(source.runAttempt) ||
+    source.runAttempt <= 0 ||
     typeof declaredAttempt !== 'number' ||
     !Number.isSafeInteger(declaredAttempt) ||
     declaredAttempt <= 0 ||
     declaredAttempt > source.runAttempt ||
     !source.headSha ||
+    !/^[a-f0-9]{40}$/u.test(source.headSha) ||
     manifest.head !== source.headSha
   )
     throw new Error('Required power: manifest source run, attempt or head does not match');
 
   const matrix = object(manifest.matrix, 'sweep matrix');
-  const expected = new Map<string, boolean>();
+  const expected = new Map<string, JsonRow>();
   for (const topology of ['single_node', 'multi_node']) {
     const buckets = object(matrix[topology], topology);
     for (const [scenario, entries] of Object.entries(buckets)) {
@@ -99,7 +147,7 @@ export function verifyRequiredPowerPublication(
             osl,
           );
           if (expected.has(key)) throw new Error(`Required power: duplicate matrix point ${key}`);
-          expected.set(key, row.disagg === true);
+          expected.set(key, { ...row, matrixTopology: topology });
         }
       }
     }
@@ -140,7 +188,7 @@ export function verifyRequiredPowerPublication(
         'total_gpu_energy_j',
         'joules_per_output_token',
       ];
-      if (expected.get(key))
+      if (expected.get(key)?.disagg === true)
         fields.push(
           'prefill_gpu_energy_j',
           'decode_gpu_energy_j',
@@ -158,6 +206,7 @@ export function verifyRequiredPowerPublication(
   for (const key of expected.keys()) {
     if (!seen.has(key)) throw new Error(`Required power: missing benchmark point ${key}`);
   }
+  verifyPointEvidence(manifest, expected, seen, artifacts);
   return [...seen.values()].map(({ point }) => point);
 }
 
@@ -165,9 +214,21 @@ export function verifyRequiredPowerPublication(
 export function verifyRequiredPowerArtifacts(
   root: string,
   source: RequiredPowerSource,
+  required = false,
 ): BenchmarkParams[] {
   const manifestDir = path.join(root, REQUIRED_POWER_MANIFEST);
-  if (!fs.existsSync(manifestDir)) return [];
+  if (!fs.existsSync(manifestDir)) {
+    if (required) throw new Error('Required power: sweep manifest missing for required dispatch');
+    const metadataDir = path.join(root, CHANGELOG_ARTIFACT_NAME);
+    if (fs.existsSync(metadataDir)) {
+      for (const name of fs.readdirSync(metadataDir).filter((file) => file.endsWith('.json'))) {
+        const metadata = JSON.parse(fs.readFileSync(path.join(metadataDir, name), 'utf8'));
+        if (metadata?.['require-power'] === true)
+          throw new Error('Required power: sweep manifest missing for required changelog scope');
+      }
+    }
+    return [];
+  }
   const manifest = JSON.parse(
     fs.readFileSync(path.join(manifestDir, 'sweep_manifest.json'), 'utf8'),
   );
@@ -178,8 +239,28 @@ export function verifyRequiredPowerArtifacts(
     if (!fs.statSync(dir).isDirectory()) continue;
     for (const file of fs.readdirSync(dir)) {
       if (!file.endsWith('.json')) continue;
-      const data = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
-      artifacts.push({ path: path.join(name, file), rows: Array.isArray(data) ? data : [data] });
+      const contents = fs.readFileSync(path.join(dir, file));
+      const data = JSON.parse(contents.toString('utf8'));
+      artifacts.push({
+        path: path.join(name, file),
+        rows: Array.isArray(data) ? data : [data],
+        contents,
+      });
+    }
+  }
+  for (const pointValue of Array.isArray(manifest.points) ? manifest.points : []) {
+    const point = object(pointValue, 'point');
+    if (!Array.isArray(point.artifacts)) throw new Error('Required power: missing point artifacts');
+    for (const value of point.artifacts) {
+      const artifact = object(value, 'artifact');
+      const relative = safeArtifactPath(artifact.path);
+      const file = path.join(root, relative);
+      if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+        throw new Error(`Required power: missing required artifact ${relative}`);
+      if (!fs.realpathSync(file).startsWith(`${fs.realpathSync(root)}${path.sep}`))
+        throw new Error(`Required power: artifact escapes bundle ${relative}`);
+      if (!artifacts.some((item) => item.path === relative))
+        artifacts.push({ path: relative, rows: [], contents: fs.readFileSync(file) });
     }
   }
   const points = verifyRequiredPowerPublication(manifest, artifacts, source);
@@ -189,3 +270,424 @@ export function verifyRequiredPowerArtifacts(
   );
   return points;
 }
+
+function digest(artifact: BenchmarkArtifactRows): string {
+  return createHash('sha256').update(artifact.contents!).digest('hex');
+}
+
+function safeArtifactPath(value: unknown): string {
+  if (
+    typeof value !== 'string' ||
+    !value ||
+    value.includes('\\') ||
+    path.posix.isAbsolute(value) ||
+    value.split('/').some((part) => !part || part === '.' || part === '..')
+  )
+    throw new Error('Required power: invalid artifact path');
+  return value;
+}
+
+function positive(value: unknown, label: string): number {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+    throw new Error(`Required power: ${label} must be finite and positive`);
+  return value;
+}
+
+function nonempty(value: unknown, label: string): string {
+  if (typeof value !== 'string' || !value.trim())
+    throw new Error(`Required power: missing ${label}`);
+  return value;
+}
+
+function verifyPointEvidence(
+  manifest: JsonRow,
+  expected: Map<string, JsonRow>,
+  seen: Map<string, { row: JsonRow; path: string; point: BenchmarkParams }>,
+  artifacts: readonly BenchmarkArtifactRows[],
+): void {
+  if (!Array.isArray(manifest.points) || manifest.points.length !== expected.size)
+    throw new Error('Required power: point manifest does not cover the exact required matrix');
+  const verified = new Set<string>();
+  const files = new Map(artifacts.map((artifact) => [artifact.path, artifact]));
+  for (const declaredValue of manifest.points) {
+    const declared = object(declaredValue, 'point');
+    const id = object(declared.identity, 'point identity');
+    const key = identity(
+      id.recipe_fingerprint,
+      id.concurrency,
+      String(id.benchmark_type),
+      id.isl,
+      id.osl,
+    );
+    const matched = seen.get(key);
+    const matrix = expected.get(key);
+    if (!matched || !matrix || verified.has(key))
+      throw new Error(`Required power: unexpected or duplicate manifest point ${key}`);
+    verified.add(key);
+    if (nonempty(declared.config_key, 'config_key') !== matrix['exp-name'])
+      throw new Error(`Required power: config_key differs from required matrix for ${key}`);
+    const { row, point } = matched;
+    for (const [field, rawField] of [
+      ['model', 'infmax_model_prefix'],
+      ['hardware', 'hw'],
+      ['framework', 'framework'],
+      ['precision', 'precision'],
+    ]) {
+      if (
+        nonempty(id[field], field) !==
+        (row[rawField] ?? (field === 'model' ? row.model : undefined))
+      )
+        throw new Error(`Required power: ${field} identity differs from benchmark for ${key}`);
+    }
+    for (const [field, matrixField] of [
+      ['model', 'model-prefix'],
+      ['hardware', 'runner'],
+      ['framework', 'framework'],
+      ['precision', 'precision'],
+    ]) {
+      if (id[field] !== matrix[matrixField])
+        throw new Error(
+          `Required power: ${field} identity differs from required matrix for ${key}`,
+        );
+    }
+    const topology = object(declared.topology, 'point topology');
+    if (
+      topology.disagg !== point.config.disagg ||
+      topology.is_multinode !== point.config.isMultinode ||
+      topology.disagg !== (matrix.disagg === true) ||
+      topology.is_multinode !== (matrix.matrixTopology === 'multi_node')
+    )
+      throw new Error(`Required power: topology differs from benchmark or matrix for ${key}`);
+    const rawGpuCount =
+      row.num_gpus ??
+      (topology.is_multinode
+        ? Number(row.num_prefill_gpu) + Number(row.num_decode_gpu)
+        : Number(row.tp) * Number(row.pp ?? 1) * Number(row.pcp_size ?? 1));
+    if (topology.num_gpus !== rawGpuCount)
+      throw new Error(`Required power: num_gpus topology differs from benchmark for ${key}`);
+    const topologyFields = [
+      'num_prefill_gpu',
+      'num_decode_gpu',
+      'tp',
+      'ep',
+      'dp_attention',
+      'prefill_tp',
+      'prefill_ep',
+      'prefill_num_workers',
+      'decode_tp',
+      'decode_ep',
+      'decode_num_workers',
+      'pp',
+      'pcp_size',
+      'dcp_size',
+      'prefill_pp',
+      'decode_pp',
+      'prefill_pcp_size',
+      'decode_pcp_size',
+      'prefill_dcp_size',
+      'decode_dcp_size',
+      'prefill_dp_attention',
+      'decode_dp_attention',
+    ];
+    for (const field of topologyFields) {
+      if (topology[field] !== row[field])
+        throw new Error(`Required power: ${field} topology differs from benchmark for ${key}`);
+      const role = field.startsWith('prefill_')
+        ? 'prefill'
+        : field.startsWith('decode_')
+          ? 'decode'
+          : null;
+      const roleField = role ? field.slice(role.length + 1) : field;
+      const matrixField =
+        roleField === 'num_workers'
+          ? 'num-worker'
+          : roleField === 'dp_attention'
+            ? 'dp-attn'
+            : roleField.replaceAll('_', '-');
+      let planned = role
+        ? matrix[role]
+          ? object(matrix[role], `${role} matrix`)[matrixField]
+          : matrix[field.replaceAll('_', '-')]
+        : matrix[matrixField];
+      if (
+        role === 'decode' &&
+        matrix.decode &&
+        object(matrix.decode, 'decode matrix')['num-worker'] === 0 &&
+        ['tp', 'ep', 'pp', 'pcp_size', 'dcp_size'].includes(roleField)
+      )
+        planned = ['tp', 'ep'].includes(roleField) ? 0 : 1;
+      let actual =
+        topology[field] ??
+        (['pp', 'pcp_size', 'dcp_size'].includes(roleField)
+          ? 1
+          : roleField === 'dp_attention'
+            ? false
+            : undefined);
+      if (roleField === 'dp_attention' && typeof actual === 'string') actual = actual === 'true';
+      const normalizedPlanned =
+        roleField === 'dp_attention' && typeof planned === 'string' ? planned === 'true' : planned;
+      if (planned !== undefined && actual !== normalizedPlanned)
+        throw new Error(
+          `Required power: ${field} topology differs from required matrix for ${key}`,
+        );
+    }
+    let plannedGpuCount = matrix['num-gpus'];
+    if (matrix.prefill && matrix.decode) {
+      plannedGpuCount = 0;
+      for (const role of ['prefill', 'decode']) {
+        const planned = object(matrix[role], `${role} matrix`);
+        const count =
+          Number(planned.tp) *
+          Number(planned.pp ?? 1) *
+          Number(planned['pcp-size'] ?? 1) *
+          Number(planned['num-worker']);
+        if (count !== topology[`num_${role}_gpu`])
+          throw new Error(
+            `Required power: ${role} GPU count differs from required matrix for ${key}`,
+          );
+        plannedGpuCount = Number(plannedGpuCount) + count;
+      }
+    } else if (plannedGpuCount === undefined && matrix.tp !== undefined) {
+      plannedGpuCount =
+        Number(matrix.tp) * Number(matrix.pp ?? 1) * Number(matrix['pcp-size'] ?? 1);
+    }
+    if (plannedGpuCount !== undefined && plannedGpuCount !== topology.num_gpus)
+      throw new Error(`Required power: physical GPU count differs from required matrix for ${key}`);
+    const expectedCount = positive(topology.num_gpus, 'topology num_gpus');
+    if (!Number.isSafeInteger(expectedCount))
+      throw new Error('Required power: invalid physical GPU count');
+    const window = object(declared.measurement_window, 'measurement window');
+    const start = positive(window.start_time_unix, 'window start');
+    const end = positive(window.end_time_unix, 'window end');
+    if (end <= start) throw new Error('Required power: invalid measurement window boundaries');
+    if (!Array.isArray(declared.artifacts) || declared.artifacts.length === 0)
+      throw new Error('Required power: missing required artifacts');
+    const evidence = new Map<string, BenchmarkArtifactRows>();
+    for (const value of declared.artifacts) {
+      const artifact = object(value, 'required artifact');
+      const relative = safeArtifactPath(artifact.path);
+      if (evidence.has(relative))
+        throw new Error(`Required power: duplicate required artifact ${relative}`);
+      const file = files.get(relative);
+      if (!file || file.contents === undefined || file.contents.length === 0)
+        throw new Error(`Required power: missing required artifact ${relative}`);
+      if (
+        artifact.validation_state !== 'valid' ||
+        typeof artifact.sha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(artifact.sha256) ||
+        createHash('sha256').update(file.contents).digest('hex') !== artifact.sha256
+      )
+        throw new Error(`Required power: invalid artifact validation or hash ${relative}`);
+      evidence.set(relative, file);
+    }
+    if (
+      ![...evidence.values()].some((file) =>
+        file.rows.some((candidate) => isDeepStrictEqual(candidate, row)),
+      )
+    )
+      throw new Error(`Required power: benchmark artifact is not hash-bound for ${key}`);
+    const byName = (name: string): BenchmarkArtifactRows => {
+      const matches = [...evidence.values()].filter(
+        (file) => path.posix.basename(file.path) === name,
+      );
+      if (matches.length !== 1)
+        throw new Error(`Required power: expected one required ${name} artifact`);
+      return matches[0];
+    };
+    const sidecars = [...evidence.values()].filter((file) =>
+      /^power_validation.*\.json$/u.test(path.posix.basename(file.path)),
+    );
+    if (sidecars.length !== 1)
+      throw new Error('Required power: expected one required power validation artifact');
+    const audit = object(JSON.parse(sidecars[0].contents!.toString()), 'power validation');
+    const auditWindow = object(audit.benchmark_window, 'audit benchmark window');
+    if (
+      audit.power_valid !== true ||
+      auditWindow.start_time_unix !== start ||
+      auditWindow.end_time_unix !== end ||
+      audit.expected_gpu_count !== expectedCount ||
+      audit.observed_gpu_count !== expectedCount
+    )
+      throw new Error(
+        `Required power: invalid audit verdict, window or physical GPU coverage for ${key}`,
+      );
+    if (topology.is_multinode && audit.telemetry_kind === 'native_multinode_smi') {
+      if (!Array.isArray(audit.nodes) || audit.nodes.length === 0)
+        throw new Error('Required power: missing native node receipts');
+      const traces = [...evidence.values()].filter(
+        (file) => path.posix.basename(file.path) === 'gpu_metrics.csv',
+      );
+      if (traces.length !== audit.nodes.length)
+        throw new Error('Required power: missing native node telemetry');
+      for (const file of traces) {
+        const directory = path.posix.dirname(file.path);
+        const manifestFile = evidence.get(`${directory}/manifest.json`);
+        if (!manifestFile) throw new Error('Required power: missing native node manifest');
+        const nodeManifest = object(
+          JSON.parse(manifestFile.contents!.toString()),
+          'native node manifest',
+        );
+        if (nodeManifest.lifecycle !== 'complete' || nodeManifest.collector_exit_code !== 0)
+          throw new Error('Required power: invalid native node collection');
+        const receipt = (audit.nodes as JsonRow[]).find((node) => node.node === nodeManifest.node);
+        if (
+          !receipt ||
+          receipt.manifest_sha256 !== digest(manifestFile) ||
+          receipt.telemetry_sha256 !== digest(file)
+        )
+          throw new Error('Required power: native node receipt differs from evidence');
+        for (const hash of [receipt.identity_sha256, receipt.identity_end_sha256])
+          if (
+            ![...evidence.values()].some(
+              (item) => path.posix.dirname(item.path) === directory && digest(item) === hash,
+            )
+          )
+            throw new Error('Required power: missing native physical identity evidence');
+      }
+    } else if (topology.is_multinode) {
+      byName('samples.csv');
+      byName('manifest.json');
+      if (
+        ![...evidence.keys()].some((file) => file.includes('/windows/') && file.endsWith('.json'))
+      )
+        throw new Error('Required power: missing central measurement window artifact');
+    } else byName('gpu_metrics.csv');
+    const energies = object(audit.per_gpu_energy_j, 'audit device energy');
+    let auditDevices: JsonRow[];
+    if (audit.per_gpu_role === undefined) {
+      const nodeFiles = [...evidence.values()].filter((file) =>
+        ['power_node.txt', 'gpu_metrics_node.txt'].includes(path.posix.basename(file.path)),
+      );
+      if (nodeFiles.length !== 1)
+        throw new Error('Required power: expected one node identity artifact');
+      const node = nodeFiles[0].contents!.toString().trim();
+      const identityFiles = [...evidence.values()].filter((file) =>
+        /^(?:gpu_metrics_identity\.csv|gpu_metrics_devices\.json)$/u.test(
+          path.posix.basename(file.path),
+        ),
+      );
+      if (identityFiles.length !== 1)
+        throw new Error('Required power: expected one physical GPU identity artifact');
+      const uuidRows: [string, string][] = [];
+      if (identityFiles[0].path.endsWith('.csv')) {
+        const lines = identityFiles[0].contents!.toString().trim().split(/\r?\n/u);
+        const columns = lines
+          .shift()!
+          .split(',')
+          .map((part) => part.trim().replaceAll('"', '').toLowerCase());
+        const indexColumn = columns.indexOf('index');
+        const uuidColumn = columns.indexOf('uuid');
+        if (indexColumn === -1 || uuidColumn === -1)
+          throw new Error('Required power: invalid physical GPU identity CSV');
+        for (const line of lines) {
+          const fields = line.split(',').map((part) => part.trim().replaceAll('"', ''));
+          uuidRows.push([fields[indexColumn], fields[uuidColumn]]);
+        }
+      } else {
+        const visit = (value: unknown): void => {
+          if (Array.isArray(value)) value.forEach(visit);
+          else if (value && typeof value === 'object') {
+            const deviceRow = Object.fromEntries(
+              Object.entries(value).map(([field, item]) => [field.toLowerCase(), item]),
+            );
+            if ('gpu' in deviceRow && 'uuid' in deviceRow)
+              uuidRows.push([String(deviceRow.gpu), String(deviceRow.uuid)]);
+            else Object.values(value).forEach(visit);
+          }
+        };
+        visit(JSON.parse(identityFiles[0].contents!.toString()));
+      }
+      if (
+        uuidRows.length === 0 ||
+        uuidRows.some(
+          ([index, uuid]) =>
+            !/^\d+$/u.test(index) || !uuid || ['n/a', 'none', 'null'].includes(uuid.toLowerCase()),
+        ) ||
+        new Set(uuidRows.map(([index]) => index)).size !== uuidRows.length ||
+        new Set(uuidRows.map(([, uuid]) => uuid)).size !== uuidRows.length
+      )
+        throw new Error('Required power: invalid or duplicate physical GPU identity');
+      const uuids = new Map(uuidRows);
+      auditDevices = Object.entries(energies).map(([index, energy]) => ({
+        node,
+        gpu_uuid: uuids.get(index),
+        role: 'aggregate',
+        energy_j: energy,
+      }));
+    } else {
+      const roles = object(audit.per_gpu_role, 'audit device roles');
+      const nativeNodes = new Map<string, string>();
+      if (audit.telemetry_kind === 'native_multinode_smi')
+        for (const value of audit.nodes as unknown[]) {
+          const receipt = object(value, 'native node receipt');
+          for (const uuid of Object.values(
+            object(receipt.physical_gpu_ids, 'native GPU identities'),
+          )) {
+            const uuidValue = nonempty(uuid, 'native GPU UUID');
+            if (nativeNodes.has(uuidValue))
+              throw new Error('Required power: duplicate native GPU identity');
+            nativeNodes.set(uuidValue, nonempty(receipt.node, 'native node'));
+          }
+        }
+      auditDevices = Object.entries(energies).map(([device, energy]) => {
+        const slash = device.lastIndexOf('/');
+        return {
+          node: nativeNodes.get(device) ?? device.slice(0, slash),
+          gpu_uuid: nativeNodes.has(device) ? device : device.slice(slash + 1),
+          role: roles[device] === 'agg' ? 'aggregate' : roles[device],
+          energy_j: energy,
+        };
+      });
+    }
+    if (
+      !Array.isArray(declared.devices) ||
+      declared.devices.length !== expectedCount ||
+      auditDevices.length !== expectedCount
+    )
+      throw new Error(`Required power: missing physical GPU evidence for ${key}`);
+    const devices = new Set<string>();
+    const roles = new Map<string, number>();
+    let totalEnergy = 0;
+    const roleEnergy = new Map<string, number>();
+    const nodes = new Set<string>();
+    for (const value of declared.devices) {
+      const device = object(value, 'physical GPU');
+      const node = nonempty(device.node, 'GPU node');
+      nodes.add(node);
+      const uuid = nonempty(device.gpu_uuid, 'physical GPU UUID');
+      if (['n/a', 'none', 'null'].includes(uuid.toLowerCase()) || devices.has(uuid))
+        throw new Error('Required power: duplicate or invalid physical GPU UUID');
+      devices.add(uuid);
+      if (!['aggregate', 'prefill', 'decode'].includes(String(device.role)))
+        throw new Error('Required power: invalid physical GPU role');
+      roles.set(String(device.role), (roles.get(String(device.role)) ?? 0) + 1);
+      const energy = positive(device.energy_j, 'device energy_j');
+      totalEnergy += energy;
+      roleEnergy.set(String(device.role), (roleEnergy.get(String(device.role)) ?? 0) + energy);
+      if (!auditDevices.some((actual) => isDeepStrictEqual(actual, device)))
+        throw new Error(`Required power: physical GPU evidence differs from audit for ${key}`);
+    }
+    if (nodes.size !== (matrix['node-count'] ?? 1))
+      throw new Error(
+        `Required power: participating node count differs from required matrix for ${key}`,
+      );
+    if (topology.disagg) {
+      if (
+        roles.get('prefill') !== positive(topology.num_prefill_gpu, 'prefill GPU count') ||
+        roles.get('decode') !== positive(topology.num_decode_gpu, 'decode GPU count') ||
+        roles.has('aggregate')
+      )
+        throw new Error(`Required power: missing prefill or decode evidence for ${key}`);
+      for (const role of ['prefill', 'decode']) {
+        const energy = positive(row[`${role}_gpu_energy_j`], `${role} energy`);
+        if (Math.abs((roleEnergy.get(role) ?? 0) - energy) > Math.max(0.01, energy * 1e-4))
+          throw new Error(`Required power: ${role} energy differs from device evidence for ${key}`);
+      }
+    } else if (roles.get('aggregate') !== expectedCount) {
+      throw new Error(`Required power: invalid aggregate GPU roles for ${key}`);
+    }
+    const energy = positive(row.total_gpu_energy_j, 'total_gpu_energy_j');
+    if (Math.abs(totalEnergy - energy) > Math.max(0.01, energy * 1e-4))
+      throw new Error(`Required power: total GPU energy differs from device evidence for ${key}`);
+  }
+}
diff --git a/packages/db/src/ingest-ci-run.ts b/packages/db/src/ingest-ci-run.ts
index 932a6f194..debb9f463 100644
--- a/packages/db/src/ingest-ci-run.ts
+++ b/packages/db/src/ingest-ci-run.ts
@@ -60,6 +60,7 @@ import {
   readReusedIngestMetadata,
 } from './etl/reused-ingest-metadata';
 import { mapBenchmarkRow, type BenchmarkParams } from './etl/benchmark-mapper';
+import { preflightRequiredPowerCurves } from './etl/required-power-curve';
 import {
   assertRequiredPowerPointsRetained,
   verifyRequiredPowerArtifacts,
@@ -335,11 +336,15 @@ async function main(): Promise<void> {
     }
   }
 
-  const requiredPowerPoints = verifyRequiredPowerArtifacts(artifactsDir, {
-    runId,
-    runAttempt: runAttemptNum,
-    headSha: ghInfo?.headSha ?? null,
-  });
+  const requiredPowerPoints = verifyRequiredPowerArtifacts(
+    artifactsDir,
+    {
+      runId,
+      runAttempt: runAttemptNum,
+      headSha: ghInfo?.headSha ?? null,
+    },
+    process.env.INGEST_REQUIRE_POWER === 'true',
+  );
   if (requiredPowerPoints.length > 0)
     console.log(`  Required power: ${requiredPowerPoints.length} source benchmark points verified`);
 
@@ -411,6 +416,18 @@ async function main(): Promise<void> {
   if (evalsOnly && requiredPowerPoints.length > 0)
     throw new Error('Required power: benchmark scope cannot be published as an evals-only run');
 
+  if (requiredPowerPoints.length > 0)
+    await preflightRequiredPowerCurves(
+      sql,
+      artifactsDir,
+      {
+        runId,
+        runAttempt: runAttemptNum,
+        headSha: ghInfo?.headSha ?? null,
+      },
+      { date, runStartedAt: workflowGhInfo?.runStartedAt ?? null, appendOnly },
+    );
+
   const workflowRunId = await getOrCreateWorkflowRun({
     githubRunId: runId,
     runAttempt: runAttemptNum,
diff --git a/packages/db/src/preflight-power-publication.ts b/packages/db/src/preflight-power-publication.ts
new file mode 100644
index 000000000..031c07170
--- /dev/null
+++ b/packages/db/src/preflight-power-publication.ts
@@ -0,0 +1,36 @@
+import { verifyRequiredPowerArtifacts } from './etl/required-power-publication';
+
+// Deliberately artifact-only: this entry point opens no DB connection and writes no files.
+const [root, runId, runAttempt, headSha, option] = process.argv.slice(2);
+if (
+  !root ||
+  !runId ||
+  !runAttempt ||
+  !/^\d+$/u.test(runId) ||
+  !/^\d+$/u.test(runAttempt) ||
+  !Number.isSafeInteger(Number(runId)) ||
+  !Number.isSafeInteger(Number(runAttempt)) ||
+  Number(runId) <= 0 ||
+  Number(runAttempt) <= 0 ||
+  !headSha ||
+  !/^[a-f0-9]{40}$/u.test(headSha) ||
+  (option !== undefined && option !== '--optional-power') ||
+  process.argv.length > 7
+)
+  throw new Error(
+    'Usage: preflight-power-publication.ts <artifacts-dir> <source-run-id> <attempt> <head-sha> [--optional-power]',
+  );
+
+const points = verifyRequiredPowerArtifacts(
+  root,
+  { runId: Number(runId), runAttempt: Number(runAttempt), headSha },
+  option !== '--optional-power',
+);
+console.log(
+  JSON.stringify({
+    status: 'validated_artifacts',
+    requiredPoints: points.length,
+    databaseWrites: 0,
+    curvePreservation: 'not_checked_requires_published_state',
+  }),
+);
diff --git a/packages/db/src/prepare-ci-artifacts.test.ts b/packages/db/src/prepare-ci-artifacts.test.ts
new file mode 100644
index 000000000..0f444791b
--- /dev/null
+++ b/packages/db/src/prepare-ci-artifacts.test.ts
@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const fixture = fileURLToPath(
+  new URL('../../../docs/fixtures/powerx-manifest-v2/artifacts/', import.meta.url),
+);
+const mocks = vi.hoisted(() => ({ names: [] as string[], fixture: '', corrupt: false }));
+vi.mock('node:child_process', () => ({
+  execFileSync: vi.fn(() => JSON.stringify({ head_sha: 'b'.repeat(40), run_attempt: 1 })),
+}));
+vi.mock('./lib/github-artifacts.js', () => ({
+  listRunArtifacts: () =>
+    mocks.names.map((name, id) => ({
+      id,
+      name,
+      expired: false,
+      created_at: '2026-09-16T00:00:00Z',
+    })),
+  downloadArtifact: (artifact: { name: string }, root: string) => {
+    fs.cpSync(path.join(mocks.fixture, artifact.name), path.join(root, artifact.name), {
+      recursive: true,
+    });
+    if (mocks.corrupt && artifact.name === 'agentic_golden')
+      fs.appendFileSync(path.join(root, artifact.name, 'gpu_metrics.csv'), 'corrupt\n');
+  },
+}));
+
+let directory: string;
+let originalArgs: string[];
+let originalExitCode: typeof process.exitCode;
+beforeEach(() => {
+  vi.resetModules();
+  directory = fs.mkdtempSync(path.join(os.tmpdir(), 'power-prepare-'));
+  mocks.fixture = fixture;
+  mocks.names = fs.readdirSync(fixture);
+  mocks.corrupt = false;
+  originalArgs = process.argv;
+  originalExitCode = process.exitCode;
+  process.argv = ['bun', 'prepare-ci-artifacts.ts'];
+  process.exitCode = undefined;
+  vi.stubEnv('SOURCE_RUN_ID', '123');
+  vi.stubEnv('MERGE_RUN_ID', '123');
+  vi.stubEnv('ARTIFACTS_PATH', directory);
+  vi.stubEnv('INGEST_REQUIRE_POWER', 'true');
+  vi.stubEnv('GITHUB_OUTPUT', '');
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+});
+afterEach(() => {
+  process.argv = originalArgs;
+  process.exitCode = originalExitCode;
+  vi.unstubAllEnvs();
+  vi.restoreAllMocks();
+  fs.rmSync(directory, { recursive: true, force: true });
+});
+
+describe('artifact preparation gate before migrations', () => {
+  it('accepts the actual golden source bundle without a database connection', async () => {
+    await import('./prepare-ci-artifacts');
+    expect(process.exitCode).toBeUndefined();
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('fails the preparation command when both manifest and changelog are lost', async () => {
+    mocks.names = mocks.names.filter(
+      (name) => name !== 'required-power-sweep-manifest' && name !== 'changelog-metadata',
+    );
+    await import('./prepare-ci-artifacts');
+    expect(process.exitCode).toBe(1);
+    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('required dispatch'));
+  });
+
+  it('fails preparation on corrupt downloaded telemetry', async () => {
+    mocks.corrupt = true;
+    await import('./prepare-ci-artifacts');
+    expect(process.exitCode).toBe(1);
+    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('hash'));
+  });
+
+  it('retains optional-power compatibility when there is no required marker', async () => {
+    vi.stubEnv('INGEST_REQUIRE_POWER', 'false');
+    mocks.names = ['bmk_agentic_golden'];
+    await import('./prepare-ci-artifacts');
+    expect(process.exitCode).toBeUndefined();
+    expect(console.error).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/db/src/prepare-ci-artifacts.ts b/packages/db/src/prepare-ci-artifacts.ts
index fbf834d70..f0c35780e 100644
--- a/packages/db/src/prepare-ci-artifacts.ts
+++ b/packages/db/src/prepare-ci-artifacts.ts
@@ -6,6 +6,7 @@ import path from 'node:path';
 
 import { buildArtifactPlan } from './lib/ci-artifact-preparation.js';
 import { downloadArtifact, listRunArtifacts, type ArtifactMeta } from './lib/github-artifacts.js';
+import { verifyRequiredPowerArtifacts } from './etl/required-power-publication.js';
 
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 
@@ -148,6 +149,16 @@ function main(): void {
     console.log(`Downloading artifact: ${artifact.name}`);
     downloadWithRetries(artifact, artifactsPath);
   }
+  // This command precedes migrations: malformed required input must not reach any DB write.
+  verifyRequiredPowerArtifacts(
+    artifactsPath,
+    {
+      runId: Number(sourceRunId),
+      runAttempt: sourceMetadata.run_attempt ?? 1,
+      headSha: sourceMetadata.head_sha ?? null,
+    },
+    process.env.INGEST_REQUIRE_POWER === 'true',
+  );
   if (plan.reused) {
     writeReuseMetadata(artifactsPath, sourceRunId, mergeRunId, sourceMetadata, mergeMetadata);
   }
diff --git a/packages/db/src/verify-power-publication.ts b/packages/db/src/verify-power-publication.ts
index 84bf86723..fbd34ab68 100644
--- a/packages/db/src/verify-power-publication.ts
+++ b/packages/db/src/verify-power-publication.ts
@@ -33,7 +33,7 @@ try {
     join workflow_runs wr on wr.id = br.workflow_run_id
     where wr.github_run_id = ${manifest.runId} and wr.run_attempt = ${manifest.runAttempt}
       and (br.benchmark_type = 'agentic_traces' or
-        (br.benchmark_type = 'single_turn' and br.isl = 8192 and br.osl = 1024))
+        (br.benchmark_type = 'single_turn' and br.isl in (1024, 8192) and br.osl = 1024))
   `;
   const errors = [
     ...(manifest.ingestErrors ?? []),

From ca4f61953ea73f2fc9417a62299d5efaa8582ad3 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Sun, 20 Sep 2026 21:04:32 -0700
Subject: [PATCH 015/103] fix: delete purged telemetry explicitly and report
 what went
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Migration 016 declares `on delete cascade` from gpu_metric_series to
workflow_runs and from benchmark_result_gpu_metrics to benchmark_results, so
a purge already removed telemetry — with no count in the preview and no line
in the transcript. Past GitHub's 90-day artifact retention the stored samples
are the only copy, which is the reason 016 exists, so that loss should not be
invisible at the moment the operator confirms it.

The same rows are removed as before; this is accounting, not a change of
behaviour. previewPurge now prints the series and sample counts alongside the
benchmark and server_log counts, a whole-run purge deletes the series itself
before dropping workflow_runs and logs what went, and a point purge drops only
the point-to-series links. The series stays with its run in that second case:
/api/gpu-metrics?runId= reads series by run rather than through the links, and
other points of the same run may still reference it.

New lib/telemetry-purge.ts holds the three queries, covered by 11 PGlite tests
against the real 001 and 016 migrations so the cascades under test are the ones
the migration declares.

中文：迁移 016 声明了 gpu_metric_series 到 workflow_runs、
benchmark_result_gpu_metrics 到 benchmark_results 的 `on delete cascade`，因此
purge 一直在删除遥测数据，但预览里没有计数、日志里没有记录。超过 GitHub 90 天
产物保留期后，库里的采样就是唯一副本，这正是 016 存在的理由，所以操作者确认的
那一刻不应该看不见这笔损失。

删除的行与此前完全相同，这次改的是账目而不是行为。previewPurge 现在会在
benchmark 与 server_log 计数旁一并打印 series 与采样数；整个 run 的 purge 会在
删除 workflow_runs 之前先显式删除 series 并记录；单点 purge 只解除点与 series 的
链接。后一种情况下 series 会随 run 保留，因为 /api/gpu-metrics?runId= 是按 run
读取 series 而不是走这些链接，而且同一个 run 的其他点可能仍在引用它。

新增的 lib/telemetry-purge.ts 收拢这三条查询，由 11 个 PGlite 测试覆盖，直接对
真实的 001 与 016 迁移运行，确保被测的正是迁移声明的那些级联。
---
 packages/db/src/apply-overrides.ts          |  28 +++-
 packages/db/src/lib/telemetry-purge.test.ts | 160 ++++++++++++++++++++
 packages/db/src/lib/telemetry-purge.ts      | 100 ++++++++++++
 3 files changed, 287 insertions(+), 1 deletion(-)
 create mode 100644 packages/db/src/lib/telemetry-purge.test.ts
 create mode 100644 packages/db/src/lib/telemetry-purge.ts

diff --git a/packages/db/src/apply-overrides.ts b/packages/db/src/apply-overrides.ts
index 6ac41680b..62188b705 100644
--- a/packages/db/src/apply-overrides.ts
+++ b/packages/db/src/apply-overrides.ts
@@ -26,6 +26,13 @@ import { type Sql, createAdminSql, refreshLatestBenchmarks } from './etl/db-util
 import { jsonbParam } from './lib/backfill-runner.js';
 import { planBenchmarkPointBackfill } from './lib/benchmark-point-backfill.js';
 import { selectRunOverrides } from './lib/run-override-selection.js';
+import {
+  type TelemetryPurgeCounts,
+  countRunTelemetry,
+  deleteRunTelemetry,
+  describeTelemetry,
+  unlinkPointTelemetry,
+} from './lib/telemetry-purge.js';
 import {
   type BenchmarkPointBackfill,
   type ChangelogBackfill,
@@ -315,6 +322,7 @@ interface PurgeTarget {
   stats: number;
   evals: number;
   changelogs: number;
+  telemetry: TelemetryPurgeCounts;
 }
 
 /**
@@ -358,17 +366,21 @@ async function previewPurge(
     );
   }
 
-  const [[bmk], [stats], [evals], [changelogs], [logs]] = await Promise.all([
+  const [[bmk], [stats], [evals], [changelogs], [logs], telemetry] = await Promise.all([
     sql`SELECT count(*)::int AS n FROM benchmark_results WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(*)::int AS n FROM run_stats WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(*)::int AS n FROM eval_results WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(*)::int AS n FROM changelog_entries WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(DISTINCT server_log_id)::int AS n FROM benchmark_results WHERE workflow_run_id = ANY(${wrIds}) AND server_log_id IS NOT NULL`,
+    countRunTelemetry(sql, wrIds),
   ]);
 
   console.log(
     `    ${bmk.n} benchmarks, ${logs.n} server_logs, ${stats.n} run_stats, ${evals.n} evals, ${changelogs.n} changelogs`,
   );
+  // Surfaced separately: past GitHub's 90-day artifact retention these samples
+  // are the only copy, so the operator should see them before confirming.
+  if (telemetry.series > 0) console.log(`    ${describeTelemetry(telemetry)}`);
 
   return {
     githubRunId,
@@ -378,6 +390,7 @@ async function previewPurge(
     stats: stats.n,
     evals: evals.n,
     changelogs: changelogs.n,
+    telemetry,
   };
 }
 
@@ -404,6 +417,14 @@ async function purgeBenchmarkResults(tx: Sql, resultIds: number[]): Promise<void
     WHERE id = ANY(${resultIds}) AND trace_replay_id IS NOT NULL
   `;
 
+  // Drop the point→series links explicitly rather than through the cascade on
+  // benchmark_results, so the transcript records it. The series itself stays: it
+  // belongs to the workflow_run, which survives a point purge, and
+  // /api/gpu-metrics?runId= reads series by run rather than through these links.
+  const unlinked = await unlinkPointTelemetry(tx, resultIds);
+  if (unlinked > 0)
+    console.log(`    unlinked ${unlinked} gpu_metric_series link(s); series kept with the run.`);
+
   await tx`DELETE FROM benchmark_results WHERE id = ANY(${resultIds})`;
 
   const sIds = logRows.map((r) => r.id as number);
@@ -493,6 +514,11 @@ async function purge(wrIds: number[]): Promise<void> {
     await tx`DELETE FROM eval_results WHERE workflow_run_id = ANY(${wrIds})`;
     await tx`DELETE FROM changelog_entries WHERE workflow_run_id = ANY(${wrIds})`;
 
+    // Telemetry too. The workflow_runs delete below would cascade it away anyway,
+    // but silently; deleting it here reports the cost of an irreversible loss.
+    const telemetry = await deleteRunTelemetry(tx, wrIds);
+    if (telemetry.series > 0) console.log(`    deleted ${describeTelemetry(telemetry)}.`);
+
     // Parent last (target the specific workflow_runs rows so partial purges
     // leave sibling attempts of the same github_run_id intact)
     await tx`DELETE FROM workflow_runs WHERE id = ANY(${wrIds})`;
diff --git a/packages/db/src/lib/telemetry-purge.test.ts b/packages/db/src/lib/telemetry-purge.test.ts
new file mode 100644
index 000000000..9224172f3
--- /dev/null
+++ b/packages/db/src/lib/telemetry-purge.test.ts
@@ -0,0 +1,160 @@
+/**
+ * Telemetry purge behaviour against a PGlite database with the real migrations
+ * applied, so the FK cascades declared in 016_gpu_metrics.sql are the ones under
+ * test rather than a hand-written stand-in.
+ *
+ * The regression these cover: before this change both purge levels relied on
+ * `on delete cascade`, so a purge destroyed telemetry with no count anywhere. The
+ * point-level case was worse than silent — it left the series stranded, paying
+ * storage while the per-point endpoint could never reach it again.
+ */
+
+import fs from 'node:fs';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  countRunTelemetry,
+  deleteRunTelemetry,
+  describeTelemetry,
+  unlinkPointTelemetry,
+} from './telemetry-purge';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+let sql: Sql;
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, { json: JSON.stringify, array: (value: unknown) => value });
+}
+
+const count = async (table: string): Promise<number> => {
+  const result = await db.query<{ n: number }>(`SELECT count(*)::int AS n FROM ${table}`);
+  return result.rows[0].n;
+};
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  sql = queryClient(db) as unknown as Sql;
+}, 20_000);
+
+afterAll(async () => {
+  await db?.close();
+});
+
+/**
+ * Two runs. Run 1 has two benchmark points sharing one series plus a second
+ * series linked to nothing, which is the shape a multinode upload produces. Run 2
+ * exists to prove a purge never reaches past the runs it was given.
+ */
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, html_url, created_at, date)
+    VALUES (1, 44000000001, 1, 'Run Sweep', null, now(), '2026-09-01'),
+           (2, 44000000002, 1, 'Run Sweep', null, now(), '2026-09-02');
+
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsv4', 'b200', 'sglang', 'fp8', 'none', false, 8, 8, 8, 8);
+
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, date, isl, osl, conc,
+      benchmark_type, metrics)
+    VALUES (11, 1, 1, '2026-09-01', 8192, 1024, 32, 'single_turn', '{}'::jsonb),
+           (12, 1, 1, '2026-09-01', 8192, 1024, 64, 'single_turn', '{}'::jsonb),
+           (21, 2, 1, '2026-09-02', 8192, 1024, 32, 'single_turn', '{}'::jsonb);
+
+    INSERT INTO gpu_metric_series (id, workflow_run_id, artifact_name, config_key, file_name,
+      vendor, csv_sha256, sample_count, gpu_count, started_at, ended_at)
+    VALUES (101, 1, 'gpu_metrics_a', 'a', 'a.csv', 'nvidia', 'sha-a', 1000, 8,
+              '2026-09-01T00:00:00Z', '2026-09-01T00:10:00Z'),
+           (102, 1, 'gpu_metrics_b', 'b', 'b.csv', 'nvidia', 'sha-b', 2000, 8,
+              '2026-09-01T00:00:00Z', '2026-09-01T00:20:00Z'),
+           (201, 2, 'gpu_metrics_c', 'c', 'c.csv', 'nvidia', 'sha-c', 4000, 8,
+              '2026-09-02T00:00:00Z', '2026-09-02T00:40:00Z');
+
+    INSERT INTO benchmark_result_gpu_metrics (benchmark_result_id, series_id)
+    VALUES (11, 101), (12, 101), (21, 201);
+  `);
+});
+
+describe('countRunTelemetry', () => {
+  it('sums the stored sample counts for the targeted runs only', async () => {
+    await expect(countRunTelemetry(sql, [1])).resolves.toEqual({ series: 2, samples: 3000 });
+    await expect(countRunTelemetry(sql, [2])).resolves.toEqual({ series: 1, samples: 4000 });
+    await expect(countRunTelemetry(sql, [1, 2])).resolves.toEqual({ series: 3, samples: 7000 });
+  });
+
+  it('reports zero for a run with no telemetry and reads nothing for an empty list', async () => {
+    await db.exec('DELETE FROM gpu_metric_series WHERE workflow_run_id = 2');
+    await expect(countRunTelemetry(sql, [2])).resolves.toEqual({ series: 0, samples: 0 });
+    await expect(countRunTelemetry(sql, [])).resolves.toEqual({ series: 0, samples: 0 });
+  });
+
+  it('does not delete anything', async () => {
+    await countRunTelemetry(sql, [1, 2]);
+    expect(await count('gpu_metric_series')).toBe(3);
+  });
+});
+
+describe('deleteRunTelemetry', () => {
+  it('removes the run series and reports what went', async () => {
+    await expect(deleteRunTelemetry(sql, [1])).resolves.toEqual({ series: 2, samples: 3000 });
+    expect(await count('gpu_metric_series')).toBe(1);
+  });
+
+  it('leaves other runs untouched', async () => {
+    await deleteRunTelemetry(sql, [1]);
+    await expect(countRunTelemetry(sql, [2])).resolves.toEqual({ series: 1, samples: 4000 });
+  });
+
+  it('takes the point links with it, so no link outlives its series', async () => {
+    await deleteRunTelemetry(sql, [1]);
+    expect(await count('benchmark_result_gpu_metrics')).toBe(1);
+  });
+
+  it('is a no-op on an empty list', async () => {
+    await expect(deleteRunTelemetry(sql, [])).resolves.toEqual({ series: 0, samples: 0 });
+    expect(await count('gpu_metric_series')).toBe(3);
+  });
+});
+
+describe('unlinkPointTelemetry', () => {
+  it('drops only the links for the given points', async () => {
+    await expect(unlinkPointTelemetry(sql, [11])).resolves.toBe(1);
+    const rows = await db.query<{ benchmark_result_id: number }>(
+      'SELECT benchmark_result_id FROM benchmark_result_gpu_metrics ORDER BY benchmark_result_id',
+    );
+    expect(rows.rows.map((r) => r.benchmark_result_id)).toEqual([12, 21]);
+  });
+
+  it('keeps the series, which still belongs to a run that was not purged', async () => {
+    await unlinkPointTelemetry(sql, [11, 12]);
+    expect(await count('benchmark_result_gpu_metrics')).toBe(1);
+    await expect(countRunTelemetry(sql, [1])).resolves.toEqual({ series: 2, samples: 3000 });
+  });
+
+  it('returns 0 for points that have no telemetry and for an empty list', async () => {
+    await expect(unlinkPointTelemetry(sql, [12, 999])).resolves.toBe(1);
+    await expect(unlinkPointTelemetry(sql, [999])).resolves.toBe(0);
+    await expect(unlinkPointTelemetry(sql, [])).resolves.toBe(0);
+  });
+});
+
+describe('describeTelemetry', () => {
+  it('groups the sample count so a large loss reads as large', () => {
+    expect(describeTelemetry({ series: 23, samples: 207_345 })).toBe(
+      '23 gpu_metric_series (207,345 samples)',
+    );
+  });
+});
diff --git a/packages/db/src/lib/telemetry-purge.ts b/packages/db/src/lib/telemetry-purge.ts
new file mode 100644
index 000000000..13b2b76dd
--- /dev/null
+++ b/packages/db/src/lib/telemetry-purge.ts
@@ -0,0 +1,100 @@
+/**
+ * Explicit deletion of PowerX telemetry during a purge.
+ *
+ * Migration 016 declares `on delete cascade` from `gpu_metric_series.workflow_run_id`
+ * to `workflow_runs` and from `benchmark_result_gpu_metrics.benchmark_result_id` to
+ * `benchmark_results`, so a purge already removed telemetry — silently, with no count
+ * in the preview and no line in the log. That is the wrong default for this data:
+ * past GitHub's 90-day artifact retention the stored samples are the only copy, which
+ * is the reason migration 016 exists at all. These helpers make the deletion explicit
+ * so the operator sees the cost before confirming and again in the transcript.
+ *
+ * The two levels differ on purpose:
+ *   - A whole-run purge owns the series and deletes them (`deleteRunTelemetry`).
+ *   - A point purge only drops the point→series links (`unlinkPointTelemetry`). The
+ *     series stays attached to its workflow_run because `/api/gpu-metrics?runId=`
+ *     reads series by run, not through the links, and other points of the same run
+ *     may still reference it.
+ */
+
+import type { Sql } from '../etl/db-utils.js';
+
+export interface TelemetryPurgeCounts {
+  /** Rows in `gpu_metric_series`. */
+  series: number;
+  /** Sum of `gpu_metric_series.sample_count` across those series. */
+  samples: number;
+}
+
+export const NO_TELEMETRY: TelemetryPurgeCounts = { series: 0, samples: 0 };
+
+/** `count`/`sum` come back as strings over the wire; `sum` is null on an empty set. */
+function toCounts(row: { n: unknown; samples: unknown } | undefined): TelemetryPurgeCounts {
+  if (!row) return NO_TELEMETRY;
+  return { series: Number(row.n ?? 0), samples: Number(row.samples ?? 0) };
+}
+
+/**
+ * Telemetry a whole-run purge would destroy. Read-only, for the preview line.
+ * Sums the stored `sample_count` instead of counting `gpu_metric_samples` so the
+ * preview stays cheap against a table holding tens of millions of rows.
+ */
+export async function countRunTelemetry(
+  sql: Sql,
+  workflowRunIds: readonly number[],
+): Promise<TelemetryPurgeCounts> {
+  if (workflowRunIds.length === 0) return NO_TELEMETRY;
+  const [row] = await sql`
+    SELECT count(*)::int AS n, coalesce(sum(sample_count), 0)::bigint AS samples
+    FROM gpu_metric_series
+    WHERE workflow_run_id = ANY(${[...workflowRunIds]})
+  `;
+  return toCounts(row as { n: unknown; samples: unknown } | undefined);
+}
+
+/**
+ * Delete the telemetry owned by these workflow_runs and report what went, so the
+ * caller can log it. Samples and per-GPU stats follow by cascade from the series.
+ * Call this before deleting the `workflow_runs` rows themselves.
+ */
+export async function deleteRunTelemetry(
+  sql: Sql,
+  workflowRunIds: readonly number[],
+): Promise<TelemetryPurgeCounts> {
+  if (workflowRunIds.length === 0) return NO_TELEMETRY;
+  const [row] = await sql`
+    WITH deleted AS (
+      DELETE FROM gpu_metric_series
+      WHERE workflow_run_id = ANY(${[...workflowRunIds]})
+      RETURNING sample_count
+    )
+    SELECT count(*)::int AS n, coalesce(sum(sample_count), 0)::bigint AS samples FROM deleted
+  `;
+  return toCounts(row as { n: unknown; samples: unknown } | undefined);
+}
+
+/**
+ * Drop the point→series links for purged benchmark points and report how many went.
+ * Deliberately leaves `gpu_metric_series` in place: it belongs to the workflow_run,
+ * which is not being purged here.
+ */
+export async function unlinkPointTelemetry(
+  sql: Sql,
+  benchmarkResultIds: readonly number[],
+): Promise<number> {
+  if (benchmarkResultIds.length === 0) return 0;
+  const [row] = await sql`
+    WITH deleted AS (
+      DELETE FROM benchmark_result_gpu_metrics
+      WHERE benchmark_result_id = ANY(${[...benchmarkResultIds]})
+      RETURNING series_id
+    )
+    SELECT count(*)::int AS n FROM deleted
+  `;
+  return Number((row as { n: unknown } | undefined)?.n ?? 0);
+}
+
+/** One-line summary for preview and transcript output. */
+export function describeTelemetry(counts: TelemetryPurgeCounts): string {
+  return `${counts.series} gpu_metric_series (${counts.samples.toLocaleString('en-US')} samples)`;
+}

From c763540f1ceede432babe9c18f746cb766f810e7 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Sun, 20 Sep 2026 21:04:51 -0700
Subject: [PATCH 016/103] fix: migrate before verify in apply-run-overrides and
 keep cache steps
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This workflow fires on a push to run-overrides.ts, which can land before the
next ingest dispatch has applied a pending migration. It ran admin:db:verify
with no migrate step of its own, and verify-db counts every table it knows
about, so it would fail on a schema the checked-out ref expects but production
does not have yet. Added the same Run migrations step ingest-results.yml uses;
migrations are idempotent by filename.

The worse half was what a red verify did to the two steps after it. Neither
carried if: always(), so a verify failure skipped both the production cache
invalidation and the warmup while the overrides were already committed to the
database. The dashboard then served pre-override data with a red workflow as
the only signal. Both now run whenever the overrides step itself succeeded.

中文：该工作流在 run-overrides.ts 的 push 上触发，而这次 push 可能早于下一次
ingest 派发应用待处理的迁移。它自己没有 migrate 步骤就直接跑 admin:db:verify，
而 verify-db 会统计它已知的每一张表，于是会在一个"检出的 ref 期望、但生产还没有"
的 schema 上失败。现已加入与 ingest-results.yml 相同的 Run migrations 步骤；迁移
按文件名幂等。

更严重的一半是 verify 变红对其后两个步骤的影响。两者都没有 if: always()，所以
verify 一失败就会跳过生产缓存失效和预热，而此时 override 已经写进数据库了。仪表板
于是继续提供改写前的数据，唯一的信号只有一个变红的工作流。现在只要 override 步骤
本身成功，这两步就会执行。
---
 .github/workflows/apply-run-overrides.yml | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/.github/workflows/apply-run-overrides.yml b/.github/workflows/apply-run-overrides.yml
index 749880e80..819f09aca 100644
--- a/.github/workflows/apply-run-overrides.yml
+++ b/.github/workflows/apply-run-overrides.yml
@@ -53,7 +53,18 @@ jobs:
         env:
           CYPRESS_INSTALL_BINARY: '0'
 
+      # This workflow fires on a push to run-overrides.ts, which can land before the
+      # next ingest dispatch has applied a pending migration. admin:db:verify counts
+      # every table it knows about, so without this step it fails on a schema the
+      # checked-out ref expects but production does not have yet. Same command and
+      # ordering as ingest-results.yml; migrations are idempotent by filename.
+      - name: Run migrations
+        env:
+          DATABASE_WRITE_URL: ${{ secrets.DATABASE_WRITE_URL }}
+        run: bun run admin:db:migrate --yes
+
       - name: Apply run overrides
+        id: apply
         env:
           DATABASE_WRITE_URL: ${{ secrets.DATABASE_WRITE_URL }}
           RUN_ID: ${{ inputs.run_id }}
@@ -69,10 +80,15 @@ jobs:
           DATABASE_WRITE_URL: ${{ secrets.DATABASE_WRITE_URL }}
         run: bun run admin:db:verify
 
+      # Once the overrides are in the database the CDN is stale, so these must run
+      # even if the verify step above fails. Skipping them leaves the dashboard
+      # serving pre-override data with only a red workflow as the signal.
       - name: Invalidate production cache
+        if: ${{ always() && steps.apply.outcome == 'success' }}
         env:
           INVALIDATE_SECRET: ${{ secrets.VERCEL_INVALIDATE_SECRET }}
         run: bun run admin:cache:invalidate https://inferencex.semianalysis.com
 
       - name: Warm production cache
+        if: ${{ always() && steps.apply.outcome == 'success' }}
         run: bun run admin:cache:warmup https://inferencex.semianalysis.com

From 1e5d227acde10b20c346f79b9124bdc6bf62ff48 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Sun, 20 Sep 2026 21:05:11 -0700
Subject: [PATCH 017/103] fix: keep gpu_metrics digest errors from failing the
 whole ingest
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A gpu_metrics digest failure was recorded through recordDbError, which feeds
tracker.skips.dbError, which the ingest writes into the publication manifest
as an ingestError, which verify-power-publication folds into errors and exits
non-zero on. That script is the required "Verify PowerX source, database and
public API" step with no continue-on-error, so one malformed telemetry CSV
would turn a whole production ingest red even though every benchmark row
landed correctly. This failure mode does not exist before migration 016.

Telemetry failures now have their own counter and their own recordTelemetryError,
with its own print budget so telemetry noise cannot suppress real DB errors.
The manifest reports them under telemetryWarnings, and the new
fatalPublicationErrors makes the fatal set explicit at the one place that
decides the exit code. What is lost on a digest failure is one point's PowerX
tab, and admin:db:backfill-gpu-metrics --run <id> can re-digest the artifact.

Coverage: the two counters are proven independent, and fatalPublicationErrors
is proven to ignore telemetry warnings while still failing on real ingest
errors and verification mismatches. The catch site itself has no direct test —
it sits inside the artifact loop of a script the suite only runs as a
subprocess against a purged run, which returns before reaching it.

中文：gpu_metrics 摘要失败此前经 recordDbError 记录，进入 tracker.skips.dbError，
再被 ingest 作为 ingestError 写入发布 manifest，verify-power-publication 把它折进
errors 并以非零码退出。该脚本是必需的 "Verify PowerX source, database and public
API" 步骤且没有 continue-on-error，因此一个格式错误的遥测 CSV 就能让整条生产
ingest 变红，哪怕每一行 benchmark 数据都正确落库。这个失败模式在迁移 016 之前
并不存在。

遥测失败现在有独立计数器和独立的 recordTelemetryError，并有自己的打印额度，避免
遥测噪声淹没真正的 DB 错误。manifest 将其归入 telemetryWarnings，新增的
fatalPublicationErrors 在决定退出码的唯一位置显式界定致命集合。摘要失败损失的只是
某一个点的 PowerX 标签页，用 admin:db:backfill-gpu-metrics --run <id> 可以重新摘要
该产物。

覆盖范围：已验证两个计数器互相独立，并验证 fatalPublicationErrors 忽略遥测警告、
同时仍然对真正的 ingest 错误和校验不一致判为失败。catch 处本身没有直接测试——它
位于一个脚本的产物循环内部，而测试套件只以子进程方式对一个已 purge 的 run 运行该
脚本，那条路径在到达此处之前就返回了。
---
 packages/db/src/etl/ingest-summary.ts         |  1 +
 packages/db/src/etl/power-publication.test.ts | 28 ++++++++++++++++
 packages/db/src/etl/power-publication.ts      | 21 ++++++++++++
 packages/db/src/etl/skip-tracker.test.ts      | 21 ++++++++++++
 packages/db/src/etl/skip-tracker.ts           | 33 +++++++++++++++++++
 packages/db/src/ingest-ci-run.test.ts         |  1 +
 packages/db/src/ingest-ci-run.ts              | 11 ++++++-
 packages/db/src/ingest-gcs-backup.ts          | 10 ++++--
 packages/db/src/verify-power-publication.ts   | 12 ++++---
 9 files changed, 130 insertions(+), 8 deletions(-)

diff --git a/packages/db/src/etl/ingest-summary.ts b/packages/db/src/etl/ingest-summary.ts
index 16806cc47..684d7a1f5 100644
--- a/packages/db/src/etl/ingest-summary.ts
+++ b/packages/db/src/etl/ingest-summary.ts
@@ -38,6 +38,7 @@ export function printIngestSummaryFooter(
     ['unmapped hw', skips.unmappedHw],
     ['bad/empty zip', skips.badZip],
     ['DB errors', skips.dbError],
+    ['telemetry errors (non-fatal)', skips.telemetryError],
   );
 
   const nonzeroSkipLines = skipLines.filter(([, count]) => count > 0);
diff --git a/packages/db/src/etl/power-publication.test.ts b/packages/db/src/etl/power-publication.test.ts
index b31ce0f98..60a95e3e1 100644
--- a/packages/db/src/etl/power-publication.test.ts
+++ b/packages/db/src/etl/power-publication.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest';
 import { mapBenchmarkRow } from './benchmark-mapper';
 import { createSkipTracker } from './skip-tracker';
 import {
+  fatalPublicationErrors,
   powerPublicationPoint,
   verifyPowerPublication,
   type PublishedPowerRow,
@@ -140,3 +141,30 @@ describe('PowerX publication', () => {
     expect(tracker.skips.failedRun).toBe(1);
   });
 });
+
+/**
+ * Regression for the ingest-reddening chain: a gpu_metrics digest failure used to
+ * be recorded as a DB error, reach the publication manifest's `ingestErrors`, and
+ * set exitCode 1 on the required "Verify PowerX source, database and public API"
+ * step — failing a production ingest whose benchmark data had landed fine.
+ */
+describe('fatalPublicationErrors', () => {
+  it('ignores telemetry warnings, so a bad gpu_metrics CSV cannot fail the ingest', () => {
+    expect(
+      fatalPublicationErrors({ telemetryWarnings: ['3 gpu_metrics digest errors'] }, []),
+    ).toEqual([]);
+  });
+
+  it('still fails on real ingest errors and on verification mismatches', () => {
+    expect(
+      fatalPublicationErrors(
+        { ingestErrors: ['2 database ingest errors'], telemetryWarnings: ['1 gpu_metrics'] },
+        ['point 441871 expected absent, got 642'],
+      ),
+    ).toEqual(['2 database ingest errors', 'point 441871 expected absent, got 642']);
+  });
+
+  it('treats both fields as optional', () => {
+    expect(fatalPublicationErrors({}, [])).toEqual([]);
+  });
+});
diff --git a/packages/db/src/etl/power-publication.ts b/packages/db/src/etl/power-publication.ts
index 5009468be..b0f359df8 100644
--- a/packages/db/src/etl/power-publication.ts
+++ b/packages/db/src/etl/power-publication.ts
@@ -46,8 +46,29 @@ export interface PowerPublicationManifest {
   runId: number;
   runAttempt: number;
   points: PowerPublicationPoint[];
+  /** Fatal: verify-power-publication exits non-zero when this is non-empty. */
   ingestErrors?: string[];
+  /**
+   * Non-fatal: PowerX telemetry digest failures. Surfaced in the verification
+   * receipt so they stay visible, but they never fail the ingest — the benchmark
+   * rows landed, and the artifact can be re-digested by the backfill.
+   */
+  telemetryWarnings?: string[];
 }
+/**
+ * The errors that fail an ingest. `telemetryWarnings` is deliberately not among
+ * them: a gpu_metrics digest failure costs one point's PowerX tab, while the
+ * benchmark rows it accompanies are already committed and the artifact can be
+ * re-digested by `admin:db:backfill-gpu-metrics`. Folding it in would let one
+ * malformed CSV turn a whole production ingest red.
+ */
+export function fatalPublicationErrors(
+  manifest: Pick<PowerPublicationManifest, 'ingestErrors' | 'telemetryWarnings'>,
+  verificationErrors: readonly string[],
+): string[] {
+  return [...(manifest.ingestErrors ?? []), ...verificationErrors];
+}
+
 export interface PublishedPowerRow extends Record<string, unknown> {
   metrics: Record<string, number>;
 }
diff --git a/packages/db/src/etl/skip-tracker.test.ts b/packages/db/src/etl/skip-tracker.test.ts
index e407db3a3..0e3ba64ee 100644
--- a/packages/db/src/etl/skip-tracker.test.ts
+++ b/packages/db/src/etl/skip-tracker.test.ts
@@ -9,6 +9,7 @@ describe('createSkipTracker', () => {
     expect(tracker.skips.unmappedHw).toBe(0);
     expect(tracker.skips.noIslOsl).toBe(0);
     expect(tracker.skips.dbError).toBe(0);
+    expect(tracker.skips.telemetryError).toBe(0);
     expect(tracker.skips.traceReplayMissing).toBe(0);
   });
 
@@ -53,6 +54,26 @@ describe('recordDbError', () => {
   });
 });
 
+describe('recordTelemetryError', () => {
+  it('counts separately from dbError, which is the counter that fails the ingest', () => {
+    const tracker = createSkipTracker();
+    tracker.recordTelemetryError('gpu_metrics for dsv4-b200', new Error('malformed CSV'));
+    tracker.recordTelemetryError('gpu_metrics for dsv4-b300', new Error('malformed CSV'));
+    expect(tracker.skips.telemetryError).toBe(2);
+    expect(tracker.skips.dbError).toBe(0);
+  });
+
+  it('keeps its own print budget, so telemetry noise cannot silence DB errors', () => {
+    const tracker = createSkipTracker();
+    for (let i = 0; i < 15; i++) {
+      tracker.recordTelemetryError(`context ${i}`, new Error(`error ${i}`));
+    }
+    tracker.recordDbError('availability', new Error('boom'));
+    expect(tracker.skips.telemetryError).toBe(15);
+    expect(tracker.skips.dbError).toBe(1);
+  });
+});
+
 describe('snapshot', () => {
   it('captures current counters', () => {
     const tracker = createSkipTracker();
diff --git a/packages/db/src/etl/skip-tracker.ts b/packages/db/src/etl/skip-tracker.ts
index 5d485bf22..055a92b46 100644
--- a/packages/db/src/etl/skip-tracker.ts
+++ b/packages/db/src/etl/skip-tracker.ts
@@ -10,6 +10,15 @@ export interface Skips {
   noIslOsl: number;
   failedRun: number;
   dbError: number;
+  /**
+   * PowerX telemetry digest failures, counted apart from `dbError` because they
+   * are not fatal. The benchmark rows land either way; only the per-point
+   * telemetry tab is affected, and the artifact can be re-digested later by
+   * `admin:db:backfill-gpu-metrics`. Folding these into `dbError` would let one
+   * malformed `gpu_metrics_*` CSV turn the whole production ingest red, through
+   * the publication manifest that verify-power-publication treats as fatal.
+   */
+  telemetryError: number;
   /** Agentic point whose sibling `agentic_<suffix>` artifact had no trace_replay files. */
   traceReplayMissing: number;
 }
@@ -35,6 +44,15 @@ export interface SkipTracker {
    * @param err - The caught error.
    */
   recordDbError: (context: string, err: Error) => void;
+  /**
+   * Record a non-fatal PowerX telemetry digest failure. Same printing and
+   * suppression as `recordDbError`, but increments `skips.telemetryError` so the
+   * ingest is not failed by it.
+   *
+   * @param context - Human-readable label for where the error occurred.
+   * @param err - The caught error.
+   */
+  recordTelemetryError: (context: string, err: Error) => void;
   /**
    * Capture a point-in-time snapshot of the current skip counters and
    * unmapped-name sets. Used together with `diff()` to report per-artifact drops.
@@ -76,12 +94,14 @@ export function createSkipTracker(): SkipTracker {
     noIslOsl: 0,
     failedRun: 0,
     dbError: 0,
+    telemetryError: 0,
     traceReplayMissing: 0,
   };
   const unmappedModels = new Set<string>();
   const unmappedHws = new Set<string>();
   const unmappedPrecisions = new Set<string>();
   let dbErrorsPrinted = 0;
+  let telemetryErrorsPrinted = 0;
 
   return {
     skips,
@@ -100,6 +120,19 @@ export function createSkipTracker(): SkipTracker {
       }
     },
 
+    recordTelemetryError(context: string, err: Error): void {
+      skips.telemetryError++;
+      if (telemetryErrorsPrinted < MAX_DB_ERRORS) {
+        console.error(`  [TELEMETRY] ${context}: ${err.message}`);
+        telemetryErrorsPrinted++;
+        if (telemetryErrorsPrinted === MAX_DB_ERRORS) {
+          console.error(
+            '  [TELEMETRY] further telemetry errors suppressed; count included in summary',
+          );
+        }
+      }
+    },
+
     snapshot(): SkipSnapshot {
       return {
         model: skips.unmappedModel,
diff --git a/packages/db/src/ingest-ci-run.test.ts b/packages/db/src/ingest-ci-run.test.ts
index d3ad330b4..19812f372 100644
--- a/packages/db/src/ingest-ci-run.test.ts
+++ b/packages/db/src/ingest-ci-run.test.ts
@@ -53,6 +53,7 @@ describe('purged CI ingestion', () => {
           runAttempt,
           points: [],
           ingestErrors: [],
+          telemetryWarnings: [],
         });
       } finally {
         fs.rmSync(dir, { recursive: true, force: true });
diff --git a/packages/db/src/ingest-ci-run.ts b/packages/db/src/ingest-ci-run.ts
index debb9f463..c2ae094a7 100644
--- a/packages/db/src/ingest-ci-run.ts
+++ b/packages/db/src/ingest-ci-run.ts
@@ -715,7 +715,12 @@ async function main(): Promise<void> {
                     `${ingested.seriesSkipped} unchanged (${elapsed(gpuMetricsStart)})`,
                 );
               } catch (error: any) {
-                tracker.recordDbError(`gpu_metrics for ${configKey}`, error);
+                // Non-fatal on purpose: this point's benchmark rows are already
+                // committed and only its telemetry tab is affected, and
+                // `admin:db:backfill-gpu-metrics --run <id>` can re-digest the
+                // artifact later. Recording it as a DB error instead would reach
+                // the publication manifest and fail the whole production ingest.
+                tracker.recordTelemetryError(`gpu_metrics for ${configKey}`, error);
               }
             }
           }
@@ -1110,6 +1115,10 @@ main()
               ...powerPublicationErrors,
               ...(tracker.skips.dbError ? [`${tracker.skips.dbError} database ingest errors`] : []),
             ],
+            // Reported but not fatal — see Skips.telemetryError.
+            telemetryWarnings: tracker.skips.telemetryError
+              ? [`${tracker.skips.telemetryError} gpu_metrics digest errors`]
+              : [],
           },
           null,
           2,
diff --git a/packages/db/src/ingest-gcs-backup.ts b/packages/db/src/ingest-gcs-backup.ts
index 709fdc9c3..b9cb76b59 100644
--- a/packages/db/src/ingest-gcs-backup.ts
+++ b/packages/db/src/ingest-gcs-backup.ts
@@ -104,8 +104,12 @@ interface WorkflowMapResult {
   changelogs: { baseRef: string; headRef: string; entries: ChangelogEntry[] }[];
   /** True when the changelog declares evals-only — benchmark/stats data is dropped. */
   evalsOnly: boolean;
-  /** Skip counts from mapping phase (dbError is tracked separately in phase 2). */
-  localSkips: Omit<Skips, 'dbError'>;
+  /**
+   * Skip counts from the mapping phase. `dbError` is tracked separately in phase 2,
+   * and `telemetryError` never applies here: the GCS backup path ingests no
+   * `gpu_metrics_*` artifacts.
+   */
+  localSkips: Omit<Skips, 'dbError' | 'telemetryError'>;
   localUnmappedModels: Set<string>;
   localUnmappedHws: Set<string>;
   /** Pre-formatted [WARN] lines to print at the start of phase 2 for this dir. */
@@ -121,7 +125,7 @@ interface WriteResult {
   evalSamples: number;
   changelogs: number;
   warnings: string[];
-  localSkips: Omit<Skips, 'dbError'>;
+  localSkips: Omit<Skips, 'dbError' | 'telemetryError'>;
   localUnmappedModels: string[];
   localUnmappedHws: string[];
 }
diff --git a/packages/db/src/verify-power-publication.ts b/packages/db/src/verify-power-publication.ts
index fbd34ab68..1beb41e96 100644
--- a/packages/db/src/verify-power-publication.ts
+++ b/packages/db/src/verify-power-publication.ts
@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import { DB_MODEL_TO_DISPLAY } from '@semianalysisai/inferencex-constants';
 import { createAdminSql } from './etl/db-utils';
 import {
+  fatalPublicationErrors,
   verifyPowerPublication,
   type PowerPublicationManifest,
   type PublishedPowerRow,
@@ -35,10 +36,10 @@ try {
       and (br.benchmark_type = 'agentic_traces' or
         (br.benchmark_type = 'single_turn' and br.isl in (1024, 8192) and br.osl = 1024))
   `;
-  const errors = [
-    ...(manifest.ingestErrors ?? []),
-    ...verifyPowerPublication(manifest.points, rows as unknown as PublishedPowerRow[], 'database'),
-  ];
+  const errors = fatalPublicationErrors(
+    manifest,
+    verifyPowerPublication(manifest.points, rows as unknown as PublishedPowerRow[], 'database'),
+  );
   const publicRows: PublishedPowerRow[] = [];
   const models = [
     ...new Set(manifest.points.map((point) => DB_MODEL_TO_DISPLAY[String(point.identity.model)])),
@@ -86,6 +87,9 @@ try {
     status:
       errors.length > 0 ? 'failed' : manifest.points.length > 0 ? 'matched' : 'no_power_points',
     errors,
+    // Kept out of `errors` on purpose: a telemetry digest failure costs one
+    // point's PowerX tab, not its benchmark data, so it must not fail the ingest.
+    telemetryWarnings: manifest.telemetryWarnings ?? [],
   };
   fs.writeFileSync(`${manifestPath}.verification.json`, `${JSON.stringify(receipt, null, 2)}\n`);
   console.log(JSON.stringify(receipt, null, 2));

From af1a56f5c0d541526145bd22a1e55a61bdcd90db Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Mon, 21 Sep 2026 00:07:16 -0700
Subject: [PATCH 018/103] fix: keep a line label on every series instead of
 dropping crowded ones
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The anchor pass in placeLineLabels tried four fractions along each line and, if
all of them collided, emitted visible:false. In the PowerX article's Fig 6 —
roles mode with two ?unofficialrun= overlays, so nine lines whose anchors
compete in one narrow band — that silently cost the GB300 overall series its
pill. Its curve was still drawn, next to two labelled siblings of the same
colour, so the reader could only identify it by elimination.

The drop was a layering mistake. It decided visibility from a crude nominal box
of collisionWidth/2 by 21px, while layoutPills runs right after with the real
measured boxes, mirrors, shifts rows and clamps into the plot, and says in its
own doc comment that an overlapped label beats a missing one. A rendered pill in
this figure measures 223-330px against that 120px model, so the pass that gave
up was the one least able to judge. The same function's pinned-anchor branch
already emits visible:true unconditionally.

A series with no clear slot is now deferred and placed after the clean ones, on
whichever of its slots carries the least overlap, and it no longer anchors on
points[0] — the axis-hugging index lineCandidates deliberately skips. Deferring
matters on its own: a doomed series used to be able to reserve a slot that a
later series could have had to itself. keepVisibleOnCollision is gone; it was
the single-point special case of the rule this generalises.

This ends the promise that line labels never overlap, stated in #132 and
restated in #434. It was worth less than it cost: a dropped pill is silent, and
with line labels on the PNG export omits the legend, so the series loses its
only identifier.

Verified at /inference?i_metric=y_measuredAvgPower&i_pcompare=roles&unofficialruns=
35319969159,35319956855 against the branch DB: 17 labels, all rendered, none
overlapping, including the pill the figure was missing. The 12 pills still
hidden there are the separate GH #470 de-duplication path, which is untouched.
Gates: lint, fmt, typecheck, typography, 6,949 unit tests, 521 Cypress
component tests. Three of the five new unit tests and the new component test
fail on the old code.

中文：placeLineLabels 的锚点阶段沿每条线尝试四个位置，若全部碰撞就发出
visible:false。在 PowerX 文章的 Fig 6 中（roles 模式加两个 ?unofficialrun= 叠加，
九条线的锚点挤在同一窄带里），这让 GB300 整体序列悄悄丢掉了标签。它的曲线仍然
画着，旁边是两条同色且有标签的兄弟线，读者只能靠排除法辨认。

这个丢弃是分层错误。它用 collisionWidth/2 乘 21px 的粗略估算盒来决定可见性，而
紧随其后的 layoutPills 拿着真实测量盒做镜像、错行和边界钳制，其文档注释明确写着
重叠的标签也好过消失的标签。该图里一个实际渲染的标签宽 223 到 330px，而模型只按
120px 估算，所以放弃的恰恰是最没有判断力的那一遍。同一函数的固定锚点分支本来就
无条件发出 visible:true。

现在没有空闲槽位的序列会被推迟到干净标签之后放置，落在重叠代价最小的槽位上，并且
不再锚定到 points[0]——lineCandidates 刻意跳过的贴轴位置。推迟本身也有意义：原先
一个注定重叠的序列可能占掉后面序列本可独享的槽位。keepVisibleOnCollision 已删除，
它只是本规则的单点特例。

这终结了「折线标签永不重叠」的承诺，该承诺由 #132 提出、#434 重申。它的价值抵不上
代价：标签被丢弃是无声的，而开启折线标签后 PNG 导出会省略图例，序列就失去了唯一的
标识。

验证：在指向分支数据库的 /inference?i_metric=y_measuredAvgPower&i_pcompare=roles
&unofficialruns=35319969159,35319956855 上，17 个标签全部渲染、互不覆盖，包括该图
原本缺失的那一个。页面上仍隐藏的 12 个标签来自独立的 GH #470 去重路径，未受影响。
闸门：lint、fmt、typecheck、typography、6,949 个单元测试、521 个 Cypress 组件测试。
五个新单元测试中的三个以及新增的组件测试在旧代码上失败。
---
 .../cypress/component/power-compare.cy.tsx    | 121 +++++++++++++++++-
 .../components/inference/ui/ScatterGraph.tsx  |   2 -
 .../inference/ui/line-label-layer.test.ts     | 118 ++++++++++++++++-
 .../inference/ui/line-label-layer.ts          | 113 +++++++++++-----
 4 files changed, 312 insertions(+), 42 deletions(-)

diff --git a/packages/app/cypress/component/power-compare.cy.tsx b/packages/app/cypress/component/power-compare.cy.tsx
index d14304e38..cca91215d 100644
--- a/packages/app/cypress/component/power-compare.cy.tsx
+++ b/packages/app/cypress/component/power-compare.cy.tsx
@@ -126,6 +126,8 @@ function mountCompare(
     metric?: CompareMetric;
     lineLabels?: boolean;
     precisions?: Precision[];
+    /** Extra `?unofficialrun=` runs beyond the default one, for multi-run tests. */
+    extraRuns?: { id: number; url: string; hwKeys: string[] }[];
   } = {},
 ) {
   const metricKey = options.metric ?? 'y_measuredAvgPower';
@@ -165,9 +167,24 @@ function mountCompare(
       unofficial: options.overlay
         ? {
             isUnofficialRun: true,
-            activeOverlayHwTypes: new Set(['h100']),
-            allOverlayHwTypes: new Set(['h100']),
-            runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [String(OVERLAY_RUN_ID)]: 0 },
+            activeOverlayHwTypes: new Set([
+              'h100',
+              ...(options.extraRuns ?? []).flatMap((run) => run.hwKeys),
+            ]),
+            allOverlayHwTypes: new Set([
+              'h100',
+              ...(options.extraRuns ?? []).flatMap((run) => run.hwKeys),
+            ]),
+            runIndexByUrl: {
+              [OVERLAY_RUN_URL]: 0,
+              [String(OVERLAY_RUN_ID)]: 0,
+              ...Object.fromEntries(
+                (options.extraRuns ?? []).flatMap((run, index) => [
+                  [run.url, index + 1],
+                  [String(run.id), index + 1],
+                ]),
+              ),
+            },
             unofficialRunInfos: [
               {
                 id: OVERLAY_RUN_ID,
@@ -180,6 +197,17 @@ function mountCompare(
                 status: 'completed',
                 isNonMainBranch: true,
               },
+              ...(options.extraRuns ?? []).map((run) => ({
+                id: run.id,
+                name: `powerx-compare-${run.id}`,
+                branch: `powerx-compare-${run.id}`,
+                sha: 'abc001',
+                createdAt: '2026-09-02T00:00:00Z',
+                url: run.url,
+                conclusion: 'success' as const,
+                status: 'completed' as const,
+                isNonMainBranch: true,
+              })),
             ],
           }
         : {},
@@ -500,6 +528,93 @@ describe('ScatterGraph power comparison series', () => {
       });
   });
 
+  /**
+   * Regression for the PowerX article's Fig 6. Two `?unofficialrun=` overlays in
+   * roles mode draw six lines, and the anchor pass used to hide whichever series
+   * ran out of anchor slots — in the exported figure that was the GB300 overall
+   * line, leaving a drawn curve the reader could only identify by elimination.
+   *
+   * `crowdedCurve` reproduces the shape that causes it, which a gently spread
+   * curve does not: power falls steeply with interactivity, so every series'
+   * anchors land in the top slice of a tall y domain and compete for the same
+   * few x positions. Pills stay in the DOM at opacity 0 when hidden, so counting
+   * nodes cannot see this bug; the assertions below are on `data-visible`.
+   */
+  const crowdedCurve = (hwKey: string, runUrl: string, offset: number): InferenceData[] =>
+    [
+      [8, 840, 848, 832],
+      [16, 700, 712, 690],
+      [32, 470, 486, 458],
+      [64, 330, 344, 318],
+      [128, 250, 262, 240],
+    ].map(([x, measured, prefill, decode]) =>
+      createMockInferenceData({
+        hwKey,
+        x,
+        conc: x,
+        y: measured + offset,
+        precision: Precision.FP4,
+        run_url: runUrl,
+        disagg: true,
+        measuredAvgPower: metric(measured + offset),
+        measuredPrefillAvgPower: metric(prefill + offset),
+        measuredDecodeAvgPower: metric(decode + offset),
+        gpuProvisionedWatts: metric(1000),
+        utilityProvisionedWatts: metric(1710),
+      }),
+    );
+
+  it('keeps a visible pill on all three role series of every ?unofficialrun= overlay', () => {
+    const secondRunId = 27182818284;
+    const secondRunUrl = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${secondRunId}`;
+    const overlay = [
+      ...expandPowerCompareSeries(
+        crowdedCurve('h100', OVERLAY_RUN_URL, 0),
+        'y_measuredAvgPower',
+        'roles',
+      ),
+      ...expandPowerCompareSeries(
+        crowdedCurve('b200', secondRunUrl, 6),
+        'y_measuredAvgPower',
+        'roles',
+      ),
+    ];
+    mountCompare([], {
+      overlay,
+      lineLabels: true,
+      extraRuns: [{ id: secondRunId, url: secondRunUrl, hwKeys: ['b200'] }],
+    });
+
+    cy.get(lineLabels).should('have.length', 6);
+    cy.get(`${lineLabels}[data-visible="1"]`).should('have.length', 6);
+    // The two "overall" pills are the ones the old anchor pass dropped.
+    cy.get(`${svg} ${labelSelector('')}[data-visible="1"]`).should('have.length', 2);
+    // A kept pill is only worth keeping if it is on the chart. (layoutPills'
+    // clamp is unit-tested against the exact clip rect in
+    // line-label-pill-bounds.test.ts; this is the coarse check that nothing was
+    // pushed off the chart entirely.)
+    cy.get(svg).then(($svg) => {
+      const chart = $svg[0].getBoundingClientRect();
+      cy.get(`${lineLabels}[data-visible="1"] .ll-bg`).each(($bg) => {
+        const box = $bg[0].getBoundingClientRect();
+        expect(box.left, 'pill left inside chart').to.be.at.least(chart.left - 1);
+        expect(box.right, 'pill right inside chart').to.be.at.most(chart.right + 1);
+        expect(box.top, 'pill top inside chart').to.be.at.least(chart.top - 1);
+        expect(box.bottom, 'pill bottom inside chart').to.be.at.most(chart.bottom + 1);
+      });
+    });
+    // Both runs contribute all three roles, keyed by line so the runs stay apart.
+    cy.get(`${lineLabels}[data-visible="1"]`).then(($labels) => {
+      const byLine = [...$labels].map((node) => ({
+        line: (node as HTMLElement).dataset.lineKey ?? '',
+        text: pillText(node),
+      }));
+      expect(new Set(byLine.map((entry) => entry.line)).size, 'distinct line keys').to.eq(6);
+      expect(byLine.filter((entry) => /H100/u.test(entry.text)).length).to.eq(3);
+      expect(byLine.filter((entry) => /B200/u.test(entry.text)).length).to.eq(3);
+    });
+  });
+
   it('labels ?unofficialrun= comparison siblings with the marked hardware and the variant', () => {
     const overlay = expandPowerCompareSeries(
       measuredCurve('h100', { run_url: OVERLAY_RUN_URL }),
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 301e55652..e39bd894f 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -2911,7 +2911,6 @@ const ScatterGraph = React.memo(
                 )}${suffix}`,
                 color: ir.getCssColor(ir.resolveColor(entry.hw)),
                 points: entry.points,
-                keepVisibleOnCollision: entry.points.length === 1,
               };
             });
             // Runs drawing the same hardware need a run tag on their pills.
@@ -3221,7 +3220,6 @@ const ScatterGraph = React.memo(
                 ...entry,
                 label: '',
                 color: '',
-                keepVisibleOnCollision: entry.points.length === 1,
               }),
             );
             const overlaySeries: LineLabelSeries<InferenceData>[] = Object.entries(
diff --git a/packages/app/src/components/inference/ui/line-label-layer.test.ts b/packages/app/src/components/inference/ui/line-label-layer.test.ts
index 33bb77256..0518b4ea5 100644
--- a/packages/app/src/components/inference/ui/line-label-layer.test.ts
+++ b/packages/app/src/components/inference/ui/line-label-layer.test.ts
@@ -14,17 +14,12 @@ interface Point {
   y: number;
 }
 
-const series = (
-  key: string,
-  points: Point[],
-  keepVisibleOnCollision = false,
-): LineLabelSeries<Point> => ({
+const series = (key: string, points: Point[]): LineLabelSeries<Point> => ({
   key,
   seriesId: key,
   label: key,
   color: '#000',
   points,
-  keepVisibleOnCollision,
 });
 
 const identity = (value: number) => value;
@@ -185,4 +180,115 @@ describe('line-label placement', () => {
 
     expect(labels[0]).toMatchObject({ x: 5, y: 7, visible: true });
   });
+
+  /**
+   * Regression for the PowerX roles-mode figure: with two `?unofficialrun=`
+   * overlays the chart draws nine lines whose first points sit in one narrow
+   * band, every anchor slot is taken, and one series lost its pill entirely —
+   * leaving a drawn line the reader could not identify.
+   *
+   * `band` reproduces that shape: same x sweep for everyone, y values packed
+   * inside one collision height.
+   */
+  describe('crowded series', () => {
+    const band = (key: string, y: number) =>
+      series(
+        key,
+        [0, 25, 50, 75, 100].map((x) => ({ x, y })),
+      );
+    const KEYS = ['a', 'b', 'c', 'd', 'e', 'f'];
+    const crowd = () =>
+      placeLineLabels(
+        KEYS.map((key, index) => band(key, 100 + index * 4)),
+        identity,
+        identity,
+        { collisionWidth: 120 },
+      );
+
+    it('keeps a pill for every series when every anchor slot is taken', () => {
+      const labels = crowd();
+
+      expect(labels).toHaveLength(KEYS.length);
+      expect(labels.every((label) => label.visible)).toBe(true);
+      expect(new Set(labels.map((label) => label.key))).toEqual(new Set(KEYS));
+    });
+
+    it("never anchors a crowded label on the line's first point", () => {
+      // x = 0 is points[0], the axis-hugging index lineCandidates excludes.
+      expect(crowd().every((label) => label.x > 0)).toBe(true);
+    });
+
+    it('puts a crowded label on the least crowded of its slots', () => {
+      // Slots 100px apart so a 40px collision reach cannot bleed between them.
+      // Every slot is occupied, so there is no clear choice; slot 200 carries
+      // one obstacle against three on the first slot tried and two on the rest,
+      // so only a scored fallback lands there.
+      const spread = series(
+        'only',
+        [0, 100, 200, 300, 400].map((x) => ({ x, y: 100 })),
+      );
+      const labels = placeLineLabels([spread], identity, identity, {
+        collisionWidth: 40,
+        collisionHeight: 20,
+        obstacles: [
+          { x: 100, y: 100, halfW: 20 },
+          { x: 100, y: 105, halfW: 20 },
+          { x: 100, y: 110, halfW: 20 },
+          { x: 200, y: 100, halfW: 20 },
+          { x: 300, y: 100, halfW: 20 },
+          { x: 300, y: 105, halfW: 20 },
+          { x: 400, y: 100, halfW: 20 },
+          { x: 400, y: 105, halfW: 20 },
+        ],
+      });
+
+      expect(labels[0]).toMatchObject({ x: 200, visible: true });
+    });
+
+    /**
+     * `clean` starts below the whole band, so the y sort puts it LAST. Both
+     * tests below would pass trivially if it sorted first; placing it last is
+     * what makes them discriminate against the obvious wrong fix, which is to
+     * emit a crowded label in sort order the moment its slots run out.
+     */
+    const clean = () =>
+      series('clean', [
+        { x: 0, y: 900 },
+        { x: 100, y: 1000 },
+      ]);
+
+    it('lets a clean label keep its slot when earlier series have no slot at all', () => {
+      const alone = placeLineLabels([clean()], identity, identity, { collisionWidth: 120 });
+      const withCrowd = placeLineLabels(
+        [...KEYS.map((key, index) => band(key, 100 + index * 4)), clean()],
+        identity,
+        identity,
+        { collisionWidth: 120 },
+      );
+
+      // A crowded series must not consume a slot that a later series could
+      // have had to itself, so `clean` lands exactly where it would alone.
+      expect(withCrowd.find((label) => label.key === 'clean')).toMatchObject({
+        x: alone[0].x,
+        y: alone[0].y,
+        visible: true,
+      });
+    });
+
+    it('emits crowded labels after the clean ones regardless of sort order', () => {
+      // updateRenderedLineLabels lays pills out in this order, so the labels
+      // that will have to move are handed to it last.
+      const labels = placeLineLabels(
+        [...KEYS.map((key, index) => band(key, 100 + index * 4)), clean()],
+        identity,
+        identity,
+        { collisionWidth: 120 },
+      );
+
+      const keys = labels.map((label) => label.key);
+      expect(keys[0]).toBe('a');
+      expect(keys[1]).toBe('clean');
+      expect(keys.slice(2)).toEqual(['b', 'c', 'd', 'e', 'f']);
+    });
+  });
 });
diff --git a/packages/app/src/components/inference/ui/line-label-layer.ts b/packages/app/src/components/inference/ui/line-label-layer.ts
index 2db4806a8..7ac0d0d85 100644
--- a/packages/app/src/components/inference/ui/line-label-layer.ts
+++ b/packages/app/src/components/inference/ui/line-label-layer.ts
@@ -15,7 +15,6 @@ export interface LineLabelSeries<TPoint extends CartesianPoint> {
   label: string;
   color: string;
   points: readonly TPoint[];
-  keepVisibleOnCollision?: boolean;
 }
 
 export interface LineLabelPlacement {
@@ -25,6 +24,12 @@ export interface LineLabelPlacement {
   color: string;
   x: number;
   y: number;
+  /**
+   * `placeLineLabels` always emits `true`: every series it is given keeps its
+   * pill, overlapping if it must. The only producer of `false` is the caller's
+   * de-duplication pass, which keeps a hidden data-join entry for a curve that
+   * lost the one-label-per-hardware contest (GH #470).
+   */
   visible: boolean;
 }
 
@@ -145,16 +150,16 @@ interface PillLayoutItem {
  * its anchor, and both mirrors together. Every candidate is clamped into
  * `bounds` before the overlap test, so nothing leaves the plot. When every
  * mirrored candidate collides, nearby rows are tried before the default spot
- * is kept: an overlapped label is still
- * better than a missing one, and the fallback matches what the anchor pass
- * already tolerates for pinned anchors.
+ * is kept: an overlapped label is still better than a missing one, and the
+ * fallback matches what the anchor pass already tolerates.
  *
  * With no bounds — a chart that clips nothing — the anchor offset is applied
  * unchanged and the collision pass is skipped, preserving that chart's
  * existing layout.
  *
  * Hidden pills get their default transform and occupy no space, so a label
- * that later becomes visible reappears where the anchor pass put it.
+ * that later becomes visible reappears where the anchor pass put it. Only the
+ * caller's de-duplication pass hides pills; the anchor pass never does.
  */
 function layoutPills(
   items: readonly PillLayoutItem[],
@@ -318,6 +323,21 @@ function lineCandidates<TPoint extends CartesianPoint>(
   return candidates;
 }
 
+/**
+ * Anchor one pill per series along its line.
+ *
+ * Each series tries `ANCHOR_SLOTS` fractions along its own points, rotated by
+ * its index so converging curves spread out instead of stacking at the
+ * endpoint. A series that finds a clear slot takes it. A series that finds none
+ * is deferred and placed afterwards on its least crowded slot, so it never
+ * steals a clear slot from a series that could have used it.
+ *
+ * Every series gets a visible pill. The overlap that survives here is resolved
+ * by `layoutPills`, which runs later with the pills' real measured boxes; the
+ * crude nominal box used here is far too small to decide that a label is
+ * unplaceable — a rendered pill is routinely two to three times
+ * `collisionWidth`.
+ */
 export function placeLineLabels<TPoint extends CartesianPoint>(
   series: readonly LineLabelSeries<TPoint>[],
   xScale: (value: number) => number,
@@ -345,6 +365,35 @@ export function placeLineLabels<TPoint extends CartesianPoint>(
         Math.abs(other.y - y) < collisionHeight &&
         Math.abs(other.x - x) < other.halfW + labelHalfWidth,
     );
+  /**
+   * Nominal overlap area against the labels already placed. The same crude box
+   * model as `collides`, scored instead of thresholded, so a slot that clips one
+   * neighbour is preferred over one that sits on three.
+   */
+  const collisionCost = (x: number, y: number) =>
+    placed.reduce((cost, other) => {
+      const dx = other.halfW + labelHalfWidth - Math.abs(other.x - x);
+      const dy = collisionHeight - Math.abs(other.y - y);
+      return dx > 0 && dy > 0 ? cost + dx * dy : cost;
+    }, 0);
+
+  const emit = (entry: LineLabelSeries<TPoint>, point: TPoint) => {
+    const x = xScale(point.x);
+    const y = yScale(point.y);
+    placed.push({ x, y, halfW: labelHalfWidth });
+    result.push({
+      key: entry.key,
+      seriesId: entry.seriesId,
+      label: entry.label,
+      color: entry.color,
+      x,
+      y,
+      visible: true,
+    });
+  };
+
+  /** Series with no clear slot, deferred to a second pass — see below. */
+  const crowded: { entry: LineLabelSeries<TPoint>; candidates: TPoint[] }[] = [];
 
   for (const [seriesIndex, entry] of sorted.entries()) {
     if (entry.points.length === 0) continue;
@@ -375,35 +424,37 @@ export function placeLineLabels<TPoint extends CartesianPoint>(
 
     const candidate = candidates.find((point) => !collides(xScale(point.x), yScale(point.y)));
     if (candidate) {
-      const x = xScale(candidate.x);
-      const y = yScale(candidate.y);
-      placed.push({ x, y, halfW: labelHalfWidth });
-      result.push({
-        key: entry.key,
-        seriesId: entry.seriesId,
-        label: entry.label,
-        color: entry.color,
-        x,
-        y,
-        visible: true,
-      });
+      emit(entry, candidate);
       continue;
     }
 
-    const fallback = entry.points[0];
-    const x = xScale(fallback.x);
-    const y = yScale(fallback.y);
-    const visible = entry.keepVisibleOnCollision === true;
-    if (visible) placed.push({ x, y, halfW: labelHalfWidth });
-    result.push({
-      key: entry.key,
-      seriesId: entry.seriesId,
-      label: entry.label,
-      color: entry.color,
-      x,
-      y,
-      visible,
-    });
+    // No clear slot. Defer rather than claim one now: a series that is going to
+    // overlap something must not take a slot a later series could have had to
+    // itself.
+    crowded.push({ entry, candidates });
+  }
+
+  // Every series keeps a pill. `layoutPills` runs after this with the real
+  // measured boxes and can still mirror it, shift it a row and clamp it into the
+  // plot — "an overlapped label is still better than a missing one". Emitting the
+  // crowded ones last also hands that pass the clean labels first, so the crowded
+  // ones do the moving.
+  //
+  // This is where the chart stopped promising that line labels never overlap
+  // (#132 introduced the drop as the only way to honour that, #434 restated it).
+  // The promise was worth less than it cost: a dropped pill is silent, and with
+  // line labels on, PNG export omits the legend, so the series loses its only
+  // identifier. An overlapping pill at least announces itself.
+  for (const { entry, candidates } of crowded) {
+    emit(
+      entry,
+      candidates.reduce((best, point) =>
+        collisionCost(xScale(point.x), yScale(point.y)) <
+        collisionCost(xScale(best.x), yScale(best.y))
+          ? point
+          : best,
+      ),
+    );
   }
 
   return result;

From 9bbc2290ca4af9a4d048aac8e934860086571e78 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Mon, 21 Sep 2026 00:28:54 -0700
Subject: [PATCH 019/103] refactor: remove unused PowerX telemetry helpers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove unused availability and sample-omission paths, identity wrappers,
test-only label/source helpers, and write-only telemetry fields. Keep label
formatting and nested-source coverage on the production helpers, preserve
artifact failure isolation, and refresh the unchanged API contract digest.

中文：删除未使用的 PowerX 遥测查询模式、包装函数与只写不读的字段；
将标签格式及嵌套路径测试迁到实际生产入口，保留逐产物错误隔离，
并同步 API 路由摘要。此次仅落实精简清单 1–8。
---
 docs/powerx-permanent-view.md                 |  2 +-
 packages/app/src/app/api/gpu-metrics/route.ts | 19 +++------
 .../components/gpu-power/GpuPowerChart.tsx    |  1 -
 .../agentic-point/power-telemetry-view.tsx    |  2 -
 .../inference/utils/power-compare.test.ts     | 36 ++++++++---------
 .../inference/utils/power-compare.ts          | 18 ---------
 .../inference/utils/powerTimeline.test.ts     | 36 ++++++-----------
 .../inference/utils/powerTimeline.ts          |  8 ----
 packages/app/src/lib/api-route-catalog.ts     |  2 +-
 packages/db/src/etl/gpu-metrics-ingest.ts     | 32 +++++++--------
 packages/db/src/queries/gpu-metrics.test.ts   | 32 +--------------
 packages/db/src/queries/gpu-metrics.ts        | 40 +++++--------------
 12 files changed, 63 insertions(+), 165 deletions(-)

diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 9559fb31e..0325c4a84 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -146,7 +146,7 @@ was previously split on `_`. Siblings keep the hardware colour (overlay runs kee
 colour) and take a per-variant `stroke-dasharray` (`powerVariantDash`); clone points render
 at 0.6 opacity behind their base and carry `data-power-variant`. Line labels are placed per
 hardware _and_ sibling: the base series keeps its plain hardware label, while a sibling appends
-` · <short name>` (`powerLineLabel`: TDP, All-in, PUE modeled, Prefill GPUs, …) and, when a
+` · <short name>` (`powerLineLabelSuffix`: TDP, All-in, PUE modeled, Prefill GPUs, …) and, when a
 boundary is flat on a watts axis, its shared value (`B300 (SGLang) · TDP 1.2 kW`), so an exported
 PNG explains its dashed lines without the legend; each pill carries `data-series-id`
 (`<hw>::<variant>` for a sibling) and `data-power-variant`. The legend appends one
diff --git a/packages/app/src/app/api/gpu-metrics/route.ts b/packages/app/src/app/api/gpu-metrics/route.ts
index 87488e11c..ac13862cb 100644
--- a/packages/app/src/app/api/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.ts
@@ -196,25 +196,18 @@ async function downloadBundle(
  */
 async function runJob(job: TelemetryJob, githubToken: string): Promise<TelemetryResult | null> {
   try {
-    return await runJobUnguarded(job, githubToken);
+    if (job.kind === 'csv') {
+      const parsed = await downloadArtifact(job.artifact, githubToken);
+      return parsed ? { kind: 'csv', parsed } : null;
+    }
+    const series = await downloadBundle(job.artifact, githubToken);
+    return series ? { kind: 'bundle', series } : null;
   } catch (error) {
     console.warn(`Failed to read artifact ${job.artifact.name}:`, error);
     return null;
   }
 }
 
-async function runJobUnguarded(
-  job: TelemetryJob,
-  githubToken: string,
-): Promise<TelemetryResult | null> {
-  if (job.kind === 'csv') {
-    const parsed = await downloadArtifact(job.artifact, githubToken);
-    return parsed ? { kind: 'csv', parsed } : null;
-  }
-  const series = await downloadBundle(job.artifact, githubToken);
-  return series ? { kind: 'bundle', series } : null;
-}
-
 /** Downloads in listing order with a bounded number of requests in flight. */
 async function downloadTelemetry(
   jobs: TelemetryJob[],
diff --git a/packages/app/src/components/gpu-power/GpuPowerChart.tsx b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
index addb25953..a1209ec78 100644
--- a/packages/app/src/components/gpu-power/GpuPowerChart.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
@@ -60,7 +60,6 @@ const STRINGS = {
 
 /** A second time series drawn over the telemetry on its own right-hand axis. */
 export interface TelemetryOverlaySeries {
-  key: string;
   label: string;
   unit: string;
   color: string;
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
index a2c437f72..831fa1cc0 100644
--- a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -107,7 +107,6 @@ export function collectorLabel(series: Pick<GpuMetricSeries, 'vendor' | 'sidecar
   if (typeof producer === 'string' && producer.trim() !== '') return producer;
   return VENDOR_LABEL[series.vendor] ?? series.vendor;
 }
-/** Violet: outside the Tableau10 chip palette and the foreground mean line. */
 
 interface Props {
   id: number;
@@ -199,7 +198,6 @@ export function PowerTelemetryView({ id, enabled, hardware }: Props) {
       ? serverMetrics.startNs / 1e6
       : new Date(selectedSeries.startedAt).getTime();
     return {
-      key: overlaySource.key,
       label: overlaySourceLabel(overlaySource, locale),
       unit: overlaySource.unit,
       color: overlaySource.color,
diff --git a/packages/app/src/components/inference/utils/power-compare.test.ts b/packages/app/src/components/inference/utils/power-compare.test.ts
index 6b7c76153..72683486a 100644
--- a/packages/app/src/components/inference/utils/power-compare.test.ts
+++ b/packages/app/src/components/inference/utils/power-compare.test.ts
@@ -19,7 +19,6 @@ import {
   powerCompareAvailable,
   powerCompareBase,
   powerCompareVariants,
-  powerLineLabel,
   powerLineLabelSuffix,
   powerSeriesLabel,
   powerVariantDash,
@@ -224,36 +223,35 @@ describe('line labels', () => {
     expect(formatWatts(100000)).toBe('100 kW');
   });
 
-  it('leaves the base label alone and suffixes a sibling with its variant and flat watts', () => {
-    const label = 'B300 (SGLang)';
+  it('omits the base suffix and labels a sibling with its variant and flat watts', () => {
     const tdp = basis('gpu-provisioned');
-    expect(powerLineLabel(label, undefined, { isBase: true, locale: 'en' })).toBe(label);
-    expect(powerLineLabel(label, null, { isBase: false, locale: 'en' })).toBe(label);
+    expect(powerLineLabelSuffix(undefined, { isBase: true, locale: 'en' })).toBe('');
+    expect(powerLineLabelSuffix(null, { isBase: false, locale: 'en' })).toBe('');
     // A variant that is itself the base series keeps the plain label.
-    expect(powerLineLabel(label, tdp, { isBase: true, locale: 'en', flatWatts: 1200 })).toBe(label);
-    expect(powerLineLabel(label, tdp, { isBase: false, locale: 'en' })).toBe('B300 (SGLang) · TDP');
-    expect(powerLineLabel(label, tdp, { isBase: false, locale: 'en', flatWatts: 700 })).toBe(
-      'B300 (SGLang) · TDP 700 W',
+    expect(powerLineLabelSuffix(tdp, { isBase: true, locale: 'en', flatWatts: 1200 })).toBe('');
+    expect(powerLineLabelSuffix(tdp, { isBase: false, locale: 'en' })).toBe(' · TDP');
+    expect(powerLineLabelSuffix(tdp, { isBase: false, locale: 'en', flatWatts: 700 })).toBe(
+      ' · TDP 700 W',
     );
-    expect(powerLineLabel(label, tdp, { isBase: false, locale: 'en', flatWatts: 1370 })).toBe(
-      'B300 (SGLang) · TDP 1.37 kW',
+    expect(powerLineLabelSuffix(tdp, { isBase: false, locale: 'en', flatWatts: 1370 })).toBe(
+      ' · TDP 1.37 kW',
     );
     expect(
-      powerLineLabel(label, basis('utility-provisioned'), {
+      powerLineLabelSuffix(basis('utility-provisioned'), {
         isBase: false,
         locale: 'zh',
         flatWatts: 19200,
       }),
-    ).toBe('B300 (SGLang) · 全站 19.2 kW');
+    ).toBe(' · 全站 19.2 kW');
     // Non-finite or null watts drop the value, never print NaN.
-    expect(powerLineLabel(label, tdp, { isBase: false, locale: 'en', flatWatts: null })).toBe(
-      'B300 (SGLang) · TDP',
+    expect(powerLineLabelSuffix(tdp, { isBase: false, locale: 'en', flatWatts: null })).toBe(
+      ' · TDP',
     );
-    expect(powerLineLabel(label, tdp, { isBase: false, locale: 'en', flatWatts: NaN })).toBe(
-      'B300 (SGLang) · TDP',
+    expect(powerLineLabelSuffix(tdp, { isBase: false, locale: 'en', flatWatts: NaN })).toBe(
+      ' · TDP',
     );
-    expect(powerLineLabel(label, role('decode'), { isBase: false, locale: 'en' })).toBe(
-      'B300 (SGLang) · Decode GPUs',
+    expect(powerLineLabelSuffix(role('decode'), { isBase: false, locale: 'en' })).toBe(
+      ' · Decode GPUs',
     );
     // The suffix alone is what the renderer splits into its own text segment.
     expect(powerLineLabelSuffix(role('prefill'), { isBase: false, locale: 'zh' })).toBe(
diff --git a/packages/app/src/components/inference/utils/power-compare.ts b/packages/app/src/components/inference/utils/power-compare.ts
index 19300b8cd..d0dea0b73 100644
--- a/packages/app/src/components/inference/utils/power-compare.ts
+++ b/packages/app/src/components/inference/utils/power-compare.ts
@@ -25,7 +25,6 @@ import {
 
 import { getMeasuredMetricConfig } from '../measured-metric-config';
 import type { InferenceData, PowerCompare, PowerRole, PowerVariant } from '../types';
-import { reconstructedRoleEnergy } from './role-energy';
 
 export const POWER_COMPARE_MODES = [
   'none',
@@ -286,18 +285,6 @@ export function powerLineLabelSuffix(
   return `${LINE_LABEL_SUFFIX_SEPARATOR}${powerVariantShortLabel(variant, opts.locale)}${watts}`;
 }
 
-/**
- * Line-label text for one drawn series: the hardware label alone for the base
- * series, `<label> · <variant>` for a sibling, plus the flat watts when known.
- */
-export function powerLineLabel(
-  baseLabel: string,
-  variant: PowerVariant | null | undefined,
-  opts: PowerLineLabelOptions,
-): string {
-  return `${baseLabel}${powerLineLabelSuffix(variant, opts)}`;
-}
-
 const LINE_LABEL_SERIES_DELIMITER = '::';
 
 /**
@@ -337,8 +324,3 @@ export function powerSeriesLabel(
   const variant = point.powerVariant ?? powerCompareBase(metric, mode);
   return variant ? powerVariantLabel(variant, locale) : '';
 }
-
-/** Prefill share of the reconstructed request energy for a role-energy point, in percent. */
-export function reconstructedPrefillShare(point: InferenceData): number | null {
-  return reconstructedRoleEnergy(point)?.prefillShare ?? null;
-}
diff --git a/packages/app/src/components/inference/utils/powerTimeline.test.ts b/packages/app/src/components/inference/utils/powerTimeline.test.ts
index 97b062a49..d0b37bd9f 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.test.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.test.ts
@@ -16,7 +16,6 @@ import {
   requestPowerTraceFocus,
   runIdFromUrl,
   telemetryArtifactForPoint,
-  telemetrySourceForPoint,
   traceConfigLabel,
   traceKeyForPoint,
   traceKeyRunId,
@@ -93,12 +92,10 @@ describe('planPowerTimelineRequests', () => {
       {
         runId: '1',
         prefix: 'dsr1_1k1k_fp8_sglang_conc8_h200-x',
-        artifacts: ['gpu_metrics_dsr1_1k1k_fp8_sglang_conc8_h200-x'],
       },
       {
         runId: '34716669498',
         prefix: 'qwen3.5_8k1k_fp8_',
-        artifacts: [`gpu_metrics_${NAME_B}`, `gpu_metrics_${NAME_A}`],
       },
     ]);
   });
@@ -185,15 +182,8 @@ describe('joinPowerTimeline', () => {
 });
 
 describe('trace identity helpers', () => {
-  it('names the validation file and the run-scoped trace key of a point', () => {
+  it('names the run-scoped trace key of a point', () => {
     const audited = point({ power_audit: { source: `power_validation_${NAME_A}.json` } });
-    expect(telemetrySourceForPoint(audited)).toBe(`power_validation_${NAME_A}.json`);
-    // A path prefix is dropped: bundle-cut series carry the basename.
-    expect(
-      telemetrySourceForPoint({
-        power_audit: { source: `nested/power_validation_${NAME_B}.json` },
-      }),
-    ).toBe(`power_validation_${NAME_B}.json`);
     expect(traceKeyForPoint(audited)).toBe(`34716669498:${NAME_A}`);
   });
 
@@ -202,7 +192,6 @@ describe('trace identity helpers', () => {
       null,
     );
     expect(traceKeyForPoint(point({ power_audit: { source: 'agg_results.json' } }))).toBeNull();
-    expect(telemetrySourceForPoint({})).toBeNull();
   });
 });
 
@@ -231,15 +220,18 @@ describe('joinPowerTimeline with bundle-cut series', () => {
   };
   const disagg = point({ conc: 1, disagg: true, power_audit: { source: bundleSource } });
 
-  it('matches a series by its validation-file source', () => {
-    const { traces, missing } = joinPowerTimeline(
-      [disagg],
-      new Map([['34716669498', { runInfo, series: [bundleSeries] }]]),
-    );
-    expect(missing).toEqual([]);
-    expect(traces[0].series).toBe(bundleSeries);
-    expect(traces[0].key).toBe(`34716669498:${NAME_B}`);
-  });
+  it.each(['', 'nested/'])(
+    'matches a series by its validation-file source with prefix %s',
+    (prefix) => {
+      const { traces, missing } = joinPowerTimeline(
+        [{ ...disagg, power_audit: { source: `${prefix}${bundleSource}` } }],
+        new Map([['34716669498', { runInfo, series: [bundleSeries] }]]),
+      );
+      expect(missing).toEqual([]);
+      expect(traces[0].series).toBe(bundleSeries);
+      expect(traces[0].key).toBe(`34716669498:${NAME_B}`);
+    },
+  );
 
   it('prefers the source match over a gpu_metrics artifact of the same name', () => {
     const { traces } = joinPowerTimeline(
@@ -320,7 +312,6 @@ describe('prioritizeRuns', () => {
   const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
     runId,
     prefix: '',
-    artifacts: [],
   }));
 
   it('moves overlay runs ahead of official runs and keeps both orders', () => {
@@ -350,7 +341,6 @@ describe('prioritizeRun', () => {
   const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
     runId,
     prefix: '',
-    artifacts: [],
   }));
 
   it('moves the deep-linked run to the front and keeps the rest in order', () => {
diff --git a/packages/app/src/components/inference/utils/powerTimeline.ts b/packages/app/src/components/inference/utils/powerTimeline.ts
index 937647f8c..43e6cb6d4 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.ts
@@ -41,12 +41,6 @@ export function telemetryArtifactForPoint(point: AuditedPoint): string | null {
   return name ? `${ARTIFACT_PREFIX}${name}` : null;
 }
 
-/** Basename of a point's audit source, as a bundle-cut series carries it in `source`. */
-export function telemetrySourceForPoint(point: AuditedPoint): string | null {
-  const name = telemetryNameForPoint(point);
-  return name ? `power_validation_${name}.json` : null;
-}
-
 /**
  * Stable identity of a point's trace: run id plus audit name. Unique within a
  * chart because the audit name carries the config and the concurrency.
@@ -78,7 +72,6 @@ export interface PowerTimelineRequest {
   runId: string;
   /** RESULT_FILENAME prefix shared by every wanted artifact of the run. */
   prefix: string;
-  artifacts: string[];
 }
 
 /**
@@ -104,7 +97,6 @@ export function planPowerTimelineRequests(
       return {
         runId,
         prefix: longestCommonPrefix(names.map((name) => name.slice(ARTIFACT_PREFIX.length))),
-        artifacts: names,
       };
     });
 }
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 258ad7a6a..f3cdb4da9 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -71,7 +71,7 @@ export const apiRouteCatalog = [
       en: 'UI-only PowerX read for one run: the ingest-time telemetry digest when stored, otherwise the live GPU telemetry artifacts (raw `gpu_metrics_*` rows, or `series=power` one-second buckets for the PowerX timeline, also cut per validation window from `power_audit_*` bundles). Its payload shape is not a stable public contract.',
       zh: '仅供 PowerX 界面按 run 读取：已入库时返回 ingest 阶段生成的 telemetry 摘要，否则回退到实时 GPU 遥测制品（`gpu_metrics_*` 原始行，或供 PowerX 时间线使用的 `series=power` 一秒分桶数据，后者也会按验证窗口从 `power_audit_*` bundle 中切分得到）。其返回结构不是稳定的公开契约。',
     },
-    sourceSha256: '4d387298f0311a91c319548119382646045fff6cccdf4e871adf89b39a6feee1',
+    sourceSha256: '8b15b82fac99c6c0e586fce5312de5a224de454b9d39d15cb0b2c20a2c6d8246',
   },
   {
     source: 'src/app/api/openapi.json/route.ts',
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
index 11202879c..6d4d49e75 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -156,10 +156,6 @@ export function statMetricColumn(metric: GpuMetricStats['metric']): string {
   return STAT_METRIC_COLUMN[metric];
 }
 
-function nullable(values: (number | null)[]): (number | null)[] {
-  return values;
-}
-
 async function insertSampleBatch(
   tx: TxLike,
   seriesId: number,
@@ -177,20 +173,20 @@ async function insertSampleBatch(
         ${seriesId},
         unnest(${tx.array(batch.map((s) => s.gpuIndex))}::smallint[]),
         to_timestamp(unnest(${tx.array(batch.map((s) => s.timestampMs / 1000))}::double precision[])),
-        unnest(${tx.array(nullable(batch.map((s) => s.powerW)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.temperatureC)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.smClockMhz)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.memClockMhz)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.gpuUtilPct)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.memUtilPct)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.edgeTempC)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.memTempC)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.gfxVoltageMv)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.socVoltageMv)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.memVoltageMv)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.fclkMhz)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.socclkMhz)))}::real[]),
-        unnest(${tx.array(nullable(batch.map((s) => s.mmActivityPct)))}::real[])
+        unnest(${tx.array(batch.map((s) => s.powerW))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.temperatureC))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.smClockMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memClockMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.gpuUtilPct))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memUtilPct))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.edgeTempC))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memTempC))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.gfxVoltageMv))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.socVoltageMv))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memVoltageMv))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.fclkMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.socclkMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.mmActivityPct))}::real[])
       -- nvidia-smi occasionally repeats the final sample when the monitor is
       -- stopped and flushed; the primary key makes that a no-op.
       on conflict (series_id, gpu_index, sampled_at) do nothing
diff --git a/packages/db/src/queries/gpu-metrics.test.ts b/packages/db/src/queries/gpu-metrics.test.ts
index e8eafa799..50c75418e 100644
--- a/packages/db/src/queries/gpu-metrics.test.ts
+++ b/packages/db/src/queries/gpu-metrics.test.ts
@@ -4,11 +4,7 @@ import { PGlite } from '@electric-sql/pglite';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 
 import type { DbClient } from '../connection';
-import {
-  getGpuMetricsAvailability,
-  getGpuMetricsForPoint,
-  getGpuMetricsForRun,
-} from './gpu-metrics';
+import { getGpuMetricsForPoint, getGpuMetricsForRun } from './gpu-metrics';
 
 let db: PGlite;
 const sql: DbClient = async (strings, ...values) => {
@@ -17,11 +13,6 @@ const sql: DbClient = async (strings, ...values) => {
   return result.rows;
 };
 
-/** Stand-in client that fails loudly if a query slips past an early return. */
-const exploding: DbClient = () => {
-  throw new Error('should not query');
-};
-
 const WITH_SERIES = 34557177019;
 const WITHOUT_SERIES = 34557177020;
 const RETRIED = 34557177021;
@@ -213,14 +204,6 @@ describe('getGpuMetricsForRun', () => {
     expect(node1?.benchmarkResultIds).toEqual([10]);
   });
 
-  it('omits samples but keeps the digest when includeSamples is false', async () => {
-    const payload = await getGpuMetricsForRun(sql, WITH_SERIES, { includeSamples: false });
-    expect(payload?.series.map((series) => series.data)).toEqual([[], []]);
-    expect(payload?.series[0]?.stats).toHaveLength(2);
-    // sampleCount is the stored column, so it still reports the full series length.
-    expect(payload?.series[0]?.sampleCount).toBe(3);
-  });
-
   it('reads the latest attempt of a rerun GitHub run id, not the first', async () => {
     const payload = await getGpuMetricsForRun(sql, RETRIED);
     expect(payload?.workflowRun).toMatchObject({ id: 4, runAttempt: 2, conclusion: 'success' });
@@ -281,16 +264,3 @@ describe('getGpuMetricsForPoint', () => {
     expect(single?.series.map((series) => series.id)).toEqual([100]);
   });
 });
-
-describe('getGpuMetricsAvailability', () => {
-  it('flags only the point ids that have at least one linked series', async () => {
-    expect(await getGpuMetricsAvailability(sql, [10, 11, 12, 9999])).toEqual({
-      10: true,
-      11: true,
-    });
-  });
-
-  it('short-circuits an empty id list without querying', async () => {
-    expect(await getGpuMetricsAvailability(exploding, [])).toEqual({});
-  });
-});
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
index 3319130a4..13c0649e4 100644
--- a/packages/db/src/queries/gpu-metrics.ts
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -174,7 +174,6 @@ function toStatRow(raw: RawStatRow): GpuMetricStatRow {
 async function loadSeriesDetails(
   sql: DbClient,
   seriesRows: readonly RawSeriesRow[],
-  includeSamples: boolean,
 ): Promise<GpuMetricSeries[]> {
   if (seriesRows.length === 0) return [];
   const ids = seriesRows.map((row) => Number(row.id));
@@ -187,16 +186,14 @@ async function loadSeriesDetails(
     order by series_id, gpu_index, metric
   `) as unknown as RawStatRow[];
 
-  const sampleRows = includeSamples
-    ? ((await sql`
-        select series_id, gpu_index, sampled_at, power_w, temperature_c, sm_clock_mhz,
-          mem_clock_mhz, gpu_util_pct, mem_util_pct, edge_temp_c, mem_temp_c,
-          gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv, fclk_mhz, socclk_mhz, mm_activity_pct
-        from gpu_metric_samples
-        where series_id = any(${ids}::bigint[])
-        order by series_id, sampled_at, gpu_index
-      `) as unknown as RawSampleRow[])
-    : [];
+  const sampleRows = (await sql`
+    select series_id, gpu_index, sampled_at, power_w, temperature_c, sm_clock_mhz,
+      mem_clock_mhz, gpu_util_pct, mem_util_pct, edge_temp_c, mem_temp_c,
+      gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv, fclk_mhz, socclk_mhz, mm_activity_pct
+    from gpu_metric_samples
+    where series_id = any(${ids}::bigint[])
+    order by series_id, sampled_at, gpu_index
+  `) as unknown as RawSampleRow[];
 
   const statsBySeries = new Map<number, GpuMetricStatRow[]>();
   for (const raw of statRows) {
@@ -245,7 +242,6 @@ async function loadSeriesDetails(
 export async function getGpuMetricsForRun(
   sql: DbClient,
   githubRunId: number,
-  options: { includeSamples?: boolean } = {},
 ): Promise<GpuMetricsRunPayload | null> {
   const runRows = (await sql`
     select id, github_run_id, run_attempt, name, date, html_url, head_branch, head_sha,
@@ -297,7 +293,7 @@ export async function getGpuMetricsForRun(
       status: run.status,
       createdAt: run.created_at ? isoString(run.created_at) : null,
     },
-    series: await loadSeriesDetails(sql, seriesRows, options.includeSamples ?? true),
+    series: await loadSeriesDetails(sql, seriesRows),
   };
 }
 
@@ -326,22 +322,6 @@ export async function getGpuMetricsForPoint(
   if (seriesRows.length === 0) return null;
   return {
     benchmarkResultId,
-    series: await loadSeriesDetails(sql, seriesRows, true),
+    series: await loadSeriesDetails(sql, seriesRows),
   };
 }
-
-/** `benchmark_results.id` → true for each id that has at least one linked series. */
-export async function getGpuMetricsAvailability(
-  sql: DbClient,
-  benchmarkResultIds: readonly number[],
-): Promise<Record<number, true>> {
-  if (benchmarkResultIds.length === 0) return {};
-  const rows = (await sql`
-    select distinct benchmark_result_id
-    from benchmark_result_gpu_metrics
-    where benchmark_result_id = any(${[...benchmarkResultIds]}::bigint[])
-  `) as unknown as { benchmark_result_id: number | string }[];
-  const out: Record<number, true> = {};
-  for (const row of rows) out[Number(row.benchmark_result_id)] = true;
-  return out;
-}

From f412d0ca5571b767a1655c250b267bc9580718ce Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Mon, 21 Sep 2026 00:35:22 -0700
Subject: [PATCH 020/103] fix: keep PowerX telemetry samples and digests
 consistent
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Deduplicate each GPU/timestamp before computing metadata and statistics,
keeping the first sample for both CSV and per-host power-audit series.
Include sidecars and normalized sample counts in the replay check so
corrected context is persisted and explicit re-ingest repairs old digests.

Add PGlite regressions for duplicate populations, legacy replay, timezone
and identity corrections, and JSON key-order no-ops. The focused suite
fails on the old implementation and passes all 12 tests with the fix.

中文：统一 PowerX 遥测明细与摘要的采样集合，在统计前按 GPU 和时间戳去重。
重新摄取时同时核对 sidecar 与去重后的样本数，使时区及身份修正能够落库，
并支持显式重跑修复旧摘要；补充真实 PGlite 回归测试及恢复说明。
---
 docs/data-pipeline.md                         |  10 +-
 .../db/src/etl/gpu-metrics-ingest.test.ts     | 175 +++++++++++++++++-
 packages/db/src/etl/gpu-metrics-ingest.ts     |  51 +++--
 3 files changed, 213 insertions(+), 23 deletions(-)

diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index 65dfb67c6..e486667b0 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -567,9 +567,13 @@ digests them at ingest time, in the same step that links server logs:
 - `benchmark_result_gpu_metrics` — links each benchmark point to the series that
   was recorded while it ran (several series per point for multinode artifacts).
 
-Ingest is idempotent: the same CSV hash refreshes only the point links, a changed
-CSV replaces the samples and digest inside one transaction, and repeated final
-samples (the monitor's stop-time flush) collapse on the primary key. Series are
+Ingest is idempotent: the same CSV hash, sidecars, and unique sample count refresh
+only the point links. A change replaces the samples and digest inside one
+transaction, including corrected timezone or identity sidecars. Repeated samples
+keep the first row per (GPU, timestamp) before computing counts and statistics,
+matching the sample table's primary key. Explicitly re-ingesting a run also
+repairs older duplicate-inflated counts and digests; `--all` skips runs already
+containing series, so target those runs with `--run` or use `--force`. Series are
 stored per artifact, not per point: an AgentX per-concurrency job maps to one
 point, while older fixed-sequence jobs that swept several concurrencies in one
 job share one series across points. Windowing a series to the measured serving
diff --git a/packages/db/src/etl/gpu-metrics-ingest.test.ts b/packages/db/src/etl/gpu-metrics-ingest.test.ts
index 604cafb18..0f2045124 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.test.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.test.ts
@@ -94,6 +94,7 @@ const MULTINODE_POWER_CSV = [
   '1,1789194366.292,5,host-a,1,GPU-a1,702.0',
   '1,1789194366.292,5,host-b,0,GPU-b0,650.0',
   '1,1789194366.292,5,host-b,1,GPU-b1,655.0',
+  '1,1789194366.292,5,host-a,0,GPU-a0,999.0',
 ].join('\n');
 const MULTINODE_MANIFEST = {
   schema_version: 1,
@@ -159,7 +160,7 @@ describe('prepareGpuMetricsArtifact', () => {
     const [series] = prepareGpuMetricsArtifact(writeArtifact(NVIDIA_CSV));
     expect(series?.fileName).toBe('gpu_metrics.csv');
     expect(series?.vendor).toBe('nvidia');
-    expect(series?.samples).toHaveLength(5);
+    expect(series?.samples).toHaveLength(4);
     expect(series?.gpuCount).toBe(2);
     expect(series?.sidecars.context).toEqual({ timestamp_timezone: 'UTC' });
     expect(series?.stats.find((s) => s.gpuIndex === 0 && s.metric === 'powerW')?.max).toBe(912.1);
@@ -175,7 +176,6 @@ describe('ingestGpuMetricsArtifact', () => {
       benchmarkResultIds: [10, 10],
     });
     expect(first.seriesIds).toHaveLength(1);
-    // Five CSV rows, but the repeated final sample collapses on the primary key.
     expect(first.samplesInserted).toBe(4);
     expect(first.seriesSkipped).toBe(0);
 
@@ -195,7 +195,7 @@ describe('ingestGpuMetricsArtifact', () => {
     expect(series!.artifact_name).toBe(artifact.artifactName);
     expect(series!.config_key).toBe('dsr1_8k1k_fp4_sglang_conc32_b200-x_0');
     expect(series!.vendor).toBe('nvidia');
-    expect(series!.sample_count).toBe(5);
+    expect(series!.sample_count).toBe(4);
     expect(series!.gpu_count).toBe(2);
     expect(new Date(series!.started_at).toISOString()).toBe('2026-09-11T04:19:41.982Z');
     expect(new Date(series!.ended_at).toISOString()).toBe('2026-09-11T04:19:42.994Z');
@@ -217,7 +217,7 @@ describe('ingestGpuMetricsArtifact', () => {
       where metric = 'power_w' order by gpu_index`;
     expect(stats).toEqual([
       { gpu_index: 0, metric: 'power_w', sample_count: 2, max_value: 912.1 },
-      { gpu_index: 1, metric: 'power_w', sample_count: 3, max_value: 905.3 },
+      { gpu_index: 1, metric: 'power_w', sample_count: 2, max_value: 905.3 },
     ]);
 
     const links = await sql<{ benchmark_result_id: number }[]>`
@@ -269,6 +269,18 @@ describe('ingestGpuMetricsArtifact', () => {
     const links = await sql<{ n: number }[]>`
       select count(*)::int as n from benchmark_result_gpu_metrics where benchmark_result_id = 10`;
     expect(links[0]!.n).toBe(2);
+    const [hostA] = await sql<{ sample_count: number; mean_value: number; power_w: number }[]>`
+      select stats.sample_count, stats.mean_value, samples.power_w
+      from gpu_metric_series series
+      join gpu_metric_gpu_stats stats on stats.series_id = series.id
+      join gpu_metric_samples samples on samples.series_id = series.id
+        and samples.gpu_index = stats.gpu_index
+      where series.file_name = 'LOGS/power/samples.csv#host-a'
+        and stats.gpu_index = 0 and stats.metric = 'power_w'
+      order by samples.sampled_at desc limit 1`;
+    expect(hostA!.sample_count).toBe(2);
+    expect(hostA!.mean_value).toBeCloseTo((186.656 + 700.25) / 2, 3);
+    expect(hostA!.power_w).toBe(700.25);
 
     const rerun = await ingestGpuMetricsArtifact(sql, {
       workflowRunId: 1,
@@ -295,12 +307,165 @@ describe('ingestGpuMetricsArtifact', () => {
     const [series] = await sql<{ n: number; sample_count: number }[]>`
       select (select count(*)::int from gpu_metric_series) as n, sample_count from gpu_metric_series`;
     expect(series!.n).toBe(1);
-    expect(series!.sample_count).toBe(6);
+    expect(series!.sample_count).toBe(5);
     const [stat] = await sql<{ max_value: number }[]>`
       select max_value from gpu_metric_gpu_stats where gpu_index = 0 and metric = 'power_w'`;
     expect(stat!.max_value).toBe(950);
   });
 
+  it('uses the first reading per GPU/timestamp for stored samples, metadata, and digest', async () => {
+    const csv = [
+      NVIDIA_CSV.split('\n')[0],
+      '2026/09/11 04:19:41.000, 0, 100 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+      '2026/09/11 04:19:41.000, 1, 200 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+      '2026/09/11 04:19:42.000, 0, 300 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+      '2026/09/11 04:19:42.000, 0, 900 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+    ].join('\n');
+    const artifact = writeArtifact(csv);
+    await ingestGpuMetricsArtifact(sql, { workflowRunId: 1, artifact, benchmarkResultIds: [10] });
+
+    const samples = await sql<{ gpu_index: number; power_w: number }[]>`
+      select gpu_index, power_w from gpu_metric_samples order by sampled_at, gpu_index`;
+    expect(samples).toEqual([
+      { gpu_index: 0, power_w: 100 },
+      { gpu_index: 1, power_w: 200 },
+      { gpu_index: 0, power_w: 300 },
+    ]);
+    const [series] = await sql<{ sample_count: number; gpu_count: number }[]>`
+      select sample_count, gpu_count from gpu_metric_series`;
+    expect(series).toEqual({ sample_count: 3, gpu_count: 2 });
+    const stats = await sql<{ gpu_index: number; sample_count: number; mean_value: number }[]>`
+      select gpu_index, sample_count, mean_value from gpu_metric_gpu_stats
+      where metric = 'power_w' order by gpu_index`;
+    expect(stats).toEqual([
+      { gpu_index: 0, sample_count: 2, mean_value: 200 },
+      { gpu_index: 1, sample_count: 1, mean_value: 200 },
+    ]);
+  });
+
+  it('repairs an existing duplicate-inflated digest when the same CSV is re-ingested', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    // Model an earlier ingest: SQL stored unique samples, but metadata and stats
+    // counted the repeated final CSV row. Its CSV hash and sidecars still match.
+    await sql`update gpu_metric_series set sample_count = 5`;
+    await sql`update gpu_metric_gpu_stats set sample_count = 3, mean_value = 667.1867
+      where gpu_index = 1 and metric = 'power_w'`;
+
+    const result = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(result.seriesIds).toEqual(first.seriesIds);
+    expect(result.seriesSkipped).toBe(0);
+    const [series] = await sql<{ sample_count: number; stored_count: number }[]>`
+      select sample_count, (select count(*)::int from gpu_metric_samples) as stored_count
+      from gpu_metric_series`;
+    expect(series).toEqual({ sample_count: 4, stored_count: 4 });
+    const [stat] = await sql<{ sample_count: number; mean_value: number }[]>`
+      select sample_count, mean_value from gpu_metric_gpu_stats
+      where gpu_index = 1 and metric = 'power_w'`;
+    expect(stat!.sample_count).toBe(2);
+    expect(stat!.mean_value).toBeCloseTo((190.96 + 905.3) / 2, 3);
+  });
+
+  it('replaces timestamps when only the context timezone is corrected', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    const before = await sql<{ sampled_at: Date }[]>`
+      select sampled_at from gpu_metric_samples order by sampled_at, gpu_index`;
+    fs.writeFileSync(
+      path.join(artifact.artifactDir, 'gpu_metrics_context.json'),
+      JSON.stringify({ timestamp_timezone: '+02:00' }),
+    );
+
+    const result = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(result.seriesIds).toEqual(first.seriesIds);
+    expect(result.samplesInserted).toBe(4);
+    expect(result.seriesSkipped).toBe(0);
+    const after = await sql<{ sampled_at: Date }[]>`
+      select sampled_at from gpu_metric_samples order by sampled_at, gpu_index`;
+    expect(after.map((s) => new Date(s.sampled_at).getTime())).toEqual(
+      before.map((s) => new Date(s.sampled_at).getTime() - 2 * 60 * 60 * 1000),
+    );
+    const [series] = await sql<{ started_at: Date; ended_at: Date; context: unknown }[]>`
+      select started_at, ended_at, sidecars -> 'context' as context from gpu_metric_series`;
+    expect(new Date(series!.started_at).toISOString()).toBe('2026-09-11T02:19:41.982Z');
+    expect(new Date(series!.ended_at).toISOString()).toBe('2026-09-11T02:19:42.994Z');
+    expect(series!.context).toEqual({ timestamp_timezone: '+02:00' });
+  });
+
+  it('persists identity-only sidecar corrections without changing the series or samples', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    const before = await sql`select * from gpu_metric_samples order by sampled_at, gpu_index`;
+    fs.writeFileSync(
+      path.join(artifact.artifactDir, 'gpu_metrics_identity.csv'),
+      'index, uuid, name\n0, GPU-corrected, NVIDIA B200\n1, GPU-b, NVIDIA B200\n',
+    );
+
+    const result = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(result.seriesIds).toEqual(first.seriesIds);
+    const [series] = await sql<{ identity: unknown }[]>`
+      select sidecars -> 'identity' as identity from gpu_metric_series`;
+    expect(series!.identity).toEqual([
+      { index: '0', uuid: 'GPU-corrected', name: 'NVIDIA B200' },
+      { index: '1', uuid: 'GPU-b', name: 'NVIDIA B200' },
+    ]);
+    expect(await sql`select * from gpu_metric_samples order by sampled_at, gpu_index`).toEqual(
+      before,
+    );
+  });
+
+  it('keeps reruns as no-ops when only JSON object key order changes', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const contextPath = path.join(artifact.artifactDir, 'gpu_metrics_context.json');
+    fs.writeFileSync(
+      contextPath,
+      JSON.stringify({ timestamp_timezone: 'UTC', collector: { name: 'nvidia-smi', version: 1 } }),
+    );
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    const [before] = await sql<{ ingested_at: Date }[]>`select ingested_at from gpu_metric_series`;
+    fs.writeFileSync(
+      contextPath,
+      JSON.stringify({ collector: { version: 1, name: 'nvidia-smi' }, timestamp_timezone: 'UTC' }),
+    );
+
+    const result = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(result).toEqual({ seriesIds: first.seriesIds, samplesInserted: 0, seriesSkipped: 1 });
+    const [after] = await sql<{ ingested_at: Date }[]>`select ingested_at from gpu_metric_series`;
+    expect(after!.ingested_at).toEqual(before!.ingested_at);
+  });
+
   it('ignores artifacts whose CSVs cannot be parsed', async () => {
     const artifact = writeArtifact('nonsense,header\n1,2\n');
     const result = await ingestGpuMetricsArtifact(sql, {
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
index 6d4d49e75..c1b649086 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -3,8 +3,8 @@
  * the per-GPU statistics digest, and links to the benchmark points it covers.
  *
  * Idempotency: a series is identified by (workflow run, artifact name, CSV
- * path). Re-ingesting an identical CSV (same sha256) only refreshes the point
- * links; a changed CSV replaces the stored samples and digest inside one
+ * path). Re-ingesting an identical CSV, sidecars and sample count only refreshes
+ * the point links; a change replaces the stored samples and digest inside one
  * transaction so readers never observe a half-written series.
  */
 
@@ -40,6 +40,17 @@ import { multinodePowerVendor, parseMultinodePowerSamples } from './multinode-po
 /** Samples are streamed to Postgres in unnest batches of this many rows. */
 const SAMPLE_BATCH_SIZE = 5000;
 
+function uniqueSamples(samples: readonly GpuMetricSample[]): GpuMetricSample[] {
+  const seen = new Set<string>();
+  return samples.filter((sample) => {
+    const key = `${sample.gpuIndex}:${sample.timestampMs}`;
+    if (seen.has(key)) return false;
+    // Keep the first row, matching INSERT ... ON CONFLICT DO NOTHING.
+    seen.add(key);
+    return true;
+  });
+}
+
 export interface PreparedGpuMetricSeries {
   fileName: string;
   vendor: GpuMetricsVendor;
@@ -61,8 +72,8 @@ export interface GpuMetricsIngestResult {
 
 /**
  * One series per host from the multinode power bundle. The deployment-wide
- * CSV is hashed once, so every host series of one upload shares its sha and
- * re-ingests stay no-ops together. The `#<hostname>` fragment keeps the
+ * CSV is hashed once, so every host series of one upload shares its source sha.
+ * The `#<hostname>` fragment keeps the
  * (run, artifact, file) identity unique per host.
  */
 function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
@@ -75,14 +86,15 @@ function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuM
     const vendor = multinodePowerVendor(manifest);
     const csvSha256 = createHash('sha256').update(csvText).digest('hex');
     for (const host of hosts) {
-      const summary = summarizeGpuMetricSamples(host.samples);
+      const samples = uniqueSamples(host.samples);
+      const summary = summarizeGpuMetricSamples(samples);
       if (!summary) continue;
       prepared.push({
         fileName: `${file.fileName}#${host.hostname}`,
         vendor,
         csvSha256,
-        samples: host.samples,
-        stats: computeGpuMetricStats(host.samples),
+        samples,
+        stats: computeGpuMetricStats(samples),
         sampleIntervalS: summary.sampleIntervalS,
         gpuCount: summary.gpuCount,
         startedAtMs: summary.startedAtMs,
@@ -116,14 +128,15 @@ export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): Prepare
       nvidiaUtcOffsetMinutes: contextUtcOffsetMinutes(sidecars.context),
     });
     if (!parsed) continue;
-    const summary = summarizeGpuMetricSamples(parsed.samples);
+    const samples = uniqueSamples(parsed.samples);
+    const summary = summarizeGpuMetricSamples(samples);
     if (!summary) continue;
     prepared.push({
       fileName: file.fileName,
       vendor: parsed.vendor,
       csvSha256: createHash('sha256').update(csvText).digest('hex'),
-      samples: parsed.samples,
-      stats: computeGpuMetricStats(parsed.samples),
+      samples,
+      stats: computeGpuMetricStats(samples),
       sampleIntervalS: summary.sampleIntervalS,
       gpuCount: summary.gpuCount,
       startedAtMs: summary.startedAtMs,
@@ -225,8 +238,8 @@ async function insertStats(
 
 /**
  * Upsert one prepared series and link it to `benchmarkResultIds`. Returns the
- * series id and how many sample rows were written (0 when the CSV was already
- * stored with the same hash).
+ * series id and how many sample rows were written (0 when the CSV, sidecars,
+ * and unique sample count are unchanged).
  */
 export function upsertGpuMetricSeries(
   sql: Sql,
@@ -242,8 +255,11 @@ export function upsertGpuMetricSeries(
   const sidecarsJson = JSON.stringify(series.sidecars);
 
   return sql.begin(async (tx) => {
-    const existing = await tx<{ id: number; csv_sha256: string }[]>`
-      select id, csv_sha256 from gpu_metric_series
+    const existing = await tx<
+      { id: number; csv_sha256: string; sample_count: number; sidecars_match: boolean }[]
+    >`
+      select id, csv_sha256, sample_count, sidecars = ${sidecarsJson}::jsonb as sidecars_match
+      from gpu_metric_series
       where workflow_run_id = ${workflowRunId}
         and artifact_name = ${artifactName}
         and file_name = ${series.fileName}
@@ -255,7 +271,12 @@ export function upsertGpuMetricSeries(
     let replaced = false;
     if (existing.length > 0) {
       seriesId = Number(existing[0]!.id);
-      if (existing[0]!.csv_sha256 === series.csvSha256) {
+      // Count also detects legacy digests computed before duplicate removal.
+      if (
+        existing[0]!.csv_sha256 === series.csvSha256 &&
+        existing[0]!.sidecars_match &&
+        existing[0]!.sample_count === series.samples.length
+      ) {
         needsSamples = false;
       } else {
         replaced = true;

From 4a1cac387d47dc622a9bba42461828bd7789e8dc Mon Sep 17 00:00:00 2001
From: Wenyao Gao <105094497+edwingao28@users.noreply.github.com>
Date: Mon, 21 Sep 2026 01:18:55 -0700
Subject: [PATCH 021/103] =?UTF-8?q?[PowerX]=20fix=20telemetry=20axes=20and?=
 =?UTF-8?q?=20stale=20power=20references=20/=20=E4=BF=AE=E5=A4=8D=E9=81=A5?=
 =?UTF-8?q?=E6=B5=8B=E5=9D=90=E6=A0=87=E8=BD=B4=E4=B8=8E=E6=AE=8B=E7=95=99?=
 =?UTF-8?q?=E5=8A=9F=E8=80=97=E5=8F=82=E8=80=83=E7=BA=BF=20(#1196)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix: keep constant telemetry axes readable

中文：为恒定及近恒定遥测值保留最小坐标范围，避免显存时钟刻度坍缩；补充桌面、手机、全零值和 TDP 参考线的组件回归测试。

* fix: clear power reference when switching telemetry metrics

切换到显存频率时清除旧 TDP 参考线，并验证切回功耗后仅恢复一条参考线。
---
 .../cypress/component/gpu-metrics-axis.cy.tsx | 117 ++++++++++++++++++
 .../components/gpu-power/GpuPowerChart.tsx    |  61 ++++-----
 2 files changed, 150 insertions(+), 28 deletions(-)
 create mode 100644 packages/app/cypress/component/gpu-metrics-axis.cy.tsx

diff --git a/packages/app/cypress/component/gpu-metrics-axis.cy.tsx b/packages/app/cypress/component/gpu-metrics-axis.cy.tsx
new file mode 100644
index 000000000..2d7443411
--- /dev/null
+++ b/packages/app/cypress/component/gpu-metrics-axis.cy.tsx
@@ -0,0 +1,117 @@
+import GpuMetricsChart from '@/components/gpu-power/GpuPowerChart';
+import type { GpuMetricRow } from '@/components/gpu-power/types';
+import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
+import { useState } from 'react';
+
+const svg = () => cy.get('[data-testid="gpu-metrics-chart-svg"]');
+
+function samples(clock: (sample: number) => number): GpuMetricRow[] {
+  return Array.from({ length: 8 }, (_chip, index) =>
+    Array.from({ length: 21 }, (_, sample) => ({
+      timestamp: new Date(Date.UTC(2026, 8, 20) + sample * 30_000).toISOString(),
+      index,
+      power: 300 + sample * 30,
+      memClock: clock(sample),
+    })),
+  ).flat();
+}
+
+function mountClock(data: GpuMetricRow[]) {
+  cy.mount(
+    <GpuMetricsChart
+      data={data}
+      visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
+      metricKey="memClock"
+      artifactName="gpu_metrics_b200"
+      display={{ mode: 'rolling', windowS: 300, series: 'chips' }}
+    />,
+  );
+}
+
+function assertReadableAxis(value: number) {
+  svg().should(($svg) => {
+    const labels = $svg.find('.y-axis .tick text').toArray();
+    expect(labels.length, 'multiple useful ticks').to.be.greaterThan(1);
+    const values = labels.map((label) => Number(label.textContent?.replaceAll(',', '')));
+    expect(values.every(Number.isFinite), 'numeric ticks').to.eq(true);
+    expect(new Set(values).size, 'distinct ticks').to.eq(values.length);
+    expect(Math.min(...values)).to.be.at.most(value);
+    expect(Math.max(...values)).to.be.greaterThan(value);
+    const title = $svg.find('.y-axis-label')[0]!.getBoundingClientRect();
+    for (const label of labels) {
+      expect(label.getBoundingClientRect().left, 'tick clears axis title').to.be.greaterThan(
+        title.right,
+      );
+    }
+  });
+  svg().find('path.line-path').should('have.length', 8);
+}
+
+describe('PowerX telemetry axis', () => {
+  for (const width of [1280, 375]) {
+    it(`keeps constant memory clocks readable at ${width}px`, () => {
+      cy.viewport(width, 800);
+      mountClock(samples(() => 390));
+      assertReadableAxis(390);
+    });
+  }
+
+  it('does not magnify floating-point noise after rolling averages', () => {
+    mountClock(samples((sample) => 390 - (sample % 2) * Number.EPSILON * 256));
+    assertReadableAxis(390);
+  });
+
+  it('gives all-zero telemetry a nonzero, nonnegative range', () => {
+    mountClock(samples(() => 0));
+    assertReadableAxis(0);
+    svg().find('.y-axis .tick text').first().should('have.text', '0.0');
+  });
+
+  it('preserves varying power measurements and the hardware TDP reference', () => {
+    cy.mount(
+      <GpuMetricsChart
+        data={samples(() => 390)}
+        visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
+        metricKey="power"
+        artifactName="gpu_metrics_b200"
+        display={{ mode: 'points', windowS: 300, series: 'chips' }}
+      />,
+    );
+    svg().find('.tdp-line text').should('contain.text', `${HW_REGISTRY.b200.tdp}W`);
+    svg().should(($svg) => {
+      const values = $svg
+        .find('.y-axis .tick text')
+        .toArray()
+        .map((label) => Number(label.textContent?.replaceAll(',', '')));
+      expect(Math.min(...values)).to.be.at.most(300);
+      expect(Math.max(...values)).to.be.at.least(HW_REGISTRY.b200.tdp);
+    });
+  });
+
+  it('removes the power reference when switching to memory clock and restores it once', () => {
+    function SwitchMetric() {
+      const [metric, setMetric] = useState<'power' | 'memClock'>('power');
+      return (
+        <>
+          <button onClick={() => setMetric(metric === 'power' ? 'memClock' : 'power')}>
+            Switch metric
+          </button>
+          <GpuMetricsChart
+            data={samples(() => 3996)}
+            visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
+            metricKey={metric}
+            artifactName="gpu_metrics_b200"
+            display={{ mode: 'rolling', windowS: 300, series: 'chips' }}
+          />
+        </>
+      );
+    }
+    cy.mount(<SwitchMetric />);
+    svg().find('.tdp-line').should('have.length', 1);
+    cy.contains('button', 'Switch metric').click();
+    svg().find('.tdp-line').should('not.exist');
+    assertReadableAxis(3996);
+    cy.contains('button', 'Switch metric').click();
+    svg().find('.tdp-line').should('have.length', 1);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/GpuPowerChart.tsx b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
index a1209ec78..ab5c6c9dc 100644
--- a/packages/app/src/components/gpu-power/GpuPowerChart.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
@@ -386,8 +386,14 @@ const GpuMetricsChart = React.memo(
       if (allPoints.length === 0) return [0, 100] as [number, number];
       const ext = d3.extent(allPoints, (d) => d.value) as [number, number];
       const range = ext[1] - ext[0];
-      const yMin = Math.max(0, ext[0] - range * 0.05);
-      let yMax = ext[1] + range * 0.05;
+      // Constant telemetry and floating-point noise still need a readable axis.
+      const padding = Math.max(
+        range * 0.05,
+        Math.max(Math.abs(ext[0]), Math.abs(ext[1])) * 0.01,
+        1,
+      );
+      const yMin = Math.max(0, ext[0] - padding);
+      let yMax = ext[1] + padding;
       if (tdpInfo && tdpInfo.tdp > yMax) yMax = tdpInfo.tdp * 1.05;
       return [yMin, yMax] as [number, number];
     }, [allPoints, tdpInfo]);
@@ -419,32 +425,31 @@ const GpuMetricsChart = React.memo(
           {
             type: 'custom',
             key: 'tdp-line',
-            render: tdpInfo
-              ? (group, ctx) => {
-                  const yScale = ctx.yScale as d3.ScaleLinear<number, number>;
-                  const tdpY = yScale(tdpInfo.tdp);
-                  group.selectAll('.tdp-line').remove();
-                  const tdpGroup = group.append('g').attr('class', 'tdp-line');
-                  tdpGroup
-                    .append('line')
-                    .attr('x1', 0)
-                    .attr('x2', ctx.width)
-                    .attr('y1', tdpY)
-                    .attr('y2', tdpY)
-                    .attr('stroke', '#ef4444')
-                    .attr('stroke-width', 1.5)
-                    .attr('stroke-dasharray', '6,4');
-                  tdpGroup
-                    .append('text')
-                    .attr('x', ctx.width - 4)
-                    .attr('y', tdpY - 6)
-                    .attr('text-anchor', 'end')
-                    .attr('fill', '#ef4444')
-                    .attr('font-size', '11px')
-                    .attr('font-weight', '600')
-                    .text(`${tdpInfo.sku} TDP: ${tdpInfo.tdp}W`);
-                }
-              : null,
+            render: (group, ctx) => {
+              group.selectAll('.tdp-line').remove();
+              if (!tdpInfo) return;
+              const yScale = ctx.yScale as d3.ScaleLinear<number, number>;
+              const tdpY = yScale(tdpInfo.tdp);
+              const tdpGroup = group.append('g').attr('class', 'tdp-line');
+              tdpGroup
+                .append('line')
+                .attr('x1', 0)
+                .attr('x2', ctx.width)
+                .attr('y1', tdpY)
+                .attr('y2', tdpY)
+                .attr('stroke', '#ef4444')
+                .attr('stroke-width', 1.5)
+                .attr('stroke-dasharray', '6,4');
+              tdpGroup
+                .append('text')
+                .attr('x', ctx.width - 4)
+                .attr('y', tdpY - 6)
+                .attr('text-anchor', 'end')
+                .attr('fill', '#ef4444')
+                .attr('font-size', '11px')
+                .attr('font-weight', '600')
+                .text(`${tdpInfo.sku} TDP: ${tdpInfo.tdp}W`);
+            },
           },
           // GPU lines
           {

From 17e92d7d9a26d7bc4aaea6ecc544be8a71cf7071 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Mon, 21 Sep 2026 13:21:09 -0700
Subject: [PATCH 022/103] fix: correct PowerX comparison values and timeline
 labels
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Use plotted role and boundary values in tables, sorting, and CSV exports. Reuse the locally verified 8dbab1ed table correction. Distinguish dates on multi-day UTC timelines and clarify per-chip power accounting. Cover regressions and exercise the mobile telemetry tooltip with a real click.

中文：修正 PowerX 对比数值与时间轴标签。表格、排序和 CSV 使用各角色或功耗边界的绘图数值，复用已验证的 8dbab1ed 修复；跨日 UTC 时间轴补充日期，明确每芯片功率与部署总能耗的区别，并补充回归测试和手机端点击提示框验证。
---
 .../inference-table-power-compare.cy.tsx      | 68 +++++++++++++++++++
 .../cypress/component/power-timeline.cy.tsx   | 24 +++++++
 packages/app/cypress/e2e/gpu-power.cy.ts      |  6 +-
 .../inference/ui/InferenceTable.test.ts       | 55 ++++++++++++++-
 .../inference/ui/InferenceTable.tsx           |  8 ++-
 .../inference/ui/MeasuredMetricControls.tsx   |  5 +-
 .../components/inference/ui/PowerTimeline.tsx |  5 +-
 .../inference/ui/inference-table-sort.ts      |  4 +-
 .../app/src/lib/csv-export-helpers.test.ts    | 38 +++++++++++
 packages/app/src/lib/csv-export-helpers.ts    |  3 +-
 10 files changed, 204 insertions(+), 12 deletions(-)
 create mode 100644 packages/app/cypress/component/inference-table-power-compare.cy.tsx

diff --git a/packages/app/cypress/component/inference-table-power-compare.cy.tsx b/packages/app/cypress/component/inference-table-power-compare.cy.tsx
new file mode 100644
index 000000000..d8405a969
--- /dev/null
+++ b/packages/app/cypress/component/inference-table-power-compare.cy.tsx
@@ -0,0 +1,68 @@
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+
+import { chartDefinitions } from '@/components/inference/metric-registry';
+import InferenceTable from '@/components/inference/ui/InferenceTable';
+import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
+
+import { createMockInferenceData } from '../support/mock-data';
+import { mountWithProviders } from '../support/test-utils';
+
+const metric = (y: number) => ({ y, roof: false });
+const points = expandPowerCompareSeries(
+  [
+    [708.1, 760.442, 690.652],
+    [281.614, 250.622, 291.945],
+  ].map(([all, prefill, decode], index) =>
+    createMockInferenceData({
+      hwKey: 'gb300_dynamo-trt',
+      conc: (index + 1) * 64,
+      y: all,
+      measuredAvgPower: metric(all),
+      measuredPrefillAvgPower: metric(prefill),
+      measuredDecodeAvgPower: metric(decode),
+    }),
+  ),
+  'y_measuredAvgPower',
+  'roles',
+);
+
+describe('Power comparison table values', () => {
+  for (const width of [1280, 390]) {
+    it(`keeps role values, sorting and search consistent at ${width}px`, () => {
+      cy.viewport(width, 720);
+      mountWithProviders(
+        <PathnameContext.Provider value="/inference">
+          <InferenceTable
+            data={points}
+            chartDefinition={chartDefinitions[0]}
+            selectedYAxisMetric="y_measuredAvgPower"
+          />
+        </PathnameContext.Provider>,
+      );
+      const table = '[data-testid="inference-results-table"]';
+      const assertRows = (expected: [string, string][]) => {
+        cy.get<HTMLTableRowElement>(`${table} tbody tr`).should(($rows) => {
+          expect(
+            [...$rows].map((row) => [row.cells[2].textContent, row.cells[3].textContent]),
+          ).to.deep.equal(expected);
+        });
+      };
+      const ascending: [string, string][] = [
+        ['Prefill GPUs', '251'],
+        ['All GPUs', '282'],
+        ['Decode GPUs', '292'],
+        ['Decode GPUs', '691'],
+        ['All GPUs', '708'],
+        ['Prefill GPUs', '760'],
+      ];
+      assertRows(ascending);
+      cy.get(`${table} thead th`).eq(3).scrollIntoView().click();
+      assertRows(ascending.toReversed());
+      cy.get(`${table} thead th`).eq(3).click();
+      assertRows(ascending);
+      cy.get(table).screenshot(`power-role-table-${width}`);
+      cy.get(`${table} input`).type('760');
+      assertRows([['Prefill GPUs', '760']]);
+    });
+  }
+});
diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index f0f332914..47fd413c4 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -204,6 +204,30 @@ describe('PowerTimeline', () => {
     });
   });
 
+  it('distinguishes dates when wall-clock traces span multiple days', () => {
+    cy.intercept('GET', '/api/gpu-metrics*', {
+      body: {
+        ...response,
+        series: response.series.map((trace, index) => ({
+          ...trace,
+          startMs: trace.startMs + index * 2 * 24 * 60 * 60_000,
+        })),
+      },
+    }).as('series');
+    mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('b200', 64, 900)]);
+    cy.wait('@series');
+    cy.get('[data-testid="power-timeline-axis-wall"]').click();
+    svg()
+      .find('.x-axis .tick text')
+      .should(($ticks) => {
+        const labels = [...$ticks].map((tick) => tick.textContent);
+        expect(labels.some((label) => label?.includes('09/13'))).to.equal(true);
+        expect(labels.some((label) => label?.includes('09/14'))).to.equal(true);
+        expect(new Set(labels).size).to.equal(labels.length);
+      });
+    svg().screenshot('power-timeline-multiday');
+  });
+
   it('fetches one prefixed series request per run and draws the job with its window emphasized', () => {
     cy.intercept('GET', '/api/gpu-metrics*', { body: response }).as('series');
     mountTimeline([
diff --git a/packages/app/cypress/e2e/gpu-power.cy.ts b/packages/app/cypress/e2e/gpu-power.cy.ts
index 2ff041dd5..eb769267b 100644
--- a/packages/app/cypress/e2e/gpu-power.cy.ts
+++ b/packages/app/cypress/e2e/gpu-power.cy.ts
@@ -211,9 +211,9 @@ describe('PowerX Chinese route', () => {
       .should('contain.text', '秒')
       .and('contain.text', '功耗 (W)');
     cy.get('[data-testid="gpu-metrics-chart-svg"]').should('contain.text', '点击数据点固定提示框');
-    cy.get('[data-testid="gpu-metrics-chart-svg"] svg .point')
-      .first()
-      .trigger('mouseenter', { force: true });
+    cy.get('[data-testid="gpu-metrics-chart-svg"] svg .point').first().scrollIntoView();
+    // Exercise the supported mobile interaction, not a forced off-screen hover.
+    cy.get('[data-testid="gpu-metrics-chart-svg"] svg .point').first().click();
     cy.get('[data-chart-tooltip]:visible')
       .should('contain.text', '芯片 0')
       .and('contain.text', '功耗：');
diff --git a/packages/app/src/components/inference/ui/InferenceTable.test.ts b/packages/app/src/components/inference/ui/InferenceTable.test.ts
index 0d7b1ce06..923133cb1 100644
--- a/packages/app/src/components/inference/ui/InferenceTable.test.ts
+++ b/packages/app/src/components/inference/ui/InferenceTable.test.ts
@@ -1,7 +1,12 @@
 import { describe, it, expect } from 'vitest';
+import { createElement } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
 
 import type { ChartDefinition, InferenceData } from '@/components/inference/types';
-import { formatInferenceTableNumber } from '@/components/inference/ui/InferenceTable';
+import InferenceTable, {
+  formatInferenceTableNumber,
+} from '@/components/inference/ui/InferenceTable';
+import { expandPowerCompareSeries } from '../utils/power-compare';
 
 // Test the pure logic used by InferenceTable — sorting and value resolution
 import { getNestedYValue } from '@/lib/chart-utils';
@@ -50,6 +55,54 @@ function makePoint(overrides: Partial<InferenceData>): InferenceData {
 }
 
 describe('InferenceTable sorting logic', () => {
+  it.each(['roles', 'boundaries'] as const)(
+    'renders and sorts each %s comparison by its plotted value',
+    (mode) => {
+      const base = makePoint({
+        hwKey: 'gb300_dynamo-trt',
+        y: 708.1,
+        measuredAvgPower: { y: 708.1, roof: false },
+        measuredPrefillAvgPower: { y: 760.442, roof: false },
+        measuredDecodeAvgPower: { y: 690.652, roof: false },
+        gpuProvisionedWatts: { y: 1400, roof: false },
+        utilityProvisionedWatts: { y: 1920, roof: false },
+      });
+      const points = expandPowerCompareSeries([base], 'y_measuredAvgPower', mode);
+      const sorted = sortRowsByYMetric(points, chartDefinitions[0], 'y_measuredAvgPower');
+      expect(sorted.map((point) => point.y)).toEqual(
+        mode === 'roles' ? [690.652, 708.1, 760.442] : [708.1, 1400, 1920],
+      );
+
+      const html = renderToStaticMarkup(
+        createElement(InferenceTable, {
+          data: points,
+          chartDefinition: chartDefinitions[0],
+          selectedYAxisMetric: 'y_measuredAvgPower',
+        }),
+      );
+      const body = html.split('<tbody>')[1].split('</tbody>')[0];
+      const cells = [...body.matchAll(/<tr\b[^>]*>(?<row>.*?)<\/tr>/gu)].map((match) =>
+        [...match.groups!.row.matchAll(/<td\b[^>]*>(?<cell>.*?)<\/td>/gu)].map(
+          (cell) => cell.groups!.cell,
+        ),
+      );
+      expect(cells.map((row) => [row[2], row[3]])).toEqual(
+        mode === 'roles'
+          ? [
+              ['Decode GPUs', '691'],
+              ['All GPUs', '708'],
+              ['Prefill GPUs', '760'],
+            ]
+          : [
+              ['GPU measured', '708'],
+              ['GPU provisioned (TDP)', '1,400'],
+              ['Utility provisioned (all-in)', '1,920'],
+            ],
+      );
+      expect(points.every((point) => point.measuredAvgPower?.y === 708.1)).toBe(true);
+    },
+  );
+
   it('sorts supported modeled estimates by ascending power', () => {
     const definition = chartDefinitions[0];
     const metric = 'y_modeledChassisPowerPerGpu';
diff --git a/packages/app/src/components/inference/ui/InferenceTable.tsx b/packages/app/src/components/inference/ui/InferenceTable.tsx
index 3e6ce68f9..0d4e8ab74 100644
--- a/packages/app/src/components/inference/ui/InferenceTable.tsx
+++ b/packages/app/src/components/inference/ui/InferenceTable.tsx
@@ -147,8 +147,12 @@ export default function InferenceTable({
       {
         header: headers.yMetric,
         align: 'right',
-        cell: (row) => formatInferenceTableNumber(yPath ? getNestedYValue(row, yPath) : row.y),
-        sortValue: (row) => (yPath ? getNestedYValue(row, yPath) : row.y),
+        // Comparison clones keep the source metrics; y holds the plotted role/boundary.
+        cell: (row) =>
+          formatInferenceTableNumber(
+            row.powerVariant || !yPath ? row.y : getNestedYValue(row, yPath),
+          ),
+        sortValue: (row) => (row.powerVariant || !yPath ? row.y : getNestedYValue(row, yPath)),
         className: 'tabular-nums',
         importance: 'key',
       },
diff --git a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
index da5068e02..0373fc5bd 100644
--- a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
+++ b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
@@ -24,7 +24,7 @@ const STRINGS = {
     basisHelp:
       'Where power is counted. GPU measured: runner telemetry from the GPU boards. GPU provisioned: rated TDP per GPU. Utility provisioned: all-in provisioned utility power per GPU. Utility modeled: measured GPU power carried through the modeled chassis to the utility meter with PUE. Points without a value for the chosen boundary are omitted, never replaced with an estimate.',
     basisHint:
-      'Derived boundaries report whole-deployment average power and joules per output token. Changing another setting returns to GPU measured.',
+      'Derived boundaries report average power per chip across all GPUs, and whole-deployment joules per output token. Changing another setting returns to GPU measured.',
     scope: 'Scope',
     scopeHelp:
       'All GPUs measures the whole deployment. Prefill and decode select only GPUs serving that role.',
@@ -63,7 +63,8 @@ const STRINGS = {
     basis: '功耗边界',
     basisHelp:
       '选择功耗的计量边界。GPU 实测：来自 GPU 板卡的运行器遥测；GPU 额定：每 GPU 的额定 TDP；全电源配置：每 GPU 的全电源配置（all-in）市电功率；数据中心建模：将 GPU 实测功耗经机箱功耗模型推算至市电侧并计入 PUE。所选边界缺少数值的数据点将被省略，不会用估算值替代。',
-    basisHint: '推导边界仅提供整个部署的平均功耗和每输出 token 能耗；更改其他设置将返回 GPU 实测。',
+    basisHint:
+      '推导边界提供全部 GPU 的平均每芯片功率，以及整个部署的每输出 token 能耗；更改其他设置将返回 GPU 实测。',
     scope: '统计范围',
     scopeHelp: '全部 GPU 对应整个部署；预填充和解码仅统计承担相应任务的 GPU。',
     all: '全部 GPU',
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index 316d15d26..fb698bf0c 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -1015,7 +1015,10 @@ export default function PowerTimeline({
   const xTickFormat = useMemo(() => {
     if (xMode === 'elapsed') return (value: d3.AxisDomain) => formatElapsed(Number(value));
     const span = xDomain[1] - xDomain[0];
-    const format = d3.utcFormat(span < 3 * 60_000 ? '%H:%M:%S' : '%H:%M');
+    const crossesDate = formatUtcDate(new Date(xDomain[0])) !== formatUtcDate(new Date(xDomain[1]));
+    const format = d3.utcFormat(
+      crossesDate ? '%m/%d %H:%M' : span < 3 * 60_000 ? '%H:%M:%S' : '%H:%M',
+    );
     return (value: d3.AxisDomain) =>
       format(value instanceof Date ? value : new Date(Number(value)));
   }, [xMode, xDomain]);
diff --git a/packages/app/src/components/inference/ui/inference-table-sort.ts b/packages/app/src/components/inference/ui/inference-table-sort.ts
index d9eb9b8bf..112ec5062 100644
--- a/packages/app/src/components/inference/ui/inference-table-sort.ts
+++ b/packages/app/src/components/inference/ui/inference-table-sort.ts
@@ -25,8 +25,8 @@ export function sortRowsByYMetric(
   const yAscending = rooflineDir?.startsWith('lower');
 
   return [...data].toSorted((a, b) => {
-    const ay = getNestedYValue(a, yPath);
-    const by = getNestedYValue(b, yPath);
+    const ay = a.powerVariant ? a.y : getNestedYValue(a, yPath);
+    const by = b.powerVariant ? b.y : getNestedYValue(b, yPath);
     return yAscending ? ay - by : by - ay;
   });
 }
diff --git a/packages/app/src/lib/csv-export-helpers.test.ts b/packages/app/src/lib/csv-export-helpers.test.ts
index 467115ae6..b98449f27 100644
--- a/packages/app/src/lib/csv-export-helpers.test.ts
+++ b/packages/app/src/lib/csv-export-helpers.test.ts
@@ -8,6 +8,7 @@ import {
   historicalTrendToCsv,
 } from './csv-export-helpers';
 import type { InferenceData } from '@/components/inference/types';
+import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
 
 const makePoint = (overrides: Partial<InferenceData> = {}): InferenceData => ({
   x: 100,
@@ -776,6 +777,43 @@ describe('inferenceChartToCsv power comparison', () => {
     const column = headers.indexOf('Power Series');
     expect(column).toBeGreaterThan(-1);
     expect(rows.map((row) => row[column])).toEqual(['GPU measured', 'GPU provisioned (TDP)']);
+    expect(rows.map((row) => row[headers.indexOf('Measured Power per Chip (W)')])).toEqual([
+      600, 1000,
+    ]);
     expect(rows.every((row) => row.length === headers.length)).toBe(true);
   });
+
+  it.each([false, true])('exports plotted role values with overlay=%s', (overlay) => {
+    const base = makePoint({
+      hwKey: 'gb300_dynamo-trt',
+      y: 708.1,
+      measuredAvgPower: { y: 708.1, roof: false },
+      measuredPrefillAvgPower: { y: 760.442, roof: false },
+      measuredDecodeAvgPower: { y: 690.652, roof: false },
+      run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/35532106109',
+    });
+    const points = expandPowerCompareSeries([base], 'y_measuredAvgPower', 'roles');
+    const { headers, rows } = inferenceChartToCsv(
+      overlay ? [] : points,
+      'Kimi-K3',
+      'agentic-traces',
+      overlay ? points : [],
+      {
+        yHeader: 'Measured Power per Chip (W)',
+        yPath: 'measuredAvgPower.y',
+        xHeader: 'Interactivity (tok/s/user)',
+      },
+    );
+    expect(
+      rows.map((row) => [
+        row[headers.indexOf('Power Series')],
+        row[headers.indexOf('Measured Power per Chip (W)')],
+      ]),
+    ).toEqual([
+      ['All GPUs', 708.1],
+      ['Prefill GPUs', 760.442],
+      ['Decode GPUs', 690.652],
+    ]);
+    expect(points.every((point) => point.measuredAvgPower?.y === 708.1)).toBe(true);
+  });
 });
diff --git a/packages/app/src/lib/csv-export-helpers.ts b/packages/app/src/lib/csv-export-helpers.ts
index f4803a150..a58ba948f 100644
--- a/packages/app/src/lib/csv-export-helpers.ts
+++ b/packages/app/src/lib/csv-export-helpers.ts
@@ -125,7 +125,8 @@ export function inferenceChartToCsv(
     ? [
         {
           header: displayedMetrics.yHeader,
-          value: (point: InferenceData) => nestedMetric(point, displayedMetrics.yPath),
+          value: (point: InferenceData) =>
+            point.powerVariant ? point.y : nestedMetric(point, displayedMetrics.yPath),
         },
         { header: displayedMetrics.xHeader, value: (point: InferenceData) => point.x },
       ].filter(

From d98559b499c6c9b5e52aea7bcb48dd6751701aba Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Mon, 21 Sep 2026 13:46:00 -0700
Subject: [PATCH 023/103] fix: keep PowerX time axes and role labels readable
 on mobile
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Space timeline ticks by plot width and wrap long curve-label segments without dropping hardware, framework, or role text. Add desktop/mobile geometry and mobile ruler-drag coverage.

中文：修复 PowerX 手机端时间轴与角色标签的可读性。按绘图区宽度安排时间刻度，长曲线标签换行且保留硬件、框架及角色信息；补充桌面和手机布局回归以及手机宽度的标尺拖动测试。
---
 .../cypress/component/gpu-metrics-axis.cy.tsx | 41 ++++++++
 .../cypress/component/power-compare.cy.tsx    | 97 ++++++++++++++++++-
 .../cypress/component/power-timeline.cy.tsx   | 31 +++++-
 .../components/gpu-power/GpuPowerChart.tsx    |  9 +-
 .../components/inference/ui/PowerTimeline.tsx |  8 +-
 .../components/inference/ui/ScatterGraph.tsx  | 18 ++++
 6 files changed, 200 insertions(+), 4 deletions(-)

diff --git a/packages/app/cypress/component/gpu-metrics-axis.cy.tsx b/packages/app/cypress/component/gpu-metrics-axis.cy.tsx
index 2d7443411..3513fa5bb 100644
--- a/packages/app/cypress/component/gpu-metrics-axis.cy.tsx
+++ b/packages/app/cypress/component/gpu-metrics-axis.cy.tsx
@@ -56,6 +56,47 @@ describe('PowerX telemetry axis', () => {
     });
   }
 
+  for (const width of [1440, 390]) {
+    it(`keeps long telemetry time ticks separated at ${width}px with a right axis`, () => {
+      cy.viewport(width, 844);
+      const data = samples(() => 390).map((row, i) => ({
+        ...row,
+        timestamp: new Date(Date.UTC(2026, 8, 20) + (i % 21) * 340_000).toISOString(),
+      }));
+      cy.mount(
+        <div style={{ width: '100%', padding: 33 }}>
+          <GpuMetricsChart
+            data={data}
+            visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
+            metricKey="power"
+            artifactName="gpu_metrics_h200"
+            overlay={{
+              label: 'Decode throughput',
+              unit: 'tok/s',
+              color: '#a78bfa',
+              points: [
+                { ms: Date.UTC(2026, 8, 20), value: 500 },
+                { ms: Date.UTC(2026, 8, 20) + 6800_000, value: 2000 },
+              ],
+            }}
+          />
+        </div>,
+      );
+      svg()
+        .find('.x-axis .tick text')
+        .should(($ticks) => {
+          expect($ticks.length).to.be.greaterThan(1);
+          const boxes = [...$ticks].map((tick) => tick.getBoundingClientRect());
+          for (let i = 1; i < boxes.length; i++) {
+            expect(boxes[i].left, 'seconds labels do not overlap').to.be.greaterThan(
+              boxes[i - 1].right,
+            );
+          }
+        });
+      svg().screenshot(`gpu-telemetry-time-${width}`);
+    });
+  }
+
   it('does not magnify floating-point noise after rolling averages', () => {
     mountClock(samples((sample) => 390 - (sample % 2) * Number.EPSILON * 256));
     assertReadableAxis(390);
diff --git a/packages/app/cypress/component/power-compare.cy.tsx b/packages/app/cypress/component/power-compare.cy.tsx
index cca91215d..825d6c56b 100644
--- a/packages/app/cypress/component/power-compare.cy.tsx
+++ b/packages/app/cypress/component/power-compare.cy.tsx
@@ -121,6 +121,7 @@ function mountCompare(
   data: InferenceData[],
   options: {
     pathname?: string;
+    width?: number;
     overlay?: InferenceData[];
     hiddenNonOptimal?: boolean;
     metric?: CompareMetric;
@@ -133,7 +134,7 @@ function mountCompare(
   const metricKey = options.metric ?? 'y_measuredAvgPower';
   mountWithProviders(
     <PathnameContext.Provider value={options.pathname ?? '/inference'}>
-      <div style={{ width: 1000, height: 640 }}>
+      <div style={{ width: options.width ?? 1000, height: 640 }}>
         <ScatterGraph
           chartId="power-compare-test"
           modelLabel="DeepSeek V4 Pro"
@@ -251,6 +252,100 @@ describe('ScatterGraph power comparison series', () => {
     });
   });
 
+  it('wraps long role labels without losing the framework or role on mobile', () => {
+    cy.viewport(390, 844);
+    const data = expandPowerCompareSeries(
+      measuredCurve('gb200_dynamo-sglang'),
+      'y_measuredAvgPower',
+      'roles',
+    );
+    mountWithProviders(
+      <div style={{ width: '100%', maxWidth: 1000, padding: 33 }}>
+        <ScatterGraph
+          chartId="power-compare-test"
+          modelLabel="Qwen3.5 397B"
+          data={data}
+          xLabel="Interactivity"
+          yLabel={Y_LABELS.y_measuredAvgPower}
+          chartDefinition={chartDefinition}
+        />
+      </div>,
+      {
+        inference: {
+          selectedYAxisMetric: 'y_measuredAvgPower',
+          hardwareConfig: {
+            ...hwConfig,
+            'gb200_dynamo-sglang': {
+              name: 'gb200',
+              label: 'GB200 NVL72',
+              suffix: '(Dynamo SGLang)',
+              gpu: 'GB200',
+            },
+          },
+          activeHwTypes: new Set(['gb200_dynamo-sglang']),
+          hwTypesWithData: new Set(['gb200_dynamo-sglang']),
+          selectedPrecisions: [Precision.FP4],
+          hideNonOptimal: false,
+          showLineLabels: true,
+        },
+        unofficial: {},
+      },
+    );
+    cy.get(lineLabel('prefill'))
+      .should('contain.text', 'Dynamo SGLang')
+      .and('contain.text', 'Prefill');
+    cy.get(lineLabel('decode')).should('contain.text', 'Decode');
+    cy.get(svg).should(($svg) => {
+      const clipWidth = Number($svg.find('clipPath rect')[0].getAttribute('width'));
+      const labels = $svg
+        .find('.line-label')
+        .toArray()
+        .filter((el) => el.style.opacity !== '0');
+      expect(labels).to.have.length(3);
+      for (const label of labels) {
+        const box = label.querySelector('.ll-bg')!.getBoundingClientRect();
+        expect(box.width, label.textContent ?? '').to.be.at.most(clipWidth + 1);
+      }
+    });
+    cy.get(svg).first().screenshot('power-roles-mobile-wrapped');
+    cy.viewport(1440, 900);
+    cy.get(lineLabel('prefill'))
+      .find('.ll-bg')
+      .should(($rect) => {
+        expect(
+          $rect[0].getBoundingClientRect().height,
+          'desktop uses a single line',
+        ).to.be.lessThan(30);
+      });
+    cy.get(svg).first().screenshot('power-roles-desktop-unwrapped');
+  });
+
+  it('updates a performance ruler at mobile width when dragged', () => {
+    cy.viewport(390, 844);
+    mountCompare(expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles'), {
+      width: 324,
+    });
+    cy.contains('button', 'Advanced').click();
+    cy.get('#scatter-perf-ruler').click();
+    cy.get(`${svg} .perf-ruler-hit`).eq(0).click({ force: true });
+    cy.get(`${svg} .perf-ruler-hit`).eq(1).click({ force: true });
+    cy.get(`${svg} .pr-drag`)
+      .should('have.length', 1)
+      .then(($line) => {
+        const line = $line[0];
+        const before = line.getAttribute('x1');
+        const box = line.getBoundingClientRect();
+        const view = line.ownerDocument.defaultView!;
+        const start = { clientX: box.x, clientY: box.y + box.height / 2, view, bubbles: true };
+        line.dispatchEvent(new MouseEvent('mousedown', { ...start, button: 0, buttons: 1 }));
+        view.dispatchEvent(
+          new MouseEvent('mousemove', { ...start, clientX: box.x + 20, buttons: 1 }),
+        );
+        view.dispatchEvent(new MouseEvent('mouseup', { ...start, clientX: box.x + 20 }));
+        cy.get(`${svg} .pr-drag`).invoke('attr', 'x1').should('not.equal', before);
+      });
+  });
+
   it('draws each boundary as a dashed sibling series in the hardware colour with a toggling legend row', () => {
     const data = expandPowerCompareSeries(
       measuredCurve('b200'),
diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index 47fd413c4..8356149ab 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -166,13 +166,14 @@ function mountTimeline(
   data: InferenceData[],
   options: {
     pathname?: string;
+    width?: number;
     overlay?: Parameters<typeof PowerTimeline>[0]['overlayData'];
     unofficial?: Parameters<typeof createMockUnofficialRunContext>[0];
   } = {},
 ) {
   mountWithProviders(
     <PathnameContext.Provider value={options.pathname ?? '/inference'}>
-      <div style={{ width: 1100, height: 700 }}>
+      <div style={{ width: options.width ?? 1100, height: 700 }}>
         <PowerTimeline
           chartId="power-timeline-test"
           data={data}
@@ -228,6 +229,34 @@ describe('PowerTimeline', () => {
     svg().screenshot('power-timeline-multiday');
   });
 
+  it('keeps mobile wall-clock dates separated', () => {
+    cy.viewport(390, 844);
+    cy.intercept('GET', '/api/gpu-metrics*', {
+      body: {
+        ...response,
+        series: response.series.map((trace, index) => ({
+          ...trace,
+          startMs: trace.startMs + index * 2 * 24 * 60 * 60_000,
+        })),
+      },
+    }).as('series');
+    mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('b200', 64, 900)], {
+      width: 324,
+    });
+    cy.wait('@series');
+    cy.get('[data-testid="power-timeline-axis-wall"]').click();
+    svg()
+      .find('.x-axis .tick text')
+      .should(($ticks) => {
+        expect($ticks.length).to.be.greaterThan(1);
+        const boxes = [...$ticks].map((tick) => tick.getBoundingClientRect());
+        for (let i = 1; i < boxes.length; i++) {
+          expect(boxes[i].left, 'date labels do not overlap').to.be.greaterThan(boxes[i - 1].right);
+        }
+      });
+    svg().screenshot('power-timeline-mobile-dates');
+  });
+
   it('fetches one prefixed series request per run and draws the job with its window emphasized', () => {
     cy.intercept('GET', '/api/gpu-metrics*', { body: response }).as('series');
     mountTimeline([
diff --git a/packages/app/src/components/gpu-power/GpuPowerChart.tsx b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
index ab5c6c9dc..3550efacd 100644
--- a/packages/app/src/components/gpu-power/GpuPowerChart.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
@@ -418,7 +418,14 @@ const GpuMetricsChart = React.memo(
         instructions={t.instructions}
         xScale={{ type: 'linear', domain: xDomain, nice: true }}
         yScale={{ type: 'linear', domain: yDomain, nice: true }}
-        xAxis={{ label: t.seconds, tickCount: 10 }}
+        xAxis={{
+          label: t.seconds,
+          tickValues: (scale) => {
+            const secondsScale = scale as d3.ScaleLinear<number, number>;
+            const [left, right] = secondsScale.range();
+            return secondsScale.ticks(Math.max(2, Math.min(10, Math.floor((right - left) / 60))));
+          },
+        }}
         yAxis={{ label: getGpuMetricYAxisLabel(metricConfig, locale), tickCount: 8 }}
         layers={[
           // TDP reference line (power metric only)
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index fb698bf0c..c3f04f156 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -1361,7 +1361,13 @@ export default function PowerTimeline({
         yScale={{ type: 'linear', domain: yDomain, nice: true }}
         xAxis={{
           label: xMode === 'wall' ? t.xWall : t.xElapsed,
-          tickCount: 10,
+          tickValues: (scale) => {
+            const timeScale = scale as
+              | d3.ScaleTime<number, number>
+              | d3.ScaleLinear<number, number>;
+            const [left, right] = timeScale.range();
+            return timeScale.ticks(Math.max(2, Math.min(10, Math.floor((right - left) / 80))));
+          },
           tickFormat: xTickFormat,
         }}
         yAxis={{ label: lineMode === 'pool' ? t.yPool : yLabel, tickCount: 8 }}
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index e39bd894f..01b356fa6 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -5,6 +5,7 @@ import { isPersistedBenchmarkId } from '@/lib/benchmark-id';
 import { useEphemeralUrlState } from '@/hooks/useUrlState';
 import { rememberChartStateInUrl } from '@/lib/url-state';
 import * as d3 from 'd3';
+import { CHART_TYPE } from '@/lib/d3-chart/typography';
 import dynamic from 'next/dynamic';
 import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
 
@@ -3090,7 +3091,24 @@ const ScatterGraph = React.memo(
                 .attr('class', (segment) => segment.className)
                 .attr('fill', (segment) => segment.fill)
                 .attr('font-weight', (segment) => segment.weight)
+                .attr('x', null)
+                .attr('dy', null)
                 .text((segment) => segment.text);
+              // Keep the framework and role visible when a pill is wider than
+              // the mobile plot, without shrinking its text or dropping fields.
+              const textX = Number(text.attr('x') ?? 0);
+              const maxLineWidth = ctx.width - textX - 10;
+              let lineWidth = 0;
+              text.selectAll<SVGTSpanElement, unknown>('tspan').each(function () {
+                const width = this.getComputedTextLength();
+                if (lineWidth > 0 && lineWidth + width > maxLineWidth) {
+                  d3.select(this)
+                    .attr('x', textX)
+                    .attr('dy', CHART_TYPE.lineLabel + 3);
+                  lineWidth = 0;
+                }
+                lineWidth += width;
+              });
             },
           });
           // Labels can be joined independently of the Pareto display pass.

From a6c2f5361b9ee67f7f736fe76fef40d825065f16 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 22 Sep 2026 10:16:54 -0700
Subject: [PATCH 024/103] fix: use stored PowerX full-record statistics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：全记录统计复用数据库摘要，统一 NVIDIA、AMD 和多节点指标的单位、缺失值、重复样本与时间戳语义；包含统计界面、API、回归测试和文档，不改变 serving-window 功率或 J/token。
---
 docs/dashboard-readonly-views.md              |   9 +-
 docs/data-pipeline.md                         |  11 +
 docs/powerx-persistence-recovery.md           |  21 ++
 .../cypress/component/gpu-stats-table.cy.tsx  | 156 ++++++++++++++
 .../api/v1/views/gpu-metrics/route.test.ts    | 160 ++++++++++++++
 .../src/app/api/v1/views/gpu-metrics/route.ts |  11 +-
 .../components/gpu-power/GpuPowerDisplay.tsx  |  12 +-
 .../components/gpu-power/GpuStatsTable.tsx    |  99 +++++----
 .../gpu-power/stored-gpu-stats.test.ts        | 197 ++++++++++++++++++
 .../components/gpu-power/stored-gpu-stats.ts  |  28 +++
 .../src/components/gpu-power/types.test.ts    |  61 +++++-
 .../app/src/components/gpu-power/types.ts     | 110 +++++-----
 .../agentic-point/power-telemetry-view.tsx    |   2 +-
 packages/app/src/lib/api-route-catalog.ts     |  18 +-
 .../app/src/lib/views-api/docs/extensions.ts  |  24 ++-
 .../skills/inferencex-api/integrity.json      |   2 +-
 .../references/dashboard-views.md             |  10 +-
 17 files changed, 814 insertions(+), 117 deletions(-)
 create mode 100644 docs/powerx-persistence-recovery.md
 create mode 100644 packages/app/cypress/component/gpu-stats-table.cy.tsx
 create mode 100644 packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
 create mode 100644 packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
 create mode 100644 packages/app/src/components/gpu-power/stored-gpu-stats.ts

diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 3c926b5dd..4874f2fe0 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -45,7 +45,9 @@ combinations, not the full Cartesian product of all possible filter values.
 - Evaluation/reliability: chart-data, date resolution and rolling aggregation.
 - OperatorX/CollectiveX: selected operator sweep, EP/KV/swap chart and fit helpers.
 - Submissions/images: existing table, weekly/cumulative and image freshness helpers.
-- GPU metrics: shared line/correlation transforms and unsampled statistics.
+- GPU metrics: shared line/correlation transforms and stored full-record per-GPU
+  digests. Live artifacts alone calculate statistics from samples; empty stored
+  digests remain empty. Missing-versus-zero semantics persist.
 - Video: checksum-verified stored bundles, serving/fidelity selectors and tradeoffs.
 - Overview/rankings/compare: existing discovery-page assembly and scenario helpers.
 
@@ -59,6 +61,9 @@ The AI-chart data source maps to inference; private provider keys, prompts and
 locally generated assets do not become public API data. Feedback is sensitive.
 Zoom, theme, axis scale, labels, media playback and report expansion are renderer
 state. GPU interactive downsampling does not alter returned raw data or statistics.
+The GPU statistics table includes startup and warmup for all chips in the selected
+series, regardless of chip visibility. It is separate from serving-window power,
+J/token and selected-time-window calculations.
 
 ## Verification scope
 
@@ -78,6 +83,8 @@ those properties.
 视图）均在覆盖表中登记；上表列出各只读接口接受的全部查询参数名。
 接口复用现有计算函数，公开运行与非官方叠加数据保留各自来源。
 私有上传、密钥、提示词、反馈及管理操作不作为公开读取接口。
+全记录统计使用所选序列的全部芯片摘要，包含启动与 warmup；已有摘要为空时不补算，缺失读数不补零。
+芯片显隐和图表降采样不改变该统计，也不改变 serving-window 或 J/token 的计算口径。
 
 测试覆盖契约同步及代表性的筛选行为，并未穷举所有参数组合。生产数据库上的
 完整 UI/API 对照仍需集成审查，不能仅凭单元测试宣称已完成。
diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index e486667b0..5d859a659 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -594,6 +594,17 @@ falls back to live GitHub artifacts otherwise (in-progress runs), and
 `/api/v1/gpu-metrics-point?id=` powers the PowerX tab of the per-point detail
 page.
 
+The public `/api/v1/views/gpu-metrics` projection and full-record UI table use the
+same stored per-GPU statistics digest for the selected file/host series. Empty or
+missing metric digests remain empty; only live artifacts calculate from samples.
+Statistics include startup and warmup, retain measured zero, and exclude missing
+readings per metric after first-wins timestamp/GPU deduplication. Mean is
+sample-weighted, percentiles interpolate at `p * (N - 1)`, and standard deviation
+divides by `N`. GPU visibility and chart downsampling do not alter this population.
+Serving-window power, J/token and selected-time-window calculations remain separate.
+
+中文：全记录统计使用已存摘要，包含启动与 warmup；缺失读数不补零，已有摘要为空时不重新计算。它与 serving-window 功率、J/token 和用户所选时间窗口的统计分别处理。
+
 ### PowerX publication receipts
 
 The normal CI importer writes `POWER_PUBLICATION_MANIFEST` when configured. Each
diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
new file mode 100644
index 000000000..e46930ac8
--- /dev/null
+++ b/docs/powerx-persistence-recovery.md
@@ -0,0 +1,21 @@
+# PowerX persistence and repair
+
+## Full-record statistics
+
+The point detail, run explorer and public `/api/v1/views/gpu-metrics` projection use the
+stored per-GPU digest for the existing full-record statistics, with name mappings only.
+Units and percentile/stddev definitions are unchanged.
+Zero is a value; missing metrics or an empty digest remain missing. Live, un-ingested
+artifact data still computes statistics in the browser. These tables include startup and
+warmup. They are not serving-window power, energy, or user-selected-window statistics.
+
+For each file/host series and GPU, the population keeps the first row at each timestamp,
+then excludes missing or nonfinite readings separately for each metric. Live CSV parsing
+uses the same rule; a missing optional temperature or clock does not discard valid power.
+Count is exact, mean is sample-weighted, P50/P95/P99 use linear interpolation at
+`p * (N - 1)`, and standard deviation uses the population denominator `N`. Multi-host
+GPU indices must remain in separate series. No time weighting, smoothing, chart zoom or
+GPU visibility filter changes the full-record table. Window calculations still consume
+the selected samples, and serving energy/financial metrics retain their own definitions.
+SQL samples and digests use `real` (float32), so compare stored values with an explicit
+float32 tolerance rather than the tighter tolerance of the in-memory parser tests.
diff --git a/packages/app/cypress/component/gpu-stats-table.cy.tsx b/packages/app/cypress/component/gpu-stats-table.cy.tsx
new file mode 100644
index 000000000..b2e20052a
--- /dev/null
+++ b/packages/app/cypress/component/gpu-stats-table.cy.tsx
@@ -0,0 +1,156 @@
+import { useState } from 'react';
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import GpuStatsTable from '@/components/gpu-power/GpuStatsTable';
+import { parseCsvData, type GpuMetricKey } from '@/components/gpu-power/types';
+
+const storedStats: GpuMetricStatRow[] = [
+  {
+    gpuIndex: 0,
+    metric: 'power_w',
+    count: 3,
+    min: 0,
+    max: 100,
+    mean: 50,
+    median: 50,
+    p95: 95,
+    p99: 99,
+    stddev: Math.sqrt(5000 / 3),
+  },
+  {
+    gpuIndex: 1,
+    metric: 'power_w',
+    count: 2,
+    min: 0,
+    max: 0,
+    mean: 0,
+    median: 0,
+    p95: 0,
+    p99: 0,
+    stddev: 0,
+  },
+  {
+    gpuIndex: 0,
+    metric: 'gfx_voltage_mv',
+    count: 1,
+    min: 850,
+    max: 850,
+    mean: 850,
+    median: 850,
+    p95: 850,
+    p99: 850,
+    stddev: 0,
+  },
+];
+
+function StoredTable() {
+  const [metricKey, setMetricKey] = useState<GpuMetricKey>('power');
+  return (
+    <>
+      <button onClick={() => setMetricKey('gfxVoltage')}>Voltage</button>
+      <button onClick={() => setMetricKey('temperature')}>Uncollected</button>
+      <GpuStatsTable data={[]} metricKey={metricKey} storedStats={storedStats} />
+    </>
+  );
+}
+
+function EmptyDigest() {
+  const [digest, setDigest] = useState<GpuMetricStatRow[] | undefined>();
+  return (
+    <>
+      <button onClick={() => setDigest([])}>Read empty digest</button>
+      <GpuStatsTable
+        metricKey="power"
+        storedStats={digest}
+        data={[{ timestamp: '2026-09-21T00:00:00Z', index: 0, power: 100 }]}
+      />
+    </>
+  );
+}
+
+describe('PowerX full-record statistics', () => {
+  for (const width of [1280, 390]) {
+    it(`reads stored values, sorts, and switches metrics at ${width}px`, () => {
+      cy.viewport(width, 720);
+      cy.mount(<StoredTable />);
+      cy.get('[data-testid="gpu-stats-scope"]')
+        .should('contain.text', 'Full-record statistics include startup and warmup')
+        .then(($scope) => {
+          expect($scope[0].getBoundingClientRect().right).to.be.at.most(width);
+        });
+      // The full-record digest is authoritative; rendering never needs to scan raw samples.
+      cy.get('tbody tr').should('have.length', 2);
+      cy.get('tbody tr')
+        .first()
+        .find('td')
+        .then(($cells) => {
+          expect([...$cells].map((cell) => cell.textContent)).to.deep.equal([
+            '0',
+            '3',
+            '0.0',
+            '100.0',
+            '50.0',
+            '50.0',
+            '95.0',
+            '99.0',
+            '40.8',
+          ]);
+        });
+      cy.contains('button', 'Mean (W)').click();
+      cy.get('tbody tr').first().find('td').first().should('have.text', '1');
+      cy.contains('button', 'Voltage').click();
+      cy.contains('th', 'Mean (mV)').should('exist');
+      cy.get('tbody tr').should('have.length', 1).find('td').eq(4).should('have.text', '850.0');
+      cy.get('[data-testid="gpu-stats-scope"]').parent().screenshot(`powerx-stored-stats-${width}`);
+      cy.contains('button', 'Uncollected').click();
+      cy.get('table').should('not.exist');
+    });
+  }
+
+  it('keeps Chinese labels and measured zeros in the stored digest', () => {
+    cy.viewport(390, 720);
+    cy.mount(
+      <PathnameContext.Provider value="/zh/gpu-metrics">
+        <StoredTable />
+      </PathnameContext.Provider>,
+    );
+    cy.contains('th', '平均值 (W)').should('exist');
+    cy.get('[data-testid="gpu-stats-scope"]').should(
+      'contain.text',
+      '全记录统计，包含服务启动与 warmup',
+    );
+    cy.get('tbody tr').last().find('td').eq(4).should('have.text', '0.0');
+    cy.get('[data-testid="gpu-stats-scope"]').parent().screenshot('powerx-stored-stats-zh-390');
+  });
+
+  it('computes a live artifact without a stored digest', () => {
+    cy.mount(
+      <GpuStatsTable
+        metricKey="power"
+        data={[
+          { timestamp: '2026-09-21T00:00:00Z', index: 0, power: 0 },
+          { timestamp: '2026-09-21T00:00:01Z', index: 0, power: 100 },
+        ]}
+      />,
+    );
+    cy.get('tbody tr').find('td').eq(4).should('have.text', '50.0');
+  });
+
+  it('does not synthesize stats when the stored digest is empty', () => {
+    cy.mount(<EmptyDigest />);
+    cy.get('table').should('exist');
+    cy.contains('button', 'Read empty digest').click();
+    cy.get('table').should('not.exist');
+  });
+
+  it('keeps a live CSV missing temperature separate from zero and duplicate readings', () => {
+    const data = parseCsvData(
+      'timestamp,gpu,socket_power,hotspot\n1789948800,0,0,N/A\n1789948801.0009,0,100,0\n1789948801.0011,0,900,90',
+    );
+    cy.mount(<GpuStatsTable metricKey="temperature" data={data} />);
+    cy.contains('th', 'Mean (°C)').should('exist');
+    cy.get('tbody tr').find('td').eq(1).should('have.text', '1');
+    cy.get('tbody tr').find('td').eq(4).should('have.text', '0.0');
+  });
+});
diff --git a/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts b/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
new file mode 100644
index 000000000..b9e708afe
--- /dev/null
+++ b/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
@@ -0,0 +1,160 @@
+import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+import type { GpuMetricsArtifact, GpuPowerApiResponse } from '@/components/gpu-power/types';
+import { NextRequest } from 'next/server';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { metrics } = vi.hoisted(() => ({ metrics: vi.fn() }));
+vi.mock('@/app/api/gpu-metrics/route', () => ({ GET: metrics }));
+// These source handlers are imported by the shared source module, but this view never calls them.
+vi.mock('@/app/api/v1/benchmarks/route', () => ({ GET: vi.fn() }));
+vi.mock('@/app/api/unofficial-run/route', () => ({ GET: vi.fn() }));
+
+import { GET } from './route';
+
+const rows = [
+  { timestamp: '2026-09-08T00:00:00Z', index: 0, power: 100, temperature: 40 },
+  { timestamp: '2026-09-08T00:00:01Z', index: 0, power: 300, temperature: 42 },
+  { timestamp: '2026-09-08T00:00:01Z', index: 1, power: 50, temperature: 38 },
+];
+const digest: GpuMetricStatRow[] = [
+  {
+    gpuIndex: 0,
+    metric: 'power_w',
+    count: 10,
+    min: 0,
+    max: 800,
+    mean: 350,
+    median: 300,
+    p95: 750,
+    p99: 790,
+    stddev: 200,
+  },
+  {
+    gpuIndex: 1,
+    metric: 'power_w',
+    count: 12,
+    min: 100,
+    max: 900,
+    mean: 700,
+    median: 750,
+    p95: 880,
+    p99: 898,
+    stddev: 80,
+  },
+];
+function artifact(stats: GpuMetricStatRow[] = digest): GpuMetricsArtifact {
+  return {
+    name: 'gpu_metrics_retained/host-a/gpu_metrics.csv',
+    data: rows,
+    series: {
+      id: 1,
+      artifactName: 'gpu_metrics_retained',
+      configKey: 'retained',
+      fileName: 'host-a/gpu_metrics.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 22,
+      gpuCount: 2,
+      startedAt: '2026-09-08T00:00:00Z',
+      endedAt: '2026-09-08T00:00:10Z',
+      sidecars: {},
+      benchmarkResultIds: [10, 11],
+      stats,
+    },
+  };
+}
+const runInfo = {
+  id: 34175132645,
+  name: 'Run Sweep',
+  branch: 'main',
+  sha: 'retained-source',
+  createdAt: '2026-09-08T00:00:00Z',
+  url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645',
+  conclusion: 'success',
+  status: 'completed',
+};
+function source(artifacts: GpuMetricsArtifact[]) {
+  const payload: GpuPowerApiResponse = { runInfo, artifacts };
+  metrics.mockImplementation(() => Response.json(payload));
+}
+const request = (query = '') =>
+  new NextRequest(`http://localhost/api/v1/views/gpu-metrics?runId=${runInfo.id}${query}`);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  source([artifact()]);
+});
+
+describe('GET /api/v1/views/gpu-metrics full-record statistics', () => {
+  it('returns the stored digest even when raw rows would produce different statistics', async () => {
+    const response = await GET(request());
+    expect(response.status).toBe(200);
+    expect(response.headers.get('cache-control')).toBe('private, no-store');
+    const body = await response.json();
+    expect(body.stats).toEqual(digest);
+    expect(body.rows).toEqual(rows);
+    expect(metrics.mock.calls[0][0].nextUrl.searchParams.get('runId')).toBe(String(runInfo.id));
+  });
+
+  it.each(['empty digest', 'uncollected metric'])(
+    'keeps an authoritative %s empty',
+    async (kind) => {
+      if (kind === 'empty digest') source([artifact([])]);
+      const response = await GET(
+        request(kind === 'uncollected metric' ? '&metric=temperature' : ''),
+      );
+      expect(response.status).toBe(200);
+      const body = await response.json();
+      expect(body.stats).toEqual([]);
+    },
+  );
+
+  it('sorts all stored chips while visibility filters only raw rows and the real chart', async () => {
+    const response = await GET(request('&gpus=0&sort=mean&direction=desc'));
+    const body = await response.json();
+    expect(body.stats).toEqual([digest[1], digest[0]]);
+    expect(body.rows).toEqual(rows.slice(0, 2));
+    expect(Object.keys(body.chart)).toEqual(['0']);
+    expect(body.chart['0'].map((point: { value: number }) => point.value)).toEqual([100, 300]);
+    expect(body.params).toMatchObject({ gpus: [0], sort: 'mean', direction: 'desc' });
+  });
+
+  it('computes full-record sample statistics for a live artifact without a stored digest', async () => {
+    source([{ name: 'gpu_metrics_live', data: rows }]);
+    const response = await GET(request('&gpus=1'));
+    const body = await response.json();
+    expect(body.stats).toEqual([
+      {
+        gpuIndex: 0,
+        count: 2,
+        min: 100,
+        max: 300,
+        mean: 200,
+        median: 200,
+        p95: 290,
+        p99: 298,
+        stddev: 100,
+      },
+      {
+        gpuIndex: 1,
+        count: 1,
+        min: 50,
+        max: 50,
+        mean: 50,
+        median: 50,
+        p95: 50,
+        p99: 50,
+        stddev: 0,
+      },
+    ]);
+    expect(body.rows).toEqual([rows[2]]);
+  });
+
+  it('preserves a source database failure as an uncached 503 through the real error wrapper', async () => {
+    metrics.mockResolvedValue(Response.json({ code: 'DATABASE_UNAVAILABLE' }, { status: 503 }));
+    const response = await GET(request());
+    expect(response.status).toBe(503);
+    expect(response.headers.get('cache-control')).toBe('private, no-store');
+    expect(await response.json()).toEqual({ error: 'Source data unavailable' });
+  });
+});
diff --git a/packages/app/src/app/api/v1/views/gpu-metrics/route.ts b/packages/app/src/app/api/v1/views/gpu-metrics/route.ts
index 253c8bb1f..01dd9997d 100644
--- a/packages/app/src/app/api/v1/views/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/v1/views/gpu-metrics/route.ts
@@ -1,5 +1,6 @@
 import { GET as metrics } from '@/app/api/gpu-metrics/route';
 import { buildCorrelationData, buildGroupedData } from '@/components/gpu-power/chart-data';
+import { storedGpuStatsForMetric } from '@/components/gpu-power/stored-gpu-stats';
 import {
   ALL_METRIC_OPTIONS,
   computeGpuStats,
@@ -21,7 +22,7 @@ import { type NextRequest, NextResponse } from 'next/server';
 export const dynamic = 'force-dynamic';
 export const maxDuration = 300;
 
-/** Live metrics intentionally bypass both CDN and Blob caching. */
+/** Stored and live metrics bypass response caching so repairs remain observable. */
 export function GET(request: NextRequest) {
   return runViewsRoute('gpu-metrics', async () => {
     validateViewParams(request.nextUrl.searchParams, VIEW_QUERY_PARAMS['gpu-metrics']);
@@ -70,9 +71,11 @@ export function GET(request: NextRequest) {
     );
     const direction = parseEnumParam(s.get('direction'), 'direction', ['asc', 'desc'], 'asc');
     // The UI statistics table uses all chips; chart visibility does not filter it.
-    const stats = computeGpuStats(rows, metric).sort(
-      (a, b) => (a[sort] - b[sort]) * (direction === 'asc' ? 1 : -1),
-    );
+    const stats = (
+      selected?.series
+        ? storedGpuStatsForMetric(selected.series.stats, metric)
+        : computeGpuStats(rows, metric)
+    ).sort((a, b) => (a[sort] - b[sort]) * (direction === 'asc' ? 1 : -1));
     return NextResponse.json(
       {
         view: 'gpu-metrics',
diff --git a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
index c5e5d4d77..b3cbcff16 100644
--- a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
@@ -204,10 +204,8 @@ export default function GpuMetricsDisplay() {
     artifacts.some((artifact) => artifact.name === selectedArtifactCandidate)
       ? selectedArtifactCandidate
       : (artifacts[0]?.name ?? '');
-  const currentData = useMemo(
-    () => artifacts.find((artifact) => artifact.name === selectedArtifact)?.data ?? [],
-    [artifacts, selectedArtifact],
-  );
+  const currentArtifact = artifacts.find((artifact) => artifact.name === selectedArtifact);
+  const currentData = useMemo(() => currentArtifact?.data ?? [], [currentArtifact]);
   const availableMetrics = useMemo(() => getAvailableMetrics(currentData), [currentData]);
   const urlMetric = searchParams.get('gm_metric');
   const selectedMetricCandidate = selectionApplies ? selection.metric : urlMetric;
@@ -775,7 +773,11 @@ export default function GpuMetricsDisplay() {
             <h3 className="text-sm font-semibold mb-2">
               {t.perGpuStats} ({getGpuMetricLabel(metricConfig, locale)})
             </h3>
-            <GpuStatsTable data={currentData} metricKey={selectedMetric} />
+            <GpuStatsTable
+              data={currentData}
+              metricKey={selectedMetric}
+              storedStats={currentArtifact?.series?.stats}
+            />
           </Card>
         </>
       )}
diff --git a/packages/app/src/components/gpu-power/GpuStatsTable.tsx b/packages/app/src/components/gpu-power/GpuStatsTable.tsx
index 2d569786a..d301f5acb 100644
--- a/packages/app/src/components/gpu-power/GpuStatsTable.tsx
+++ b/packages/app/src/components/gpu-power/GpuStatsTable.tsx
@@ -1,9 +1,11 @@
 'use client';
 
 import React, { useMemo, useState } from 'react';
+import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
 
 import { track } from '@/lib/analytics';
 import { useLocale } from '@/lib/use-locale';
+import { storedGpuStatsForMetric } from './stored-gpu-stats';
 
 import {
   type GpuMetricKey,
@@ -16,18 +18,26 @@ import {
 interface GpuStatsTableProps {
   data: GpuMetricRow[];
   metricKey: GpuMetricKey;
+  /** Full-record digest; omit only for live artifacts without stored statistics. */
+  storedStats?: readonly GpuMetricStatRow[];
 }
 
 type SortCol = keyof GpuStats;
 
 const fmtStat = (v: number) => (v >= 1000 ? v.toFixed(0) : v.toFixed(1));
 
-const GpuStatsTable = React.memo(({ data, metricKey }: GpuStatsTableProps) => {
+const GpuStatsTable = React.memo(({ data, metricKey, storedStats }: GpuStatsTableProps) => {
   const locale = useLocale();
   const [sortCol, setSortCol] = useState<SortCol>('gpuIndex');
   const [sortAsc, setSortAsc] = useState(true);
 
-  const stats = useMemo(() => computeGpuStats(data, metricKey), [data, metricKey]);
+  const stats = useMemo(
+    () =>
+      storedStats === undefined
+        ? computeGpuStats(data, metricKey)
+        : storedGpuStatsForMetric(storedStats, metricKey),
+    [data, metricKey, storedStats],
+  );
   const metricConfig = ALL_METRIC_OPTIONS.find((m) => m.key === metricKey)!;
 
   const sorted = useMemo(
@@ -66,47 +76,54 @@ const GpuStatsTable = React.memo(({ data, metricKey }: GpuStatsTableProps) => {
   ];
 
   return (
-    <div className="overflow-x-auto">
-      <table className="w-full text-xs">
-        <thead>
-          <tr className="border-b">
-            {cols.map((c) => (
-              <th
-                key={c.key}
-                className="px-2 py-1.5 text-left font-medium text-muted-foreground"
-                aria-sort={sortCol === c.key ? (sortAsc ? 'ascending' : 'descending') : 'none'}
-              >
-                <button
-                  type="button"
-                  className="cursor-pointer select-none hover:text-foreground"
-                  onClick={() => handleSort(c.key)}
+    <div>
+      <p className="mb-2 text-xs text-muted-foreground" data-testid="gpu-stats-scope">
+        {locale === 'zh'
+          ? '全记录统计，包含服务启动与 warmup；不随图表所选时间窗口变化。'
+          : 'Full-record statistics include startup and warmup; the selected chart window does not change this table.'}
+      </p>
+      <div className="overflow-x-auto">
+        <table className="w-full text-xs">
+          <thead>
+            <tr className="border-b">
+              {cols.map((c) => (
+                <th
+                  key={c.key}
+                  className="px-2 py-1.5 text-left font-medium text-muted-foreground"
+                  aria-sort={sortCol === c.key ? (sortAsc ? 'ascending' : 'descending') : 'none'}
                 >
-                  {c.label}
-                  {c.key !== 'gpuIndex' && c.key !== 'count' ? ` (${metricConfig.unit})` : ''}
-                  {sortCol === c.key && (sortAsc ? ' \u2191' : ' \u2193')}
-                </button>
-              </th>
-            ))}
-          </tr>
-        </thead>
-        <tbody>
-          {sorted.map((s) => (
-            <tr key={s.gpuIndex} className="border-b border-border/50 hover:bg-muted/50">
-              <td className="px-2 py-1 font-medium">{s.gpuIndex}</td>
-              <td className="px-2 py-1">
-                {locale === 'zh' ? s.count.toLocaleString('zh-CN') : s.count.toLocaleString()}
-              </td>
-              <td className="px-2 py-1">{fmtStat(s.min)}</td>
-              <td className="px-2 py-1">{fmtStat(s.max)}</td>
-              <td className="px-2 py-1">{fmtStat(s.mean)}</td>
-              <td className="px-2 py-1">{fmtStat(s.median)}</td>
-              <td className="px-2 py-1">{fmtStat(s.p95)}</td>
-              <td className="px-2 py-1">{fmtStat(s.p99)}</td>
-              <td className="px-2 py-1">{fmtStat(s.stddev)}</td>
+                  <button
+                    type="button"
+                    className="cursor-pointer select-none hover:text-foreground"
+                    onClick={() => handleSort(c.key)}
+                  >
+                    {c.label}
+                    {c.key !== 'gpuIndex' && c.key !== 'count' ? ` (${metricConfig.unit})` : ''}
+                    {sortCol === c.key && (sortAsc ? ' \u2191' : ' \u2193')}
+                  </button>
+                </th>
+              ))}
             </tr>
-          ))}
-        </tbody>
-      </table>
+          </thead>
+          <tbody>
+            {sorted.map((s) => (
+              <tr key={s.gpuIndex} className="border-b border-border/50 hover:bg-muted/50">
+                <td className="px-2 py-1 font-medium">{s.gpuIndex}</td>
+                <td className="px-2 py-1">
+                  {locale === 'zh' ? s.count.toLocaleString('zh-CN') : s.count.toLocaleString()}
+                </td>
+                <td className="px-2 py-1">{fmtStat(s.min)}</td>
+                <td className="px-2 py-1">{fmtStat(s.max)}</td>
+                <td className="px-2 py-1">{fmtStat(s.mean)}</td>
+                <td className="px-2 py-1">{fmtStat(s.median)}</td>
+                <td className="px-2 py-1">{fmtStat(s.p95)}</td>
+                <td className="px-2 py-1">{fmtStat(s.p99)}</td>
+                <td className="px-2 py-1">{fmtStat(s.stddev)}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
     </div>
   );
 });
diff --git a/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts b/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
new file mode 100644
index 000000000..676f8703b
--- /dev/null
+++ b/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
@@ -0,0 +1,197 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  computeGpuMetricStats,
+  parseGpuMetricsCsv,
+  type GpuMetricSample,
+} from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
+import {
+  prepareGpuMetricsArtifact,
+  statMetricColumn,
+} from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
+import { parseMultinodePowerSamples } from '@semianalysisai/inferencex-db/etl/multinode-power-samples';
+
+import { storedGpuStatsForMetric } from './stored-gpu-stats';
+import { ALL_METRIC_OPTIONS, computeGpuStats, parseCsvData, type GpuMetricRow } from './types';
+
+function storedStats(samples: GpuMetricSample[]) {
+  return computeGpuMetricStats(samples).map((row) => ({
+    ...row,
+    metric: statMetricColumn(row.metric),
+  }));
+}
+
+function assertAllMetricStats(samples: GpuMetricSample[], rows: GpuMetricRow[]) {
+  const digest = storedStats(samples);
+  for (const { key } of ALL_METRIC_OPTIONS) {
+    const actual = storedGpuStatsForMetric(digest, key);
+    const expected = computeGpuStats(rows, key);
+    expect(actual, key).toHaveLength(expected.length);
+    for (const [index, row] of actual.entries()) {
+      expect(row.gpuIndex).toBe(expected[index].gpuIndex);
+      expect(row.count).toBe(expected[index].count);
+      // ETL sums sorted samples while the live reader sums recording order.
+      for (const field of ['min', 'max', 'mean', 'median', 'p95', 'p99', 'stddev'] as const) {
+        expect(row[field], `${key}.${field}`).toBeCloseTo(expected[index][field], 10);
+      }
+    }
+  }
+}
+
+describe('storedGpuStatsForMetric', () => {
+  it.each(['UTC', 'America/Los_Angeles'])(
+    'matches live NVIDIA and ingest populations across DST in %s',
+    (timezone) => {
+      const csv = [
+        'timestamp,index,power.draw [W]',
+        '2026/03/08 02:30:00.000,0,100',
+        '2026/03/08 02:30:00.000,0,900',
+        '2026/03/08 03:30:00.000,0,300',
+      ].join('\n');
+      const artifactDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-stats-dst-'));
+      const originalTimezone = process.env.TZ;
+      try {
+        process.env.TZ = timezone;
+        fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
+        const [prepared] = prepareGpuMetricsArtifact({
+          artifactDir,
+          artifactName: 'gpu_metrics_nvidia_dst',
+        });
+        expect(
+          prepared.samples.map((sample) => new Date(sample.timestampMs).toISOString()),
+        ).toEqual(['2026-03-08T02:30:00.000Z', '2026-03-08T03:30:00.000Z']);
+        const live = parseCsvData(csv);
+        // Preserve raw timestamps for the bundle's later context-offset adjustment.
+        expect(live.map((row) => row.timestamp)).toEqual([
+          '2026/03/08 02:30:00.000',
+          '2026/03/08 03:30:00.000',
+        ]);
+        expect(live.map((row) => row.power)).toEqual([100, 300]);
+        const actual = computeGpuStats(live, 'power');
+        expect(actual).toEqual([
+          {
+            gpuIndex: 0,
+            count: 2,
+            min: 100,
+            max: 300,
+            mean: 200,
+            median: 200,
+            p95: 290,
+            p99: 298,
+            stddev: 100,
+          },
+        ]);
+        const { metric: _metric, ...expected } = prepared.stats[0];
+        expect(actual).toEqual([expected]);
+      } finally {
+        if (originalTimezone === undefined) delete process.env.TZ;
+        else process.env.TZ = originalTimezone;
+        fs.rmSync(artifactDir, { recursive: true, force: true });
+      }
+    },
+  );
+
+  it.each([
+    ['fractional seconds sharing a rounded millisecond', '1789948800.0009', '1789948800.0011', 1],
+    [
+      'fractional seconds in distinct rounded milliseconds',
+      '1789948800.0001',
+      '1789948800.0009',
+      2,
+    ],
+    ['fractional milliseconds', '1789948800000.9', '1789948800001.1', 1],
+    ['epoch milliseconds and ISO', '1789948800001', '2026-09-20T17:00:00.001-07:00', 1],
+  ])('matches live AMD and ingest populations for %s', (_, first, second, count) => {
+    const csv = `timestamp,gpu,socket_power\n${first},0,100\n${second},0,900`;
+    const artifactDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-stats-timestamp-'));
+    try {
+      fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
+      // Exercise production ingest normalization/dedup/digest, not a test-owned dedup.
+      const [prepared] = prepareGpuMetricsArtifact({
+        artifactDir,
+        artifactName: 'gpu_metrics_amd_fractional_timestamp',
+      });
+      const digest = storedGpuStatsForMetric(
+        prepared.stats.map((row) => ({ ...row, metric: statMetricColumn(row.metric) })),
+        'power',
+      );
+      expect(digest[0]).toMatchObject({
+        count,
+        mean: count === 1 ? 100 : 500,
+        p95: count === 1 ? 100 : 860,
+      });
+      const live = parseCsvData(csv);
+      expect(live.map((row) => Date.parse(row.timestamp))).toEqual(
+        prepared.samples.map((sample) => sample.timestampMs),
+      );
+      const { metric: _metric, ...expected } = prepared.stats[0];
+      expect(computeGpuStats(live, 'power')).toEqual([expected]);
+    } finally {
+      fs.rmSync(artifactDir, { recursive: true, force: true });
+    }
+  });
+
+  it('preserves NVIDIA units, zero readings, and full-record percentiles', () => {
+    const csv = [
+      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+      '2026/09/21 00:00:00, 0, 0 W, N/A, 120 MHz, 3996 MHz, 0 %, 0 %',
+      '2026/09/21 00:00:01, 0, 912.1 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+      '2026/09/21 00:00:02, 0, 187.8 W, 35, 120 MHz, 3996 MHz, 0 %, 0 %',
+      // Conflicting stop-time flush must not change the first reading.
+      '2026/09/21 00:00:02, 0, 999 W, 90, 120 MHz, 3996 MHz, 0 %, 0 %',
+    ].join('\n');
+    const samples = parseGpuMetricsCsv(csv)!.samples.slice(0, 3);
+    assertAllMetricStats(samples, parseCsvData(csv));
+    const [power] = storedGpuStatsForMetric(storedStats(samples), 'power');
+    expect(power.count).toBe(3);
+    expect(power.median).toBe(187.8);
+    expect(power.p95).toBeCloseTo(839.67, 10);
+    expect(power.p99).toBeCloseTo(897.614, 10);
+  });
+
+  it('maps every AMD metric without converting missing readings to zero', () => {
+    const csv = [
+      'timestamp,gpu,gfx_activity,umc_activity,mm_activity,socket_power,gfx_voltage,soc_voltage,mem_voltage,gfx_0_clk,mem_0_clk,fclk_0_clk,socclk_0_clk,edge,hotspot,mem',
+      '1789948800,0,0,0,N/A,0,N/A,N/A,N/A,N/A,2000,1250,39,N/A,N/A,24',
+      '1789948801,0,95,80,5,1180,850,900,1250,2402,2050,1300,40,55,78,60',
+      '1789948801,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0',
+    ].join('\n');
+    const samples = parseGpuMetricsCsv(csv)!.samples.slice(0, 2);
+    assertAllMetricStats(samples, parseCsvData(csv));
+    expect(storedGpuStatsForMetric(storedStats(samples), 'gfxVoltage')[0]).toMatchObject({
+      count: 1,
+      mean: 850,
+      stddev: 0,
+    });
+  });
+
+  it('keeps multinode host-local GPU indices separate and does not invent non-power stats', () => {
+    const hosts = parseMultinodePowerSamples(
+      [
+        'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+        '1,1789948800,1,host-a,0,GPU-a0,0',
+        '1,1789948801,2,host-a,0,GPU-a0,500',
+        '1,1789948800,1,host-b,0,GPU-b0,800',
+      ].join('\n'),
+    )!;
+    for (const host of hosts) {
+      assertAllMetricStats(
+        host.samples,
+        host.samples.map((sample) => ({
+          timestamp: '',
+          index: sample.gpuIndex,
+          power: sample.powerW!,
+        })),
+      );
+    }
+    expect(storedGpuStatsForMetric(storedStats(hosts[0].samples), 'power')[0].mean).toBe(250);
+    expect(storedGpuStatsForMetric(storedStats(hosts[1].samples), 'power')[0].mean).toBe(800);
+    expect(storedGpuStatsForMetric(storedStats(hosts[0].samples), 'temperature')).toEqual([]);
+  });
+
+  it('keeps a missing digest metric empty', () => {
+    expect(storedGpuStatsForMetric([], 'power')).toEqual([]);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/stored-gpu-stats.ts b/packages/app/src/components/gpu-power/stored-gpu-stats.ts
new file mode 100644
index 000000000..21971e5e2
--- /dev/null
+++ b/packages/app/src/components/gpu-power/stored-gpu-stats.ts
@@ -0,0 +1,28 @@
+import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import type { GpuMetricKey, GpuStats } from './types';
+
+const STORED_METRIC: Record<GpuMetricKey, string> = {
+  power: 'power_w',
+  temperature: 'temperature_c',
+  smClock: 'sm_clock_mhz',
+  memClock: 'mem_clock_mhz',
+  gpuUtil: 'gpu_util_pct',
+  memUtil: 'mem_util_pct',
+  edgeTemp: 'edge_temp_c',
+  memTemp: 'mem_temp_c',
+  gfxVoltage: 'gfx_voltage_mv',
+  socVoltage: 'soc_voltage_mv',
+  memVoltage: 'mem_voltage_mv',
+  fclk: 'fclk_mhz',
+  socClk: 'socclk_mhz',
+  mmActivity: 'mm_activity_pct',
+};
+
+/** Full-record statistics, including startup/warmup; never a measured-window summary. */
+export function storedGpuStatsForMetric(
+  stats: readonly GpuMetricStatRow[],
+  metricKey: GpuMetricKey,
+): GpuStats[] {
+  return stats.filter((row) => row.metric === STORED_METRIC[metricKey]);
+}
diff --git a/packages/app/src/components/gpu-power/types.test.ts b/packages/app/src/components/gpu-power/types.test.ts
index 2886fdd30..74c3e598b 100644
--- a/packages/app/src/components/gpu-power/types.test.ts
+++ b/packages/app/src/components/gpu-power/types.test.ts
@@ -59,6 +59,20 @@ describe('parseCsvData', () => {
     expect(result[1].power).toBe(300.2);
   });
 
+  it('keeps ISO timestamps and deduplicates equivalent offset instants', () => {
+    const csv = `${CSV_HEADER}
+2026-03-08T02:30:00.000Z, 0, 100, 60, 1500, 2000, 95, 80
+2026-03-07T18:30:00.000-08:00, 0, 900, 60, 1500, 2000, 95, 80
+2026-03-08T03:30:00.000Z, 0, 300, 60, 1500, 2000, 95, 80`;
+    const rows = parseCsvData(csv);
+    expect(rows.map((row) => row.timestamp)).toEqual([
+      '2026-03-08T02:30:00.000Z',
+      '2026-03-08T03:30:00.000Z',
+    ]);
+    expect(rows.map((row) => row.power)).toEqual([100, 300]);
+    expect(computeGpuStats(rows, 'power')[0]).toMatchObject({ count: 2, mean: 200, p95: 290 });
+  });
+
   it('returns empty array for header-only CSV', () => {
     expect(parseCsvData(CSV_HEADER)).toEqual([]);
   });
@@ -67,13 +81,15 @@ describe('parseCsvData', () => {
     expect(parseCsvData('')).toEqual([]);
   });
 
-  it('skips rows with insufficient columns', () => {
+  it('retains valid power when secondary metric columns are missing', () => {
     const csv = `${CSV_HEADER}
 2026/03/07 00:20:37.071, 0, 76.78 W
 2026/03/07 00:20:37.071, 1, 76.08 W, 29, 345 MHz, 3201 MHz, 0 %, 0 %`;
     const result = parseCsvData(csv);
-    expect(result).toHaveLength(1);
-    expect(result[0].index).toBe(1);
+    expect(result).toHaveLength(2);
+    expect(result[0].index).toBe(0);
+    expect(result[0].power).toBe(76.78);
+    expect(result[0].temperature).toBeUndefined();
   });
 
   it('skips rows with NaN values', () => {
@@ -246,7 +262,44 @@ describe('parseCsvData', () => {
 1772939616,0,0,0,135,133,901,N/A,N/A,41`;
     const result = parseCsvData(csv);
     expect(result).toHaveLength(1);
-    expect(result[0].temperature).toBe(0); // defaults to 0 when both are N/A
+    expect(result[0].temperature).toBeUndefined();
+  });
+
+  it('NVIDIA: retains finite metrics, measured zeros and the first duplicate sample', () => {
+    const csv = `${CSV_HEADER}
+2026/03/07 00:20:37.071, 0, 0 W, N/A, Infinity, 3201 MHz, 0 %, N/A
+2026/03/07 00:20:37.071, 0, 900 W, 70, 1980 MHz, 3201 MHz, 99 %, 80 %
+2026/03/07 00:20:38.071, 0, 100 W, 40, 120 MHz, 3201 MHz, 0 %, 0 %
+2026/03/07 00:20:38.071, 1, Infinity, 40, 120 MHz, 3201 MHz, 0 %, 0 %`;
+    const rows = parseCsvData(csv);
+    expect(rows).toHaveLength(2);
+    expect(rows[0]).toMatchObject({ power: 0, gpuUtil: 0 });
+    expect(rows[0].temperature).toBeUndefined();
+    expect(rows[0].smClock).toBeUndefined();
+    expect(computeGpuStats(rows, 'power')[0]).toMatchObject({ count: 2, min: 0, mean: 50 });
+    expect(computeGpuStats(rows, 'temperature')[0]).toMatchObject({ count: 1, mean: 40 });
+  });
+
+  it('NVIDIA: resolves reordered and omitted optional columns by name', () => {
+    const rows = parseCsvData(
+      'index,power.draw [W],timestamp,utilization.gpu [%]\n0,0 W,2026/03/07 00:20:37.071,0 %',
+    );
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({ index: 0, power: 0, gpuUtil: 0 });
+    expect(rows[0].temperature).toBeUndefined();
+  });
+
+  it('AMD: leaves absent, N/A and nonfinite metrics missing without losing zeros', () => {
+    const rows = parseCsvData(
+      'timestamp,gpu,socket_power,gfx_activity,gfx_0_clk,gfx_voltage\n1772939616,0,0,0,N/A,Infinity',
+    );
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({ power: 0, gpuUtil: 0 });
+    for (const key of ['temperature', 'smClock', 'memClock', 'memUtil', 'gfxVoltage'] as const) {
+      expect(rows[0][key], key).toBeUndefined();
+      expect(computeGpuStats(rows, key), key).toEqual([]);
+    }
+    expect(getAvailableMetrics(rows).map((metric) => metric.key)).toEqual(['power', 'gpuUtil']);
   });
 
   it('AMD: populates all AMD-specific metric fields', () => {
diff --git a/packages/app/src/components/gpu-power/types.ts b/packages/app/src/components/gpu-power/types.ts
index ce6e3c5a0..1a9ffdd11 100644
--- a/packages/app/src/components/gpu-power/types.ts
+++ b/packages/app/src/components/gpu-power/types.ts
@@ -1,4 +1,9 @@
 import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
+import {
+  parseAmdTimestamp,
+  parseNvidiaTimestamp,
+} from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
 
 export interface GpuMetricRow {
   timestamp: string;
@@ -36,6 +41,8 @@ export interface GpuPowerRunInfo {
 export interface GpuMetricsArtifact {
   name: string;
   data: GpuMetricRow[];
+  /** Only database-backed artifacts carry the full-record digest. */
+  series?: Omit<GpuMetricSeries, 'data'>;
 }
 
 export interface GpuPowerApiResponse {
@@ -201,11 +208,11 @@ export const ALL_METRIC_OPTIONS: GpuMetricConfig[] = [...GPU_METRIC_OPTIONS, ...
 
 /**
  * Returns the metric options that have data in the given dataset.
- * AMD-specific metrics are only shown when at least one row has a non-undefined value.
+ * A metric is shown only when at least one row has a finite reading.
  */
 export function getAvailableMetrics(data: GpuMetricRow[]): GpuMetricConfig[] {
   if (data.length === 0) return GPU_METRIC_OPTIONS;
-  return ALL_METRIC_OPTIONS.filter((m) => data.some((row) => row[m.key] !== undefined));
+  return ALL_METRIC_OPTIONS.filter((m) => data.some((row) => Number.isFinite(row[m.key])));
 }
 
 /**
@@ -421,7 +428,7 @@ function buildColumnMap(headerLine: string): Map<string, number> {
   const headers = splitCsvLine(headerLine);
   const map = new Map<string, number>();
   for (let i = 0; i < headers.length; i++) {
-    map.set(headers[i].toLowerCase(), i);
+    map.set(headers[i].toLowerCase().replace(/\s*\[.*\]$/u, ''), i);
   }
   return map;
 }
@@ -432,40 +439,39 @@ function buildColumnMap(headerLine: string): Map<string, number> {
  * clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]
  */
 function parseNvidiaCsv(lines: string[]): GpuMetricRow[] {
+  const columns = buildColumnMap(lines[0]);
+  const col = (name: string) => columns.get(name) ?? -1;
+  const iTimestamp = col('timestamp');
+  const iIndex = col('index');
+  const iPower = col('power.draw');
+  if (iTimestamp < 0 || iIndex < 0 || iPower < 0) return [];
   const results: GpuMetricRow[] = [];
   for (let i = 1; i < lines.length; i++) {
     const cols = lines[i].split(',').map((c) => c.trim());
-    if (cols.length < 8) continue;
-
-    const index = parseInt(cols[1], 10);
-    const power = parseFloat(cols[2]);
-    const temperature = parseFloat(cols[3]);
-    const smClock = parseFloat(cols[4]);
-    const memClock = parseFloat(cols[5]);
-    const gpuUtil = parseFloat(cols[6]);
-    const memUtil = parseFloat(cols[7]);
-
-    if ([index, power, temperature, smClock, memClock, gpuUtil, memUtil].some(isNaN)) continue;
+    if (cols.length <= Math.max(iTimestamp, iIndex, iPower)) continue;
+    const index = parseInt(cols[iIndex], 10);
+    const power = safeFloat(cols[iPower]);
+    if (!Number.isInteger(index) || index < 0 || power === undefined) continue;
 
     results.push({
-      timestamp: cols[0],
+      timestamp: cols[iTimestamp],
       index,
       power,
-      temperature,
-      smClock,
-      memClock,
-      gpuUtil,
-      memUtil,
+      temperature: safeFloat(cols[col('temperature.gpu')]),
+      smClock: safeFloat(cols[col('clocks.current.sm')]),
+      memClock: safeFloat(cols[col('clocks.current.memory')]),
+      gpuUtil: safeFloat(cols[col('utilization.gpu')]),
+      memUtil: safeFloat(cols[col('utilization.memory')]),
     });
   }
   return results;
 }
 
-/** Safely parse a float, returning undefined for N/A or unparseable values. */
+/** Missing, unparseable and nonfinite readings stay absent; measured zero is valid. */
 function safeFloat(val: string | undefined): number | undefined {
   if (val === undefined || val === 'N/A' || val === '') return undefined;
   const n = parseFloat(val);
-  return isNaN(n) ? undefined : n;
+  return Number.isFinite(n) ? n : undefined;
 }
 
 /**
@@ -498,28 +504,25 @@ function parseAmdCsv(lines: string[], colMap: Map<string, number>): GpuMetricRow
   const results: GpuMetricRow[] = [];
   for (let i = 1; i < lines.length; i++) {
     const cols = splitCsvLine(lines[i]);
-    if (cols.length < 3) continue;
+    if (cols.length <= Math.max(iTimestamp, iGpu, iPower)) continue;
 
     const index = parseInt(cols[iGpu], 10);
-    const power = parseFloat(cols[iPower]);
+    const power = safeFloat(cols[iPower]);
     // Prefer hotspot temp, fall back to edge
-    let temperature = iHotspot >= 0 ? parseFloat(cols[iHotspot]) : NaN;
-    if (isNaN(temperature) && iEdge >= 0) temperature = parseFloat(cols[iEdge]);
-    const smClock = iGfxClk >= 0 ? parseFloat(cols[iGfxClk]) : 0;
-    const memClock = iMemClk >= 0 ? parseFloat(cols[iMemClk]) : 0;
-    const gpuUtil = iGfxActivity >= 0 ? parseFloat(cols[iGfxActivity]) : 0;
-    const memUtil = iUmcActivity >= 0 ? parseFloat(cols[iUmcActivity]) : 0;
-
-    if (isNaN(index) || isNaN(power)) continue;
-    if (isNaN(temperature)) temperature = 0;
-
-    // AMD timestamps are Unix epoch seconds — convert to ms-based string for consistency
-    const rawTimestamp = cols[iTimestamp];
-    const epochSec = parseFloat(rawTimestamp);
-    const timestamp =
-      !isNaN(epochSec) && epochSec > 1e9 && epochSec < 1e11
-        ? new Date(epochSec * 1000).toISOString()
-        : rawTimestamp;
+    const temperature = safeFloat(cols[iHotspot]) ?? safeFloat(cols[iEdge]);
+    const smClock = safeFloat(cols[iGfxClk]);
+    const memClock = safeFloat(cols[iMemClk]);
+    const gpuUtil = safeFloat(cols[iGfxActivity]);
+    const memUtil = safeFloat(cols[iUmcActivity]);
+
+    if (!Number.isInteger(index) || index < 0 || power === undefined) continue;
+
+    // Round epoch fractions exactly as ingest does before constructing the dedup key.
+    const timestampMs = parseAmdTimestamp(cols[iTimestamp]);
+    if (timestampMs === null) continue;
+    const date = new Date(timestampMs);
+    if (!Number.isFinite(date.getTime())) continue;
+    const timestamp = date.toISOString();
 
     // AMD-specific metrics
     const edgeTemp = iEdge >= 0 ? safeFloat(cols[iEdge]) : undefined;
@@ -566,13 +569,22 @@ export function parseCsvData(csvText: string): GpuMetricRow[] {
 
   const headerLower = lines[0].toLowerCase();
 
-  // Detect AMD format by checking for amd-smi specific columns
-  if (headerLower.includes('socket_power') || headerLower.includes('gfx_activity')) {
-    const colMap = buildColumnMap(lines[0]);
-    return parseAmdCsv(lines, colMap);
-  }
-
-  return parseNvidiaCsv(lines);
+  const rows =
+    headerLower.includes('socket_power') || headerLower.includes('gfx_activity')
+      ? parseAmdCsv(lines, buildColumnMap(lines[0]))
+      : parseNvidiaCsv(lines);
+  // Normalize one CSV at a time: host-local indices may repeat in other files.
+  // Keep the first device/timestamp sample, matching the persisted digest.
+  const seen = new Set<string>();
+  return rows.filter((row) => {
+    // NVIDIA's naive collector clock must not use the reader's local DST rules.
+    const ms = parseNvidiaTimestamp(row.timestamp) ?? parseTimestampToMs(row.timestamp);
+    if (ms === null || !Number.isFinite(ms)) return false;
+    const key = `${row.index}:${ms}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
 }
 
 // --- Statistics ---
@@ -601,7 +613,7 @@ export function computeGpuStats(data: GpuMetricRow[], metricKey: GpuMetricKey):
   const groups = new Map<number, number[]>();
   for (const row of data) {
     const val = row[metricKey];
-    if (val === undefined) continue;
+    if (val === undefined || !Number.isFinite(val)) continue;
     if (!groups.has(row.index)) groups.set(row.index, []);
     groups.get(row.index)!.push(val);
   }
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
index 831fa1cc0..94d272eda 100644
--- a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -438,7 +438,7 @@ export function PowerTelemetryView({ id, enabled, hardware }: Props) {
 
       <Card>
         <h3 className="mb-2 text-sm font-medium">{t.perGpuStats}</h3>
-        <GpuStatsTable data={data} metricKey={metricKey} />
+        <GpuStatsTable data={data} metricKey={metricKey} storedStats={selectedSeries.stats} />
       </Card>
     </div>
   );
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index cff5d938e..6c1435c26 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -115,7 +115,7 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'published-read',
     operationId: 'get-gpu-metrics-view',
-    sourceSha256: '34860f3f64e4070bf4c0bf390c3b61f34bdb98b673a90d119bae162226dc1edd',
+    sourceSha256: '2ad6ff9f64b397ed4fea5a0456b2b0f328b46f9e171753fa90af458c1f70f23a',
   },
   {
     source: 'src/app/api/v1/views/gpu-specs/route.ts',
@@ -793,6 +793,22 @@ export interface ApiContractSourceDigest {
  * touching a route module. Digest changes require an explicit documentation review.
  */
 export const apiContractSourceDigests = [
+  {
+    source: 'src/components/gpu-power/stored-gpu-stats.ts',
+    sourceSha256: '90adde200c37694c2e37e427458a8c6a9bdb70873033699e343e8c94a291544a',
+    reviewArea: {
+      en: 'Stored full-record GPU metric mappings, authoritative missing digests, and UI/API statistics parity.',
+      zh: '已存全记录 GPU 指标映射、缺失摘要语义，以及界面和 API 的统计一致性。',
+    },
+  },
+  {
+    source: 'src/components/gpu-power/types.ts',
+    sourceSha256: 'cc75290d20b1f7b3a31c49634ae592f60c69857696cca7697a84c6f897ba2575',
+    reviewArea: {
+      en: 'GPU telemetry units, missing values, timestamp deduplication, and full-record live statistics definitions.',
+      zh: 'GPU 遥测单位、缺失值、时间戳去重，以及实时产物全记录统计的定义。',
+    },
+  },
   {
     source: 'src/lib/views-api/upstream-error.ts',
     sourceSha256: 'c3f1b4c318e1ae771a67edd85f16d69b7316461334604fd8c892254eface715a',
diff --git a/packages/app/src/lib/views-api/docs/extensions.ts b/packages/app/src/lib/views-api/docs/extensions.ts
index 7b40b479c..1f1d17fda 100644
--- a/packages/app/src/lib/views-api/docs/extensions.ts
+++ b/packages/app/src/lib/views-api/docs/extensions.ts
@@ -22,8 +22,8 @@ const PARAMETER_NOTES: Record<string, [string, string]> = {
     '快照截止日期，格式为 YYYY-MM-DD。指定 runId 时改为读取该次运行的逻辑快照。',
   ],
   runId: [
-    'Positive safe integer workflow run ID. Omit to select the default run; required for live GPU metrics.',
-    '正安全整数格式的工作流运行 ID。不填时选择默认运行；实时 GPU 指标必须填写。',
+    'Positive safe integer workflow run ID. Omit to select the default run; required for GPU metrics.',
+    '正安全整数格式的工作流运行 ID。不填时选择默认运行；GPU 指标必须填写。',
   ],
   precisions: [
     'Comma-separated precision keys; omitted selection uses available curve density. Calculator extensions auto-select the densest official precision and include precisions present in unofficial-run overlays.',
@@ -391,9 +391,19 @@ const NEW_VIEWS = {
     { rows: objects, options: object },
   ],
   'gpu-metrics': [
-    'Live GPU metrics and statistics',
-    '实时 GPU 指标与统计',
-    { runInfo: object, artifacts: strings, rows: objects, stats: objects, rendering: object },
+    'GPU telemetry and full-record statistics',
+    'GPU 遥测与全记录统计',
+    {
+      runInfo: object,
+      artifacts: strings,
+      rows: objects,
+      stats: {
+        ...objects,
+        description:
+          'Per-GPU statistics for the selected file/host series, including startup and warmup. Stored digests are authoritative, including an empty or missing metric digest; only live artifacts compute from samples. Count is the finite-reading count after first-wins timestamp/GPU deduplication. Mean is sample-weighted, P50/P95/P99 use linear interpolation at p*(N-1), and standard deviation divides by N. Values use the selected metric unit. GPU visibility and chart downsampling do not change this population. These are not serving-window power or J/token.',
+      },
+      rendering: object,
+    },
   ],
   video: [
     'Published video evidence and tradeoffs',
@@ -422,14 +432,14 @@ export const operations: ApiOperation[] = Object.entries(NEW_VIEWS).map(
           view === 'video'
             ? ' Only already published artifacts are read. Cell, phase, slot and GPU-basis choices select result evidence and normalized serving rates; x/y/cost/workload filters produce computed tradeoff points. Local bundles and arbitrary URLs are excluded. Responses are no-store.'
             : view === 'gpu-metrics'
-              ? ' Live artifact reads are no-store; statistics use all chips and unsampled values, while chart rows respect selected GPU indices. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings.'
+              ? ' Telemetry responses use private, no-store. Full-record statistics include startup and warmup and use the stored per-GPU digest when present; an empty or missing metric digest stays empty. Only live artifacts compute statistics from samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings.'
               : ''
         }`,
         `只读${zh}，使用仪表板的数据读取和计算函数。未知或重复查询键返回 400；响应包含解析后的参数，保留缺失数据。仅影响样式的控件不作为 API 参数。${
           view === 'video'
             ? ' 仅读取已发布产物。cell、阶段、slot 和 GPU 口径选择对应结果证据，并计算 serving 归一化速率；x/y、成本及工作负载筛选生成权衡图数据点。不读取本地数据包或任意 URL。响应不缓存。'
             : view === 'gpu-metrics'
-              ? ' 实时产物读取不缓存；统计量使用所有芯片的未降采样值，图表行则按芯片索引筛选。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。'
+              ? ' 遥测响应使用 private, no-store。全记录统计包含服务启动与 warmup，已有数据使用数据库中的每 GPU 统计摘要；摘要为空或缺少所选指标时仍返回空统计数组。仅实时产物按样本计算统计。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。'
               : ''
         }`,
       ),
diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index 19f6b63c4..8a3cf3a04 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -7,7 +7,7 @@
     "references/cli-contract.md": "82e0016e42bc1d06c3ac53b33473a0a56d0df422c6006fc74b5f3a75ac21b8d9",
     "references/cli.md": "580ea3492c3835ccc45298b339fa2a8c6fc457079a547cb04be3432a263752b0",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "6f98323c9dbdd638cd31f4d0aab8a463afb605edf28f59af1267b645d93a2843",
+    "references/dashboard-views.md": "9ab6b436f2ad4a47efd361ba7a288f5a2b75986abfc1ec2fe9cd5e9798a9539a",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/powerx.md": "f04f89ce77590d6898a776f892749722f4f4303e40e7daeeb576cbcff5d098cf",
     "references/provenance.md": "da4e9d078b31f234727706593f77ca9d5fdac611921783aaa09b5741de58b69a",
diff --git a/packages/skills/skills/inferencex-api/references/dashboard-views.md b/packages/skills/skills/inferencex-api/references/dashboard-views.md
index ae147e7c5..19e8f9d90 100644
--- a/packages/skills/skills/inferencex-api/references/dashboard-views.md
+++ b/packages/skills/skills/inferencex-api/references/dashboard-views.md
@@ -60,7 +60,7 @@ which controls belong together.
 | `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                               |
 | `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                    |
 | `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                 |
-| `gpu-metrics`                   | Required run, artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. Raw rows and statistics remain unsampled; live response is no-store.                                             |
+| `gpu-metrics`                   | Required run, artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. Full-record statistics use stored digests. Responses are no-store.                                               |
 | `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                    |
 
 ## Interpretation and maintenance
@@ -91,8 +91,12 @@ Custom chip costs are USD/chip-hour, token prices USD/million tokens,
 interactivity tok/s/user, and video costs USD/deployment-hour. Preserve the
 response's resolved TCO, utilization, license share, topology and power basis.
 Modeled and provisioned power are distinct. Missing measured evidence is not zero.
-GPU chart projections preserve the existing renderer's missing-metric zero
-fallback; use unsampled `rows` to distinguish absent optional sensor values.
+GPU chart projections omit missing metric readings; measured zero remains zero.
+The selected series' full-record statistics include startup and warmup
+and cover all chips regardless of visibility or chart downsampling. Stored digests
+are authoritative, including empty or absent metric digests; only live artifacts
+calculate from samples. Keep these sample-weighted statistics separate from
+serving-window power, J/token and selected-time-window calculations.
 
 Zoom, axis scale, theme, labels, report expansion, media playback and download
 buttons are presentation state, not new datasets. AI-chart provider keys and

From 2f67a843880686c565418cfc0fe693fec2d229e5 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 22 Sep 2026 10:18:16 -0700
Subject: [PATCH 025/103] fix: read historical PowerX timelines from the
 database
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：历史 Timeline 优先读取数据库，保留主机、GPU、验证窗口及分桶语义；缺少存储时按来源回退，数据库故障明确报错。统一 context 时区与文件顺序，包含历史读取的测试和文档。
---
 docs/dashboard-readonly-views.md              |  10 +-
 docs/data-pipeline.md                         |  29 +-
 docs/powerx-permanent-view.md                 |   6 +-
 docs/powerx-persistence-recovery.md           |  55 +++
 .../cypress/component/power-timeline.cy.tsx   | 148 ++++++--
 .../app/cypress/e2e/powerx-timeline.cy.ts     |   4 +-
 .../app/api/gpu-metrics/route.context.test.ts | 342 +++++++++++++++++
 .../app/api/gpu-metrics/route.sources.test.ts | 356 ++++++++++++++++++
 .../app/src/app/api/gpu-metrics/route.test.ts | 336 ++++++++++++++++-
 packages/app/src/app/api/gpu-metrics/route.ts | 343 +++++++++++++++--
 .../gpu-power/power-audit-bundle.ts           | 130 ++++++-
 .../components/gpu-power/power-series.test.ts |  53 +++
 .../src/components/gpu-power/power-series.ts  |  34 +-
 .../gpu-power/stored-power-series.ts          | 168 +++++++++
 .../components/inference/ui/PowerTimeline.tsx |   5 +-
 .../inference/utils/powerTimeline.test.ts     |   5 +
 .../inference/utils/powerTimeline.ts          |   3 +
 packages/app/src/lib/api-route-catalog.ts     |  25 +-
 packages/app/src/lib/github-artifacts.test.ts |   6 +-
 packages/app/src/lib/github-artifacts.ts      |   2 +-
 .../app/src/lib/views-api/docs/extensions.ts  |   4 +-
 .../db/src/etl/gpu-metrics-artifacts.test.ts  |  44 +++
 packages/db/src/etl/gpu-metrics-artifacts.ts  |  30 +-
 .../db/src/etl/gpu-metrics-ingest.test.ts     |  33 ++
 packages/db/src/etl/gpu-metrics-ingest.ts     |  36 +-
 .../src/queries/gpu-metrics-timeline.test.ts  | 287 ++++++++++++++
 packages/db/src/queries/gpu-metrics.test.ts   |   1 +
 packages/db/src/queries/gpu-metrics.ts        |  20 +-
 .../skills/inferencex-api/integrity.json      |   2 +-
 .../references/dashboard-views.md             |   8 +-
 30 files changed, 2405 insertions(+), 120 deletions(-)
 create mode 100644 packages/app/src/app/api/gpu-metrics/route.context.test.ts
 create mode 100644 packages/app/src/app/api/gpu-metrics/route.sources.test.ts
 create mode 100644 packages/app/src/components/gpu-power/stored-power-series.ts
 create mode 100644 packages/db/src/queries/gpu-metrics-timeline.test.ts

diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 4874f2fe0..7a7167cae 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -47,7 +47,7 @@ combinations, not the full Cartesian product of all possible filter values.
 - Submissions/images: existing table, weekly/cumulative and image freshness helpers.
 - GPU metrics: shared line/correlation transforms and stored full-record per-GPU
   digests. Live artifacts alone calculate statistics from samples; empty stored
-  digests remain empty. Missing-versus-zero semantics persist.
+  digests remain empty. File/host identity and missing-versus-zero semantics persist.
 - Video: checksum-verified stored bundles, serving/fidelity selectors and tradeoffs.
 - Overview/rankings/compare: existing discovery-page assembly and scenario helpers.
 
@@ -63,7 +63,9 @@ Zoom, theme, axis scale, labels, media playback and report expansion are rendere
 state. GPU interactive downsampling does not alter returned raw data or statistics.
 The GPU statistics table includes startup and warmup for all chips in the selected
 series, regardless of chip visibility. It is separate from serving-window power,
-J/token and selected-time-window calculations.
+J/token and selected-time-window calculations. Run telemetry is DB-first with an
+artifact fallback for missing storage; the public view returns private, no-store
+responses and preserves upstream 503 failures.
 
 ## Verification scope
 
@@ -83,8 +85,10 @@ those properties.
 视图）均在覆盖表中登记；上表列出各只读接口接受的全部查询参数名。
 接口复用现有计算函数，公开运行与非官方叠加数据保留各自来源。
 私有上传、密钥、提示词、反馈及管理操作不作为公开读取接口。
-全记录统计使用所选序列的全部芯片摘要，包含启动与 warmup；已有摘要为空时不补算，缺失读数不补零。
+GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全记录统计使用所选文件、
+主机序列的全部芯片摘要，包含启动与 warmup；已有摘要为空时不补算，缺失读数不补零。
 芯片显隐和图表降采样不改变该统计，也不改变 serving-window 或 J/token 的计算口径。
+响应使用 private, no-store，上游 503 保留为错误响应。
 
 测试覆盖契约同步及代表性的筛选行为，并未穷举所有参数组合。生产数据库上的
 完整 UI/API 对照仍需集成审查，不能仅凭单元测试宣称已完成。
diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index 5d859a659..d949a37b8 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -589,10 +589,23 @@ run — are never copied. Our own GCS reader (`lib/gcs-artifacts.ts`) additional
 ignores everything but `bmk_`/`server_logs_` objects, so widening the mirror's run
 filter would also need a reader change before backfill could use it.
 
-Readers: `/api/gpu-metrics?runId=` serves the digest when the run is stored and
-falls back to live GitHub artifacts otherwise (in-progress runs), and
-`/api/v1/gpu-metrics-point?id=` powers the PowerX tab of the per-point detail
-page.
+Readers: `/api/gpu-metrics?runId=` serves stored telemetry first, including
+`series=power` Timeline buckets reconstructed with retained windows and device
+identities. Missing storage falls back to GitHub artifacts. Known-incomplete CSV
+fallback must match retained filenames and sample counts; known-incomplete bundles
+need exact-source re-ingest. Healthy DB series remain in mixed fallback responses.
+Database failures return `503 DATABASE_UNAVAILABLE`; incomplete storage without
+usable fallback returns `503 STORED_TELEMETRY_INCOMPLETE` with re-ingest guidance.
+Timeline requests use read-only POST with sorted validation basenames in a `sources`
+JSON body. Stored coverage of those identities permits an artifact-independent response;
+missing siblings, including other windows in the same bundle, use source-level DB-first
+merging. Unavailable artifacts leave healthy DB traces readable with explicit missing
+sources. `sourceCoverage` describes only the requested identities; legacy GET reports
+coverage unknown. Plain CSV fallback applies the adjacent context timezone just like
+ingest and bundle reads. Raw multi-file artifacts retain separate file/host series.
+Successful reads and storage errors use no-store.
+
+`/api/v1/gpu-metrics-point?id=` powers the PowerX point-detail tab.
 
 The public `/api/v1/views/gpu-metrics` projection and full-record UI table use the
 same stored per-GPU statistics digest for the selected file/host series. Empty or
@@ -603,7 +616,13 @@ sample-weighted, percentiles interpolate at `p * (N - 1)`, and standard deviatio
 divides by `N`. GPU visibility and chart downsampling do not alter this population.
 Serving-window power, J/token and selected-time-window calculations remain separate.
 
-中文：全记录统计使用已存摘要，包含启动与 warmup；缺失读数不补零，已有摘要为空时不重新计算。它与 serving-window 功率、J/token 和用户所选时间窗口的统计分别处理。
+中文：历史遥测和 Timeline 优先读取数据库；缺少存储数据时回退到 GitHub 产物，
+文件、主机与 GPU 的身份保持独立。数据库故障返回 503；已知存储不完整且无法恢复时，
+返回带定向重新入库提示的 503。Timeline 通过只读 POST 传入所需来源标识；缺失的兄弟曲线
+按来源补齐，GitHub 不可用时仍返回健康的 DB 曲线，并显式标出缺失来源。旧的 GET
+没有预期清单，覆盖状态为 unknown。sourceCoverage 仅描述本次请求，不代表整个 run
+的完整性；普通 CSV 与 bundle、ingest 使用相同的 context 时区。
+全记录统计使用已存摘要，包含启动与 warmup；缺失读数不补零，已有摘要为空时不重新计算。它与 serving-window 功率、J/token 和用户所选时间窗口的统计分别处理。
 
 ### PowerX publication receipts
 
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 0325c4a84..c76b3ec38 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -205,9 +205,11 @@ config is `display: 'timeline'`.
   `prioritizeRuns` — so an overlay the user asked for is never the run that gets dropped),
   narrowed with
   `prefix=` to the common RESULT_FILENAME prefix so a nightly sweep's other models are not
-  downloaded. `/api/gpu-metrics?series=power` returns one-second per-GPU buckets
+  downloaded. `/api/gpu-metrics?series=power` first uses persisted telemetry and returns one-second per-GPU buckets
   (`components/gpu-power/power-series.ts`, ~1 MB for a 25-config run instead of ~27 MB of
-  raw rows); with `series=power` the route also downloads `power_audit_*` bundles whose name
+  raw rows). Missing stored telemetry falls back to artifacts; database failures are explicit errors.
+  See [persistence and repair](./powerx-persistence-recovery.md) for cache freshness and coverage receipts.
+  With `series=power` the artifact fallback also downloads `power_audit_*` bundles whose name
   shares the prefix (a bundle names the sweep, so the match runs both ways), reads only
   `LOGS/power/samples.csv`, `LOGS/power/manifest.json` and the top-level
   `power_validation_*.json` entries, and skips bundles above 256 MiB (the GB200 nw8 sweep is
diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
index e46930ac8..3e7c67d6d 100644
--- a/docs/powerx-persistence-recovery.md
+++ b/docs/powerx-persistence-recovery.md
@@ -1,5 +1,60 @@
 # PowerX persistence and repair
 
+PowerX point detail, the run explorer and Power Timeline read migration-016 telemetry
+from the database. Timeline applies the same prefix selection, validation-window cuts,
+60-second padding and one-second per-device means as the artifact path. Stored samples
+retain UTC timestamps, original units and separate host-local GPU identities. GitHub
+remains the fallback for telemetry that has not been stored. Database failures return an
+error, not an empty result or an artifact fallback.
+
+Timeline sends a read-only `POST /api/gpu-metrics?runId=RUN_ID&series=power&prefix=PREFIX`
+with JSON `{ "sources": ["power_validation_RESULT_FILENAME.json"] }`. The planner sorts
+and deduplicates validation basenames, and includes them in the React Query key. The body
+accepts 1–1000 identities, each RESULT_FILENAME up to 200 ASCII letters/digits/`.`/`_`/`-`,
+matching `prefix` when supplied; invalid input returns 400 and bodies above 256 KiB return 413. POST avoids putting a whole run's identity list in a URL. GET remains compatible with
+the raw explorer and existing callers.
+
+Only requested identities absent from healthy DB series trigger artifact discovery. Merging
+prefers DB by validation identity, so a live sibling window in the same bundle is retained.
+`sourceCoverage: { status, missingSources }` reports coverage of the requested identities:
+`complete` or `incomplete` for POST, `unknown` for GET without an expectation list. It is
+not a full-run/sweep or raw-sample completeness receipt. An unavailable GitHub token, listing
+or download keeps healthy requested DB series readable with incomplete coverage; it cannot
+hide known-incomplete stored telemetry or database failures. Unrelated stored artifacts
+outside the requested identities do not block that read.
+
+Live ordinary CSVs and bundle CSVs normalize NVIDIA wall-clock timestamps with adjacent
+collector context using the ingest parser. Context must be in the same ZIP directory as
+the CSV; host directories never share offsets. When multiple context candidates exist, both
+ingest and live reads select the first valid object in code-unit filename order, independent
+of archive or filesystem listing order. ISO/AMD timestamps and missing context
+retain their existing behavior.
+
+Both paths keep the first row for a device/timestamp, matching the existing ingest
+deduplication, before averaging distinct samples within a bucket. A discovered unreadable
+host CSV alongside readable CSVs fails telemetry preparation before any series is written;
+it cannot disappear from the stored inventory and falsely establish complete coverage.
+
+New ingests preserve validation documents, bundle manifests and expected file/sample
+inventories in the existing series sidecars. Older ingests
+can recover validation source/window from linked benchmark `power_audit` provenance.
+Information never retained, such as historical validation role overrides, cannot be
+reconstructed: recover the exact original artifact and re-ingest it. An incomplete
+stored bundle must not silently become a smaller deployment's average. Incomplete stored
+telemetry can use live CSV fallback only when every retained file and deduplicated sample
+count is present. Missing/header-only host files, truncated data, and a second incomplete
+artifact must not disappear behind another artifact's successful recovery. Complete stored
+artifacts remain in a fallback response even if their GitHub artifacts have expired.
+A known-incomplete power bundle needs re-ingest because the downloaded window cuts do not
+prove its full original host/sample inventory. Un-ingested bundles still use normal artifact
+fallback. Unverifiable recovery returns `503 STORED_TELEMETRY_INCOMPLETE` with the artifact
+and a targeted re-ingest action. DB query failures return `503 DATABASE_UNAVAILABLE` and do
+not attempt artifact fallback.
+
+The live raw explorer also keeps each CSV as a separate series, matching the database
+reader. Multi-file artifact labels include the CSV path, so host-local GPU 0 values cannot
+be merged into one device. Single-file labels remain unchanged.
+
 ## Full-record statistics
 
 The point detail, run explorer and public `/api/v1/views/gpu-metrics` projection use the
diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index 8356149ab..adab6f6ac 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -1,5 +1,6 @@
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
 import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
+import { useState, type ReactElement } from 'react';
 
 import type {
   GpuPowerDevice,
@@ -163,7 +164,7 @@ const poolResponse: GpuPowerSeriesResponse = {
 const GB200_TDP = HW_REGISTRY.gb200?.tdp || HW_REGISTRY.b200.tdp;
 
 function mountTimeline(
-  data: InferenceData[],
+  data: InferenceData[] | ReactElement,
   options: {
     pathname?: string;
     width?: number;
@@ -174,12 +175,16 @@ function mountTimeline(
   mountWithProviders(
     <PathnameContext.Provider value={options.pathname ?? '/inference'}>
       <div style={{ width: options.width ?? 1100, height: 700 }}>
-        <PowerTimeline
-          chartId="power-timeline-test"
-          data={data}
-          overlayData={options.overlay}
-          yLabel="Measured Average Power per Chip over Time (W)"
-        />
+        {Array.isArray(data) ? (
+          <PowerTimeline
+            chartId="power-timeline-test"
+            data={data}
+            overlayData={options.overlay}
+            yLabel="Measured Average Power per Chip over Time (W)"
+          />
+        ) : (
+          data
+        )}
       </div>
     </PathnameContext.Provider>,
     {
@@ -206,7 +211,7 @@ describe('PowerTimeline', () => {
   });
 
   it('distinguishes dates when wall-clock traces span multiple days', () => {
-    cy.intercept('GET', '/api/gpu-metrics*', {
+    cy.intercept('POST', '/api/gpu-metrics*', {
       body: {
         ...response,
         series: response.series.map((trace, index) => ({
@@ -231,7 +236,7 @@ describe('PowerTimeline', () => {
 
   it('keeps mobile wall-clock dates separated', () => {
     cy.viewport(390, 844);
-    cy.intercept('GET', '/api/gpu-metrics*', {
+    cy.intercept('POST', '/api/gpu-metrics*', {
       body: {
         ...response,
         series: response.series.map((trace, index) => ({
@@ -258,9 +263,14 @@ describe('PowerTimeline', () => {
   });
 
   it('fetches one prefixed series request per run and draws the job with its window emphasized', () => {
-    cy.intercept('GET', '/api/gpu-metrics*', { body: response }).as('series');
+    cy.intercept('POST', '/api/gpu-metrics*', { body: response }).as('series');
     mountTimeline([
-      measuredPoint('b200', 16, 700),
+      measuredPoint('b200', 16, 700, {
+        power_audit: {
+          source: `results/power_validation_${resultName('b200', 16)}.json`,
+          ...WINDOW,
+        },
+      }),
       measuredPoint('b200', 64, 900),
       // Same run, no artifact uploaded (e.g. a disaggregated Dynamo row).
       measuredPoint('b200', 256, 950, {
@@ -274,6 +284,14 @@ describe('PowerTimeline', () => {
       expect(url.searchParams.get('runId')).to.eq(RUN_ID);
       expect(url.searchParams.get('series')).to.eq('power');
       expect(url.searchParams.get('prefix')).to.eq('dsv4_8k1k_fp4_');
+      expect(request.body).to.deep.equal({
+        sources: [
+          `power_validation_${resultName('b200', 16)}.json`,
+          `power_validation_${resultName('b200', 64)}.json`,
+          'power_validation_dsv4_8k1k_fp4_dynamo-sglang_conc256.json',
+        ].toSorted(),
+      });
+      expect(request.body.sources).to.deep.equal([...new Set(request.body.sources)].toSorted());
     });
 
     svg().within(() => {
@@ -327,6 +345,88 @@ describe('PowerTimeline', () => {
     });
   });
 
+  it('fetches again when wanted sources change within the same run and prefix', () => {
+    const source16 = `power_validation_${resultName('b200', 16)}.json`;
+    const source32 = `power_validation_${resultName('b200', 32)}.json`;
+    const source64 = `power_validation_${resultName('b200', 64)}.json`;
+    cy.intercept('POST', '/api/gpu-metrics*', (request) => {
+      request.reply({
+        body: {
+          ...response,
+          series: request.body.sources.includes(source32)
+            ? [series('b200', 16, 700), series('b200', 32, 800)]
+            : response.series,
+        },
+      });
+    }).as('series');
+
+    function ChangingSelection() {
+      const [changed, setChanged] = useState(false);
+      return (
+        <>
+          <button onClick={() => setChanged(true)}>Select concurrency 32</button>
+          <PowerTimeline
+            chartId="power-timeline-test"
+            data={[
+              measuredPoint('b200', 16, 700),
+              measuredPoint('b200', changed ? 32 : 64, changed ? 800 : 900),
+            ]}
+            yLabel="Measured Average Power per Chip over Time (W)"
+          />
+        </>
+      );
+    }
+
+    mountTimeline(<ChangingSelection />);
+    cy.wait('@series').then(({ request: first }) => {
+      expect(first.body).to.deep.equal({ sources: [source16, source64] });
+      svg().find('text.power-trace-label').should('contain.text', 'c64');
+      cy.contains('button', 'Select concurrency 32').click();
+      cy.wait('@series').then(({ request: second }) => {
+        expect(second.url).to.eq(first.url);
+        expect(second.body).to.deep.equal({ sources: [source16, source32] });
+      });
+    });
+    svg()
+      .find('text.power-trace-label')
+      .should('contain.text', 'c32')
+      .and('not.contain.text', 'c64');
+    cy.get('[data-testid="power-timeline-missing"]').should('not.exist');
+    cy.get('@series.all').should('have.length', 2);
+  });
+
+  for (const [locale, pathname, width] of [
+    ['EN desktop', '/inference', 1280],
+    ['ZH mobile', '/zh/inference', 390],
+  ] as const) {
+    it(`draws the stored and recovered sibling from a hybrid API fixture on ${locale}`, () => {
+      cy.viewport(width, 844);
+      // Transport fixture: the API already retained c16 from DB and recovered c64 from GitHub.
+      // Real database recovery is verified separately by the route integration checks.
+      cy.intercept('POST', '/api/gpu-metrics*', {
+        body: { ...response, source: 'github' },
+      }).as('series');
+      mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('b200', 64, 900)], {
+        pathname,
+        width: width === 390 ? 324 : 1100,
+      });
+      cy.wait('@series').then(({ request }) => {
+        expect(request.body.sources).to.deep.equal([
+          `power_validation_${resultName('b200', 16)}.json`,
+          `power_validation_${resultName('b200', 64)}.json`,
+        ]);
+      });
+      svg().find('path.power-trace[data-segment="window"]').should('have.length', 2);
+      svg().find('text.power-trace-label').should('contain.text', 'c16').and('contain.text', 'c64');
+      cy.get('[data-testid="power-timeline-missing"]').should('not.exist');
+      cy.get('[data-testid="power-timeline-empty"]').should('not.exist');
+      if (pathname.startsWith('/zh')) {
+        cy.get('[data-testid="power-timeline-toolbar"]').should('contain.text', '时间轴');
+      }
+      svg().screenshot(`power-timeline-hybrid-${width === 390 ? 'zh-mobile' : 'en-desktop'}`);
+    });
+  }
+
   it('colours overlay-run traces by run and honours the overlay hardware filter', () => {
     const overlayPoint = measuredPoint('h200', 16, 500, {
       run_url: OVERLAY_RUN_URL,
@@ -339,8 +439,8 @@ describe('PowerTimeline', () => {
       runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
       series: [series('h200', 16, 500)],
     };
-    cy.intercept('GET', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
-    cy.intercept('GET', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
+    cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
       body: overlayResponse,
     }).as('overlay');
     mountTimeline([measuredPoint('b200', 16, 700)], {
@@ -394,7 +494,7 @@ describe('PowerTimeline', () => {
         ...WINDOW,
       },
     });
-    cy.intercept('GET', '/api/gpu-metrics*', { body: response }).as('series');
+    cy.intercept('POST', '/api/gpu-metrics*', { body: response }).as('series');
     mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('h100', 16, 600)], {
       overlay: {
         data: [overlayPoint],
@@ -447,7 +547,7 @@ describe('PowerTimeline', () => {
       measuredPoint('b200', 8 * 2 ** index, 700, { run_url: runUrlFor(runId) }),
     );
     officialRuns.forEach((runId, index) => {
-      cy.intercept('GET', `/api/gpu-metrics?runId=${runId}*`, {
+      cy.intercept('POST', `/api/gpu-metrics?runId=${runId}*`, {
         body: {
           runInfo: { ...response.runInfo, id: Number(runId), url: runUrlFor(runId) },
           series: [series('b200', 8 * 2 ** index, 700)],
@@ -461,7 +561,7 @@ describe('PowerTimeline', () => {
         ...WINDOW,
       },
     });
-    cy.intercept('GET', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+    cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
       body: {
         runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
         series: [series('h200', 16, 500)],
@@ -509,7 +609,7 @@ describe('PowerTimeline', () => {
   });
 
   it('reports a failed run and hides traces the legend has switched off', () => {
-    cy.intercept('GET', '/api/gpu-metrics*', {
+    cy.intercept('POST', '/api/gpu-metrics*', {
       statusCode: 500,
       body: { error: 'No gpu_metrics artifacts found for this run' },
     }).as('failed');
@@ -524,7 +624,7 @@ describe('PowerTimeline', () => {
   });
 
   it('translates the toolbar, legend switches and status on /zh', () => {
-    cy.intercept('GET', '/api/gpu-metrics*', { body: response }).as('series');
+    cy.intercept('POST', '/api/gpu-metrics*', { body: response }).as('series');
     mountTimeline([measuredPoint('b200', 16, 700)], { pathname: '/zh/inference' });
     cy.wait('@series');
     cy.get('[data-testid="power-timeline-toolbar"]').should('contain.text', '时间轴');
@@ -535,7 +635,7 @@ describe('PowerTimeline', () => {
   });
 
   it('sums prefill and decode pools against pool-sized TDP references in pool mode', () => {
-    cy.intercept('GET', '/api/gpu-metrics*', { body: poolResponse }).as('series');
+    cy.intercept('POST', '/api/gpu-metrics*', { body: poolResponse }).as('series');
     mountTimeline([measuredPoint('b200', 16, 700), disaggPoint(8, 800)]);
     cy.wait('@series');
 
@@ -614,7 +714,7 @@ describe('PowerTimeline', () => {
   });
 
   it('keeps separate pool references when prefill and decode pools differ in size', () => {
-    cy.intercept('GET', '/api/gpu-metrics*', {
+    cy.intercept('POST', '/api/gpu-metrics*', {
       body: {
         runInfo: response.runInfo,
         series: [poolSeries(8, 6)],
@@ -643,8 +743,8 @@ describe('PowerTimeline', () => {
       runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
       series: [poolSeries(8)],
     };
-    cy.intercept('GET', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
-    cy.intercept('GET', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
+    cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
       body: overlayResponse,
     }).as('overlay');
     mountTimeline([measuredPoint('b200', 16, 700)], {
@@ -706,7 +806,7 @@ describe('PowerTimeline', () => {
   it('focuses the deep-linked trace, opens pool mode for it and clears on request', () => {
     const disagg = disaggPoint(8, 800);
     requestPowerTraceFocus(traceKeyForPoint(disagg)!);
-    cy.intercept('GET', '/api/gpu-metrics*', { body: poolResponse }).as('series');
+    cy.intercept('POST', '/api/gpu-metrics*', { body: poolResponse }).as('series');
     mountTimeline([measuredPoint('b200', 16, 700), disagg]);
     cy.wait('@series');
 
@@ -750,7 +850,7 @@ describe('PowerTimeline', () => {
   it('translates the pool switch, pool labels and focus chip on /zh', () => {
     const disagg = disaggPoint(8, 800);
     requestPowerTraceFocus(traceKeyForPoint(disagg)!);
-    cy.intercept('GET', '/api/gpu-metrics*', { body: poolResponse }).as('series');
+    cy.intercept('POST', '/api/gpu-metrics*', { body: poolResponse }).as('series');
     mountTimeline([disagg], { pathname: '/zh/inference' });
     cy.wait('@series');
 
diff --git a/packages/app/cypress/e2e/powerx-timeline.cy.ts b/packages/app/cypress/e2e/powerx-timeline.cy.ts
index b78ca57cd..9572a71de 100644
--- a/packages/app/cypress/e2e/powerx-timeline.cy.ts
+++ b/packages/app/cypress/e2e/powerx-timeline.cy.ts
@@ -118,7 +118,7 @@ function interceptRows() {
   cy.intercept('GET', '/api/v1/workflow-info*', {
     body: { runs: [], changelogs: [], configs: [] },
   });
-  cy.intercept('GET', `/api/gpu-metrics?runId=${RUN_ID}*`, {
+  cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, {
     body: seriesFor('b200', RUN_URL, RUN_ID),
   }).as('series');
 }
@@ -143,7 +143,7 @@ function interceptOverlay() {
       evaluations: [],
     },
   }).as('unofficialRun');
-  cy.intercept('GET', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+  cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
     body: seriesFor('h200', OVERLAY_RUN_URL, OVERLAY_RUN_ID),
   }).as('overlaySeries');
 }
diff --git a/packages/app/src/app/api/gpu-metrics/route.context.test.ts b/packages/app/src/app/api/gpu-metrics/route.context.test.ts
new file mode 100644
index 000000000..02a12b63e
--- /dev/null
+++ b/packages/app/src/app/api/gpu-metrics/route.context.test.ts
@@ -0,0 +1,342 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import AdmZip from 'adm-zip';
+import { NextRequest } from 'next/server';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { prepareGpuMetricsArtifact } from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import { cutPowerAuditBundle } from '@/components/gpu-power/power-audit-bundle';
+import { parseCsvData } from '@/components/gpu-power/types';
+
+const { readStored } = vi.hoisted(() => ({ readStored: vi.fn() }));
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({ getDb: () => ({}) }));
+vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
+  getGpuMetricsForRun: readStored,
+}));
+
+import { GET } from './route';
+
+const HEADER =
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
+const CSV = `${HEADER}\n2026/09/21 00:00:00.000, 0, 100 W, 40, 1500, 2000, 90, 80\n2026/09/21 00:00:01.000, 0, 200 W, 41, 1500, 2000, 90, 80\n`;
+const directories: string[] = [];
+
+beforeEach(() => {
+  readStored.mockReset().mockResolvedValue(null);
+  vi.stubEnv('GITHUB_TOKEN', 'controlled-not-a-real-token');
+  vi.stubEnv('DATABASE_READONLY_URL', 'postgresql://controlled.invalid/never-contacted');
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.unstubAllEnvs();
+  for (const directory of directories.splice(0)) fs.rmSync(directory, { recursive: true });
+});
+
+function liveArtifact(
+  files: Record<string, string>,
+  name = 'gpu_metrics_probe_live',
+  options: Partial<AdmZip.InitOptions> = {},
+) {
+  const zip = new AdmZip(undefined, options);
+  for (const [entry, contents] of Object.entries(files)) zip.addFile(entry, Buffer.from(contents));
+  const bytes = zip.toBuffer();
+  vi.stubGlobal(
+    'fetch',
+    vi.fn((input: unknown) => {
+      const url = String(input);
+      if (url.includes('/artifacts?')) {
+        return Promise.resolve(
+          Response.json({
+            artifacts: [{ id: 2, name, archive_download_url: 'https://example.test/dl/live' }],
+          }),
+        );
+      }
+      if (url === 'https://example.test/dl/live') {
+        return Promise.resolve(
+          new Response(new Uint8Array(bytes), {
+            headers: { 'Content-Length': String(bytes.length) },
+          }),
+        );
+      }
+      if (url.endsWith('/actions/runs/12345')) {
+        return Promise.resolve(
+          Response.json({
+            id: 12345,
+            name: 'Controlled context fixture',
+            head_branch: 'test',
+            head_sha: 'fixture',
+            created_at: '2026-09-21T00:00:00Z',
+            html_url: 'https://example.test/runs/12345',
+            conclusion: 'success',
+            status: 'completed',
+          }),
+        );
+      }
+      throw new Error(`Unexpected network request: ${url}`);
+    }),
+  );
+  return bytes;
+}
+
+async function readRoute(params = '') {
+  const response = await GET(
+    new NextRequest(`http://localhost/api/gpu-metrics?runId=12345${params}`),
+  );
+  expect(response.status).toBe(200);
+  return response.json();
+}
+
+function prepareSeries(files: Record<string, string>, artifactName: string): GpuMetricSeries[] {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-context-'));
+  directories.push(directory);
+  for (const [name, contents] of Object.entries(files)) {
+    const file = path.join(directory, name);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, contents);
+  }
+  return prepareGpuMetricsArtifact({ artifactName, artifactDir: directory }).map(
+    (entry, index) => ({
+      id: index + 1,
+      artifactName,
+      configKey: artifactName.slice('gpu_metrics_'.length),
+      fileName: entry.fileName,
+      vendor: entry.vendor,
+      sampleIntervalS: entry.sampleIntervalS,
+      sampleCount: entry.samples.length,
+      gpuCount: entry.gpuCount,
+      startedAt: new Date(entry.startedAtMs).toISOString(),
+      endedAt: new Date(entry.endedAtMs).toISOString(),
+      sidecars: { ...entry.sidecars },
+      benchmarkResultIds: [index + 1],
+      stats: [],
+      data: entry.samples.map((sample) => ({
+        timestamp: new Date(sample.timestampMs).toISOString(),
+        index: sample.gpuIndex,
+        power: sample.powerW!,
+      })),
+    }),
+  );
+}
+
+describe('GET /api/gpu-metrics collector context', () => {
+  it.each([
+    {
+      label: 'reversed lowercase names',
+      contexts: [
+        ['z_gpu_metrics_context.json', '+02:00'],
+        ['a_gpu_metrics_context.json', '-07:00'],
+      ],
+      expected: '2026-09-21T07:00:00.000Z',
+      expectedZone: '-07:00',
+    },
+    {
+      label: 'code-unit ordering of uppercase and lowercase names',
+      contexts: [
+        ['a_gpu_metrics_context.json', '-07:00'],
+        ['Z_gpu_metrics_context.json', '+02:00'],
+      ],
+      expected: '2026-09-20T22:00:00.000Z',
+      expectedZone: '+02:00',
+    },
+  ])('ignores ZIP context order: $label', async ({ contexts, expected, expectedZone }) => {
+    const files: Record<string, string> = {
+      ...Object.fromEntries(
+        contexts.map(([name, zone]) => [name, JSON.stringify({ timestamp_timezone: zone })]),
+      ),
+      '0_gpu_metrics_context.json': '{bad json',
+      'gpu_metrics.csv': CSV,
+      'power_validation_probe.json': JSON.stringify({
+        selected_window: {
+          start_time_unix: Date.parse('2026-09-20T22:00:00Z') / 1000,
+          end_time_unix: Date.parse('2026-09-21T07:00:01Z') / 1000,
+        },
+      }),
+    };
+    const bytes = liveArtifact(files, 'gpu_metrics_probe_live', { noSort: true });
+    const archive = new AdmZip(bytes);
+    expect(archive.getEntries().map((entry) => entry.entryName)).toEqual(Object.keys(files));
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-context-order-'));
+    directories.push(directory);
+    archive.extractAllTo(directory);
+    const [stored] = prepareGpuMetricsArtifact({
+      artifactName: 'gpu_metrics_probe_live',
+      artifactDir: directory,
+    });
+    expect(stored.sidecars.context).toEqual({ timestamp_timezone: expectedZone });
+    expect(new Date(stored.startedAtMs).toISOString()).toBe(expected);
+
+    const raw = await readRoute();
+    expect.soft(raw.artifacts[0].data[0].timestamp).toBe(expected);
+    const power = await readRoute('&series=power');
+    expect.soft(power.series[0].startMs).toBe(Date.parse(expected));
+
+    liveArtifact(files, 'power_audit_probe', { noSort: true });
+    const bundle = await readRoute('&series=power');
+    expect.soft(bundle.series[0].startMs).toBe(Date.parse(expected));
+    expect(bundle.series[0].power).toEqual([[100, 200]]);
+  });
+
+  it.each([
+    ['gpu_metrics_context.json', '-07:00', '2026-09-21T07:00:00.000Z'],
+    ['gpu_metrics_context.json', '+05:30', '2026-09-20T18:30:00.000Z'],
+    ['gpu_metrics_context.json', ' +0530 ', '2026-09-20T18:30:00.000Z'],
+    ['gpu_metrics_context.JSON', '-07:00', '2026-09-21T07:00:00.000Z'],
+    ['gpu_metrics_CONTEXT.JSON', '+05:30', '2026-09-20T18:30:00.000Z'],
+  ])('aligns live CSV, ingest and bundle timestamps for %s (%s)', async (name, zone, expected) => {
+    const files: Record<string, string> = {
+      'gpu_metrics.csv': CSV,
+    };
+    if (name === 'gpu_metrics_context.JSON') files['gpu_metrics_bad_context.json'] = '{bad json';
+    files[name] = JSON.stringify({ timestamp_timezone: zone });
+    const stored = prepareSeries(files, 'gpu_metrics_probe_live');
+    expect(stored[0].startedAt).toBe(expected);
+    liveArtifact(files);
+
+    const raw = await readRoute();
+    expect(raw.artifacts[0].data[0].timestamp).toBe(expected);
+    const power = await readRoute('&series=power');
+    expect(power.series[0].startMs).toBe(Date.parse(expected));
+    expect(power.series[0].power).toEqual([[100, 200]]);
+
+    const bundleFiles = {
+      ...files,
+      'power_validation_probe.json': JSON.stringify({
+        selected_window: {
+          start_time_unix: Date.parse(expected) / 1000,
+          end_time_unix: Date.parse(expected) / 1000 + 1,
+        },
+      }),
+    };
+    const bundle = cutPowerAuditBundle('power_audit_probe', new Map(Object.entries(bundleFiles)));
+    expect(bundle[0]?.startMs).toBe(Date.parse(expected));
+    expect(bundle[0]?.power).toEqual([[100, 200]]);
+    liveArtifact(bundleFiles, 'power_audit_probe');
+    const bundleRoute = await readRoute('&series=power');
+    expect(bundleRoute.series).toEqual(bundle);
+  });
+
+  it('uses each host directory context and skips malformed neighboring context files', async () => {
+    liveArtifact({
+      'gpu_metrics_context.json': '{"timestamp_timezone":"+12:00"}',
+      'host-a/gpu_metrics.csv': CSV,
+      'host-a/gpu_metrics_bad_context.json': '{bad json',
+      'host-a/gpu_metrics_context.json': '{"timestamp_timezone":"-07:00"}',
+      'host-b/gpu_metrics.csv': CSV,
+      'host-b/gpu_metrics_context.json': '{"timestamp_timezone":"+05:30"}',
+    });
+    const raw = await readRoute();
+    expect(raw.artifacts).toMatchObject([
+      {
+        name: 'gpu_metrics_probe_live/host-a/gpu_metrics.csv',
+        data: [
+          { timestamp: '2026-09-21T07:00:00.000Z' },
+          { timestamp: '2026-09-21T07:00:01.000Z' },
+        ],
+      },
+      {
+        name: 'gpu_metrics_probe_live/host-b/gpu_metrics.csv',
+        data: [
+          { timestamp: '2026-09-20T18:30:00.000Z' },
+          { timestamp: '2026-09-20T18:30:01.000Z' },
+        ],
+      },
+    ]);
+  });
+
+  it.each([
+    ['absent', undefined],
+    ['malformed', '{bad json'],
+    ['non-object', '[]'],
+    ['unknown zone', '{"timestamp_timezone":"America/Los_Angeles"}'],
+    ['UTC', '{"timestamp_timezone":"UTC"}'],
+  ])(
+    'keeps UTC behavior with %s context and ignores other directories',
+    async (_label, context) => {
+      const files: Record<string, string> = {
+        'gpu_metrics_host/gpu_metrics.csv': CSV,
+        'gpu_metrics_context.json': '{"timestamp_timezone":"-07:00"}',
+        'gpu_metrics_host/unrelated_context.json': '{"timestamp_timezone":"+05:30"}',
+        'gpu_metrics_host/GPU_METRICS_context.JSON': '{"timestamp_timezone":"+05:30"}',
+      };
+      if (context !== undefined) files['gpu_metrics_host/gpu_metrics_context.json'] = context;
+      liveArtifact(files);
+      const raw = await readRoute();
+      expect(raw.artifacts[0].data[0].timestamp).toBe('2026/09/21 00:00:00.000');
+      const power = await readRoute('&series=power');
+      expect(power.series[0].startMs).toBe(Date.parse('2026-09-21T00:00:00Z'));
+    },
+  );
+
+  it.each([
+    ['ISO', `${HEADER}\n2026-09-21T07:00:00Z, 0, 100 W, 40, 1500, 2000, 90, 80\n`],
+    [
+      'AMD seconds',
+      `timestamp,gpu,socket_power\n${Date.parse('2026-09-21T07:00:00Z') / 1000},0,100\n`,
+    ],
+    [
+      'AMD milliseconds',
+      `timestamp,gpu,socket_power\n${Date.parse('2026-09-21T07:00:00Z')},0,100\n`,
+    ],
+  ])('does not apply the collector offset twice to %s timestamps', async (_label, csv) => {
+    liveArtifact({
+      'gpu_metrics.csv': csv,
+      'gpu_metrics_context.json': '{"timestamp_timezone":"-07:00"}',
+    });
+    const raw = await readRoute();
+    expect(raw.artifacts[0].data[0].timestamp).toBe(parseCsvData(csv)[0].timestamp);
+    const power = await readRoute('&series=power');
+    expect(power.series[0].startMs).toBe(Date.parse('2026-09-21T07:00:00Z'));
+  });
+
+  it('keeps recovered live power aligned with durable history and raw responses', async () => {
+    const files = {
+      'gpu_metrics.csv': CSV,
+      'gpu_metrics_context.json': '{"timestamp_timezone":"-07:00"}',
+    };
+    const healthy = prepareSeries(files, 'gpu_metrics_probe_stored');
+    const partial = prepareSeries(files, 'gpu_metrics_probe_live');
+    partial[0].data = partial[0].data.slice(0, 1);
+    readStored.mockResolvedValue({
+      workflowRun: {
+        id: 7,
+        githubRunId: 12345,
+        runAttempt: 1,
+        name: 'Controlled context fixture',
+        date: '2026-09-21',
+        htmlUrl: 'https://example.test/runs/12345',
+        headBranch: 'test',
+        headSha: 'fixture',
+        conclusion: 'success',
+        status: 'completed',
+        createdAt: '2026-09-21T00:00:00Z',
+      },
+      series: [...healthy, ...partial],
+    });
+    liveArtifact(files);
+    const power = await readRoute('&series=power&prefix=probe_');
+    expect(power.source).toBe('github');
+    expect(power.series).toMatchObject([
+      {
+        artifact: 'gpu_metrics_probe_stored',
+        startMs: Date.parse('2026-09-21T07:00:00Z'),
+        power: [[100, 200]],
+      },
+      {
+        artifact: 'gpu_metrics_probe_live',
+        startMs: Date.parse('2026-09-21T07:00:00Z'),
+        power: [[100, 200]],
+      },
+    ]);
+
+    const storedRaw = await readRoute('&prefix=probe_stored');
+    expect(storedRaw.source).toBe('database');
+    readStored.mockResolvedValue(null);
+    const liveRaw = await readRoute('&prefix=probe_live');
+    expect(liveRaw.source).toBe('github');
+    expect(liveRaw.artifacts[0].data).toMatchObject(storedRaw.artifacts[0].data);
+  });
+});
diff --git a/packages/app/src/app/api/gpu-metrics/route.sources.test.ts b/packages/app/src/app/api/gpu-metrics/route.sources.test.ts
new file mode 100644
index 000000000..f8d59998b
--- /dev/null
+++ b/packages/app/src/app/api/gpu-metrics/route.sources.test.ts
@@ -0,0 +1,356 @@
+import AdmZip from 'adm-zip';
+import { NextRequest } from 'next/server';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+import { parseCsvData } from '@/components/gpu-power/types';
+import type { InferenceData } from '@/components/inference/types';
+import {
+  joinPowerTimeline,
+  planPowerTimelineRequests,
+} from '@/components/inference/utils/powerTimeline';
+
+const { readRun } = vi.hoisted(() => ({ readRun: vi.fn() }));
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({
+  getDb: () => ({}),
+}));
+vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
+  getGpuMetricsForRun: readRun,
+}));
+
+import { GET, POST } from './route';
+
+const RUN_ID = '12345';
+const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
+const NAME_A = 'dsr1_conc32_b200';
+const NAME_B = 'dsr1_conc64_b200';
+const source = (name: string) => `power_validation_${name}.json`;
+const csvName = (name: string) => `gpu_metrics_${name}`;
+const SOURCE_A = source(NAME_A);
+const SOURCE_B = source(NAME_B);
+const START = Date.parse('2026-03-01T00:00:00Z') / 1000;
+const workflowRun = {
+  id: 1,
+  githubRunId: Number(RUN_ID),
+  runAttempt: 1,
+  name: 'Run Sweep',
+  date: '2026-03-01',
+  htmlUrl: RUN_URL,
+  headBranch: 'main',
+  headSha: 'abc123',
+  conclusion: 'success',
+  status: 'completed',
+  createdAt: '2026-03-01T00:00:00Z',
+};
+
+function csv(power: number): string {
+  return [
+    'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+    `2026/03/01 00:00:00.000, 0, ${power} W, 65, 1500 MHz, 2000 MHz, 95 %, 80 %`,
+    `2026/03/01 00:00:01.000, 0, ${power + 10} W, 65, 1500 MHz, 2000 MHz, 95 %, 80 %`,
+  ].join('\n');
+}
+
+function stored(name: string, power = 100): GpuMetricSeries {
+  return {
+    id: 1,
+    artifactName: csvName(name),
+    configKey: name,
+    fileName: 'gpu_metrics.csv',
+    vendor: 'nvidia',
+    sampleIntervalS: 1,
+    sampleCount: 2,
+    gpuCount: 1,
+    startedAt: '2026-03-01T00:00:00Z',
+    endedAt: '2026-03-01T00:00:01Z',
+    sidecars: {
+      seriesInventory: [{ fileName: 'gpu_metrics.csv', sampleCount: 2 }],
+    },
+    benchmarkResultIds: [1],
+    stats: [],
+    data: parseCsvData(csv(power)).map((row, index) => ({
+      ...row,
+      timestamp: new Date((START + index) * 1000).toISOString(),
+    })),
+  };
+}
+
+function zip(entries: Record<string, string>): Uint8Array<ArrayBuffer> {
+  const archive = new AdmZip();
+  for (const [name, text] of Object.entries(entries)) archive.addFile(name, Buffer.from(text));
+  return new Uint8Array(archive.toBuffer());
+}
+
+function github(archives: Record<string, Uint8Array<ArrayBuffer>>) {
+  const downloads: string[] = [];
+  vi.stubGlobal(
+    'fetch',
+    vi.fn((input: string | URL | Request) => {
+      const url = String(input);
+      if (url.includes('/artifacts?')) {
+        return Promise.resolve(
+          Response.json({
+            artifacts: Object.keys(archives).map((name, id) => ({
+              id,
+              name,
+              archive_download_url: `https://artifacts.test/${name}`,
+            })),
+          }),
+        );
+      }
+      if (url.startsWith('https://artifacts.test/')) {
+        const name = url.slice('https://artifacts.test/'.length);
+        downloads.push(name);
+        return Promise.resolve(new Response(archives[name]));
+      }
+      return Promise.resolve(
+        Response.json({
+          id: Number(RUN_ID),
+          name: workflowRun.name,
+          head_branch: 'main',
+          head_sha: 'abc123',
+          created_at: workflowRun.createdAt,
+          html_url: RUN_URL,
+          conclusion: 'success',
+          status: 'completed',
+        }),
+      );
+    }),
+  );
+  return downloads;
+}
+
+function request(body: unknown, prefix = 'dsr1_', raw = false): NextRequest {
+  const params = new URLSearchParams({
+    runId: RUN_ID,
+    series: 'power',
+    prefix,
+  });
+  return new NextRequest(`http://localhost/api/gpu-metrics?${params}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: raw ? String(body) : JSON.stringify(body),
+  });
+}
+
+beforeEach(() => {
+  readRun.mockReset().mockResolvedValue({ workflowRun, series: [stored(NAME_A)] });
+  vi.stubEnv('DATABASE_READONLY_URL', 'postgresql://readonly.example.test/test');
+  vi.stubEnv('GITHUB_TOKEN', 'test-token');
+  vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Unexpected GitHub request')));
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
+});
+
+describe('Timeline requested-source coverage', () => {
+  it('keeps the planned stored c32 and downloads only missing c64 under their common prefix', async () => {
+    const points = [NAME_A, NAME_B].map(
+      (name, index) =>
+        ({
+          x: 1,
+          y: 1,
+          hwKey: 'b200_sglang',
+          tp: 4,
+          conc: index === 0 ? 32 : 64,
+          precision: 'fp8',
+          date: '2026-03-01',
+          run_url: RUN_URL,
+          power_audit: { source: source(name) },
+        }) as InferenceData,
+    );
+    const [planned] = planPowerTimelineRequests(points);
+    expect(planned.sources).toEqual([SOURCE_A, SOURCE_B]);
+    const downloads = github({
+      [csvName(NAME_A)]: zip({ 'gpu_metrics.csv': csv(900) }),
+      [csvName(NAME_B)]: zip({ 'gpu_metrics.csv': csv(300) }),
+      gpu_metrics_dsr1_conc128_b200: zip({ 'gpu_metrics.csv': csv(500) }),
+    });
+    const response = await POST(request({ sources: planned.sources }, planned.prefix));
+    expect(response.status).toBe(200);
+    expect(response.headers.get('Cache-Control')).toBe('no-store');
+    const body = await response.json();
+    expect(body.sourceCoverage).toEqual({
+      status: 'complete',
+      missingSources: [],
+    });
+    expect(downloads).toEqual([csvName(NAME_B)]);
+    const joined = joinPowerTimeline(points, new Map([[RUN_ID, body]]));
+    expect(joined.missing).toEqual([]);
+    expect(joined.traces.map((trace) => trace.series.power)).toEqual([[[100, 110]], [[300, 310]]]);
+  });
+
+  it('serves the complete requested set from DB without GitHub and canonicalizes duplicates', async () => {
+    readRun.mockResolvedValue({
+      workflowRun,
+      series: [stored(NAME_A), stored(NAME_B, 300)],
+    });
+    const response = await POST(request({ sources: [SOURCE_B, SOURCE_A, SOURCE_B] }));
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body.sourceCoverage).toEqual({
+      status: 'complete',
+      missingSources: [],
+    });
+    expect(body.series).toHaveLength(2);
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it.each(['no token', 'GitHub 404'])(
+    'preserves healthy DB data with incomplete coverage when %s',
+    async (failure) => {
+      if (failure === 'no token') vi.stubEnv('GITHUB_TOKEN', '');
+      else vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(null, { status: 404 })));
+      const response = await POST(request({ sources: [SOURCE_B, SOURCE_A] }));
+      expect(response.status).toBe(200);
+      const body = await response.json();
+      expect(body.sourceCoverage).toEqual({
+        status: 'incomplete',
+        missingSources: [SOURCE_B],
+      });
+      expect(body.series).toMatchObject([{ artifact: csvName(NAME_A), power: [[100, 110]] }]);
+      if (failure === 'no token') expect(globalThis.fetch).not.toHaveBeenCalled();
+    },
+  );
+
+  it('does not call an identity-free GET complete', async () => {
+    const response = await GET(
+      new NextRequest(`http://localhost/api/gpu-metrics?runId=${RUN_ID}&series=power`),
+    );
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body.sourceCoverage).toEqual({
+      status: 'unknown',
+      missingSources: [],
+    });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('keeps known missing hosts as 503 even when another requested series is healthy', async () => {
+    const partial = stored(NAME_B, 300);
+    partial.sidecars.seriesInventory = [
+      { fileName: 'gpu_metrics.csv', sampleCount: 2 },
+      { fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
+    ];
+    readRun.mockResolvedValue({
+      workflowRun,
+      series: [stored(NAME_A), partial],
+    });
+    vi.stubEnv('GITHUB_TOKEN', '');
+    const response = await POST(request({ sources: [SOURCE_A, SOURCE_B] }));
+    expect(response.status).toBe(503);
+    expect(await response.json()).toMatchObject({
+      code: 'STORED_TELEMETRY_INCOMPLETE',
+      artifact: csvName(NAME_B),
+    });
+  });
+
+  it('ignores an unrelated partial artifact under the same common prefix', async () => {
+    const partial = stored('dsr1_conc128_b200');
+    partial.sidecars.seriesInventory = [{ fileName: 'missing.csv', sampleCount: 2 }];
+    readRun.mockResolvedValue({
+      workflowRun,
+      series: [stored(NAME_A), partial],
+    });
+    const response = await POST(request({ sources: [SOURCE_A] }));
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body.sourceCoverage).toEqual({
+      status: 'complete',
+      missingSources: [],
+    });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('supplements a missing validation window from the same bundle without replacing its stored window', async () => {
+    const artifact = 'power_audit_dsr1';
+    const validation = {
+      selected_window: { start_time_unix: START, end_time_unix: START + 1 },
+    };
+    const bundle = stored(NAME_A);
+    bundle.artifactName = artifact;
+    bundle.fileName = 'LOGS/power/samples.csv#host-a';
+    bundle.sidecars = {
+      identity: [{ hostname: 'host-a', gpu_index: 0, gpu_uuid: 'GPU-a' }],
+      validations: { [SOURCE_A]: validation },
+      seriesInventory: [{ fileName: bundle.fileName, sampleCount: 2 }],
+    };
+    readRun.mockResolvedValue({ workflowRun, series: [bundle] });
+    const downloads = github({
+      [artifact]: zip({
+        'LOGS/power/samples.csv': [
+          'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+          `1,${START},1,host-a,0,GPU-a,900`,
+          `1,${START + 1},2,host-a,0,GPU-a,910`,
+        ].join('\n'),
+        'LOGS/power/manifest.json': '{}',
+        [SOURCE_A]: JSON.stringify(validation),
+        [SOURCE_B]: JSON.stringify(validation),
+      }),
+    });
+    const response = await POST(request({ sources: [SOURCE_A, SOURCE_B] }));
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body.sourceCoverage).toEqual({
+      status: 'complete',
+      missingSources: [],
+    });
+    expect(body.series).toHaveLength(2);
+    expect(
+      body.series.find((entry: { source: string }) => entry.source === SOURCE_A).power,
+    ).toEqual([[100, 110]]);
+    expect(
+      body.series.find((entry: { source: string }) => entry.source === SOURCE_B).power,
+    ).toEqual([[900, 910]]);
+    expect(downloads).toEqual([artifact]);
+  });
+});
+
+describe('Timeline source request validation', () => {
+  it.each([
+    ['malformed JSON', '{', true],
+    ['null', null, false],
+    ['missing sources', {}, false],
+    ['string sources', { sources: SOURCE_A }, false],
+    ['empty sources', { sources: [] }, false],
+    ['non-string source', { sources: [42] }, false],
+    ['source path', { sources: [`dir/${SOURCE_A}`] }, false],
+    ['wrong source name', { sources: [csvName(NAME_A)] }, false],
+    ['overlong suffix', { sources: [source(`dsr1_${'a'.repeat(196)}`)] }, false],
+    ['too many sources', { sources: Array.from({ length: 1001 }, () => SOURCE_A) }, false],
+    ['prefix mismatch', { sources: [source('other_conc32')] }, false],
+  ])('rejects %s before DB or GitHub access', async (_label, body, raw) => {
+    const response = await POST(request(body, 'dsr1_', Boolean(raw)));
+    expect(response.status).toBe(400);
+    expect(readRun).not.toHaveBeenCalled();
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects bodies beyond 256 KiB before attempting telemetry reads', async () => {
+    const response = await POST(request(' '.repeat(256 * 1024 + 1), 'dsr1_', true));
+    expect(response.status).toBe(413);
+    expect(readRun).not.toHaveBeenCalled();
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('accepts 1000 bounded sources through the body without a long query string', async () => {
+    const names = Array.from(
+      { length: 1000 },
+      (_, index) => `dsr1_${String(index).padStart(4, '0')}_${'a'.repeat(190)}`,
+    );
+    const sources = names.map(source);
+    readRun.mockResolvedValue({ workflowRun, series: [stored(names[0])] });
+    vi.stubEnv('GITHUB_TOKEN', '');
+    const input = request({ sources });
+    expect(input.url.length).toBeLessThan(200);
+    const response = await POST(input);
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body.sourceCoverage).toEqual({
+      status: 'incomplete',
+      missingSources: sources.slice(1),
+    });
+  });
+});
diff --git a/packages/app/src/app/api/gpu-metrics/route.test.ts b/packages/app/src/app/api/gpu-metrics/route.test.ts
index 06dff6412..89aa6d990 100644
--- a/packages/app/src/app/api/gpu-metrics/route.test.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.test.ts
@@ -1,4 +1,5 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import type * as GpuPowerTypes from '@/components/gpu-power/types';
 
 const { mockParseCsvData, zipArchives } = vi.hoisted(() => {
   interface ZipEntry {
@@ -9,7 +10,7 @@ const { mockParseCsvData, zipArchives } = vi.hoisted(() => {
     { entryName: 'gpu_metrics_0.csv', data: 'timestamp,index,power\n2026-03-01T00:00:00Z,0,300' },
   ];
   return {
-    mockParseCsvData: vi.fn((csv: string) => {
+    mockParseCsvData: vi.fn((csv: string): GpuPowerTypes.GpuMetricRow[] => {
       if (csv.trim().length === 0) return [];
       return [
         {
@@ -86,6 +87,10 @@ function req(url: string): NextRequest {
   return new NextRequest(new URL(url, 'http://localhost'));
 }
 
+function nvidiaRow(second: number, power: number): string {
+  return `2026/03/01 00:00:0${second}.000, 0, ${power} W, 65, 1500 MHz, 2000 MHz, 95 %, 80 %`;
+}
+
 beforeEach(() => {
   vi.clearAllMocks();
   zipArchives.byKey.clear();
@@ -299,18 +304,300 @@ describe('GET /api/gpu-metrics — database first', () => {
     expect(body.artifacts[0].name).toBe('gpu_metrics_live');
   });
 
-  it('falls back to GitHub when the database lookup throws', async () => {
+  it('reports a database failure separately instead of treating it as missing data', async () => {
     process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
     mockGetGpuMetricsForRun.mockRejectedValueOnce(new Error('relation does not exist'));
     globalThis.fetch = vi.fn().mockResolvedValueOnce({ ok: false, status: 404 });
 
     const res = await GET(req('/api/gpu-metrics?runId=99'));
-    expect(res.status).toBe(500);
+    expect(res.status).toBe(503);
+    expect(await res.json()).toMatchObject({ code: 'DATABASE_UNAVAILABLE' });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('renders persisted Timeline series with GitHub unavailable and preserves prefix filtering', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    mockGetGpuMetricsForRun.mockResolvedValueOnce(storedRunPayload);
+    globalThis.fetch = vi.fn().mockRejectedValue(new Error('GitHub artifacts expired'));
+    const res = await GET(req('/api/gpu-metrics?runId=34557177019&series=power&prefix=dsr1_'));
+    expect(res.status).toBe(200);
+    expect(res.headers.get('Cache-Control')).toBe('no-store');
+    expect(await res.json()).toMatchObject({
+      source: 'database',
+      series: [
+        {
+          artifact: 'gpu_metrics_dsr1_conc32_b200-x_0',
+          startMs: Date.parse('2026-09-11T04:19:41Z'),
+          bucketSeconds: 1,
+          gpus: [0],
+          t: [0, 1],
+          power: [[187.8, 912.1]],
+        },
+      ],
+    });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('uses stored bundle windows when a point prefix extends past the artifact name', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    const source = 'power_validation_qwen3.5_8k1k_fp8_slurm_conc32.json';
+    const base = storedRunPayload.series[0];
+    const start = Date.parse(base.data[0].timestamp) / 1000;
+    const bundle = (host: string, power: number) => ({
+      ...base,
+      artifactName: 'power_audit_qwen3.5_8k1k_fp8_slurm',
+      fileName: `LOGS/power/samples.csv#${host}`,
+      sidecars: {
+        identity: [{ hostname: host, gpu_index: 0, gpu_uuid: `GPU-${host}` }],
+        validations: {
+          [source]: { selected_window: { start_time_unix: start, end_time_unix: start + 1 } },
+        },
+      },
+      data: [{ ...base.data[0], power }],
+    });
+    mockGetGpuMetricsForRun.mockResolvedValueOnce({
+      ...storedRunPayload,
+      series: [bundle('a', 100), bundle('b', 500)],
+    });
+    globalThis.fetch = vi.fn().mockRejectedValue(new Error('GitHub unavailable'));
+    const res = await GET(
+      req('/api/gpu-metrics?runId=34557177019&series=power&prefix=qwen3.5_8k1k_fp8_slurm_conc32'),
+    );
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.series).toMatchObject([
+      {
+        artifact: 'power_audit_qwen3.5_8k1k_fp8_slurm',
+        source,
+        gpus: [0, 1],
+        power: [[100], [500]],
+        devices: [{ id: 'a/GPU-a' }, { id: 'b/GPU-b' }],
+      },
+    ]);
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('reports the incomplete artifact and recovery action when partial storage cannot fall back to GitHub', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    const entry = storedRunPayload.series[0];
+    const artifactName = 'power_audit_qwen3.5_multinode';
+    mockGetGpuMetricsForRun.mockResolvedValueOnce({
+      ...storedRunPayload,
+      series: [
+        {
+          ...entry,
+          artifactName,
+          fileName: 'LOGS/power/samples.csv#host-a',
+          sidecars: {
+            seriesInventory: [
+              { fileName: 'LOGS/power/samples.csv#host-a', sampleCount: 2 },
+              { fileName: 'LOGS/power/samples.csv#host-b', sampleCount: 2 },
+            ],
+          },
+        },
+      ],
+    });
+    globalThis.fetch = vi.fn().mockResolvedValue({ ok: false, status: 404 });
+    const res = await GET(req('/api/gpu-metrics?runId=34557177019&series=power'));
     expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+    expect(res.status).toBe(503);
+    const body = await res.json();
+    expect(body).toMatchObject({ code: 'STORED_TELEMETRY_INCOMPLETE', artifact: artifactName });
+    expect(body.error).toContain('host-b');
+    expect(body.error).toContain('Re-ingest');
+    expect(body.series).toBeUndefined();
+  });
+
+  it.each([
+    'complete',
+    'missing host',
+    'empty host',
+    'truncated host',
+    'second missing artifact',
+    'healthy stored artifact',
+    'healthy stored artifact also live',
+  ])('checks retained file/sample coverage before using a %s CSV fallback', async (coverage) => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    const { parseCsvData } = await vi.importActual<typeof GpuPowerTypes>(
+      '@/components/gpu-power/types',
+    );
+    const header =
+      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
+    const hostA = [header, nvidiaRow(0, 300), nvidiaRow(0, 999), nvidiaRow(1, 310)].join('\n');
+    const hostB =
+      coverage === 'empty host'
+        ? header
+        : [
+            header,
+            nvidiaRow(0, 500),
+            ...(coverage === 'truncated host' ? [] : [nvidiaRow(1, 510)]),
+          ].join('\n');
+    zipArchives.byKey.set('coverage', [
+      { entryName: 'host-a/gpu_metrics.csv', data: hostA },
+      ...(coverage === 'missing host'
+        ? []
+        : [{ entryName: 'host-b/gpu_metrics.csv', data: hostB }]),
+    ]);
+    mockParseCsvData.mockImplementationOnce(parseCsvData);
+    if (coverage !== 'missing host') mockParseCsvData.mockImplementationOnce(parseCsvData);
+    const entry = storedRunPayload.series[0];
+    const healthyStoredArtifact = coverage.startsWith('healthy stored artifact');
+    mockGetGpuMetricsForRun.mockResolvedValueOnce({
+      ...storedRunPayload,
+      series: [
+        {
+          ...entry,
+          artifactName: 'gpu_metrics_live',
+          fileName: 'host-a/gpu_metrics.csv',
+          sidecars: {
+            seriesInventory: [
+              { fileName: 'host-a/gpu_metrics.csv', sampleCount: 2 },
+              { fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
+            ],
+          },
+        },
+        ...(healthyStoredArtifact ? [entry] : []),
+        ...(coverage === 'second missing artifact'
+          ? [
+              {
+                ...entry,
+                artifactName: 'gpu_metrics_second',
+                fileName: 'host-a/gpu_metrics.csv',
+                sidecars: {
+                  seriesInventory: [
+                    { fileName: 'host-a/gpu_metrics.csv', sampleCount: 2 },
+                    { fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
+                  ],
+                },
+              },
+            ]
+          : []),
+      ],
+    });
+    globalThis.fetch = vi
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            id: 34557177019,
+            name: 'Sweep',
+            head_branch: 'main',
+            head_sha: 'abc',
+            created_at: '2026-03-01T00:00:00Z',
+            html_url: 'https://example.test/run',
+            status: 'completed',
+            conclusion: 'success',
+          }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            artifacts: [
+              {
+                id: 1,
+                name: 'gpu_metrics_live',
+                archive_download_url: 'https://example.test/zip',
+              },
+              ...(coverage === 'healthy stored artifact also live'
+                ? [
+                    {
+                      id: 2,
+                      name: entry.artifactName,
+                      archive_download_url: 'https://example.test/healthy-zip',
+                    },
+                  ]
+                : []),
+            ],
+          }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        arrayBuffer: () => Promise.resolve(new TextEncoder().encode('coverage').buffer),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+      });
+    const res = await GET(req('/api/gpu-metrics?runId=34557177019&series=power'));
+    if (coverage === 'complete' || healthyStoredArtifact) {
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.source).toBe('github');
+      expect(body.series).toHaveLength(healthyStoredArtifact ? 2 : 1);
+      expect(body.series).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            artifact: 'gpu_metrics_live',
+            power: [
+              [300, 310],
+              [500, 510],
+            ],
+          }),
+          ...(healthyStoredArtifact
+            ? [
+                expect.objectContaining({
+                  artifact: entry.artifactName,
+                  power: [[187.8, 912.1]],
+                }),
+              ]
+            : []),
+        ]),
+      );
+    } else {
+      expect(res.status).toBe(503);
+      expect(await res.json()).toMatchObject({
+        code: 'STORED_TELEMETRY_INCOMPLETE',
+        artifact:
+          coverage === 'second missing artifact' ? 'gpu_metrics_second' : 'gpu_metrics_live',
+      });
+    }
+    expect(globalThis.fetch).toHaveBeenCalledTimes(
+      coverage === 'healthy stored artifact also live' ? 4 : 3,
+    );
+  });
+
+  it('reports Timeline database failure even when the GitHub token is absent', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    delete process.env.GITHUB_TOKEN;
+    mockGetGpuMetricsForRun.mockRejectedValueOnce(new Error('connection unavailable'));
+    globalThis.fetch = vi.fn();
+    const res = await GET(req('/api/gpu-metrics?runId=34557177019&series=power'));
+    expect(res.status).toBe(503);
+    expect(await res.json()).toMatchObject({ code: 'DATABASE_UNAVAILABLE' });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
   });
 });
 
 describe('GET /api/gpu-metrics', () => {
+  it('keeps host-local GPU zero separate in the default live multi-file response', async () => {
+    const { parseCsvData } = await vi.importActual<typeof GpuPowerTypes>(
+      '@/components/gpu-power/types',
+    );
+    const header =
+      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
+    zipArchives.byKey.set('multinode-csv', [
+      { entryName: 'host-a/gpu_metrics.csv', data: [header, nvidiaRow(0, 300)].join('\n') },
+      { entryName: 'host-b/gpu_metrics.csv', data: [header, nvidiaRow(0, 500)].join('\n') },
+    ]);
+    mockParseCsvData.mockImplementationOnce(parseCsvData).mockImplementationOnce(parseCsvData);
+    mockGithub([{ name: 'gpu_metrics_live', url: 'https://example.test/dl/multinode' }], {
+      'https://example.test/dl/multinode': { archive: 'multinode-csv' },
+    });
+    const res = await GET(req('/api/gpu-metrics?runId=12345'));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toMatchObject({
+      source: 'github',
+      artifacts: [
+        { name: 'gpu_metrics_live/host-a/gpu_metrics.csv', data: [{ index: 0, power: 300 }] },
+        { name: 'gpu_metrics_live/host-b/gpu_metrics.csv', data: [{ index: 0, power: 500 }] },
+      ],
+    });
+  });
+
   it('returns 400 when runId is missing', async () => {
     const res = await GET(req('/api/gpu-metrics'));
     expect(res.status).toBe(400);
@@ -792,6 +1079,49 @@ describe('GET /api/gpu-metrics?series=power with power_audit bundles', () => {
     vi.spyOn(console, 'warn').mockImplementation(() => {});
   });
 
+  it('does not accept a same-name partial bundle as recovery for known missing stored hosts', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    mockGetGpuMetricsForRun.mockResolvedValueOnce({
+      ...storedRunPayload,
+      series: [
+        {
+          ...storedRunPayload.series[0],
+          artifactName: BUNDLE_NAME,
+          fileName: 'LOGS/power/samples.csv#cn01',
+          sidecars: {
+            seriesInventory: [
+              { fileName: 'LOGS/power/samples.csv#cn01', sampleCount: 2 },
+              { fileName: 'LOGS/power/samples.csv#cn02', sampleCount: 2 },
+            ],
+          },
+        },
+      ],
+    });
+    zipArchives.byKey.set(
+      'partial-bundle',
+      BUNDLE_ARCHIVE.map((entry) =>
+        entry.entryName === 'LOGS/power/samples.csv'
+          ? {
+              ...entry,
+              data: entry.data
+                .split('\n')
+                .filter((line) => !line.includes(',cn02,'))
+                .join('\n'),
+            }
+          : entry,
+      ),
+    );
+    mockGithub([{ name: BUNDLE_NAME, url: 'https://example.test/dl/bundle' }], {
+      'https://example.test/dl/bundle': { archive: 'partial-bundle' },
+    });
+    const res = await GET(req('/api/gpu-metrics?runId=12345&series=power'));
+    expect(res.status).toBe(503);
+    expect(await res.json()).toMatchObject({
+      code: 'STORED_TELEMETRY_INCOMPLETE',
+      artifact: BUNDLE_NAME,
+    });
+  });
+
   it('cuts a bundle into per-window series alongside gpu_metrics series', async () => {
     const fetchMock = mockGithub(
       [
diff --git a/packages/app/src/app/api/gpu-metrics/route.ts b/packages/app/src/app/api/gpu-metrics/route.ts
index ac13862cb..202400433 100644
--- a/packages/app/src/app/api/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.ts
@@ -8,7 +8,7 @@
  *
  * DO NOT ADD CACHING (blob, CDN, or unstable_cache) to this route. The
  * fallback fetches live GitHub Actions artifacts which change while a run is
- * in progress, and the database path is already a single indexed read.
+ * in progress, and stored telemetry must reflect a successful re-ingest immediately.
  *
  * Two telemetry collectors publish GPU power for a run:
  * - single-node runners (nvidia-smi / amd-smi) publish one `gpu_metrics_<RESULT_FILENAME>`
@@ -26,12 +26,15 @@
  *   (`components/gpu-power/power-series.ts`) for the PowerX timeline, from
  *   CSV artifacts and from bundles cut per validation window. The timeline
  *   joins them to chart points by `source` (bundle) or artifact name (CSV).
- *   This shape still reads GitHub: the stored digest holds the same samples
- *   but no per-window cut yet.
+ *   Persisted samples and validation windows use the same bucketing/cut
+ *   transform as artifacts, so historical runs survive artifact expiry.
  * `prefix=<RESULT_FILENAME prefix>` narrows either shape to the artifacts of
  * one model / workload / precision so a full nightly sweep is not downloaded
  * for one chart. A bundle names a whole sweep, so it also matches when the
  * prefix extends past its name into the per-concurrency suffix.
+ * Timeline POSTs sorted validation basenames in `{ sources: [...] }` to recover
+ * missing siblings while keeping fully covered DB reads independent of GitHub.
+ * `sourceCoverage` describes those requested identities, not full-run completeness.
  */
 import { type NextRequest, NextResponse } from 'next/server';
 
@@ -42,16 +45,21 @@ import {
   type GpuMetricsRunPayload,
 } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
 
-import {
-  parseCsvData,
-  type GpuMetricRow,
-  type GpuPowerRunInfo,
-} from '@/components/gpu-power/types';
+import { type GpuMetricRow, type GpuPowerRunInfo } from '@/components/gpu-power/types';
 import {
   cutPowerAuditBundle,
   isPowerAuditBundleEntry,
+  parsePowerCsvData,
 } from '@/components/gpu-power/power-audit-bundle';
-import { bucketPowerSeries, type GpuPowerSeries } from '@/components/gpu-power/power-series';
+import {
+  bucketPowerFiles,
+  parseTelemetryTimestampUtc,
+  type GpuPowerSeries,
+} from '@/components/gpu-power/power-series';
+import {
+  storedPowerSeries,
+  StoredTelemetryIncompleteError,
+} from '@/components/gpu-power/stored-power-series';
 import {
   downloadGithubArtifact,
   extractZipEntries,
@@ -75,6 +83,8 @@ const ARTIFACT_PREFIX = 'gpu_metrics_';
 const BUNDLE_PREFIX = 'power_audit_';
 /** RESULT_FILENAME characters: model, workload, precision, framework, parallelism, host, hash. */
 const PREFIX_PATTERN = /^[A-Za-z0-9._-]{1,200}$/u;
+const SOURCE_PATTERN = /^power_validation_[A-Za-z0-9._-]{1,200}\.json$/u;
+const MAX_REQUEST_BYTES = 256 * 1024;
 
 export type GpuMetricsSource = 'database' | 'github';
 
@@ -125,7 +135,13 @@ export function databasePayloadToResponse(payload: GpuMetricsRunPayload): GpuMet
 }
 
 /** The GitHub path also carries the bundle series the timeline draws. */
-interface GithubGpuMetricsResponse extends GpuMetricsRouteResponse {
+interface GithubArtifactPayload {
+  name: string;
+  files: { name: string; data: GpuMetricRow[] }[];
+}
+
+interface GithubGpuMetricsResponse extends Omit<GpuMetricsRouteResponse, 'artifacts'> {
+  artifacts: GithubArtifactPayload[];
   source: 'github';
   bundleSeries: GpuPowerSeries[];
 }
@@ -135,7 +151,7 @@ type TelemetryJob =
   | { kind: 'bundle'; artifact: GithubArtifact };
 
 type TelemetryResult =
-  | { kind: 'csv'; parsed: GpuMetricsArtifactPayload }
+  | { kind: 'csv'; parsed: GithubArtifactPayload }
   | { kind: 'bundle'; series: GpuPowerSeries[] };
 
 /** Fetches one artifact zip, or `null` (with a warning) when it fails or exceeds `maxBytes`. */
@@ -161,18 +177,37 @@ async function downloadZip(
 async function downloadArtifact(
   artifact: GithubArtifact,
   githubToken: string,
-): Promise<GpuMetricsArtifactPayload | null> {
+): Promise<GithubArtifactPayload | null> {
   const buffer = await downloadZip(artifact, githubToken, MAX_ARTIFACT_BYTES);
   if (!buffer) return null;
-  const rows = extractZipEntries(
+  const contexts = new Map<string, Record<string, unknown>>();
+  const contextFiles = extractZipEntries(buffer, '.json', (name, contents) => {
+    const base = name.slice(name.lastIndexOf('/') + 1);
+    if (!base.includes('gpu_metrics') || !base.toLowerCase().endsWith('_context.json')) return [];
+    const context: unknown = JSON.parse(contents);
+    return context && typeof context === 'object' && !Array.isArray(context)
+      ? [{ name, context: context as Record<string, unknown> }]
+      : [];
+  });
+  // Ingest uses code-unit filename order, not archive order or the host locale.
+  contextFiles.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  for (const { name, context } of contextFiles) {
+    const directory = name.slice(0, name.lastIndexOf('/') + 1);
+    if (!contexts.has(directory)) contexts.set(directory, context);
+  }
+  const files = extractZipEntries(
     buffer,
     '.csv',
-    (_entryName, contents) => parseCsvData(contents),
+    (entryName, contents) => {
+      const directory = entryName.slice(0, entryName.lastIndexOf('/') + 1);
+      const data = parsePowerCsvData(contents, contexts.get(directory) ?? null);
+      return data.length > 0 ? [{ name: entryName, data }] : [];
+    },
     (entryName, error) => {
       console.warn(`Failed to parse CSV ${entryName} from ${artifact.name}:`, error);
     },
   );
-  return rows.length > 0 ? { name: artifact.name, data: rows } : null;
+  return files.length > 0 ? { name: artifact.name, files } : null;
 }
 
 async function downloadBundle(
@@ -237,6 +272,35 @@ function isWantedBundle(name: string, prefix: string | null): boolean {
   return name.startsWith(wanted) || wanted.startsWith(name);
 }
 
+/** Validation basenames identify individual windows, including siblings in one bundle. */
+function seriesSource(series: GpuPowerSeries): string | null {
+  return (
+    series.source ??
+    (series.artifact.startsWith(ARTIFACT_PREFIX)
+      ? `power_validation_${series.artifact.slice(ARTIFACT_PREFIX.length)}.json`
+      : null)
+  );
+}
+
+function isRequestedArtifact(name: string, sources: string[] | null): boolean {
+  return (
+    sources === null ||
+    sources.some((source) => {
+      const result = source.slice('power_validation_'.length, -'.json'.length);
+      return name === `${ARTIFACT_PREFIX}${result}` || isWantedBundle(name, result);
+    })
+  );
+}
+
+function sourceCoverage(series: GpuPowerSeries[], sources: string[] | null) {
+  const available = new Set(series.map(seriesSource));
+  const missingSources = sources?.filter((source) => !available.has(source)) ?? [];
+  return {
+    status: sources === null ? 'unknown' : missingSources.length > 0 ? 'incomplete' : 'complete',
+    missingSources,
+  };
+}
+
 /**
  * Narrows a stored run to the artifacts a `prefix` names, mirroring the GitHub
  * listing filter so both sources answer the same request the same way.
@@ -257,6 +321,7 @@ async function fetchGpuMetricsFromGithub(
   runId: string,
   prefix: string | null,
   includeBundles: boolean,
+  sources: string[] | null = null,
 ): Promise<GithubGpuMetricsResponse> {
   const githubToken = getGithubToken();
   if (!githubToken) throw new Error('GitHub token not configured');
@@ -270,11 +335,12 @@ async function fetchGpuMetricsFromGithub(
   // `eval_gpu_metrics_*` artifacts are excluded by the bare `gpu_metrics` test.
   const wanted = prefix ? `${ARTIFACT_PREFIX}${prefix}` : 'gpu_metrics';
   const jobs: TelemetryJob[] = artifacts
-    .filter((a) => a.name.startsWith(wanted))
+    .filter((a) => a.name.startsWith(wanted) && isRequestedArtifact(a.name, sources))
     .map((artifact) => ({ kind: 'csv', artifact }));
   if (includeBundles) {
     for (const artifact of artifacts) {
-      if (isWantedBundle(artifact.name, prefix)) jobs.push({ kind: 'bundle', artifact });
+      if (isWantedBundle(artifact.name, prefix) && isRequestedArtifact(artifact.name, sources))
+        jobs.push({ kind: 'bundle', artifact });
     }
   }
   if (jobs.length === 0) {
@@ -288,7 +354,7 @@ async function fetchGpuMetricsFromGithub(
   const results = await downloadTelemetry(jobs, githubToken);
   if (results.length === 0) throw new Error('No Chip metrics data found in artifacts');
 
-  const parsedArtifacts: GpuMetricsArtifactPayload[] = [];
+  const parsedArtifacts: GithubArtifactPayload[] = [];
   const bundleSeries: GpuPowerSeries[] = [];
   for (const result of results) {
     if (result.kind === 'csv') parsedArtifacts.push(result.parsed);
@@ -304,18 +370,69 @@ async function fetchGpuMetricsFromGithub(
 
 async function fetchGpuMetricsFromDatabase(runId: string): Promise<GpuMetricsRouteResponse | null> {
   if (!process.env.DATABASE_READONLY_URL) return null;
+  const payload = await getGpuMetricsForRun(getDb(), Number(runId));
+  return payload ? databasePayloadToResponse(payload) : null;
+}
+
+export function GET(request: NextRequest) {
+  return readGpuMetrics(request, null);
+}
+
+/** Read-only Timeline transport; the body avoids URL limits for a run's point identities. */
+export async function POST(request: NextRequest) {
+  const reader = request.body?.getReader();
+  const chunks: Uint8Array[] = [];
+  let bytes = 0;
   try {
-    const payload = await getGpuMetricsForRun(getDb(), Number(runId));
-    return payload ? databasePayloadToResponse(payload) : null;
-  } catch (error) {
-    // A schema that predates migration 016 or a transient DB error must not
-    // hide the live GitHub artifacts.
-    console.warn(`gpu-metrics: database lookup failed for run ${runId}, using GitHub:`, error);
-    return null;
+    if (reader) {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        bytes += value.byteLength;
+        if (bytes > MAX_REQUEST_BYTES) {
+          await reader.cancel();
+          return NextResponse.json({ error: 'Request body exceeds 256 KiB' }, { status: 413 });
+        }
+        chunks.push(value);
+      }
+    }
+    const body: unknown = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    const sources =
+      body && typeof body === 'object' && !Array.isArray(body) && 'sources' in body
+        ? body.sources
+        : null;
+    if (
+      !Array.isArray(sources) ||
+      sources.length === 0 ||
+      sources.length > 1000 ||
+      !sources.every(
+        (source): source is string => typeof source === 'string' && SOURCE_PATTERN.test(source),
+      )
+    ) {
+      return NextResponse.json(
+        { error: 'sources must contain 1–1000 power_validation_<RESULT_FILENAME>.json basenames' },
+        { status: 400 },
+      );
+    }
+    if (request.nextUrl.searchParams.get('series') !== 'power') {
+      return NextResponse.json({ error: 'POST requires series=power' }, { status: 400 });
+    }
+    const prefix = request.nextUrl.searchParams.get('prefix');
+    if (
+      prefix !== null &&
+      sources.some((source) => !source.startsWith(`power_validation_${prefix}`))
+    ) {
+      return NextResponse.json({ error: 'Every source must match prefix' }, { status: 400 });
+    }
+    return readGpuMetrics(request, [...new Set(sources)].sort());
+  } catch {
+    return NextResponse.json({ error: 'Request body must be valid JSON' }, { status: 400 });
+  } finally {
+    reader?.releaseLock();
   }
 }
 
-export async function GET(request: NextRequest) {
+async function readGpuMetrics(request: NextRequest, sources: string[] | null) {
   const params = request.nextUrl.searchParams;
   const runId = params.get('runId');
 
@@ -334,34 +451,180 @@ export async function GET(request: NextRequest) {
     return NextResponse.json({ error: 'series must be "power" when present' }, { status: 400 });
   }
 
+  let stored: GpuMetricsRouteResponse | null;
   try {
+    stored = await fetchGpuMetricsFromDatabase(runId);
+  } catch (error) {
+    // Missing data may use live artifacts; a failed read cannot establish absence.
+    console.error(`gpu-metrics: database lookup failed for run ${runId}:`, error);
+    return NextResponse.json(
+      {
+        error: 'Stored telemetry is temporarily unavailable. Retry the request.',
+        code: 'DATABASE_UNAVAILABLE',
+      },
+      { status: 503, headers: { 'Cache-Control': 'no-store' } },
+    );
+  }
+
+  const incomplete: StoredTelemetryIncompleteError[] = [];
+  const databaseSeries: GpuPowerSeries[] = [];
+  let githubFallbackStarted = false;
+  try {
+    if (stored) {
+      const artifacts = filterArtifactsByPrefix(stored.artifacts, prefix).filter((artifact) =>
+        isRequestedArtifact(artifact.series?.artifactName ?? artifact.name, sources),
+      );
+      if (series === 'power') {
+        const groups = Map.groupBy(
+          artifacts.flatMap((artifact) =>
+            artifact.series ? [{ ...artifact.series, data: artifact.data }] : [],
+          ),
+          (entry) => entry.artifactName,
+        );
+        for (const entries of groups.values()) {
+          try {
+            databaseSeries.push(
+              ...storedPowerSeries(entries).filter(
+                (entry) => sources === null || sources.includes(seriesSource(entry) ?? ''),
+              ),
+            );
+          } catch (error) {
+            if (!(error instanceof StoredTelemetryIncompleteError)) throw error;
+            incomplete.push(error);
+            console.warn(
+              'gpu-metrics: incomplete stored telemetry, trying artifacts:',
+              error.message,
+            );
+          }
+        }
+        if (
+          incomplete.length === 0 &&
+          databaseSeries.length > 0 &&
+          sourceCoverage(databaseSeries, sources).missingSources.length === 0
+        ) {
+          return NextResponse.json(
+            {
+              source: 'database',
+              runInfo: stored.runInfo,
+              series: databaseSeries,
+              sourceCoverage: sourceCoverage(databaseSeries, sources),
+            },
+            { headers: { 'Cache-Control': 'no-store' } },
+          );
+        }
+      } else if (artifacts.length > 0) {
+        return NextResponse.json(
+          { ...stored, artifacts },
+          { headers: { 'Cache-Control': 'no-store' } },
+        );
+      }
+    }
     if (series === 'power') {
+      githubFallbackStarted = true;
       const { runInfo, artifacts, bundleSeries } = await fetchGpuMetricsFromGithub(
         runId,
         prefix,
         true,
+        sources === null ? null : sourceCoverage(databaseSeries, sources).missingSources,
       );
       const powerSeries = artifacts
-        .map((artifact) => bucketPowerSeries(artifact.name, artifact.data))
+        .map((artifact) => bucketPowerFiles(artifact.name, artifact.files))
         .filter((entry): entry is GpuPowerSeries => entry !== null);
-      return NextResponse.json({ runInfo, series: [...powerSeries, ...bundleSeries] });
-    }
-    const stored = await fetchGpuMetricsFromDatabase(runId);
-    if (stored) {
-      const artifacts = filterArtifactsByPrefix(stored.artifacts, prefix);
-      if (artifacts.length > 0) return NextResponse.json({ ...stored, artifacts });
+      // A fallback response can combine durable history with live recovery.
+      // Keep healthy stored windows even when their GitHub copies expired,
+      // and never replace or duplicate them with a live copy. source='github'
+      // records that this response required fallback, not that every row is live.
+      const databaseSources = new Set(databaseSeries.map(seriesSource));
+      const combined = [
+        ...databaseSeries,
+        ...[...powerSeries, ...bundleSeries].filter(
+          (entry) =>
+            !databaseSources.has(seriesSource(entry)) &&
+            (sources === null || sources.includes(seriesSource(entry) ?? '')),
+        ),
+      ];
+      for (const missing of incomplete) {
+        const incompleteArtifact = missing.artifact;
+        const live = artifacts.find((artifact) => artifact.name === incompleteArtifact);
+        const inventory = stored?.artifacts.find(
+          (artifact) => artifact.series?.artifactName === incompleteArtifact,
+        )?.series?.sidecars.seriesInventory;
+        // A matching name alone cannot prove that missing hosts/samples recovered.
+        // Bundle cuts do not retain the raw inventory, so known-incomplete bundles
+        // require re-ingest; ordinary un-ingested bundle fallback stays available.
+        if (!live || !Array.isArray(inventory) || inventory.length === 0) throw missing;
+        const counts = new Map(
+          live.files.map((file) => [
+            file.name,
+            new Set(
+              file.data.flatMap((row) => {
+                const time = parseTelemetryTimestampUtc(row.timestamp);
+                return time === null || !Number.isInteger(row.index) || !Number.isFinite(row.power)
+                  ? []
+                  : [`${row.index}:${time}`];
+              }),
+            ).size,
+          ]),
+        );
+        if (
+          !inventory.every(
+            (expected) =>
+              expected !== null &&
+              typeof expected === 'object' &&
+              typeof expected.fileName === 'string' &&
+              typeof expected.sampleCount === 'number' &&
+              counts.get(expected.fileName) === expected.sampleCount,
+          )
+        )
+          throw missing;
+      }
+      return NextResponse.json(
+        {
+          source: 'github',
+          runInfo,
+          series: combined,
+          sourceCoverage: sourceCoverage(combined, sources),
+        },
+        { headers: { 'Cache-Control': 'no-store' } },
+      );
     }
     const live = await fetchGpuMetricsFromGithub(runId, prefix, false);
-    return NextResponse.json({
-      source: live.source,
-      runInfo: live.runInfo,
-      artifacts: live.artifacts,
-    });
+    return NextResponse.json(
+      {
+        source: live.source,
+        runInfo: live.runInfo,
+        artifacts: live.artifacts.flatMap(({ name, files }) =>
+          files.map((file) => ({
+            name: files.length > 1 ? `${name}/${file.name}` : name,
+            data: file.data,
+          })),
+        ),
+      },
+      { headers: { 'Cache-Control': 'no-store' } },
+    );
   } catch (error) {
     console.error('Error fetching GPU power data:', error);
+    const missing = error instanceof StoredTelemetryIncompleteError ? error : incomplete[0];
+    if (githubFallbackStarted && !missing && stored && databaseSeries.length > 0) {
+      return NextResponse.json(
+        {
+          source: 'database',
+          runInfo: stored.runInfo,
+          series: databaseSeries,
+          sourceCoverage: sourceCoverage(databaseSeries, sources),
+        },
+        { headers: { 'Cache-Control': 'no-store' } },
+      );
+    }
     return NextResponse.json(
-      { error: error instanceof Error ? error.message : 'Unknown error occurred' },
-      { status: 500 },
+      missing
+        ? {
+            error: missing.message,
+            code: 'STORED_TELEMETRY_INCOMPLETE',
+            artifact: missing.artifact,
+          }
+        : { error: error instanceof Error ? error.message : 'Unknown error occurred' },
+      { status: missing ? 503 : 500, headers: { 'Cache-Control': 'no-store' } },
     );
   }
 }
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.ts b/packages/app/src/components/gpu-power/power-audit-bundle.ts
index 03c01583e..65efac26c 100644
--- a/packages/app/src/components/gpu-power/power-audit-bundle.ts
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.ts
@@ -13,13 +13,16 @@
  * Pure: the route hands over the extracted entry texts; nothing here reads
  * the network or the zip.
  */
+import { parseNvidiaTimestamp } from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
+
 import {
   bucketPowerSeries,
+  parseTelemetryTimestampUtc,
   type GpuPowerDevice,
   type GpuPowerRole,
   type GpuPowerSeries,
 } from './power-series';
-import type { GpuMetricRow } from './types';
+import { parseCsvData, type GpuMetricRow } from './types';
 
 /** Seconds of telemetry kept on each side of a validated window (ramp-up / drain context). */
 export const BUNDLE_WINDOW_PAD_SECONDS = 60;
@@ -34,18 +37,29 @@ export function isPowerAuditBundleEntry(entryName: string): boolean {
   return (
     entryName === BUNDLE_SAMPLES_ENTRY ||
     entryName === BUNDLE_MANIFEST_ENTRY ||
-    VALIDATION_ENTRY.test(entryName)
+    VALIDATION_ENTRY.test(entryName) ||
+    isSmiCsv(entryName) ||
+    isContextEntry(entryName)
   );
 }
 
-interface Sample {
+function isSmiCsv(name: string): boolean {
+  return /(?:^|\/)gpu_metrics[^/]*\.csv$/u.test(name) && !/_(?:identity|energy_)/u.test(name);
+}
+
+function isContextEntry(entryName: string): boolean {
+  const name = basename(entryName);
+  return name.includes('gpu_metrics') && name.toLowerCase().endsWith('_context.json');
+}
+
+export interface PowerAuditSample {
   /** Unix seconds. */
   time: number;
   deviceId: string;
   power: number;
 }
 
-interface Device {
+export interface PowerAuditDevice {
   /** `<hostname>/<GPU-uuid>`, the form `power_audit.observed_gpu_ids` uses. */
   id: string;
   hostname: string;
@@ -53,9 +67,9 @@ interface Device {
 }
 
 interface ParsedSamples {
-  samples: Sample[];
+  samples: PowerAuditSample[];
   /** Devices in first-seen order. */
-  devices: Map<string, Device>;
+  devices: Map<string, PowerAuditDevice>;
 }
 
 const SAMPLE_COLUMNS = ['timestamp_unix', 'hostname', 'gpu_index', 'gpu_uuid', 'power_w'] as const;
@@ -84,8 +98,8 @@ function parseSamples(csv: string): ParsedSamples {
   const [timeCol, hostCol, indexCol, uuidCol, powerCol] = columns;
   const width = Math.max(...columns) + 1;
 
-  const samples: Sample[] = [];
-  const devices = new Map<string, Device>();
+  const samples: PowerAuditSample[] = [];
+  const devices = new Map<string, PowerAuditDevice>();
   for (const line of lines.slice(headerIndex + 1)) {
     const cells = line.split(',');
     if (cells.length < width) continue;
@@ -193,7 +207,10 @@ function compareText(a: string, b: string): number {
 }
 
 /** Prefill, then decode, then unassigned; within a role by hostname, then gpu_index. */
-function orderDevices(devices: readonly GpuPowerDevice[], byId: ReadonlyMap<string, Device>) {
+function orderDevices(
+  devices: readonly GpuPowerDevice[],
+  byId: ReadonlyMap<string, PowerAuditDevice>,
+) {
   return devices.toSorted((a, b) => {
     const rank = roleRank(a.role) - roleRank(b.role);
     if (rank !== 0) return rank;
@@ -207,6 +224,26 @@ function basename(entryName: string): string {
   return entryName.slice(entryName.lastIndexOf('/') + 1);
 }
 
+/** Apply the adjacent collector context only to NVIDIA's unzoned wall-clock timestamps. */
+export function parsePowerCsvData(
+  text: string,
+  context: Record<string, unknown> | null,
+): GpuMetricRow[] {
+  const zone = context?.timestamp_timezone;
+  const offset =
+    typeof zone === 'string'
+      ? /^(?<sign>[+-])(?<h>\d{2}):?(?<m>\d{2})$/u.exec(zone.trim())?.groups
+      : null;
+  const offsetMinutes = offset
+    ? (offset.sign === '-' ? -1 : 1) * (Number(offset.h) * 60 + Number(offset.m))
+    : 0;
+  return parseCsvData(text).map((row) => {
+    if (!offsetMinutes) return row;
+    const timestamp = parseNvidiaTimestamp(row.timestamp, offsetMinutes);
+    return timestamp === null ? row : { ...row, timestamp: new Date(timestamp).toISOString() };
+  });
+}
+
 /**
  * One series per validation file that has a window and samples within
  * `BUNDLE_WINDOW_PAD_SECONDS` of it. Rows follow `devices`, ordered prefill,
@@ -219,17 +256,77 @@ export function cutPowerAuditBundle(
   artifact: string,
   files: ReadonlyMap<string, string>,
 ): GpuPowerSeries[] {
+  const validations = new Map<string, Record<string, unknown>>();
+  for (const [entryName, text] of files) {
+    if (!VALIDATION_ENTRY.test(entryName)) continue;
+    const validation = parseJsonObject(text);
+    if (validation) validations.set(entryName, validation);
+  }
+  const manifest = parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY));
+  const contextFiles = [...files]
+    .filter(([name]) => isContextEntry(name))
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+  const smiFiles = [...files]
+    .filter(([name]) => isSmiCsv(name))
+    .map(([name, text]) => {
+      const directory = name.slice(0, name.lastIndexOf('/') + 1);
+      let context: Record<string, unknown> | null = null;
+      for (const [entry, contents] of contextFiles) {
+        if (entry.slice(0, entry.lastIndexOf('/') + 1) !== directory) continue;
+        context = parseJsonObject(contents);
+        if (context) break;
+      }
+      const data = parsePowerCsvData(text, context);
+      return { name, data };
+    })
+    .filter((file) => file.data.length > 0);
+  // Ingest prefers the richer SMI CSV when the bundle carries both collectors.
+  if (smiFiles.length > 0) return cutPowerAuditCsvs(artifact, smiFiles, validations, manifest);
   const samplesText = files.get(BUNDLE_SAMPLES_ENTRY);
   if (samplesText === undefined) return [];
   const { samples, devices } = parseSamples(samplesText);
   if (samples.length === 0) return [];
-  const fallbackRoles = manifestRoles(parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY)));
+  return cutPowerAuditSamples(
+    artifact,
+    samples,
+    devices,
+    validations,
+    parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY)),
+  );
+}
 
+/** Apply bundle window cuts to the richer SMI CSVs without requiring DCGM UUID sidecars. */
+export function cutPowerAuditCsvs(
+  artifact: string,
+  files: readonly { name: string; data: readonly GpuMetricRow[] }[],
+  validations: ReadonlyMap<string, Record<string, unknown>>,
+  manifest: Record<string, unknown> | null,
+): GpuPowerSeries[] {
+  const populated = files.filter((file) => file.data.length > 0);
+  const devices = new Map<string, PowerAuditDevice>();
+  const samples: PowerAuditSample[] = [];
+  for (const file of populated) {
+    for (const row of file.data) {
+      const id = populated.length === 1 ? String(row.index) : `${file.name}/${row.index}`;
+      devices.set(id, { id, hostname: file.name, gpuIndex: row.index });
+      const time = parseTelemetryTimestampUtc(row.timestamp);
+      if (time !== null) samples.push({ deviceId: id, time: time / 1000, power: row.power });
+    }
+  }
+  return cutPowerAuditSamples(artifact, samples, devices, validations, manifest);
+}
+
+/** The same window/device/bucketing transform for persisted samples and artifact CSVs. */
+export function cutPowerAuditSamples(
+  artifact: string,
+  samples: readonly PowerAuditSample[],
+  devices: ReadonlyMap<string, PowerAuditDevice>,
+  validations: ReadonlyMap<string, Record<string, unknown>>,
+  manifest: Record<string, unknown> | null,
+): GpuPowerSeries[] {
+  const fallbackRoles = manifestRoles(manifest);
   const cut: { start: number; series: GpuPowerSeries }[] = [];
-  for (const [entryName, text] of files) {
-    if (!VALIDATION_ENTRY.test(entryName)) continue;
-    const validation = parseJsonObject(text);
-    if (!validation) continue;
+  for (const [entryName, validation] of validations) {
     const window = validationWindow(validation);
     if (!window) continue;
 
@@ -253,11 +350,6 @@ export function cutPowerAuditBundle(
       timestamp: String(sample.time),
       index: rowOf.get(sample.deviceId)!,
       power: sample.power,
-      temperature: 0,
-      smClock: 0,
-      memClock: 0,
-      gpuUtil: 0,
-      memUtil: 0,
     }));
     const series = bucketPowerSeries(artifact, rows);
     if (!series) continue;
diff --git a/packages/app/src/components/gpu-power/power-series.test.ts b/packages/app/src/components/gpu-power/power-series.test.ts
index e20146c09..cfecc4bdd 100644
--- a/packages/app/src/components/gpu-power/power-series.test.ts
+++ b/packages/app/src/components/gpu-power/power-series.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest';
 
 import {
   bucketPowerSeries,
+  bucketPowerFiles,
   bucketTimeMs,
   meanPowerAt,
   parseTelemetryTimestampUtc,
@@ -70,6 +71,30 @@ describe('bucketPowerSeries', () => {
     expect(bucketTimeMs(series!, 2)).toBe(Date.UTC(2026, 8, 12, 20, 20, 43));
   });
 
+  it('keeps the first sample at each GPU/timestamp before averaging distinct samples', () => {
+    const rows = [
+      row('2026/09/12 04:00:00.100', 0, 300),
+      row('2026/09/12 04:00:00.100', 0, 300), // repeated monitor flush
+      row('2026-09-12T04:00:00.100Z', 0, 999), // same instant, conflicting value
+      row('2026/09/12 04:00:00.100', 1, 100), // different GPU remains independent
+      row('2026/09/12 04:00:00.800', 0, 500),
+      row('2026/09/12 04:00:01.100', 0, 700),
+    ];
+    expect(bucketPowerSeries('gpu_metrics_duplicate', rows)).toMatchObject({
+      gpus: [0, 1],
+      t: [0, 1],
+      power: [
+        [400, 700],
+        [100, null],
+      ],
+    });
+    expect(bucketPowerSeries('gpu_metrics_duplicate', rows, 2)).toMatchObject({
+      bucketSeconds: 2,
+      t: [0],
+      power: [[500], [100]],
+    });
+  });
+
   it('omits empty buckets so long gaps do not pad the payload', () => {
     const series = bucketPowerSeries('gpu_metrics_gap', [
       row('2026/09/12 20:00:00.000', 0, 100),
@@ -117,3 +142,31 @@ describe('sumPowerAt', () => {
     expect(sumPowerAt(series, [7], 0)).toBeNull();
   });
 });
+
+describe('bucketPowerFiles', () => {
+  it('keeps repeated GPU indices from different host files separate with stable identity', () => {
+    const time = '2026-09-12T04:00:00Z';
+    const files = [
+      { name: 'host-b/gpu_metrics.csv', data: [row(time, 0, 500)] },
+      { name: 'host-a/gpu_metrics.csv', data: [row(time, 0, 100), row(time, 2, 200)] },
+      { name: 'empty.csv', data: [] },
+    ];
+    const expected = {
+      artifact: 'gpu_metrics_multinode',
+      startMs: Date.parse(time),
+      bucketSeconds: 1,
+      gpus: [0, 1, 2],
+      t: [0],
+      power: [[100], [200], [500]],
+      devices: [
+        { id: 'host-a/gpu_metrics.csv/0' },
+        { id: 'host-a/gpu_metrics.csv/2' },
+        { id: 'host-b/gpu_metrics.csv/0' },
+      ],
+    };
+    expect(bucketPowerFiles('gpu_metrics_multinode', files)).toEqual(expected);
+    expect(bucketPowerFiles('gpu_metrics_multinode', files.toReversed())).toEqual(expected);
+    expect(bucketPowerFiles('empty', [])).toBeNull();
+    expect(bucketPowerFiles('single', [files[0]])?.gpus).toEqual([0]);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/power-series.ts b/packages/app/src/components/gpu-power/power-series.ts
index a05b0376d..8ff75fabb 100644
--- a/packages/app/src/components/gpu-power/power-series.ts
+++ b/packages/app/src/components/gpu-power/power-series.ts
@@ -53,6 +53,11 @@ export interface GpuPowerSeries {
 export interface GpuPowerSeriesResponse {
   runInfo: GpuPowerRunInfo;
   series: GpuPowerSeries[];
+  /** Coverage of requested validation identities only, never the full run/sweep. */
+  sourceCoverage?: {
+    status: 'complete' | 'incomplete' | 'unknown';
+    missingSources: string[];
+  };
 }
 
 const RUNNER_TIMESTAMP =
@@ -84,7 +89,8 @@ export function parseTelemetryTimestampUtc(raw: string): number | null {
 
 /**
  * Buckets raw per-GPU rows into the compact series. Samples of one GPU that
- * share a bucket are averaged; buckets nobody sampled are omitted from `t`.
+ * share a bucket are averaged; repeated GPU/timestamps keep the first sample,
+ * matching ingest. Buckets nobody sampled are omitted from `t`.
  * Returns `null` when no row carries a parseable timestamp.
  */
 export function bucketPowerSeries(
@@ -96,10 +102,14 @@ export function bucketPowerSeries(
   const bucketMs = bucketSeconds * 1000;
   let startMs = Number.POSITIVE_INFINITY;
   const parsed: { ms: number; gpu: number; power: number }[] = [];
+  const seen = new Set<string>();
   for (const row of rows) {
     if (!Number.isFinite(row.power) || !Number.isInteger(row.index)) continue;
     const ms = parseTelemetryTimestampUtc(row.timestamp);
     if (ms === null) continue;
+    const key = `${row.index}:${ms}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
     parsed.push({ ms, gpu: row.index, power: row.power });
     if (ms < startMs) startMs = ms;
   }
@@ -141,6 +151,28 @@ export function bucketPowerSeries(
   };
 }
 
+/** Keep host-local GPU indices distinct when one artifact stages multiple CSVs. */
+export function bucketPowerFiles(
+  artifact: string,
+  files: readonly { name: string; data: readonly GpuMetricRow[] }[],
+): GpuPowerSeries | null {
+  const populated = files
+    .filter((file) => file.data.length > 0)
+    .toSorted((a, b) => a.name.localeCompare(b.name));
+  if (populated.length === 0) return null;
+  if (populated.length === 1) return bucketPowerSeries(artifact, populated[0].data);
+  const devices = populated.flatMap((file) =>
+    [...new Set(file.data.map((row) => row.index))]
+      .toSorted((a, b) => a - b)
+      .map((gpu) => ({ id: `${file.name}/${gpu}`, file, gpu })),
+  );
+  const rows = devices.flatMap(({ file, gpu }, index) =>
+    file.data.filter((row) => row.index === gpu).map((row) => ({ ...row, index })),
+  );
+  const bucketed = bucketPowerSeries(artifact, rows);
+  return bucketed ? { ...bucketed, devices: devices.map(({ id }) => ({ id })) } : null;
+}
+
 /** Mean watts across the GPUs that have a sample in bucket `column`, or `null`. */
 export function meanPowerAt(series: GpuPowerSeries, column: number): number | null {
   let sum = 0;
diff --git a/packages/app/src/components/gpu-power/stored-power-series.ts b/packages/app/src/components/gpu-power/stored-power-series.ts
new file mode 100644
index 000000000..964d44812
--- /dev/null
+++ b/packages/app/src/components/gpu-power/stored-power-series.ts
@@ -0,0 +1,168 @@
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import {
+  cutPowerAuditSamples,
+  cutPowerAuditCsvs,
+  type PowerAuditDevice,
+  type PowerAuditSample,
+} from './power-audit-bundle';
+import { bucketPowerFiles, type GpuPowerSeries } from './power-series';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export class StoredTelemetryIncompleteError extends Error {
+  readonly artifact: string;
+
+  constructor(artifact: string, reason: string) {
+    super(`${artifact}: ${reason}. Re-ingest this artifact for the same run and attempt.`);
+    this.name = 'StoredTelemetryIncompleteError';
+    this.artifact = artifact;
+  }
+}
+
+/** Compare storage against the original parsed artifact, not only surviving host rows. */
+function checkSeriesInventory(artifact: string, series: readonly GpuMetricSeries[]): void {
+  for (const entry of series) {
+    const inventory = entry.sidecars.seriesInventory;
+    if (!Array.isArray(inventory)) continue;
+    for (const expected of inventory) {
+      if (
+        !isRecord(expected) ||
+        typeof expected.fileName !== 'string' ||
+        typeof expected.sampleCount !== 'number'
+      )
+        continue;
+      const actual = series.find((candidate) => candidate.fileName === expected.fileName);
+      if (!actual || actual.data.length !== expected.sampleCount) {
+        throw new StoredTelemetryIncompleteError(
+          artifact,
+          `stored file/sample coverage is incomplete for ${expected.fileName}`,
+        );
+      }
+    }
+  }
+}
+
+/** Reconstruct only source/window evidence retained by the pre-validation ingest. */
+function storedValidations(series: readonly GpuMetricSeries[]) {
+  const validations = new Map<string, Record<string, unknown>>();
+  for (const entry of series) {
+    if (!isRecord(entry.sidecars.validations)) continue;
+    for (const [name, validation] of Object.entries(entry.sidecars.validations)) {
+      if (/^power_validation_[^/]+\.json$/u.test(name) && isRecord(validation)) {
+        validations.set(name, validation);
+      }
+    }
+  }
+  // New ingests carry the complete original documents, including role overrides.
+  // The legacy path has source + the selected serving window and manifest roles.
+  if (validations.size > 0) return validations;
+  for (const entry of series) {
+    for (const audit of entry.powerAudits ?? []) {
+      const { source, window_start_unix: start, window_end_unix: end } = audit;
+      if (
+        typeof source !== 'string' ||
+        typeof start !== 'number' ||
+        typeof end !== 'number' ||
+        !Number.isFinite(start) ||
+        !Number.isFinite(end) ||
+        end < start
+      )
+        continue;
+      const name = source.slice(source.lastIndexOf('/') + 1);
+      if (!/^power_validation_[^/]+\.json$/u.test(name)) continue;
+      validations.set(name, { selected_window: { start_time_unix: start, end_time_unix: end } });
+    }
+  }
+  return validations;
+}
+
+function storedBundle(artifact: string, series: readonly GpuMetricSeries[]): GpuPowerSeries[] {
+  const validations = storedValidations(series);
+  if (validations.size === 0)
+    throw new StoredTelemetryIncompleteError(artifact, 'validation window provenance is missing');
+  const smiFiles = series.filter((entry) => /(?:^|\/)gpu_metrics[^/]*\.csv$/u.test(entry.fileName));
+  if (smiFiles.length > 0) {
+    const manifest = smiFiles.find((entry) => isRecord(entry.sidecars.powerManifest))?.sidecars
+      .powerManifest;
+    return cutPowerAuditCsvs(
+      artifact,
+      smiFiles.map((entry) => ({ name: entry.fileName, data: entry.data })),
+      validations,
+      isRecord(manifest) ? manifest : null,
+    );
+  }
+  const devices = new Map<string, PowerAuditDevice>();
+  const samples: PowerAuditSample[] = [];
+  for (const entry of series) {
+    const identity = entry.sidecars.identity;
+    if (!Array.isArray(identity)) continue;
+    const ids = new Map<number, string>();
+    for (const item of identity) {
+      if (!isRecord(item)) continue;
+      const { hostname, gpu_index: gpuIndex, gpu_uuid: uuid } = item;
+      if (typeof hostname !== 'string' || typeof gpuIndex !== 'number' || typeof uuid !== 'string')
+        continue;
+      const id = `${hostname}/${uuid}`;
+      ids.set(gpuIndex, id);
+      devices.set(id, { id, hostname, gpuIndex });
+    }
+    for (const row of entry.data) {
+      const deviceId = ids.get(row.index);
+      if (!deviceId)
+        throw new StoredTelemetryIncompleteError(
+          artifact,
+          `device identity is missing for ${entry.fileName} GPU ${row.index}`,
+        );
+      samples.push({ deviceId, time: Date.parse(row.timestamp) / 1000, power: row.power });
+    }
+  }
+  const manifest = series.find((entry) => isRecord(entry.sidecars.context))?.sidecars.context;
+  const expectedDevices = isRecord(manifest) ? manifest.expected_devices : null;
+  if (Array.isArray(expectedDevices)) {
+    const slots = new Set(
+      [...devices.values()].map((device) => `${device.hostname}#${device.gpuIndex}`),
+    );
+    for (const expected of expectedDevices) {
+      if (
+        isRecord(expected) &&
+        typeof expected.hostname === 'string' &&
+        typeof expected.gpu_index === 'number' &&
+        !slots.has(`${expected.hostname}#${expected.gpu_index}`)
+      ) {
+        throw new StoredTelemetryIncompleteError(
+          artifact,
+          `expected device ${expected.hostname} GPU ${expected.gpu_index} is not stored`,
+        );
+      }
+    }
+  }
+  return cutPowerAuditSamples(
+    artifact,
+    samples,
+    devices,
+    validations,
+    isRecord(manifest) ? manifest : null,
+  );
+}
+
+/** Apply the artifact path's existing cuts and one-second means to persisted rows. */
+export function storedPowerSeries(series: readonly GpuMetricSeries[]): GpuPowerSeries[] {
+  const groups = new Map<string, GpuMetricSeries[]>();
+  for (const entry of series) {
+    const group = groups.get(entry.artifactName) ?? [];
+    group.push(entry);
+    groups.set(entry.artifactName, group);
+  }
+  return [...groups].flatMap(([artifact, entries]) => {
+    checkSeriesInventory(artifact, entries);
+    if (artifact.startsWith('power_audit_')) return storedBundle(artifact, entries);
+    const bucketed = bucketPowerFiles(
+      artifact,
+      entries.map((entry) => ({ name: entry.fileName, data: entry.data })),
+    );
+    return bucketed ? [bucketed] : [];
+  });
+}
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index c3f04f156..001c4c346 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -320,6 +320,9 @@ async function fetchPowerSeries(
   const params = new URLSearchParams({ runId: request.runId, series: 'power' });
   if (request.prefix) params.set('prefix', request.prefix);
   const response = await fetch(`/api/gpu-metrics?${params.toString()}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ sources: request.sources }),
     cache: 'no-store',
     signal,
   });
@@ -761,7 +764,7 @@ export default function PowerTimeline({
   const droppedRuns = requests.length - fetchedRequests.length;
   const queries = useQueries({
     queries: fetchedRequests.map((request) => ({
-      queryKey: ['power-timeline', request.runId, request.prefix] as const,
+      queryKey: ['power-timeline', request.runId, request.prefix, request.sources] as const,
       queryFn: ({ signal }: { signal: AbortSignal }) => fetchPowerSeries(request, signal),
       staleTime: 5 * 60_000,
       retry: 1,
diff --git a/packages/app/src/components/inference/utils/powerTimeline.test.ts b/packages/app/src/components/inference/utils/powerTimeline.test.ts
index d0b37bd9f..def7e63cc 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.test.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.test.ts
@@ -79,6 +79,7 @@ describe('planPowerTimelineRequests', () => {
     const points = [
       point({ power_audit: { source: `power_validation_${NAME_A}.json` } }),
       point({ conc: 1, power_audit: { source: `power_validation_${NAME_B}.json` } }),
+      point({ power_audit: { source: `nested/power_validation_${NAME_A}.json` } }),
       point({
         run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/1',
         power_audit: { source: 'power_validation_dsr1_1k1k_fp8_sglang_conc8_h200-x.json' },
@@ -92,10 +93,12 @@ describe('planPowerTimelineRequests', () => {
       {
         runId: '1',
         prefix: 'dsr1_1k1k_fp8_sglang_conc8_h200-x',
+        sources: ['power_validation_dsr1_1k1k_fp8_sglang_conc8_h200-x.json'],
       },
       {
         runId: '34716669498',
         prefix: 'qwen3.5_8k1k_fp8_',
+        sources: [`power_validation_${NAME_A}.json`, `power_validation_${NAME_B}.json`].sort(),
       },
     ]);
   });
@@ -312,6 +315,7 @@ describe('prioritizeRuns', () => {
   const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
     runId,
     prefix: '',
+    sources: [],
   }));
 
   it('moves overlay runs ahead of official runs and keeps both orders', () => {
@@ -341,6 +345,7 @@ describe('prioritizeRun', () => {
   const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
     runId,
     prefix: '',
+    sources: [],
   }));
 
   it('moves the deep-linked run to the front and keeps the rest in order', () => {
diff --git a/packages/app/src/components/inference/utils/powerTimeline.ts b/packages/app/src/components/inference/utils/powerTimeline.ts
index 43e6cb6d4..cff71ac26 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.ts
@@ -72,6 +72,8 @@ export interface PowerTimelineRequest {
   runId: string;
   /** RESULT_FILENAME prefix shared by every wanted artifact of the run. */
   prefix: string;
+  /** Sorted, unique validation basenames expected by the displayed points. */
+  sources: string[];
 }
 
 /**
@@ -97,6 +99,7 @@ export function planPowerTimelineRequests(
       return {
         runId,
         prefix: longestCommonPrefix(names.map((name) => name.slice(ARTIFACT_PREFIX.length))),
+        sources: names.map((name) => `power_validation_${name.slice(ARTIFACT_PREFIX.length)}.json`),
       };
     });
 }
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 6c1435c26..cb4070654 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -236,10 +236,21 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'ui-artifact-read',
     exclusionReason: {
-      en: 'UI-only PowerX read for one run: the ingest-time telemetry digest when stored, otherwise the live GPU telemetry artifacts (raw `gpu_metrics_*` rows, or `series=power` one-second buckets for the PowerX timeline, also cut per validation window from `power_audit_*` bundles). Its payload shape is not a stable public contract.',
-      zh: '仅供 PowerX 界面按 run 读取：已入库时返回 ingest 阶段生成的 telemetry 摘要，否则回退到实时 GPU 遥测制品（`gpu_metrics_*` 原始行，或供 PowerX 时间线使用的 `series=power` 一秒分桶数据，后者也会按验证窗口从 `power_audit_*` bundle 中切分得到）。其返回结构不是稳定的公开契约。',
+      en: 'UI-only PowerX raw/series=power read: DB-first with artifact fallback, separate host/GPU identities and adjacent CSV context timezone normalization. GET has no expected identities and reports sourceCoverage unknown. Healthy stored windows survive fallback; known-incomplete CSVs require retained file/sample inventory and known-incomplete bundles require re-ingest. DB failures return 503 DATABASE_UNAVAILABLE; unresolved stored gaps return 503 STORED_TELEMETRY_INCOMPLETE. Responses use no-store. This is not a stable public API.',
+      zh: '仅供 PowerX 界面读取原始遥测或 series=power：优先 DB，缺失时回退产物，保留主机/GPU 身份，并按相邻 CSV context 规范化时区。GET 没有预期身份清单，sourceCoverage 为 unknown。回退保留健康存储窗口；已知不完整 CSV 须满足文件/样本清单，已知不完整 bundle 须重新 ingest。数据库故障返回 503 DATABASE_UNAVAILABLE，未恢复的存储缺口返回 503 STORED_TELEMETRY_INCOMPLETE。响应使用 no-store，不作为稳定公开 API。',
     },
-    sourceSha256: '8b15b82fac99c6c0e586fce5312de5a224de454b9d39d15cb0b2c20a2c6d8246',
+    sourceSha256: '12a04eb419e8339c1e2f7d9b8f4b295c0abd899f1606e919df21ebf8a2acde6e',
+  },
+  {
+    source: 'src/app/api/gpu-metrics/route.ts',
+    path: '/api/gpu-metrics',
+    method: 'POST',
+    classification: 'ui-artifact-read',
+    exclusionReason: {
+      en: 'Read-only Timeline transport with runId, series=power and optional prefix in the query; JSON sources contains 1–1000 validation basenames with RESULT_FILENAME up to 200 ASCII letters/digits/dot/underscore/hyphen, matching prefix. Invalid input returns 400; bodies over 256 KiB return 413. Fully covered DB reads skip GitHub; missing identities fall back and merge by validation source, preserving stored sibling windows. Offline GitHub preserves healthy DB series with incomplete sourceCoverage. Coverage describes only requested identities, never whole-run/sample completeness. The GET no-store/error/inventory guarantees also apply. UI-owned, excluded from the stable public API.',
+      zh: 'Timeline 只读传输：查询参数为 runId、series=power 和可选 prefix；JSON sources 含 1–1000 个验证文件 basename，RESULT_FILENAME 最长 200 个 ASCII 字母/数字/点/下划线/连字符，且须匹配 prefix。输入错误返回 400，正文超过 256 KiB 返回 413。DB 已覆盖请求时跳过 GitHub，否则按缺失身份回退，以 validation source 为键合并，并保留已存储的同 bundle 兄弟窗口。GitHub 离线仍返回健康 DB 序列，sourceCoverage 标记 incomplete。覆盖仅针对请求身份，不代表整次 run 或样本完整性。沿用 GET 的 no-store、错误和清单约束；属于界面接口，不纳入稳定公开 API。',
+    },
+    sourceSha256: '12a04eb419e8339c1e2f7d9b8f4b295c0abd899f1606e919df21ebf8a2acde6e',
   },
   {
     source: 'src/app/api/openapi.json/route.ts',
@@ -793,6 +804,14 @@ export interface ApiContractSourceDigest {
  * touching a route module. Digest changes require an explicit documentation review.
  */
 export const apiContractSourceDigests = [
+  {
+    source: 'src/components/gpu-power/power-audit-bundle.ts',
+    sourceSha256: 'c288ae25d4702c31a6bef5e5601e5b0b8c4abe89cd978a7eef2a4dc0247a344a',
+    reviewArea: {
+      en: 'Deterministic adjacent context selection and timezone normalization shared by artifact Timeline and run views, plus validation-window and device identity semantics.',
+      zh: '产物 Timeline 和 run 视图共用的确定性相邻 context 选择与时区规范化，以及验证窗口和设备身份语义。',
+    },
+  },
   {
     source: 'src/components/gpu-power/stored-gpu-stats.ts',
     sourceSha256: '90adde200c37694c2e37e427458a8c6a9bdb70873033699e343e8c94a291544a',
diff --git a/packages/app/src/lib/github-artifacts.test.ts b/packages/app/src/lib/github-artifacts.test.ts
index 450623b48..948a18462 100644
--- a/packages/app/src/lib/github-artifacts.test.ts
+++ b/packages/app/src/lib/github-artifacts.test.ts
@@ -124,6 +124,7 @@ describe('extractZipEntries', () => {
   it('skips non-matching files and continues after parse errors', () => {
     const zip = new AdmZip();
     zip.addFile('good.json', Buffer.from('{"id":1}', 'utf8'));
+    zip.addFile('upper.JSON', Buffer.from('{"id":2}', 'utf8'));
     zip.addFile('bad.json', Buffer.from('not json', 'utf8'));
     zip.addFile('notes.txt', Buffer.from('ignore me', 'utf8'));
 
@@ -137,7 +138,10 @@ describe('extractZipEntries', () => {
       },
     );
 
-    expect(rows).toEqual([{ entryName: 'good.json', payload: { id: 1 } }]);
+    expect(rows).toEqual([
+      { entryName: 'good.json', payload: { id: 1 } },
+      { entryName: 'upper.JSON', payload: { id: 2 } },
+    ]);
     expect(parseErrors).toEqual(['bad.json']);
   });
 });
diff --git a/packages/app/src/lib/github-artifacts.ts b/packages/app/src/lib/github-artifacts.ts
index 97d6ac01d..d29162741 100644
--- a/packages/app/src/lib/github-artifacts.ts
+++ b/packages/app/src/lib/github-artifacts.ts
@@ -149,7 +149,7 @@ export function extractZipEntries<T>(
   const rows: T[] = [];
 
   for (const entry of zip.getEntries()) {
-    if (!entry.entryName.endsWith(extension)) {
+    if (!entry.entryName.toLowerCase().endsWith(extension.toLowerCase())) {
       continue;
     }
 
diff --git a/packages/app/src/lib/views-api/docs/extensions.ts b/packages/app/src/lib/views-api/docs/extensions.ts
index 1f1d17fda..40b9fd9df 100644
--- a/packages/app/src/lib/views-api/docs/extensions.ts
+++ b/packages/app/src/lib/views-api/docs/extensions.ts
@@ -432,14 +432,14 @@ export const operations: ApiOperation[] = Object.entries(NEW_VIEWS).map(
           view === 'video'
             ? ' Only already published artifacts are read. Cell, phase, slot and GPU-basis choices select result evidence and normalized serving rates; x/y/cost/workload filters produce computed tradeoff points. Local bundles and arbitrary URLs are excluded. Responses are no-store.'
             : view === 'gpu-metrics'
-              ? ' Telemetry responses use private, no-store. Full-record statistics include startup and warmup and use the stored per-GPU digest when present; an empty or missing metric digest stays empty. Only live artifacts compute statistics from samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings.'
+              ? ' Telemetry reads stored DB series first and falls back to GitHub artifacts when storage is absent. Responses use private, no-store; an upstream database failure remains HTTP 503 rather than an empty dataset. File/host series retain separate identities. Full-record statistics include startup and warmup and use the stored per-GPU digest when present; an empty or missing metric digest stays empty. Only live artifacts compute statistics from samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings.'
               : ''
         }`,
         `只读${zh}，使用仪表板的数据读取和计算函数。未知或重复查询键返回 400；响应包含解析后的参数，保留缺失数据。仅影响样式的控件不作为 API 参数。${
           view === 'video'
             ? ' 仅读取已发布产物。cell、阶段、slot 和 GPU 口径选择对应结果证据，并计算 serving 归一化速率；x/y、成本及工作负载筛选生成权衡图数据点。不读取本地数据包或任意 URL。响应不缓存。'
             : view === 'gpu-metrics'
-              ? ' 遥测响应使用 private, no-store。全记录统计包含服务启动与 warmup，已有数据使用数据库中的每 GPU 统计摘要；摘要为空或缺少所选指标时仍返回空统计数组。仅实时产物按样本计算统计。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。'
+              ? ' 遥测优先读取数据库中已存储的序列；缺少存储数据时回退到 GitHub 产物。响应使用 private, no-store；上游数据库故障保留 HTTP 503，不作为空数据返回。各文件、主机的序列身份独立保留。全记录统计包含服务启动与 warmup，已有数据使用数据库中的每 GPU 统计摘要；摘要为空或缺少所选指标时仍返回空统计数组。仅实时产物按样本计算统计。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。'
               : ''
         }`,
       ),
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.test.ts b/packages/db/src/etl/gpu-metrics-artifacts.test.ts
index 877865568..02c1e9ea0 100644
--- a/packages/db/src/etl/gpu-metrics-artifacts.test.ts
+++ b/packages/db/src/etl/gpu-metrics-artifacts.test.ts
@@ -12,6 +12,7 @@ import {
   listMultinodePowerSampleFiles,
   parseEnergyCsv,
   readGpuMetricsSidecars,
+  readPowerAuditValidations,
 } from './gpu-metrics-artifacts.js';
 
 const roots: string[] = [];
@@ -96,6 +97,29 @@ describe('gpu_metrics artifact discovery', () => {
 });
 
 describe('sidecars', () => {
+  it.each([
+    ['z_gpu_metrics_context.json', 'a_gpu_metrics_context.json', '-07:00'],
+    ['a_gpu_metrics_context.json', 'Z_gpu_metrics_context.json', '+02:00'],
+  ])(
+    'chooses the first valid context in code-unit filename order (%s, %s)',
+    (first, second, expected) => {
+      const root = tempRoot();
+      const csv = path.join(root, 'gpu_metrics.csv');
+      fs.writeFileSync(csv, 'timestamp\n');
+      for (const name of [first, second]) {
+        fs.writeFileSync(
+          path.join(root, name),
+          JSON.stringify({
+            timestamp_timezone: name.startsWith('a_') ? '-07:00' : '+02:00',
+          }),
+        );
+      }
+      fs.writeFileSync(path.join(root, '0_gpu_metrics_context.json'), '{bad json');
+      fs.writeFileSync(path.join(root, '1_gpu_metrics_context.json'), '[]');
+      expect(readGpuMetricsSidecars(csv).context).toEqual({ timestamp_timezone: expected });
+    },
+  );
+
   it('reads context, identity CSV, and energy counters next to the CSV', () => {
     const root = tempRoot();
     const csv = path.join(root, 'gpu_metrics.csv');
@@ -131,3 +155,23 @@ describe('sidecars', () => {
     expect(contextUtcOffsetMinutes(null)).toBe(0);
   });
 });
+
+describe('readPowerAuditValidations', () => {
+  it('retains only valid top-level validation documents and tolerates missing inputs', () => {
+    const root = tempRoot();
+    const validation = {
+      selected_window: { start_time_unix: 10, end_time_unix: 20 },
+      per_gpu_role: { 'host-a/GPU-a': 'prefill' },
+    };
+    fs.writeFileSync(path.join(root, 'power_validation_point.json'), JSON.stringify(validation));
+    fs.writeFileSync(path.join(root, 'power_validation_malformed.json'), '{');
+    fs.writeFileSync(path.join(root, 'power_validation_array.json'), '[]');
+    fs.writeFileSync(path.join(root, 'power_validation_null.json'), 'null');
+    fs.writeFileSync(path.join(root, 'unrelated.json'), '{}');
+    fs.mkdirSync(path.join(root, 'LOGS'));
+    fs.writeFileSync(path.join(root, 'LOGS', 'power_validation_copy.json'), '{}');
+    expect(readPowerAuditValidations(root)).toEqual({ 'power_validation_point.json': validation });
+    expect(readPowerAuditValidations(path.join(root, 'missing'))).toEqual({});
+    expect(readPowerAuditValidations(path.join(root, 'unrelated.json'))).toEqual({});
+  });
+});
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.ts b/packages/db/src/etl/gpu-metrics-artifacts.ts
index 07258b3eb..4bd4e2959 100644
--- a/packages/db/src/etl/gpu-metrics-artifacts.ts
+++ b/packages/db/src/etl/gpu-metrics-artifacts.ts
@@ -41,6 +41,12 @@ export interface GpuMetricsCsvFile {
 
 export interface GpuMetricsSidecars {
   context: Record<string, unknown> | null;
+  /** Original per-window audit documents, keyed by their source filename. */
+  validations?: Record<string, Record<string, unknown>>;
+  /** Expected stored files and deduplicated row counts from this one artifact. */
+  seriesInventory?: { fileName: string; sampleCount: number }[];
+  /** Bundle manifest when the preferred CSV has its own collector context. */
+  powerManifest?: Record<string, unknown> | null;
   identity: unknown | null;
   energyStart: Record<string, number> | null;
   energyEnd: Record<string, number> | null;
@@ -112,6 +118,20 @@ export function readMultinodePowerManifest(samplesPath: string): Record<string,
     : null;
 }
 
+/** Preserve window boundaries and role overrides before GitHub artifact expiry. */
+export function readPowerAuditValidations(root: string): Record<string, Record<string, unknown>> {
+  const validations: Record<string, Record<string, unknown>> = {};
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return validations;
+  for (const name of fs.readdirSync(root).sort()) {
+    if (!/^power_validation_[^/]+\.json$/u.test(name)) continue;
+    const parsed = readJsonIfPresent(path.join(root, name));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      validations[name] = parsed as Record<string, unknown>;
+    }
+  }
+  return validations;
+}
+
 function readJsonIfPresent(pathname: string): unknown | null {
   if (!fs.existsSync(pathname)) return null;
   try {
@@ -163,8 +183,14 @@ function readIdentity(csvDir: string): unknown | null {
 export function readGpuMetricsSidecars(csvPath: string): GpuMetricsSidecars {
   const dir = path.dirname(csvPath);
   let context: Record<string, unknown> | null = null;
-  for (const entry of fs.readdirSync(dir)) {
-    if (!entry.toLowerCase().endsWith('_context.json') || !entry.includes('gpu_metrics')) continue;
+  // Match live ZIP reads even when filesystem/central-directory orders differ.
+  const contextFiles = fs
+    .readdirSync(dir)
+    .filter(
+      (entry) => entry.toLowerCase().endsWith('_context.json') && entry.includes('gpu_metrics'),
+    )
+    .sort();
+  for (const entry of contextFiles) {
     const parsed = readJsonIfPresent(path.join(dir, entry));
     if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
       context = parsed as Record<string, unknown>;
diff --git a/packages/db/src/etl/gpu-metrics-ingest.test.ts b/packages/db/src/etl/gpu-metrics-ingest.test.ts
index 0f2045124..43298799b 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.test.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.test.ts
@@ -168,6 +168,39 @@ describe('prepareGpuMetricsArtifact', () => {
 });
 
 describe('ingestGpuMetricsArtifact', () => {
+  it.each(['unrecognized telemetry header\nno samples', NVIDIA_CSV.split('\n')[0]!])(
+    'refuses a partial artifact when a discovered host CSV cannot be ingested: %s',
+    async (brokenCsv) => {
+      const artifact = writeArtifact(NVIDIA_CSV);
+      const missingHostFile = path.join(artifact.artifactDir, 'host-b', 'gpu_metrics.csv');
+      fs.mkdirSync(path.dirname(missingHostFile));
+      fs.writeFileSync(missingHostFile, brokenCsv);
+      await expect(
+        ingestGpuMetricsArtifact(sql, {
+          workflowRunId: 1,
+          artifact,
+          benchmarkResultIds: [10],
+        }),
+      ).rejects.toThrow('host-b/gpu_metrics.csv');
+      const before = await sql`select count(*)::int as n from gpu_metric_series`;
+      expect(before).toEqual([{ n: 0 }]);
+      fs.writeFileSync(missingHostFile, NVIDIA_CSV);
+      const recovered = await ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact,
+        benchmarkResultIds: [10],
+      });
+      expect(recovered.seriesIds).toHaveLength(2);
+      expect(recovered.samplesInserted).toBe(8);
+      const replay = await ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact,
+        benchmarkResultIds: [10],
+      });
+      expect(replay.samplesInserted).toBe(0);
+    },
+  );
+
   it('stores series, samples, digest, and point links; reruns are no-ops', async () => {
     const artifact = writeArtifact(NVIDIA_CSV);
     const first = await ingestGpuMetricsArtifact(sql, {
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
index c1b649086..dc9b05b87 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -32,6 +32,7 @@ import {
   listMultinodePowerSampleFiles,
   readGpuMetricsSidecars,
   readMultinodePowerManifest,
+  readPowerAuditValidations,
   type GpuMetricsArtifact,
   type GpuMetricsSidecars,
 } from './gpu-metrics-artifacts.js';
@@ -78,6 +79,7 @@ export interface GpuMetricsIngestResult {
  */
 function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
   const prepared: PreparedGpuMetricSeries[] = [];
+  const validations = readPowerAuditValidations(artifact.artifactDir);
   for (const file of listMultinodePowerSampleFiles(artifact.artifactDir)) {
     const csvText = fs.readFileSync(file.path, 'utf8');
     const hosts = parseMultinodePowerSamples(csvText);
@@ -101,6 +103,7 @@ function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuM
         endedAtMs: summary.endedAtMs,
         sidecars: {
           context: manifest,
+          validations,
           identity: Object.entries(host.gpuUuids).map(([index, uuid]) => ({
             hostname: host.hostname,
             gpu_index: Number(index),
@@ -116,21 +119,33 @@ function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuM
 }
 
 /**
- * Parse every CSV in an extracted artifact; unparseable files are skipped.
- * Without any nvidia-smi/amd-smi CSV, fall back to the multinode power bundle.
+ * Parse every CSV in an extracted artifact; refuse a partly readable CSV set.
+ * Without usable nvidia-smi/amd-smi CSVs, fall back to the multinode power bundle.
  */
 export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
   const prepared: PreparedGpuMetricSeries[] = [];
+  const unreadable: string[] = [];
   for (const file of listGpuMetricsCsvFiles(artifact.artifactDir)) {
     const csvText = fs.readFileSync(file.path, 'utf8');
     const sidecars = readGpuMetricsSidecars(file.path);
+    if (artifact.artifactName.startsWith('power_audit_')) {
+      sidecars.validations = readPowerAuditValidations(artifact.artifactDir);
+      const bundleFile = listMultinodePowerSampleFiles(artifact.artifactDir)[0];
+      sidecars.powerManifest = bundleFile ? readMultinodePowerManifest(bundleFile.path) : null;
+    }
     const parsed = parseGpuMetricsCsv(csvText, {
       nvidiaUtcOffsetMinutes: contextUtcOffsetMinutes(sidecars.context),
     });
-    if (!parsed) continue;
+    if (!parsed) {
+      unreadable.push(file.fileName);
+      continue;
+    }
     const samples = uniqueSamples(parsed.samples);
     const summary = summarizeGpuMetricSamples(samples);
-    if (!summary) continue;
+    if (!summary) {
+      unreadable.push(file.fileName);
+      continue;
+    }
     prepared.push({
       fileName: file.fileName,
       vendor: parsed.vendor,
@@ -144,7 +159,18 @@ export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): Prepare
       sidecars,
     });
   }
-  return prepared.length > 0 ? prepared : prepareMultinodePowerSeries(artifact);
+  if (prepared.length > 0 && unreadable.length > 0) {
+    throw new Error(
+      `Incomplete telemetry artifact ${artifact.artifactName}: unreadable CSVs ${unreadable.join(', ')}`,
+    );
+  }
+  const series = prepared.length > 0 ? prepared : prepareMultinodePowerSeries(artifact);
+  const seriesInventory = series.map((entry) => ({
+    fileName: entry.fileName,
+    sampleCount: entry.samples.length,
+  }));
+  for (const entry of series) entry.sidecars.seriesInventory = seriesInventory;
+  return series;
 }
 
 const STAT_METRIC_COLUMN: Record<GpuMetricStats['metric'], string> = {
diff --git a/packages/db/src/queries/gpu-metrics-timeline.test.ts b/packages/db/src/queries/gpu-metrics-timeline.test.ts
new file mode 100644
index 000000000..e0db7b355
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics-timeline.test.ts
@@ -0,0 +1,287 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import { cutPowerAuditBundle } from '../../../app/src/components/gpu-power/power-audit-bundle';
+import { bucketPowerSeries } from '../../../app/src/components/gpu-power/power-series';
+import { storedPowerSeries } from '../../../app/src/components/gpu-power/stored-power-series';
+import { parseCsvData } from '../../../app/src/components/gpu-power/types';
+import type { DbClient } from '../connection';
+import { ingestGpuMetricsArtifact } from '../etl/gpu-metrics-ingest';
+import { getGpuMetricsForPoint, getGpuMetricsForRun } from './gpu-metrics';
+
+let db: PGlite;
+let sql: postgres.Sql;
+let readSql: DbClient;
+let root: string;
+const RUN = 34557177019;
+const NAME = 'power_audit_qwen3.5_8k1k_fp8_dynamo-sglang_b200-slurm_0';
+const SOURCE = 'power_validation_qwen3.5_8k1k_fp8_dynamo-sglang_b200-slurm_0_conc32.json';
+const START = 1789194365;
+const CSV = [
+  'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+  `1,${START - 61},0,host-a,0,GPU-a0,1`, // outside the existing 60 s pad
+  `1,${START - 60},1,host-a,0,GPU-a0,0`, // genuine zero must survive
+  `1,${START + 0.1},2,host-b,0,GPU-b0,450`,
+  `1,${START + 0.1},2,host-a,0,GPU-a0,300`,
+  `1,${START + 0.1},2,host-a,0,GPU-a0,300`, // identical duplicate flush
+  `1,${START + 0.1},2,host-a,0,GPU-a0,999`, // conflicting duplicate: first wins
+  `1,${START + 0.8},3,host-a,0,GPU-a0,500`, // same second: mean 400 W
+  `1,${START + 1.1},4,host-a,0,GPU-a0,550`, // host-b dropout: null bucket
+  `1,${START + 61},5,host-b,0,GPU-b0,90`, // inclusive padded boundary
+  `1,${START + 62},6,host-b,0,GPU-b0,1`,
+].join('\n');
+const MANIFEST = {
+  producer: 'srt-slurm.dcgm-power',
+  expected_devices: [
+    { hostname: 'host-a', gpu_index: 0, assignments: [{ worker_role: 'prefill' }] },
+    { hostname: 'host-b', gpu_index: 0, assignments: [{ worker_role: 'decode' }] },
+  ],
+};
+const VALIDATION = {
+  selected_window: { start_time_unix: START, end_time_unix: START + 1 },
+  benchmark_window: { start_time_unix: START - 100, end_time_unix: START + 100 },
+};
+
+function stamp(seconds: number): string {
+  return new Date((seconds + 7200) * 1000)
+    .toISOString()
+    .replaceAll('-', '/')
+    .replace('T', ' ')
+    .replace('Z', '');
+}
+
+function client(database: Pick<PGlite, 'query'>) {
+  return Object.assign(
+    async (strings: TemplateStringsArray, ...values: unknown[]) => {
+      const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+      const result = await database.query<Record<string, unknown>>(query, values);
+      return result.rows;
+    },
+    { json: JSON.stringify, array: (value: unknown) => value },
+  );
+}
+
+function writeArtifact(name: string, files: ReadonlyMap<string, string>) {
+  const artifactDir = path.join(root, name);
+  for (const [file, contents] of files) {
+    const pathname = path.join(artifactDir, file);
+    fs.mkdirSync(path.dirname(pathname), { recursive: true });
+    fs.writeFileSync(pathname, contents);
+  }
+  return { artifactName: name, artifactDir };
+}
+
+function bundle(validation: Record<string, unknown> = VALIDATION) {
+  return new Map([
+    ['LOGS/power/samples.csv', CSV],
+    ['LOGS/power/manifest.json', JSON.stringify(MANIFEST)],
+    [SOURCE, JSON.stringify(validation)],
+  ]);
+}
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-timeline-'));
+  db = await PGlite.create();
+  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  await db.exec('ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb');
+  readSql = client(db);
+  sql = Object.assign(client(db), {
+    begin: (fn: (tx: postgres.Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(client(tx) as unknown as postgres.Sql)),
+  }) as unknown as postgres.Sql;
+}, 20_000);
+
+afterAll(async () => {
+  await db?.close();
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, created_at, date)
+      VALUES (1, ${RUN}, 1, 'Run Sweep', 'completed', '2026-09-12', '2026-09-12');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+      VALUES (1, 'qwen3.5', 'b200', 'sglang', 'fp8', 'none', false, 1, 1, 1, 1);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+      isl, osl, conc, metrics)
+      VALUES (10, 1, 1, 'single_turn', '2026-09-12', 8192, 1024, 32, '{}'),
+             (11, 1, 1, 'single_turn', '2026-09-12', 8192, 1024, 64, '{}');`);
+});
+
+describe('artifact → ingest → stored Timeline', () => {
+  it('matches artifact windows, host/GPU identity, deduplicated mean watts and gaps for a multinode bundle', async () => {
+    const files = bundle();
+    const artifact = writeArtifact(NAME, files);
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 11],
+    });
+    // Remove the actual artifact before querying: only the DB survives.
+    fs.rmSync(artifact.artifactDir, { recursive: true });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    const actual = storedPowerSeries(stored!.series);
+    expect(actual).toEqual(cutPowerAuditBundle(NAME, files));
+    expect(actual[0]).toMatchObject({
+      artifact: NAME,
+      source: SOURCE,
+      startMs: (START - 60) * 1000,
+      t: [0, 60, 61, 121],
+      power: [
+        [0, 400, 550, null],
+        [null, 450, null, 90],
+      ],
+      devices: [
+        { id: 'host-a/GPU-a0', role: 'prefill' },
+        { id: 'host-b/GPU-b0', role: 'decode' },
+      ],
+    });
+    const point = await getGpuMetricsForPoint(readSql, 10);
+    expect(point!.series.map((series) => series.benchmarkResultIds)).toEqual([
+      [10, 11],
+      [10, 11],
+    ]);
+    expect(storedPowerSeries(point!.series)).toEqual(actual);
+  });
+
+  it('retains selected-window precedence and validation role overrides across ingestion', async () => {
+    const files = bundle({
+      ...VALIDATION,
+      per_gpu_role: { 'host-a/GPU-a0': 'decode', 'host-b/GPU-b0': 'prefill' },
+    });
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NAME, files),
+      benchmarkResultIds: [10],
+    });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    const actual = storedPowerSeries(stored!.series);
+    expect(actual).toEqual(cutPowerAuditBundle(NAME, files));
+    expect(actual[0].devices?.[0]).toEqual({ id: 'host-b/GPU-b0', role: 'prefill' });
+  });
+
+  it('recovers a previously ingested bundle from linked audit source/window and retained manifest', async () => {
+    const files = bundle();
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NAME, files),
+      benchmarkResultIds: [10, 11],
+    });
+    await sql`UPDATE gpu_metric_series SET sidecars = sidecars - 'validations'`;
+    const audit = {
+      source: `some/path/${SOURCE}`,
+      window_start_unix: START,
+      window_end_unix: START + 1,
+    };
+    await sql`UPDATE benchmark_results SET power_audit = ${JSON.stringify(audit)}::jsonb`;
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    expect(stored!.series[0].powerAudits).toHaveLength(2);
+    expect(storedPowerSeries(stored!.series)).toEqual(cutPowerAuditBundle(NAME, files));
+  });
+
+  it('does not fabricate a whole-run validation window when legacy provenance is absent', async () => {
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NAME, bundle()),
+      benchmarkResultIds: [10],
+    });
+    await sql`UPDATE gpu_metric_series SET sidecars = sidecars - 'validations'`;
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    expect(() => storedPowerSeries(stored!.series)).toThrow(
+      'validation window provenance is missing',
+    );
+    expect((await getGpuMetricsForPoint(readSql, 10))!.series).toHaveLength(2);
+  });
+
+  it('matches the CSV artifact path after duplicate flushes without changing distinct-sample means', async () => {
+    const name = 'gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc32_b200_0';
+    const csv = [
+      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+      '2026/09/12 04:00:00.100, 2, 300 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %',
+      '2026/09/12 04:00:00.100, 2, 300 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %', // repeated monitor flush
+      '2026/09/12 04:00:00.100, 2, 999 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %',
+      '2026/09/12 04:00:00.800, 2, 500 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %',
+      '2026/09/12 04:00:01.100, 7, 0 W, 60, 1000 MHz, 2000 MHz, 0 %, 0 %',
+    ].join('\n');
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(name, new Map([['gpu_metrics.csv', csv]])),
+      benchmarkResultIds: [10],
+    });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    expect(storedPowerSeries(stored!.series)).toEqual([bucketPowerSeries(name, parseCsvData(csv))]);
+    expect(storedPowerSeries(stored!.series)[0]).toMatchObject({
+      gpus: [2, 7],
+      power: [
+        [400, null],
+        [null, 0],
+      ],
+    });
+  });
+
+  it('keeps SMI telemetry embedded in a power_audit bundle readable with the same source/window cuts', async () => {
+    const files = bundle();
+    files.set(
+      'gpu_metrics.csv',
+      [
+        'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+        `${stamp(START - 61)}, 0, 1 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+        `${stamp(START)}, 0, 300 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+        `${stamp(START)}, 1, 500 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+        `${stamp(START + 1)}, 0, 700 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+      ].join('\n'),
+    );
+    files.set('gpu_metrics_identity.csv', 'index, uuid\n0, GPU-a\n1, GPU-b');
+    files.set(
+      'benchmark_gpu_metrics_context.json',
+      JSON.stringify({ timestamp_timezone: '+02:00' }),
+    );
+    const artifact = writeArtifact(NAME, files);
+    await ingestGpuMetricsArtifact(sql, { workflowRunId: 1, artifact, benchmarkResultIds: [10] });
+    fs.rmSync(artifact.artifactDir, { recursive: true });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    expect(stored!.series).toHaveLength(1);
+    expect(stored!.series[0].fileName).toBe('gpu_metrics.csv');
+    const actual = storedPowerSeries(stored!.series);
+    expect(actual).toEqual(cutPowerAuditBundle(NAME, files));
+    expect(actual).toMatchObject([
+      {
+        source: SOURCE,
+        startMs: START * 1000,
+        gpus: [0, 1],
+        power: [
+          [300, 700],
+          [500, null],
+        ],
+        devices: [{ id: '0' }, { id: '1' }],
+      },
+    ]);
+  });
+
+  it('rejects incomplete per-host commits using the artifact inventory and legacy manifest', async () => {
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NAME, bundle()),
+      benchmarkResultIds: [10],
+    });
+    await sql`DELETE FROM gpu_metric_series WHERE file_name = 'LOGS/power/samples.csv#host-b'`;
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    expect(stored!.series).toHaveLength(1);
+    expect(() => storedPowerSeries(stored!.series)).toThrow(
+      'stored file/sample coverage is incomplete',
+    );
+    await sql`UPDATE gpu_metric_series SET sidecars = sidecars - 'seriesInventory'`;
+    const legacy = await getGpuMetricsForRun(readSql, RUN);
+    expect(() => storedPowerSeries(legacy!.series)).toThrow(
+      'expected device host-b GPU 0 is not stored',
+    );
+  });
+});
diff --git a/packages/db/src/queries/gpu-metrics.test.ts b/packages/db/src/queries/gpu-metrics.test.ts
index 50c75418e..fc313acb2 100644
--- a/packages/db/src/queries/gpu-metrics.test.ts
+++ b/packages/db/src/queries/gpu-metrics.test.ts
@@ -22,6 +22,7 @@ beforeAll(async () => {
   for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
     await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
   }
+  await db.exec('ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb');
 }, 20_000);
 
 afterAll(async () => {
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
index 13c0649e4..37d0a141b 100644
--- a/packages/db/src/queries/gpu-metrics.ts
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -59,6 +59,8 @@ export interface GpuMetricSeries {
   endedAt: string;
   sidecars: Record<string, unknown>;
   benchmarkResultIds: number[];
+  /** Existing benchmark provenance can recover windows from older ingests. */
+  powerAudits?: Record<string, unknown>[];
   stats: GpuMetricStatRow[];
   data: GpuMetricSampleRow[];
 }
@@ -94,6 +96,7 @@ interface RawSeriesRow {
   ended_at: string | Date;
   sidecars: Record<string, unknown> | string;
   benchmark_result_ids: (number | string)[] | null;
+  power_audits: Record<string, unknown>[] | null;
 }
 
 interface RawStatRow {
@@ -228,6 +231,7 @@ async function loadSeriesDetails(
           ? (JSON.parse(row.sidecars) as Record<string, unknown>)
           : row.sidecars,
       benchmarkResultIds: (row.benchmark_result_ids ?? []).map(Number),
+      powerAudits: row.power_audits ?? [],
       stats: statsBySeries.get(id) ?? [],
       data: samplesBySeries.get(id) ?? [],
     };
@@ -272,7 +276,13 @@ export async function getGpuMetricsForRun(
       (
         select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
         from benchmark_result_gpu_metrics l where l.series_id = s.id
-      ) as benchmark_result_ids
+      ) as benchmark_result_ids,
+      (
+        select jsonb_agg(br.power_audit order by br.id)
+        from benchmark_result_gpu_metrics l
+        join benchmark_results br on br.id = l.benchmark_result_id
+        where l.series_id = s.id and br.power_audit is not null
+      ) as power_audits
     from gpu_metric_series s
     where s.workflow_run_id = ${Number(run.id)}
     order by s.artifact_name, s.file_name
@@ -313,7 +323,13 @@ export async function getGpuMetricsForPoint(
       (
         select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
         from benchmark_result_gpu_metrics l where l.series_id = s.id
-      ) as benchmark_result_ids
+      ) as benchmark_result_ids,
+      (
+        select jsonb_agg(br.power_audit order by br.id)
+        from benchmark_result_gpu_metrics l
+        join benchmark_results br on br.id = l.benchmark_result_id
+        where l.series_id = s.id and br.power_audit is not null
+      ) as power_audits
     from benchmark_result_gpu_metrics link
     join gpu_metric_series s on s.id = link.series_id
     where link.benchmark_result_id = ${benchmarkResultId}
diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index 8a3cf3a04..1b8c97b2a 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -7,7 +7,7 @@
     "references/cli-contract.md": "82e0016e42bc1d06c3ac53b33473a0a56d0df422c6006fc74b5f3a75ac21b8d9",
     "references/cli.md": "580ea3492c3835ccc45298b339fa2a8c6fc457079a547cb04be3432a263752b0",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "9ab6b436f2ad4a47efd361ba7a288f5a2b75986abfc1ec2fe9cd5e9798a9539a",
+    "references/dashboard-views.md": "68b51d04395e6a5f3bc7255194333a0a26a83e24094803fcd3bf29e5af333b15",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/powerx.md": "f04f89ce77590d6898a776f892749722f4f4303e40e7daeeb576cbcff5d098cf",
     "references/provenance.md": "da4e9d078b31f234727706593f77ca9d5fdac611921783aaa09b5741de58b69a",
diff --git a/packages/skills/skills/inferencex-api/references/dashboard-views.md b/packages/skills/skills/inferencex-api/references/dashboard-views.md
index 19e8f9d90..5eec9cf6d 100644
--- a/packages/skills/skills/inferencex-api/references/dashboard-views.md
+++ b/packages/skills/skills/inferencex-api/references/dashboard-views.md
@@ -60,7 +60,7 @@ which controls belong together.
 | `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                               |
 | `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                    |
 | `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                 |
-| `gpu-metrics`                   | Required run, artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. Full-record statistics use stored digests. Responses are no-store.                                               |
+| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first telemetry; full-record statistics use stored digests. Responses are no-store.                 |
 | `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                    |
 
 ## Interpretation and maintenance
@@ -92,11 +92,13 @@ interactivity tok/s/user, and video costs USD/deployment-hour. Preserve the
 response's resolved TCO, utilization, license share, topology and power basis.
 Modeled and provisioned power are distinct. Missing measured evidence is not zero.
 GPU chart projections omit missing metric readings; measured zero remains zero.
-The selected series' full-record statistics include startup and warmup
+The selected file/host series' full-record statistics include startup and warmup
 and cover all chips regardless of visibility or chart downsampling. Stored digests
 are authoritative, including empty or absent metric digests; only live artifacts
 calculate from samples. Keep these sample-weighted statistics separate from
-serving-window power, J/token and selected-time-window calculations.
+serving-window power, J/token and selected-time-window calculations. The view reads
+stored telemetry first, falls back to artifacts for missing storage, and preserves
+upstream 503 failures. Treat an error as unavailable evidence, not an empty dataset.
 
 Zoom, axis scale, theme, labels, report expansion, media playback and download
 buttons are presentation state, not new datasets. AI-chart provider keys and

From cfebaa9384f585bd864bdcba0d16e0d019d0ec12 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 22 Sep 2026 10:19:11 -0700
Subject: [PATCH 026/103] fix: refresh PowerX telemetry after re-ingest
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：点详情以数据库版本选择缓存，修正 sidecar、新增关联及共享序列更新后自动读取新数据；恢复页面聚焦刷新，包含缓存失败恢复、事务回滚和真实数据库浏览器验收。
---
 bun.lock                                      |   1 +
 docs/data-pipeline.md                         |  12 +-
 docs/fixtures/powerx-reingest/README.md       |  59 ++++
 docs/fixtures/powerx-reingest/nvidia.csv      |  25 ++
 docs/fixtures/powerx-reingest/provenance.json |  31 ++
 docs/powerx-persistence-recovery.md           |  48 +++
 packages/app/cypress.powerx-db.config.ts      |  57 ++++
 .../app/cypress/powerx-db/telemetry.cy.ts     | 300 ++++++++++++++++++
 packages/app/package.json                     |   2 +
 packages/app/scripts/powerx-blob-fixture.ts   |  76 +++++
 packages/app/scripts/powerx-db-acceptance.ts  | 184 +++++++++++
 packages/app/scripts/powerx-db-fixture.ts     | 256 +++++++++++++++
 .../api/v1/gpu-metrics-point/route.test.ts    | 246 ++++++++++++++
 .../src/app/api/v1/gpu-metrics-point/route.ts |  27 +-
 .../components/gpu-power/GpuPowerDisplay.tsx  |   1 +
 .../components/inference/ui/PowerTimeline.tsx |   3 +-
 .../app/src/hooks/api/benchmark-id-query.ts   |   2 +
 .../src/hooks/api/use-gpu-metrics-point.ts    |   8 +-
 packages/app/src/lib/api-route-catalog.ts     |   6 +-
 packages/db/src/backfill-gpu-metrics.ts       |   2 +-
 .../db/src/etl/gpu-metrics-ingest.test.ts     | 121 +++++++
 .../db/src/queries/gpu-metrics-revision.ts    |  24 ++
 22 files changed, 1473 insertions(+), 18 deletions(-)
 create mode 100644 docs/fixtures/powerx-reingest/README.md
 create mode 100644 docs/fixtures/powerx-reingest/nvidia.csv
 create mode 100644 docs/fixtures/powerx-reingest/provenance.json
 create mode 100644 packages/app/cypress.powerx-db.config.ts
 create mode 100644 packages/app/cypress/powerx-db/telemetry.cy.ts
 create mode 100644 packages/app/scripts/powerx-blob-fixture.ts
 create mode 100644 packages/app/scripts/powerx-db-acceptance.ts
 create mode 100644 packages/app/scripts/powerx-db-fixture.ts
 create mode 100644 packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
 create mode 100644 packages/db/src/queries/gpu-metrics-revision.ts

diff --git a/bun.lock b/bun.lock
index 29d749498..ea567a09d 100644
--- a/bun.lock
+++ b/bun.lock
@@ -69,6 +69,7 @@
       },
       "devDependencies": {
         "@bahmutov/cypress-esbuild-preprocessor": "^2.2.8",
+        "@electric-sql/pglite": "^0.5.8",
         "@mdx-js/mdx": "^3.1.1",
         "@tailwindcss/postcss": "^4.3.3",
         "@types/adm-zip": "^0.5.8",
diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index d949a37b8..3e5bd2223 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -605,7 +605,12 @@ coverage unknown. Plain CSV fallback applies the adjacent context timezone just
 ingest and bundle reads. Raw multi-file artifacts retain separate file/host series.
 Successful reads and storage errors use no-store.
 
-`/api/v1/gpu-metrics-point?id=` powers the PowerX point-detail tab.
+`/api/v1/gpu-metrics-point?id=` powers the PowerX point-detail tab. Every request
+checks the current DB revision before reading its Blob payload cache. Sidecar repairs,
+new point links and shared-series changes therefore select fresh payloads without a
+manual purge. Success, missing-point and error responses use no-store; missing data
+is 404 and database failures remain errors. Cache-write failures log a warning and
+serve the fresh uncached result; the next request retries cache population.
 
 The public `/api/v1/views/gpu-metrics` projection and full-record UI table use the
 same stored per-GPU statistics digest for the selected file/host series. Empty or
@@ -622,7 +627,10 @@ Serving-window power, J/token and selected-time-window calculations remain separ
 按来源补齐，GitHub 不可用时仍返回健康的 DB 曲线，并显式标出缺失来源。旧的 GET
 没有预期清单，覆盖状态为 unknown。sourceCoverage 仅描述本次请求，不代表整个 run
 的完整性；普通 CSV 与 bundle、ingest 使用相同的 context 时区。
-全记录统计使用已存摘要，包含启动与 warmup；缺失读数不补零，已有摘要为空时不重新计算。它与 serving-window 功率、J/token 和用户所选时间窗口的统计分别处理。
+点详情每次读取先核对数据库版本，修正 sidecar 或共享关联后
+无需手动清缓存；响应均为 no-store。全记录统计使用已存摘要，包含启动与 warmup；
+缺失读数不补零，已有摘要为空时不重新计算。它与 serving-window 功率、J/token 和
+用户所选时间窗口的统计分别处理。
 
 ### PowerX publication receipts
 
diff --git a/docs/fixtures/powerx-reingest/README.md b/docs/fixtures/powerx-reingest/README.md
new file mode 100644
index 000000000..f22777fe1
--- /dev/null
+++ b/docs/fixtures/powerx-reingest/README.md
@@ -0,0 +1,59 @@
+# Retained telemetry for re-ingest recovery
+
+`nvidia.csv` contains unchanged readings from the public InferenceX B200/Qwen3.5
+run [34175132645, attempt 1](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645/attempts/1).
+`provenance.json` records the original artifact name, full-file SHA-256, physical
+line ranges and derived-file SHA-256. Tests read these committed bytes; no artifact
+download is required.
+
+Retain original line 1 and lines 2898–2921, joined with LF and a final LF: three
+consecutive samples of all eight GPUs, 24 rows / 1,901 bytes. Headers, units,
+timestamps and values are unchanged. The CSV contains no hostnames or UUIDs, so
+no identity anonymization was needed. The original collector version and timezone
+are unknown. The file hash identifies the source bytes independently of those
+unknowns.
+
+The UTC context, collector labels, identity sidecars, local benchmark rows and
+repair offsets used by tests are **constructed test inputs**. They do not describe
+a correction to the original run. No original energy/quality claim is attached to
+this cropped fragment. It proves retained-format parsing and recovery through the
+consumer, not GPU collection reliability or serving-window qualification.
+
+Fixed checks come directly from the retained rows: GPU 0 has
+`380.42, 336.61, 337.18 W`; with the explicit UTC test context the range is
+`2026-09-08T07:20:19.279Z`–`2026-09-08T07:20:21.279Z`. Its sample mean is
+`351.4033333333333 W`. Production parsers/statistics functions must not generate
+test expectations.
+
+Run the recovery checks from the repository root after the lockfile dependencies,
+Cypress binary and PostgreSQL 17 tools are installed:
+
+```sh
+bun run --cwd packages/db test:unit src/etl/gpu-metrics-ingest.test.ts --maxWorkers=2
+(cd packages/app && bun node_modules/vitest/vitest.mjs run src/app/api/v1/gpu-metrics-point/route.test.ts --maxWorkers=2)
+POWERX_ACCEPTANCE_APP_PORT=3157 POWERX_ACCEPTANCE_PG_PORT=3158 \
+  bun run --cwd packages/app test:e2e:powerx /absolute/fresh/output-directory
+```
+
+The API test uses PGlite, the production parser/ingest/query/cache/point handler,
+and the real Blob SDK with a local HTTP transport. Its four cases retain
+missing→present, shared links, timezone/identity repair, no-op, cache-write failure
+and retry, and DB failure. The ingest tests separately check actual late FK
+rollback and second-series failure followed by repair; they do not claim whole
+artifact atomicity.
+
+The browser driver creates a disposable loopback PostgreSQL database, runs real
+migrations and ETL, then starts Next.js and Cypress. The two retained-source cases
+populate old cache entries for both shared points, repair constructed sidecars,
+and check API values plus EN desktop / ZH mobile focus, reopen and no-op behavior.
+The original eight synthetic browser cases remain. Successful telemetry responses
+are never substituted. The seed verifies the excerpt hash before database writes
+and records it in `seed-receipt.json`; `blob-receipt.json` records both revisions.
+
+`POWERX_PG_BIN` selects the PostgreSQL bin directory; app/PG ports default to
+3137/3138 and must be unused. Use a fresh output directory each time. The driver
+stops its owned Next, PostgreSQL and Blob fixture and records cleanup errors.
+This local check needs no artifact download or production credentials. Ancillary
+site stars/font traffic is not blocked by this driver, so it does not establish
+strict network-isolated execution. Hosted Neon, Blob/CDN and deployment are not
+covered. No collector or telemetry-validity policy changes are included.
diff --git a/docs/fixtures/powerx-reingest/nvidia.csv b/docs/fixtures/powerx-reingest/nvidia.csv
new file mode 100644
index 000000000..62113072c
--- /dev/null
+++ b/docs/fixtures/powerx-reingest/nvidia.csv
@@ -0,0 +1,25 @@
+timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]
+2026/09/08 07:20:19.279, 0, 380.42 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 1, 392.58 W, 43, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 2, 375.45 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 3, 384.71 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 4, 379.91 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 5, 388.18 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 6, 374.34 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 7, 379.36 W, 41, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 0, 336.61 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 1, 346.06 W, 43, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 2, 333.34 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 3, 344.15 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 4, 337.25 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 5, 342.84 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 6, 335.00 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 7, 335.78 W, 41, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 0, 337.18 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 1, 345.05 W, 43, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 2, 340.15 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 3, 344.63 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 4, 337.94 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 5, 342.85 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 6, 334.88 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 7, 336.11 W, 41, 1965 MHz, 3996 MHz, 100 %, 9 %
diff --git a/docs/fixtures/powerx-reingest/provenance.json b/docs/fixtures/powerx-reingest/provenance.json
new file mode 100644
index 000000000..e6a332ee1
--- /dev/null
+++ b/docs/fixtures/powerx-reingest/provenance.json
@@ -0,0 +1,31 @@
+{
+  "source": {
+    "repository": "SemiAnalysisAI/InferenceX",
+    "run_id": 34175132645,
+    "run_attempt": 1,
+    "run_url": "https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645/attempts/1",
+    "artifact_name": "power_audit_qwen3.5_8k1k_fp8_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc1_b200-nscale-slurm_00_recipe-4a9cbfa6f11448e8",
+    "file": "gpu_metrics.csv",
+    "sha256": "0c04d4c47ce4ebdd71aa2a56e179cbf481733bb9517021bb9c6e91b261897c0d",
+    "collector_version": null,
+    "timestamp_timezone": null,
+    "head_sha": "931838616543914232d4bab6724bae79742ba371"
+  },
+  "fixture": {
+    "file": "nvidia.csv",
+    "sha256": "833cf864da4618579deeeda89b3ddde6dbf8b7b32b7877fda643f18411ee3481",
+    "physical_lines_inclusive": [
+      [1, 1],
+      [2898, 2921]
+    ],
+    "transformations": [
+      "Retain header and three complete consecutive 8-GPU samples; join unchanged lines with LF and final LF."
+    ],
+    "bytes": 1901,
+    "sample_count": 24,
+    "gpu_count": 8,
+    "utc_start_with_test_context": "2026-09-08T07:20:19.279Z",
+    "utc_end_with_test_context": "2026-09-08T07:20:21.279Z",
+    "gpu0_power_w": [380.42, 336.61, 337.18]
+  }
+}
diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
index 3e7c67d6d..2973b8a77 100644
--- a/docs/powerx-persistence-recovery.md
+++ b/docs/powerx-persistence-recovery.md
@@ -55,6 +55,23 @@ The live raw explorer also keeps each CSV as a separate series, matching the dat
 reader. Multi-file artifact labels include the CSV path, so host-local GPU 0 values cannot
 be merged into one device. Single-file labels remain unchanged.
 
+## Cache and browser recovery
+
+`/api/v1/gpu-metrics-point?id=N` checks a live database revision before reading its existing
+Blob cache. The revision includes linked series, ingest time, CSV hash, sidecars and shared
+point links/audits. The payload stays in Blob; the revision query reads only metadata.
+Same-input ingest leaves the revision unchanged. A sidecar correction, series replacement,
+new point link or linked audit correction selects a new cache entry, including for every
+point sharing the series. Missing points are not negatively cached.
+
+Point and Timeline responses use `Cache-Control: no-store`, so CDN/browser response caches
+cannot skip the database check. Client queries revalidate on mount and window focus.
+An already open page refreshes when revisited/refocused or reloaded; there is no continuous
+polling. A failed Blob write logs `serving uncached result`, returns fresh DB data, and is
+retried on the next read. A database failure remains an API error even if an old Blob exists.
+Old cache generations remain until the existing prefix cleanup runs; repair does not require
+a manual PowerX cache purge. General benchmark cache invalidation still follows normal CI.
+
 ## Full-record statistics
 
 The point detail, run explorer and public `/api/v1/views/gpu-metrics` projection use the
@@ -74,3 +91,34 @@ GPU visibility filter changes the full-record table. Window calculations still c
 the selected samples, and serving energy/financial metrics retain their own definitions.
 SQL samples and digests use `real` (float32), so compare stored values with an explicit
 float32 tolerance rather than the tighter tolerance of the in-memory parser tests.
+
+## Local verification
+
+From the repository root:
+
+```sh
+bun install --frozen-lockfile --ignore-scripts
+bun run test:unit
+bun run typecheck
+bun run lint
+bun run fmt
+bun run check:typography
+bun run --cwd packages/app test:unit src/app/api/v1/gpu-metrics-point/route.test.ts
+bun run --cwd packages/app test:unit src/app/api/v1/views/gpu-metrics/route.test.ts
+bun run --cwd packages/db test:unit src/queries/gpu-metrics-timeline.test.ts
+bun run --cwd packages/app test:e2e:component --spec cypress/component/gpu-stats-table.cy.tsx
+```
+
+The focused browser driver creates a disposable localhost PostgreSQL database, ingests
+NVIDIA/AMD/multinode artifacts, starts Next without a GitHub token, and enables the real
+Blob SDK against a local HTTP fixture. It writes logs, screenshots and receipts, then stops
+its owned processes. It uses ports 3137/3138 and requires PostgreSQL 17 tools. Run with a
+fresh output directory while no other dev server is using this checkout's `.next` directory:
+
+```sh
+cd packages/app
+POWERX_PG_BIN=/path/to/postgresql/bin bun scripts/powerx-db-acceptance.ts /absolute/fresh/output
+```
+
+The ordinary fixture-backed smoke command remains `bun run test:e2e` with an
+`E2E_FIXTURES=1` dev server. The full cross-browser matrix remains the repository CI gate.
diff --git a/packages/app/cypress.powerx-db.config.ts b/packages/app/cypress.powerx-db.config.ts
new file mode 100644
index 000000000..61bcb2e07
--- /dev/null
+++ b/packages/app/cypress.powerx-db.config.ts
@@ -0,0 +1,57 @@
+import createBundler from '@bahmutov/cypress-esbuild-preprocessor';
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { defineConfig } from 'cypress';
+
+export default defineConfig({
+  allowCypressEnv: false,
+  video: false,
+  retries: 0,
+  defaultCommandTimeout: 10000,
+  screenshotsFolder: path.join(process.env.POWERX_ACCEPTANCE_OUTPUT!, 'screenshots'),
+  e2e: {
+    baseUrl: process.env.POWERX_ACCEPTANCE_BASE_URL ?? 'http://127.0.0.1:3137',
+    specPattern: 'cypress/powerx-db/*.cy.ts',
+    supportFile: 'cypress/support/e2e.ts',
+    setupNodeEvents(on) {
+      on(
+        'file:preprocessor',
+        createBundler({
+          define: { 'process.env.NODE_ENV': '"test"' },
+          alias: { '@': path.resolve(__dirname, 'src') },
+        }),
+      );
+      on('task', {
+        unlinkRetainedPoint() {
+          execFileSync('bun', ['scripts/powerx-db-fixture.ts', 'unlink-retained-point'], {
+            env: process.env,
+          });
+          return null;
+        },
+        retainedTelemetry(repaired: boolean) {
+          return JSON.parse(
+            execFileSync(
+              'bun',
+              ['scripts/powerx-db-fixture.ts', repaired ? 'retained-repair' : 'retained-reset'],
+              { encoding: 'utf8', env: process.env },
+            ),
+          );
+        },
+        repairTelemetry() {
+          return execFileSync('bun', ['scripts/powerx-db-fixture.ts', 'repair'], {
+            encoding: 'utf8',
+            env: process.env,
+          });
+        },
+        setTelemetryAvailable(available: boolean) {
+          execFileSync(
+            'bun',
+            ['scripts/powerx-db-fixture.ts', available ? 'restore' : 'unavailable'],
+            { env: process.env },
+          );
+          return null;
+        },
+      });
+    },
+  },
+});
diff --git a/packages/app/cypress/powerx-db/telemetry.cy.ts b/packages/app/cypress/powerx-db/telemetry.cy.ts
new file mode 100644
index 000000000..1e1e3dc7f
--- /dev/null
+++ b/packages/app/cypress/powerx-db/telemetry.cy.ts
@@ -0,0 +1,300 @@
+const POINT = '/api/v1/gpu-metrics-point?id=206885';
+const RUN = '34716669498';
+const telemetry = '[data-testid="power-telemetry-view"]';
+const statsCard = `${telemetry} > [data-slot="card"]:last-child`;
+
+function visit(url: string, delayTelemetry = false) {
+  cy.visit(url, {
+    onBeforeLoad(win) {
+      win.localStorage.setItem('inferencex-feature-gate', '1');
+      win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
+      if (delayTelemetry) {
+        const nativeFetch = win.fetch.bind(win);
+        win.fetch = async (...args) => {
+          const response = await nativeFetch(...args);
+          if (String(args[0]).includes('gpu-metrics-point')) {
+            await new Promise((resolve) => {
+              win.setTimeout(resolve, 700);
+            });
+          }
+          return response;
+        };
+      }
+    },
+  });
+}
+
+function captureViewport(selector: string, name: string, fromBottom = false) {
+  // Wait for Radix exit animations before scrolling or capturing the page.
+  cy.get('[data-slot="select-content"]').should('not.exist');
+  cy.get(selector).then(($target) => {
+    cy.window().then((win) => {
+      const rect = $target[0].getBoundingClientRect();
+      win.scrollTo({
+        top: win.scrollY + (fromBottom ? rect.bottom - 600 : rect.top - 112),
+        left: 0,
+        behavior: 'instant',
+      });
+    });
+  });
+  cy.screenshot(name, { capture: 'viewport' });
+}
+
+function refocus() {
+  cy.window().then((win) => {
+    Object.defineProperty(win.document, 'visibilityState', { configurable: true, value: 'hidden' });
+    win.dispatchEvent(new win.Event('visibilitychange'));
+    Object.defineProperty(win.document, 'visibilityState', {
+      configurable: true,
+      value: 'visible',
+    });
+    win.dispatchEvent(new win.Event('visibilitychange'));
+  });
+}
+
+describe('PowerX artifact → PostgreSQL → real API → browser', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message === 'ResizeObserver loop completed with undelivered notifications.')
+        return false;
+    });
+  });
+  afterEach(() => {
+    cy.task('setTelemetryAvailable', true);
+  });
+
+  it('loads NVIDIA point telemetry and the stored full-record digest without GitHub', () => {
+    cy.viewport(1280, 900);
+    // Delay the real fetch result; Cypress response intercepts race dev StrictMode aborts.
+    visit('/inference/agentic/206885?view=power', true);
+    cy.get('[data-testid="power-telemetry-loading"]').should('be.visible');
+    cy.get(telemetry).should('contain.text', 'collector-before-repair');
+    cy.request(POINT).then((response) => {
+      expect(response.status).to.eq(200);
+      expect(response.headers['cache-control']).to.eq('no-store');
+      const series = response.body.series[0];
+      expect(series.sampleCount).to.eq(16); // 17 CSV rows, one duplicate flush.
+      expect(
+        series.stats.find(
+          (row: { gpuIndex: number; metric: string }) =>
+            row.gpuIndex === 0 && row.metric === 'power_w',
+        ).mean,
+      ).to.eq(135);
+    });
+    cy.get(telemetry).should('contain.text', 'collector-before-repair');
+    cy.get('[data-testid="power-telemetry-sample-count"]').should('have.text', '16');
+    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '135.0');
+    cy.get('[data-testid="gpu-metrics-chart-svg"] path.line-path').should('have.length', 2);
+    captureViewport('[data-testid="power-telemetry-chart"]', 'point-nvidia-desktop-chart');
+    captureViewport(statsCard, 'point-nvidia-desktop-stats');
+  });
+
+  it('keeps AMD missing samples and metric units correct in Chinese on mobile', () => {
+    cy.viewport(390, 844);
+    visit('/zh/inference/agentic/206886?view=power');
+    cy.get(telemetry).should('contain.text', 'amd-smi');
+    cy.get('[data-testid="power-telemetry-metric-select"]').click();
+    cy.get('[data-slot="select-item"]').contains('GFX 电压 (mV)').click();
+    cy.get(`${telemetry} table`).should('contain.text', '平均值 (mV)');
+    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(1).should('have.text', '6');
+    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '850.0');
+    captureViewport(
+      '[data-testid="power-telemetry-metric-select"]',
+      'point-amd-mobile-zh-controls',
+    );
+    captureViewport('[data-testid="power-telemetry-chart"]', 'point-amd-mobile-zh-chart');
+    captureViewport(
+      '[data-testid="power-telemetry-chart"]',
+      'point-amd-mobile-zh-chart-bottom',
+      true,
+    );
+    captureViewport(statsCard, 'point-amd-mobile-zh-stats');
+  });
+
+  it('switches multinode series without merging host-local GPU zero', () => {
+    cy.viewport(1280, 900);
+    visit('/inference/agentic/206887?view=power');
+    cy.get(telemetry).should('contain.text', 'srt-slurm.dcgm-power');
+    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '535.0');
+    cy.get('#power-telemetry-series-select').click();
+    cy.get('[data-slot="select-item"]').contains('host-b').click();
+    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '635.0');
+    cy.get('[data-testid="power-telemetry-sample-count"]').should('have.text', '16');
+    cy.get('[data-testid="power-telemetry-metric-select"]').click();
+    cy.get('[data-slot="select-item"]').should('have.length', 1).and('contain.text', 'Power Draw');
+    cy.get('body').type('{esc}');
+    captureViewport('[data-testid="power-telemetry-chart"]', 'point-multinode-series-chart');
+    captureViewport(statsCard, 'point-multinode-series-stats');
+  });
+
+  for (const [prefix, width] of [
+    ['', 1280],
+    ['/zh', 390],
+  ] as const) {
+    it(`renders database Timeline with GitHub unavailable at ${prefix || 'en'} ${width}px`, () => {
+      cy.viewport(width, 900);
+      cy.request({ url: '/api/gpu-metrics?runId=999999', failOnStatusCode: false }).then(
+        (response) => {
+          expect(response.status).to.eq(500);
+          expect(response.body.error).to.eq('GitHub token not configured');
+        },
+      );
+      cy.intercept('POST', `/api/gpu-metrics?runId=${RUN}*`).as('timeline');
+      visit(
+        `${prefix}/inference?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4&i_metric=y_measuredPowerTimeline`,
+      );
+      cy.wait('@timeline').then(({ request, response }) => {
+        expect(request.body.sources).to.have.length(3);
+        expect(response!.statusCode).to.eq(200);
+        expect(response!.body.source).to.eq('database');
+        expect(response!.body.series).to.have.length(3);
+      });
+      cy.get(
+        '[data-testid="power-timeline-chart-svg"] path.power-trace[data-segment="full"]',
+      ).should('have.length', 3);
+      cy.get('[data-testid="power-timeline-missing"]').should('not.exist');
+      captureViewport(
+        '[data-testid="power-timeline"]',
+        `timeline-db-${prefix ? 'zh-mobile' : 'en-desktop'}`,
+      );
+      captureViewport(
+        '[data-testid="power-timeline-chart-svg"]',
+        `timeline-db-${prefix ? 'zh-mobile' : 'en-desktop'}-chart-bottom`,
+        true,
+      );
+    });
+  }
+
+  it('distinguishes a real database read error from missing data and retries successfully', () => {
+    cy.task('setTelemetryAvailable', false);
+    cy.request({
+      url: `/api/v1/views/gpu-metrics?runId=${RUN}`,
+      failOnStatusCode: false,
+    }).then(({ status, body, headers }) => {
+      expect(status).to.eq(503);
+      expect(body.error).to.eq('Source data unavailable');
+      expect(headers['cache-control']).to.eq('private, no-store');
+    });
+    visit('/zh/inference/agentic/206885?view=power');
+    cy.get('[data-testid="power-telemetry-query-error"]').should('be.visible');
+    cy.get('[data-testid="power-telemetry-missing"]').should('not.exist');
+    cy.task('setTelemetryAvailable', true);
+    cy.get('[data-testid="power-telemetry-query-error"]').contains('button', '重试').click();
+    cy.get(telemetry).should('contain.text', 'collector-before-repair');
+    cy.get('[data-testid="power-telemetry-query-error"]').should('not.exist');
+  });
+
+  it('shows a genuine missing point as missing', () => {
+    visit('/inference/agentic/999999?view=power');
+    cy.get('[data-testid="power-telemetry-missing"]').should('contain.text', '#999999');
+    cy.get('[data-testid="power-telemetry-query-error"]').should('not.exist');
+  });
+
+  it('returns retained full-record digests through the public view while filtering chart GPUs', () => {
+    cy.request('/api/v1/gpu-metrics-point?id=206888').then(({ body }) => {
+      const digest = body.series[0].stats
+        .filter((row: { metric: string }) => row.metric === 'power_w')
+        .sort((a: { mean: number }, b: { mean: number }) => b.mean - a.mean);
+      cy.request(
+        '/api/v1/views/gpu-metrics?runId=34175132645&metric=power&gpus=0&sort=mean&direction=desc',
+      ).then((response) => {
+        expect(response.status).to.eq(200);
+        expect(response.headers['cache-control']).to.eq('private, no-store');
+        expect(response.body.stats).to.deep.eq(digest);
+        expect(response.body.stats).to.have.length(8);
+        const gpu0 = response.body.stats.find((row: { gpuIndex: number }) => row.gpuIndex === 0);
+        expect(gpu0.count).to.eq(3);
+        expect(gpu0.mean).to.be.closeTo(351.4033333333333, 0.0001);
+        expect(response.body.rows).to.have.length(3);
+        expect(response.body.rows.every((row: { index: number }) => row.index === 0)).to.eq(true);
+        expect(Object.keys(response.body.chart)).to.deep.eq(['0']);
+      });
+    });
+  });
+
+  it('recovers a missing point link through unchanged-input ingest and browser refocus', () => {
+    cy.task('retainedTelemetry', false);
+    cy.task('unlinkRetainedPoint');
+    visit('/inference/agentic/206889?view=power');
+    cy.get('[data-testid="power-telemetry-missing"]').should('be.visible');
+    cy.request({ url: '/api/v1/gpu-metrics-point?id=206889', failOnStatusCode: false })
+      .its('status')
+      .should('eq', 404);
+    cy.task('retainedTelemetry', false).should('include', { samplesInserted: 0 });
+    refocus();
+    cy.get(telemetry).should('contain.text', 'retained-before-repair');
+    cy.get(`${telemetry} table tbody tr`).should('have.length', 8);
+    cy.request('/api/v1/gpu-metrics-point?id=206889').then(({ body }) => {
+      expect(body.series[0].sampleCount).to.eq(24);
+      expect(body.series[0].benchmarkResultIds).to.deep.eq([206888, 206889]);
+    });
+  });
+
+  it('refreshes corrected sidecars and timestamps on focus and reopening the tab', () => {
+    visit('/inference/agentic/206885?view=power');
+    cy.get(telemetry).should('contain.text', 'collector-before-repair');
+    cy.request(POINT).its('body.series.0.startedAt').should('eq', '2026-09-01T20:00:00.000Z');
+    cy.task('repairTelemetry');
+    refocus();
+    cy.get(telemetry).should('contain.text', 'collector-after-repair');
+    cy.request(POINT).then((response) => {
+      expect(response.body.series[0].startedAt).to.eq('2026-09-01T18:00:00.000Z');
+      expect(response.body.series[0].sampleCount).to.eq(16);
+    });
+    cy.get('[data-testid="detail-view-point"]').click();
+    cy.get('[data-testid="detail-view-power"]').click();
+    cy.get(telemetry).should('contain.text', 'collector-after-repair');
+    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '135.0');
+    captureViewport(telemetry, 'point-after-reingest');
+  });
+
+  for (const [prefix, width] of [
+    ['', 1280],
+    ['/zh', 390],
+  ] as const) {
+    it(`repairs retained B200 telemetry through cache, shared points and ${prefix || 'en'} browser`, () => {
+      cy.task('retainedTelemetry', false);
+      cy.viewport(width, 900);
+      for (const id of [206888, 206889]) {
+        cy.request(`/api/v1/gpu-metrics-point?id=${id}`).then(({ body }) => {
+          expect(body.series[0].startedAt).to.eq('2026-09-08T07:20:19.279Z');
+          expect(body.series[0].sampleCount).to.eq(24);
+          expect(body.series[0].gpuCount).to.eq(8);
+          expect(body.series[0].benchmarkResultIds).to.deep.eq([206888, 206889]);
+          expect(body.series[0].data[0].power).to.be.closeTo(380.42, 0.0001);
+        });
+      }
+      visit(`${prefix}/inference/agentic/206888?view=power`);
+      cy.get(telemetry).should('contain.text', 'retained-before-repair');
+      cy.get('[data-testid="power-telemetry-sample-count"]').should('have.text', '24');
+      cy.get(`${telemetry} table tbody tr`).should('have.length', 8);
+      cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '351.4');
+      cy.task('retainedTelemetry', true).its('samplesInserted').should('eq', 24);
+      refocus();
+      cy.get(telemetry).should('contain.text', 'retained-after-repair');
+      cy.window().then((win) => {
+        const expected = new win.Date('2026-09-08T05:20:19.279Z').toLocaleTimeString(
+          prefix ? 'zh-CN' : undefined,
+        );
+        cy.get(telemetry).should('contain.text', expected);
+      });
+      for (const id of [206888, 206889]) {
+        cy.request(`/api/v1/gpu-metrics-point?id=${id}`).then(({ body }) => {
+          expect(body.series[0].startedAt).to.eq('2026-09-08T05:20:19.279Z');
+          expect(body.series[0].sampleCount).to.eq(24);
+          expect(JSON.stringify(body.series[0].sidecars)).to.contain('GPU-fixture-corrected-0');
+        });
+      }
+      cy.task('retainedTelemetry', true).should('include', {
+        samplesInserted: 0,
+        seriesSkipped: 1,
+      });
+      cy.get('[data-testid="detail-view-point"]').click();
+      cy.get('[data-testid="detail-view-power"]').click();
+      cy.get(telemetry).should('contain.text', 'retained-after-repair');
+      cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '351.4');
+      captureViewport(telemetry, `retained-repair-${prefix ? 'zh-mobile' : 'en-desktop'}`);
+      captureViewport(statsCard, `retained-stats-${prefix ? 'zh-mobile' : 'en-desktop'}`);
+    });
+  }
+});
diff --git a/packages/app/package.json b/packages/app/package.json
index 3ee80be32..8aefd19d3 100644
--- a/packages/app/package.json
+++ b/packages/app/package.json
@@ -24,6 +24,7 @@
     "test:e2e:full": "cypress run --component && cypress run",
     "test:e2e:component": "cypress run --component",
     "test:e2e:integration": "cypress run",
+    "test:e2e:powerx": "bun scripts/powerx-db-acceptance.ts",
     "test:unit": "bun --env-file=../../.env vitest run",
     "test:unit:coverage": "bun --env-file=../../.env vitest run --coverage",
     "clean": "rimraf .next out",
@@ -83,6 +84,7 @@
   },
   "devDependencies": {
     "@bahmutov/cypress-esbuild-preprocessor": "^2.2.8",
+    "@electric-sql/pglite": "^0.5.8",
     "@mdx-js/mdx": "^3.1.1",
     "@tailwindcss/postcss": "^4.3.3",
     "@types/adm-zip": "^0.5.8",
diff --git a/packages/app/scripts/powerx-blob-fixture.ts b/packages/app/scripts/powerx-blob-fixture.ts
new file mode 100644
index 000000000..ea283fc10
--- /dev/null
+++ b/packages/app/scripts/powerx-blob-fixture.ts
@@ -0,0 +1,76 @@
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+
+/** Local HTTP transport for the real Blob SDK; never contacts a Blob store. */
+export async function startPowerxBlobFixture(port = 0) {
+  const objects = new Map<string, string>();
+  const counts = { reads: 0, writes: 0, failedWrites: 0 };
+  let rejectWrites = false;
+  const server = createServer(async (request, response) => {
+    const url = new URL(request.url!, 'http://localhost');
+    const pathname = url.searchParams.get('pathname') ?? url.searchParams.get('url');
+    response.setHeader('content-type', 'application/json');
+    const fail = (status: number, code: string) => {
+      response.writeHead(status);
+      response.end(JSON.stringify({ error: { code, message: code } }));
+    };
+    if (url.pathname === '/body') {
+      counts.reads++;
+      const body = objects.get(pathname!);
+      if (body === undefined) return fail(404, 'not_found');
+      response.end(body);
+      return;
+    }
+    if (!pathname) return fail(400, 'bad_request');
+    if (request.method === 'PUT') {
+      counts.writes++;
+      if (rejectWrites) {
+        counts.failedWrites++;
+        request.resume();
+        return fail(403, 'forbidden');
+      }
+      const chunks: Buffer[] = [];
+      for await (const chunk of request) chunks.push(Buffer.from(chunk));
+      objects.set(pathname, Buffer.concat(chunks).toString());
+    }
+    if (!objects.has(pathname)) return fail(404, 'not_found');
+    const address = server.address() as AddressInfo;
+    const bodyUrl = `http://127.0.0.1:${address.port}/body?url=${encodeURIComponent(pathname)}`;
+    response.end(
+      JSON.stringify({
+        url: bodyUrl,
+        downloadUrl: bodyUrl,
+        pathname,
+        size: Buffer.byteLength(objects.get(pathname)!),
+        contentType: 'application/json',
+        uploadedAt: new Date().toISOString(),
+        etag: 'local-fixture',
+      }),
+    );
+  });
+  await new Promise<void>((resolve) => {
+    server.listen(port, '127.0.0.1', resolve);
+  });
+  const address = server.address() as AddressInfo;
+  return {
+    env: {
+      VERCEL_BLOB_API_URL: `http://127.0.0.1:${address.port}`,
+      BLOB_READ_WRITE_TOKEN: 'vercel_blob_rw_local_fixture',
+      BLOB_CACHE_PREFIX: 'powerx-local-acceptance',
+    },
+    objects,
+    counts,
+    rejectWrites: (value: boolean) => {
+      rejectWrites = value;
+    },
+    close: () =>
+      new Promise<void>((resolve, reject) => {
+        server.closeAllConnections();
+        server.close((error) =>
+          error && (error as NodeJS.ErrnoException).code !== 'ERR_SERVER_NOT_RUNNING'
+            ? reject(error)
+            : resolve(),
+        );
+      }),
+  };
+}
diff --git a/packages/app/scripts/powerx-db-acceptance.ts b/packages/app/scripts/powerx-db-acceptance.ts
new file mode 100644
index 000000000..6566c1eef
--- /dev/null
+++ b/packages/app/scripts/powerx-db-acceptance.ts
@@ -0,0 +1,184 @@
+/** bun scripts/powerx-db-acceptance.ts /absolute/output/directory; requires PostgreSQL 17 tools. */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync, spawn } from 'node:child_process';
+import { startPowerxBlobFixture } from './powerx-blob-fixture';
+
+const output = path.resolve(
+  process.argv[2] ?? fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-db-')),
+);
+const pgBin = process.env.POWERX_PG_BIN ?? '/opt/homebrew/opt/postgresql@17/bin';
+const appRoot = path.resolve(import.meta.dirname, '..');
+const pgData = path.join(output, 'postgres');
+const appPort = Number(process.env.POWERX_ACCEPTANCE_APP_PORT ?? 3137);
+const pgPort = Number(process.env.POWERX_ACCEPTANCE_PG_PORT ?? 3138);
+const baseUrl = `http://127.0.0.1:${appPort}`;
+const dbUrl = `postgres://powerx_acceptance@127.0.0.1:${pgPort}/powerx_acceptance`;
+fs.mkdirSync(output, { recursive: true });
+const blob = await startPowerxBlobFixture();
+const env = {
+  ...process.env,
+  POWERX_ACCEPTANCE_OUTPUT: output,
+  POWERX_ACCEPTANCE_DATABASE_URL: dbUrl,
+  POWERX_ACCEPTANCE_BASE_URL: baseUrl,
+  DATABASE_READONLY_URL: dbUrl,
+  DATABASE_WRITE_URL: '',
+  DATABASE_DRIVER: 'postgres',
+  DATABASE_SSL: 'false',
+  E2E_FIXTURES: '0',
+  GITHUB_TOKEN: '',
+  ...blob.env,
+  NEXT_PUBLIC_POSTHOG_KEY: '',
+};
+let server: ReturnType<typeof spawn> | undefined;
+let dbStarted = false;
+const cleanupErrors: string[] = [];
+const receipt = {
+  output,
+  database: 'disposable localhost PostgreSQL',
+  githubToken: false,
+  blobCache: 'real SDK, local HTTP transport',
+  retainedFixture: JSON.parse(
+    fs.readFileSync(
+      path.resolve(appRoot, '../../docs/fixtures/powerx-reingest/provenance.json'),
+      'utf8',
+    ),
+  ),
+  exitCode: 1,
+  cleanupErrors,
+};
+try {
+  execFileSync(
+    path.join(pgBin, 'initdb'),
+    ['-D', pgData, '-A', 'trust', '-U', 'powerx_acceptance', '--no-locale', '--encoding=UTF8'],
+    { stdio: 'pipe' },
+  );
+  execFileSync(
+    path.join(pgBin, 'pg_ctl'),
+    [
+      '-D',
+      pgData,
+      '-l',
+      path.join(output, 'postgres.log'),
+      '-o',
+      `-h 127.0.0.1 -p ${pgPort} -k /tmp`,
+      'start',
+    ],
+    { stdio: 'pipe' },
+  );
+  dbStarted = true;
+  execFileSync(path.join(pgBin, 'createdb'), [
+    '-h',
+    '127.0.0.1',
+    '-p',
+    String(pgPort),
+    '-U',
+    'powerx_acceptance',
+    'powerx_acceptance',
+  ]);
+  const seedLog = fs.openSync(path.join(output, 'seed.log'), 'w');
+  execFileSync('bun', ['scripts/powerx-db-fixture.ts', 'seed'], {
+    cwd: appRoot,
+    env,
+    stdio: ['ignore', seedLog, seedLog],
+  });
+  fs.closeSync(seedLog);
+  const serverLog = fs.openSync(path.join(output, 'next.log'), 'w');
+  server = spawn(
+    'node',
+    [
+      'node_modules/next/dist/bin/next',
+      'dev',
+      '--hostname',
+      '127.0.0.1',
+      '--port',
+      String(appPort),
+    ],
+    {
+      cwd: appRoot,
+      env,
+      detached: true,
+      stdio: ['ignore', serverLog, serverLog],
+    },
+  );
+  let ready = false;
+  for (let i = 0; i < 60; i++) {
+    try {
+      const response = await fetch(`${baseUrl}/api/v1/gpu-metrics-point?id=206885`, {
+        signal: AbortSignal.timeout(5000),
+      });
+      if (response.ok) {
+        ready = true;
+        break;
+      }
+    } catch {
+      /* Connection refusal is expected while Next starts. */
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 500);
+    });
+  }
+  if (!ready) throw new Error(`Local server did not become ready; inspect ${output}/next.log`);
+  await fetch(`${baseUrl}/inference/agentic/206885?view=power`);
+  await fetch(`${baseUrl}/zh/inference/agentic/206885?view=power`);
+  await fetch(`${baseUrl}/inference`);
+  const browserLog = fs.openSync(path.join(output, 'browser.log'), 'w');
+  const browser = spawn(
+    'node',
+    ['node_modules/cypress/bin/cypress', 'run', '--config-file', 'cypress.powerx-db.config.ts'],
+    {
+      cwd: appRoot,
+      env,
+      stdio: ['ignore', browserLog, browserLog],
+    },
+  );
+  receipt.exitCode = await new Promise<number>((resolve) => {
+    browser.on('exit', (code) => resolve(code ?? 1));
+  });
+  const revisions = [...blob.objects.values()]
+    .map((value) => JSON.parse(value))
+    .filter((payload) => payload?.benchmarkResultId === 206885);
+  const producers = revisions.map((payload) => payload.series[0].sidecars.context.producer);
+  const retainedProducers = [...blob.objects.values()]
+    .map((value) => JSON.parse(value))
+    .filter((payload) => [206888, 206889].includes(payload?.benchmarkResultId))
+    .map((payload) => payload.series[0].sidecars.context.producer);
+  const cacheVerified =
+    blob.counts.reads > 0 &&
+    producers.includes('collector-before-repair') &&
+    producers.includes('collector-after-repair') &&
+    retainedProducers.includes('retained-before-repair') &&
+    retainedProducers.includes('retained-after-repair');
+  fs.writeFileSync(
+    path.join(output, 'blob-receipt.json'),
+    JSON.stringify({ counts: blob.counts, producers, retainedProducers, cacheVerified }, null, 2),
+  );
+  if (!cacheVerified) receipt.exitCode = 1;
+  fs.closeSync(browserLog);
+  fs.closeSync(serverLog);
+} finally {
+  try {
+    if (server?.pid) process.kill(-server.pid, 'SIGTERM');
+  } catch (error) {
+    if (!(error instanceof Error && 'code' in error && error.code === 'ESRCH'))
+      cleanupErrors.push(`Next: ${String(error)}`);
+  }
+  try {
+    if (dbStarted)
+      execFileSync(path.join(pgBin, 'pg_ctl'), ['-D', pgData, '-m', 'fast', 'stop'], {
+        stdio: 'pipe',
+      });
+  } catch (error) {
+    cleanupErrors.push(`PostgreSQL: ${String(error)}`);
+  }
+  try {
+    await blob.close();
+  } catch (error) {
+    cleanupErrors.push(`Blob fixture: ${String(error)}`);
+  }
+  if (cleanupErrors.length > 0) receipt.exitCode = 1;
+  fs.writeFileSync(path.join(output, 'receipt.json'), JSON.stringify(receipt, null, 2));
+}
+console.log(JSON.stringify(receipt));
+process.exitCode = receipt.exitCode;
diff --git a/packages/app/scripts/powerx-db-fixture.ts b/packages/app/scripts/powerx-db-fixture.ts
new file mode 100644
index 000000000..5ce4d65b1
--- /dev/null
+++ b/packages/app/scripts/powerx-db-fixture.ts
@@ -0,0 +1,256 @@
+/** Disposable localhost-only browser fixture. Telemetry always goes through production ingest. */
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { createAdminSql } from '@semianalysisai/inferencex-db/etl/db-utils';
+
+import { ingestGpuMetricsArtifact } from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
+import { runMigrations } from '@semianalysisai/inferencex-db/lib/migration-runner';
+
+const url = new URL(process.env.POWERX_ACCEPTANCE_DATABASE_URL ?? '');
+if (url.hostname !== '127.0.0.1' || url.pathname !== '/powerx_acceptance') {
+  throw new Error('This fixture only writes the disposable loopback powerx_acceptance database');
+}
+const sql = createAdminSql({ url: url.toString(), noSsl: true, max: 1, onnotice: () => {} });
+const output = process.env.POWERX_ACCEPTANCE_OUTPUT!;
+const artifactsDir = path.join(output, 'artifacts');
+const runId = 34716669498;
+const start = Date.UTC(2026, 8, 1, 20) / 1000;
+const suffixes = [
+  'dsv4_8k1k_fp4_sglang_tp2_conc16_b200-local_0',
+  'dsv4_8k1k_fp4_sglang_tp1_conc32_mi355x-local_0',
+  'dsv4_8k1k_fp4_sglang_tp4_conc64_b200-multinode_0',
+];
+const retainedName = 'gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc1_b200-retained_0';
+
+function write(name: string, file: string, contents: string) {
+  const target = path.join(artifactsDir, name, file);
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.writeFileSync(target, contents);
+}
+
+function ingest(index: number) {
+  const artifactName = `${index === 2 ? 'power_audit_' : 'gpu_metrics_'}${suffixes[index]}`;
+  return ingestGpuMetricsArtifact(sql, {
+    workflowRunId: 1,
+    artifact: { artifactName, artifactDir: path.join(artifactsDir, artifactName) },
+    benchmarkResultIds: [206885 + index],
+  });
+}
+
+async function ingestRetained(repaired: boolean) {
+  // CSV bytes are retained; sidecars deliberately inject a repair scenario.
+  write(
+    retainedName,
+    'gpu_metrics_context.json',
+    JSON.stringify({
+      timestamp_timezone: repaired ? '+02:00' : 'UTC',
+      producer: repaired ? 'retained-after-repair' : 'retained-before-repair',
+    }),
+  );
+  write(
+    retainedName,
+    'gpu_metrics_identity.csv',
+    [
+      'index,uuid,name',
+      ...Array.from(
+        { length: 8 },
+        (_, gpu) => `${gpu},GPU-fixture-${repaired ? 'corrected' : 'original'}-${gpu},NVIDIA B200`,
+      ),
+    ].join('\n'),
+  );
+  const result = await ingestGpuMetricsArtifact(sql, {
+    workflowRunId: 2,
+    artifact: { artifactName: retainedName, artifactDir: path.join(artifactsDir, retainedName) },
+    benchmarkResultIds: [206888, 206889],
+  });
+  return result;
+}
+
+async function seed() {
+  const fixtureDir = path.resolve(import.meta.dirname, '../../../docs/fixtures/powerx-reingest');
+  const retainedCsv = fs.readFileSync(path.join(fixtureDir, 'nvidia.csv'));
+  const retainedSha256 = createHash('sha256').update(retainedCsv).digest('hex');
+  const provenance = JSON.parse(fs.readFileSync(path.join(fixtureDir, 'provenance.json'), 'utf8'));
+  if (retainedSha256 !== provenance.fixture.sha256) throw new Error('Retained CSV hash mismatch');
+  await runMigrations(sql, path.resolve(import.meta.dirname, '../../db/migrations'));
+  await sql`INSERT INTO workflow_runs
+    (id, github_run_id, run_attempt, name, status, conclusion, head_branch, head_sha, html_url, created_at, run_started_at, date)
+    VALUES (1, ${runId}, 1, 'PowerX local acceptance', 'completed', 'success', 'main', 'local-fixture',
+      ${`https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${runId}`},
+      '2026-09-01T20:00:00Z', '2026-09-01T20:00:00Z', '2026-09-01')`;
+  for (let i = 0; i < 3; i++) {
+    const gpuCount = [2, 1, 4][i];
+    await sql`INSERT INTO configs
+      (id, model, hardware, framework, precision, spec_method, disagg, is_multinode,
+       prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+      VALUES (${i + 1}, 'dsv4', ${i === 1 ? 'mi355x' : 'b200'}, 'sglang', 'fp4', 'none', false,
+        ${i === 2}, ${gpuCount}, ${gpuCount}, ${gpuCount}, ${gpuCount})`;
+    await sql`INSERT INTO benchmark_results
+      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, image, metrics, power_audit)
+      VALUES (${206885 + i}, 1, ${i + 1}, 'single_turn', '2026-09-01', 8192, 1024, ${16 * 2 ** i},
+        'sglang:local-fixture', ${sql.json({
+          median_intvty: 90 - i * 20,
+          median_itl: 1 / (90 - i * 20),
+          median_e2el: 20,
+          median_ttft: 0.5,
+          tput_per_gpu: 1800,
+          output_tput_per_gpu: 200,
+          input_tput_per_gpu: 1600,
+          power_valid: 1,
+          power_metric_schema_version: 2,
+          avg_power_w: [185, 470, 595][i],
+          avg_total_gpu_power_w: [370, 470, 2380][i],
+          joules_per_output_token: [0.925, 2.35, 2.975][i],
+        })}, ${sql.json({
+          source: `power_validation_${suffixes[i]}.json`,
+          sample_count: gpuCount * 4,
+          window_start_unix: start + 2,
+          window_end_unix: start + 5,
+          observed_gpu_ids: Array.from({ length: gpuCount }, (_, gpu) => String(gpu)),
+        })})`;
+  }
+  const nvidia = `gpu_metrics_${suffixes[0]}`;
+  const nvidiaRows = Array.from({ length: 8 }, (_, sample) =>
+    [0, 1].map(
+      (gpu) =>
+        `2026/09/01 20:00:0${sample}, ${gpu}, ${100 + gpu * 100 + sample * 10} W, ${40 + sample}, 1500 MHz, 3996 MHz, ${sample * 10} %, 0 %`,
+    ),
+  ).flat();
+  write(
+    nvidia,
+    'gpu_metrics.csv',
+    [
+      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+      ...nvidiaRows,
+      nvidiaRows.at(-1),
+    ].join('\n'),
+  );
+  write(
+    nvidia,
+    'gpu_metrics_context.json',
+    JSON.stringify({ timestamp_timezone: 'UTC', producer: 'collector-before-repair' }),
+  );
+  write(
+    nvidia,
+    'gpu_metrics_identity.csv',
+    'index,uuid,name\n0,GPU-n0,NVIDIA B200\n1,GPU-n1,NVIDIA B200\n',
+  );
+  const amd = `gpu_metrics_${suffixes[1]}`;
+  write(
+    amd,
+    'gpu_metrics.csv',
+    [
+      'timestamp,gpu,gfx_activity,umc_activity,mm_activity,socket_power,gfx_voltage,soc_voltage,mem_voltage,gfx_0_clk,mem_0_clk,fclk_0_clk,socclk_0_clk,edge,hotspot,mem',
+      ...Array.from(
+        { length: 8 },
+        (_, sample) =>
+          `${start + sample},0,90,80,N/A,${400 + sample * 20},${sample < 2 ? 'N/A' : 850},900,1250,2402,2000,1250,39,55,78,60`,
+      ),
+    ].join('\n'),
+  );
+  const multi = `power_audit_${suffixes[2]}`;
+  write(
+    multi,
+    'LOGS/power/samples.csv',
+    [
+      'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+      ...Array.from({ length: 8 }, (_, sample) =>
+        ['host-a', 'host-b'].flatMap((host, h) =>
+          [0, 1].map(
+            (gpu) =>
+              `1,${start + sample},${sample},${host},${gpu},GPU-${host}-${gpu},${500 + h * 100 + gpu * 20 + sample * 10}`,
+          ),
+        ),
+      ).flat(),
+    ].join('\n'),
+  );
+  write(
+    multi,
+    'LOGS/power/manifest.json',
+    JSON.stringify({
+      producer: 'srt-slurm.dcgm-power',
+      expected_devices: ['host-a', 'host-b'].flatMap((hostname) =>
+        [0, 1].map((gpu_index) => ({ hostname, gpu_index })),
+      ),
+    }),
+  );
+  write(
+    multi,
+    `power_validation_${suffixes[2]}.json`,
+    JSON.stringify({
+      selected_window: { start_time_unix: start + 2, end_time_unix: start + 5 },
+    }),
+  );
+  const results = [];
+  for (let i = 0; i < 3; i++) results.push(await ingest(i));
+  // Benchmark rows are local linkage fixtures, not republished benchmark measurements.
+  await sql`INSERT INTO workflow_runs
+    (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+    VALUES (2, 34175132645, 1, 'Retained telemetry recovery fixture', 'completed', 'success',
+      '2026-09-08T07:20:19Z', '2026-09-08')`;
+  await sql`INSERT INTO configs
+    (id, model, hardware, framework, precision, spec_method, disagg,
+     prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (4, 'qwen3.5', 'b200', 'sglang', 'fp8', 'none', false, 8, 8, 8, 8)`;
+  await sql`INSERT INTO benchmark_results
+    (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    VALUES (206888, 2, 4, 'single_turn', '2026-09-08', 8192, 1024, 1, '{}'),
+           (206889, 2, 4, 'single_turn', '2026-09-08', 8192, 1024, 2, '{}')`;
+  write(retainedName, 'gpu_metrics.csv', retainedCsv.toString());
+  const retained = await ingestRetained(false);
+  await sql`REFRESH MATERIALIZED VIEW latest_benchmarks`;
+  fs.writeFileSync(
+    path.join(output, 'seed-receipt.json'),
+    JSON.stringify(
+      {
+        runId,
+        pointIds: [206885, 206886, 206887],
+        results,
+        retained: {
+          runId: 34175132645,
+          pointIds: [206888, 206889],
+          sha256: retainedSha256,
+          result: retained,
+        },
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+try {
+  if (process.argv[2] === 'seed') await seed();
+  else if (process.argv[2] === 'repair') {
+    write(
+      `gpu_metrics_${suffixes[0]}`,
+      'gpu_metrics_context.json',
+      JSON.stringify({
+        timestamp_timezone: '+02:00',
+        producer: 'collector-after-repair',
+      }),
+    );
+    const result = await ingest(0);
+    fs.writeFileSync(path.join(output, 'repair-receipt.json'), JSON.stringify(result, null, 2));
+    console.log(JSON.stringify(result));
+  } else if (process.argv[2] === 'retained-repair' || process.argv[2] === 'retained-reset') {
+    const result = await ingestRetained(process.argv[2] === 'retained-repair');
+    fs.writeFileSync(
+      path.join(output, `${process.argv[2]}-receipt.json`),
+      JSON.stringify(result, null, 2),
+    );
+    console.log(JSON.stringify(result));
+  } else if (process.argv[2] === 'unlink-retained-point') {
+    await sql`DELETE FROM benchmark_result_gpu_metrics WHERE benchmark_result_id = 206889`;
+  } else if (process.argv[2] === 'unavailable') {
+    await sql`ALTER TABLE gpu_metric_series RENAME TO gpu_metric_series_unavailable`;
+  } else if (process.argv[2] === 'restore') {
+    await sql`ALTER TABLE IF EXISTS gpu_metric_series_unavailable RENAME TO gpu_metric_series`;
+  } else
+    throw new Error(
+      'Expected seed, repair, retained-repair, retained-reset, unlink-retained-point, unavailable, or restore',
+    );
+} finally {
+  await sql.end();
+}
diff --git a/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts b/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
new file mode 100644
index 000000000..1fa3042da
--- /dev/null
+++ b/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
@@ -0,0 +1,246 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { gunzipSync } from 'node:zlib';
+import { PGlite } from '@electric-sql/pglite';
+import { NextRequest } from 'next/server';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ingestGpuMetricsArtifact } from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+import { getGpuMetricsPointRevision } from '@semianalysisai/inferencex-db/queries/gpu-metrics-revision';
+import { startPowerxBlobFixture } from '../../../../../scripts/powerx-blob-fixture';
+
+const connection = vi.hoisted(() => ({ getDb: vi.fn() }));
+vi.mock('@semianalysisai/inferencex-db/connection', () => connection);
+// The query, cache abstraction, Blob SDK, HTTP transport and ETL are real.
+import { GET } from './route';
+
+let db: PGlite;
+type Sql = Parameters<typeof ingestGpuMetricsArtifact>[0];
+let sql: Sql;
+let blob: Awaited<ReturnType<typeof startPowerxBlobFixture>>;
+let root: string;
+let sampleReads = 0;
+const artifactName = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+const artifact = () => ({ artifactName, artifactDir: root });
+
+function client(database: Pick<PGlite, 'query'>) {
+  return Object.assign(
+    async (strings: TemplateStringsArray, ...values: unknown[]) => {
+      const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+      if (query.includes('from gpu_metric_samples')) sampleReads++;
+      const result = await database.query<Record<string, unknown>>(query, values);
+      return result.rows;
+    },
+    { json: JSON.stringify, array: (value: unknown) => value },
+  );
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+    await db.exec(
+      fs.readFileSync(new URL(`../../../../../../db/migrations/${name}`, import.meta.url), 'utf8'),
+    );
+  }
+  await db.exec(`ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+    VALUES (1, 34557177019, 1, 'Run Sweep', 'completed', 'success', '2026-09-11', '2026-09-11');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 4, 4, 4, 4);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+      (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}');`);
+  sql = Object.assign(client(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(client(tx) as unknown as Sql)),
+  }) as unknown as Sql;
+  connection.getDb.mockReturnValue(sql);
+  blob = await startPowerxBlobFixture();
+  for (const [key, value] of Object.entries(blob.env)) vi.stubEnv(key, value);
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-cache-recovery-'));
+  // Retained run 34175132645, attempt 1; source and excerpt hashes live beside the fixture.
+  const csv = fs.readFileSync(
+    new URL('../../../../../../../docs/fixtures/powerx-reingest/nvidia.csv', import.meta.url),
+  );
+  expect(createHash('sha256').update(csv).digest('hex')).toBe(
+    '833cf864da4618579deeeda89b3ddde6dbf8b7b32b7877fda643f18411ee3481',
+  );
+  fs.writeFileSync(path.join(root, 'gpu_metrics.csv'), csv);
+}, 20_000);
+
+afterAll(async () => {
+  vi.unstubAllEnvs();
+  await blob?.close();
+  await db?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+beforeEach(async () => {
+  await db.exec(
+    'TRUNCATE gpu_metric_series RESTART IDENTITY CASCADE; UPDATE benchmark_results SET power_audit = null;',
+  );
+  blob.objects.clear();
+  Object.assign(blob.counts, { reads: 0, writes: 0, failedWrites: 0 });
+  sampleReads = 0;
+  // Injected test sidecars: the retained source does not establish its timezone or identity.
+  fs.writeFileSync(
+    path.join(root, 'gpu_metrics_context.json'),
+    JSON.stringify({ timestamp_timezone: 'UTC' }),
+  );
+  fs.writeFileSync(
+    path.join(root, 'gpu_metrics_identity.csv'),
+    'index, uuid, name\n0, GPU-old, NVIDIA B200\n',
+  );
+});
+
+async function request(id: number) {
+  const response = await GET(new NextRequest(`http://localhost/api/v1/gpu-metrics-point?id=${id}`));
+  const bytes = Buffer.from(await response.arrayBuffer());
+  const body =
+    response.headers.get('content-encoding') === 'gzip'
+      ? gunzipSync(bytes).toString()
+      : bytes.toString();
+  return { response, body: JSON.parse(body) };
+}
+
+describe('artifact → local DB → real Blob cache → point API recovery', () => {
+  it('requires live revision checks for successful and missing responses', async () => {
+    const missing = await request(10);
+    expect(missing.response.headers.get('cache-control')).toBe('no-store');
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10],
+    });
+    const present = await request(10);
+    expect(present.response.headers.get('cache-control')).toBe('no-store');
+  });
+  it('refreshes missing points, shared links, timezone and identity repairs without purging', async () => {
+    const missing = await request(10);
+    expect(missing.response.status).toBe(404);
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10],
+    });
+    const old = await request(10);
+    expect(old.response.status).toBe(200);
+    const originalSeries: GpuMetricSeries = old.body.series[0];
+    expect(originalSeries).toMatchObject({
+      sampleCount: 24,
+      gpuCount: 8,
+      startedAt: '2026-09-08T07:20:19.279Z',
+      endedAt: '2026-09-08T07:20:21.279Z',
+    });
+    expect(originalSeries.data).toHaveLength(24);
+    expect(originalSeries.data.filter((row) => row.index === 0).map((row) => row.power)).toEqual([
+      380.42, 336.61, 337.18,
+    ]);
+    expect(blob.objects.size).toBe(1);
+    const beforeHit = blob.counts.reads;
+    const beforeSampleReads = sampleReads;
+    const cached = await request(10);
+    expect(cached.body).toEqual(old.body);
+    expect(blob.counts.reads).toBe(beforeHit + 1);
+    expect(sampleReads).toBe(beforeSampleReads);
+
+    const unlinked = await request(11);
+    expect(unlinked.response.status).toBe(404);
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [11],
+    });
+    for (const id of [10, 11]) {
+      const linked = await request(id);
+      expect(linked.body.series[0].benchmarkResultIds).toEqual([10, 11]);
+    }
+    const oldRevision = await getGpuMetricsPointRevision(client(db), 10);
+    fs.writeFileSync(
+      path.join(root, 'gpu_metrics_context.json'),
+      JSON.stringify({ timestamp_timezone: '+08:00' }),
+    );
+    fs.writeFileSync(
+      path.join(root, 'gpu_metrics_identity.csv'),
+      'index, uuid, name\n0, GPU-corrected, NVIDIA B200\n',
+    );
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10, 11],
+    });
+    expect(await getGpuMetricsPointRevision(client(db), 10)).not.toBe(oldRevision);
+    for (const id of [10, 11]) {
+      const repaired = await request(id);
+      expect(repaired.body.series[0].data[0].timestamp).toBe('2026-09-07T23:20:19.279Z');
+      expect(repaired.body.series[0].sampleCount).toBe(24);
+      expect(JSON.stringify(repaired.body.series[0].sidecars)).toContain('GPU-corrected');
+    }
+    const revision = await getGpuMetricsPointRevision(client(db), 10);
+    const writes = blob.counts.writes;
+    const unchanged = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10, 11],
+    });
+    expect(unchanged.seriesSkipped).toBe(1);
+    expect(await getGpuMetricsPointRevision(client(db), 10)).toBe(revision);
+    await request(10);
+    expect(blob.counts.writes).toBe(writes);
+    const samples = await db.query('select count(*)::int as n from gpu_metric_samples');
+    expect(samples.rows).toEqual([{ n: 24 }]);
+  });
+
+  it('logs failed cache writes, serves repaired data, and retries on the next request', async () => {
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10],
+    });
+    await request(10);
+    await db.exec(
+      `UPDATE benchmark_results SET power_audit = '{"source":"repaired"}' WHERE id = 10`,
+    );
+    blob.rejectWrites(true);
+    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    try {
+      const fresh = await request(10);
+      expect(fresh.response.status).toBe(200);
+      expect(fresh.body.series[0].powerAudits).toEqual([{ source: 'repaired' }]);
+      expect(blob.counts.failedWrites).toBeGreaterThan(0);
+      expect(warning).toHaveBeenCalledWith(expect.stringContaining('serving uncached result'));
+      blob.rejectWrites(false);
+      const writes = blob.counts.writes;
+      const recovered = await request(10);
+      expect(recovered.body).toEqual(fresh.body);
+      expect(blob.counts.writes).toBe(writes + 1);
+      await request(10);
+      expect(blob.counts.writes).toBe(writes + 1);
+    } finally {
+      warning.mockRestore();
+      blob.rejectWrites(false);
+    }
+  });
+
+  it('does not serve a cached success when the revision DB read fails', async () => {
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10],
+    });
+    await request(10);
+    connection.getDb.mockImplementationOnce(() => {
+      throw new Error('local DB unavailable');
+    });
+    const log = vi.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      const failed = await request(10);
+      expect(failed.response.status).toBe(500);
+    } finally {
+      log.mockRestore();
+    }
+  });
+});
diff --git a/packages/app/src/app/api/v1/gpu-metrics-point/route.ts b/packages/app/src/app/api/v1/gpu-metrics-point/route.ts
index f9d04f1df..6b995ecb2 100644
--- a/packages/app/src/app/api/v1/gpu-metrics-point/route.ts
+++ b/packages/app/src/app/api/v1/gpu-metrics-point/route.ts
@@ -1,4 +1,6 @@
 import { getDb } from '@semianalysisai/inferencex-db/connection';
+import { getGpuMetricsPointRevision } from '@semianalysisai/inferencex-db/queries/gpu-metrics-revision';
+import type { NextRequest } from 'next/server';
 import {
   getGpuMetricsForPoint,
   type GpuMetricsPointPayload,
@@ -10,16 +12,11 @@ import { idQueryRoute } from '../id-routes';
 
 export const dynamic = 'force-dynamic';
 
-/**
- * Blob-cache namespace. Stored series are immutable per (run, artifact, CSV
- * hash), so the payload for a point only changes when the digest schema does;
- * bump the suffix alongside any change to the row shape in
- * `queries/gpu-metrics.ts`.
- */
-export const CACHE_KEY_PREFIX = 'gpu-metrics-point-v1';
+export const CACHE_KEY_PREFIX = 'gpu-metrics-point-v2';
 
 const getCachedGpuMetricsForPoint = cachedQuery(
-  (id: number): Promise<GpuMetricsPointPayload | null> => getGpuMetricsForPoint(getDb(), id),
+  (id: number, _revision: string): Promise<GpuMetricsPointPayload | null> =>
+    getGpuMetricsForPoint(getDb(), id),
   CACHE_KEY_PREFIX,
   { blobOnly: true },
 );
@@ -33,7 +30,17 @@ const getCachedGpuMetricsForPoint = cachedQuery(
  * run predates migration 016 and the artifacts have expired, or the job
  * uploaded no gpu_metrics artifact).
  */
-export const GET = idQueryRoute({
+const handleGet = idQueryRoute({
   logLabel: 'gpu metrics point',
-  fetch: getCachedGpuMetricsForPoint,
+  fetch: async (id) => {
+    const revision = await getGpuMetricsPointRevision(getDb(), id);
+    return revision === null ? null : getCachedGpuMetricsForPoint(id, revision);
+  },
 });
+
+export async function GET(request: NextRequest): Promise<Response> {
+  const response = await handleGet(request);
+  // The live revision check must run even when a point used to be missing.
+  response.headers.set('Cache-Control', 'no-store');
+  return response;
+}
diff --git a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
index b3cbcff16..ec039bc6f 100644
--- a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
@@ -179,6 +179,7 @@ export default function GpuMetricsDisplay() {
     gcTime: 0,
     retry: false,
     refetchOnMount: 'always',
+    refetchOnWindowFocus: true,
   });
   const artifacts = query.data?.artifacts ?? [];
   const runInfo = query.data?.runInfo ?? null;
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index 001c4c346..8db61155d 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -766,7 +766,8 @@ export default function PowerTimeline({
     queries: fetchedRequests.map((request) => ({
       queryKey: ['power-timeline', request.runId, request.prefix, request.sources] as const,
       queryFn: ({ signal }: { signal: AbortSignal }) => fetchPowerSeries(request, signal),
-      staleTime: 5 * 60_000,
+      staleTime: 0,
+      refetchOnWindowFocus: true,
       retry: 1,
     })),
   });
diff --git a/packages/app/src/hooks/api/benchmark-id-query.ts b/packages/app/src/hooks/api/benchmark-id-query.ts
index d1540f1d8..0f9adf95b 100644
--- a/packages/app/src/hooks/api/benchmark-id-query.ts
+++ b/packages/app/src/hooks/api/benchmark-id-query.ts
@@ -49,6 +49,7 @@ export function useByIdQuery<T, TSelected = T>(
   id: number | null,
   enabled: boolean,
   select?: (data: T) => TSelected,
+  freshness?: { staleTime: number; refetchOnWindowFocus: boolean },
 ) {
   const selectNullable = useCallback(
     (data: T | null): TSelected | null =>
@@ -67,6 +68,7 @@ export function useByIdQuery<T, TSelected = T>(
     },
     enabled,
     staleTime: STALE_TIME_MS,
+    ...freshness,
     // TanStack Query re-runs select when its function identity changes. Keep
     // this wrapper stable so decoding a large compact payload happens only
     // when the cached wire data or the caller's selector actually changes.
diff --git a/packages/app/src/hooks/api/use-gpu-metrics-point.ts b/packages/app/src/hooks/api/use-gpu-metrics-point.ts
index 12c023331..53ae1dbe8 100644
--- a/packages/app/src/hooks/api/use-gpu-metrics-point.ts
+++ b/packages/app/src/hooks/api/use-gpu-metrics-point.ts
@@ -14,5 +14,11 @@ export type { GpuMetricsPointPayload, GpuMetricSeries, GpuMetricStatRow };
  * the whole job (hundreds of KB), so it is not paid for on every page load.
  */
 export function useGpuMetricsPoint(id: number | null, enabled = false) {
-  return useByIdQuery<GpuMetricsPointPayload>('gpu-metrics-point', id, enabled && Boolean(id));
+  return useByIdQuery<GpuMetricsPointPayload>(
+    'gpu-metrics-point',
+    id,
+    enabled && Boolean(id),
+    undefined,
+    { staleTime: 0, refetchOnWindowFocus: true },
+  );
 }
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index cb4070654..1d811bb85 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -512,10 +512,10 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'page-bff',
     exclusionReason: {
-      en: 'Agentic point-detail BFF returning the PowerX telemetry series and per-GPU digest linked to one benchmark point; coupled to the PowerX tab implementation.',
-      zh: '智能体数据点详情页专用 BFF；返回与单个基准测试数据点关联的 PowerX telemetry 序列及每 GPU 统计摘要，与 PowerX 标签页实现紧密耦合。',
+      en: 'Point-detail BFF returning linked PowerX telemetry series, per-GPU digests and retained validation/audit metadata. Every read checks a live DB revision before using the Blob payload cache; responses use no-store, missing data returns 404, and database failures remain errors. Re-ingest and shared-link changes do not require manual cache purges. Coupled to the PowerX tab implementation.',
+      zh: '数据点详情页专用 BFF；返回关联的 PowerX 遥测序列、每 GPU 统计摘要及保留的验证与审计元数据。每次读取先核对数据库版本再使用 Blob 缓存；响应使用 no-store，数据缺失返回 404，数据库故障仍作为错误返回。重新入库及共享链接变化无需手动清理缓存。与 PowerX 标签页实现紧密耦合。',
     },
-    sourceSha256: '3929581f54058183344d59a8f6127db3ef1c8487cad26c73faa93b00fe75a82d',
+    sourceSha256: 'c04a01fcd8e1cb4cb7101a46a0ba44b227f2696819c499bcc93be8ee7a8ce255',
   },
   {
     source: 'src/app/api/v1/request-chart-data/route.ts',
diff --git a/packages/db/src/backfill-gpu-metrics.ts b/packages/db/src/backfill-gpu-metrics.ts
index 5141256d8..ac20e759e 100644
--- a/packages/db/src/backfill-gpu-metrics.ts
+++ b/packages/db/src/backfill-gpu-metrics.ts
@@ -311,7 +311,7 @@ async function main(): Promise<void> {
       `${missingRuns} run(s) without pairs, ${goneRuns} run(s) gone from GitHub, ` +
       `${artifactFailures} failed artifact(s), ${runFailures} failed run(s) ===`,
   );
-  console.log('  Invalidate API cache after the backfill: bun run admin:cache:invalidate');
+  console.log('  Point telemetry reads use the stored revision; no manual cache purge is needed.');
   if (artifactFailures > 0 || runFailures > 0) process.exitCode = 1;
 }
 
diff --git a/packages/db/src/etl/gpu-metrics-ingest.test.ts b/packages/db/src/etl/gpu-metrics-ingest.test.ts
index 43298799b..c8f593d48 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.test.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.test.ts
@@ -25,6 +25,18 @@ function queryClient(database: Pick<PGlite, 'query'>) {
   });
 }
 
+async function storedSeries(seriesId: number) {
+  return {
+    metadata: await sql`select * from gpu_metric_series where id = ${seriesId}`,
+    samples: await sql`select * from gpu_metric_samples where series_id = ${seriesId}
+      order by sampled_at, gpu_index`,
+    stats: await sql`select * from gpu_metric_gpu_stats where series_id = ${seriesId}
+      order by gpu_index, metric`,
+    links: await sql`select * from benchmark_result_gpu_metrics where series_id = ${seriesId}
+      order by benchmark_result_id`,
+  };
+}
+
 beforeAll(async () => {
   db = await PGlite.create();
   for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
@@ -346,6 +358,115 @@ describe('ingestGpuMetricsArtifact', () => {
     expect(stat!.max_value).toBe(950);
   });
 
+  it('rolls back a replacement when point linking fails and retries without losing existing links', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    const seriesId = first.seriesIds[0]!;
+    const before = await storedSeries(seriesId);
+    fs.writeFileSync(
+      path.join(artifact.artifactDir, 'gpu_metrics.csv'),
+      `${NVIDIA_CSV}\n2026/09/11 04:19:43.990, 0, 950.00 W, 65, 1965 MHz, 3996 MHz, 99 %, 75 %`,
+    );
+    fs.writeFileSync(
+      path.join(artifact.artifactDir, 'gpu_metrics_context.json'),
+      JSON.stringify({ timestamp_timezone: '+02:00' }),
+    );
+
+    // Point links are written last, after replacement metadata, samples and stats.
+    await expect(
+      ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact,
+        benchmarkResultIds: [11, 999],
+      }),
+    ).rejects.toMatchObject({ code: '23503' });
+    expect(await storedSeries(seriesId)).toEqual(before);
+
+    const recovered = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [11],
+    });
+    expect(recovered).toEqual({ seriesIds: [seriesId], samplesInserted: 5, seriesSkipped: 0 });
+    const after = await storedSeries(seriesId);
+    expect(after.metadata).toMatchObject([
+      { sample_count: 5, sidecars: { context: { timestamp_timezone: '+02:00' } } },
+    ]);
+    expect(after.metadata[0]!.csv_sha256).not.toBe(before.metadata[0]!.csv_sha256);
+    expect(after.samples).toHaveLength(5);
+    expect(new Date(after.samples[0]!.sampled_at).toISOString()).toBe('2026-09-11T02:19:41.982Z');
+    expect(
+      after.stats.find((row) => row.gpu_index === 0 && row.metric === 'power_w'),
+    ).toMatchObject({
+      sample_count: 3,
+      max_value: 950,
+    });
+    expect(after.links.map((row) => Number(row.benchmark_result_id))).toEqual([10, 11]);
+  });
+
+  it('retries a partial artifact after a later series fails without rewriting its committed series', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    const seriesId = first.seriesIds[0]!;
+    const secondFile = path.join(artifact.artifactDir, 'host-b', 'gpu_metrics.csv');
+    fs.mkdirSync(path.dirname(secondFile));
+    // Both CSVs parse, but the second series exceeds the database smallint range.
+    fs.writeFileSync(secondFile, NVIDIA_CSV.replaceAll(', 0,', ', 999999,'));
+    await expect(
+      ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact,
+        benchmarkResultIds: [11],
+      }),
+    ).rejects.toMatchObject({ code: '22003' });
+    expect(await sql`select file_name from gpu_metric_series order by file_name`).toEqual([
+      { file_name: 'gpu_metrics.csv' },
+    ]);
+    const committed = await storedSeries(seriesId);
+    expect(committed.samples).toHaveLength(4);
+    expect(committed.stats).toHaveLength(12);
+    expect(committed.links.map((row) => Number(row.benchmark_result_id))).toEqual([10, 11]);
+
+    fs.writeFileSync(secondFile, NVIDIA_CSV);
+    const recovered = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [11],
+    });
+    expect(recovered.seriesIds).toHaveLength(2);
+    expect(recovered.seriesIds[0]).toBe(seriesId);
+    expect(recovered.samplesInserted).toBe(4);
+    expect(recovered.seriesSkipped).toBe(1);
+    expect(await storedSeries(seriesId)).toEqual(committed);
+    const second = await storedSeries(recovered.seriesIds[1]!);
+    expect(second.samples).toHaveLength(4);
+    expect(second.stats).toHaveLength(12);
+    expect(second.links.map((row) => Number(row.benchmark_result_id))).toEqual([11]);
+    expect(await sql`select count(*)::int as n from gpu_metric_series`).toEqual([{ n: 2 }]);
+    expect(await sql`select count(*)::int as n from gpu_metric_samples`).toEqual([{ n: 8 }]);
+
+    const replay = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [11],
+    });
+    expect(replay).toEqual({
+      seriesIds: recovered.seriesIds,
+      samplesInserted: 0,
+      seriesSkipped: 2,
+    });
+    expect(await storedSeries(seriesId)).toEqual(committed);
+    expect(await storedSeries(recovered.seriesIds[1]!)).toEqual(second);
+  });
+
   it('uses the first reading per GPU/timestamp for stored samples, metadata, and digest', async () => {
     const csv = [
       NVIDIA_CSV.split('\n')[0],
diff --git a/packages/db/src/queries/gpu-metrics-revision.ts b/packages/db/src/queries/gpu-metrics-revision.ts
new file mode 100644
index 000000000..d80711129
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics-revision.ts
@@ -0,0 +1,24 @@
+import type { DbClient } from '../connection';
+
+/** Re-ingest and shared-link changes must bypass older point payloads. */
+export async function getGpuMetricsPointRevision(
+  sql: DbClient,
+  benchmarkResultId: number,
+): Promise<string | null> {
+  const [row] = await sql`
+    select md5(jsonb_agg(jsonb_build_array(
+      s.id, s.ingested_at, s.csv_sha256, s.sample_count, s.sidecars,
+      (
+        select jsonb_agg(jsonb_build_array(l.benchmark_result_id, b.power_audit)
+          order by l.benchmark_result_id)
+        from benchmark_result_gpu_metrics l
+        join benchmark_results b on b.id = l.benchmark_result_id
+        where l.series_id = s.id
+      )
+    ) order by s.id)::text) as revision
+    from benchmark_result_gpu_metrics link
+    join gpu_metric_series s on s.id = link.series_id
+    where link.benchmark_result_id = ${benchmarkResultId}
+  `;
+  return typeof row?.revision === 'string' ? row.revision : null;
+}

From 1d882e89298fb9aea9b2f61178217b47cc9345d4 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 22 Sep 2026 10:20:03 -0700
Subject: [PATCH 027/103] fix: reconcile PowerX telemetry coverage per point
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：扩展现有 run/attempt 发布回执，独立追踪预期点、产物、序列、样本、关联与 API 可读性；保留未知分母、失败身份和定向恢复动作，包含 CI、backfill、幂等恢复及历史身份修复的测试和操作说明。
---
 docs/powerx-persistence-recovery.md           | 137 ++-
 packages/db/src/backfill-gpu-metrics.test.ts  | 797 +++++++++++++++++-
 packages/db/src/backfill-gpu-metrics.ts       | 251 +++++-
 packages/db/src/etl/power-publication.ts      |   3 +
 packages/db/src/etl/telemetry-receipt.test.ts | 739 ++++++++++++++++
 packages/db/src/etl/telemetry-receipt.ts      | 447 ++++++++++
 packages/db/src/ingest-ci-run.test.ts         |  48 ++
 packages/db/src/ingest-ci-run.ts              |  89 +-
 packages/db/src/ingest-ci-telemetry.test.ts   | 219 +++++
 .../src/lib/benchmark-result-lookup.test.ts   |  20 +
 .../db/src/lib/benchmark-result-lookup.ts     |  17 +-
 .../db/src/lib/gpu-metrics-backfill.test.ts   | 163 +++-
 packages/db/src/lib/gpu-metrics-backfill.ts   |  51 +-
 packages/db/src/prepare-ci-artifacts.test.ts  |  17 +
 packages/db/src/verify-power-publication.ts   |  15 +
 15 files changed, 2955 insertions(+), 58 deletions(-)
 create mode 100644 packages/db/src/etl/telemetry-receipt.test.ts
 create mode 100644 packages/db/src/etl/telemetry-receipt.ts
 create mode 100644 packages/db/src/ingest-ci-telemetry.test.ts

diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
index 2973b8a77..9225af2fb 100644
--- a/docs/powerx-persistence-recovery.md
+++ b/docs/powerx-persistence-recovery.md
@@ -72,6 +72,90 @@ retried on the next read. A database failure remains an API error even if an old
 Old cache generations remain until the existing prefix cleanup runs; repair does not require
 a manual PowerX cache purge. General benchmark cache invalidation still follows normal CI.
 
+## Coverage receipts
+
+The existing `power-publication.json` gains an optional `telemetry` receipt, keyed by run,
+attempt and stable benchmark-point identity. Its stages distinguish expected benchmark
+attachments, produced artifacts, stored series/samples, point links and actual API readback.
+Normal CI builds expectations from benchmark rows before telemetry discovery. Backfill
+also inspects benchmark siblings whose telemetry artifact is absent. Unreadable benchmark
+siblings are recorded in `expectationErrors`; known identities still proceed independently.
+
+`plannedPointCount: null` explicitly means the full planned sweep is unknown. Attachment
+coverage over available benchmark rows does **not** prove full sweep coverage. Point,
+artifact, series and sample counts are separate: a bundle can contain multiple host series
+and multiple points can share those series. Receipt entries list missing identities,
+reasons, and exact run/attempt/artifact recovery targets. DB success leaves API status
+`unknown`; only `verify-power-publication.ts` advances it after an actual HTTP read.
+Telemetry failures remain isolated from benchmark publication failure policy.
+
+The expectation boundary is the successfully mapped, non-purged benchmark rows
+selected for ingestion, plus persisted benchmark identities recovered by the
+receipt query. It is not every raw result or every planned job. Mapping/preflight
+errors remain in the existing ingest diagnostics. Unreadable/unmappable benchmark
+rows and failed config resolution make `expectedSource` unknown while retaining
+known point identities; intentionally failed or purged benchmarks remain excluded.
+The telemetry receipt does not
+reconstruct the planned matrix, even when a separate required-power manifest is
+available; `plannedPointCount` stays null. An unreadable backfill benchmark sibling
+sets `expectationErrors` and makes `expectedPoints` unknown, including when its
+telemetry pair exists.
+Backfill preserves mapped points alongside per-row diagnostics for unmappable rows;
+multiple row errors in one benchmark artifact count as one failed artifact. Every
+mapped point in a correction must match a persisted benchmark before telemetry
+ingest can clear that artifact's recovery failure. An uploaded correction with an
+unmatched point is not a successful repair, even when older data remains readable.
+Later refreshes retain unresolved expectation errors until that exact sibling's
+identities can actually be recovered; an expired sibling cannot disappear from
+the unknown denominator.
+This also applies on the first receipt: a selected expired benchmark sibling records
+an expectation error without attempting a download. Superseded retries and unrelated
+targets remain excluded by the existing logical-name and artifact filters.
+Known failed benchmark rows remain excluded, matching normal CI.
+
+Historical backfill retains the resolver's exact-first, unique-fallback offload matching.
+A proven fallback uses the persisted point's offload identity before receipt counting
+and recovery checks, including benchmark siblings whose telemetry is absent. Repeating
+the recovery removes only the corresponding old null-ID phantom in that artifact's
+scope; real on/off points remain distinct. Conflicting artifact observations or prior
+artifact scope stay visible with an unknown denominator rather than overwriting errors.
+
+Normal CI deliberately retains successful artifacts from earlier attempts of the
+same run/head for `rerun-failed`. Receipt `runAttempt` identifies the persisted
+ingest cohort, not the collection attempt of every artifact. Per-artifact collection
+attempt is unknown unless independently retained in source provenance. Do not
+filter the normal artifact plan to the latest attempt and silently drop successful
+points. Explicit `--download .../attempts/N` rejects a different current attempt;
+targeted GitHub telemetry recovery uses its stricter current-attempt filter below.
+
+An empty or wholly unreadable telemetry correction is an ingest failure, even when
+older stored samples remain readable. A targeted recovery retains unresolved
+`recoveryError` and `recoveryArtifactNames` from other artifacts. Sequential successful
+repairs remove only their own artifact names. Older receipts with an unscoped recovery
+error require a successful full-run refresh to clear that error; repairing a different
+artifact cannot establish recovery. Retained error text describes the failed attempts;
+the remaining artifact names identify the outstanding scope.
+
+| Receipt reason       | Targeted action                                                                                                                                                     |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `artifact_missing`   | Recover the exact listed sibling from the same source provenance; use retained local bytes if GitHub no longer has that attempt. Do not substitute a newer attempt. |
+| `ingest_failed`      | Inspect the recorded error, correct the exact artifact or sidecar, then re-ingest it. Empty/unparseable CSVs do not count as a successful correction.               |
+| `point_link_missing` | Re-ingest the named unchanged artifact for the recorded run/attempt. Existing series/samples remain idempotent and the missing link is restored.                    |
+| `expectationErrors`  | Recover the named benchmark sibling first so its point identities can be enumerated; successful telemetry downloads alone do not establish the denominator.         |
+
+Apply the run/attempt/artifact selectors in each point's `recovery` object to the
+commands below, merge the same receipt, then run the HTTP verifier. A missing explicit
+target or deleted GitHub run reports failure. Neither a successful command nor the
+benchmark-level `matched` status establishes telemetry completeness: inspect the
+separate counts, unknowns and outstanding errors.
+
+The stored inventory distinguishes `storage.status` complete/incomplete/unknown. Missing
+host files and mismatched sample counts remain gaps even when the surviving payload can be
+read. `apiReadablePoints` counts actual successful HTTP reads; `apiCompletePoints` additionally
+requires the retained artifact inventory and every point link. Legacy rows without an inventory
+remain unknown until recovered; they do not silently count as complete. A failed correction or
+receipt recovery error also blocks the complete count, even when older data remains readable.
+
 ## Full-record statistics
 
 The point detail, run explorer and public `/api/v1/views/gpu-metrics` projection use the
@@ -105,7 +189,7 @@ bun run fmt
 bun run check:typography
 bun run --cwd packages/app test:unit src/app/api/v1/gpu-metrics-point/route.test.ts
 bun run --cwd packages/app test:unit src/app/api/v1/views/gpu-metrics/route.test.ts
-bun run --cwd packages/db test:unit src/queries/gpu-metrics-timeline.test.ts
+bun run --cwd packages/db test:unit src/queries/gpu-metrics-timeline.test.ts src/etl/telemetry-receipt.test.ts
 bun run --cwd packages/app test:e2e:component --spec cypress/component/gpu-stats-table.cy.tsx
 ```
 
@@ -122,3 +206,54 @@ POWERX_PG_BIN=/path/to/postgresql/bin bun scripts/powerx-db-acceptance.ts /absol
 
 The ordinary fixture-backed smoke command remains `bun run test:e2e` with an
 `E2E_FIXTURES=1` dev server. The full cross-browser matrix remains the repository CI gate.
+
+## Deployment and targeted data repair (operator review required)
+
+1. Deploy the reviewed application and ingest/backfill code together. Verify migrations
+   `015_power_provenance.sql` and `016_gpu_metrics.sql` already exist on the target. This
+   change adds no migration. Do not run migrations or backfill against production merely
+   to inspect a receipt.
+2. Retain the original publication receipt, exact artifact bytes, sidecars, source run and
+   attempt. Snapshot the target run's telemetry series, samples, digests and point links
+   before correction. Check that the app reads the same database that ingest writes.
+3. Inspect a bounded candidate with the existing command, using explicitly selected
+   target credentials in the operator environment:
+
+   ```sh
+   bun run admin:db:backfill-gpu-metrics --run RUN_ID --attempt ATTEMPT --dry-run
+   ```
+
+4. Once authorized, repair only the named artifact and merge the existing receipt:
+
+   ```sh
+   bun run admin:db:backfill-gpu-metrics --run RUN_ID --attempt ATTEMPT \
+     --artifact EXACT_ARTIFACT_NAME --receipt /path/power-publication.json --yes
+   bun packages/db/src/verify-power-publication.ts /path/power-publication.json https://TARGET_ORIGIN
+   ```
+
+   An explicit `--run` is rechecked even if some series already exist. Unchanged inputs
+   are no-ops. The GitHub backfill route accepts only the current source attempt and
+   filters out earlier attempt artifacts; it refuses a mismatched historical attempt.
+   Expired or older-attempt bytes require retained artifacts through the existing local
+   ingest path (`INGEST_ARTIFACTS_PATH` and exact source-run metadata), after operator
+   review. Never substitute another attempt's bytes. A local sidecar correction must be
+   applied to the retained artifact tree; re-downloading unchanged GitHub bytes cannot fix it.
+   The local ingest entry takes `INGEST_RUN_ID`, `INGEST_RUN_ATTEMPT`,
+   `INGEST_REPO=SemiAnalysisAI/InferenceX`, `INGEST_ARTIFACTS_PATH` and
+   `POWER_PUBLICATION_MANIFEST`, then `bun run admin:db:ingest:ci`. It also requires
+   `GITHUB_TOKEN` and the reviewed `DATABASE_WRITE_URL`. Inspect any retained
+   `reused-ingest-metadata/reuse_source_run.json` first: it overrides run/attempt identity.
+
+5. Inspect per-point receipt gaps and both point/Timeline APIs, then refocus/reload the
+   browser. Check expected hosts, GPU IDs, timestamps and digest values. Ingest success
+   alone is insufficient. No telemetry cache purge is required.
+
+For rollback, revert application code only if needed; additive sidecars/receipt fields are
+compatible with the previous schema. Reverting application code restores its old cache
+behavior, so the existing cache invalidation procedure is required in that case. To undo
+a data correction, re-ingest the retained original bytes/sidecars against the exact same
+run/attempt/point identities, or restore only the snapshotted rows in a reviewed transaction.
+Verify links and counts again. Do not delete a shared series to repair one point.
+
+Local tests do not establish deployment, production repair, expired-artifact recoverability,
+or complete published PowerX coverage.
diff --git a/packages/db/src/backfill-gpu-metrics.test.ts b/packages/db/src/backfill-gpu-metrics.test.ts
index e54fe1d78..94a61a820 100644
--- a/packages/db/src/backfill-gpu-metrics.test.ts
+++ b/packages/db/src/backfill-gpu-metrics.test.ts
@@ -1,21 +1,35 @@
 /**
- * Candidate-selection tests for the gpu_metrics backfill CLI.
+ * Candidate-selection and real persistence tests for the gpu_metrics backfill CLI.
  *
  * The script owns its `sql` handle and calls `runBackfillMain` at import time,
  * so the seam here is the module boundary: `createAdminSql` is redirected at a
  * PGlite database that has the real migrations applied, `runBackfillMain`
  * captures `main` instead of running it, and `listRunArtifacts` records which
- * runs the CLI actually reached. Every candidate query runs for real; nothing
- * touches GitHub.
+ * runs the CLI actually reached. Downloads copy local fixture directories;
+ * mapping, ingest transactions and receipt queries run for real without GitHub.
  */
 
 import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 
 import { PGlite } from '@electric-sql/pglite';
 import type postgres from 'postgres';
-import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import type * as DbUtilsModule from './etl/db-utils';
+import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest';
+import {
+  benchmarkPublicationIdentity,
+  type PowerPublicationManifest,
+} from './etl/power-publication';
+import {
+  readTelemetryReceipt,
+  verifyTelemetryApi,
+  type TelemetryReceipt,
+} from './etl/telemetry-receipt';
+import { NonRetryableArtifactError } from './lib/artifact-retry';
+import { readMappedBenchmarkRows } from './lib/benchmark-result-lookup';
 import type * as BackfillRunnerModule from './lib/backfill-runner';
 import type * as GithubArtifactsModule from './lib/github-artifacts';
 import type { ArtifactMeta } from './lib/github-artifacts';
@@ -25,9 +39,16 @@ let db: PGlite;
 let sql: Sql;
 let main: () => Promise<void>;
 const listedRunIds: string[] = [];
+const retainedArtifacts = new Map<string, ArtifactMeta[]>();
+const artifactSources = new Map<string, string>();
+const downloadFailures = new Set<string>();
+const downloadedNames: string[] = [];
+const roots: string[] = [];
 /** GitHub run ids whose artifact listing should 404 (the run was deleted). */
 const goneRunIds = new Set<string>();
+const latestRunAttempts = new Map<string, number>();
 const originalArgv = process.argv;
+const originalExitCode = process.exitCode;
 
 vi.mock('./etl/db-utils.js', async (importOriginal) => ({
   ...(await importOriginal<typeof DbUtilsModule>()),
@@ -38,12 +59,32 @@ vi.mock('./lib/github-artifacts.js', async (importOriginal) => {
   const actual = await importOriginal<typeof GithubArtifactsModule>();
   return {
     ...actual,
+    fetchRunMeta: (_repository: string, runId: string) => ({
+      id: Number(runId),
+      name: 'Run Sweep',
+      path: '.github/workflows/run-sweep.yml',
+      run_attempt: latestRunAttempts.get(runId) ?? 1,
+      run_started_at: '2026-09-01T00:00:00Z',
+      head_sha: 'local-fixture',
+      head_branch: 'main',
+      status: 'completed',
+      conclusion: 'success',
+    }),
+    downloadArtifact: (artifact: ArtifactMeta, tempDir: string) => {
+      downloadedNames.push(artifact.name);
+      const source = artifactSources.get(artifact.name);
+      if (!source || downloadFailures.has(artifact.name))
+        throw new NonRetryableArtifactError(`Fixture download unavailable: ${artifact.name}`);
+      const destination = path.join(tempDir, artifact.name);
+      fs.cpSync(source, destination, { recursive: true });
+      return destination;
+    },
     listRunArtifacts: (repository: string, runId: string): Promise<ArtifactMeta[]> => {
       listedRunIds.push(runId);
       if (goneRunIds.has(runId)) {
         return Promise.reject(new actual.WorkflowRunNotFoundError(repository, runId));
       }
-      return Promise.resolve([]);
+      return Promise.resolve(retainedArtifacts.get(runId) ?? []);
     },
   };
 });
@@ -82,10 +123,13 @@ async function selectedRuns(...args: string[]): Promise<number[]> {
 
 beforeAll(async () => {
   db = await PGlite.create();
-  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
-    await db.exec(fs.readFileSync(new URL(`../migrations/${name}`, import.meta.url), 'utf8'));
-  }
-  sql = queryClient(db) as unknown as Sql;
+  const migrations = new URL('../migrations/', import.meta.url);
+  for (const name of fs.readdirSync(migrations).toSorted())
+    if (name.endsWith('.sql')) await db.exec(fs.readFileSync(new URL(name, migrations), 'utf8'));
+  sql = Object.assign(queryClient(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(queryClient(tx) as unknown as Sql)),
+  }) as unknown as Sql;
   await import('./backfill-gpu-metrics');
   expect(typeof main).toBe('function');
 }, 20_000);
@@ -95,6 +139,12 @@ afterAll(async () => {
   await db?.close();
 });
 
+afterEach(() => {
+  process.exitCode = originalExitCode;
+  vi.restoreAllMocks();
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
 /**
  * Four runs covering each axis of the candidate filter: fresh/stale relative to
  * GitHub's 90-day artifact retention, with/without an already-stored series, and
@@ -103,7 +153,13 @@ afterAll(async () => {
 beforeEach(async () => {
   listedRunIds.length = 0;
   goneRunIds.clear();
+  retainedArtifacts.clear();
+  artifactSources.clear();
+  downloadFailures.clear();
+  downloadedNames.length = 0;
+  latestRunAttempts.clear();
   vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
   await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
     INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, html_url, created_at, date)
     VALUES (1, ${FRESH_NO_SERIES}, 1, 'Run Sweep', null, now(), '${daysAgo(10)}'),
@@ -131,6 +187,54 @@ beforeEach(async () => {
               1, 8, now(), now());`);
 });
 
+describe('attempt selection', () => {
+  beforeEach(async () => {
+    await db.exec(`
+      INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
+      VALUES (5, ${FRESH_NO_SERIES}, 2, 'Run Sweep', now(), '${daysAgo(10)}');
+      INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+        isl, osl, conc, metrics)
+      VALUES (13, 5, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 32, '{}');
+    `);
+    latestRunAttempts.set(String(FRESH_NO_SERIES), 2);
+  });
+
+  it('selects only the latest persisted attempt by default', async () => {
+    expect(await selectedRuns('--run', String(FRESH_NO_SERIES))).toEqual([FRESH_NO_SERIES]);
+  });
+
+  it('selects an explicit matching attempt and does not substitute an absent attempt', async () => {
+    expect(await selectedRuns('--run', String(FRESH_NO_SERIES), '--attempt', '2')).toEqual([
+      FRESH_NO_SERIES,
+    ]);
+    await expect(selectedRuns('--run', String(FRESH_NO_SERIES), '--attempt', '3')).rejects.toThrow(
+      'No persisted benchmark target',
+    );
+  });
+
+  it('rejects historical-attempt recovery against the latest GitHub artifact listing', async () => {
+    const before = await db.query('select id, workflow_run_id from benchmark_results order by id');
+    await expect(selectedRuns('--run', String(FRESH_NO_SERIES), '--attempt', '1')).rejects.toThrow(
+      'GitHub attempt 2 differs from target 1; refusing mixed-attempt',
+    );
+    expect(listedRunIds).toEqual([String(FRESH_NO_SERIES)]);
+    const after = await db.query('select id, workflow_run_id from benchmark_results order by id');
+    expect(after.rows).toEqual(before.rows);
+  });
+
+  it('continues a bulk dry run after one metadata mismatch and reports a failed run', async () => {
+    latestRunAttempts.set(String(FRESH_WITH_SERIES), 2);
+    expect(await selectedRuns('--all', '--force')).toEqual([FRESH_WITH_SERIES, FRESH_NO_SERIES]);
+    expect(process.exitCode).toBe(1);
+    const errors = vi.mocked(console.error).mock.calls.map((call) => call.join(' '));
+    expect(errors).toContainEqual(expect.stringContaining(`run ${FRESH_WITH_SERIES}`));
+    expect(errors).toContainEqual(expect.stringContaining('refusing mixed-attempt'));
+    const lines = vi.mocked(console.log).mock.calls.map((call) => call.join(' '));
+    expect(lines).toContainEqual(expect.stringContaining(`run ${FRESH_NO_SERIES}`));
+    expect(lines.at(-1)).toContain('1 failed');
+  });
+});
+
 describe('candidate selection', () => {
   it('defaults --since to GitHub 90-day artifact retention window', async () => {
     // --force removes the series filter, isolating the date cutoff. The 100-day-old
@@ -204,9 +308,684 @@ describe('flag validation', () => {
     { args: ['--all', '--since', '09/01/2026'], message: '--since requires a YYYY-MM-DD date' },
     { args: ['--all', '--parallel', '0'], message: '--parallel requires a positive integer' },
     { args: ['--run', '0'], message: '--run requires a positive integer' },
+    {
+      args: ['--run', String(FRESH_NO_SERIES), '--attempt', '0'],
+      message: '--attempt requires a positive integer',
+    },
+    {
+      args: ['--all', '--attempt', '2'],
+      message: '--attempt, --artifact and --receipt require --run',
+    },
   ])('rejects $args', async ({ args, message }) => {
     process.argv = ['bun', 'src/backfill-gpu-metrics.ts', '--dry-run', ...args];
     await expect(main()).rejects.toThrow(message);
     expect(listedRunIds).toEqual([]);
   });
 });
+
+function fixtureArtifact(name: string, files: Record<string, string>): ArtifactMeta {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'backfill-telemetry-fixture-'));
+  roots.push(root);
+  for (const [file, content] of Object.entries(files))
+    fs.writeFileSync(path.join(root, file), content);
+  artifactSources.set(name, root);
+  return { name, archive_download_url: `fixture://${name}`, created_at: '2026-09-02T00:00:00Z' };
+}
+
+function benchmarkArtifact(suffix: string, concs = [32]): ArtifactMeta {
+  return fixtureArtifact(`bmk_${suffix}`, {
+    'results.json': JSON.stringify(
+      concs.map((conc) => ({
+        infmax_model_prefix: 'dsr1',
+        hw: 'b200-nv',
+        framework: 'sglang',
+        precision: 'fp4',
+        isl: 8192,
+        osl: 1024,
+        conc,
+        tp: 8,
+        ep: 1,
+        dp_attention: false,
+        tput_per_gpu: 1234.5,
+      })),
+    ),
+  });
+}
+
+const TELEMETRY_CSV =
+  'timestamp, index, power.draw [W]\n2026/09/02 00:00:00.000, 0, 100 W\n2026/09/02 00:00:01.000, 0, 200 W';
+function telemetryArtifact(suffix: string, csv = TELEMETRY_CSV): ArtifactMeta {
+  return fixtureArtifact(`gpu_metrics_${suffix}`, { 'gpu_metrics.csv': csv });
+}
+
+function receiptFile(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'backfill-telemetry-receipt-'));
+  roots.push(root);
+  return path.join(root, 'power-publication.json');
+}
+
+async function recover(receipt: string, artifact?: string, attempt = 1): Promise<TelemetryReceipt> {
+  process.exitCode = 0;
+  process.argv = [
+    'bun',
+    'src/backfill-gpu-metrics.ts',
+    '--run',
+    String(FRESH_NO_SERIES),
+    '--attempt',
+    String(attempt),
+    '--receipt',
+    receipt,
+    '--parallel',
+    '1',
+    '--yes',
+    ...(artifact ? ['--artifact', artifact] : []),
+  ];
+  await main();
+  return (JSON.parse(fs.readFileSync(receipt, 'utf8')) as PowerPublicationManifest).telemetry!;
+}
+
+describe('targeted recovery receipts', () => {
+  it.each([true, false])(
+    'counts a unique historical offload fallback once with paired=%s',
+    async (paired) => {
+      await db.exec("UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10");
+      const bmk = benchmarkArtifact('historical');
+      const gpu = telemetryArtifact('historical');
+      retainedArtifacts.set(String(FRESH_NO_SERIES), paired ? [bmk, gpu] : [bmk]);
+      const receiptPath = receiptFile();
+      for (let attempt = 0; attempt < 2; attempt++) {
+        const receipt = await recover(receiptPath);
+        expect(receipt.counts).toMatchObject({ expectedPoints: 1, linkedPoints: paired ? 1 : 0 });
+        expect(receipt.points).toHaveLength(1);
+        expect(receipt.points[0]).toMatchObject({
+          benchmarkResultId: 10,
+          identity: { offload_mode: 'on' },
+          produced: paired,
+          reasons: paired ? [] : ['artifact_missing', 'series_not_stored'],
+        });
+      }
+      const count = await db.query(
+        'SELECT count(*)::int AS count FROM benchmark_result_gpu_metrics',
+      );
+      expect(count.rows).toEqual([{ count: paired ? 1 : 0 }]);
+    },
+  );
+
+  it('keeps real offload on/off points separate and leaves ambiguous fallback candidates unlinked', async () => {
+    await db.exec(`INSERT INTO benchmark_results
+      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, offload_mode, metrics)
+      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 32, 'on', '{}')`);
+    const bmk = benchmarkArtifact('offload');
+    const file = path.join(artifactSources.get(bmk.name)!, 'results.json');
+    const [raw] = JSON.parse(fs.readFileSync(file, 'utf8'));
+    fs.writeFileSync(file, JSON.stringify([raw, { ...raw, offload_mode: 'on' }]));
+    const gpu = telemetryArtifact('offload');
+    retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
+    const exact = await recover(receiptFile());
+    expect(exact.counts).toMatchObject({ expectedPoints: 2, linkedPoints: 2, storedSeries: 1 });
+    expect(exact.points.map((p) => p.benchmarkResultId).toSorted()).toEqual([10, 14]);
+    expect(exact.points.map((p) => p.identity.offload_mode).toSorted()).toEqual(['off', 'on']);
+
+    await db.exec(
+      "TRUNCATE gpu_metric_series CASCADE; UPDATE benchmark_results SET offload_mode = 'dram' WHERE id = 10",
+    );
+    fs.writeFileSync(file, JSON.stringify([raw]));
+    const ambiguous = await recover(receiptFile());
+    expect(process.exitCode).toBe(1);
+    expect(ambiguous.counts.linkedPoints).toBe(0);
+    expect(ambiguous.points.find((p) => p.identity.offload_mode === 'off')).toMatchObject({
+      benchmarkResultId: null,
+      error: expect.stringContaining('no matching benchmark rows'),
+    });
+    const links = await db.query('SELECT * FROM benchmark_result_gpu_metrics');
+    expect(links.rows).toEqual([]);
+  });
+
+  it.each([true, false])(
+    'removes only a proven prior offload phantom on paired=%s retry',
+    async (paired) => {
+      await db.exec(`UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10;
+      INSERT INTO benchmark_results
+      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 64, '{}')`);
+      const bmk = benchmarkArtifact('historical');
+      const gpu = telemetryArtifact('historical');
+      const otherBmk = benchmarkArtifact('unrelated', [64]);
+      const otherGpu = telemetryArtifact('unrelated');
+      retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu, otherBmk, otherGpu]);
+      // Build the old receipt through the real reader without fallback metadata.
+      const old = await readTelemetryReceipt(sql, { runId: FRESH_NO_SERIES, runAttempt: 1 }, [
+        {
+          identity: benchmarkPublicationIdentity(
+            readMappedBenchmarkRows(artifactSources.get(bmk.name)!)[0]!,
+          ),
+          artifactNames: [gpu.name, 'power_audit_historical'],
+          produced: false,
+        },
+      ]);
+      expect(old.points).toHaveLength(3);
+      const unrelated = point(old, 14);
+      unrelated.error = 'unrelated failure';
+      unrelated.api = { status: 'readable' };
+      unrelated.reasons.push('ingest_failed');
+      const receiptPath = receiptFile();
+      fs.writeFileSync(
+        receiptPath,
+        JSON.stringify({
+          version: 1,
+          runId: FRESH_NO_SERIES,
+          runAttempt: 1,
+          points: [],
+          telemetry: old,
+        }),
+      );
+      retainedArtifacts.set(
+        String(FRESH_NO_SERIES),
+        paired ? [bmk, gpu, otherBmk, otherGpu] : [bmk, otherBmk, otherGpu],
+      );
+      for (let attempt = 0; attempt < 2; attempt++) {
+        const repaired = await recover(receiptPath, gpu.name);
+        expect(repaired.counts.expectedPoints).toBe(2);
+        expect(repaired.points.map((p) => p.benchmarkResultId).toSorted()).toEqual([10, 14]);
+        expect(point(repaired, 14)).toEqual(unrelated);
+        expect(point(repaired, 10)).toMatchObject({
+          identity: { offload_mode: 'on' },
+          produced: paired,
+        });
+      }
+    },
+  );
+
+  it('clears a legacy run recovery error after a full unique-offload repair without retaining its phantom', async () => {
+    await db.exec("UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10");
+    const bmk = benchmarkArtifact('historical');
+    const gpu = telemetryArtifact('historical');
+    retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
+    const old = await readTelemetryReceipt(sql, { runId: FRESH_NO_SERIES, runAttempt: 1 }, [
+      {
+        identity: benchmarkPublicationIdentity(
+          readMappedBenchmarkRows(artifactSources.get(bmk.name)!)[0]!,
+        ),
+        artifactNames: [gpu.name],
+        produced: true,
+      },
+    ]);
+    old.recoveryError = 'previous full-run failure';
+    const receiptPath = receiptFile();
+    fs.writeFileSync(
+      receiptPath,
+      JSON.stringify({
+        version: 1,
+        runId: FRESH_NO_SERIES,
+        runAttempt: 1,
+        points: [],
+        telemetry: old,
+      }),
+    );
+    const repaired = await recover(receiptPath);
+    expect(repaired.recoveryError).toBeUndefined();
+    expect(repaired.counts.expectedPoints).toBe(1);
+    await verifyTelemetryApi(repaired, 'http://local.test', {
+      fetch: () =>
+        Promise.resolve(
+          Response.json({
+            benchmarkResultId: 10,
+            series: point(repaired, 10).series.map((series) => ({
+              ...series,
+              data: [{ power: 100 }, { power: 200 }],
+            })),
+          }),
+        ),
+    });
+    expect(repaired.counts).toMatchObject({ apiReadablePoints: 1, apiCompletePoints: 1 });
+  });
+
+  it.each([
+    { paired: true, invalid: 'unmapped' },
+    { paired: true, invalid: 'non-object' },
+    { paired: false, invalid: 'unmapped' },
+    { paired: false, invalid: 'non-object' },
+  ])(
+    'retains unknown expectations for $invalid rows with paired=$paired',
+    async ({ paired, invalid }) => {
+      const bmk = benchmarkArtifact('point1');
+      const gpu = telemetryArtifact('point1');
+      retainedArtifacts.set(String(FRESH_NO_SERIES), paired ? [bmk, gpu] : [bmk]);
+      const file = path.join(artifactSources.get(bmk.name)!, 'results.json');
+      const [valid] = JSON.parse(fs.readFileSync(file, 'utf8'));
+      const receiptPath = receiptFile();
+      fs.writeFileSync(file, '{broken');
+      const broken = await recover(receiptPath);
+      expect(broken.counts.expectedPoints).toBeNull();
+
+      fs.writeFileSync(
+        file,
+        JSON.stringify([
+          valid,
+          invalid === 'unmapped'
+            ? { ...valid, conc: 64, infmax_model_prefix: 'unknown-model' }
+            : 42,
+          null,
+        ]),
+      );
+      const partial = await recover(receiptPath);
+      expect(partial.counts.expectedPoints).toBeNull();
+      expect(process.exitCode).toBe(1);
+      expect(partial.expectationErrors).toEqual(
+        [2, 3].map((row) =>
+          expect.objectContaining({
+            benchmarkArtifact: bmk.name,
+            artifactNames: expect.arrayContaining([gpu.name]),
+            error: `Unmappable benchmark row: results.json row ${row}`,
+          }),
+        ),
+      );
+      const summary = vi
+        .mocked(console.log)
+        .mock.calls.map((call) => call.join(' '))
+        .findLast((line) => line.startsWith('\n=== backfill complete:'));
+      expect(summary).toContain('1 failed artifact(s), 0 failed run(s)');
+      expect(point(partial, 10)).toMatchObject({
+        produced: paired,
+        storage: { status: paired ? 'complete' : 'incomplete' },
+      });
+      expect(point(partial, 10).error).toBeUndefined();
+      expect(partial.counts.apiCompletePoints).toBe(0);
+
+      await db.exec(`INSERT INTO benchmark_results
+      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 64, '{}')`);
+      fs.writeFileSync(file, JSON.stringify([valid, { ...valid, conc: 64 }]));
+      const repaired = await recover(receiptPath);
+      expect(process.exitCode).toBe(0);
+      expect(repaired.expectationErrors).toEqual([]);
+      expect(repaired.counts).toMatchObject({ expectedPoints: 2, storedPoints: paired ? 2 : 0 });
+    },
+  );
+
+  it.each(['download', 'parse'])(
+    'records a paired benchmark %s failure as an unknown expectation',
+    async (failure) => {
+      const bmk = benchmarkArtifact('point1');
+      const gpu = telemetryArtifact('point1');
+      retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
+      if (failure === 'download') downloadFailures.add(bmk.name);
+      else fs.writeFileSync(path.join(artifactSources.get(bmk.name)!, 'results.json'), '{broken');
+      const receipt = await recover(receiptFile(), gpu.name);
+      expect(process.exitCode).toBe(1);
+      expect(receipt.expectationErrors).toEqual([
+        {
+          benchmarkArtifact: bmk.name,
+          artifactNames: [gpu.name],
+          error: expect.any(String),
+        },
+      ]);
+      expect(receipt.counts.expectedPoints).toBeNull();
+      expect(receipt.counts.apiCompletePoints).toBe(0);
+    },
+  );
+
+  it('records a missing GitHub run as failed recovery instead of a successful empty backfill', async () => {
+    goneRunIds.add(String(FRESH_NO_SERIES));
+    const receipt = await recover(receiptFile(), 'gpu_metrics_point1');
+    expect(process.exitCode).toBe(1);
+    expect(receipt.recoveryError).toContain('gone from GitHub');
+    expect(receipt.recoveryArtifactNames).toEqual(['gpu_metrics_point1']);
+    expect(receipt.counts.apiCompletePoints).toBe(0);
+  });
+
+  it('keeps unknown expectations when a later full refresh cannot recover the failed sibling', async () => {
+    const broken = benchmarkArtifact('unreadable');
+    const gpu = telemetryArtifact('unreadable');
+    const good = benchmarkArtifact('point1');
+    const goodGpu = telemetryArtifact('point1');
+    retainedArtifacts.set(String(FRESH_NO_SERIES), [broken, gpu, good, goodGpu]);
+    fs.writeFileSync(path.join(artifactSources.get(broken.name)!, 'results.json'), '{broken');
+    const receiptPath = receiptFile();
+    const failed = await recover(receiptPath);
+    expect(failed.counts.expectedPoints).toBeNull();
+    retainedArtifacts.set(String(FRESH_NO_SERIES), [good, goodGpu]);
+    const refreshed = await recover(receiptPath);
+    expect(refreshed.expectationErrors).toEqual(failed.expectationErrors);
+    expect(refreshed.counts.expectedPoints).toBeNull();
+  });
+
+  it('does not accept readable old data after a corrective artifact contains no parseable telemetry', async () => {
+    const bmk = benchmarkArtifact('point1');
+    const gpu = telemetryArtifact('point1');
+    retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
+    const receiptPath = receiptFile();
+    const original = await recover(receiptPath, gpu.name);
+    expect(original.counts.storedPoints).toBe(1);
+    fs.writeFileSync(path.join(artifactSources.get(gpu.name)!, 'gpu_metrics.csv'), '');
+    const failed = await recover(receiptPath, gpu.name);
+    expect(process.exitCode).toBe(1);
+    expect(failed.points[0]).toMatchObject({
+      error: expect.stringContaining('no parseable gpu_metrics CSV'),
+      reasons: ['ingest_failed'],
+      storage: { status: 'complete' },
+    });
+    await verifyTelemetryApi(failed, 'http://local.test', {
+      fetch: () =>
+        Promise.resolve(
+          Response.json({
+            benchmarkResultId: 10,
+            series: original.points[0]!.series.map((series) => ({
+              ...series,
+              data: [{ power: 100 }, { power: 200 }],
+            })),
+          }),
+        ),
+    });
+    expect(failed.counts).toMatchObject({
+      storedPoints: 1,
+      apiReadablePoints: 1,
+      apiCompletePoints: 0,
+    });
+  });
+
+  it('retains both failed targets until each is repaired', async () => {
+    await db.exec(`INSERT INTO benchmark_results
+      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 64, '{}')`);
+    const a = telemetryArtifact('point1');
+    const b = telemetryArtifact('point2');
+    const artifacts = [benchmarkArtifact('point1'), benchmarkArtifact('point2', [64])];
+    retainedArtifacts.set(String(FRESH_NO_SERIES), artifacts);
+    const receiptPath = receiptFile();
+    await recover(receiptPath, a.name);
+    let receipt = await recover(receiptPath, b.name);
+    expect(receipt.recoveryArtifactNames).toEqual([a.name, b.name]);
+    expect(receipt.recoveryError).toContain(a.name);
+    expect(receipt.recoveryError).toContain(b.name);
+    artifacts.push(b);
+    receipt = await recover(receiptPath, b.name);
+    expect(receipt.recoveryArtifactNames).toEqual([a.name]);
+    expect(receipt.recoveryError).toContain(a.name);
+    artifacts.push(a);
+    receipt = await recover(receiptPath, a.name);
+    expect(receipt.recoveryArtifactNames).toBeUndefined();
+    expect(receipt.recoveryError).toBeUndefined();
+  });
+
+  it.each([
+    { name: 'fully unmatched', concs: [64] },
+    { name: 'partially unmatched', concs: [32, 64] },
+  ])(
+    'keeps a $name correction failed until its benchmark target is persisted',
+    async ({ concs }) => {
+      await db.exec(`INSERT INTO benchmark_results
+      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+      VALUES (15, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 96, '{}')`);
+      const bmk = benchmarkArtifact('point1');
+      const gpu = telemetryArtifact('point1');
+      const unrelated = telemetryArtifact('unrelated');
+      retainedArtifacts.set(String(FRESH_NO_SERIES), [
+        bmk,
+        gpu,
+        benchmarkArtifact('unrelated', [96]),
+        unrelated,
+      ]);
+      const receiptPath = receiptFile();
+      const original = await recover(receiptPath);
+      for (const receiptPoint of original.points) receiptPoint.api = { status: 'readable' };
+      const manifest = JSON.parse(fs.readFileSync(receiptPath, 'utf8'));
+      manifest.telemetry = original;
+      fs.writeFileSync(receiptPath, JSON.stringify(manifest));
+      const storedBefore = await db.query(
+        'SELECT * FROM gpu_metric_samples ORDER BY series_id, sampled_at',
+      );
+      const unrelatedBefore = point(original, 15);
+
+      goneRunIds.add(String(FRESH_NO_SERIES));
+      const missing = await recover(receiptPath, gpu.name);
+      expect(missing.recoveryArtifactNames).toEqual([gpu.name]);
+      expect(missing.counts.apiCompletePoints).toBe(0);
+      goneRunIds.clear();
+      benchmarkArtifact('point1', concs);
+      downloadedNames.length = 0;
+      const unmatched = await recover(receiptPath, gpu.name);
+      expect(unmatched.recoveryError).toBe(missing.recoveryError);
+      expect(unmatched.recoveryArtifactNames).toEqual([gpu.name]);
+      expect(process.exitCode).toBe(1);
+      expect(downloadedNames).toEqual([bmk.name]);
+      expect(
+        unmatched.points.find((receiptPoint) => receiptPoint.identity.conc === 64),
+      ).toMatchObject({
+        produced: true,
+        benchmarkResultId: null,
+        error: expect.stringContaining('no matching benchmark rows'),
+        reasons: expect.arrayContaining(['ingest_failed', 'benchmark_not_stored']),
+      });
+      expect(unmatched.counts.apiCompletePoints).toBe(0);
+      if (concs.includes(32)) {
+        expect(point(unmatched, 10)).toMatchObject({
+          storage: { status: 'complete' },
+          error: expect.stringContaining('no matching benchmark rows'),
+          reasons: ['ingest_failed'],
+        });
+      } else expect(point(unmatched, 10)).toEqual(point(missing, 10));
+      expect(point(unmatched, 15)).toEqual(unrelatedBefore);
+      expect(
+        await db.query('SELECT * FROM gpu_metric_samples ORDER BY series_id, sampled_at'),
+      ).toEqual(storedBefore);
+
+      await db.exec(`INSERT INTO benchmark_results
+      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 64, '{}')`);
+      const repaired = await recover(receiptPath, gpu.name);
+      expect(process.exitCode).toBe(0);
+      expect(repaired.recoveryError).toBeUndefined();
+      expect(repaired.recoveryArtifactNames).toBeUndefined();
+      expect(point(repaired, 14)).toMatchObject({
+        produced: true,
+        storage: { status: 'complete' },
+        reasons: [],
+      });
+      expect(point(repaired, 14).error).toBeUndefined();
+      if (concs.includes(32)) {
+        expect(point(repaired, 10).reasons).toEqual([]);
+        expect(point(repaired, 10).error).toBeUndefined();
+      } else expect(point(repaired, 10)).toEqual(point(missing, 10));
+      expect(point(repaired, 15)).toEqual(unrelatedBefore);
+      expect(
+        await db.query('SELECT * FROM gpu_metric_samples ORDER BY series_id, sampled_at'),
+      ).toEqual(storedBefore);
+    },
+  );
+
+  it('rejects an absent explicit target without touching its receipt', async () => {
+    const receipt = receiptFile();
+    fs.writeFileSync(receipt, '{"preserve":"existing evidence"}');
+    await expect(recover(receipt, 'gpu_metrics_point1', 3)).rejects.toThrow(
+      'No persisted benchmark target',
+    );
+    expect(fs.readFileSync(receipt, 'utf8')).toBe('{"preserve":"existing evidence"}');
+    expect(downloadedNames).toEqual([]);
+  });
+});
+
+function point(value: TelemetryReceipt, id: number) {
+  return value.points.find((p) => p.benchmarkResultId === id)!;
+}
+
+describe('real persistence through the recovery CLI', () => {
+  it('repairs absent, failed and unlinked points separately without duplicating shared series or crossing attempts', async () => {
+    await db.exec(`
+      INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
+      VALUES (5, ${FRESH_NO_SERIES}, 2, 'Later attempt', now(), '${daysAgo(10)}');
+      INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 64, '{}'),
+             (15, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 96, '{}'),
+             (16, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 128, '{}'),
+             (17, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 160, '{}'),
+             (20, 5, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 32, '{}');
+    `);
+    const benchmarks = [
+      benchmarkArtifact('absent', [32]),
+      benchmarkArtifact('failed', [64]),
+      benchmarkArtifact('unlinked', [96]),
+      benchmarkArtifact('shared', [128, 160]),
+    ];
+    const absent = telemetryArtifact('absent');
+    const failed = telemetryArtifact('failed', TELEMETRY_CSV.replaceAll(', 0,', ', 999999,'));
+    const unlinked = telemetryArtifact('unlinked');
+    const shared = telemetryArtifact('shared');
+    retainedArtifacts.set(String(FRESH_NO_SERIES), [...benchmarks, failed, unlinked, shared]);
+    const persisted = (artifact: ArtifactMeta, ids: number[], workflowRunId = 1) =>
+      ingestGpuMetricsArtifact(sql, {
+        workflowRunId,
+        artifact: { artifactName: artifact.name, artifactDir: artifactSources.get(artifact.name)! },
+        benchmarkResultIds: ids,
+      });
+    await persisted(unlinked, [15]);
+    await db.exec('DELETE FROM benchmark_result_gpu_metrics WHERE benchmark_result_id = 15');
+    await persisted(shared, [16, 17]);
+    await persisted(absent, [20], 5);
+
+    const observations = benchmarks.flatMap((bmk, index) =>
+      readMappedBenchmarkRows(artifactSources.get(bmk.name)!).map((row) => ({
+        identity: benchmarkPublicationIdentity(row),
+        artifactNames: [[absent, failed, unlinked, shared][index]!.name],
+        produced: index !== 0,
+      })),
+    );
+    const receiptPath = receiptFile();
+    const seed = await readTelemetryReceipt(
+      sql,
+      { runId: FRESH_NO_SERIES, runAttempt: 1 },
+      observations,
+      { expectedSource: 'benchmark_artifacts' },
+    );
+    fs.writeFileSync(
+      receiptPath,
+      JSON.stringify({
+        version: 1,
+        runId: FRESH_NO_SERIES,
+        runAttempt: 1,
+        points: [],
+        telemetry: seed,
+      } satisfies PowerPublicationManifest),
+    );
+
+    // Missing telemetry is discovered from the retained benchmark sibling.
+    let receipt = await recover(receiptPath, absent.name);
+    expect(process.exitCode).toBe(1);
+    expect(receipt.recoveryError).toContain(`No retained telemetry pair for ${absent.name}`);
+    expect(receipt.recoveryArtifactNames).toEqual([absent.name]);
+    // The failure is a real smallint violation inside the ingest transaction.
+    receipt = await recover(receiptPath, failed.name);
+    expect(process.exitCode).toBe(1);
+    expect(point(receipt, 10).reasons).toContain('artifact_missing');
+    expect(point(receipt, 14).reasons).toContain('ingest_failed');
+    expect(point(receipt, 14).error).toContain('smallint');
+    expect(receipt.recoveryError).toContain(`No retained telemetry pair for ${absent.name}`);
+    expect(receipt.recoveryArtifactNames).toEqual([absent.name]);
+    expect(point(receipt, 15).reasons).toContain('point_link_missing');
+    for (const [id, artifact] of [
+      [10, absent],
+      [14, failed],
+      [15, unlinked],
+    ] as const) {
+      expect(point(receipt, id).key).toBe(point(seed, id).key);
+      expect(point(receipt, id).recovery).toEqual({
+        runId: FRESH_NO_SERIES,
+        runAttempt: 1,
+        artifactNames: expect.arrayContaining([artifact.name]),
+      });
+    }
+    expect(receipt.counts).toMatchObject({
+      expectedPoints: 5,
+      producedPoints: 4,
+      producedArtifacts: 3,
+      storedPoints: 3,
+      linkedPoints: 2,
+      storedSeries: 2,
+      storedSamples: 4,
+      apiReadablePoints: 0,
+      apiCompletePoints: 0,
+      apiUnknownPoints: 5,
+    });
+    expect(receipt.plannedPointCount).toBeNull();
+
+    const storedState = async () => {
+      const result = await db.query<{
+        series: { artifact_name: string; workflow_run_id: number };
+      }>(`
+      SELECT to_jsonb(s) AS series,
+        (SELECT jsonb_agg(to_jsonb(x) ORDER BY x.gpu_index, x.sampled_at)
+          FROM gpu_metric_samples x WHERE x.series_id = s.id) AS samples,
+        (SELECT jsonb_agg(to_jsonb(x) ORDER BY x.gpu_index, x.metric)
+          FROM gpu_metric_gpu_stats x WHERE x.series_id = s.id) AS stats,
+        (SELECT jsonb_agg(to_jsonb(l) ORDER BY l.benchmark_result_id)
+          FROM benchmark_result_gpu_metrics l WHERE l.series_id = s.id) AS links
+      FROM gpu_metric_series s ORDER BY s.id
+    `);
+      return result.rows;
+    };
+    const protectedBefore = await storedState();
+    const benchmarksBefore = await db.query('SELECT * FROM benchmark_results ORDER BY id');
+
+    retainedArtifacts.get(String(FRESH_NO_SERIES))!.push(absent);
+    fs.writeFileSync(
+      path.join(artifactSources.get(failed.name)!, 'gpu_metrics.csv'),
+      TELEMETRY_CSV,
+    );
+    const repairCases = [
+      { artifact: absent, id: 10, stored: 4, linked: 3, series: 3, samples: 6 },
+      { artifact: failed, id: 14, stored: 5, linked: 4, series: 4, samples: 8 },
+      { artifact: unlinked, id: 15, stored: 5, linked: 5, series: 4, samples: 8 },
+    ];
+    for (const target of repairCases) {
+      const previous = receipt;
+      downloadedNames.length = 0;
+      receipt = await recover(receiptPath, target.artifact.name);
+      expect(process.exitCode).toBe(0);
+      expect(receipt.recoveryError).toBeUndefined();
+      expect(receipt.recoveryArtifactNames).toBeUndefined();
+      expect(downloadedNames).toEqual([
+        `bmk_${target.artifact.name.slice('gpu_metrics_'.length)}`,
+        target.artifact.name,
+      ]);
+      expect(point(receipt, target.id).reasons).toEqual([]);
+      expect(point(receipt, target.id).key).toBe(point(previous, target.id).key);
+      expect(receipt.points.filter((p) => p.benchmarkResultId !== target.id)).toEqual(
+        previous.points.filter((p) => p.benchmarkResultId !== target.id),
+      );
+      expect(receipt.counts).toMatchObject({
+        expectedPoints: 5,
+        producedArtifacts: 4,
+        storedPoints: target.stored,
+        linkedPoints: target.linked,
+        storedSeries: target.series,
+        storedSamples: target.samples,
+        apiReadablePoints: 0,
+        apiCompletePoints: 0,
+        apiUnknownPoints: 5,
+      });
+      const repairedState = await storedState();
+      const replay = await recover(receiptPath, target.artifact.name);
+      expect(replay.points).toEqual(receipt.points);
+      expect(await storedState()).toEqual(repairedState);
+    }
+    // Shared telemetry counts once; the other attempt and unrelated runs retain exact bytes.
+    const finalState = await storedState();
+    expect(
+      finalState.filter((row) => {
+        const series = row.series;
+        return series.workflow_run_id !== 1 || series.artifact_name === shared.name;
+      }),
+    ).toEqual(
+      protectedBefore.filter((row) => {
+        const series = row.series;
+        return series.artifact_name !== unlinked.name;
+      }),
+    );
+    const benchmarksAfter = await db.query('SELECT * FROM benchmark_results ORDER BY id');
+    expect(benchmarksAfter.rows).toEqual(benchmarksBefore.rows);
+    const otherAttemptLinks = await db.query(
+      'SELECT * FROM benchmark_result_gpu_metrics WHERE benchmark_result_id = 20',
+    );
+    expect(otherAttemptLinks.rows).toHaveLength(1);
+  });
+});
diff --git a/packages/db/src/backfill-gpu-metrics.ts b/packages/db/src/backfill-gpu-metrics.ts
index ac20e759e..a89f81c1f 100644
--- a/packages/db/src/backfill-gpu-metrics.ts
+++ b/packages/db/src/backfill-gpu-metrics.ts
@@ -29,6 +29,18 @@ import { hasNoSslFlag } from './cli-utils.js';
 import { AsyncSemaphore } from './etl/async-semaphore.js';
 import { createAdminSql } from './etl/db-utils.js';
 import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest.js';
+import {
+  benchmarkPublicationIdentity,
+  stablePowerPointIdentity,
+  type PowerPublicationManifest,
+} from './etl/power-publication.js';
+import {
+  readTelemetryReceipt,
+  summarizeTelemetryReceipt,
+  telemetryArtifactsForAttempt,
+  type TelemetryObservation,
+  type TelemetryReceipt,
+} from './etl/telemetry-receipt.js';
 import { retryArtifactOperation } from './lib/artifact-retry.js';
 import {
   confirmProceed,
@@ -37,9 +49,10 @@ import {
   runBackfillMain,
 } from './lib/backfill-runner.js';
 import { findBenchmarkResultIds, readMappedBenchmarkRows } from './lib/benchmark-result-lookup.js';
-import { downloadArtifact } from './lib/github-artifacts.js';
+import { downloadArtifact, fetchRunMeta } from './lib/github-artifacts.js';
 import {
   pairGpuMetricsArtifacts,
+  collectMissingTelemetryExpectations,
   type GpuMetricsArtifactPair,
 } from './lib/gpu-metrics-backfill.js';
 import { repositoryFromRunUrl } from './lib/runtime-metadata-artifacts.js';
@@ -64,6 +77,9 @@ interface BackfillFlags {
   fromRun: number | null;
   since: string | null;
   parallel: number;
+  attempt: number | null;
+  artifact: string | null;
+  receipt: string | null;
 }
 
 function positiveIntFlag(flag: string): number | null {
@@ -76,6 +92,14 @@ function positiveIntFlag(flag: string): number | null {
   return Number(raw);
 }
 
+function stringFlag(flag: string): string | null {
+  const index = process.argv.indexOf(flag);
+  if (index === -1) return null;
+  const value = process.argv[index + 1];
+  if (!value || value.startsWith('--')) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
 function parseFlags(): BackfillFlags {
   const sinceIndex = process.argv.indexOf('--since');
   const since = sinceIndex === -1 ? null : (process.argv[sinceIndex + 1] ?? null);
@@ -89,6 +113,9 @@ function parseFlags(): BackfillFlags {
     fromRun: positiveIntFlag('--from-run'),
     since,
     parallel: positiveIntFlag('--parallel') ?? 4,
+    attempt: positiveIntFlag('--attempt'),
+    artifact: stringFlag('--artifact'),
+    receipt: stringFlag('--receipt'),
   };
 }
 
@@ -109,11 +136,15 @@ async function loadCandidateRuns(
   const rows = await sql<CandidateRun[]>`
     select wr.id, wr.github_run_id, wr.run_attempt, wr.html_url, wr.date::text as date,
       (select count(*)::int from gpu_metric_series s where s.workflow_run_id = wr.id) as series_count
-    from latest_workflow_runs wr
+    from workflow_runs wr
     where exists (select 1 from benchmark_results br where br.workflow_run_id = wr.id)
       and (${flags.run}::bigint is null or wr.github_run_id = ${flags.run})
       and (${flags.fromRun}::bigint is null or wr.github_run_id >= ${flags.fromRun})
       and (${flags.run}::bigint is not null or wr.date >= ${since}::date)
+      and ((${flags.attempt}::integer is not null and wr.run_attempt = ${flags.attempt}) or
+        (${flags.attempt}::integer is null and not exists (
+          select 1 from workflow_runs newer where newer.github_run_id = wr.github_run_id
+            and newer.run_attempt > wr.run_attempt)))
     order by wr.date desc, wr.github_run_id desc
   `;
   const candidates = rows
@@ -128,9 +159,14 @@ async function loadCandidateRuns(
 }
 
 type PairOutcome =
-  | { kind: 'ingested'; seriesCount: number; samplesInserted: number; pointsLinked: number }
+  | {
+      kind: 'ingested';
+      seriesCount: number;
+      samplesInserted: number;
+      pointsLinked: number;
+      expectationsUnknown: boolean;
+    }
   | { kind: 'unmatched' }
-  | { kind: 'empty' }
   | { kind: 'failed' };
 
 /** Download one gpu_metrics/bmk pair, resolve its points, and persist the series. */
@@ -138,16 +174,43 @@ async function processPair(
   run: CandidateRun,
   pair: GpuMetricsArtifactPair,
   tempDir: string,
+  observations: Map<string, TelemetryObservation>,
+  expectationErrors: NonNullable<TelemetryReceipt['expectationErrors']>,
+  uniqueFallbacks: Map<string, number>,
 ): Promise<PairOutcome> {
   let benchmarkDir: string | null = null;
   let gpuMetricsDir: string | null = null;
+  const pointKeys: string[] = [];
+  let expectationsUnknown = false;
   try {
     benchmarkDir = await retryArtifactOperation(`downloading ${pair.benchmarks.name}`, () =>
       downloadArtifact(pair.benchmarks, tempDir),
     );
-    const mappedRows = readMappedBenchmarkRows(benchmarkDir);
-    const resultIds = await findBenchmarkResultIds(sql, run, mappedRows);
+    const mappedRows = readMappedBenchmarkRows(benchmarkDir, (error) => {
+      expectationsUnknown = true;
+      expectationErrors.push({
+        benchmarkArtifact: pair.benchmarks.name,
+        artifactNames: [pair.gpuMetrics.name],
+        error,
+      });
+    });
+    for (const row of mappedRows) {
+      const identity = benchmarkPublicationIdentity(row);
+      const key = stablePowerPointIdentity(identity);
+      pointKeys.push(key);
+      observations.set(key, { identity, artifactNames: [pair.gpuMetrics.name], produced: true });
+    }
+    const matchedIds: number[] = [];
+    for (const row of mappedRows) {
+      const ids = await findBenchmarkResultIds(sql, run, [row], (id) =>
+        uniqueFallbacks.set(stablePowerPointIdentity(benchmarkPublicationIdentity(row)), id),
+      );
+      if (ids.length === 0) throw new Error(`${pair.gpuMetrics.name}: no matching benchmark rows`);
+      matchedIds.push(...ids);
+    }
+    const resultIds = [...new Set(matchedIds)];
     if (resultIds.length === 0) {
+      if (expectationsUnknown) return { kind: 'failed' };
       console.warn(`  [WARN] ${pair.gpuMetrics.name}: no matching benchmark rows`);
       return { kind: 'unmatched' };
     }
@@ -160,16 +223,26 @@ async function processPair(
       benchmarkResultIds: resultIds,
     });
     if (ingested.seriesIds.length === 0) {
-      console.warn(`  [WARN] ${pair.gpuMetrics.name}: no parseable gpu_metrics CSV`);
-      return { kind: 'empty' };
+      throw new Error(`${pair.gpuMetrics.name}: no parseable gpu_metrics CSV`);
     }
     return {
       kind: 'ingested',
       seriesCount: ingested.seriesIds.length,
       samplesInserted: ingested.samplesInserted,
       pointsLinked: resultIds.length,
+      expectationsUnknown,
     };
   } catch (error) {
+    if (pointKeys.length === 0)
+      expectationErrors.push({
+        benchmarkArtifact: pair.benchmarks.name,
+        artifactNames: [pair.gpuMetrics.name],
+        error: error instanceof Error ? error.message : String(error),
+      });
+    for (const key of pointKeys) {
+      const observation = observations.get(key)!;
+      observation.error = error instanceof Error ? error.message : String(error);
+    }
     console.error(`  ✗ run ${run.github_run_id} artifact ${pair.gpuMetrics.name}:`, error);
     return { kind: 'failed' };
   } finally {
@@ -184,6 +257,8 @@ async function main(): Promise<void> {
   if (!flags.all && flags.run === null) {
     throw new Error('Pass --run <github run id> or --all');
   }
+  if ((flags.attempt !== null || flags.artifact || flags.receipt) && flags.run === null)
+    throw new Error('--attempt, --artifact and --receipt require --run');
 
   console.log('=== backfill-gpu-metrics ===');
   const runs = await loadCandidateRuns(flags, limit, force);
@@ -194,6 +269,10 @@ async function main(): Promise<void> {
       : '';
   console.log(`  ${runs.length} candidate run(s)${staleNote}`);
   if (runs.length === 0) {
+    if (flags.attempt !== null || flags.artifact || flags.receipt)
+      throw new Error(
+        `No persisted benchmark target for run ${flags.run} attempt ${flags.attempt ?? 'latest'}`,
+      );
     console.log('\n  Nothing to do.');
     return;
   }
@@ -202,23 +281,39 @@ async function main(): Promise<void> {
     let pairedRuns = 0;
     let pairs = 0;
     let goneRuns = 0;
+    let failedRuns = 0;
     for (const run of runs) {
-      const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
-      const artifacts = await listBackfillRunArtifacts(repository, run.github_run_id);
-      if (artifacts === null) {
-        goneRuns++;
-        console.log(`  run ${run.github_run_id} (${run.date}): gone from GitHub`);
-        continue;
+      try {
+        const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
+        const artifacts = await listBackfillRunArtifacts(repository, run.github_run_id);
+        if (artifacts === null) {
+          goneRuns++;
+          console.log(`  run ${run.github_run_id} (${run.date}): gone from GitHub`);
+          continue;
+        }
+        const runPairs = pairGpuMetricsArtifacts(
+          telemetryArtifactsForAttempt(
+            artifacts,
+            fetchRunMeta(repository, String(run.github_run_id)),
+            run.run_attempt,
+          ),
+        ).filter((pair) => !flags.artifact || pair.gpuMetrics.name === flags.artifact);
+        if (runPairs.length > 0) pairedRuns++;
+        pairs += runPairs.length;
+        console.log(`  run ${run.github_run_id} (${run.date}): ${runPairs.length} pair(s)`);
+      } catch (error) {
+        if (flags.run !== null) throw error;
+        failedRuns++;
+        console.error(
+          `  run ${run.github_run_id} (${run.date}): ${error instanceof Error ? error.message : String(error)}`,
+        );
       }
-      const runPairs = pairGpuMetricsArtifacts(artifacts);
-      if (runPairs.length > 0) pairedRuns++;
-      pairs += runPairs.length;
-      console.log(`  run ${run.github_run_id} (${run.date}): ${runPairs.length} pair(s)`);
     }
     console.log(
       `\n=== dry run: ${runs.length} run(s), ${pairedRuns} with pairs, ${pairs} pair(s), ` +
-        `${goneRuns} gone from GitHub ===`,
+        `${goneRuns} gone from GitHub, ${failedRuns} failed ===`,
     );
+    if (failedRuns > 0) process.exitCode = 1;
     return;
   }
 
@@ -231,7 +326,6 @@ async function main(): Promise<void> {
   let samplesStored = 0;
   let pointsLinked = 0;
   let unmatchedArtifacts = 0;
-  let emptyArtifacts = 0;
   let artifactFailures = 0;
   let runFailures = 0;
   let missingRuns = 0;
@@ -242,17 +336,79 @@ async function main(): Promise<void> {
     const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `gpu-metrics-backfill-${runId}-`));
     const runStart = Date.now();
+    const receiptPath =
+      flags.receipt ?? `power-publication-${runId}-attempt-${run.run_attempt}.json`;
+    const manifest: PowerPublicationManifest = fs.existsSync(receiptPath)
+      ? JSON.parse(fs.readFileSync(receiptPath, 'utf8'))
+      : { version: 1, runId, runAttempt: run.run_attempt, points: [] };
+    if (
+      manifest.version !== 1 ||
+      manifest.runId !== runId ||
+      manifest.runAttempt !== run.run_attempt ||
+      !Array.isArray(manifest.points) ||
+      (manifest.telemetry &&
+        (manifest.telemetry.runId !== runId || manifest.telemetry.runAttempt !== run.run_attempt))
+    )
+      throw new Error('Publication receipt run/attempt does not match the recovery target');
+    const observations = new Map<string, TelemetryObservation>();
+    const uniqueFallbacks = new Map<string, number>();
+    let recoveryError: string | undefined;
+    let expectationErrors: TelemetryReceipt['expectationErrors'];
     try {
-      const artifacts = await listBackfillRunArtifacts(repository, runId);
-      if (artifacts === null) {
+      const listedArtifacts = await listBackfillRunArtifacts(repository, runId);
+      if (listedArtifacts === null) {
         goneRuns++;
+        runFailures++;
+        recoveryError = `Run ${runId} attempt ${run.run_attempt} is gone from GitHub`;
         console.log(
           `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt}: gone from GitHub`,
         );
         continue;
       }
-      const pairs = pairGpuMetricsArtifacts(artifacts);
+      const artifacts = telemetryArtifactsForAttempt(
+        listedArtifacts,
+        fetchRunMeta(repository, String(runId)),
+        run.run_attempt,
+      );
+      const allPairs = pairGpuMetricsArtifacts(artifacts);
+      const pairs = allPairs.filter(
+        (pair) => !flags.artifact || pair.gpuMetrics.name === flags.artifact,
+      );
+      // Expectations come from benchmark siblings even when no telemetry was
+      // uploaded. Counting only the successful pairs would hide missing points.
+      const missing = await collectMissingTelemetryExpectations(
+        artifacts,
+        allPairs,
+        flags.artifact,
+        async (artifact, onUnmapped) => {
+          let directory: string | null = null;
+          try {
+            directory = await retryArtifactOperation(`downloading ${artifact.name}`, () =>
+              downloadArtifact(artifact, tempDir),
+            );
+            const rows = readMappedBenchmarkRows(directory, onUnmapped);
+            for (const row of rows)
+              await findBenchmarkResultIds(sql, run, [row], (id) =>
+                uniqueFallbacks.set(
+                  stablePowerPointIdentity(benchmarkPublicationIdentity(row)),
+                  id,
+                ),
+              );
+            return rows;
+          } finally {
+            if (directory) fs.rmSync(directory, { recursive: true, force: true });
+          }
+        },
+      );
+      for (const observation of missing.observations)
+        observations.set(stablePowerPointIdentity(observation.identity), observation);
+      expectationErrors = missing.errors;
+      artifactFailures += new Set(missing.errors.map((error) => error.benchmarkArtifact)).size;
       if (pairs.length === 0) {
+        if (flags.artifact) {
+          artifactFailures++;
+          recoveryError = `No retained telemetry pair for ${flags.artifact}`;
+        }
         missingRuns++;
         console.log(
           `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt}: no retained gpu_metrics pairs`,
@@ -262,7 +418,11 @@ async function main(): Promise<void> {
 
       const limiter = new AsyncSemaphore(flags.parallel);
       const outcomes = await Promise.all(
-        pairs.map((pair) => limiter.run(() => processPair(run, pair, tempDir))),
+        pairs.map((pair) =>
+          limiter.run(() =>
+            processPair(run, pair, tempDir, observations, missing.errors, uniqueFallbacks),
+          ),
+        ),
       );
       let runSeries = 0;
       let runSamples = 0;
@@ -270,6 +430,7 @@ async function main(): Promise<void> {
         switch (outcome.kind) {
           case 'ingested': {
             artifactsProcessed++;
+            if (outcome.expectationsUnknown) artifactFailures++;
             runSeries += outcome.seriesCount;
             runSamples += outcome.samplesInserted;
             pointsLinked += outcome.pointsLinked;
@@ -279,10 +440,6 @@ async function main(): Promise<void> {
             unmatchedArtifacts++;
             break;
           }
-          case 'empty': {
-            emptyArtifacts++;
-            break;
-          }
           case 'failed': {
             artifactFailures++;
             break;
@@ -298,8 +455,40 @@ async function main(): Promise<void> {
       );
     } catch (error) {
       runFailures++;
+      recoveryError = error instanceof Error ? error.message : String(error);
       console.error(`  ✗ run ${runId}:`, error);
     } finally {
+      manifest.telemetry = await readTelemetryReceipt(
+        sql,
+        { runId, runAttempt: run.run_attempt },
+        [...observations.values()],
+        { previous: manifest.telemetry, targeted: Boolean(flags.artifact), uniqueFallbacks },
+      );
+      if (recoveryError) {
+        const priorError = manifest.telemetry.recoveryError;
+        const priorScope = manifest.telemetry.recoveryArtifactNames;
+        manifest.telemetry.recoveryError = [
+          ...new Set([priorError, recoveryError].filter(Boolean).join('\n').split('\n')),
+        ].join('\n');
+        if (flags.artifact && (!priorError || priorScope))
+          manifest.telemetry.recoveryArtifactNames = [
+            ...new Set([...(priorScope ?? []), flags.artifact]),
+          ];
+        else delete manifest.telemetry.recoveryArtifactNames;
+      }
+      if (expectationErrors) {
+        const failedBenchmarks = new Set(expectationErrors.map((error) => error.benchmarkArtifact));
+        manifest.telemetry.expectationErrors = [
+          ...(manifest.telemetry.expectationErrors ?? []).filter(
+            (error) => !failedBenchmarks.has(error.benchmarkArtifact),
+          ),
+          ...expectationErrors,
+        ];
+      }
+      summarizeTelemetryReceipt(manifest.telemetry);
+      fs.mkdirSync(path.dirname(path.resolve(receiptPath)), { recursive: true });
+      fs.writeFileSync(receiptPath, `${JSON.stringify(manifest, null, 2)}\n`);
+      console.log(`  PowerX ingest receipt: ${receiptPath}`);
       fs.rmSync(tempDir, { recursive: true, force: true });
     }
   }
@@ -307,11 +496,13 @@ async function main(): Promise<void> {
   console.log(
     `\n=== backfill complete: ${artifactsProcessed} artifact(s), ${seriesStored} series, ` +
       `${samplesStored} sample(s), ${pointsLinked} point link(s), ` +
-      `${unmatchedArtifacts} unmatched artifact(s), ${emptyArtifacts} empty artifact(s), ` +
+      `${unmatchedArtifacts} unmatched artifact(s), ` +
       `${missingRuns} run(s) without pairs, ${goneRuns} run(s) gone from GitHub, ` +
       `${artifactFailures} failed artifact(s), ${runFailures} failed run(s) ===`,
   );
-  console.log('  Point telemetry reads use the stored revision; no manual cache purge is needed.');
+  console.log(
+    '  Point telemetry reads use the stored revision; API verification is recorded separately.',
+  );
   if (artifactFailures > 0 || runFailures > 0) process.exitCode = 1;
 }
 
diff --git a/packages/db/src/etl/power-publication.ts b/packages/db/src/etl/power-publication.ts
index b0f359df8..af855f313 100644
--- a/packages/db/src/etl/power-publication.ts
+++ b/packages/db/src/etl/power-publication.ts
@@ -1,6 +1,7 @@
 import { isDeepStrictEqual } from 'node:util';
 import { MEASURED_POWER_METRIC_KEYS } from '@semianalysisai/inferencex-constants';
 import type { BenchmarkParams } from './benchmark-mapper';
+import type { TelemetryReceipt } from './telemetry-receipt';
 
 const CONFIG_FIELDS = {
   hardware: 'hardware',
@@ -54,6 +55,8 @@ export interface PowerPublicationManifest {
    * rows landed, and the artifact can be re-digested by the backfill.
    */
   telemetryWarnings?: string[];
+  /** Attachment completeness, separate from benchmark/power publication validity. */
+  telemetry?: TelemetryReceipt;
 }
 /**
  * The errors that fail an ingest. `telemetryWarnings` is deliberately not among
diff --git a/packages/db/src/etl/telemetry-receipt.test.ts b/packages/db/src/etl/telemetry-receipt.test.ts
new file mode 100644
index 000000000..45e1e80dd
--- /dev/null
+++ b/packages/db/src/etl/telemetry-receipt.test.ts
@@ -0,0 +1,739 @@
+import fs from 'node:fs';
+import { createServer } from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { PGlite } from '@electric-sql/pglite';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { DbClient } from '../connection';
+import { getGpuMetricsForPoint } from '../queries/gpu-metrics';
+import type * as DbUtils from './db-utils';
+import type { Sql } from './db-utils';
+import { ingestGpuMetricsArtifact } from './gpu-metrics-ingest';
+import {
+  fatalPublicationErrors,
+  stablePowerPointIdentity,
+  type PowerPublicationManifest,
+} from './power-publication';
+import {
+  readTelemetryReceipt,
+  summarizeTelemetryReceipt,
+  verifyTelemetryApi,
+  telemetryArtifactsForAttempt,
+  type TelemetryObservation,
+} from './telemetry-receipt';
+
+let db: PGlite;
+let sql: Sql;
+const roots: string[] = [];
+const run = { runId: 123, runAttempt: 2 };
+vi.mock('./db-utils', async (importOriginal) => ({
+  ...(await importOriginal<typeof DbUtils>()),
+  createAdminSql: () => Object.assign(sql, { end: async () => {} }),
+}));
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const text = strings.reduce((query, part, i) => query + (i ? `$${i}` : '') + part, '');
+    const result = await database.query(text, values);
+    return result.rows;
+  };
+  return Object.assign(client, { json: JSON.stringify, array: (value: unknown) => value });
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql'])
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  await db.exec(
+    "alter table benchmark_results add column offload_mode text not null default 'off'; alter table benchmark_results add column recipe_fingerprint text; alter table benchmark_results add column workers jsonb; alter table benchmark_results add column power_audit jsonb;",
+  );
+  sql = Object.assign(queryClient(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(queryClient(tx) as unknown as Sql)),
+  }) as unknown as Sql;
+}, 20_000);
+
+beforeEach(async () => {
+  await db.exec(`truncate workflow_runs, configs restart identity cascade;
+    insert into workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
+    values (1, 123, 2, 'Sweep', '2026-09-21', '2026-09-21'),
+      (2, 123, 1, 'Previous attempt', '2026-09-20', '2026-09-20');
+    insert into configs (id, model, hardware, framework, precision, spec_method, prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    values (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', 1, 1, 1, 1);
+    insert into benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    values (10, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 1, '{}'),
+      (11, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 2, '{}'),
+      (12, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 3, '{}'),
+      (13, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 4, '{}'),
+      (20, 2, 1, 'single_turn', '2026-09-20', 8192, 1024, 1, '{}');`);
+});
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+afterAll(async () => {
+  await db?.close();
+});
+
+function artifact(name: string) {
+  const artifactDir = fs.mkdtempSync(path.join(os.tmpdir(), 'telemetry-receipt-'));
+  roots.push(artifactDir);
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics.csv'),
+    'timestamp, index, power.draw [W]\n2026/09/21 00:00:00.000, 0, 100 W\n2026/09/21 00:00:01.000, 0, 200 W',
+  );
+  return { artifactName: name, artifactDir };
+}
+async function observations(): Promise<TelemetryObservation[]> {
+  const rows =
+    await sql`select c.*, br.id, br.benchmark_type, br.isl, br.osl, br.conc, br.offload_mode, br.recipe_fingerprint
+    from benchmark_results br join configs c on c.id = br.config_id where br.workflow_run_id = 1 order by br.id`;
+  return rows.map((identity, i) => ({
+    identity,
+    artifactNames: [`gpu_metrics_point${i + 1}`],
+    produced: true,
+  }));
+}
+
+describe('telemetry attachment receipts', () => {
+  it('preserves an unrelated prior artifact failure at the canonical offload identity', async () => {
+    await db.exec("UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10");
+    const [canonical] = await observations();
+    canonical!.error = 'prior artifact failed';
+    const previous = await readTelemetryReceipt(sql, run, [canonical!]);
+    const alias = {
+      identity: { ...canonical!.identity, offload_mode: 'off' },
+      artifactNames: ['gpu_metrics_other'],
+      produced: true,
+    };
+    const receipt = await readTelemetryReceipt(sql, run, [alias], {
+      previous,
+      targeted: true,
+      uniqueFallbacks: new Map([[stablePowerPointIdentity(alias.identity), 10]]),
+    });
+    expect(receipt.points.find((p) => p.benchmarkResultId === 10)).toEqual(
+      previous.points.find((p) => p.benchmarkResultId === 10),
+    );
+    expect(receipt.counts.expectedPoints).toBeNull();
+  });
+
+  it('retains conflicting artifact observations when a historical fallback reaches an occupied identity', async () => {
+    await db.exec("UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10");
+    const [canonical] = await observations();
+    const alias = {
+      ...canonical!,
+      identity: { ...canonical!.identity, offload_mode: 'off' },
+      artifactNames: ['gpu_metrics_other'],
+      error: 'failed correction',
+    };
+    const receipt = await readTelemetryReceipt(sql, run, [canonical!, alias], {
+      uniqueFallbacks: new Map([[stablePowerPointIdentity(alias.identity), 10]]),
+    });
+    expect(receipt.counts.expectedPoints).toBeNull();
+    expect(
+      receipt.points.find((p) => p.key === stablePowerPointIdentity(alias.identity)),
+    ).toMatchObject({
+      error: 'failed correction',
+      benchmarkResultId: null,
+      artifactNames: ['gpu_metrics_other'],
+    });
+    expect(receipt.points.find((p) => p.benchmarkResultId === 10)?.artifactNames).toEqual(
+      canonical!.artifactNames,
+    );
+  });
+
+  it.each([11, 20])(
+    'does not canonicalize a fallback to a different point or attempt (id=%s)',
+    async (id) => {
+      const [source] = await observations();
+      const alias = { ...source!, identity: { ...source!.identity, offload_mode: 'on' } };
+      const previous = await readTelemetryReceipt(sql, run, [alias]);
+      const receipt = await readTelemetryReceipt(sql, run, [alias], {
+        previous,
+        targeted: true,
+        uniqueFallbacks: new Map([[stablePowerPointIdentity(alias.identity), id]]),
+      });
+      expect(receipt.counts.expectedPoints).toBe(previous.counts.expectedPoints);
+      expect(
+        receipt.points.find((p) => p.key === stablePowerPointIdentity(alias.identity)),
+      ).toMatchObject({
+        benchmarkResultId: null,
+        identity: { conc: 1, offload_mode: 'on' },
+      });
+    },
+  );
+
+  it('persists real HTTP query results through the publication verifier without failing benchmark publication', async () => {
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact('gpu_metrics_point1'),
+      benchmarkResultIds: [10],
+    });
+    const points = await observations();
+    points[1]!.produced = false;
+    const telemetry = await readTelemetryReceipt(sql, run, points, {
+      expectedSource: 'benchmark_artifacts',
+    });
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'telemetry-verifier-'));
+    roots.push(directory);
+    const manifestPath = path.join(directory, 'power-publication.json');
+    const manifest: PowerPublicationManifest = {
+      version: 1,
+      ...run,
+      points: points.map((point) => ({
+        identity: point.identity,
+        metrics: {},
+        workers: null,
+        power_invalid_reasons: null,
+        power_audit: null,
+        artifact: { path: 'bmk_fixture/results.json', sha256: 'fixture' },
+      })),
+      telemetryWarnings: ['Fixture telemetry unavailable for three benchmark points'],
+      telemetry,
+    };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest));
+    const requests: string[] = [];
+    let unavailable = false;
+    // Exercise the production SQL reader over loopback HTTP. This does not
+    // stand in for a Next deployment, Blob/CDN, or retained-artifact replay.
+    const server = createServer(async (request, response) => {
+      try {
+        const url = new URL(request.url!, 'http://127.0.0.1');
+        requests.push(url.pathname + url.search);
+        let payload: unknown;
+        if (url.pathname === '/api/v1/benchmarks') {
+          payload = await sql`select c.*, br.* from benchmark_results br
+            join configs c on c.id = br.config_id where br.workflow_run_id = 1`;
+        } else if (unavailable) {
+          response.writeHead(503).end();
+          return;
+        } else {
+          payload = await getGpuMetricsForPoint(
+            sql as unknown as DbClient,
+            Number(url.searchParams.get('id')),
+          );
+        }
+        response.writeHead(payload ? 200 : 404, { 'Content-Type': 'application/json' });
+        response.end(JSON.stringify(payload));
+      } catch (error) {
+        response.writeHead(500).end(String(error));
+      }
+    });
+    await new Promise<void>((resolve) => {
+      server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') throw new Error('Expected TCP address');
+    const originalArgv = process.argv;
+    const originalExitCode = process.exitCode;
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      process.argv = [
+        'bun',
+        'verify-power-publication.ts',
+        manifestPath,
+        `http://127.0.0.1:${address.port}`,
+      ];
+      await import('../verify-power-publication');
+      const result = JSON.parse(fs.readFileSync(`${manifestPath}.verification.json`, 'utf8'));
+      const updated = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+      expect(result).toMatchObject({ status: 'matched', points: 4, errors: [] });
+      expect(result.telemetryWarnings).toEqual(manifest.telemetryWarnings);
+      expect(result.telemetry).toEqual(updated.telemetry);
+      expect(result.telemetry.counts).toMatchObject({
+        expectedPoints: 4,
+        apiReadablePoints: 1,
+        apiCompletePoints: 1,
+        apiUnknownPoints: 0,
+      });
+      expect(result.telemetry.plannedPointCount).toBeNull();
+      expect(requests).toHaveLength(5);
+      expect(requests[0]).toContain('runId=123&exactRun=true');
+      expect(
+        result.telemetry.points.find(
+          (point: { benchmarkResultId: number }) => point.benchmarkResultId === 11,
+        ).api.error,
+      ).toBe('HTTP 404');
+      expect(process.exitCode).toBe(originalExitCode);
+
+      unavailable = true;
+      vi.resetModules();
+      await import('../verify-power-publication');
+      const failed = JSON.parse(fs.readFileSync(`${manifestPath}.verification.json`, 'utf8'));
+      expect(failed).toMatchObject({ status: 'matched', errors: [] });
+      expect(failed.telemetry.counts).toMatchObject({ apiReadablePoints: 0, apiCompletePoints: 0 });
+      expect(
+        failed.telemetry.points.every(
+          (point: { api: { error: string } }) => point.api.error === 'HTTP 503',
+        ),
+      ).toBe(true);
+      expect(process.exitCode).toBe(originalExitCode);
+    } finally {
+      process.argv = originalArgv;
+      process.exitCode = originalExitCode;
+      log.mockRestore();
+      await new Promise<void>((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+      });
+    }
+  });
+
+  it('isolates the source attempt before selecting or downloading artifact pairs', () => {
+    const old = {
+      name: 'gpu_metrics_old',
+      created_at: '2026-09-20T00:00:00Z',
+      archive_download_url: 'old',
+    };
+    const current = {
+      name: 'gpu_metrics_new',
+      created_at: '2026-09-21T01:00:00Z',
+      archive_download_url: 'new',
+    };
+    const source = { run_attempt: 2, run_started_at: '2026-09-21T00:00:00Z' };
+    expect(telemetryArtifactsForAttempt([old, current], source, 2)).toEqual([current]);
+    expect(() => telemetryArtifactsForAttempt([old, current], source, 1)).toThrow('mixed-attempt');
+    expect(() => telemetryArtifactsForAttempt([current], { run_attempt: 2 }, 2)).toThrow(
+      'start time',
+    );
+  });
+  it('retains missing/failed/unlinked point identities and targeted recovery changes only the repaired point', async () => {
+    const points = await observations();
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact('gpu_metrics_point1'),
+      benchmarkResultIds: [10],
+    });
+    points[1]!.produced = false;
+    const badArtifact = artifact('gpu_metrics_point3');
+    fs.writeFileSync(
+      path.join(badArtifact.artifactDir, 'gpu_metrics.csv'),
+      'timestamp, index, power.draw [W]\n2026/09/21 00:00:00.000, 999999, 100 W',
+    );
+    try {
+      await ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact: badArtifact,
+        benchmarkResultIds: [12],
+      });
+      throw new Error('Expected the invalid GPU index to fail persistence');
+    } catch (error) {
+      points[2]!.error = error instanceof Error ? error.message : String(error);
+    }
+    expect(points[2]!.error).toContain('smallint');
+    const orphan = artifact('gpu_metrics_point4');
+    const fourth = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: orphan,
+      benchmarkResultIds: [13],
+    });
+    await sql`delete from benchmark_result_gpu_metrics where benchmark_result_id = 13`;
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 2,
+      artifact: artifact('gpu_metrics_point1'),
+      benchmarkResultIds: [20],
+    });
+    const receipt = await readTelemetryReceipt(sql, run, points, {
+      expectedSource: 'benchmark_artifacts',
+    });
+    expect(receipt.counts).toEqual({
+      expectedPoints: 4,
+      producedPoints: 3,
+      productionUnknownPoints: 0,
+      storedPoints: 2,
+      linkedPoints: 1,
+      storageUnknownPoints: 0,
+      apiReadablePoints: 0,
+      apiCompletePoints: 0,
+      apiUnknownPoints: 4,
+      producedArtifacts: 3,
+      storedSeries: 2,
+      storedSamples: 4,
+    });
+    expect(receipt.plannedPointCount).toBeNull();
+    expect(receipt.points.find((p) => p.benchmarkResultId === 11)?.reasons).toContain(
+      'artifact_missing',
+    );
+    expect(receipt.points.find((p) => p.benchmarkResultId === 12)).toMatchObject({
+      error: points[2]!.error,
+      reasons: ['ingest_failed', 'series_not_stored'],
+    });
+    const missingLink = receipt.points.find((p) => p.benchmarkResultId === 13)!;
+    expect(missingLink.reasons).toEqual(['point_link_missing']);
+    expect(missingLink.series).toEqual([
+      {
+        id: fourth.seriesIds[0],
+        artifactName: 'gpu_metrics_point4',
+        fileName: 'gpu_metrics.csv',
+        sampleCount: 2,
+      },
+    ]);
+    expect(missingLink.recovery).toEqual({
+      runId: 123,
+      runAttempt: 2,
+      artifactNames: ['gpu_metrics_point4'],
+    });
+    receipt.expectationErrors = [
+      {
+        benchmarkArtifact: 'bmk_unreadable',
+        artifactNames: ['gpu_metrics_unreadable'],
+        error: 'Download failed',
+      },
+    ];
+    expect(summarizeTelemetryReceipt(receipt).counts.expectedPoints).toBeNull();
+    const refreshed = await readTelemetryReceipt(sql, run, points, { previous: receipt });
+    expect(refreshed.expectationErrors).toEqual(receipt.expectationErrors);
+    expect(refreshed.counts.expectedPoints).toBeNull();
+    const recovered = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: orphan,
+      benchmarkResultIds: [13],
+    });
+    expect(recovered.samplesInserted).toBe(0);
+    const repaired = await readTelemetryReceipt(sql, run, [points[3]!], {
+      previous: receipt,
+      targeted: true,
+    });
+    expect(repaired.points).toHaveLength(4);
+    expect(repaired.expectationErrors).toEqual(receipt.expectationErrors);
+    expect(repaired.counts.expectedPoints).toBeNull();
+    expect(repaired.counts).toMatchObject({ storedSeries: 2, storedSamples: 4, linkedPoints: 2 });
+    expect(repaired.points.find((p) => p.benchmarkResultId === 13)?.reasons).toEqual([]);
+    expect(repaired.points.filter((p) => p.benchmarkResultId !== 13)).toEqual(
+      receipt.points.filter((p) => p.benchmarkResultId !== 13),
+    );
+    expect(repaired.points.find((p) => p.benchmarkResultId === 10)?.series).toEqual([
+      {
+        id: first.seriesIds[0],
+        artifactName: 'gpu_metrics_point1',
+        fileName: 'gpu_metrics.csv',
+        sampleCount: 2,
+      },
+    ]);
+    expect(fatalPublicationErrors({ telemetryWarnings: ['CSV parse failed'] }, [])).toEqual([]);
+  });
+
+  it('counts a shared series once and keeps unavailable expectations unknown', async () => {
+    const points = await observations();
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact('gpu_metrics_shared'),
+      benchmarkResultIds: [10, 11],
+    });
+    const receipt = await readTelemetryReceipt(
+      sql,
+      run,
+      points.slice(0, 2).map((p) => ({ ...p, artifactNames: ['gpu_metrics_shared'] })),
+    );
+    expect(receipt.counts).toMatchObject({
+      expectedPoints: 4,
+      storedPoints: 2,
+      linkedPoints: 2,
+      storedSeries: 1,
+      storedSamples: 2,
+      productionUnknownPoints: 2,
+    });
+    const unavailable = await readTelemetryReceipt(sql, { runId: 999, runAttempt: 1 }, [], {
+      expectedSource: 'unknown',
+    });
+    expect(unavailable.counts.expectedPoints).toBeNull();
+    await expect(
+      readTelemetryReceipt(sql, { runId: 123, runAttempt: 1 }, [], { previous: receipt }),
+    ).rejects.toThrow('run/attempt');
+  });
+
+  it('keeps a partial host artifact incomplete until targeted recovery restores its inventory', async () => {
+    const points = await observations();
+    const multi = artifact('gpu_metrics_point1');
+    const csv = fs.readFileSync(path.join(multi.artifactDir, 'gpu_metrics.csv'));
+    fs.unlinkSync(path.join(multi.artifactDir, 'gpu_metrics.csv'));
+    for (const host of ['host-a', 'host-b']) {
+      fs.mkdirSync(path.join(multi.artifactDir, host));
+      fs.writeFileSync(path.join(multi.artifactDir, host, 'gpu_metrics.csv'), csv);
+    }
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: multi,
+      benchmarkResultIds: [10],
+    });
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact('gpu_metrics_point4'),
+      benchmarkResultIds: [13],
+    });
+    await sql`delete from gpu_metric_series where file_name = 'host-b/gpu_metrics.csv'`;
+    const receipt = await readTelemetryReceipt(sql, run, points);
+    const partial = receipt.points.find((point) => point.benchmarkResultId === 10)!;
+    expect(partial.storage).toEqual({
+      status: 'incomplete',
+      expectedSeries: [
+        { artifactName: 'gpu_metrics_point1', fileName: 'host-a/gpu_metrics.csv', sampleCount: 2 },
+        { artifactName: 'gpu_metrics_point1', fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
+      ],
+    });
+    expect(partial.series).toMatchObject([{ fileName: 'host-a/gpu_metrics.csv', sampleCount: 2 }]);
+    expect(partial.reasons).toContain('series_coverage_incomplete');
+    expect(partial.recovery).toEqual({ ...run, artifactNames: ['gpu_metrics_point1'] });
+    expect(receipt.counts).toMatchObject({
+      storedPoints: 1,
+      linkedPoints: 1,
+      storedSeries: 2,
+      storedSamples: 4,
+    });
+    await verifyTelemetryApi(receipt, 'http://local.test', {
+      fetch: (input) =>
+        Promise.resolve(
+          new URL(String(input)).searchParams.get('id') === '10'
+            ? Response.json({
+                benchmarkResultId: 10,
+                series: partial.series.map((entry) => ({
+                  id: entry.id,
+                  sampleCount: entry.sampleCount,
+                  data: [{ power: 100 }, { power: 200 }],
+                })),
+              })
+            : new Response('missing', { status: 404 }),
+        ),
+    });
+    expect(partial.api.status).toBe('readable');
+    expect(receipt.counts).toMatchObject({ apiReadablePoints: 1, apiCompletePoints: 0 });
+    const recovered = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: multi,
+      benchmarkResultIds: [10],
+    });
+    expect(recovered).toMatchObject({ seriesSkipped: 1, samplesInserted: 2 });
+    const repaired = await readTelemetryReceipt(sql, run, [points[0]!], {
+      previous: receipt,
+      targeted: true,
+    });
+    const repairedPoint = repaired.points.find((point) => point.benchmarkResultId === 10)!;
+    expect(repairedPoint.storage.status).toBe('complete');
+    expect(repairedPoint.reasons).toEqual([]);
+    expect(repairedPoint.api.status).toBe('unknown');
+    expect(repaired.counts).toMatchObject({
+      storedPoints: 2,
+      linkedPoints: 2,
+      storedSeries: 3,
+      storedSamples: 6,
+    });
+    expect(repaired.points.filter((point) => point.benchmarkResultId !== 10)).toEqual(
+      receipt.points.filter((point) => point.benchmarkResultId !== 10),
+    );
+    const replay = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: multi,
+      benchmarkResultIds: [10],
+    });
+    expect(replay).toMatchObject({ seriesSkipped: 2, samplesInserted: 0 });
+    const sampleCount = await sql`select count(*)::int as count from gpu_metric_samples`;
+    expect(sampleCount).toEqual([{ count: 6 }]);
+  });
+
+  it('distinguishes missing sample coverage from legacy unknown inventory', async () => {
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact('gpu_metrics_point1'),
+      benchmarkResultIds: [10],
+    });
+    await sql`delete from gpu_metric_samples where sampled_at = '2026-09-21T00:00:01Z'`;
+    const partial = await readTelemetryReceipt(sql, run, await observations());
+    expect(partial.points.find((point) => point.benchmarkResultId === 10)?.reasons).toContain(
+      'sample_coverage_incomplete',
+    );
+    expect(partial.counts).toMatchObject({ storedPoints: 0, linkedPoints: 0, storedSamples: 1 });
+    await sql`update gpu_metric_series set sidecars = sidecars - 'seriesInventory'`;
+    const legacy = await readTelemetryReceipt(sql, run, await observations());
+    expect(legacy.points.find((point) => point.benchmarkResultId === 10)).toMatchObject({
+      storage: { status: 'unknown', expectedSeries: null },
+      reasons: ['series_inventory_unknown'],
+    });
+    expect(legacy.counts).toMatchObject({
+      storedPoints: 0,
+      linkedPoints: 0,
+      storageUnknownPoints: 1,
+    });
+  });
+
+  it('does not count readable old data as a successful corrective ingest', async () => {
+    const source = artifact('gpu_metrics_point1');
+    const csvPath = path.join(source.artifactDir, 'gpu_metrics.csv');
+    const originalCsv = fs.readFileSync(csvPath, 'utf8');
+    const original = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: source,
+      benchmarkResultIds: [10],
+    });
+    const points = await observations();
+    fs.writeFileSync(csvPath, originalCsv.replaceAll(', 0,', ', 999999,'));
+    try {
+      await ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact: source,
+        benchmarkResultIds: [10],
+      });
+      throw new Error('Expected the corrective ingest to fail');
+    } catch (error) {
+      points[0]!.error = error instanceof Error ? error.message : String(error);
+    }
+    expect(points[0]!.error).toContain('smallint');
+    const failed = await readTelemetryReceipt(sql, run, points);
+    const fetcher: typeof fetch = (input) =>
+      Promise.resolve(
+        new URL(String(input)).searchParams.get('id') === '10'
+          ? Response.json({
+              benchmarkResultId: 10,
+              series: [
+                {
+                  id: original.seriesIds[0],
+                  sampleCount: 2,
+                  data: [{ power: 100 }, { power: 200 }],
+                },
+              ],
+            })
+          : new Response('missing', { status: 404 }),
+      );
+    await verifyTelemetryApi(failed, 'http://local.test', { fetch: fetcher });
+    expect(failed.points.find((point) => point.benchmarkResultId === 10)).toMatchObject({
+      storage: { status: 'complete' },
+      api: { status: 'readable' },
+      reasons: ['ingest_failed'],
+    });
+    expect(failed.counts).toMatchObject({
+      storedPoints: 1,
+      apiReadablePoints: 1,
+      apiCompletePoints: 0,
+    });
+
+    fs.writeFileSync(csvPath, originalCsv);
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: source,
+      benchmarkResultIds: [10],
+    });
+    delete points[0]!.error;
+    const repaired = await readTelemetryReceipt(sql, run, [points[0]!], {
+      previous: failed,
+      targeted: true,
+    });
+    await verifyTelemetryApi(repaired, 'http://local.test', { fetch: fetcher });
+    expect(repaired.points.find((point) => point.benchmarkResultId === 10)?.error).toBeUndefined();
+    expect(repaired.counts.apiCompletePoints).toBe(1);
+
+    repaired.recoveryError = 'Artifact recovery did not finish';
+    repaired.recoveryArtifactNames = ['gpu_metrics_point1'];
+    expect(summarizeTelemetryReceipt(repaired).counts).toMatchObject({
+      apiReadablePoints: 1,
+      apiCompletePoints: 0,
+    });
+    const retried = await readTelemetryReceipt(sql, run, [points[0]!], {
+      previous: repaired,
+      targeted: true,
+    });
+    await verifyTelemetryApi(retried, 'http://local.test', { fetch: fetcher });
+    expect(retried.recoveryError).toBeUndefined();
+    expect(retried.counts.apiCompletePoints).toBe(1);
+  });
+
+  it('does not clear a failed recovery when only an unrelated artifact is repaired', async () => {
+    const points = await observations();
+    for (const index of [0, 1])
+      await ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact: artifact(`gpu_metrics_point${index + 1}`),
+        benchmarkResultIds: [10 + index],
+      });
+    const previous = await readTelemetryReceipt(sql, run, points);
+    previous.recoveryError = 'No retained telemetry pair for gpu_metrics_point1';
+    previous.recoveryArtifactNames = ['gpu_metrics_point1'];
+    const stillMissing = await readTelemetryReceipt(
+      sql,
+      run,
+      [{ ...points[0]!, produced: false }, points[1]!],
+      { previous },
+    );
+    expect(stillMissing.recoveryError).toBe(previous.recoveryError);
+    expect(stillMissing.recoveryArtifactNames).toEqual(['gpu_metrics_point1']);
+    const unrelated = await readTelemetryReceipt(sql, run, [points[1]!], {
+      previous,
+      targeted: true,
+    });
+    expect(unrelated.recoveryError).toBe(previous.recoveryError);
+    expect(unrelated.recoveryArtifactNames).toEqual(['gpu_metrics_point1']);
+    await verifyTelemetryApi(unrelated, 'http://local.test', {
+      fetch: async (input) => {
+        const payload = await getGpuMetricsForPoint(
+          sql as unknown as DbClient,
+          Number(new URL(String(input)).searchParams.get('id')),
+        );
+        return payload ? Response.json(payload) : new Response(null, { status: 404 });
+      },
+    });
+    expect(unrelated.counts).toMatchObject({ apiReadablePoints: 2, apiCompletePoints: 0 });
+    const recovered = await readTelemetryReceipt(sql, run, [points[0]!], {
+      previous: unrelated,
+      targeted: true,
+    });
+    expect(recovered.recoveryError).toBeUndefined();
+    expect(recovered.recoveryArtifactNames).toBeUndefined();
+
+    previous.recoveryArtifactNames = ['gpu_metrics_point1', 'gpu_metrics_point2'];
+    const firstRepair = await readTelemetryReceipt(sql, run, [points[0]!], {
+      previous,
+      targeted: true,
+    });
+    expect(firstRepair.recoveryArtifactNames).toEqual(['gpu_metrics_point2']);
+    const secondRepair = await readTelemetryReceipt(sql, run, [points[1]!], {
+      previous: firstRepair,
+      targeted: true,
+    });
+    expect(secondRepair.recoveryError).toBeUndefined();
+
+    delete previous.recoveryArtifactNames;
+    const legacy = await readTelemetryReceipt(sql, run, [points[0]!], {
+      previous,
+      targeted: true,
+    });
+    expect(legacy.recoveryError).toBe(previous.recoveryError);
+    const partialRefresh = await readTelemetryReceipt(sql, run, [points[0]!], { previous: legacy });
+    expect(partialRefresh.recoveryError).toBe(previous.recoveryError);
+    const refreshed = await readTelemetryReceipt(sql, run, points, { previous: legacy });
+    expect(refreshed.recoveryError).toBeUndefined();
+  });
+
+  it('advances API readability only after the matching HTTP payload, preserving 404/error evidence', async () => {
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact('gpu_metrics_point1'),
+      benchmarkResultIds: [10],
+    });
+    const receipt = await readTelemetryReceipt(sql, run, await observations());
+    const point = receipt.points.find((p) => p.benchmarkResultId === 10)!;
+    const requests: string[] = [];
+    const fetcher: typeof fetch = (input) => {
+      const url = new URL(String(input));
+      requests.push(url.toString());
+      if (url.searchParams.get('id') !== '10')
+        return Promise.resolve(new Response('missing', { status: 404 }));
+      return Promise.resolve(
+        Response.json({
+          benchmarkResultId: 10,
+          series: [
+            { id: point.series[0]!.id, sampleCount: 2, data: [{ power: 100 }, { power: 200 }] },
+          ],
+        }),
+      );
+    };
+    expect(receipt.counts.apiReadablePoints).toBe(0);
+    const checked = await verifyTelemetryApi(receipt, 'http://local.test', { fetch: fetcher });
+    expect(requests).toHaveLength(4);
+    expect(checked.counts).toMatchObject({
+      apiReadablePoints: 1,
+      apiCompletePoints: 1,
+      apiUnknownPoints: 0,
+    });
+    expect(point.api.status).toBe('readable');
+    expect(checked.points.find((p) => p.benchmarkResultId === 11)?.api.error).toBe('HTTP 404');
+    await verifyTelemetryApi(receipt, 'http://local.test', {
+      fetch: () => Promise.resolve(Response.json({ benchmarkResultId: 10, series: [] })),
+    });
+    expect(point.api.status).toBe('failed');
+  });
+});
diff --git a/packages/db/src/etl/telemetry-receipt.ts b/packages/db/src/etl/telemetry-receipt.ts
new file mode 100644
index 000000000..f618538bb
--- /dev/null
+++ b/packages/db/src/etl/telemetry-receipt.ts
@@ -0,0 +1,447 @@
+import type { Sql } from './db-utils';
+import type { ArtifactMeta, RunMeta } from '../lib/github-artifacts';
+import { stablePowerPointIdentity } from './power-publication';
+import { gpuMetricsArtifactSuffix } from './gpu-metrics-artifacts';
+
+export interface TelemetryObservation {
+  identity: Record<string, unknown>;
+  /** Exact selected artifact names, or both allowed sibling names when absent. */
+  artifactNames: string[];
+  produced: boolean | null;
+  error?: string;
+}
+
+interface TelemetrySeriesCoverage {
+  artifactName: string;
+  fileName: string;
+  sampleCount: number;
+}
+
+export interface TelemetryPointReceipt extends TelemetryObservation {
+  key: string;
+  benchmarkResultId: number | null;
+  series: (TelemetrySeriesCoverage & { id: number })[];
+  storage: {
+    status: 'complete' | 'incomplete' | 'unknown';
+    /** Null means the original artifact inventory was not retained. */
+    expectedSeries: TelemetrySeriesCoverage[] | null;
+  };
+  linkedSeriesIds: number[];
+  api: {
+    status: 'unknown' | 'readable' | 'failed';
+    checkedAt?: string;
+    url?: string;
+    error?: string;
+  };
+  reasons: string[];
+  recovery: { runId: number; runAttempt: number; artifactNames: string[] };
+}
+
+export interface TelemetryReceipt {
+  version: 1;
+  runId: number;
+  runAttempt: number;
+  checkedAt: string;
+  /** This is attachment coverage for known benchmark points, not a full-sweep verdict. */
+  expectedSource: 'benchmark_artifacts' | 'database_benchmarks' | 'unknown';
+  /** No complete independent planned matrix is available to this attachment reader. */
+  plannedPointCount: null;
+  databaseError?: string;
+  recoveryError?: string;
+  /** Missing on older receipts or when the failed recovery covered the whole run. */
+  recoveryArtifactNames?: string[];
+  /** The sibling is known, but a download/parse failure prevents identifying its points. */
+  expectationErrors?: { benchmarkArtifact: string; artifactNames: string[]; error: string }[];
+  points: TelemetryPointReceipt[];
+  counts: {
+    expectedPoints: number | null;
+    producedPoints: number;
+    productionUnknownPoints: number;
+    storedPoints: number | null;
+    linkedPoints: number | null;
+    storageUnknownPoints: number;
+    /** Actual successful HTTP reads, including readable but incomplete artifacts. */
+    apiReadablePoints: number;
+    /** Readable, fully stored/linked points with no outstanding corrective-ingest failure. */
+    apiCompletePoints: number;
+    apiUnknownPoints: number;
+    producedArtifacts: number;
+    storedSeries: number | null;
+    storedSamples: number | null;
+  };
+}
+
+interface StoredPoint extends Record<string, unknown> {
+  id: number;
+}
+
+interface StoredSeries {
+  id: number;
+  artifact_name: string;
+  file_name: string;
+  sidecars: { seriesInventory?: unknown };
+  sample_count: number;
+  benchmark_result_ids: number[];
+}
+
+function isInventoryEntry(value: unknown): value is { fileName: string; sampleCount: number } {
+  if (value === null || typeof value !== 'object') return false;
+  const entry = value as Record<string, unknown>;
+  return (
+    typeof entry.fileName === 'string' &&
+    typeof entry.sampleCount === 'number' &&
+    Number.isSafeInteger(entry.sampleCount) &&
+    entry.sampleCount >= 0
+  );
+}
+
+function seriesCoverageKey(artifact: string, file: string): string {
+  return JSON.stringify([artifact, file]);
+}
+
+function seriesCoverage(
+  series: readonly StoredSeries[],
+  reasons: string[],
+): TelemetryPointReceipt['storage'] {
+  if (series.length === 0) return { status: 'incomplete', expectedSeries: null };
+  const expected = new Map<string, TelemetrySeriesCoverage>();
+  const inventories = new Map<string, string>();
+  let unknown = false;
+  for (const entry of series) {
+    const inventory = entry.sidecars?.seriesInventory;
+    if (!Array.isArray(inventory) || inventory.length === 0 || !inventory.every(isInventoryEntry)) {
+      unknown = true;
+      continue;
+    }
+    const signature = JSON.stringify(
+      inventory.toSorted((a, b) => a.fileName.localeCompare(b.fileName)),
+    );
+    const previous = inventories.get(entry.artifact_name);
+    if (previous && previous !== signature) unknown = true;
+    inventories.set(entry.artifact_name, signature);
+    if (!inventory.some((item) => item.fileName === entry.file_name)) unknown = true;
+    for (const item of inventory) {
+      expected.set(seriesCoverageKey(entry.artifact_name, item.fileName), {
+        artifactName: entry.artifact_name,
+        ...item,
+      });
+    }
+  }
+  const actual = new Map(
+    series.map((entry) => [seriesCoverageKey(entry.artifact_name, entry.file_name), entry]),
+  );
+  const missing = [...expected].some(([name]) => !actual.has(name));
+  const wrongSamples = [...expected].some(([name, entry]) => {
+    const stored = actual.get(name);
+    return stored !== undefined && Number(stored.sample_count) !== entry.sampleCount;
+  });
+  if (missing) reasons.push('series_coverage_incomplete');
+  if (wrongSamples) reasons.push('sample_coverage_incomplete');
+  if (unknown) reasons.push('series_inventory_unknown');
+  return {
+    status:
+      missing || wrongSamples || series.some((entry) => Number(entry.sample_count) === 0)
+        ? 'incomplete'
+        : unknown
+          ? 'unknown'
+          : 'complete',
+    expectedSeries: expected.size > 0 ? [...expected.values()] : null,
+  };
+}
+
+/** GitHub's run-wide listing also retains artifacts from earlier attempts. */
+export function telemetryArtifactsForAttempt(
+  artifacts: readonly ArtifactMeta[],
+  source: Pick<RunMeta, 'run_attempt' | 'run_started_at'>,
+  targetAttempt: number,
+): ArtifactMeta[] {
+  if (source.run_attempt !== targetAttempt)
+    throw new Error(
+      `GitHub attempt ${source.run_attempt} differs from target ${targetAttempt}; refusing mixed-attempt telemetry recovery`,
+    );
+  const start = Date.parse(source.run_started_at ?? '');
+  if (!Number.isFinite(start))
+    throw new Error('Cannot isolate telemetry artifacts without attempt start time');
+  return artifacts.filter((artifact) => Date.parse(artifact.created_at) >= start);
+}
+
+/** Count identities, artifacts, series and samples separately; shared series count once. */
+export function summarizeTelemetryReceipt(receipt: TelemetryReceipt): TelemetryReceipt {
+  const points = receipt.points;
+  const series = new Map(points.flatMap((point) => point.series.map((s) => [s.id, s] as const)));
+  const complete = points.filter((point) => point.storage?.status === 'complete');
+  const linked = complete.filter((point) =>
+    point.series.every((s) => point.linkedSeriesIds.includes(s.id)),
+  );
+  receipt.counts = {
+    expectedPoints:
+      receipt.expectedSource === 'unknown' || receipt.expectationErrors?.length
+        ? null
+        : points.length,
+    producedPoints: points.filter((p) => p.produced === true).length,
+    productionUnknownPoints: points.filter((p) => p.produced === null).length,
+    storedPoints: receipt.databaseError ? null : complete.length,
+    linkedPoints: receipt.databaseError ? null : linked.length,
+    storageUnknownPoints: points.filter(
+      (point) => !point.storage || point.storage.status === 'unknown',
+    ).length,
+    apiReadablePoints: points.filter((p) => p.api.status === 'readable').length,
+    apiCompletePoints:
+      receipt.databaseError || receipt.recoveryError
+        ? 0
+        : linked.filter((point) => point.api.status === 'readable' && !point.error).length,
+    apiUnknownPoints: points.filter((p) => p.api.status === 'unknown').length,
+    producedArtifacts: new Set(
+      points.filter((p) => p.produced === true).flatMap((p) => p.artifactNames),
+    ).size,
+    storedSeries: receipt.databaseError ? null : series.size,
+    storedSamples: receipt.databaseError
+      ? null
+      : [...series.values()].reduce((sum, s) => sum + s.sampleCount, 0),
+  };
+  return receipt;
+}
+
+/** Absent observations name alternative siblings, not two required uploads. */
+function coversArtifactScope(
+  current: TelemetryObservation,
+  previous: TelemetryObservation,
+): boolean {
+  return (
+    previous.artifactNames.length > 0 &&
+    previous.artifactNames.every(
+      (name) =>
+        current.artifactNames.includes(name) ||
+        (previous.produced === false &&
+          gpuMetricsArtifactSuffix(name) !== null &&
+          current.artifactNames.some(
+            (candidate) => gpuMetricsArtifactSuffix(candidate) === gpuMetricsArtifactSuffix(name),
+          )),
+    )
+  );
+}
+
+/** Read actual persistence/link state, preserving unrelated points on targeted recovery. */
+export async function readTelemetryReceipt(
+  sql: Sql,
+  run: { runId: number; runAttempt: number },
+  observations: readonly TelemetryObservation[],
+  options: {
+    expectedSource?: TelemetryReceipt['expectedSource'];
+    previous?: TelemetryReceipt;
+    targeted?: boolean;
+    /** Mapped identity -> persisted ID, only from the historical resolver's unique fallback. */
+    uniqueFallbacks?: ReadonlyMap<string, number>;
+  } = {},
+): Promise<TelemetryReceipt> {
+  const previous = options.previous;
+  if (previous && (previous.runId !== run.runId || previous.runAttempt !== run.runAttempt))
+    throw new Error('Telemetry receipt run/attempt does not match the recovery target');
+  const receipt: TelemetryReceipt = {
+    version: 1,
+    ...run,
+    checkedAt: new Date().toISOString(),
+    expectedSource: options.expectedSource ?? previous?.expectedSource ?? 'database_benchmarks',
+    plannedPointCount: null,
+    points: [],
+    counts: {} as TelemetryReceipt['counts'],
+  };
+  let rows: StoredPoint[] = [];
+  let series: StoredSeries[] = [];
+  try {
+    rows = await sql<StoredPoint[]>`
+      select c.*, br.id, br.benchmark_type, br.isl, br.osl, br.conc,
+        br.offload_mode, br.recipe_fingerprint
+      from benchmark_results br
+      join configs c on c.id = br.config_id
+      join workflow_runs wr on wr.id = br.workflow_run_id
+      where wr.github_run_id = ${run.runId} and wr.run_attempt = ${run.runAttempt}
+      order by br.id
+    `;
+    series = await sql<StoredSeries[]>`
+      select s.id, s.artifact_name, s.file_name, s.sidecars,
+        (select count(*)::int from gpu_metric_samples x where x.series_id = s.id) as sample_count,
+        coalesce((select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
+          from benchmark_result_gpu_metrics l
+          join benchmark_results br on br.id = l.benchmark_result_id
+          where l.series_id = s.id and br.workflow_run_id = s.workflow_run_id), '{}') as benchmark_result_ids
+      from gpu_metric_series s join workflow_runs wr on wr.id = s.workflow_run_id
+      where wr.github_run_id = ${run.runId} and wr.run_attempt = ${run.runAttempt}
+      order by s.id
+    `;
+  } catch (error) {
+    receipt.databaseError = error instanceof Error ? error.message : String(error);
+    if (observations.length === 0 && !previous) receipt.expectedSource = 'unknown';
+  }
+  const stored = new Map(rows.map((row) => [stablePowerPointIdentity(row), row]));
+  const storedById = new Map(rows.map((row) => [Number(row.id), row]));
+  const prior = new Map(previous?.points.map((point) => [point.key, point]));
+  const observed = new Map(
+    observations.map((point) => [stablePowerPointIdentity(point.identity), point]),
+  );
+  for (const [key, id] of options.uniqueFallbacks ?? []) {
+    const observation = observed.get(key);
+    const row = storedById.get(id);
+    if (receipt.databaseError || !observation || !row || stored.has(key)) continue;
+    // The resolver allows historical offload drift only; keep every other dimension exact.
+    const identity = { ...observation.identity, offload_mode: row.offload_mode };
+    const canonicalKey = stablePowerPointIdentity(identity);
+    if (canonicalKey !== stablePowerPointIdentity(row)) continue;
+    const collision = observed.get(canonicalKey);
+    const priorCanonical = prior.get(canonicalKey);
+    if (
+      (priorCanonical &&
+        (priorCanonical.artifactNames.length > 0 || priorCanonical.error) &&
+        !coversArtifactScope(observation, priorCanonical)) ||
+      (collision &&
+        (collision.produced !== observation.produced ||
+          collision.error !== observation.error ||
+          collision.artifactNames.length !== observation.artifactNames.length ||
+          collision.artifactNames.some((name) => !observation.artifactNames.includes(name))))
+    ) {
+      receipt.expectedSource = 'unknown';
+      continue;
+    }
+    observed.delete(key);
+    observed.set(canonicalKey, { ...observation, identity });
+    const old = prior.get(key);
+    if (old?.benchmarkResultId === null && coversArtifactScope(observation, old)) prior.delete(key);
+  }
+  const resolvedObservations = [...observed.values()];
+  const pendingRecoveryArtifacts = previous?.recoveryArtifactNames?.filter(
+    (name) =>
+      !resolvedObservations.some(
+        (point) => point.produced === true && !point.error && point.artifactNames.includes(name),
+      ),
+  );
+  const successfulKeys = new Set(
+    resolvedObservations
+      .filter((point) => point.produced === true && !point.error)
+      .map((point) => stablePowerPointIdentity(point.identity)),
+  );
+  const recoveryUnresolved = previous?.recoveryArtifactNames?.length
+    ? pendingRecoveryArtifacts?.length
+    : options.targeted ||
+      resolvedObservations.length === 0 ||
+      successfulKeys.size !== resolvedObservations.length ||
+      [...prior.values()].some((point) => !successfulKeys.has(point.key));
+  Object.assign(receipt, {
+    ...(previous?.recoveryError && recoveryUnresolved
+      ? {
+          recoveryError: previous.recoveryError,
+          ...(pendingRecoveryArtifacts ? { recoveryArtifactNames: pendingRecoveryArtifacts } : {}),
+        }
+      : {}),
+    ...(previous?.expectationErrors
+      ? {
+          expectationErrors: previous.expectationErrors.filter(
+            (error) =>
+              !resolvedObservations.some((point) =>
+                point.artifactNames.some((name) => error.artifactNames.includes(name)),
+              ),
+          ),
+        }
+      : {}),
+  });
+  const keys = new Set([...prior.keys(), ...stored.keys(), ...observed.keys()]);
+  for (const key of keys) {
+    const old = prior.get(key);
+    if (options.targeted && old && !observed.has(key)) {
+      receipt.points.push(old);
+      continue;
+    }
+    const row = stored.get(key);
+    const benchmarkResultId = row ? Number(row.id) : null;
+    const linked = series.filter((s) =>
+      s.benchmark_result_ids.map(Number).includes(benchmarkResultId!),
+    );
+    const observation = observed.get(key) ??
+      old ?? {
+        identity: row!,
+        artifactNames: [...new Set(linked.map((s) => s.artifact_name))],
+        produced: linked.length > 0 ? true : null,
+      };
+    const matching = series.filter((s) => observation.artifactNames.includes(s.artifact_name));
+    const reasons: string[] = [];
+    if (observation.produced === false) reasons.push('artifact_missing');
+    if (observation.produced === null) reasons.push('artifact_pair_unknown');
+    if (observation.error) reasons.push('ingest_failed');
+    if (receipt.databaseError) reasons.push('database_check_failed');
+    else {
+      if (benchmarkResultId === null) reasons.push('benchmark_not_stored');
+      if (matching.length === 0) reasons.push('series_not_stored');
+      else if (matching.some((s) => Number(s.sample_count) === 0)) reasons.push('samples_missing');
+      if (matching.some((s) => !linked.includes(s))) reasons.push('point_link_missing');
+    }
+    const storage: TelemetryPointReceipt['storage'] = receipt.databaseError
+      ? { status: 'unknown', expectedSeries: null }
+      : seriesCoverage(matching, reasons);
+    receipt.points.push({
+      identity: observation.identity,
+      artifactNames: observation.artifactNames,
+      produced: observation.produced,
+      ...(observation.error ? { error: observation.error } : {}),
+      key,
+      benchmarkResultId,
+      series: matching.map((s) => ({
+        id: Number(s.id),
+        artifactName: s.artifact_name,
+        fileName: s.file_name,
+        sampleCount: Number(s.sample_count),
+      })),
+      storage,
+      linkedSeriesIds: linked.filter((s) => matching.includes(s)).map((s) => Number(s.id)),
+      api: { status: 'unknown' },
+      reasons,
+      recovery: { ...run, artifactNames: observation.artifactNames },
+    });
+  }
+  receipt.points.sort((a, b) => a.key.localeCompare(b.key));
+  return summarizeTelemetryReceipt(receipt);
+}
+
+/** Only an actual HTTP read advances API status; DB-queryable is not API-readable. */
+export async function verifyTelemetryApi(
+  receipt: TelemetryReceipt,
+  origin: string,
+  options: { fetch?: typeof fetch; headers?: HeadersInit } = {},
+): Promise<TelemetryReceipt> {
+  for (const point of receipt.points) {
+    if (point.benchmarkResultId === null) continue;
+    const url = new URL('/api/v1/gpu-metrics-point', origin);
+    url.searchParams.set('id', String(point.benchmarkResultId));
+    const checkedAt = new Date().toISOString();
+    try {
+      const response = await (options.fetch ?? fetch)(url, {
+        headers: options.headers,
+        signal: AbortSignal.timeout(30_000),
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const payload = await response.json();
+      if (payload?.benchmarkResultId !== point.benchmarkResultId || !Array.isArray(payload.series))
+        throw new Error('Point API returned a different identity or invalid series');
+      if (point.series.length === 0 || payload.series.length !== point.series.length)
+        throw new Error('Point API series set differs from stored telemetry');
+      for (const stored of point.series) {
+        const actual = payload.series.find((s: { id: number }) => s.id === stored.id);
+        if (
+          !actual ||
+          stored.sampleCount === 0 ||
+          actual.sampleCount !== stored.sampleCount ||
+          !Array.isArray(actual.data) ||
+          actual.data.length !== stored.sampleCount
+        )
+          throw new Error(`Point API series ${stored.id} sample count differs from storage`);
+      }
+      point.api = { status: 'readable', checkedAt, url: url.toString() };
+    } catch (error) {
+      point.api = {
+        status: 'failed',
+        checkedAt,
+        url: url.toString(),
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+  return summarizeTelemetryReceipt(receipt);
+}
diff --git a/packages/db/src/ingest-ci-run.test.ts b/packages/db/src/ingest-ci-run.test.ts
index 19812f372..cc464e52d 100644
--- a/packages/db/src/ingest-ci-run.test.ts
+++ b/packages/db/src/ingest-ci-run.test.ts
@@ -5,6 +5,54 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { describe, expect, it } from 'vitest';
 
+describe('explicit download attempt identity', () => {
+  it.each([
+    { requestedAttempt: 1, expectedStatus: 1 },
+    { requestedAttempt: 2, expectedStatus: 0 },
+  ])('checks the requested attempt $requestedAttempt', ({ requestedAttempt, expectedStatus }) => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'attempt-ingest-'));
+    const manifestPath = path.join(dir, 'power-publication.json');
+    try {
+      fs.writeFileSync(
+        path.join(dir, 'gh'),
+        '#!/bin/sh\ncase "$*" in\n*--paginate*) exit 0 ;;\n*--jq*) printf "2\\n" ;;\n*) exit 3 ;;\nesac\n',
+        { mode: 0o755 },
+      );
+      const result = spawnSync(
+        'bun',
+        [
+          fileURLToPath(new URL('ingest-ci-run.ts', import.meta.url)),
+          '--download',
+          `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/25199291771/attempts/${requestedAttempt}`,
+        ],
+        {
+          cwd: dir,
+          env: {
+            PATH: `${dir}${path.delimiter}${process.env.PATH}`,
+            TMPDIR: dir,
+            NODE_ENV: 'test',
+            DATABASE_WRITE_URL: 'postgres://unused:unused@127.0.0.1:1/unused',
+            GITHUB_TOKEN: 'unused',
+            POWER_PUBLICATION_MANIFEST: manifestPath,
+          },
+          encoding: 'utf8',
+          timeout: 10_000,
+        },
+      );
+      expect(result.error).toBeUndefined();
+      expect(result.status, result.stderr).toBe(expectedStatus);
+      if (expectedStatus === 0) {
+        expect(JSON.parse(fs.readFileSync(manifestPath, 'utf8')).runAttempt).toBe(2);
+      } else {
+        expect(result.stderr).toContain('GitHub attempt 2 differs from requested 1');
+        expect(fs.existsSync(manifestPath)).toBe(false);
+      }
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
 describe('purged CI ingestion', () => {
   it.each([
     { runId: 20286769842, runAttempt: 1, reused: false },
diff --git a/packages/db/src/ingest-ci-run.ts b/packages/db/src/ingest-ci-run.ts
index c2ae094a7..9d470e687 100644
--- a/packages/db/src/ingest-ci-run.ts
+++ b/packages/db/src/ingest-ci-run.ts
@@ -27,6 +27,8 @@ import { createHash } from 'node:crypto';
 import {
   powerPublicationPoint,
   publicationIdentity,
+  benchmarkPublicationIdentity,
+  stablePowerPointIdentity,
   type PowerPublicationPoint,
 } from './etl/power-publication';
 import os from 'os';
@@ -81,6 +83,7 @@ import { discoverTraceReplayArtifacts } from './etl/trace-artifact-discovery';
 import { discoverServerLogArtifacts, readServerLogArtifact } from './etl/server-log-artifacts';
 import { discoverGpuMetricsArtifacts } from './etl/gpu-metrics-artifacts';
 import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest';
+import { readTelemetryReceipt, type TelemetryObservation } from './etl/telemetry-receipt';
 import { datasetSlugFromBenchmarkRow } from './etl/dataset-provenance';
 import { mapAggEvalRow, mapEvalRow } from './etl/eval-mapper';
 import { ingestEvalRow } from './etl/eval-ingest';
@@ -99,6 +102,9 @@ import {
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 const powerPublicationPoints = new Map<string, PowerPublicationPoint>();
 const powerPublicationErrors: string[] = [];
+const telemetryObservations = new Map<string, TelemetryObservation>();
+let telemetryExpectationsUnknown = false;
+let checkTelemetry = false;
 const tracker = createSkipTracker();
 const isDownloadMode = process.argv[2] === '--download';
 
@@ -154,6 +160,15 @@ if (isDownloadMode) {
     input.match(/^https:\/\/github\.com\/(?<repo>[^/]+\/[^/]+)\/actions\/runs\/\d+/u)?.[1] ??
     DEFAULT_REPO;
 
+  runAttemptNum = fetchRunAttempt(REPO, runIdStr);
+  const requestedAttempt = input.match(/\/attempts\/(?<attempt>\d+)/u)?.groups?.attempt;
+  if (requestedAttempt && Number(requestedAttempt) !== runAttemptNum) {
+    throw new Error(
+      `GitHub attempt ${runAttemptNum} differs from requested ${requestedAttempt}; ` +
+        'use retained artifacts and exact source metadata for historical-attempt ingestion',
+    );
+  }
+
   // Download artifacts
   tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ingest-'));
   artifactsDir = tempDir;
@@ -197,8 +212,6 @@ if (isDownloadMode) {
   }
 
   console.log(`\n  Downloaded ${byLogical.size} artifact(s)`);
-
-  runAttemptNum = fetchRunAttempt(REPO, runIdStr);
 } else {
   // CI mode — read from env vars
   for (const key of [
@@ -289,6 +302,7 @@ async function main(): Promise<void> {
   }
 
   validateRunBackfills();
+  checkTelemetry = true;
   const configCache = createConfigCache(sql);
   const { getOrCreateConfig, preloadConfigs } = configCache;
   const { fetchGithubRun, getOrCreateWorkflowRun } = createWorkflowRunServices(sql, GITHUB_TOKEN, [
@@ -548,6 +562,7 @@ async function main(): Promise<void> {
       );
       const data = readJson(file);
       if (!data) {
+        telemetryExpectationsUnknown = true;
         powerPublicationErrors.push(`Unreadable benchmark JSON: ${relativeFile}`);
         console.log(`    skipped unreadable JSON (${elapsed(fileStart)})`);
         continue;
@@ -564,16 +579,26 @@ async function main(): Promise<void> {
         if (datasetSlug) datasetSlugs.add(datasetSlug);
       }
 
+      let fileExpectationsUnknown = false;
       const rows = rawRows
-        .filter((r) => typeof r === 'object' && r !== null)
+        .filter((r) => {
+          const isRow = typeof r === 'object' && r !== null;
+          if (!isRow) fileExpectationsUnknown = true;
+          return isRow;
+        })
         .map((r) => {
+          const failedRuns = tracker.skips.failedRun;
           const mapped = mapBenchmarkRow(r, tracker, undefined, runIdStr);
+          // Known failed benchmarks are intentionally excluded; unmappable rows
+          // leave an unknown number of successful attachment expectations.
+          if (!mapped && tracker.skips.failedRun === failedRuns) fileExpectationsUnknown = true;
           if (!mapped && Number(r.isl) === 8192 && Number(r.osl) === 1024) {
             powerPublicationErrors.push(`Unmapped or failed 8K/1K result: ${relativeFile}`);
           }
           return mapped;
         })
         .filter((r): r is NonNullable<typeof r> => r !== null);
+      if (fileExpectationsUnknown) telemetryExpectationsUnknown = true;
 
       console.log(`    mapped rows: ${rows.length}`);
       if (rows.length === 0) {
@@ -582,11 +607,17 @@ async function main(): Promise<void> {
       }
 
       const toInsert = [];
+      const parentDir = path.basename(path.dirname(file));
+      const configKey = parentDir.replace(/^bmk_/u, '');
+      const suffix = stripBmkAndAgenticPrefix(parentDir);
+      const gpuMetricsArtifact =
+        gpuMetricsArtifacts.get(configKey) ?? gpuMetricsArtifacts.get(suffix);
       for (const row of rows) {
         let configId: number;
         try {
           configId = await getOrCreateConfig(row.config);
         } catch (error: any) {
+          telemetryExpectationsUnknown = true;
           tracker.recordDbError(`config for ${path.basename(file)}`, error);
           continue;
         }
@@ -631,6 +662,21 @@ async function main(): Promise<void> {
         if (publication)
           powerPublicationPoints.set(publicationIdentity(publication.identity), publication);
         toInsert.push(applied.point);
+        const identity = benchmarkPublicationIdentity(applied.point);
+        const key = stablePowerPointIdentity(identity);
+        // Aggregate copies may arrive before/after their per-job sibling. Only
+        // the latter establishes whether that exact telemetry artifact exists.
+        if (parentDir.startsWith('bmk_') || !telemetryObservations.has(key)) {
+          telemetryObservations.set(key, {
+            identity,
+            artifactNames: gpuMetricsArtifact
+              ? [gpuMetricsArtifact.artifactName]
+              : parentDir.startsWith('bmk_')
+                ? [`gpu_metrics_${suffix}`, `power_audit_${suffix}`]
+                : [],
+            produced: parentDir.startsWith('bmk_') ? Boolean(gpuMetricsArtifact) : null,
+          });
+        }
       }
       console.log(`    rows with resolved configs: ${toInsert.length}`);
 
@@ -666,14 +712,12 @@ async function main(): Promise<void> {
             });
           }
 
-          const parentDir = path.basename(path.dirname(file));
           if (parentDir.startsWith('bmk_') && insertedIds.length > 0) {
             // Single-turn artifacts are `bmk_<key>` paired with
             // `server_logs_<key>`. Agentic artifacts are `bmk_agentic_<key>`
             // but the server log is still `server_logs_<key>` (no `agentic_`
             // prefix), so fall back to the fully-stripped suffix — otherwise
             // agentic rows never get their server log (and KV-pool size) linked.
-            const configKey = parentDir.replace(/^bmk_/u, '');
             const logArtifact =
               serverLogArtifacts.get(configKey) ??
               serverLogArtifacts.get(stripBmkAndAgenticPrefix(parentDir));
@@ -696,9 +740,6 @@ async function main(): Promise<void> {
             }
             // Same pairing rule as server logs: `gpu_metrics_<key>` carries no
             // `agentic_` prefix, so agentic points fall back to the bare suffix.
-            const gpuMetricsArtifact =
-              gpuMetricsArtifacts.get(configKey) ??
-              gpuMetricsArtifacts.get(stripBmkAndAgenticPrefix(parentDir));
             if (gpuMetricsArtifact) {
               try {
                 const gpuMetricsStart = Date.now();
@@ -707,6 +748,10 @@ async function main(): Promise<void> {
                   artifact: gpuMetricsArtifact,
                   benchmarkResultIds: insertedIds,
                 });
+                if (ingested.seriesIds.length === 0)
+                  throw new Error(
+                    `No parseable telemetry series in ${gpuMetricsArtifact.artifactName}`,
+                  );
                 totalGpuMetricSeries += ingested.seriesIds.length;
                 totalGpuMetricSamples += ingested.samplesInserted;
                 console.log(
@@ -721,6 +766,12 @@ async function main(): Promise<void> {
                 // artifact later. Recording it as a DB error instead would reach
                 // the publication manifest and fail the whole production ingest.
                 tracker.recordTelemetryError(`gpu_metrics for ${configKey}`, error);
+                for (const row of toInsert) {
+                  const point = telemetryObservations.get(
+                    stablePowerPointIdentity(benchmarkPublicationIdentity(row)),
+                  );
+                  if (point) point.error = error instanceof Error ? error.message : String(error);
+                }
               }
             }
           }
@@ -729,7 +780,6 @@ async function main(): Promise<void> {
           // harness emits `agentic_<suffix>/trace_replay/...` next to the
           // `bmk_agentic_<suffix>` artifact we just ingested.
           if (parentDir.startsWith('bmk_agentic_') && insertedIds.length > 0) {
-            const suffix = stripBmkAndAgenticPrefix(parentDir);
             const concMatch = path.basename(file).match(/_conc(?<conc>\d+)\.json$/u);
             const trace =
               (concMatch?.groups?.conc
@@ -1100,9 +1150,24 @@ main()
     console.error('ingest-ci-run failed:', error);
     process.exitCode = 1;
   })
-  .finally(() => {
-    const publicationPath = process.env.POWER_PUBLICATION_MANIFEST;
+  .finally(async () => {
+    const publicationPath =
+      process.env.POWER_PUBLICATION_MANIFEST ??
+      `power-publication-${runIdNum}-attempt-${runAttemptNum}.json`;
     if (publicationPath) {
+      const telemetry = checkTelemetry
+        ? await readTelemetryReceipt(
+            sql,
+            { runId: runIdNum, runAttempt: runAttemptNum },
+            [...telemetryObservations.values()],
+            {
+              expectedSource:
+                !telemetryExpectationsUnknown && telemetryObservations.size > 0
+                  ? 'benchmark_artifacts'
+                  : 'unknown',
+            },
+          )
+        : undefined;
       fs.writeFileSync(
         publicationPath,
         `${JSON.stringify(
@@ -1119,11 +1184,13 @@ main()
             telemetryWarnings: tracker.skips.telemetryError
               ? [`${tracker.skips.telemetryError} gpu_metrics digest errors`]
               : [],
+            ...(telemetry ? { telemetry } : {}),
           },
           null,
           2,
         )}\n`,
       );
+      console.log(`  PowerX ingest receipt: ${publicationPath}`);
     }
     if (tempDir) {
       try {
diff --git a/packages/db/src/ingest-ci-telemetry.test.ts b/packages/db/src/ingest-ci-telemetry.test.ts
new file mode 100644
index 000000000..0d0506b2f
--- /dev/null
+++ b/packages/db/src/ingest-ci-telemetry.test.ts
@@ -0,0 +1,219 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import type * as DbUtils from './etl/db-utils';
+import type * as ConfigCache from './etl/config-cache';
+import type * as BenchmarkIngest from './etl/benchmark-ingest';
+import type * as ChangelogIngest from './etl/changelog-ingest';
+import type * as TelemetryReceipt from './etl/telemetry-receipt';
+import type * as RunOverrides from './etl/run-overrides';
+
+const mocks = vi.hoisted(() => ({
+  finish: undefined as (() => void) | undefined,
+  persistBenchmark: vi.fn(() => Promise.resolve({ newCount: 1, dupCount: 0, insertedIds: [10] })),
+  configFailure: false,
+  purgeExtra: false,
+  serverLogFailure: false,
+}));
+vi.mock('./etl/db-utils', async (importOriginal) => ({
+  ...(await importOriginal<typeof DbUtils>()),
+  createAdminSql: () =>
+    Object.assign(() => Promise.resolve([{ n: 1 }]), {
+      end: () => Promise.resolve(mocks.finish?.()),
+    }),
+  refreshLatestBenchmarks: async () => {},
+}));
+vi.mock('./etl/config-cache', async (importOriginal) => ({
+  ...(await importOriginal<typeof ConfigCache>()),
+  createConfigCache: () => ({
+    getOrCreateConfig: (config: { hardware: string }) =>
+      mocks.configFailure && config.hardware === 'b200'
+        ? Promise.reject(new Error('Fixture config failure'))
+        : Promise.resolve(1),
+    preloadConfigs: async () => {},
+    size: 1,
+  }),
+}));
+vi.mock('./etl/workflow-run', () => ({
+  createWorkflowRunServices: () => ({
+    fetchGithubRun: () => Promise.resolve({ createdAt: '2026-09-21T00:00:00Z' }),
+    getOrCreateWorkflowRun: () => Promise.resolve(1),
+  }),
+}));
+vi.mock('./etl/benchmark-ingest', async (importOriginal) => ({
+  ...(await importOriginal<typeof BenchmarkIngest>()),
+  bulkIngestBenchmarkRows: mocks.persistBenchmark,
+  bulkUpsertAvailability: async () => {},
+  insertServerLogFiles: () => Promise.reject(new Error('Fixture server log failure')),
+}));
+vi.mock('./etl/changelog-ingest', async (importOriginal) => ({
+  ...(await importOriginal<typeof ChangelogIngest>()),
+  ingestChangelogEntries: () => Promise.resolve(1),
+}));
+vi.mock('./etl/telemetry-receipt', async (importOriginal) => ({
+  ...(await importOriginal<typeof TelemetryReceipt>()),
+  readTelemetryReceipt: (
+    _sql: unknown,
+    run: unknown,
+    observations: unknown,
+    options: { expectedSource: string },
+  ) =>
+    Promise.resolve({
+      run,
+      points: observations,
+      expectedSource: options.expectedSource,
+    }),
+}));
+vi.mock('./etl/run-overrides', async (importOriginal) => {
+  const actual = await importOriginal<typeof RunOverrides>();
+  return {
+    ...actual,
+    isBenchmarkPointPurged: (...args: Parameters<typeof RunOverrides.isBenchmarkPointPurged>) =>
+      (mocks.purgeExtra && args[2].conc === 2) || actual.isBenchmarkPointPurged(...args),
+  };
+});
+
+beforeEach(() => {
+  vi.resetModules();
+  vi.clearAllMocks();
+  mocks.configFailure = false;
+  mocks.purgeExtra = false;
+  mocks.serverLogFailure = false;
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  vi.restoreAllMocks();
+});
+
+interface Scenario {
+  name: string;
+  extra?: Record<string, unknown> | string;
+  unknown?: boolean;
+  configFailure?: boolean;
+  purgeExtra?: boolean;
+  serverLogFailure?: boolean;
+  ingestError?: string;
+}
+const scenarios: Scenario[] = [
+  { name: 'unreadable telemetry alone' },
+  {
+    name: 'unreadable benchmark JSON',
+    extra: '{',
+    unknown: true,
+    ingestError: 'Unreadable benchmark JSON: bmk_agentic_extra/agg.json',
+  },
+  { name: 'non-object benchmark JSON', extra: '42', unknown: true },
+  { name: 'unmapped model', extra: { infmax_model_prefix: 'unknown-model' }, unknown: true },
+  { name: 'unmapped hardware', extra: { hw: 'unknown-hardware' }, unknown: true },
+  { name: 'missing concurrency', extra: { users: null, conc: null }, unknown: true },
+  {
+    name: 'missing sequence length',
+    extra: { scenario_type: 'single_turn', isl: null, osl: 1024 },
+    unknown: true,
+  },
+  {
+    name: 'config resolution failure',
+    extra: { hw: 'b200' },
+    configFailure: true,
+    unknown: true,
+    ingestError: '1 database ingest errors',
+  },
+  { name: 'explicit failed benchmark', extra: { benchmark_outcome: { status: 'failed' } } },
+  {
+    name: 'zero successful requests',
+    extra: { num_requests_total: 2, num_requests_successful: 0 },
+  },
+  { name: 'purged benchmark', extra: {}, purgeExtra: true },
+  {
+    name: 'unrelated server log failure',
+    serverLogFailure: true,
+    ingestError: '1 database ingest errors',
+  },
+];
+
+it.each(scenarios)(
+  'keeps the benchmark and honest expectation scope with $name',
+  async (scenario) => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ci-telemetry-'));
+    const originalArgv = process.argv;
+    const originalExitCode = process.exitCode;
+    try {
+      mocks.configFailure = scenario.configFailure ?? false;
+      mocks.purgeExtra = scenario.purgeExtra ?? false;
+      mocks.serverLogFailure = scenario.serverLogFailure ?? false;
+      process.argv = ['bun', 'ingest-ci-run.ts'];
+      process.exitCode = undefined;
+      for (const [key, value] of Object.entries({
+        DATABASE_WRITE_URL: 'postgres://unused:unused@127.0.0.1:1/unused',
+        GITHUB_TOKEN: 'unused',
+        INGEST_RUN_ID: '123',
+        INGEST_RUN_ATTEMPT: '2',
+        INGEST_ARTIFACTS_PATH: dir,
+        INGEST_REPO: 'SemiAnalysisAI/InferenceX',
+        POWER_PUBLICATION_MANIFEST: path.join(dir, 'power-publication.json'),
+        INGEST_REQUIRE_POWER: 'false',
+      }))
+        vi.stubEnv(key, value);
+      vi.spyOn(console, 'log').mockImplementation(() => {});
+      vi.spyOn(console, 'warn').mockImplementation(() => {});
+      vi.spyOn(console, 'error').mockImplementation(() => {});
+      fs.cpSync(
+        new URL(
+          '../../../docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/',
+          import.meta.url,
+        ),
+        path.join(dir, 'bmk_agentic_golden'),
+        { recursive: true },
+      );
+      fs.mkdirSync(path.join(dir, 'gpu_metrics_golden'));
+      fs.writeFileSync(
+        path.join(dir, 'gpu_metrics_golden', 'gpu_metrics.csv'),
+        'not,a,telemetry,csv\n',
+      );
+      if (scenario.extra !== undefined) {
+        fs.mkdirSync(path.join(dir, 'bmk_agentic_extra'));
+        const row = JSON.parse(
+          fs.readFileSync(path.join(dir, 'bmk_agentic_golden', 'agg.json'), 'utf8'),
+        );
+        fs.writeFileSync(
+          path.join(dir, 'bmk_agentic_extra', 'agg.json'),
+          typeof scenario.extra === 'string'
+            ? scenario.extra
+            : JSON.stringify({ ...row, conc: 2, users: 2, ...scenario.extra }),
+        );
+      }
+      if (mocks.serverLogFailure) {
+        fs.mkdirSync(path.join(dir, 'server_logs_golden'));
+        fs.writeFileSync(path.join(dir, 'server_logs_golden', 'server.log'), 'server ready\n');
+      }
+      const complete = new Promise<void>((resolve) => {
+        mocks.finish = resolve;
+      });
+      await import('./ingest-ci-run');
+      await complete;
+      const manifest = JSON.parse(
+        fs.readFileSync(path.join(dir, 'power-publication.json'), 'utf8'),
+      );
+      expect(mocks.persistBenchmark, JSON.stringify(manifest)).toHaveBeenCalledOnce();
+      expect(process.exitCode).toBeUndefined();
+      expect(manifest.ingestErrors).toEqual(scenario.ingestError ? [scenario.ingestError] : []);
+      expect(manifest.telemetry.expectedSource).toBe(
+        scenario.unknown ? 'unknown' : 'benchmark_artifacts',
+      );
+      expect(manifest.telemetryWarnings).toEqual(['1 gpu_metrics digest errors']);
+      expect(manifest.telemetry.points).toEqual([
+        expect.objectContaining({
+          produced: true,
+          artifactNames: ['gpu_metrics_golden'],
+          error: 'No parseable telemetry series in gpu_metrics_golden',
+        }),
+      ]);
+    } finally {
+      process.argv = originalArgv;
+      process.exitCode = originalExitCode;
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  },
+);
diff --git a/packages/db/src/lib/benchmark-result-lookup.test.ts b/packages/db/src/lib/benchmark-result-lookup.test.ts
index 985a5723a..2985969e4 100644
--- a/packages/db/src/lib/benchmark-result-lookup.test.ts
+++ b/packages/db/src/lib/benchmark-result-lookup.test.ts
@@ -216,4 +216,24 @@ describe('readMappedBenchmarkRows', () => {
     expect(rows).toHaveLength(1);
     expect(rows[0]).toMatchObject({ conc: 32, isl: 8192, osl: 1024, offloadMode: 'off' });
   });
+
+  it('reports unknown rows without discarding mapped points or treating known failures as unknown', () => {
+    const root = writeArtifact({
+      'results.json': JSON.stringify([
+        rawRow(),
+        rawRow({ hw: 'not-a-gpu' }),
+        null,
+        42,
+        [],
+        rawRow({ benchmark_outcome: { status: 'failed' } }),
+        rawRow({ num_requests_total: 2, num_requests_successful: 0 }),
+      ]),
+    });
+    const errors: string[] = [];
+    const rows = readMappedBenchmarkRows(root, (error) => errors.push(error));
+    expect(rows.map((row) => row.conc)).toEqual([32]);
+    expect(errors).toEqual(
+      [2, 3, 4, 5].map((row) => `Unmappable benchmark row: results.json row ${row}`),
+    );
+  });
 });
diff --git a/packages/db/src/lib/benchmark-result-lookup.ts b/packages/db/src/lib/benchmark-result-lookup.ts
index 37afe2acd..6cfc41a80 100644
--- a/packages/db/src/lib/benchmark-result-lookup.ts
+++ b/packages/db/src/lib/benchmark-result-lookup.ts
@@ -80,17 +80,26 @@ function findJsonFiles(root: string): string[] {
   return files.toSorted();
 }
 
-/** Map every raw benchmark JSON under an extracted bmk artifact through the production mapper. */
-export function readMappedBenchmarkRows(root: string): BenchmarkParams[] {
+/** Map known successful rows; report unidentifiable rows separately from known failures. */
+export function readMappedBenchmarkRows(
+  root: string,
+  onUnmapped: (error: string) => void = () => {},
+): BenchmarkParams[] {
   const tracker = createSkipTracker();
   const rows: BenchmarkParams[] = [];
   for (const file of findJsonFiles(root)) {
     const parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as unknown;
     const rawRows = Array.isArray(parsed) ? parsed : [parsed];
-    for (const raw of rawRows) {
-      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
+    for (const [index, raw] of rawRows.entries()) {
+      const error = `Unmappable benchmark row: ${path.relative(root, file)} row ${index + 1}`;
+      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        onUnmapped(error);
+        continue;
+      }
+      const failedRuns = tracker.skips.failedRun;
       const mapped = mapBenchmarkRow(raw as Record<string, unknown>, tracker);
       if (mapped) rows.push(mapped);
+      else if (tracker.skips.failedRun === failedRuns) onUnmapped(error);
     }
   }
   return rows;
diff --git a/packages/db/src/lib/gpu-metrics-backfill.test.ts b/packages/db/src/lib/gpu-metrics-backfill.test.ts
index ed8c1e32a..771f6ad79 100644
--- a/packages/db/src/lib/gpu-metrics-backfill.test.ts
+++ b/packages/db/src/lib/gpu-metrics-backfill.test.ts
@@ -1,7 +1,18 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import type { ArtifactMeta } from './github-artifacts.js';
-import { pairGpuMetricsArtifacts } from './gpu-metrics-backfill.js';
+import {
+  collectMissingTelemetryExpectations,
+  pairGpuMetricsArtifacts,
+} from './gpu-metrics-backfill.js';
+import { mapBenchmarkRow } from '../etl/benchmark-mapper.js';
+import { createSkipTracker } from '../etl/skip-tracker.js';
+import type { Sql } from '../etl/db-utils.js';
+import {
+  readTelemetryReceipt,
+  summarizeTelemetryReceipt,
+  telemetryArtifactsForAttempt,
+} from '../etl/telemetry-receipt.js';
 
 const meta = (
   name: string,
@@ -17,6 +28,154 @@ const meta = (
 });
 
 describe('pairGpuMetricsArtifacts', () => {
+  it('keeps expired sibling expectations unknown through an unrelated targeted repair', async () => {
+    const artifacts = telemetryArtifactsForAttempt(
+      [
+        meta('bmk_previous_h200-cw_0', 1, '2026-09-10T00:00:00Z', true),
+        meta('bmk_expired_h200-cw_0', 2, '2026-09-11T01:00:00Z', true),
+        meta('bmk_healthy_h200-cw_0', 3, '2026-09-11T01:00:00Z'),
+        meta('gpu_metrics_healthy_h200-cw_0', 4, '2026-09-11T01:00:00Z'),
+      ],
+      { run_attempt: 2, run_started_at: '2026-09-11T00:00:00Z' },
+      2,
+    );
+    const pairs = pairGpuMetricsArtifacts(artifacts);
+    const readRows = vi.fn(() => Promise.resolve([]));
+    const missing = await collectMissingTelemetryExpectations(artifacts, pairs, null, readRows);
+    expect(missing.errors).toEqual([
+      {
+        benchmarkArtifact: 'bmk_expired_h200-cw_0',
+        artifactNames: ['gpu_metrics_expired_h200-cw_0', 'power_audit_expired_h200-cw_0'],
+        error: 'Benchmark artifact expired; point identities unavailable',
+      },
+    ]);
+    expect(missing.observations).toEqual([]);
+    expect(readRows).not.toHaveBeenCalled();
+
+    const storedPoint = { id: 10, model: 'dsr1', conc: 8, offload_mode: 'off' };
+    const series = {
+      id: 5,
+      artifact_name: pairs[0]!.gpuMetrics.name,
+      file_name: 'gpu_metrics.csv',
+      sidecars: { seriesInventory: [{ fileName: 'gpu_metrics.csv', sampleCount: 1 }] },
+      sample_count: 1,
+      benchmark_result_ids: [storedPoint.id],
+    };
+    const sql = vi
+      .fn()
+      .mockResolvedValueOnce([storedPoint])
+      .mockResolvedValueOnce([series])
+      .mockResolvedValueOnce([storedPoint])
+      .mockResolvedValueOnce([series]) as unknown as Sql;
+    const observation = {
+      identity: storedPoint,
+      artifactNames: [series.artifact_name],
+      produced: true,
+    };
+    const run = { runId: 123, runAttempt: 2 };
+    const receipt = await readTelemetryReceipt(sql, run, [observation]);
+    receipt.expectationErrors = missing.errors;
+    summarizeTelemetryReceipt(receipt);
+    expect(receipt.counts).toMatchObject({
+      expectedPoints: null,
+      storedPoints: 1,
+      linkedPoints: 1,
+      apiReadablePoints: 0,
+    });
+
+    const targeted = await collectMissingTelemetryExpectations(
+      artifacts,
+      pairs,
+      series.artifact_name,
+      readRows,
+    );
+    expect(targeted).toEqual({ observations: [], errors: [] });
+    expect(readRows).not.toHaveBeenCalled();
+    const repaired = await readTelemetryReceipt(sql, run, [observation], {
+      previous: receipt,
+      targeted: true,
+    });
+    expect(repaired.expectationErrors).toEqual(missing.errors);
+    expect(repaired.counts.expectedPoints).toBeNull();
+  });
+
+  it.each(['gpu_metrics', 'power_audit'])(
+    'records the expired sibling for the selected %s target without downloading',
+    async (prefix) => {
+      const artifacts = [meta('bmk_expired_h200-cw_0', 1, undefined, true)];
+      const readRows = vi.fn(() => Promise.resolve([]));
+      const result = await collectMissingTelemetryExpectations(
+        artifacts,
+        [],
+        `${prefix}_expired_h200-cw_0`,
+        readRows,
+      );
+      expect(result.observations).toEqual([]);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0]).toMatchObject({
+        benchmarkArtifact: artifacts[0]!.name,
+        artifactNames: expect.arrayContaining([`${prefix}_expired_h200-cw_0`]),
+      });
+      expect(readRows).not.toHaveBeenCalled();
+    },
+  );
+
+  it('does not report an expired retry superseded by a retained sibling', async () => {
+    const artifacts = [
+      meta('bmk_healthy_h200-cw_0', 1, '2026-09-11T00:00:00Z', true),
+      meta('bmk_healthy_h200-dgxc-slurm_1', 2, '2026-09-11T01:00:00Z'),
+      meta('gpu_metrics_healthy_h200-dgxc-slurm_1', 3, '2026-09-11T01:00:00Z'),
+    ];
+    const pairs = pairGpuMetricsArtifacts(artifacts);
+    const readRows = vi.fn(() => Promise.resolve([]));
+    expect(await collectMissingTelemetryExpectations(artifacts, pairs, null, readRows)).toEqual({
+      observations: [],
+      errors: [],
+    });
+    expect(readRows).not.toHaveBeenCalled();
+  });
+
+  it('isolates a corrupt unpaired sibling while retaining later expectations and valid recovery pairs', async () => {
+    const artifacts = [
+      meta('bmk_broken_h200-cw_0', 1),
+      meta('bmk_missing_h200-cw_0', 2),
+      meta('bmk_healthy_h200-cw_0', 3),
+      meta('gpu_metrics_healthy_h200-cw_0', 4),
+    ];
+    const pairs = pairGpuMetricsArtifacts(artifacts);
+    const row = mapBenchmarkRow(
+      {
+        infmax_model_prefix: 'dsr1',
+        hw: 'b200',
+        framework: 'sglang',
+        precision: 'fp4',
+        isl: 8192,
+        osl: 1024,
+        conc: 8,
+        tp: 1,
+      },
+      createSkipTracker(),
+    )!;
+    const result = await collectMissingTelemetryExpectations(artifacts, pairs, null, (artifact) =>
+      artifact.id === 1
+        ? Promise.reject(new Error('Malformed benchmark JSON'))
+        : Promise.resolve([row]),
+    );
+    expect(result.errors).toEqual([
+      {
+        benchmarkArtifact: 'bmk_broken_h200-cw_0',
+        artifactNames: ['gpu_metrics_broken_h200-cw_0', 'power_audit_broken_h200-cw_0'],
+        error: 'Malformed benchmark JSON',
+      },
+    ]);
+    expect(result.observations).toHaveLength(1);
+    expect(result.observations[0]).toMatchObject({
+      identity: { model: 'dsr1', conc: 8 },
+      artifactNames: ['gpu_metrics_missing_h200-cw_0', 'power_audit_missing_h200-cw_0'],
+      produced: false,
+    });
+    expect(pairs.map((pair) => pair.gpuMetrics.name)).toEqual(['gpu_metrics_healthy_h200-cw_0']);
+  });
   it('pairs gpu_metrics with the exact bmk sibling and prefers the agentic sibling', () => {
     const pairs = pairGpuMetricsArtifacts([
       meta('gpu_metrics_cfg-a_h200-cw_0', 1),
diff --git a/packages/db/src/lib/gpu-metrics-backfill.ts b/packages/db/src/lib/gpu-metrics-backfill.ts
index 59c012f55..30f4799f8 100644
--- a/packages/db/src/lib/gpu-metrics-backfill.ts
+++ b/packages/db/src/lib/gpu-metrics-backfill.ts
@@ -1,7 +1,14 @@
 /** Pairing rules for the historical gpu_metrics backfill. */
 
 import { gpuMetricsArtifactSuffix, isPowerAuditArtifact } from '../etl/gpu-metrics-artifacts.js';
-import { RUNNER_SUFFIX_RE, type ArtifactMeta } from './github-artifacts.js';
+import type { BenchmarkParams } from '../etl/benchmark-mapper.js';
+import { benchmarkPublicationIdentity } from '../etl/power-publication.js';
+import type { TelemetryObservation, TelemetryReceipt } from '../etl/telemetry-receipt.js';
+import {
+  dedupeArtifactsByLogicalName,
+  RUNNER_SUFFIX_RE,
+  type ArtifactMeta,
+} from './github-artifacts.js';
 
 export interface GpuMetricsArtifactPair {
   /** `gpu_metrics_<suffix>`, or the `power_audit_<suffix>` bundle when a multinode job uploaded no other. */
@@ -54,3 +61,45 @@ export function pairGpuMetricsArtifacts(
     a.gpuMetrics.name.localeCompare(b.gpuMetrics.name),
   );
 }
+
+/** A corrupt unrelated benchmark sibling must not prevent valid pairs from being repaired. */
+export async function collectMissingTelemetryExpectations(
+  artifacts: readonly ArtifactMeta[],
+  pairs: readonly GpuMetricsArtifactPair[],
+  selectedArtifact: string | null,
+  readRows: (
+    artifact: ArtifactMeta,
+    onUnmapped: (error: string) => void,
+  ) => Promise<readonly BenchmarkParams[]>,
+): Promise<{
+  observations: TelemetryObservation[];
+  errors: NonNullable<TelemetryReceipt['expectationErrors']>;
+}> {
+  const paired = new Set(pairs.map((pair) => pair.benchmarks.name));
+  const observations: TelemetryObservation[] = [];
+  const errors: NonNullable<TelemetryReceipt['expectationErrors']> = [];
+  for (const artifact of dedupeArtifactsByLogicalName(artifacts).values()) {
+    if (!artifact.name.startsWith('bmk_') || paired.has(artifact.name)) continue;
+    const suffix = artifact.name.replace(/^bmk_(?:agentic_)?/u, '');
+    const artifactNames = [`gpu_metrics_${suffix}`, `power_audit_${suffix}`];
+    if (selectedArtifact && !artifactNames.includes(selectedArtifact)) continue;
+    const recordError = (error: string) => {
+      errors.push({ benchmarkArtifact: artifact.name, artifactNames, error });
+    };
+    if (artifact.expired) {
+      recordError('Benchmark artifact expired; point identities unavailable');
+      continue;
+    }
+    try {
+      for (const row of await readRows(artifact, recordError))
+        observations.push({
+          identity: benchmarkPublicationIdentity(row),
+          artifactNames,
+          produced: false,
+        });
+    } catch (error) {
+      recordError(error instanceof Error ? error.message : String(error));
+    }
+  }
+  return { observations, errors };
+}
diff --git a/packages/db/src/prepare-ci-artifacts.test.ts b/packages/db/src/prepare-ci-artifacts.test.ts
index 0f444791b..c327bf9e9 100644
--- a/packages/db/src/prepare-ci-artifacts.test.ts
+++ b/packages/db/src/prepare-ci-artifacts.test.ts
@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -58,6 +59,22 @@ afterEach(() => {
 });
 
 describe('artifact preparation gate before migrations', () => {
+  it('preserves earlier successful artifacts when only failed jobs are rerun', async () => {
+    vi.mocked(execFileSync).mockReturnValueOnce(
+      JSON.stringify({
+        head_sha: 'b'.repeat(40),
+        run_attempt: 2,
+        run_started_at: '2026-09-17T00:00:00Z',
+      }),
+    );
+    await import('./prepare-ci-artifacts');
+    expect(process.exitCode).toBeUndefined();
+    expect(fs.readdirSync(directory).toSorted()).toEqual(mocks.names.toSorted());
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('declared attempt 1, ingest attempt 2'),
+    );
+  });
+
   it('accepts the actual golden source bundle without a database connection', async () => {
     await import('./prepare-ci-artifacts');
     expect(process.exitCode).toBeUndefined();
diff --git a/packages/db/src/verify-power-publication.ts b/packages/db/src/verify-power-publication.ts
index 1beb41e96..41038b292 100644
--- a/packages/db/src/verify-power-publication.ts
+++ b/packages/db/src/verify-power-publication.ts
@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { DB_MODEL_TO_DISPLAY } from '@semianalysisai/inferencex-constants';
 import { createAdminSql } from './etl/db-utils';
+import { verifyTelemetryApi } from './etl/telemetry-receipt';
 import {
   fatalPublicationErrors,
   verifyPowerPublication,
@@ -71,6 +72,19 @@ try {
     publicRows.push(...body);
   }
   errors.push(...verifyPowerPublication(manifest.points, publicRows, 'public API'));
+  if (manifest.telemetry) {
+    if (
+      manifest.telemetry.runId !== manifest.runId ||
+      manifest.telemetry.runAttempt !== manifest.runAttempt
+    )
+      throw new Error('Telemetry receipt belongs to a different run/attempt');
+    manifest.telemetry = await verifyTelemetryApi(manifest.telemetry, origin, {
+      headers: process.env.CACHE_PROTECTION_BYPASS_SECRET
+        ? { 'x-vercel-protection-bypass': process.env.CACHE_PROTECTION_BYPASS_SECRET }
+        : undefined,
+    });
+    fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+  }
   const counts = { strict: 0, invalid: 0, other: 0 };
   for (const point of manifest.points) {
     if (point.metrics.power_valid === 1 && point.metrics.power_metric_schema_version === 2)
@@ -90,6 +104,7 @@ try {
     // Kept out of `errors` on purpose: a telemetry digest failure costs one
     // point's PowerX tab, not its benchmark data, so it must not fail the ingest.
     telemetryWarnings: manifest.telemetryWarnings ?? [],
+    ...(manifest.telemetry ? { telemetry: manifest.telemetry } : {}),
   };
   fs.writeFileSync(`${manifestPath}.verification.json`, `${JSON.stringify(receipt, null, 2)}\n`);
   console.log(JSON.stringify(receipt, null, 2));

From 2f4a4cabec30fa0f009e9d15f8ef9644e4defe7c Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 22 Sep 2026 11:16:00 -0700
Subject: [PATCH 028/103] feat: open PowerX telemetry from dashboard points
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reuse the stored point telemetry view in a lazy in-page dialog. Preserve the PowerX gate, measured share links, and unofficial trace fallback. Cover desktop, Chinese mobile, and collapsed comparison legends.

中文：从仪表板数据点按需打开 PowerX 遥测面板，复用已存储遥测。保留功能门控、实测指标分享链接及非正式运行曲线入口，并验证桌面、中文手机端和收起图例后的交互。
---
 docs/powerx-permanent-view.md                 |  10 ++
 .../e2e/gpu-compare-agentic-detail.cy.ts      |  35 +++++
 .../app/cypress/e2e/powerx-timeline.cy.ts     | 132 +++++++++++++++++-
 .../agentic-point/power-telemetry-view.tsx    |  83 +++++------
 .../inference/power-telemetry-dialog.tsx      |  51 +++++++
 .../src/components/inference/ui/GPUGraph.tsx  |  47 ++++++-
 .../components/inference/ui/ScatterGraph.tsx  |  35 +++++
 .../utils/tooltip-utils.power-trace.test.ts   |  51 +++++++
 .../inference/utils/tooltipUtils.ts           |  25 +++-
 9 files changed, 423 insertions(+), 46 deletions(-)
 create mode 100644 packages/app/src/components/inference/power-telemetry-dialog.tsx

diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index c76b3ec38..7ded29c2c 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -112,6 +112,16 @@ selection. Append:
 | 7      | Reconstructed request energy, prefill share   | `&i_metric=y_measuredJPerOutputToken&i_pcompare=roles` (prefill share in the clone's tooltip)                                                                            |
 | 1      | Measured power over the benchmark job         | `&i_metric=y_measuredPowerTimeline` (Display → Timeline, see below)                                                                                                      |
 
+Pinned official dashboard points now offer **View PowerX** when the feature gate is unlocked
+or a measured-metric share link is active. The lazy in-page dialog reads the existing
+`GET /api/v1/gpu-metrics-point?id=N` API, without entering a run ID or changing chart filters.
+This also works in the hardware/date comparison view. The per-chip chart and statistics span
+the recorded job (including startup/warmup), not just the audited serving window. Fixed-sequence
+points do not request AgentX server-metric overlays. Missing telemetry is shown as unavailable,
+not zero power. Unofficial points have no database ID and retain **View power trace**, which
+resolves their run/audit provenance automatically. No API contract or ingestion changes are
+needed for this presentation-only entry point.
+
 The `/gpu-metrics` page keeps the raw per-run explorer (every metric, one artifact at a time);
 the timeline below is the chart-scoped view of the same artifacts.
 
diff --git a/packages/app/cypress/e2e/gpu-compare-agentic-detail.cy.ts b/packages/app/cypress/e2e/gpu-compare-agentic-detail.cy.ts
index d643a2d44..fae2d640a 100644
--- a/packages/app/cypress/e2e/gpu-compare-agentic-detail.cy.ts
+++ b/packages/app/cypress/e2e/gpu-compare-agentic-detail.cy.ts
@@ -234,4 +234,39 @@ describe('GPU comparison agentic point detail', () => {
       .and('not.contain.text', 'SGLang');
     cy.contains('button', 'Jun 12, 2026').should('be.visible');
   });
+
+  it('opens PowerX from a comparison point while the chart legend is collapsed', () => {
+    cy.intercept('GET', '/api/v1/availability', { body: agenticAvailability });
+    cy.intercept('GET', '/api/v1/benchmarks*', { body: agenticBenchmarks });
+    cy.intercept('GET', '/api/v1/gpu-metrics-point*', { statusCode: 404 }).as('pointTelemetry');
+    cy.intercept('GET', '/api/v1/trace-server-metrics*', { statusCode: 404 });
+    interceptDerivedAgenticMetrics();
+    cy.visit(
+      '/inference?g_model=DeepSeek-V4-Pro&i_seq=agentic-traces&i_prec=fp4&i_gpus=b200_vllm&i_dates=2026-06-12&i_dstart=2026-06-12&i_dend=2026-06-12',
+      {
+        onBeforeLoad(win) {
+          win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
+          unlockAgenticGate(win);
+        },
+      },
+    );
+    cy.get('[data-testid="gpu-graph"]')
+      .first()
+      .within(() => {
+        cy.get('[data-testid="legend-close-button"]').click();
+        cy.get('[data-testid="legend-open-button"]').should('be.visible');
+        cy.get('svg .dot-group').first().find('.visible-shape').click({ force: true });
+      });
+    cy.get('[data-chart-tooltip]:visible [data-action="view-power-telemetry"]').click();
+    cy.wait('@pointTelemetry').then(({ request }) => {
+      const id = Number(new URL(request.url).searchParams.get('id'));
+      expect(agenticIds.has(id)).to.eq(true);
+      cy.get('[data-testid="power-telemetry-dialog"]').should('contain.text', `#${id}`);
+    });
+    cy.get('[data-testid="power-telemetry-missing"]').should('be.visible');
+    cy.get('[data-testid="power-telemetry-dialog"]').contains('button', 'Close').click();
+    cy.get('[data-testid="power-telemetry-dialog"]').should('not.exist');
+    cy.get('[data-testid="gpu-graph"] [data-testid="legend-open-button"]').should('be.visible');
+    cy.location('pathname').should('eq', '/inference');
+  });
 });
diff --git a/packages/app/cypress/e2e/powerx-timeline.cy.ts b/packages/app/cypress/e2e/powerx-timeline.cy.ts
index 9572a71de..5e2267dec 100644
--- a/packages/app/cypress/e2e/powerx-timeline.cy.ts
+++ b/packages/app/cypress/e2e/powerx-timeline.cy.ts
@@ -97,6 +97,38 @@ const seriesFor = (hardware: string, runUrl: string, runId: string) => ({
   }),
 });
 
+function pointTelemetry(id: number) {
+  const trace = seriesFor('b200', RUN_URL, RUN_ID).series[1];
+  const data = trace.gpus.flatMap((index, gpu) =>
+    trace.t.map((second, sample) => ({
+      timestamp: new Date(START_MS + second * 1000).toISOString(),
+      index,
+      power: trace.power[gpu][sample],
+    })),
+  );
+  return {
+    benchmarkResultId: id,
+    series: [
+      {
+        id: 1,
+        artifactName: trace.artifact,
+        configKey: resultName('b200', 64),
+        fileName: 'gpu_metrics.csv',
+        vendor: 'nvidia',
+        sampleIntervalS: 1,
+        sampleCount: data.length,
+        gpuCount: trace.gpus.length,
+        startedAt: data[0].timestamp,
+        endedAt: data.at(-1)!.timestamp,
+        sidecars: {},
+        benchmarkResultIds: [id],
+        stats: [],
+        data,
+      },
+    ],
+  };
+}
+
 const availability = [
   {
     model: MODEL,
@@ -113,14 +145,16 @@ const availability = [
 ];
 
 function interceptRows() {
+  const benchmarks = rows(RUN_URL, 'b200');
   cy.intercept('GET', '/api/v1/availability', { body: availability }).as('availability');
-  cy.intercept('GET', '/api/v1/benchmarks*', { body: rows(RUN_URL, 'b200') }).as('benchmarks');
+  cy.intercept('GET', '/api/v1/benchmarks*', { body: benchmarks }).as('benchmarks');
   cy.intercept('GET', '/api/v1/workflow-info*', {
     body: { runs: [], changelogs: [], configs: [] },
   });
   cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, {
     body: seriesFor('b200', RUN_URL, RUN_ID),
   }).as('series');
+  return benchmarks;
 }
 
 function interceptOverlay() {
@@ -151,19 +185,23 @@ function interceptOverlay() {
 function visitChart({
   path = '/inference',
   extraParams = '',
+  unlocked = true,
 }: {
   path?: string;
   extraParams?: string;
+  unlocked?: boolean;
 }) {
-  interceptRows();
+  const benchmarks = interceptRows();
   cy.visit(`${path}?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4${extraParams}`, {
     onBeforeLoad(win) {
       win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
-      win.localStorage.setItem('inferencex-feature-gate', '1');
+      if (unlocked) win.localStorage.setItem('inferencex-feature-gate', '1');
+      else win.localStorage.removeItem('inferencex-feature-gate');
     },
   });
   cy.wait(['@availability', '@benchmarks']);
   cy.get('[data-testid="inference-chart-display"]').should('exist');
+  return benchmarks;
 }
 
 describe('PowerX measured power timeline', () => {
@@ -270,6 +308,8 @@ describe('PowerX measured power timeline', () => {
   // ── "View power trace" on pinned scatter tooltips ─────────────────────────
 
   const POWER_TRACE_ACTION = '[data-chart-tooltip]:visible [data-action="view-power-trace"]';
+  const TELEMETRY_ACTION = '[data-chart-tooltip]:visible [data-action="view-power-telemetry"]';
+  const TELEMETRY_DIALOG = '[data-testid="power-telemetry-dialog"]';
 
   /** Pin the tooltip of the marker plotted for `conc` (official `.dot-group` or overlay X). */
   function pinPointTooltip(selector: string, conc: number): void {
@@ -284,6 +324,91 @@ describe('PowerX measured power timeline', () => {
       });
   }
 
+  for (const [path, width, closeLabel] of [
+    ['/inference', 1280, 'Close'],
+    ['/zh/inference', 390, '关闭'],
+  ] as const) {
+    it(`loads the selected point's PowerX telemetry in place at ${path} ${width}px`, () => {
+      cy.viewport(width, 900);
+      cy.intercept('GET', '/api/v1/gpu-metrics-point*', (request) => {
+        const id = Number(new URL(request.url).searchParams.get('id'));
+        request.reply({ body: pointTelemetry(id) });
+      }).as('pointTelemetry');
+      cy.intercept('GET', '/api/v1/trace-server-metrics*', { statusCode: 404 }).as('serverMetrics');
+      const benchmarks = visitChart({ path, extraParams: '&i_metric=y_measuredAvgPower' });
+      const selectedPointId = benchmarks.find((point) => point.conc === 64)!.id;
+      cy.get('@pointTelemetry.all').should('have.length', 0);
+      pinPointTooltip('.dot-group', 64);
+      cy.get(TELEMETRY_ACTION).should('have.prop', 'tagName', 'BUTTON').click();
+      cy.wait('@pointTelemetry').then(({ request }) => {
+        const id = Number(new URL(request.url).searchParams.get('id'));
+        expect(id).to.eq(selectedPointId);
+      });
+      cy.location('pathname').should('eq', path);
+      cy.get(TELEMETRY_DIALOG)
+        .should('contain.text', 'PowerX')
+        .within(() => {
+          cy.get('[data-testid="gpu-metrics-run-input"]').should('not.exist');
+          cy.get('[data-testid="power-telemetry-sample-count"]').should('have.text', '122');
+          cy.get('[data-testid="gpu-metrics-chart-svg"] path.line-path').should('have.length', 2);
+        });
+      cy.get(TELEMETRY_DIALOG)
+        .should(($dialog) => {
+          const dialog = $dialog[0];
+          expect(dialog.scrollWidth, 'no horizontal dialog overflow').to.be.at.most(
+            dialog.clientWidth + 1,
+          );
+          const bounds = dialog.getBoundingClientRect();
+          expect(bounds.left).to.be.at.least(0);
+          expect(bounds.right).to.be.at.most(width);
+        })
+        .screenshot(`powerx-point-dialog-${width}`);
+      cy.get(TELEMETRY_DIALOG)
+        .scrollTo('bottom')
+        .screenshot(`powerx-point-dialog-${width}-bottom`)
+        .scrollTo('top');
+      cy.get(TELEMETRY_DIALOG).contains('button', closeLabel).click();
+      cy.get(TELEMETRY_DIALOG).should('not.exist');
+      assertShareLinkMetric('y_measuredAvgPower');
+      cy.get('@serverMetrics.all').should('have.length', 0);
+      pinPointTooltip('.dot-group', 64);
+      cy.get(TELEMETRY_ACTION).click();
+      cy.get(TELEMETRY_DIALOG).should('be.visible');
+      cy.get('body').type('{esc}');
+      cy.get(TELEMETRY_DIALOG).should('not.exist');
+    });
+  }
+
+  it('keeps the normal-metric entry gated and reveals it after unlocking PowerX', () => {
+    cy.intercept('GET', '/api/v1/gpu-metrics-point*', { statusCode: 404 }).as('pointTelemetry');
+    visitChart({ extraParams: '&i_metric=y_tpPerGpu', unlocked: false });
+    pinPointTooltip('.dot-group', 64);
+    cy.get(TELEMETRY_ACTION).should('not.exist');
+    cy.get('body').type('{uparrow}{uparrow}{downarrow}{downarrow}');
+    cy.get('[data-testid="tab-trigger-hidden"]').should('be.visible');
+    pinPointTooltip('.dot-group', 16);
+    cy.get(TELEMETRY_ACTION).should('be.visible').click();
+    cy.wait('@pointTelemetry');
+    cy.get(TELEMETRY_DIALOG).should('contain.text', 'PowerX');
+    cy.location('pathname').should('eq', '/inference');
+  });
+
+  it('shows unavailable telemetry instead of a run-ID form when the selected point has no series', () => {
+    cy.intercept('GET', '/api/v1/gpu-metrics-point*', { statusCode: 404 }).as('missingTelemetry');
+    visitChart({ extraParams: '&i_metric=y_measuredAvgPower' });
+    pinPointTooltip('.dot-group', 64);
+    cy.get(TELEMETRY_ACTION).click();
+    cy.wait('@missingTelemetry');
+    cy.get(TELEMETRY_DIALOG).within(() => {
+      cy.get('[data-testid="power-telemetry-missing"]').should(
+        'contain.text',
+        'No PowerX telemetry is stored',
+      );
+      cy.get('[data-testid="power-telemetry-query-error"]').should('not.exist');
+      cy.get('[data-testid="gpu-metrics-run-input"]').should('not.exist');
+    });
+  });
+
   it('jumps from a pinned point to the timeline focused on that config', () => {
     visitChart({ extraParams: '&i_metric=y_measuredAvgPower' });
     // Only a pinned tooltip offers the action (the hover gate is unit-tested).
@@ -313,6 +438,7 @@ describe('PowerX measured power timeline', () => {
     });
     cy.wait('@unofficialRun');
     pinPointTooltip('.unofficial-overlay-pt', 64);
+    cy.get(TELEMETRY_ACTION).should('not.exist');
     cy.get(POWER_TRACE_ACTION).should('be.visible').should('contain.text', 'View power trace');
     cy.get(POWER_TRACE_ACTION).click();
 
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
index 94d272eda..75901d338 100644
--- a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -43,7 +43,7 @@ const STRINGS = {
     loading: 'Loading PowerX telemetry…',
     error: 'Failed to load PowerX telemetry.',
     missing:
-      'No PowerX telemetry is stored for benchmark point #{id}. The run predates telemetry ingestion and its gpu_metrics artifact has expired on GitHub, or the job uploaded no telemetry.',
+      'No PowerX telemetry is stored for benchmark point #{id}. Telemetry may not have been collected or ingested.',
     series: 'Telemetry series',
     metric: 'Metric',
     vendor: 'Collector',
@@ -69,8 +69,7 @@ const STRINGS = {
   zh: {
     loading: '正在加载 PowerX 遥测数据……',
     error: 'PowerX 遥测数据加载失败。',
-    missing:
-      '基准测试数据点 #{id} 没有存储的 PowerX 遥测数据。该运行早于遥测入库上线且 GitHub 上的 gpu_metrics 产物已过期，或该任务未上传遥测数据。',
+    missing: '基准测试数据点 #{id} 没有存储的 PowerX 遥测数据。遥测数据可能尚未采集或入库。',
     series: '遥测序列',
     metric: '指标',
     vendor: '采集器',
@@ -113,6 +112,8 @@ interface Props {
   enabled: boolean;
   /** The point's hardware key, for the TDP reference line. */
   hardware?: string;
+  /** Fixed-sequence points do not have AgentX server-metric overlays. */
+  serverMetricsEnabled?: boolean;
 }
 
 function seriesLabel(series: GpuMetricSeries, total: number): string {
@@ -124,7 +125,7 @@ function seriesLabel(series: GpuMetricSeries, total: number): string {
  * recorded while this benchmark point ran, read from the ingest-time digest
  * (migration 016) rather than from GitHub artifacts.
  */
-export function PowerTelemetryView({ id, enabled, hardware }: Props) {
+export function PowerTelemetryView({ id, enabled, hardware, serverMetricsEnabled = true }: Props) {
   const locale = useLocale();
   const t = STRINGS[locale];
   const query = useGpuMetricsPoint(id, enabled);
@@ -181,7 +182,7 @@ export function PowerTelemetryView({ id, enabled, hardware }: Props) {
 
   // Server-metric overlay. The series are fetched as soon as the tab opens so
   // the menu can list exactly the metrics this point has; one source at a time.
-  const metricsQuery = useTraceServerMetrics(id, enabled);
+  const metricsQuery = useTraceServerMetrics(id, enabled && serverMetricsEnabled);
   const serverMetrics = metricsQuery.data;
   const overlaySources = useMemo(() => availableOverlaySources(serverMetrics), [serverMetrics]);
   const [overlaySelection, setOverlaySelection] = useState<{ id: number; key: string } | null>(
@@ -343,43 +344,45 @@ export function PowerTelemetryView({ id, enabled, hardware }: Props) {
           idPrefix="power-telemetry-display"
           className="mt-3 border-t border-border/60 pt-3"
         />
-        <div className="mt-3 flex flex-wrap items-end gap-x-3 gap-y-1">
-          <div className="space-y-1">
-            <Label htmlFor="power-telemetry-overlay">{t.overlayToggle}</Label>
-            <Select
-              value={overlayKey}
-              disabled={overlaySources.length === 0}
-              onValueChange={(value) => {
-                track('inference_agentic_power_overlay_changed', { id, source: value });
-                setOverlaySelection({ id, key: value });
-              }}
-            >
-              <SelectTrigger
-                id="power-telemetry-overlay"
-                data-testid="power-telemetry-overlay-select"
-                className="w-full sm:w-64"
+        {serverMetricsEnabled && (
+          <div className="mt-3 flex flex-wrap items-end gap-x-3 gap-y-1">
+            <div className="space-y-1">
+              <Label htmlFor="power-telemetry-overlay">{t.overlayToggle}</Label>
+              <Select
+                value={overlayKey}
+                disabled={overlaySources.length === 0}
+                onValueChange={(value) => {
+                  track('inference_agentic_power_overlay_changed', { id, source: value });
+                  setOverlaySelection({ id, key: value });
+                }}
               >
-                <SelectValue />
-              </SelectTrigger>
-              <SelectContent>
-                <SelectItem value="none">{t.overlayNone}</SelectItem>
-                {overlaySources.map((source) => (
-                  <SelectItem key={source.key} value={source.key}>
-                    {overlaySourceLabel(source, locale)} ({source.unit})
-                  </SelectItem>
-                ))}
-              </SelectContent>
-            </Select>
+                <SelectTrigger
+                  id="power-telemetry-overlay"
+                  data-testid="power-telemetry-overlay-select"
+                  className="w-full sm:w-64"
+                >
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="none">{t.overlayNone}</SelectItem>
+                  {overlaySources.map((source) => (
+                    <SelectItem key={source.key} value={source.key}>
+                      {overlaySourceLabel(source, locale)} ({source.unit})
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+            {overlayNote && (
+              <span
+                className="pb-2 text-xs text-muted-foreground"
+                data-testid="power-telemetry-overlay-note"
+              >
+                {overlayNote}
+              </span>
+            )}
           </div>
-          {overlayNote && (
-            <span
-              className="pb-2 text-xs text-muted-foreground"
-              data-testid="power-telemetry-overlay-note"
-            >
-              {overlayNote}
-            </span>
-          )}
-        </div>
+        )}
       </Card>
 
       <Card className="relative" data-testid="power-telemetry-chart">
diff --git a/packages/app/src/components/inference/power-telemetry-dialog.tsx b/packages/app/src/components/inference/power-telemetry-dialog.tsx
new file mode 100644
index 000000000..e20718a55
--- /dev/null
+++ b/packages/app/src/components/inference/power-telemetry-dialog.tsx
@@ -0,0 +1,51 @@
+'use client';
+
+import type { InferenceData } from '@/components/inference/types';
+import { PowerTelemetryView } from '@/components/inference/agentic-point/power-telemetry-view';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import { isPersistedBenchmarkId } from '@/lib/benchmark-id';
+import { useLocale } from '@/lib/use-locale';
+
+const STRINGS = {
+  en: { point: 'Benchmark point', concurrency: 'Concurrency' },
+  zh: { point: '基准测试数据点', concurrency: '并发数' },
+} as const;
+
+interface Props {
+  point: InferenceData;
+  onOpenChange: (open: boolean) => void;
+}
+
+export function PowerTelemetryDialog({ point, onOpenChange }: Props) {
+  const t = STRINGS[useLocale()];
+  if (!isPersistedBenchmarkId(point.id)) return null;
+
+  return (
+    <Dialog open onOpenChange={onOpenChange}>
+      <DialogContent
+        className="flex max-h-[94vh] w-[min(96vw,80rem)] max-w-[min(96vw,80rem)] flex-col gap-3 overflow-y-auto p-3 sm:p-5"
+        data-testid="power-telemetry-dialog"
+      >
+        <DialogHeader className="pr-6">
+          <DialogTitle>PowerX</DialogTitle>
+          <DialogDescription className="break-words">
+            {t.point} #{point.id} · {point.hwKey} · {point.precision.toUpperCase()} ·{' '}
+            {t.concurrency} {point.conc}
+          </DialogDescription>
+        </DialogHeader>
+        <PowerTelemetryView
+          id={point.id}
+          enabled
+          hardware={point.hw}
+          serverMetricsEnabled={point.benchmark_type === 'agentic_traces'}
+        />
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/GPUGraph.tsx b/packages/app/src/components/inference/ui/GPUGraph.tsx
index f5cb0c7e4..ac17588d9 100644
--- a/packages/app/src/components/inference/ui/GPUGraph.tsx
+++ b/packages/app/src/components/inference/ui/GPUGraph.tsx
@@ -1,5 +1,7 @@
 'use client';
 
+import { useFeatureGate } from '@/lib/use-feature-gate';
+import { getMeasuredMetricConfig } from '@/components/inference/measured-metric-config';
 import { track } from '@/lib/analytics';
 import { isPersistedBenchmarkId } from '@/lib/benchmark-id';
 import { useEphemeralUrlState } from '@/hooks/useUrlState';
@@ -110,6 +112,14 @@ import {
 } from '@/components/inference/ui/line-label-layer';
 import { QuickFiltersDialog } from '@/components/inference/ui/QuickFiltersDialog';
 
+const PowerTelemetryDialog = dynamic(
+  () =>
+    import('@/components/inference/power-telemetry-dialog').then(
+      (module) => module.PowerTelemetryDialog,
+    ),
+  { ssr: false },
+);
+
 const FixedSequenceLogDialog = dynamic(() =>
   import('@/components/inference/log-viewer/fixed-sequence-log-dialog').then(
     (module) => module.FixedSequenceLogDialog,
@@ -256,6 +266,11 @@ const GPUGraph = React.memo(
       setQuickFilterPower,
     } = useInferenceActions();
     const locale = useLocale();
+    const featureGateUnlocked = useFeatureGate();
+    const showPowerTelemetry =
+      featureGateUnlocked || getMeasuredMetricConfig(selectedYAxisMetric) !== undefined;
+    const showPowerTelemetryRef = useRef(showPowerTelemetry);
+    showPowerTelemetryRef.current = showPowerTelemetry;
     const legendT = GPU_STRINGS[locale];
     const frontierDirection = chartDefinition[
       `${selectedYAxisMetric}_roofline` as keyof ChartDefinition
@@ -522,6 +537,7 @@ const GPUGraph = React.memo(
     const logAvailabilityRef = useRef(logAvailability);
     logAvailabilityRef.current = logAvailability;
     const [fixedLogPointId, setFixedLogPointId] = useState<number | null>(null);
+    const [powerTelemetryPoint, setPowerTelemetryPoint] = useState<InferenceData | null>(null);
 
     // Warning annotations for visible series with known upstream issues —
     // same treatment the scatter view gets, applied to the date-comparison view.
@@ -1262,7 +1278,7 @@ const GPUGraph = React.memo(
       );
     }
 
-    return (
+    const chart = (
       <D3Chart<InferenceData>
         ref={chartRef}
         // Embeds drop the zoom/pan hint line; the host page has its own caption.
@@ -1374,6 +1390,7 @@ const GPUGraph = React.memo(
               yLabel,
               selectedYAxisMetric,
               hardwareConfig,
+              showPowerTelemetry: showPowerTelemetryRef.current,
               runUrl: d.run_url ? updateRepoUrl(d.run_url) : undefined,
               hasTrace: isPersistedBenchmarkId(d.id)
                 ? traceAvailabilityRef.current?.[d.id] === true
@@ -1435,6 +1452,19 @@ const GPUGraph = React.memo(
                 });
               });
             }
+            const powerBtn = tooltipEl.querySelector('[data-action="view-power-telemetry"]');
+            if (powerBtn && isPersistedBenchmarkId(d.id)) {
+              powerBtn.addEventListener('click', (event) => {
+                event.stopPropagation();
+                setPowerTelemetryPoint(d);
+                chartRef.current?.dismissTooltip();
+                track('inference_power_telemetry_opened', {
+                  id: d.id,
+                  hwKey: d.hwKey,
+                  conc: d.conc,
+                });
+              });
+            }
             const logsBtn = tooltipEl.querySelector('[data-action="view-logs"]');
             if (logsBtn && typeof d.id === 'number') {
               logsBtn.addEventListener('click', (event) => {
@@ -1705,6 +1735,21 @@ const GPUGraph = React.memo(
         }
       />
     );
+
+    return (
+      <>
+        {powerTelemetryPoint === null ? null : (
+          <PowerTelemetryDialog
+            key={powerTelemetryPoint.id}
+            point={powerTelemetryPoint}
+            onOpenChange={(open) => {
+              if (!open) setPowerTelemetryPoint(null);
+            }}
+          />
+        )}
+        {chart}
+      </>
+    );
   },
 );
 
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 01b356fa6..1241d8d1c 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -1,5 +1,7 @@
 'use client';
 
+import { useFeatureGate } from '@/lib/use-feature-gate';
+import { getMeasuredMetricConfig } from '@/components/inference/measured-metric-config';
 import { track } from '@/lib/analytics';
 import { isPersistedBenchmarkId } from '@/lib/benchmark-id';
 import { useEphemeralUrlState } from '@/hooks/useUrlState';
@@ -193,6 +195,14 @@ import {
   fitContinuationLabelBaseline,
 } from '@/components/inference/utils/overflowContinuations';
 
+const PowerTelemetryDialog = dynamic(
+  () =>
+    import('@/components/inference/power-telemetry-dialog').then(
+      (module) => module.PowerTelemetryDialog,
+    ),
+  { ssr: false },
+);
+
 const FixedSequenceLogDialog = dynamic(
   () =>
     import('@/components/inference/log-viewer/fixed-sequence-log-dialog').then(
@@ -614,6 +624,9 @@ const ScatterGraph = React.memo(
       [showPowerEnvelope, chartDefinition.chartType, selectedYAxisMetric],
     );
     const locale = useLocale();
+    const featureGateUnlocked = useFeatureGate();
+    const showPowerTelemetry =
+      featureGateUnlocked || getMeasuredMetricConfig(selectedYAxisMetric) !== undefined;
     const legendT = SCATTER_STRINGS[locale];
     // Comparison series (`i_pcompare`) switched off from the legend. Chart-local,
     // like Optimal Only's point set: the URL carries the comparison, not which
@@ -1287,6 +1300,7 @@ const ScatterGraph = React.memo(
     );
     const { data: persistedLogAvailability } = useLogAvailability(persistedPointIds);
     const [fixedLogPointId, setFixedLogPointId] = useState<number | null>(null);
+    const [powerTelemetryPoint, setPowerTelemetryPoint] = useState<InferenceData | null>(null);
 
     // "View power trace" on a pinned tooltip (official or overlay point): the
     // same-tab click stays in-page — remember which trace to emphasise, switch
@@ -1900,6 +1914,7 @@ const ScatterGraph = React.memo(
       knownIssueAnnotations,
       traceAvailability,
       logAvailability: persistedLogAvailability,
+      showPowerTelemetry,
     });
     interactionRef.current = {
       isPointVisible,
@@ -1913,6 +1928,7 @@ const ScatterGraph = React.memo(
       knownIssueAnnotations,
       traceAvailability,
       logAvailability: persistedLogAvailability,
+      showPowerTelemetry,
     };
 
     // --- Perf ruler (opt-in: click two curves, drag the ruler to any iso-x) ---
@@ -2498,6 +2514,7 @@ const ScatterGraph = React.memo(
             yLabel,
             selectedYAxisMetric,
             hardwareConfig,
+            showPowerTelemetry: interactionRef.current.showPowerTelemetry,
             runUrl: d.run_url ? updateRepoUrl(d.run_url) : undefined,
             hasTrace:
               d.benchmark_type === 'agentic_traces' && isPersistedBenchmarkId(d.id)
@@ -2559,6 +2576,15 @@ const ScatterGraph = React.memo(
               });
             });
           }
+          const powerBtn = tooltipEl.querySelector('[data-action="view-power-telemetry"]');
+          if (powerBtn && isPersistedBenchmarkId(d.id)) {
+            powerBtn.addEventListener('click', (event) => {
+              event.stopPropagation();
+              setPowerTelemetryPoint(d);
+              chartRef.current?.dismissTooltip();
+              track('inference_power_telemetry_opened', { id: d.id, hwKey: d.hwKey, conc: d.conc });
+            });
+          }
           const logsBtn = tooltipEl.querySelector('[data-action="view-logs"]');
           if (logsBtn && typeof d.id === 'number') {
             logsBtn.addEventListener('click', (btnEvent) => {
@@ -4656,6 +4682,15 @@ const ScatterGraph = React.memo(
             }
           />
         )}
+        {powerTelemetryPoint === null ? null : (
+          <PowerTelemetryDialog
+            key={powerTelemetryPoint.id}
+            point={powerTelemetryPoint}
+            onOpenChange={(open) => {
+              if (!open) setPowerTelemetryPoint(null);
+            }}
+          />
+        )}
         {fixedLogPointId === null ? null : (
           <FixedSequenceLogDialog
             pointId={fixedLogPointId}
diff --git a/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts b/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
index 1382c594e..93c2af577 100644
--- a/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
+++ b/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
@@ -17,6 +17,7 @@ const RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34716
 const AUDIT_NAME =
   'dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc64_b200-host-0123';
 const ACTION = 'data-action="view-power-trace"';
+const TELEMETRY_ACTION = 'data-action="view-power-telemetry"';
 
 const hardwareConfig = {
   b200: {
@@ -182,3 +183,53 @@ describe('View power trace tooltip action', () => {
     expect(generateGPUGraphTooltipContent(config({ hasLog: true }))).not.toContain(ACTION);
   });
 });
+
+describe('View PowerX point telemetry action', () => {
+  for (const [chart, generate] of [
+    ['scatter', generateTooltipContent],
+    ['GPU comparison', generateGPUGraphTooltipContent],
+  ] as const) {
+    it(`opens from a pinned ordinary ${chart} point without requiring logs or artifact provenance`, () => {
+      const html = generate(
+        config({
+          showPowerTelemetry: true,
+          data: measuredPoint({ power_audit: undefined, run_url: undefined }),
+        }),
+      );
+      expect(html).toMatch(/<button\b[^>]*data-action="view-power-telemetry"/u);
+      expect(html).not.toMatch(/<a\b[^>]*data-action="view-power-telemetry"/u);
+      expect(html).toContain('PowerX');
+    });
+
+    it(`keeps ${chart} telemetry hidden until enabled and pinned`, () => {
+      expect(generate(config())).not.toContain(TELEMETRY_ACTION);
+      expect(generate(config({ showPowerTelemetry: false }))).not.toContain(TELEMETRY_ACTION);
+      expect(generate(config({ showPowerTelemetry: true, isPinned: false }))).not.toContain(
+        TELEMETRY_ACTION,
+      );
+    });
+
+    it.each([undefined, 0, -1, 1.5, Number.NaN])(
+      `does not offer a DB lookup for invalid ${chart} point ID %s`,
+      (id) => {
+        expect(
+          generate(config({ showPowerTelemetry: true, data: measuredPoint({ id }) })),
+        ).not.toContain(TELEMETRY_ACTION);
+      },
+    );
+  }
+
+  it('uses the Chinese action label', () => {
+    expect(generateTooltipContent(config({ showPowerTelemetry: true, locale: 'zh' }))).toMatch(
+      /查看\s*PowerX/u,
+    );
+  });
+
+  it.each([0, 980001])('keeps overlay ID %s on its run-backed trace, never the DB action', (id) => {
+    const html = generateOverlayTooltipContent(
+      overlayConfig({ showPowerTelemetry: true, data: measuredPoint({ id }) }),
+    );
+    expect(html).not.toContain(TELEMETRY_ACTION);
+    expect(html).toContain(ACTION);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/tooltipUtils.ts b/packages/app/src/components/inference/utils/tooltipUtils.ts
index c770e731a..2ae288497 100644
--- a/packages/app/src/components/inference/utils/tooltipUtils.ts
+++ b/packages/app/src/components/inference/utils/tooltipUtils.ts
@@ -57,6 +57,8 @@ export interface TooltipConfig {
   hasTrace?: boolean;
   /** Whether this official DB-backed point has a linked `server_logs` row. */
   hasLog?: boolean;
+  /** Opt in only when the host handles the dialog action. */
+  showPowerTelemetry?: boolean;
   /** Page locale for tooltip metadata labels. Defaults to English. */
   locale?: Locale;
 }
@@ -536,8 +538,18 @@ const generateAgenticHTML = (d: InferenceData, locale: Locale): string => {
 };
 
 const ACTION_STRINGS = {
-  en: { charts: 'View charts', logs: 'View logs', powerTrace: 'View power trace' },
-  zh: { charts: '查看图表', logs: '查看日志', powerTrace: '查看功耗曲线' },
+  en: {
+    charts: 'View charts',
+    logs: 'View logs',
+    powerTelemetry: 'View PowerX',
+    powerTrace: 'View power trace',
+  },
+  zh: {
+    charts: '查看图表',
+    logs: '查看日志',
+    powerTelemetry: '查看 PowerX',
+    powerTrace: '查看功耗曲线',
+  },
 } as const;
 
 type TooltipAction = 'view-charts' | 'view-logs' | 'view-power-trace';
@@ -582,6 +594,7 @@ interface ViewActionsInput {
    * so they never render a "View power trace" link nothing would handle.
    */
   powerTraceMetric?: string;
+  showPowerTelemetry?: boolean;
   locale: Locale;
 }
 
@@ -596,6 +609,7 @@ const viewActionsHTML = ({
   hasLogData,
   point,
   powerTraceMetric,
+  showPowerTelemetry,
   locale,
 }: ViewActionsInput): string => {
   if (!isPinned) return '';
@@ -617,6 +631,11 @@ const viewActionsHTML = ({
       actions.push(pointDetailActionLink('view-logs', logHref, t.logs));
     }
   }
+  if (showPowerTelemetry && isPersistedBenchmarkId(pointId)) {
+    actions.push(
+      `<button type="button" data-action="view-power-telemetry" class="w-full rounded-md border border-border bg-accent px-2 py-1 text-xs font-medium text-accent-foreground cursor-pointer">${t.powerTelemetry} &rarr;</button>`,
+    );
+  }
   if (powerTraceMetric !== undefined && showsPowerTraceAction(point, powerTraceMetric)) {
     actions.push(pointDetailActionLink('view-power-trace', powerTraceHref(), t.powerTrace));
   }
@@ -819,6 +838,7 @@ export const generateTooltipContent = (config: TooltipConfig): string => {
         hasTraceData: Boolean(hasTrace),
         hasLogData: Boolean(config.hasLog),
         point: d,
+        showPowerTelemetry: config.showPowerTelemetry,
         powerTraceMetric: selectedYAxisMetric,
         locale,
       })}
@@ -941,6 +961,7 @@ export const generateGPUGraphTooltipContent = (config: TooltipConfig): string =>
         hasTraceData: Boolean(hasTrace),
         hasLogData: Boolean(hasLog),
         point: d,
+        showPowerTelemetry: config.showPowerTelemetry,
         locale,
       })}
     </div>

From 7ed498f42103e5b1eaa386cb655fdb61a3b1376f Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 22 Sep 2026 17:37:12 -0700
Subject: [PATCH 029/103] fix: stabilize PowerX persistence and recovery
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Decode persisted JSONB sidecars, recover nested AgentX source/window evidence,
and refresh benchmark caches after targeted backfill. Preserve source identity,
metrics and validity, and retain failed refresh receipts for cache-only retries.

中文：稳定 PowerX 持久化与恢复链路。兼容已存储的 JSONB sidecars，
恢复嵌套 AgentX 来源与窗口，回填后自动刷新基准缓存；保留身份、指标和
有效性，并支持失败后的仅缓存重试。

Squashes the reviewed local recovery commits cbd7455c, 24f8859d and a6c5e58d.
The code tree is identical to the accepted local candidate a6c5e58d.
---
 docs/data-pipeline.md                         |   9 +
 docs/powerx-persistence-recovery.md           |  56 ++++
 .../gpu-power/power-audit-bundle.test.ts      |  11 +-
 .../gpu-power/power-audit-bundle.ts           |  15 +-
 .../components/inference/ui/PowerTimeline.tsx |   5 +-
 packages/app/src/lib/api-route-catalog.ts     |  14 +-
 packages/db/src/backfill-gpu-metrics.test.ts  | 211 +++++++++++-
 packages/db/src/backfill-gpu-metrics.ts       | 122 ++++++-
 packages/db/src/etl/benchmark-mapper.ts       |   2 +-
 packages/db/src/etl/gpu-metrics-artifacts.ts  |  44 ++-
 .../db/src/etl/gpu-metrics-ingest.test.ts     |  22 +-
 packages/db/src/etl/gpu-metrics-ingest.ts     |  40 ++-
 .../db/src/etl/power-audit-recovery.test.ts   | 124 +++++++
 packages/db/src/etl/power-audit-recovery.ts   |  42 +++
 .../src/etl/power-audit-validations.test.ts   | 247 ++++++++++++++
 .../db/src/etl/power-audit-validations.ts     | 125 +++++++
 packages/db/src/etl/power-publication.ts      |  16 +
 packages/db/src/etl/telemetry-receipt.test.ts | 101 ++++++
 packages/db/src/etl/telemetry-receipt.ts      |  18 +-
 packages/db/src/ingest-ci-run.ts              |  33 +-
 .../lib/backfill-benchmark-refresh.test.ts    | 306 ++++++++++++++++++
 .../db/src/lib/backfill-benchmark-refresh.ts  | 224 +++++++++++++
 .../src/queries/gpu-metrics-timeline.test.ts  | 109 +++++++
 23 files changed, 1850 insertions(+), 46 deletions(-)
 create mode 100644 packages/db/src/etl/power-audit-recovery.test.ts
 create mode 100644 packages/db/src/etl/power-audit-recovery.ts
 create mode 100644 packages/db/src/etl/power-audit-validations.test.ts
 create mode 100644 packages/db/src/etl/power-audit-validations.ts
 create mode 100644 packages/db/src/lib/backfill-benchmark-refresh.test.ts
 create mode 100644 packages/db/src/lib/backfill-benchmark-refresh.ts

diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index 3e5bd2223..8b4fac9f2 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -605,6 +605,15 @@ coverage unknown. Plain CSV fallback applies the adjacent context timezone just
 ingest and bundle reads. Raw multi-file artifacts retain separate file/host series.
 Successful reads and storage errors use no-store.
 
+AgentX nested validation documents are matched to the exact root result and retained
+window before receiving a canonical validation filename alias. Original path, result
+filename and validation hash remain in stored sidecars. CI attaches recovered source
+and window metadata before benchmark publication/upsert; targeted telemetry re-ingest
+fills only NULL provenance for a unique explicit run/result/concurrency match, even
+when samples are unchanged. Metrics and validity remain untouched. Benchmark metadata
+repair additionally needs the existing materialized-view refresh and benchmark-cache
+invalidation before the UI planner can discover the restored Timeline source.
+
 `/api/v1/gpu-metrics-point?id=` powers the PowerX point-detail tab. Every request
 checks the current DB revision before reading its Blob payload cache. Sidecar repairs,
 new point links and shared-series changes therefore select fresh payloads without a
diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
index 9225af2fb..06f5ee1bd 100644
--- a/docs/powerx-persistence-recovery.md
+++ b/docs/powerx-persistence-recovery.md
@@ -55,6 +55,26 @@ The live raw explorer also keeps each CSV as a separate series, matching the dat
 reader. Multi-file artifact labels include the CSV path, so host-local GPU 0 values cannot
 be merged into one device. Single-file labels remain unchanged.
 
+AgentX artifacts may retain their validation at
+`LOGS/agentic/conc_N/power_validation.json`. Both stored and artifact readers recognize
+this layout only when the exact root result filename, its `conc`, and the retained
+`LOGS/power/windows/agentic_power_concurrency_N.json` agree with the validation's
+selected window. Missing, malformed or mismatched evidence does not create a window.
+The normalized source is `power_validation_<root-result-stem>.json`; it is an alias,
+not an invented top-level file. Stored validation sidecars retain `validation_path`,
+`result_file` and the SHA-256 of the original validation bytes. Legacy top-level
+validation documents take precedence, and power-validity and role values stay unchanged.
+
+Normal CI derives missing AgentX benchmark source/window metadata before publication
+and benchmark upsert, retaining it across aggregate copies of the same full point
+identity. Targeted telemetry re-ingest also fills SQL-NULL `power_audit` after all hosts
+are stored and linked, including sample no-ops. It requires one unambiguous AgentX point
+within the caller's explicit run/result IDs with matching concurrency; it neither
+overwrites non-null provenance nor changes metrics, workers or validity. The ingest
+result reports actual `metadataUpdatedBenchmarkResultIds`. Ordinary benchmark reads
+also require the existing `latest_benchmarks` refresh and benchmark cache invalidation;
+point/Timeline revision changes alone do not refresh the UI's benchmark source list.
+
 ## Cache and browser recovery
 
 `/api/v1/gpu-metrics-point?id=N` checks a live database revision before reading its existing
@@ -231,6 +251,42 @@ The ordinary fixture-backed smoke command remains `bun run test:e2e` with an
    bun packages/db/src/verify-power-publication.ts /path/power-publication.json https://TARGET_ORIGIN
    ```
 
+   Before a backfill that may fill missing AgentX `power_audit`, set
+   `CACHE_INVALIDATE_URL=https://TARGET_ORIGIN/api/v1/invalidate` and
+   `CACHE_INVALIDATE_SECRET` (or `INVALIDATE_SECRET`); protected previews also need
+   `CACHE_PROTECTION_BYPASS_SECRET`. The selected app must use the same DB and its
+   existing cache namespace/Blob prefix. No new cache scope is introduced.
+
+   The backfill checkpoints NULL-audit AgentX candidates in the existing manifest
+   before ingest writes. `benchmarkRefresh` records IDs, retained source-derived
+   audit updates, target endpoint, pending/complete/failed status, check time and
+   error. DB audits must match that saved source evidence. Only the matching
+   publication points' NULL audit fields are enriched; original artifact hashes,
+   benchmark values and unrelated points remain unchanged. Without `--receipt`, the
+   existing default is `power-publication-RUN_ID-attempt-ATTEMPT.json`. Missing
+   configuration fails that pair before ingest; configuration errors cannot
+   silently turn a metadata write into a successful backfill.
+
+   After ingest, refresh runs in this order: `latest_benchmarks` materialized view,
+   the existing invalidate endpoint, then exact-run benchmark API comparison by ID
+   and structured `power_audit`. Refresh failure exits nonzero and retains the
+   responsibility even if the next ingest changes no samples or metadata.
+   To retry only that phase, without downloading artifacts or rewriting samples:
+
+   ```sh
+   bun run admin:db:backfill-gpu-metrics --run RUN_ID --attempt ATTEMPT \
+     --receipt /path/power-publication.json --refresh-cache-only --yes
+   ```
+
+   The receipt's run/attempt, point IDs and endpoint must still match. A checkpoint
+   interrupted before its metadata UPDATE leaves NULL candidates. They retain a
+   failed refresh responsibility and require targeted artifact re-ingest; a later
+   upsert clearing an already-written audit cannot erase that responsibility.
+   Invalid/string-encoded audits fail explicitly. HTTP calls have a 30-second
+   timeout; retries use the saved receipt rather than an unrecorded manual purge.
+   Dry runs never refresh. `complete` covers the recorded IDs and API metadata,
+   not browser state, energy validity or deployment-wide acceptance.
+
    An explicit `--run` is rechecked even if some series already exist. Unchanged inputs
    are no-ops. The GitHub backfill route accepts only the current source attempt and
    filters out earlier attempt artifacts; it refuses a mismatched historical attempt.
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.test.ts b/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
index 00bd200d6..7c3c7ab1c 100644
--- a/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
@@ -109,14 +109,19 @@ function bundle(overrides: Record<string, string | undefined> = {}): Map<string,
 }
 
 describe('isPowerAuditBundleEntry', () => {
-  it('selects samples, manifest, and top-level validations only', () => {
+  it('selects samples, manifest and retained validation/result/window documents', () => {
     expect(isPowerAuditBundleEntry(BUNDLE_SAMPLES_ENTRY)).toBe(true);
     expect(isPowerAuditBundleEntry(BUNDLE_MANIFEST_ENTRY)).toBe(true);
     expect(isPowerAuditBundleEntry(validationName(8))).toBe(true);
     expect(isPowerAuditBundleEntry('LOGS/power/windows/results_concurrency_8.json')).toBe(false);
     expect(isPowerAuditBundleEntry(`LOGS/sa-bench_isl_8192_osl_1024/results.json`)).toBe(false);
-    expect(isPowerAuditBundleEntry(`agg_${RESULT}_conc8.json`)).toBe(false);
-    expect(isPowerAuditBundleEntry(`${RESULT}_conc8.json`)).toBe(false);
+    // Root result candidates are matched to the exact artifact by normalization.
+    expect(isPowerAuditBundleEntry(`agg_${RESULT}_conc8.json`)).toBe(true);
+    expect(isPowerAuditBundleEntry(`${RESULT}_conc8.json`)).toBe(true);
+    expect(isPowerAuditBundleEntry('LOGS/agentic/conc_8/power_validation.json')).toBe(true);
+    expect(isPowerAuditBundleEntry('LOGS/power/windows/agentic_power_concurrency_8.json')).toBe(
+      true,
+    );
     expect(isPowerAuditBundleEntry(`nested/${validationName(8)}`)).toBe(false);
     expect(isPowerAuditBundleEntry('power_validation_x.json.bak')).toBe(false);
   });
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.ts b/packages/app/src/components/gpu-power/power-audit-bundle.ts
index 65efac26c..f1530a7e8 100644
--- a/packages/app/src/components/gpu-power/power-audit-bundle.ts
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.ts
@@ -14,6 +14,10 @@
  * the network or the zip.
  */
 import { parseNvidiaTimestamp } from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
+import {
+  isPowerAuditValidationEntry,
+  normalizePowerAuditValidations,
+} from '@semianalysisai/inferencex-db/etl/power-audit-validations';
 
 import {
   bucketPowerSeries,
@@ -29,15 +33,13 @@ export const BUNDLE_WINDOW_PAD_SECONDS = 60;
 
 export const BUNDLE_SAMPLES_ENTRY = 'LOGS/power/samples.csv';
 export const BUNDLE_MANIFEST_ENTRY = 'LOGS/power/manifest.json';
-/** Top-level `power_validation_<name>.json`; the `LOGS/` copies of results are not validations. */
-const VALIDATION_ENTRY = /^power_validation_[^/]+\.json$/u;
 
 /** Zip entries the route must extract for `cutPowerAuditBundle`; everything else stays compressed. */
 export function isPowerAuditBundleEntry(entryName: string): boolean {
   return (
     entryName === BUNDLE_SAMPLES_ENTRY ||
     entryName === BUNDLE_MANIFEST_ENTRY ||
-    VALIDATION_ENTRY.test(entryName) ||
+    isPowerAuditValidationEntry(entryName) ||
     isSmiCsv(entryName) ||
     isContextEntry(entryName)
   );
@@ -256,12 +258,7 @@ export function cutPowerAuditBundle(
   artifact: string,
   files: ReadonlyMap<string, string>,
 ): GpuPowerSeries[] {
-  const validations = new Map<string, Record<string, unknown>>();
-  for (const [entryName, text] of files) {
-    if (!VALIDATION_ENTRY.test(entryName)) continue;
-    const validation = parseJsonObject(text);
-    if (validation) validations.set(entryName, validation);
-  }
+  const validations = normalizePowerAuditValidations(artifact, files);
   const manifest = parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY));
   const contextFiles = [...files]
     .filter(([name]) => isContextEntry(name))
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index 8db61155d..6a56f0c4d 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -110,7 +110,7 @@ const STRINGS = {
     utilityHelp:
       'Dashed reference at the all-in provisioned utility power per GPU from the hardware registry (SemiAnalysis Datacenter Industry Model). Off by default because it compresses the traces.',
     loading: (runs: number) =>
-      `Loading GPU telemetry for ${runs} run${runs === 1 ? '' : 's'}… (GitHub artifacts, may take a minute)`,
+      `Loading GPU telemetry for ${runs} run${runs === 1 ? '' : 's'}… (may take a minute)`,
     loadError: (runId: string, message: string) => `Run ${runId}: ${message}`,
     missing: (missing: number, total: number) =>
       `${missing} of ${total} measured configs have no telemetry trace and are not drawn.`,
@@ -179,8 +179,7 @@ const STRINGS = {
     utilityLines: '全电源配置参考线',
     utilityHelp:
       '按硬件注册表中每 GPU 的全电源配置（all-in）市电功率绘制虚线参考（SemiAnalysis 数据中心行业模型）。默认关闭，因为它会压缩曲线的纵向分辨率。',
-    loading: (runs: number) =>
-      `正在加载 ${runs} 个运行的 GPU 遥测数据……（GitHub 产物，可能需要约一分钟）`,
+    loading: (runs: number) => `正在加载 ${runs} 个运行的 GPU 遥测数据……（可能需要约一分钟）`,
     loadError: (runId: string, message: string) => `运行 ${runId}：${message}`,
     missing: (missing: number, total: number) =>
       `${total} 个有实测值的配置中有 ${missing} 个没有遥测曲线，未绘制。`,
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 1d811bb85..91933c97e 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -804,12 +804,20 @@ export interface ApiContractSourceDigest {
  * touching a route module. Digest changes require an explicit documentation review.
  */
 export const apiContractSourceDigests = [
+  {
+    source: '../db/src/etl/power-audit-validations.ts',
+    sourceSha256: '44a607747b79d038bb8f4e53590efba689d376c143f50a5d750d3552faa0c442',
+    reviewArea: {
+      en: 'Shared legacy and nested AgentX validation identity normalization for artifact and stored Timeline windows.',
+      zh: '产物与数据库 Timeline 窗口共用的 legacy 和嵌套 AgentX validation 身份规范化。',
+    },
+  },
   {
     source: 'src/components/gpu-power/power-audit-bundle.ts',
-    sourceSha256: 'c288ae25d4702c31a6bef5e5601e5b0b8c4abe89cd978a7eef2a4dc0247a344a',
+    sourceSha256: '35901a329822ae6522fe39522eb1da5509bcecee1afda93a2ce9c0d06b0f27de',
     reviewArea: {
-      en: 'Deterministic adjacent context selection and timezone normalization shared by artifact Timeline and run views, plus validation-window and device identity semantics.',
-      zh: '产物 Timeline 和 run 视图共用的确定性相邻 context 选择与时区规范化，以及验证窗口和设备身份语义。',
+      en: 'Artifact Timeline validation windows, strict nested AgentX result identity, adjacent context selection, timezone normalization and device identity semantics.',
+      zh: '产物 Timeline 验证窗口、严格匹配的嵌套 AgentX result 身份、相邻 context 选择、时区规范化及设备身份语义。',
     },
   },
   {
diff --git a/packages/db/src/backfill-gpu-metrics.test.ts b/packages/db/src/backfill-gpu-metrics.test.ts
index 94a61a820..8ad63bf29 100644
--- a/packages/db/src/backfill-gpu-metrics.test.ts
+++ b/packages/db/src/backfill-gpu-metrics.test.ts
@@ -141,6 +141,7 @@ afterAll(async () => {
 
 afterEach(() => {
   process.exitCode = originalExitCode;
+  vi.unstubAllEnvs();
   vi.restoreAllMocks();
   for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
 });
@@ -326,8 +327,10 @@ describe('flag validation', () => {
 function fixtureArtifact(name: string, files: Record<string, string>): ArtifactMeta {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'backfill-telemetry-fixture-'));
   roots.push(root);
-  for (const [file, content] of Object.entries(files))
+  for (const [file, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, file)), { recursive: true });
     fs.writeFileSync(path.join(root, file), content);
+  }
   artifactSources.set(name, root);
   return { name, archive_download_url: `fixture://${name}`, created_at: '2026-09-02T00:00:00Z' };
 }
@@ -809,6 +812,212 @@ function point(value: TelemetryReceipt, id: number) {
   return value.points.find((p) => p.benchmarkResultId === id)!;
 }
 
+describe('benchmark metadata cache recovery', () => {
+  const audit = {
+    source: 'power_validation_agentx.json',
+    window_start_unix: 10,
+    window_end_unix: 20,
+  };
+
+  async function pendingReceipt() {
+    vi.stubEnv('CACHE_INVALIDATE_URL', 'http://127.0.0.1:3137/api/v1/invalidate');
+    vi.stubEnv('CACHE_INVALIDATE_SECRET', 'local-test-secret');
+    await sql`UPDATE workflow_runs SET date = current_date WHERE id = 1`;
+    await sql`UPDATE benchmark_results SET power_audit = ${JSON.stringify(audit)}::jsonb, date = current_date WHERE id = 10`;
+    const file = receiptFile();
+    const [identity] =
+      await sql`SELECT c.*, br.id, br.benchmark_type, br.isl, br.osl, br.conc, br.offload_mode, br.recipe_fingerprint
+      FROM benchmark_results br JOIN configs c ON c.id = br.config_id WHERE br.id = 10`;
+    const manifest: PowerPublicationManifest = {
+      version: 1,
+      runId: FRESH_NO_SERIES,
+      runAttempt: 1,
+      points: [],
+      benchmarkRefresh: {
+        status: 'pending',
+        benchmarkResultIds: [10],
+        auditUpdates: [{ benchmarkResultId: 10, identity: identity!, powerAudit: audit }],
+        endpoint: 'http://127.0.0.1:3137/api/v1/invalidate',
+      },
+    };
+    fs.writeFileSync(file, JSON.stringify(manifest));
+    return file;
+  }
+
+  function successfulFetch() {
+    return vi
+      .spyOn(globalThis, 'fetch')
+      .mockImplementation((_url, init) =>
+        Promise.resolve(
+          Response.json(
+            init?.method === 'POST'
+              ? { invalidated: true, blobsDeleted: 1 }
+              : [{ id: 10, power_audit: audit }],
+          ),
+        ),
+      );
+  }
+
+  it.each([true, false])(
+    'checkpoints source evidence before metadata writes with configured=%s',
+    async (configured) => {
+      vi.stubEnv(
+        'CACHE_INVALIDATE_URL',
+        configured ? 'http://127.0.0.1:3137/api/v1/invalidate' : '',
+      );
+      vi.stubEnv('CACHE_INVALIDATE_SECRET', 'local-test-secret');
+      await sql`UPDATE benchmark_results SET benchmark_type = 'agentic_traces', isl = NULL, osl = NULL WHERE id = 10`;
+      const bmk = benchmarkArtifact('metadata');
+      const source = artifactSources.get(bmk.name)!;
+      const [raw] = JSON.parse(fs.readFileSync(path.join(source, 'results.json'), 'utf8'));
+      fs.writeFileSync(
+        path.join(source, 'results.json'),
+        JSON.stringify([{ ...raw, scenario_type: 'agentic-coding', users: 32 }]),
+      );
+      const expectedAudit = {
+        source: 'power_validation_metadata_conc32.json',
+        window_start_unix: 10,
+        window_end_unix: 20,
+      };
+      const gpu = fixtureArtifact('power_audit_metadata', {
+        'LOGS/power/samples.csv':
+          'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w\n1,10,0,host-a,0,GPU-0,100\n1,11,1,host-a,0,GPU-0,200',
+        'LOGS/power/manifest.json': JSON.stringify({ producer: 'srt-slurm.dcgm-power' }),
+        [expectedAudit.source]: JSON.stringify({
+          validation_path: 'LOGS/agentic/conc_32/power_validation.json',
+          result_file: 'metadata_conc32.json',
+          selected_window: { concurrency: 32, start_time_unix: 10, end_time_unix: 20 },
+        }),
+      });
+      retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
+      const [mapped] = readMappedBenchmarkRows(source);
+      const identity = benchmarkPublicationIdentity(mapped!);
+      await sql`UPDATE benchmark_results SET offload_mode = ${mapped!.offloadMode} WHERE id = 10`;
+      const original = {
+        identity,
+        metrics: { power_valid: 0, tput_per_gpu: 1234.5 },
+        workers: null,
+        power_invalid_reasons: ['original'],
+        power_audit: null,
+        artifact: { path: 'original.json', sha256: 'preserve-original-hash' },
+      };
+      const unrelated = { ...original, identity: { ...identity, conc: 64 } };
+      const file = receiptFile();
+      fs.writeFileSync(
+        file,
+        JSON.stringify({
+          version: 1,
+          runId: FRESH_NO_SERIES,
+          runAttempt: 1,
+          points: [original, unrelated],
+        }),
+      );
+      const request = vi
+        .spyOn(globalThis, 'fetch')
+        .mockImplementation((_url, init) =>
+          Promise.resolve(
+            Response.json(
+              init?.method === 'POST'
+                ? { invalidated: true, blobsDeleted: 1 }
+                : [{ id: 10, power_audit: expectedAudit }],
+            ),
+          ),
+        );
+      await recover(file, gpu.name);
+      const result: PowerPublicationManifest = JSON.parse(fs.readFileSync(file, 'utf8'));
+      expect(result.benchmarkRefresh?.status).toBe(configured ? 'complete' : 'failed');
+      expect(result.benchmarkRefresh?.auditUpdates?.[0]?.powerAudit).toEqual(expectedAudit);
+      expect(result.points).toEqual([
+        { ...original, power_audit: configured ? expectedAudit : null },
+        unrelated,
+      ]);
+      expect(await sql`SELECT power_audit FROM benchmark_results WHERE id = 10`).toEqual([
+        { power_audit: configured ? expectedAudit : null },
+      ]);
+      if (configured) expect(process.exitCode).toBe(0);
+      else {
+        expect(process.exitCode).toBe(1);
+        expect(request).not.toHaveBeenCalled();
+        expect(await sql`SELECT * FROM gpu_metric_samples`).toEqual([]);
+      }
+    },
+  );
+
+  it('refreshes a saved target without listing/downloading artifacts or changing telemetry', async () => {
+    const file = await pendingReceipt();
+    successfulFetch();
+    const before = await sql`SELECT * FROM gpu_metric_series ORDER BY id`;
+    process.argv = [
+      'bun',
+      'backfill-gpu-metrics.ts',
+      '--refresh-cache-only',
+      '--run',
+      String(FRESH_NO_SERIES),
+      '--attempt',
+      '1',
+      '--receipt',
+      file,
+      '--yes',
+    ];
+    await main();
+    expect(JSON.parse(fs.readFileSync(file, 'utf8')).benchmarkRefresh.status).toBe('complete');
+    expect(listedRunIds).toEqual([]);
+    expect(downloadedNames).toEqual([]);
+    expect(await sql`SELECT * FROM gpu_metric_series ORDER BY id`).toEqual(before);
+    expect(await sql`SELECT power_audit FROM latest_benchmarks WHERE id = 10`).toEqual([
+      { power_audit: audit },
+    ]);
+  });
+
+  it('retries a failed cache phase on unchanged ingest with zero sample rewrites', async () => {
+    const file = await pendingReceipt();
+    const bmk = benchmarkArtifact('metadata');
+    const gpu = telemetryArtifact('metadata');
+    retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
+    const request = successfulFetch();
+    request.mockResolvedValueOnce(new Response('unavailable', { status: 503 }));
+    await recover(file, gpu.name);
+    expect(process.exitCode).toBe(1);
+    expect(JSON.parse(fs.readFileSync(file, 'utf8')).benchmarkRefresh).toMatchObject({
+      status: 'failed',
+      benchmarkResultIds: [10],
+      error: 'invalidate cache: HTTP 503',
+    });
+    const before =
+      await sql`SELECT * FROM gpu_metric_samples ORDER BY series_id, sampled_at, gpu_index`;
+    await recover(file, gpu.name);
+    expect(process.exitCode).toBe(0);
+    expect(JSON.parse(fs.readFileSync(file, 'utf8')).benchmarkRefresh.status).toBe('complete');
+    expect(
+      await sql`SELECT * FROM gpu_metric_samples ORDER BY series_id, sampled_at, gpu_index`,
+    ).toEqual(before);
+    expect(
+      vi
+        .mocked(console.log)
+        .mock.calls.flat()
+        .some((line) => String(line).includes('+0 samples')),
+    ).toBe(true);
+  });
+
+  it('rejects a receipt for another run before any cache request or artifact download', async () => {
+    const file = await pendingReceipt();
+    const request = successfulFetch();
+    process.argv = [
+      'bun',
+      'backfill-gpu-metrics.ts',
+      '--refresh-cache-only',
+      '--run',
+      String(FRESH_WITH_SERIES),
+      '--receipt',
+      file,
+      '--yes',
+    ];
+    await expect(main()).rejects.toThrow('receipt run/attempt');
+    expect(request).not.toHaveBeenCalled();
+    expect(downloadedNames).toEqual([]);
+  });
+});
+
 describe('real persistence through the recovery CLI', () => {
   it('repairs absent, failed and unlinked points separately without duplicating shared series or crossing attempts', async () => {
     await db.exec(`
diff --git a/packages/db/src/backfill-gpu-metrics.ts b/packages/db/src/backfill-gpu-metrics.ts
index a89f81c1f..cfd53819c 100644
--- a/packages/db/src/backfill-gpu-metrics.ts
+++ b/packages/db/src/backfill-gpu-metrics.ts
@@ -29,6 +29,8 @@ import { hasNoSslFlag } from './cli-utils.js';
 import { AsyncSemaphore } from './etl/async-semaphore.js';
 import { createAdminSql } from './etl/db-utils.js';
 import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest.js';
+import { readPowerAuditValidations } from './etl/gpu-metrics-artifacts.js';
+import { recoveredPowerAudit } from './etl/power-audit-validations.js';
 import {
   benchmarkPublicationIdentity,
   stablePowerPointIdentity,
@@ -42,6 +44,11 @@ import {
   type TelemetryReceipt,
 } from './etl/telemetry-receipt.js';
 import { retryArtifactOperation } from './lib/artifact-retry.js';
+import {
+  checkpointBenchmarkRefresh,
+  refreshBackfillBenchmarks,
+  type BenchmarkAuditUpdate,
+} from './lib/backfill-benchmark-refresh.js';
 import {
   confirmProceed,
   listBackfillRunArtifacts,
@@ -80,6 +87,7 @@ interface BackfillFlags {
   attempt: number | null;
   artifact: string | null;
   receipt: string | null;
+  refreshCacheOnly: boolean;
 }
 
 function positiveIntFlag(flag: string): number | null {
@@ -116,6 +124,7 @@ function parseFlags(): BackfillFlags {
     attempt: positiveIntFlag('--attempt'),
     artifact: stringFlag('--artifact'),
     receipt: stringFlag('--receipt'),
+    refreshCacheOnly: process.argv.includes('--refresh-cache-only'),
   };
 }
 
@@ -165,6 +174,7 @@ type PairOutcome =
       samplesInserted: number;
       pointsLinked: number;
       expectationsUnknown: boolean;
+      metadataUpdatedBenchmarkResultIds: number[];
     }
   | { kind: 'unmatched' }
   | { kind: 'failed' };
@@ -177,6 +187,7 @@ async function processPair(
   observations: Map<string, TelemetryObservation>,
   expectationErrors: NonNullable<TelemetryReceipt['expectationErrors']>,
   uniqueFallbacks: Map<string, number>,
+  checkpointMetadata: (updates: BenchmarkAuditUpdate[]) => Promise<void>,
 ): Promise<PairOutcome> {
   let benchmarkDir: string | null = null;
   let gpuMetricsDir: string | null = null;
@@ -201,12 +212,15 @@ async function processPair(
       observations.set(key, { identity, artifactNames: [pair.gpuMetrics.name], produced: true });
     }
     const matchedIds: number[] = [];
+    const mappedPoints: { ids: number[]; identity: Record<string, unknown> }[] = [];
     for (const row of mappedRows) {
       const ids = await findBenchmarkResultIds(sql, run, [row], (id) =>
         uniqueFallbacks.set(stablePowerPointIdentity(benchmarkPublicationIdentity(row)), id),
       );
       if (ids.length === 0) throw new Error(`${pair.gpuMetrics.name}: no matching benchmark rows`);
       matchedIds.push(...ids);
+      if (row.benchmarkType === 'agentic_traces')
+        mappedPoints.push({ ids, identity: benchmarkPublicationIdentity(row) });
     }
     const resultIds = [...new Set(matchedIds)];
     if (resultIds.length === 0) {
@@ -217,6 +231,31 @@ async function processPair(
     gpuMetricsDir = await retryArtifactOperation(`downloading ${pair.gpuMetrics.name}`, () =>
       downloadArtifact(pair.gpuMetrics, tempDir),
     );
+    const validations = Object.entries(
+      readPowerAuditValidations(gpuMetricsDir, pair.gpuMetrics.name),
+    )
+      .map(([source, validation]) => ({
+        powerAudit: recoveredPowerAudit(source, validation),
+        conc: (validation.selected_window as Record<string, unknown> | undefined)?.concurrency,
+      }))
+      .filter((validation) => validation.powerAudit !== null);
+    const auditUpdates: BenchmarkAuditUpdate[] = [];
+    for (const point of mappedPoints) {
+      const candidates = validations.filter(
+        (validation) => validation.conc === point.identity.conc,
+      );
+      if (candidates.length !== 1) continue;
+      const powerAudit = candidates[0]!.powerAudit;
+      if (powerAudit)
+        auditUpdates.push(
+          ...point.ids.map((benchmarkResultId) => ({
+            benchmarkResultId,
+            identity: point.identity,
+            powerAudit,
+          })),
+        );
+    }
+    await checkpointMetadata(auditUpdates);
     const ingested = await ingestGpuMetricsArtifact(sql, {
       workflowRunId: run.id,
       artifact: { artifactName: pair.gpuMetrics.name, artifactDir: gpuMetricsDir },
@@ -231,6 +270,7 @@ async function processPair(
       samplesInserted: ingested.samplesInserted,
       pointsLinked: resultIds.length,
       expectationsUnknown,
+      metadataUpdatedBenchmarkResultIds: ingested.metadataUpdatedBenchmarkResultIds,
     };
   } catch (error) {
     if (pointKeys.length === 0)
@@ -259,6 +299,15 @@ async function main(): Promise<void> {
   }
   if ((flags.attempt !== null || flags.artifact || flags.receipt) && flags.run === null)
     throw new Error('--attempt, --artifact and --receipt require --run');
+  if (
+    flags.refreshCacheOnly &&
+    (!flags.run || !flags.receipt || flags.artifact || flags.all || flags.dryRun)
+  )
+    throw new Error(
+      '--refresh-cache-only requires --run and --receipt, without --all, --artifact or --dry-run',
+    );
+  if (flags.refreshCacheOnly && !fs.existsSync(flags.receipt!))
+    throw new Error('--refresh-cache-only requires an existing receipt');
 
   console.log('=== backfill-gpu-metrics ===');
   const runs = await loadCandidateRuns(flags, limit, force);
@@ -317,7 +366,13 @@ async function main(): Promise<void> {
     return;
   }
 
-  if (!(await confirmProceed(`${runs.length} workflow run(s) will be checked for gpu_metrics.`))) {
+  if (
+    !(await confirmProceed(
+      flags.refreshCacheOnly
+        ? 'Only the recorded benchmark metadata cache will be refreshed.'
+        : `${runs.length} workflow run(s) will be checked for gpu_metrics.`,
+    ))
+  ) {
     return;
   }
 
@@ -334,7 +389,6 @@ async function main(): Promise<void> {
   for (const [runIndex, run] of runs.entries()) {
     const runId = run.github_run_id;
     const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `gpu-metrics-backfill-${runId}-`));
     const runStart = Date.now();
     const receiptPath =
       flags.receipt ?? `power-publication-${runId}-attempt-${run.run_attempt}.json`;
@@ -350,6 +404,50 @@ async function main(): Promise<void> {
         (manifest.telemetry.runId !== runId || manifest.telemetry.runAttempt !== run.run_attempt))
     )
       throw new Error('Publication receipt run/attempt does not match the recovery target');
+    const saveReceipt = () => {
+      fs.mkdirSync(path.dirname(path.resolve(receiptPath)), { recursive: true });
+      const temporary = `${receiptPath}.tmp`;
+      fs.writeFileSync(temporary, `${JSON.stringify(manifest, null, 2)}\n`, { flush: true });
+      fs.renameSync(temporary, receiptPath);
+    };
+    const refresh = async () => {
+      try {
+        await refreshBackfillBenchmarks(sql, manifest, saveReceipt);
+      } catch (error) {
+        process.exitCode = 1;
+        console.error(
+          `  Benchmark metadata refresh failed; retry --refresh-cache-only --run ${runId} --attempt ${run.run_attempt} --receipt ${receiptPath} --yes`,
+          error,
+        );
+      }
+    };
+    if (flags.refreshCacheOnly) {
+      await refresh();
+      continue;
+    }
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `gpu-metrics-backfill-${runId}-`));
+    const checkpointMetadata = async (updates: BenchmarkAuditUpdate[]) => {
+      if (updates.length === 0) return;
+      const candidates = await sql<{ id: number; offload_mode: string }[]>`
+        select br.id, br.offload_mode from benchmark_results br
+        where br.workflow_run_id = ${run.id}
+          and br.id = any(${sql.array(updates.map((update) => update.benchmarkResultId))}::bigint[])
+          and br.benchmark_type = 'agentic_traces' and br.power_audit is null
+      `;
+      checkpointBenchmarkRefresh(
+        manifest,
+        candidates.map((row) => Number(row.id)),
+        saveReceipt,
+        candidates.map((row) => {
+          const update = updates.find((entry) => entry.benchmarkResultId === Number(row.id))!;
+          return {
+            ...update,
+            sourceIdentity: update.identity,
+            identity: { ...update.identity, offload_mode: row.offload_mode },
+          };
+        }),
+      );
+    };
     const observations = new Map<string, TelemetryObservation>();
     const uniqueFallbacks = new Map<string, number>();
     let recoveryError: string | undefined;
@@ -420,7 +518,15 @@ async function main(): Promise<void> {
       const outcomes = await Promise.all(
         pairs.map((pair) =>
           limiter.run(() =>
-            processPair(run, pair, tempDir, observations, missing.errors, uniqueFallbacks),
+            processPair(
+              run,
+              pair,
+              tempDir,
+              observations,
+              missing.errors,
+              uniqueFallbacks,
+              checkpointMetadata,
+            ),
           ),
         ),
       );
@@ -434,6 +540,11 @@ async function main(): Promise<void> {
             runSeries += outcome.seriesCount;
             runSamples += outcome.samplesInserted;
             pointsLinked += outcome.pointsLinked;
+            checkpointBenchmarkRefresh(
+              manifest,
+              outcome.metadataUpdatedBenchmarkResultIds,
+              saveReceipt,
+            );
             break;
           }
           case 'unmatched': {
@@ -486,8 +597,9 @@ async function main(): Promise<void> {
         ];
       }
       summarizeTelemetryReceipt(manifest.telemetry);
-      fs.mkdirSync(path.dirname(path.resolve(receiptPath)), { recursive: true });
-      fs.writeFileSync(receiptPath, `${JSON.stringify(manifest, null, 2)}\n`);
+      saveReceipt();
+      if (manifest.benchmarkRefresh && manifest.benchmarkRefresh.status !== 'complete')
+        await refresh();
       console.log(`  PowerX ingest receipt: ${receiptPath}`);
       fs.rmSync(tempDir, { recursive: true, force: true });
     }
diff --git a/packages/db/src/etl/benchmark-mapper.ts b/packages/db/src/etl/benchmark-mapper.ts
index 060b39412..d63a4a49a 100644
--- a/packages/db/src/etl/benchmark-mapper.ts
+++ b/packages/db/src/etl/benchmark-mapper.ts
@@ -148,7 +148,7 @@ export interface PowerAudit {
   max_sample_gap_s?: number;
   producer_sha?: string | null;
   exporter_image_sha256?: string | null;
-  /** Relative path within the source run artifact bundle. */
+  /** Validation filename; nested AgentX documents use a canonical filename alias. */
   source?: string;
   /** Producer device identifiers; not necessarily physical UUIDs on older traces. */
   observed_gpu_ids?: string[];
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.ts b/packages/db/src/etl/gpu-metrics-artifacts.ts
index 4bd4e2959..d101976e4 100644
--- a/packages/db/src/etl/gpu-metrics-artifacts.ts
+++ b/packages/db/src/etl/gpu-metrics-artifacts.ts
@@ -22,8 +22,13 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 
 import { isMultinodePowerSamplesPath } from './multinode-power-samples.js';
+import {
+  isPowerAuditValidationEntry,
+  normalizePowerAuditValidations,
+} from './power-audit-validations.js';
 
 export const GPU_METRICS_ARTIFACT_PREFIX = 'gpu_metrics_';
 export const POWER_AUDIT_ARTIFACT_PREFIX = 'power_audit_';
@@ -41,7 +46,7 @@ export interface GpuMetricsCsvFile {
 
 export interface GpuMetricsSidecars {
   context: Record<string, unknown> | null;
-  /** Original per-window audit documents, keyed by their source filename. */
+  /** Audit documents keyed by canonical source; nested documents retain original path/hash. */
   validations?: Record<string, Record<string, unknown>>;
   /** Expected stored files and deduplicated row counts from this one artifact. */
   seriesInventory?: { fileName: string; sampleCount: number }[];
@@ -119,17 +124,38 @@ export function readMultinodePowerManifest(samplesPath: string): Record<string,
 }
 
 /** Preserve window boundaries and role overrides before GitHub artifact expiry. */
-export function readPowerAuditValidations(root: string): Record<string, Record<string, unknown>> {
-  const validations: Record<string, Record<string, unknown>> = {};
-  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return validations;
+export function readPowerAuditValidations(
+  root: string,
+  artifactName = path.basename(root),
+): Record<string, Record<string, unknown>> {
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return {};
+  const files = new Map<string, string>();
+  const read = (name: string) => {
+    const file = path.join(root, name);
+    if (isPowerAuditValidationEntry(name) && fs.existsSync(file) && fs.statSync(file).isFile()) {
+      files.set(name, fs.readFileSync(file, 'utf8'));
+    }
+  };
   for (const name of fs.readdirSync(root).sort()) {
-    if (!/^power_validation_[^/]+\.json$/u.test(name)) continue;
-    const parsed = readJsonIfPresent(path.join(root, name));
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-      validations[name] = parsed as Record<string, unknown>;
+    read(name);
+  }
+  const agentic = path.join(root, 'LOGS', 'agentic');
+  if (fs.existsSync(agentic) && fs.statSync(agentic).isDirectory()) {
+    for (const entry of fs.readdirSync(agentic, { withFileTypes: true })) {
+      const match = /^conc_(?<concurrency>[1-9]\d*)$/u.exec(entry.name);
+      if (!entry.isDirectory() || !match) continue;
+      read(`LOGS/agentic/${entry.name}/power_validation.json`);
+      read(`LOGS/power/windows/agentic_power_concurrency_${match.groups!.concurrency}.json`);
     }
   }
-  return validations;
+  const validations = normalizePowerAuditValidations(artifactName, files);
+  for (const validation of validations.values()) {
+    if (typeof validation.validation_path !== 'string') continue;
+    const original = files.get(validation.validation_path);
+    if (original !== undefined)
+      validation.validation_sha256 = createHash('sha256').update(original).digest('hex');
+  }
+  return Object.fromEntries(validations);
 }
 
 function readJsonIfPresent(pathname: string): unknown | null {
diff --git a/packages/db/src/etl/gpu-metrics-ingest.test.ts b/packages/db/src/etl/gpu-metrics-ingest.test.ts
index c8f593d48..9d35fb2fc 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.test.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.test.ts
@@ -391,7 +391,12 @@ describe('ingestGpuMetricsArtifact', () => {
       artifact,
       benchmarkResultIds: [11],
     });
-    expect(recovered).toEqual({ seriesIds: [seriesId], samplesInserted: 5, seriesSkipped: 0 });
+    expect(recovered).toEqual({
+      metadataUpdatedBenchmarkResultIds: [],
+      seriesIds: [seriesId],
+      samplesInserted: 5,
+      seriesSkipped: 0,
+    });
     const after = await storedSeries(seriesId);
     expect(after.metadata).toMatchObject([
       { sample_count: 5, sidecars: { context: { timestamp_timezone: '+02:00' } } },
@@ -459,6 +464,7 @@ describe('ingestGpuMetricsArtifact', () => {
       benchmarkResultIds: [11],
     });
     expect(replay).toEqual({
+      metadataUpdatedBenchmarkResultIds: [],
       seriesIds: recovered.seriesIds,
       samplesInserted: 0,
       seriesSkipped: 2,
@@ -615,7 +621,12 @@ describe('ingestGpuMetricsArtifact', () => {
       artifact,
       benchmarkResultIds: [10],
     });
-    expect(result).toEqual({ seriesIds: first.seriesIds, samplesInserted: 0, seriesSkipped: 1 });
+    expect(result).toEqual({
+      metadataUpdatedBenchmarkResultIds: [],
+      seriesIds: first.seriesIds,
+      samplesInserted: 0,
+      seriesSkipped: 1,
+    });
     const [after] = await sql<{ ingested_at: Date }[]>`select ingested_at from gpu_metric_series`;
     expect(after!.ingested_at).toEqual(before!.ingested_at);
   });
@@ -627,6 +638,11 @@ describe('ingestGpuMetricsArtifact', () => {
       artifact,
       benchmarkResultIds: [10],
     });
-    expect(result).toEqual({ seriesIds: [], samplesInserted: 0, seriesSkipped: 0 });
+    expect(result).toEqual({
+      metadataUpdatedBenchmarkResultIds: [],
+      seriesIds: [],
+      samplesInserted: 0,
+      seriesSkipped: 0,
+    });
   });
 });
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
index dc9b05b87..18f60b82d 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -37,6 +37,7 @@ import {
   type GpuMetricsSidecars,
 } from './gpu-metrics-artifacts.js';
 import { multinodePowerVendor, parseMultinodePowerSamples } from './multinode-power-samples.js';
+import { recoveredPowerAudit } from './power-audit-validations.js';
 
 /** Samples are streamed to Postgres in unnest batches of this many rows. */
 const SAMPLE_BATCH_SIZE = 5000;
@@ -69,6 +70,7 @@ export interface GpuMetricsIngestResult {
   seriesIds: number[];
   samplesInserted: number;
   seriesSkipped: number;
+  metadataUpdatedBenchmarkResultIds: number[];
 }
 
 /**
@@ -79,7 +81,7 @@ export interface GpuMetricsIngestResult {
  */
 function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
   const prepared: PreparedGpuMetricSeries[] = [];
-  const validations = readPowerAuditValidations(artifact.artifactDir);
+  const validations = readPowerAuditValidations(artifact.artifactDir, artifact.artifactName);
   for (const file of listMultinodePowerSampleFiles(artifact.artifactDir)) {
     const csvText = fs.readFileSync(file.path, 'utf8');
     const hosts = parseMultinodePowerSamples(csvText);
@@ -129,7 +131,7 @@ export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): Prepare
     const csvText = fs.readFileSync(file.path, 'utf8');
     const sidecars = readGpuMetricsSidecars(file.path);
     if (artifact.artifactName.startsWith('power_audit_')) {
-      sidecars.validations = readPowerAuditValidations(artifact.artifactDir);
+      sidecars.validations = readPowerAuditValidations(artifact.artifactDir, artifact.artifactName);
       const bundleFile = listMultinodePowerSampleFiles(artifact.artifactDir)[0];
       sidecars.powerManifest = bundleFile ? readMultinodePowerManifest(bundleFile.path) : null;
     }
@@ -374,7 +376,12 @@ export async function ingestGpuMetricsArtifact(
   },
 ): Promise<GpuMetricsIngestResult> {
   const prepared = prepareGpuMetricsArtifact(input.artifact);
-  const result: GpuMetricsIngestResult = { seriesIds: [], samplesInserted: 0, seriesSkipped: 0 };
+  const result: GpuMetricsIngestResult = {
+    seriesIds: [],
+    samplesInserted: 0,
+    seriesSkipped: 0,
+    metadataUpdatedBenchmarkResultIds: [],
+  };
   for (const series of prepared) {
     const upserted = await upsertGpuMetricSeries(sql, {
       workflowRunId: input.workflowRunId,
@@ -386,5 +393,32 @@ export async function ingestGpuMetricsArtifact(
     result.samplesInserted += upserted.samplesInserted;
     if (upserted.samplesInserted === 0 && !upserted.replaced) result.seriesSkipped++;
   }
+  // The caller has resolved this artifact's exact benchmark identities. Recover
+  // only a unique AgentX point within that explicit set, after every host is
+  // stored/linked. This also repairs metadata when all samples were a no-op.
+  const validations = prepared[0]?.sidecars.validations ?? {};
+  const audits = Object.entries(validations)
+    .map(([source, validation]) => ({
+      audit: recoveredPowerAudit(source, validation),
+      conc: (validation.selected_window as Record<string, unknown> | undefined)?.concurrency,
+    }))
+    .filter((entry) => entry.audit !== null);
+  for (const { audit, conc } of audits) {
+    if (typeof conc !== 'number' || !Number.isSafeInteger(conc) || conc <= 0) continue;
+    if (audits.filter((entry) => entry.conc === conc).length !== 1) continue;
+    const updated = await sql<{ id: number }[]>`
+      with candidates as (
+        select id from benchmark_results
+        where workflow_run_id = ${input.workflowRunId}
+          and id = any(${sql.array([...new Set(input.benchmarkResultIds)])}::bigint[])
+          and benchmark_type = 'agentic_traces' and conc = ${conc}
+      )
+      update benchmark_results set power_audit = ${sql.json(audit)}::jsonb
+      where id in (select id from candidates)
+        and (select count(*) from candidates) = 1 and power_audit is null
+      returning id
+    `;
+    result.metadataUpdatedBenchmarkResultIds.push(...updated.map((row) => Number(row.id)));
+  }
   return result;
 }
diff --git a/packages/db/src/etl/power-audit-recovery.test.ts b/packages/db/src/etl/power-audit-recovery.test.ts
new file mode 100644
index 000000000..569b1aed2
--- /dev/null
+++ b/packages/db/src/etl/power-audit-recovery.test.ts
@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest';
+
+import type { BenchmarkPersistenceInput } from './benchmark-ingest.js';
+import {
+  createBenchmarkPowerAuditRecovery,
+  type BenchmarkPowerAuditEvidence,
+} from './power-audit-recovery.js';
+
+const resultFile = 'kimik3_recipe-a_conc48.json';
+const source = `power_validation_${resultFile}`;
+const validation = {
+  power_valid: true,
+  validation_path: 'LOGS/agentic/conc_48/power_validation.json',
+  result_file: resultFile,
+  selected_window: {
+    concurrency: 48,
+    start_time_unix: 1000,
+    end_time_unix: 1100,
+    result_path: 'agentic/conc_48/agentic_power_concurrency_48.json',
+    window_file: 'windows/agentic_power_concurrency_48.json',
+  },
+};
+const evidence = { resultFile, validations: { [source]: validation } };
+const expectedAudit = { source, window_start_unix: 1000, window_end_unix: 1100 };
+
+function point(overrides: Partial<BenchmarkPersistenceInput> = {}): BenchmarkPersistenceInput {
+  return {
+    configId: 1,
+    benchmarkType: 'agentic_traces',
+    isl: null,
+    osl: null,
+    conc: 48,
+    offloadMode: 'on',
+    image: 'image',
+    recipeFingerprint: 'recipe-a',
+    metrics: { power_valid: 1, avg_power_w: 234.5, mean_ttft: 0.2 },
+    workers: [{ role: 'agg', worker_idx: 0, num_gpus: 8, avg_power_w: 234.5 }],
+    ...overrides,
+  };
+}
+
+describe('CI benchmark audit recovery', () => {
+  it.each([
+    ['aggregate before sibling', [false, true]],
+    ['aggregate after sibling', [true, false]],
+    ['repeated/no-op sibling ingest', [true, false, true, false]],
+  ])('retains exact provenance with %s and preserves benchmark values', (_label, paired) => {
+    const recover = createBenchmarkPowerAuditRecovery();
+    const original = point();
+    let latest = original;
+    for (const isPaired of paired) {
+      latest = recover(original, isPaired ? evidence : undefined);
+      expect(latest.metrics).toBe(original.metrics);
+      expect(latest.workers).toBe(original.workers);
+      expect({ ...latest, powerAudit: undefined }).toEqual({ ...original, powerAudit: undefined });
+    }
+    expect(latest.powerAudit).toEqual(expectedAudit);
+    expect(original.powerAudit).toBeUndefined();
+  });
+
+  it('preserves every explicit audit, including one without a source', () => {
+    const recover = createBenchmarkPowerAuditRecovery();
+    recover(point(), evidence);
+    for (const powerAudit of [{ source: 'producer-original.json' }, { sample_count: 42 }, {}]) {
+      const original = point({ powerAudit });
+      expect(recover(original, evidence)).toBe(original);
+      expect(recover(original)).toBe(original);
+    }
+  });
+
+  it.each([
+    { configId: 2 },
+    { recipeFingerprint: 'recipe-b' },
+    { offloadMode: 'off' },
+    { conc: 56 },
+    { isl: 8192 },
+    { osl: 1024 },
+    { benchmarkType: 'single_turn' as const },
+  ])('does not reuse the same run/concurrency audit for another point: %j', (difference) => {
+    const recover = createBenchmarkPowerAuditRecovery();
+    recover(point(), evidence);
+    const other = point(difference);
+    expect(recover(other)).toBe(other);
+    expect(other.powerAudit).toBeUndefined();
+  });
+
+  it('does not carry evidence into another run', () => {
+    createBenchmarkPowerAuditRecovery()(point(), evidence);
+    const nextRun = point();
+    expect(createBenchmarkPowerAuditRecovery()(nextRun)).toBe(nextRun);
+  });
+
+  it('restores audit metadata without promoting an invalid power verdict', () => {
+    const original = point({ metrics: { power_valid: 0, mean_ttft: 0.2 } });
+    const restored = createBenchmarkPowerAuditRecovery()(original, {
+      resultFile,
+      validations: { [source]: { ...validation, power_valid: false } },
+    });
+    expect(restored.powerAudit).toEqual(expectedAudit);
+    expect(restored.metrics).toBe(original.metrics);
+    expect(restored.metrics).toEqual({ power_valid: 0, mean_ttft: 0.2 });
+  });
+
+  it.each<BenchmarkPowerAuditEvidence>([
+    { resultFile: 'different-result.json', validations: evidence.validations },
+    {
+      resultFile,
+      validations: {
+        [source]: {
+          ...validation,
+          selected_window: { ...validation.selected_window, concurrency: 56 },
+        },
+      },
+    },
+    { resultFile, validations: { [source]: { ...validation, validation_path: undefined } } },
+    { resultFile, validations: {} },
+    { resultFile, validations: { [source]: validation, [`other/${source}`]: validation } },
+  ])('leaves missing or ambiguous exact sibling evidence unknown', (candidate) => {
+    const recover = createBenchmarkPowerAuditRecovery();
+    const original = point();
+    expect(recover(original, candidate)).toBe(original);
+    expect(recover(original)).toBe(original);
+  });
+});
diff --git a/packages/db/src/etl/power-audit-recovery.ts b/packages/db/src/etl/power-audit-recovery.ts
new file mode 100644
index 000000000..808be3ef7
--- /dev/null
+++ b/packages/db/src/etl/power-audit-recovery.ts
@@ -0,0 +1,42 @@
+import { benchmarkPointIngestKey, type BenchmarkPersistenceInput } from './benchmark-ingest.js';
+import type { PowerAudit } from './benchmark-mapper.js';
+import { recoveredPowerAudit } from './power-audit-validations.js';
+
+export interface BenchmarkPowerAuditEvidence {
+  resultFile: string;
+  validations: Record<string, Record<string, unknown>>;
+}
+
+/** One run's exact sibling evidence also applies to its later aggregate copies. */
+export function createBenchmarkPowerAuditRecovery() {
+  const recovered = new Map<string, PowerAudit>();
+  return <T extends BenchmarkPersistenceInput>(
+    row: T,
+    evidence?: BenchmarkPowerAuditEvidence,
+  ): T => {
+    if (row.benchmarkType !== 'agentic_traces' || row.powerAudit !== undefined) return row;
+    const key = benchmarkPointIngestKey(row);
+    if (evidence) {
+      const matches = Object.entries(evidence.validations).filter(([, validation]) => {
+        const window = validation.selected_window;
+        if (
+          validation.result_file !== evidence.resultFile ||
+          !window ||
+          typeof window !== 'object' ||
+          Array.isArray(window) ||
+          !('concurrency' in window) ||
+          window.concurrency !== row.conc
+        )
+          return false;
+        return true;
+      });
+      // Ambiguous/missing evidence must not establish new provenance.
+      if (matches.length !== 1) return row;
+      const audit = recoveredPowerAudit(...matches[0]);
+      if (!audit) return row;
+      recovered.set(key, audit);
+    }
+    const audit = recovered.get(key);
+    return audit ? { ...row, powerAudit: audit } : row;
+  };
+}
diff --git a/packages/db/src/etl/power-audit-validations.test.ts b/packages/db/src/etl/power-audit-validations.test.ts
new file mode 100644
index 000000000..d272b39cb
--- /dev/null
+++ b/packages/db/src/etl/power-audit-validations.test.ts
@@ -0,0 +1,247 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  isPowerAuditValidationEntry,
+  normalizePowerAuditValidations,
+  recoveredPowerAudit,
+} from './power-audit-validations.js';
+
+const ARTIFACT = 'power_audit_kimik3_agentx_fp4';
+const RESULT = 'kimik3_agentx_fp4_conc48.json';
+const SOURCE = 'power_validation_kimik3_agentx_fp4_conc48.json';
+const VALIDATION = 'LOGS/agentic/conc_48/power_validation.json';
+const WINDOW = 'LOGS/power/windows/agentic_power_concurrency_48.json';
+const RESULT_PATH = 'agentic/conc_48/agentic_power_concurrency_48.json';
+const START = 1789940129.369988;
+const END = 1789943769.371839;
+
+function fixture() {
+  const selected: Record<string, unknown> = {
+    window_file: 'windows/agentic_power_concurrency_48.json',
+    result_path: RESULT_PATH,
+    benchmark_type: 'custom',
+    concurrency: 48,
+    start_time_unix: START,
+    end_time_unix: END,
+    duration: END - START,
+  };
+  const validation: Record<string, unknown> = {
+    power_valid: true,
+    selected_window: selected,
+    per_gpu_role: { 'host-a/GPU-a': 'prefill', 'host-b/GPU-b': 'decode' },
+    validation_errors: [],
+  };
+  const result: Record<string, unknown> = { conc: 48, power_valid: 1 };
+  const window: Record<string, unknown> = {
+    schema_version: 1,
+    concurrency: 48,
+    result_path: RESULT_PATH,
+    benchmark_start_time_unix: START,
+    benchmark_end_time_unix: END,
+    status: 'completed',
+  };
+  const files = () =>
+    new Map([
+      [VALIDATION, JSON.stringify(validation)],
+      [RESULT, JSON.stringify(result)],
+      [WINDOW, JSON.stringify(window)],
+    ]);
+  return { selected, validation, result, window, files };
+}
+
+describe('isPowerAuditValidationEntry', () => {
+  it.each([SOURCE, VALIDATION, WINDOW, RESULT])('selects required input %s', (name) => {
+    expect(isPowerAuditValidationEntry(name)).toBe(true);
+  });
+
+  it.each([
+    'manifest.json',
+    'unrelated.json',
+    'results/kimik3_agentx_fp4_conc48.json',
+    'LOGS/power_validation_point.json',
+    'LOGS/agentic/conc_048/power_validation.json',
+    'LOGS/agentic/conc_0/power_validation.json',
+    'LOGS/agentic/conc_48/power_validation_copy.json',
+    'logs/agentic/conc_48/power_validation.json',
+    'LOGS/power/windows/unrelated_conc48.json',
+    'LOGS/power/windows/agentic_power_concurrency_48.json.bak',
+  ])('does not select unrelated or unsupported input %s', (name) => {
+    expect(isPowerAuditValidationEntry(name)).toBe(false);
+  });
+});
+
+describe('normalizePowerAuditValidations', () => {
+  it('preserves legacy top-level objects without adding new validity gates', () => {
+    const legacy = { power_valid: false, selected_window: null, note: 'retained as published' };
+    const files = new Map([
+      ['power_validation_legacy.json', JSON.stringify(legacy)],
+      ['power_validation_empty.json', '{}'],
+      ['power_validation_broken.json', '{'],
+      ['power_validation_array.json', '[]'],
+      ['power_validation_null.json', 'null'],
+      ['LOGS/power_validation_copy.json', '{}'],
+    ]);
+    expect(normalizePowerAuditValidations('legacy-upload', files)).toEqual(
+      new Map<string, Record<string, unknown>>([
+        ['power_validation_legacy.json', legacy],
+        ['power_validation_empty.json', {}],
+      ]),
+    );
+  });
+
+  it('aliases an exactly matched nested document without changing its window, roles or verdict', () => {
+    const input = fixture();
+    const files = input.files();
+    const retained = [...files];
+    expect(normalizePowerAuditValidations(ARTIFACT, files)).toEqual(
+      new Map([
+        [SOURCE, { ...input.validation, validation_path: VALIDATION, result_file: RESULT }],
+      ]),
+    );
+    expect([...files]).toEqual(retained);
+    expect(input.validation).not.toHaveProperty('validation_path');
+  });
+
+  it.each([false, undefined])(
+    'does not manufacture a valid verdict from power_valid=%s',
+    (valid) => {
+      const input = fixture();
+      if (valid === undefined) delete input.validation.power_valid;
+      else input.validation.power_valid = valid;
+      const normalized = normalizePowerAuditValidations(ARTIFACT, input.files()).get(SOURCE)!;
+      expect(normalized).toEqual({
+        ...input.validation,
+        validation_path: VALIDATION,
+        result_file: RESULT,
+      });
+      expect(Object.hasOwn(normalized, 'power_valid')).toBe(valid !== undefined);
+      expect(recoveredPowerAudit(SOURCE, normalized)).toEqual({
+        source: SOURCE,
+        window_start_unix: START,
+        window_end_unix: END,
+      });
+    },
+  );
+
+  it.each([VALIDATION, RESULT, WINDOW])('requires the exact paired input %s', (name) => {
+    const files = fixture().files();
+    files.delete(name);
+    expect(normalizePowerAuditValidations(ARTIFACT, files).size).toBe(0);
+  });
+
+  it.each([VALIDATION, RESULT, WINDOW])('rejects malformed or non-object input %s', (name) => {
+    for (const text of ['{bad json', '[]', 'null', '48']) {
+      const files = fixture().files();
+      files.set(name, text);
+      expect(normalizePowerAuditValidations(ARTIFACT, files).size).toBe(0);
+    }
+  });
+
+  it.each([
+    ['result', 'conc', 64],
+    ['result', 'conc', '48'],
+    ['selected', 'concurrency', 64],
+    ['selected', 'concurrency', '48'],
+    ['selected', 'result_path', 'agentic/conc_64/agentic_power_concurrency_64.json'],
+    ['selected', 'window_file', 'windows/agentic_power_concurrency_64.json'],
+    ['window', 'concurrency', 64],
+    ['window', 'result_path', 'agentic/conc_64/agentic_power_concurrency_64.json'],
+    ['window', 'benchmark_start_time_unix', START + 1],
+    ['window', 'benchmark_end_time_unix', END - 1],
+  ] as const)('rejects mismatched %s.%s', (document, field, value) => {
+    const input = fixture();
+    input[document][field] = value;
+    expect(normalizePowerAuditValidations(ARTIFACT, input.files()).size).toBe(0);
+  });
+
+  it.each([
+    [0, END],
+    [-1, END],
+    [START, START],
+    [END, START],
+    [null, END],
+    [START, '1789943769.371839'],
+  ])('rejects an invalid selected time range %s to %s', (start, end) => {
+    const input = fixture();
+    input.selected.start_time_unix = start;
+    input.window.benchmark_start_time_unix = start;
+    input.selected.end_time_unix = end;
+    input.window.benchmark_end_time_unix = end;
+    expect(normalizePowerAuditValidations(ARTIFACT, input.files()).size).toBe(0);
+  });
+
+  it('rejects an overflowing JSON number instead of emitting an infinite time', () => {
+    const files = fixture().files();
+    files.set(VALIDATION, files.get(VALIDATION)!.replace(String(START), '1e400'));
+    files.set(WINDOW, files.get(WINDOW)!.replace(String(START), '1e400'));
+    expect(normalizePowerAuditValidations(ARTIFACT, files).size).toBe(0);
+  });
+
+  it('does not guess the result from another root file with the same concurrency', () => {
+    const files = fixture().files();
+    files.set('different_config_conc48.json', files.get(RESULT)!);
+    files.delete(RESULT);
+    expect(normalizePowerAuditValidations(ARTIFACT, files).size).toBe(0);
+  });
+
+  it('does not borrow a document from a different nested concurrency directory', () => {
+    const files = fixture().files();
+    files.set('LOGS/agentic/conc_64/power_validation.json', files.get(VALIDATION)!);
+    files.delete(VALIDATION);
+    files.set('kimik3_agentx_fp4_conc64.json', JSON.stringify({ conc: 64 }));
+    expect(normalizePowerAuditValidations(ARTIFACT, files).size).toBe(0);
+  });
+
+  it('leaves a canonical legacy document authoritative regardless of insertion order', () => {
+    const files = fixture().files();
+    const legacy = { power_valid: false, selected_window: null, note: 'legacy wins' };
+    files.set(SOURCE, JSON.stringify(legacy));
+    expect(normalizePowerAuditValidations(ARTIFACT, files)).toEqual(new Map([[SOURCE, legacy]]));
+    expect(normalizePowerAuditValidations(ARTIFACT, new Map([...files].toReversed()))).toEqual(
+      new Map([[SOURCE, legacy]]),
+    );
+  });
+
+  it('does not derive AgentX aliases for an unrelated artifact', () => {
+    expect(
+      normalizePowerAuditValidations('gpu_metrics_kimik3_agentx_fp4', fixture().files()).size,
+    ).toBe(0);
+  });
+});
+
+describe('recoveredPowerAudit', () => {
+  it('returns only source and recorded times from a normalized nested validation', () => {
+    const normalized = normalizePowerAuditValidations(ARTIFACT, fixture().files()).get(SOURCE)!;
+    expect(recoveredPowerAudit(SOURCE, normalized)).toEqual({
+      source: SOURCE,
+      window_start_unix: START,
+      window_end_unix: END,
+    });
+  });
+
+  it('does not treat an ordinary legacy validation as recovered AgentX metadata', () => {
+    expect(recoveredPowerAudit(SOURCE, fixture().validation)).toBeNull();
+  });
+
+  it.each([
+    ['validation_path', 'LOGS/agentic/conc_64/power_validation.json'],
+    ['validation_path', 'power_validation_legacy.json'],
+    ['result_file', 'kimik3_agentx_fp4_conc64.json'],
+    ['result_file', 'nested/kimik3_agentx_fp4_conc48.json'],
+    ['selected_window', null],
+    ['selected_window', { concurrency: 48, start_time_unix: START, end_time_unix: Infinity }],
+    ['selected_window', { concurrency: 48, start_time_unix: END, end_time_unix: START }],
+    ['selected_window', { concurrency: 64, start_time_unix: START, end_time_unix: END }],
+  ])('rejects inconsistent recovery metadata in %s', (field, value) => {
+    const normalized = normalizePowerAuditValidations(ARTIFACT, fixture().files()).get(SOURCE)!;
+    normalized[String(field)] = value;
+    expect(recoveredPowerAudit(SOURCE, normalized)).toBeNull();
+  });
+
+  it('requires the alias to match the actual result filename', () => {
+    const normalized = normalizePowerAuditValidations(ARTIFACT, fixture().files()).get(SOURCE)!;
+    expect(
+      recoveredPowerAudit('power_validation_different_config_conc48.json', normalized),
+    ).toBeNull();
+  });
+});
diff --git a/packages/db/src/etl/power-audit-validations.ts b/packages/db/src/etl/power-audit-validations.ts
new file mode 100644
index 000000000..179c2abf1
--- /dev/null
+++ b/packages/db/src/etl/power-audit-validations.ts
@@ -0,0 +1,125 @@
+/** Pure normalization of legacy and retained AgentX power-audit documents. */
+const LEGACY_VALIDATION = /^power_validation_[^/]+\.json$/u;
+const AGENTX_VALIDATION = /^LOGS\/agentic\/conc_(?<concurrency>[1-9]\d*)\/power_validation\.json$/u;
+const AGENTX_WINDOW = /^LOGS\/power\/windows\/agentic_power_concurrency_[1-9]\d*\.json$/u;
+const RESULT_FILE = /^(?<stem>[^/]+)_conc(?<concurrency>[1-9]\d*)\.json$/u;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function parseObject(text: string | undefined): Record<string, unknown> | null {
+  if (text === undefined) return null;
+  try {
+    const value: unknown = JSON.parse(text);
+    return isRecord(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function hasWindowTimes(value: unknown): value is Record<string, unknown> & {
+  start_time_unix: number;
+  end_time_unix: number;
+} {
+  return (
+    isRecord(value) &&
+    typeof value.start_time_unix === 'number' &&
+    Number.isFinite(value.start_time_unix) &&
+    value.start_time_unix > 0 &&
+    typeof value.end_time_unix === 'number' &&
+    Number.isFinite(value.end_time_unix) &&
+    value.end_time_unix > value.start_time_unix
+  );
+}
+
+/** Only documents needed to identify a validation and its recorded result/window. */
+export function isPowerAuditValidationEntry(name: string): boolean {
+  return (
+    LEGACY_VALIDATION.test(name) ||
+    AGENTX_VALIDATION.test(name) ||
+    AGENTX_WINDOW.test(name) ||
+    RESULT_FILE.test(name)
+  );
+}
+
+/**
+ * Legacy top-level documents keep their names and contents. A nested AgentX
+ * document gains a canonical alias only when its result and retained window
+ * agree; path annotations retain the original document's provenance.
+ */
+export function normalizePowerAuditValidations(
+  artifactName: string,
+  files: ReadonlyMap<string, string>,
+): Map<string, Record<string, unknown>> {
+  const validations = new Map<string, Record<string, unknown>>();
+  for (const [name, text] of files) {
+    if (!LEGACY_VALIDATION.test(name)) continue;
+    const validation = parseObject(text);
+    if (validation) validations.set(name, validation);
+  }
+  const artifactStem = /^power_audit_(?<stem>[^/]+)$/u.exec(artifactName)?.groups?.stem;
+  if (!artifactStem) return validations;
+
+  for (const [validationPath, text] of files) {
+    const match = AGENTX_VALIDATION.exec(validationPath);
+    if (!match?.groups) continue;
+    const concurrency = Number(match.groups.concurrency);
+    if (!Number.isSafeInteger(concurrency)) continue;
+    const resultFile = `${artifactStem}_conc${concurrency}.json`;
+    const source = `power_validation_${resultFile.slice(0, -5)}.json`;
+    if (validations.has(source)) continue;
+    const validation = parseObject(text);
+    const result = parseObject(files.get(resultFile));
+    const selected = validation?.selected_window;
+    const resultPath = `agentic/conc_${concurrency}/agentic_power_concurrency_${concurrency}.json`;
+    const windowFile = `windows/agentic_power_concurrency_${concurrency}.json`;
+    const window = parseObject(files.get(`LOGS/power/${windowFile}`));
+    if (
+      !validation ||
+      result?.conc !== concurrency ||
+      !hasWindowTimes(selected) ||
+      selected.concurrency !== concurrency ||
+      selected.result_path !== resultPath ||
+      selected.window_file !== windowFile ||
+      window?.concurrency !== concurrency ||
+      window.result_path !== resultPath ||
+      window.benchmark_start_time_unix !== selected.start_time_unix ||
+      window.benchmark_end_time_unix !== selected.end_time_unix
+    )
+      continue;
+    validations.set(source, {
+      ...validation,
+      validation_path: validationPath,
+      result_file: resultFile,
+    });
+  }
+  return validations;
+}
+
+/** Recover source/window metadata only from a normalized nested validation. */
+export function recoveredPowerAudit(
+  source: string,
+  validation: Record<string, unknown>,
+): { source: string; window_start_unix: number; window_end_unix: number } | null {
+  const path = validation.validation_path;
+  const result = validation.result_file;
+  if (typeof path !== 'string' || typeof result !== 'string') return null;
+  const nested = AGENTX_VALIDATION.exec(path)?.groups;
+  const file = RESULT_FILE.exec(result)?.groups;
+  const selected = validation.selected_window;
+  if (
+    !nested ||
+    !file ||
+    nested.concurrency !== file.concurrency ||
+    source !== `power_validation_${result.slice(0, -5)}.json` ||
+    !hasWindowTimes(selected) ||
+    selected.concurrency !== Number(nested.concurrency)
+  )
+    return null;
+  return {
+    source,
+    window_start_unix: selected.start_time_unix,
+    window_end_unix: selected.end_time_unix,
+  };
+}
diff --git a/packages/db/src/etl/power-publication.ts b/packages/db/src/etl/power-publication.ts
index af855f313..d4a0ba17c 100644
--- a/packages/db/src/etl/power-publication.ts
+++ b/packages/db/src/etl/power-publication.ts
@@ -57,6 +57,22 @@ export interface PowerPublicationManifest {
   telemetryWarnings?: string[];
   /** Attachment completeness, separate from benchmark/power publication validity. */
   telemetry?: TelemetryReceipt;
+  /** Durable refresh responsibility when telemetry recovery fills benchmark metadata. */
+  benchmarkRefresh?: {
+    status: 'pending' | 'complete' | 'failed';
+    benchmarkResultIds: number[];
+    /** Expected enrichment comes from retained validation, never a DB snapshot. */
+    auditUpdates?: {
+      benchmarkResultId: number;
+      identity: Record<string, unknown>;
+      /** Original mapped identity when the existing historical offload resolver used a fallback. */
+      sourceIdentity?: Record<string, unknown>;
+      powerAudit: { source: string; window_start_unix: number; window_end_unix: number };
+    }[];
+    endpoint?: string;
+    checkedAt?: string;
+    error?: string;
+  };
 }
 /**
  * The errors that fail an ingest. `telemetryWarnings` is deliberately not among
diff --git a/packages/db/src/etl/telemetry-receipt.test.ts b/packages/db/src/etl/telemetry-receipt.test.ts
index 45e1e80dd..417e91df7 100644
--- a/packages/db/src/etl/telemetry-receipt.test.ts
+++ b/packages/db/src/etl/telemetry-receipt.test.ts
@@ -94,6 +94,107 @@ async function observations(): Promise<TelemetryObservation[]> {
 }
 
 describe('telemetry attachment receipts', () => {
+  it.each(['object', 'encoded string', 'null', 'malformed', 'array', 'invalid inventory'])(
+    'reads persisted JSONB %s sidecars without confusing unknown inventory with DB failure',
+    async (encoding) => {
+      const points = await observations();
+      const shared = artifact('gpu_metrics_shared');
+      fs.writeFileSync(
+        path.join(shared.artifactDir, 'gpu_metrics_host2.csv'),
+        fs.readFileSync(path.join(shared.artifactDir, 'gpu_metrics.csv')),
+      );
+      await ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact: shared,
+        benchmarkResultIds: [10, 11],
+      });
+      const stored = await db.query<{ sidecars: unknown }>(
+        'select sidecars from gpu_metric_series order by id',
+      );
+      const inventory = stored.rows[0]!.sidecars;
+      const value =
+        encoding === 'object'
+          ? inventory
+          : encoding === 'encoded string'
+            ? JSON.stringify(inventory)
+            : encoding === 'null'
+              ? null
+              : encoding === 'malformed'
+                ? '{broken'
+                : encoding === 'array'
+                  ? []
+                  : { seriesInventory: [{ fileName: 'gpu_metrics.csv', sampleCount: '2' }] };
+      await db.query('update gpu_metric_series set sidecars = $1::jsonb', [JSON.stringify(value)]);
+      const raw = await db.query<{ kind: string }>(
+        'select jsonb_typeof(sidecars) as kind from gpu_metric_series',
+      );
+      const kind =
+        encoding === 'encoded string' || encoding === 'malformed'
+          ? 'string'
+          : encoding === 'null'
+            ? 'null'
+            : encoding === 'array'
+              ? 'array'
+              : 'object';
+      expect(raw.rows).toEqual([{ kind }, { kind }]);
+      const receipt = await readTelemetryReceipt(
+        sql,
+        run,
+        points.slice(0, 2).map((point) => ({ ...point, artifactNames: [shared.artifactName] })),
+      );
+      const complete = encoding === 'object' || encoding === 'encoded string';
+      expect(receipt.databaseError).toBeUndefined();
+      expect(receipt.counts).toMatchObject({
+        expectedPoints: 4,
+        storedPoints: complete ? 2 : 0,
+        linkedPoints: complete ? 2 : 0,
+        storageUnknownPoints: complete ? 0 : 2,
+        storedSeries: 2,
+        storedSamples: 4,
+      });
+      for (const point of receipt.points.filter((candidate) =>
+        [10, 11].includes(candidate.benchmarkResultId!),
+      )) {
+        expect(point.storage.status).toBe(complete ? 'complete' : 'unknown');
+        expect(point.reasons).toEqual(complete ? [] : ['series_inventory_unknown']);
+        expect(point.linkedSeriesIds).toHaveLength(2);
+      }
+      const repaired = await readTelemetryReceipt(
+        sql,
+        run,
+        [{ ...points[0]!, artifactNames: [shared.artifactName] }],
+        { previous: receipt, targeted: true },
+      );
+      expect(repaired.points.filter((point) => point.benchmarkResultId !== 10)).toEqual(
+        receipt.points.filter((point) => point.benchmarkResultId !== 10),
+      );
+      expect(repaired.counts).toEqual(receipt.counts);
+    },
+  );
+
+  it('keeps a database query failure separate from an unknown stored inventory', async () => {
+    await db.exec('alter table gpu_metric_series rename to unavailable_gpu_metric_series');
+    try {
+      const receipt = await readTelemetryReceipt(sql, run, await observations());
+      expect(receipt.databaseError).toContain('gpu_metric_series');
+      expect(receipt.counts).toMatchObject({
+        expectedPoints: 4,
+        storedPoints: null,
+        linkedPoints: null,
+        storedSeries: null,
+        storedSamples: null,
+      });
+      expect(receipt.points.every((point) => point.reasons.includes('database_check_failed'))).toBe(
+        true,
+      );
+      expect(
+        receipt.points.every((point) => !point.reasons.includes('series_inventory_unknown')),
+      ).toBe(true);
+    } finally {
+      await db.exec('alter table unavailable_gpu_metric_series rename to gpu_metric_series');
+    }
+  });
+
   it('preserves an unrelated prior artifact failure at the canonical offload identity', async () => {
     await db.exec("UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10");
     const [canonical] = await observations();
diff --git a/packages/db/src/etl/telemetry-receipt.ts b/packages/db/src/etl/telemetry-receipt.ts
index f618538bb..16b8b019b 100644
--- a/packages/db/src/etl/telemetry-receipt.ts
+++ b/packages/db/src/etl/telemetry-receipt.ts
@@ -79,7 +79,7 @@ interface StoredSeries {
   id: number;
   artifact_name: string;
   file_name: string;
-  sidecars: { seriesInventory?: unknown };
+  sidecars: unknown;
   sample_count: number;
   benchmark_result_ids: number[];
 }
@@ -95,6 +95,20 @@ function isInventoryEntry(value: unknown): value is { fileName: string; sampleCo
   );
 }
 
+/** JSONB may contain an encoded object; unavailable inventories remain unknown. */
+function storedSeriesInventory(sidecars: unknown): unknown {
+  if (typeof sidecars === 'string') {
+    try {
+      sidecars = JSON.parse(sidecars) as unknown;
+    } catch {
+      return undefined;
+    }
+  }
+  return sidecars !== null && typeof sidecars === 'object' && !Array.isArray(sidecars)
+    ? (sidecars as { seriesInventory?: unknown }).seriesInventory
+    : undefined;
+}
+
 function seriesCoverageKey(artifact: string, file: string): string {
   return JSON.stringify([artifact, file]);
 }
@@ -108,7 +122,7 @@ function seriesCoverage(
   const inventories = new Map<string, string>();
   let unknown = false;
   for (const entry of series) {
-    const inventory = entry.sidecars?.seriesInventory;
+    const inventory = storedSeriesInventory(entry.sidecars);
     if (!Array.isArray(inventory) || inventory.length === 0 || !inventory.every(isInventoryEntry)) {
       unknown = true;
       continue;
diff --git a/packages/db/src/ingest-ci-run.ts b/packages/db/src/ingest-ci-run.ts
index 9d470e687..351233bf9 100644
--- a/packages/db/src/ingest-ci-run.ts
+++ b/packages/db/src/ingest-ci-run.ts
@@ -81,7 +81,11 @@ import {
 import { AsyncSemaphore } from './etl/async-semaphore';
 import { discoverTraceReplayArtifacts } from './etl/trace-artifact-discovery';
 import { discoverServerLogArtifacts, readServerLogArtifact } from './etl/server-log-artifacts';
-import { discoverGpuMetricsArtifacts } from './etl/gpu-metrics-artifacts';
+import {
+  discoverGpuMetricsArtifacts,
+  readPowerAuditValidations,
+} from './etl/gpu-metrics-artifacts';
+import { createBenchmarkPowerAuditRecovery } from './etl/power-audit-recovery';
 import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest';
 import { readTelemetryReceipt, type TelemetryObservation } from './etl/telemetry-receipt';
 import { datasetSlugFromBenchmarkRow } from './etl/dataset-provenance';
@@ -551,6 +555,7 @@ async function main(): Promise<void> {
 
     const allBmkFiles = [...bmkFiles, ...allBmkDirs.flatMap((d) => findJsonFiles(d))];
     const seenPointIdentities = new Map<string, string>();
+    const recoverPowerAudit = createBenchmarkPowerAuditRecovery();
     console.log(`  Found ${allBmkFiles.length} benchmark JSON file(s)`);
 
     for (const [fileIndex, file] of allBmkFiles.entries()) {
@@ -612,6 +617,23 @@ async function main(): Promise<void> {
       const suffix = stripBmkAndAgenticPrefix(parentDir);
       const gpuMetricsArtifact =
         gpuMetricsArtifacts.get(configKey) ?? gpuMetricsArtifacts.get(suffix);
+      let auditEvidence;
+      if (parentDir.startsWith('bmk_agentic_') && gpuMetricsArtifact) {
+        try {
+          auditEvidence = {
+            resultFile: path.basename(file),
+            validations: readPowerAuditValidations(
+              gpuMetricsArtifact.artifactDir,
+              gpuMetricsArtifact.artifactName,
+            ),
+          };
+        } catch (error) {
+          tracker.recordTelemetryError(
+            `power audit for ${configKey}`,
+            error instanceof Error ? error : new Error(String(error)),
+          );
+        }
+      }
       for (const row of rows) {
         let configId: number;
         try {
@@ -654,15 +676,18 @@ async function main(): Promise<void> {
               `config ${configId}, conc ${row.conc}`,
           );
         }
+        // Attach exact retained validation metadata before both the receipt and
+        // the upsert. A later aggregate copy must not null this run's recovery.
+        const point = recoverPowerAudit(applied.point, auditEvidence);
         const publication = powerPublicationPoint(
-          applied.point,
+          point,
           `https://github.com/${REPO}/actions/runs/${runIdNum}/attempts/${runAttemptNum}`,
           { path: relativeFile, sha256: artifactSha256 },
         );
         if (publication)
           powerPublicationPoints.set(publicationIdentity(publication.identity), publication);
-        toInsert.push(applied.point);
-        const identity = benchmarkPublicationIdentity(applied.point);
+        toInsert.push(point);
+        const identity = benchmarkPublicationIdentity(point);
         const key = stablePowerPointIdentity(identity);
         // Aggregate copies may arrive before/after their per-job sibling. Only
         // the latter establishes whether that exact telemetry artifact exists.
diff --git a/packages/db/src/lib/backfill-benchmark-refresh.test.ts b/packages/db/src/lib/backfill-benchmark-refresh.test.ts
new file mode 100644
index 000000000..623595ed9
--- /dev/null
+++ b/packages/db/src/lib/backfill-benchmark-refresh.test.ts
@@ -0,0 +1,306 @@
+import fs from 'node:fs';
+import { createServer } from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import { afterAll, afterEach, beforeAll, beforeEach, expect, it, vi } from 'vitest';
+
+import type { Sql } from '../etl/db-utils';
+import type { PowerPublicationManifest } from '../etl/power-publication';
+import {
+  checkpointBenchmarkRefresh,
+  refreshBackfillBenchmarks,
+} from './backfill-benchmark-refresh';
+
+let db: PGlite;
+let sql: Sql;
+let manifest: PowerPublicationManifest;
+let root: string;
+let origin: string;
+let failure: 'invalidate' | 'stale' | undefined;
+let apiIds: unknown[] | undefined;
+const audit = {
+  source: 'power_validation.json',
+  sample_count: 1,
+  window_start_unix: 1788220800,
+  window_end_unix: 1788220801,
+};
+const identity = {
+  hardware: 'b200',
+  framework: 'sglang',
+  model: 'dsr1',
+  precision: 'fp4',
+  spec_method: 'none',
+  disagg: false,
+  is_multinode: false,
+  prefill_tp: 8,
+  prefill_ep: 1,
+  prefill_dp_attention: false,
+  prefill_num_workers: 0,
+  decode_tp: 8,
+  decode_ep: 1,
+  decode_dp_attention: false,
+  decode_num_workers: 0,
+  num_prefill_gpu: 8,
+  num_decode_gpu: 8,
+  benchmark_type: 'single_turn',
+  isl: 8192,
+  osl: 1024,
+  conc: 32,
+  offload_mode: 'off',
+};
+const auditUpdates = [{ benchmarkResultId: 10, identity, powerAudit: audit }];
+const requests: { method: string; url: string; auth?: string; audit?: unknown }[] = [];
+const save = () => fs.writeFileSync(path.join(root, 'receipt.json'), JSON.stringify(manifest));
+const read = (): PowerPublicationManifest =>
+  JSON.parse(fs.readFileSync(path.join(root, 'receipt.json'), 'utf8'));
+const samples = async () => {
+  const result = await db.query('SELECT ctid::text, * FROM gpu_metric_samples');
+  return result.rows;
+};
+
+// Real HTTP transport around local SQL; this is not a deployed API/Blob acceptance test.
+const server = createServer(async (request, response) => {
+  try {
+    const entry: (typeof requests)[number] = {
+      method: request.method!,
+      url: request.url!,
+      auth: request.headers.authorization,
+    };
+    requests.push(entry);
+    let body: unknown;
+    if (entry.method === 'POST' && entry.url === '/api/v1/invalidate') {
+      const result = await db.query<{ power_audit: unknown }>(
+        'SELECT power_audit FROM latest_benchmarks WHERE id = 10',
+      );
+      entry.audit = result.rows[0]?.power_audit;
+      if (failure === 'invalidate') {
+        response.writeHead(503).end();
+        return;
+      }
+      body = { invalidated: true, blobsDeleted: 1 };
+    } else if (entry.url.startsWith('/api/v1/benchmarks?')) {
+      const result = await db.query<{ id: number; power_audit: unknown }>(
+        'SELECT id, power_audit FROM benchmark_results WHERE id = 10',
+      );
+      body = failure === 'stale' ? [{ id: 10, power_audit: null }] : result.rows;
+      if (apiIds) body = apiIds.map((id) => ({ ...result.rows[0], id }));
+    } else {
+      response.writeHead(404).end();
+      return;
+    }
+    response.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify(body));
+  } catch (error) {
+    response.writeHead(500).end(String(error));
+  }
+});
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  const migrations = new URL('../../migrations/', import.meta.url);
+  for (const name of fs.readdirSync(migrations).toSorted())
+    if (name.endsWith('.sql')) await db.exec(fs.readFileSync(new URL(name, migrations), 'utf8'));
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await db.query(query, values);
+    return result.rows;
+  };
+  sql = Object.assign(client, { array: (value: unknown) => value }) as unknown as Sql;
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  const address = server.address();
+  if (!address || typeof address === 'string') throw new Error('Expected loopback TCP address');
+  origin = `http://127.0.0.1:${address.port}`;
+}, 30_000);
+
+beforeEach(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'benchmark-refresh-'));
+  requests.length = 0;
+  failure = undefined;
+  apiIds = undefined;
+  manifest = { version: 1, runId: 123, runAttempt: 2, points: [] };
+  vi.stubEnv('CACHE_INVALIDATE_URL', `${origin}/api/v1/invalidate`);
+  vi.stubEnv('CACHE_INVALIDATE_SECRET', 'local-secret');
+  vi.stubEnv('CACHE_PROTECTION_BYPASS_SECRET', undefined);
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+      VALUES (1, 123, 2, 'Run Sweep', 'completed', 'success', '2026-09-01', '2026-09-01');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+      VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 8, 8, 8, 8);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+      VALUES (10, 1, 1, 'single_turn', '2026-09-01', 8192, 1024, 32, '{}');
+    INSERT INTO gpu_metric_series (id, workflow_run_id, artifact_name, config_key, file_name,
+      vendor, csv_sha256, sample_count, gpu_count, started_at, ended_at)
+      VALUES (1, 1, 'gpu_metrics_fixture', 'fixture', 'gpu_metrics.csv', 'nvidia', 'fixture', 1, 1, '2026-09-01', '2026-09-01');
+    INSERT INTO gpu_metric_samples (series_id, gpu_index, sampled_at, power_w) VALUES (1, 0, '2026-09-01', 351.4);
+    REFRESH MATERIALIZED VIEW latest_benchmarks;`);
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  fs.rmSync(root, { recursive: true, force: true });
+});
+afterAll(async () => {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => (error ? reject(error) : resolve()));
+  });
+  await db?.close();
+});
+
+async function updateAudit() {
+  await db.query('UPDATE benchmark_results SET power_audit = $1 WHERE id = 10', [audit]);
+}
+
+it('resumes the pre-write disk checkpoint and refreshes the materialized view before POST', async () => {
+  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
+  expect(read().benchmarkRefresh).toMatchObject({
+    status: 'pending',
+    benchmarkResultIds: [10],
+    auditUpdates,
+  });
+  await updateAudit();
+  const before = await db.query('SELECT power_audit FROM latest_benchmarks WHERE id = 10');
+  expect(before.rows).toEqual([{ power_audit: null }]);
+  manifest = read(); // Simulate losing all in-process state after the committed UPDATE.
+  await refreshBackfillBenchmarks(sql, manifest, save);
+  expect(requests).toHaveLength(2);
+  expect(requests[0]).toMatchObject({ method: 'POST', auth: 'Bearer local-secret', audit });
+  expect(new URL(requests[1].url, origin).searchParams.get('runId')).toBe('123');
+  expect(new URL(requests[1].url, origin).searchParams.get('exactRun')).toBe('true');
+  expect(read().benchmarkRefresh?.status).toBe('complete');
+});
+
+it.each(['invalidate', 'stale'] as const)(
+  'retains %s failure and retries without rewriting samples',
+  async (mode) => {
+    checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
+    await updateAudit();
+    const before = await samples();
+    failure = mode;
+    await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(
+      mode === 'invalidate' ? 'invalidate cache: HTTP 503' : 'power_audit differs',
+    );
+    expect(read().benchmarkRefresh).toMatchObject({ status: 'failed', benchmarkResultIds: [10] });
+    manifest = read();
+    failure = undefined;
+    await refreshBackfillBenchmarks(sql, manifest, save);
+    expect(read().benchmarkRefresh).toMatchObject({ status: 'complete', benchmarkResultIds: [10] });
+    expect(read().benchmarkRefresh).not.toHaveProperty('error');
+    expect(await samples()).toEqual(before);
+  },
+);
+
+it('verifies string benchmark IDs returned by native PostgreSQL without rewriting samples', async () => {
+  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
+  await updateAudit();
+  const before = await samples();
+  apiIds = ['10'];
+  manifest = read();
+  await refreshBackfillBenchmarks(sql, manifest, save);
+  expect(read().benchmarkRefresh).toMatchObject({ status: 'complete', benchmarkResultIds: [10] });
+  expect(requests).toHaveLength(2);
+  expect(await samples()).toEqual(before);
+});
+
+it('rejects duplicate benchmark API IDs after numeric normalization', async () => {
+  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
+  await updateAudit();
+  for (const ids of [
+    [10, '10'],
+    ['10', '10'],
+  ]) {
+    apiIds = ids;
+    await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(
+      'power_audit differs',
+    );
+    expect(read().benchmarkRefresh).toMatchObject({ status: 'failed', benchmarkResultIds: [10] });
+  }
+});
+
+it('rejects malformed benchmark API IDs instead of coercing them into matches', async () => {
+  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
+  await updateAudit();
+  for (const id of [['10'], {}, null, true, ' 10 ', '010', '10.0', '1e1', '0xa', '10oops']) {
+    apiIds = [id];
+    await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(
+      'power_audit differs',
+    );
+    expect(read().benchmarkRefresh).toMatchObject({ status: 'failed', benchmarkResultIds: [10] });
+  }
+});
+
+it('rejects a receipt for a different host before POST', async () => {
+  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
+  manifest.benchmarkRefresh!.endpoint = `${origin.replace('127.0.0.1', '127.0.0.2')}/api/v1/invalidate`;
+  await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow('target differs');
+  expect(read().benchmarkRefresh?.status).toBe('failed');
+  expect(requests).toEqual([]);
+});
+
+it('rejects a stringified audit even though the API fixture would return the same DB value', async () => {
+  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
+  await db.query('UPDATE benchmark_results SET power_audit = $1::jsonb WHERE id = 10', [
+    JSON.stringify(JSON.stringify(audit)),
+  ]);
+  const stored = await db.query('SELECT power_audit FROM benchmark_results WHERE id = 10');
+  expect(stored.rows).toEqual([{ power_audit: JSON.stringify(audit) }]);
+  await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(
+    'power_audit must be an object with a nonempty source',
+  );
+  expect(read().benchmarkRefresh?.status).toBe('failed');
+  expect(requests).toEqual([]);
+});
+
+it('rejects wrong run, attempt, foreign IDs and malformed IDs before POST', async () => {
+  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
+  const original = read();
+  for (const change of [
+    { runId: 999 },
+    { runAttempt: 1 },
+    ...[[11], [10, 10], [-1], [1.5]].map((ids) => ({
+      benchmarkRefresh: { ...original.benchmarkRefresh!, benchmarkResultIds: ids },
+    })),
+  ]) {
+    manifest = { ...structuredClone(original), ...change };
+    await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(
+      /run\/attempt|Invalid benchmarkResultIds/,
+    );
+    expect(read().benchmarkRefresh?.status).toBe('failed');
+  }
+  expect(requests).toEqual([]);
+});
+
+it('retains a NULL pre-write checkpoint and requires artifact re-ingest without purging', async () => {
+  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
+  manifest = read();
+  await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(/NULL.*re-ingest/);
+  expect(read().benchmarkRefresh).toMatchObject({
+    status: 'failed',
+    benchmarkResultIds: [10],
+    auditUpdates,
+  });
+  expect(requests).toEqual([]);
+});
+
+it('retains confirmed refresh responsibility when a later upsert clears the audit to NULL', async () => {
+  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
+  await updateAudit();
+  failure = 'invalidate';
+  await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow('HTTP 503');
+  const pending = read().benchmarkRefresh!;
+  const before = await samples();
+  await db.exec('UPDATE benchmark_results SET power_audit = NULL WHERE id = 10');
+  manifest = read();
+  failure = undefined;
+  await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(/NULL.*re-ingest/);
+  expect(read().benchmarkRefresh).toMatchObject({
+    status: 'failed',
+    benchmarkResultIds: pending.benchmarkResultIds,
+    auditUpdates: pending.auditUpdates,
+  });
+  expect(requests).toHaveLength(1);
+  expect(await samples()).toEqual(before);
+});
diff --git a/packages/db/src/lib/backfill-benchmark-refresh.ts b/packages/db/src/lib/backfill-benchmark-refresh.ts
new file mode 100644
index 000000000..15d2d60f6
--- /dev/null
+++ b/packages/db/src/lib/backfill-benchmark-refresh.ts
@@ -0,0 +1,224 @@
+import { isDeepStrictEqual } from 'node:util';
+import { DB_MODEL_TO_DISPLAY } from '@semianalysisai/inferencex-constants';
+import { refreshLatestBenchmarks, type Sql } from '../etl/db-utils.js';
+import {
+  stablePowerPointIdentity,
+  type PowerPublicationManifest,
+} from '../etl/power-publication.js';
+
+export type BenchmarkAuditUpdate = NonNullable<
+  NonNullable<PowerPublicationManifest['benchmarkRefresh']>['auditUpdates']
+>[number];
+
+function refreshTarget(manifest: PowerPublicationManifest) {
+  const raw = process.env.CACHE_INVALIDATE_URL;
+  if (!raw) throw new Error('CACHE_INVALIDATE_URL is required for benchmark metadata refresh');
+  const endpoint = new URL(raw);
+  if (
+    !['http:', 'https:'].includes(endpoint.protocol) ||
+    endpoint.pathname !== '/api/v1/invalidate' ||
+    endpoint.search ||
+    endpoint.hash ||
+    endpoint.username ||
+    endpoint.password
+  )
+    throw new Error(
+      'CACHE_INVALIDATE_URL must name /api/v1/invalidate without credentials or query',
+    );
+  const previous = manifest.benchmarkRefresh?.endpoint;
+  if (previous && previous !== endpoint.href)
+    throw new Error('Benchmark refresh receipt target differs from CACHE_INVALIDATE_URL');
+  const secret = process.env.CACHE_INVALIDATE_SECRET || process.env.INVALIDATE_SECRET;
+  if (!secret) throw new Error('CACHE_INVALIDATE_SECRET or INVALIDATE_SECRET is required');
+  return {
+    endpoint,
+    headers: {
+      Authorization: `Bearer ${secret}`,
+      ...(process.env.CACHE_PROTECTION_BYPASS_SECRET
+        ? { 'x-vercel-protection-bypass': process.env.CACHE_PROTECTION_BYPASS_SECRET }
+        : {}),
+    },
+  };
+}
+
+/** Persist possible writes before ingest, including a crash before UPDATE returns its IDs. */
+export function checkpointBenchmarkRefresh(
+  manifest: PowerPublicationManifest,
+  ids: number[],
+  save: () => void,
+  auditUpdates: BenchmarkAuditUpdate[] = [],
+): void {
+  if (ids.length === 0) return;
+  const previous = manifest.benchmarkRefresh;
+  manifest.benchmarkRefresh = {
+    status: 'pending',
+    benchmarkResultIds: [
+      ...new Set([
+        ...(previous?.status === 'complete' ? [] : (previous?.benchmarkResultIds ?? [])),
+        ...ids,
+      ]),
+    ],
+    auditUpdates: [...(previous?.auditUpdates ?? [])],
+    ...(previous?.endpoint ? { endpoint: previous.endpoint } : {}),
+  };
+  for (const update of auditUpdates) {
+    const existing = manifest.benchmarkRefresh.auditUpdates!.find(
+      (value) => value.benchmarkResultId === update.benchmarkResultId,
+    );
+    if (
+      existing &&
+      (!isDeepStrictEqual(existing.powerAudit, update.powerAudit) ||
+        stablePowerPointIdentity(existing.identity) !== stablePowerPointIdentity(update.identity))
+    )
+      throw new Error('Conflicting retained audit evidence for benchmark refresh');
+    if (!existing) manifest.benchmarkRefresh.auditUpdates!.push(update);
+  }
+  save();
+  try {
+    manifest.benchmarkRefresh.endpoint = refreshTarget(manifest).endpoint.href;
+  } catch (error) {
+    manifest.benchmarkRefresh.status = 'failed';
+    manifest.benchmarkRefresh.error = error instanceof Error ? error.message : String(error);
+    throw error;
+  } finally {
+    save();
+  }
+}
+
+/** Retry only the materialized view/cache/API phase; never download or rewrite samples. */
+export async function refreshBackfillBenchmarks(
+  sql: Sql,
+  manifest: PowerPublicationManifest,
+  save: () => void,
+): Promise<void> {
+  const receipt = manifest.benchmarkRefresh;
+  if (!receipt) throw new Error('Receipt has no benchmark metadata refresh responsibility');
+  receipt.status = 'pending';
+  receipt.checkedAt = new Date().toISOString();
+  delete receipt.error;
+  save();
+  let phase = 'validate target';
+  try {
+    const { endpoint, headers } = refreshTarget(manifest);
+    receipt.endpoint = endpoint.href;
+    save();
+    const ids = receipt.benchmarkResultIds;
+    if (
+      !Array.isArray(ids) ||
+      ids.some((id) => !Number.isSafeInteger(id) || id <= 0) ||
+      new Set(ids).size !== ids.length
+    )
+      throw new Error('Invalid benchmarkResultIds in refresh receipt');
+    const rows = await sql<
+      (Record<string, unknown> & { id: number; model: string; power_audit: unknown })[]
+    >`
+      select c.*, br.id, br.benchmark_type, br.isl, br.osl, br.conc, br.offload_mode,
+        br.recipe_fingerprint, br.power_audit from benchmark_results br
+      join configs c on c.id = br.config_id
+      join workflow_runs wr on wr.id = br.workflow_run_id
+      where wr.github_run_id = ${manifest.runId} and wr.run_attempt = ${manifest.runAttempt}
+        and br.id = any(${sql.array(ids)}::bigint[])
+    `;
+    if (rows.length !== ids.length)
+      throw new Error('Refresh receipt IDs do not belong to its run/attempt');
+    const changed = rows;
+    for (const row of changed) {
+      const audit = row.power_audit;
+      if (audit === null)
+        throw new Error(
+          `Benchmark ${row.id} power_audit is NULL; targeted artifact re-ingest is required before cache refresh`,
+        );
+      if (
+        !audit ||
+        typeof audit !== 'object' ||
+        Array.isArray(audit) ||
+        !('source' in audit) ||
+        typeof audit.source !== 'string' ||
+        !audit.source.trim()
+      )
+        throw new Error(`Benchmark ${row.id} power_audit must be an object with a nonempty source`);
+      const updates =
+        receipt.auditUpdates?.filter((update) => update.benchmarkResultId === Number(row.id)) ?? [];
+      if (updates.length !== 1 || !isDeepStrictEqual(updates[0]!.powerAudit, audit))
+        throw new Error(`Benchmark ${row.id} power_audit differs from retained source evidence`);
+      const update = updates[0]!;
+      if (stablePowerPointIdentity(update.identity) !== stablePowerPointIdentity(row))
+        throw new Error(`Benchmark ${row.id} identity differs from retained source mapping`);
+      const identities = new Set(
+        [update.identity, update.sourceIdentity ?? update.identity].map(stablePowerPointIdentity),
+      );
+      const points = manifest.points.filter((point) =>
+        identities.has(stablePowerPointIdentity(point.identity)),
+      );
+      if (points.length > 1)
+        throw new Error(`Ambiguous publication identity for benchmark ${row.id}`);
+      if (
+        points.length === 1 &&
+        (points[0]!.power_audit === null || points[0]!.power_audit === undefined)
+      )
+        points[0]!.power_audit = update.powerAudit;
+    }
+    save();
+    if (changed.length > 0) {
+      phase = 'refresh latest_benchmarks';
+      await refreshLatestBenchmarks(sql);
+      phase = 'invalidate cache';
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers,
+        redirect: 'error',
+        signal: AbortSignal.timeout(30_000),
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const result = await response.json();
+      if (
+        result?.invalidated !== true ||
+        !Number.isSafeInteger(result.blobsDeleted) ||
+        result.blobsDeleted < 0
+      )
+        throw new Error('Invalid cache invalidation response');
+      phase = 'verify benchmark API';
+      for (const model of new Set(changed.map((row) => row.model))) {
+        const displayModel = DB_MODEL_TO_DISPLAY[model];
+        if (!displayModel) throw new Error(`Unmapped public model: ${model}`);
+        const url = new URL('/api/v1/benchmarks', endpoint);
+        url.search = new URLSearchParams({
+          model: displayModel,
+          runId: String(manifest.runId),
+          exactRun: 'true',
+        }).toString();
+        const api = await fetch(url, {
+          headers: process.env.CACHE_PROTECTION_BYPASS_SECRET
+            ? { 'x-vercel-protection-bypass': process.env.CACHE_PROTECTION_BYPASS_SECRET }
+            : undefined,
+          redirect: 'error',
+          signal: AbortSignal.timeout(30_000),
+        });
+        if (!api.ok) throw new Error(`HTTP ${api.status}`);
+        const body: unknown = await api.json();
+        if (!Array.isArray(body)) throw new Error('Invalid benchmark API response');
+        for (const row of changed.filter((entry) => entry.model === model)) {
+          const matches = body.filter((candidate) => {
+            const raw = candidate?.id;
+            const id =
+              typeof raw === 'number'
+                ? raw
+                : typeof raw === 'string' && /^[1-9]\d*$/u.test(raw)
+                  ? Number(raw)
+                  : NaN;
+            return Number.isSafeInteger(id) && id > 0 && id === Number(row.id);
+          });
+          if (matches.length !== 1 || !isDeepStrictEqual(matches[0].power_audit, row.power_audit))
+            throw new Error(`Benchmark ${row.id} power_audit differs from database`);
+        }
+      }
+    }
+    receipt.status = 'complete';
+  } catch (error) {
+    receipt.status = 'failed';
+    receipt.error = `${phase}: ${error instanceof Error ? error.message : String(error)}`;
+    throw new Error(receipt.error, { cause: error });
+  } finally {
+    save();
+  }
+}
diff --git a/packages/db/src/queries/gpu-metrics-timeline.test.ts b/packages/db/src/queries/gpu-metrics-timeline.test.ts
index e0db7b355..4f6bc2a81 100644
--- a/packages/db/src/queries/gpu-metrics-timeline.test.ts
+++ b/packages/db/src/queries/gpu-metrics-timeline.test.ts
@@ -84,6 +84,36 @@ function bundle(validation: Record<string, unknown> = VALIDATION) {
   ]);
 }
 
+function agentxBundle() {
+  const files = bundle();
+  files.delete(SOURCE);
+  const resultPath = 'agentic/conc_32/agentic_power_concurrency_32.json';
+  files.set(`${NAME.slice('power_audit_'.length)}_conc32.json`, JSON.stringify({ conc: 32 }));
+  files.set(
+    'LOGS/agentic/conc_32/power_validation.json',
+    JSON.stringify({
+      ...VALIDATION,
+      power_valid: false,
+      selected_window: {
+        ...VALIDATION.selected_window,
+        concurrency: 32,
+        result_path: resultPath,
+        window_file: 'windows/agentic_power_concurrency_32.json',
+      },
+    }),
+  );
+  files.set(
+    'LOGS/power/windows/agentic_power_concurrency_32.json',
+    JSON.stringify({
+      concurrency: 32,
+      result_path: resultPath,
+      benchmark_start_time_unix: START,
+      benchmark_end_time_unix: START + 1,
+    }),
+  );
+  return files;
+}
+
 beforeAll(async () => {
   root = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-timeline-'));
   db = await PGlite.create();
@@ -117,6 +147,85 @@ beforeEach(async () => {
 });
 
 describe('artifact → ingest → stored Timeline', () => {
+  it('restores nested AgentX provenance on ingest and sample no-op without changing metrics or validity', async () => {
+    await db.exec(`UPDATE benchmark_results SET benchmark_type = 'agentic_traces',
+      metrics = '{"power_valid":0,"throughput":17}' WHERE id = 10`);
+    const files = agentxBundle();
+    const input = {
+      workflowRunId: 1,
+      artifact: writeArtifact(NAME, files),
+      benchmarkResultIds: [10, 11],
+    };
+    const initial = await ingestGpuMetricsArtifact(sql, input);
+    expect(initial.metadataUpdatedBenchmarkResultIds).toEqual([10]);
+    const expected = {
+      source: SOURCE,
+      window_start_unix: START,
+      window_end_unix: START + 1,
+    };
+    const row = () => db.query('SELECT power_audit, metrics FROM benchmark_results WHERE id = 10');
+    const initialRow = await row();
+    expect(initialRow.rows[0]).toEqual({
+      power_audit: expected,
+      metrics: { power_valid: 0, throughput: 17 },
+    });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    expect(storedPowerSeries(stored!.series)).toEqual(cutPowerAuditBundle(NAME, files));
+    expect(storedPowerSeries(stored!.series)).toHaveLength(1);
+    expect(stored!.series[0].sidecars).toMatchObject({
+      validations: {
+        [SOURCE]: {
+          validation_path: 'LOGS/agentic/conc_32/power_validation.json',
+          validation_sha256: expect.stringMatching(/^[a-f0-9]{64}$/u),
+          power_valid: false,
+        },
+      },
+    });
+    await db.exec('UPDATE benchmark_results SET power_audit = NULL WHERE id = 10');
+    expect(await ingestGpuMetricsArtifact(sql, input)).toMatchObject({
+      samplesInserted: 0,
+      seriesSkipped: 2,
+      metadataUpdatedBenchmarkResultIds: [10],
+    });
+    const unchanged = await ingestGpuMetricsArtifact(sql, input);
+    expect(unchanged.metadataUpdatedBenchmarkResultIds).toEqual([]);
+    const repaired = await row();
+    expect(repaired.rows[0]).toEqual({
+      power_audit: expected,
+      metrics: { power_valid: 0, throughput: 17 },
+    });
+    const unrelated = await db.query('SELECT power_audit FROM benchmark_results WHERE id = 11');
+    expect(unrelated.rows).toEqual([{ power_audit: null }]);
+  });
+
+  it.each(['explicit', 'wrong-run', 'wrong-id', 'wrong-conc', 'ambiguous'])(
+    'does not infer or overwrite point provenance for %s identity',
+    async (scenario) => {
+      await db.exec("UPDATE benchmark_results SET benchmark_type = 'agentic_traces'");
+      if (scenario === 'explicit')
+        await db.exec(
+          `UPDATE benchmark_results SET power_audit = '{"source":"existing.json"}' WHERE id = 10`,
+        );
+      if (scenario === 'wrong-run') {
+        await db.exec(`INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, created_at, date)
+          VALUES (2, 1, 1, 'Other run', 'completed', '2026-09-12', '2026-09-12');
+          UPDATE benchmark_results SET workflow_run_id = 2 WHERE id = 10`);
+      }
+      if (scenario === 'wrong-conc')
+        await db.exec('UPDATE benchmark_results SET conc = 31 WHERE id = 10');
+      if (scenario === 'ambiguous')
+        await db.exec('UPDATE benchmark_results SET conc = 32, isl = 1 WHERE id = 11');
+      const before = await db.query('SELECT id, power_audit FROM benchmark_results ORDER BY id');
+      await ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact: writeArtifact(NAME, agentxBundle()),
+        benchmarkResultIds: scenario === 'wrong-id' ? [11] : [10, 11],
+      });
+      const after = await db.query('SELECT id, power_audit FROM benchmark_results ORDER BY id');
+      expect(after.rows).toEqual(before.rows);
+    },
+  );
+
   it('matches artifact windows, host/GPU identity, deduplicated mean watts and gaps for a multinode bundle', async () => {
     const files = bundle();
     const artifact = writeArtifact(NAME, files);

From a903159c2cbc03c0fca70f4f7437f4b0d3e20fb4 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 22 Sep 2026 22:28:21 -0700
Subject: [PATCH 030/103] refactor: remove unused GPU anomaly detection
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove the unused anomaly detector and its dedicated tests. Preserve timestamp normalization, full-record statistics and their existing assertions; refresh the reviewed source digest without changing the API contract.

中文：删除未使用的 GPU 异常检测及其专属测试；保留时间戳处理、全记录统计字段和统计断言。同步源码校验摘要，不改变 API 契约。
---
 .../src/components/gpu-power/types.test.ts    | 175 ------------------
 .../app/src/components/gpu-power/types.ts     | 150 ---------------
 packages/app/src/lib/api-route-catalog.ts     |   2 +-
 3 files changed, 1 insertion(+), 326 deletions(-)

diff --git a/packages/app/src/components/gpu-power/types.test.ts b/packages/app/src/components/gpu-power/types.test.ts
index 74c3e598b..d4847cc8c 100644
--- a/packages/app/src/components/gpu-power/types.test.ts
+++ b/packages/app/src/components/gpu-power/types.test.ts
@@ -3,7 +3,6 @@ import { describe, expect, it } from 'vitest';
 import {
   ALL_METRIC_OPTIONS,
   computeGpuStats,
-  detectAnomalies,
   detectTdpFromArtifactName,
   getAvailableMetrics,
   tdpForHardware,
@@ -505,164 +504,6 @@ function makeRow(
   };
 }
 
-// ---------------------------------------------------------------------------
-// detectAnomalies
-// ---------------------------------------------------------------------------
-
-describe('detectAnomalies', () => {
-  it('returns empty array for empty data', () => {
-    expect(detectAnomalies([], 'power')).toEqual([]);
-  });
-
-  it('detects statistical outliers via MAD', () => {
-    const rows: GpuMetricRow[] = [];
-    for (let i = 0; i < 10; i++) {
-      rows.push(
-        makeRow({
-          timestamp: `2026/03/07 00:20:${37 + i}.000`,
-          index: 0,
-          power: i === 9 ? 600 : 300 + (i % 3),
-        }),
-      );
-    }
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'statistical')).toBe(true);
-    const stat = anomalies.find((a) => a.type === 'statistical')!;
-    expect(stat.gpuIndex).toBe(0);
-    expect(stat.value).toBe(600);
-  });
-
-  it('detects thermal throttle above 83°C', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, temperature: 70 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'thermal')).toBe(true);
-    const thermal = anomalies.find((a) => a.type === 'thermal')!;
-    expect(thermal.value).toBe(85);
-  });
-
-  it('detects near-TDP power draw', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 300 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 650 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, power: 300 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power', 'gpu_metrics_h200_test');
-    expect(anomalies.some((a) => a.type === 'near_tdp')).toBe(true);
-  });
-
-  it('does not flag near-TDP without artifact name', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 650 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 650 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, power: 650 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'near_tdp')).toBe(false);
-  });
-
-  it('detects utilization drop to 0% after high usage', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, gpuUtil: 95 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, gpuUtil: 0 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, gpuUtil: 90 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'util_drop')).toBe(true);
-  });
-
-  it('does not flag all-identical values as anomalies', () => {
-    const rows: GpuMetricRow[] = [];
-    for (let i = 0; i < 10; i++) {
-      rows.push(makeRow({ timestamp: `2026/03/07 00:20:${37 + i}.000`, index: 0, power: 300 }));
-    }
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.filter((a) => a.type === 'statistical')).toHaveLength(0);
-  });
-
-  it('deduplicates anomalies at same second', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:37.500', index: 0, temperature: 86 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, temperature: 65 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    const thermals = anomalies.filter(
-      (a) => a.type === 'thermal' && a.gpuIndex === 0 && Math.round(a.seconds) === 0,
-    );
-    expect(thermals).toHaveLength(1);
-  });
-
-  it('detects clock drop when SM clock drops >30% below median', () => {
-    const rows: GpuMetricRow[] = [];
-    // 9 rows at 1980 MHz, 1 row at 1000 MHz (49% drop)
-    for (let i = 0; i < 10; i++) {
-      rows.push(
-        makeRow({
-          timestamp: `2026/03/07 00:20:${37 + i}.000`,
-          index: 0,
-          smClock: i === 5 ? 1000 : 1980,
-        }),
-      );
-    }
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'clock_drop')).toBe(true);
-    const drop = anomalies.find((a) => a.type === 'clock_drop')!;
-    expect(drop.value).toBe(1000);
-  });
-
-  it('detects anomalies independently per GPU', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 1, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 1, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 1, temperature: 65 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'temperature');
-    const thermals = anomalies.filter((a) => a.type === 'thermal');
-    expect(thermals).toHaveLength(2);
-    expect(thermals.map((a) => a.gpuIndex).toSorted()).toEqual([0, 1]);
-  });
-
-  it('skips GPU groups with fewer than 3 samples for MAD detection', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 100 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 900 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    // Only 2 samples — MAD-based statistical detection should be skipped
-    expect(anomalies.filter((a) => a.type === 'statistical')).toHaveLength(0);
-  });
-
-  it('anomaly message includes GPU index and metric value', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 2, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 2, temperature: 90 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 2, temperature: 65 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'temperature');
-    const thermal = anomalies.find((a) => a.type === 'thermal')!;
-    expect(thermal.message).toContain('Chip 2');
-    expect(thermal.message).toContain('90');
-    expect(thermal.message).toContain('83');
-  });
-
-  it('does not flag util_drop when previous utilization is <= 50%', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, gpuUtil: 40 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, gpuUtil: 0 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, gpuUtil: 50 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'util_drop')).toBe(false);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // computeGpuStats
 // ---------------------------------------------------------------------------
@@ -795,20 +636,4 @@ describe('power-only rows', () => {
       'power',
     ]);
   });
-
-  it('raises no thermal, clock, or utilization anomalies from absent readings', () => {
-    const rows = Array.from({ length: 40 }, (_, i) => ({
-      ...powerOnly(0, 700 + (i % 2)),
-      timestamp: new Date(1789194365292 + i * 1000).toISOString(),
-    }));
-    expect(
-      detectAnomalies(rows, 'power', 'power_audit_kimik3_conc48').map((a) => a.type),
-    ).not.toContain('thermal');
-    expect(
-      detectAnomalies(rows, 'power', 'power_audit_kimik3_conc48').map((a) => a.type),
-    ).not.toContain('clock_drop');
-    expect(
-      detectAnomalies(rows, 'power', 'power_audit_kimik3_conc48').map((a) => a.type),
-    ).not.toContain('util_drop');
-  });
 });
diff --git a/packages/app/src/components/gpu-power/types.ts b/packages/app/src/components/gpu-power/types.ts
index 1a9ffdd11..7c95b7ce3 100644
--- a/packages/app/src/components/gpu-power/types.ts
+++ b/packages/app/src/components/gpu-power/types.ts
@@ -240,21 +240,6 @@ export function detectTdpFromArtifactName(
   return null;
 }
 
-export interface Anomaly {
-  type: 'statistical' | 'thermal' | 'near_tdp' | 'clock_drop' | 'util_drop';
-  label: string;
-  gpuIndex: number;
-  seconds: number;
-  value: number;
-  message: string;
-}
-
-function median(values: number[]): number {
-  const sorted = [...values].toSorted((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-}
-
 function parseTimestampToMs(raw: string): number | null {
   const d = new Date(raw);
   if (!isNaN(d.getTime())) return d.getTime();
@@ -263,141 +248,6 @@ function parseTimestampToMs(raw: string): number | null {
   return null;
 }
 
-/**
- * Detect anomalies in GPU metrics data using MAD-based Modified Z-score
- * (per NIST/Iglewicz & Hoaglin, threshold 3.5) plus domain-specific GPU thresholds.
- */
-export function detectAnomalies(
-  data: GpuMetricRow[],
-  metricKey: GpuMetricKey,
-  artifactName?: string,
-): Anomaly[] {
-  if (data.length === 0) return [];
-
-  const anomalies: Anomaly[] = [];
-  const tdpInfo = artifactName ? detectTdpFromArtifactName(artifactName) : null;
-
-  // Find earliest timestamp for seconds calculation
-  let minTime = Infinity;
-  for (const row of data) {
-    const ms = parseTimestampToMs(row.timestamp);
-    if (ms !== null && ms < minTime) minTime = ms;
-  }
-
-  // Group by GPU index
-  const gpuGroups = new Map<number, GpuMetricRow[]>();
-  for (const row of data) {
-    if (!gpuGroups.has(row.index)) gpuGroups.set(row.index, []);
-    gpuGroups.get(row.index)!.push(row);
-  }
-
-  for (const [gpuIndex, rows] of gpuGroups) {
-    const rawValues = rows.map((r) => r[metricKey]);
-    // Skip if any values are undefined (metric not available for this vendor)
-    if (rawValues.some((v) => v === undefined)) continue;
-    const values = rawValues as number[];
-    if (values.length < 3) continue;
-
-    // MAD-based Modified Z-score detection
-    const med = median(values);
-    const absDeviations = values.map((v) => Math.abs(v - med));
-    const mad = median(absDeviations);
-
-    // Pre-compute SM clock median for clock_drop detection (avoid O(n^2))
-    const smClocks = rows.map((r) => r.smClock).filter((v): v is number => v !== undefined);
-    const smMedian =
-      (metricKey === 'smClock' || metricKey === 'power') && smClocks.length > 0
-        ? median(smClocks)
-        : 0;
-
-    for (let i = 0; i < rows.length; i++) {
-      const row = rows[i];
-      const ms = parseTimestampToMs(row.timestamp);
-      const seconds = ms === null ? i : (ms - minTime) / 1000;
-
-      // Statistical outlier (MAD)
-      if (mad > 0) {
-        const modifiedZ = (0.6745 * (values[i] - med)) / mad;
-        if (Math.abs(modifiedZ) > 3.5) {
-          anomalies.push({
-            type: 'statistical',
-            label: 'Statistical Outlier',
-            gpuIndex,
-            seconds,
-            value: values[i],
-            message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: ${metricKey} = ${values[i].toFixed(1)} (Modified Z = ${modifiedZ.toFixed(1)}, median = ${med.toFixed(1)})`,
-          });
-        }
-      }
-
-      // Domain-specific: thermal throttle (temperature > 83°C)
-      if (row.temperature !== undefined && row.temperature > 83) {
-        anomalies.push({
-          type: 'thermal',
-          label: 'Thermal Throttle',
-          gpuIndex,
-          seconds,
-          value: row.temperature,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: temperature ${row.temperature}°C exceeds throttle threshold (83°C)`,
-        });
-      }
-
-      // Domain-specific: near TDP (power > 90% of TDP)
-      if (tdpInfo && row.power > tdpInfo.tdp * 0.9) {
-        anomalies.push({
-          type: 'near_tdp',
-          label: 'Near TDP',
-          gpuIndex,
-          seconds,
-          value: row.power,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: power ${row.power.toFixed(1)}W is ${((row.power / tdpInfo.tdp) * 100).toFixed(0)}% of TDP (${tdpInfo.tdp}W)`,
-        });
-      }
-
-      // Domain-specific: clock drop (SM clock > 30% below median)
-      if (
-        (metricKey === 'smClock' || metricKey === 'power') &&
-        smMedian > 0 &&
-        row.smClock !== undefined &&
-        row.smClock < smMedian * 0.7
-      ) {
-        anomalies.push({
-          type: 'clock_drop',
-          label: 'Clock Drop',
-          gpuIndex,
-          seconds,
-          value: row.smClock,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: SM clock ${row.smClock} MHz dropped ${((1 - row.smClock / smMedian) * 100).toFixed(0)}% below median (${smMedian.toFixed(0)} MHz)`,
-        });
-      }
-
-      // Domain-specific: utilization drop (GPU util = 0 after being > 50%)
-      const previousUtil = i > 0 ? rows[i - 1].gpuUtil : undefined;
-      if (row.gpuUtil === 0 && previousUtil !== undefined && previousUtil > 50) {
-        anomalies.push({
-          type: 'util_drop',
-          label: 'Utilization Drop',
-          gpuIndex,
-          seconds,
-          value: 0,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: utilization dropped to 0% (was ${previousUtil}%)`,
-        });
-      }
-    }
-  }
-
-  // Deduplicate: keep only one anomaly per (type, gpuIndex, second)
-  const seen = new Set<string>();
-  const deduped = anomalies.filter((a) => {
-    const key = `${a.type}_${a.gpuIndex}_${Math.round(a.seconds)}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-
-  return deduped.toSorted((a, b) => a.seconds - b.seconds);
-}
-
 /**
  * Split a CSV line respecting double-quoted fields (which may contain commas).
  * Required for AMD amd-smi CSV where array fields like "['N/A', 'N/A']" are quoted.
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 91933c97e..6323c04c2 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -830,7 +830,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/gpu-power/types.ts',
-    sourceSha256: 'cc75290d20b1f7b3a31c49634ae592f60c69857696cca7697a84c6f897ba2575',
+    sourceSha256: '226120667c2b6183ead6f86b6c78913c822c7deed0f27ac9d6226fe63e858fd2',
     reviewArea: {
       en: 'GPU telemetry units, missing values, timestamp deduplication, and full-record live statistics definitions.',
       zh: 'GPU 遥测单位、缺失值、时间戳去重，以及实时产物全记录统计的定义。',

From 92e349eb789537086a85cb5be70df582eeec6849 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 22 Sep 2026 22:35:59 -0700
Subject: [PATCH 031/103] refactor: deduplicate PowerX types and helpers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reuse stored telemetry types and the shared CSV splitter. Share the chart legend and power-series response construction while preserving each view's control IDs, API payloads and cache headers. Cover view switching on English desktop and Chinese mobile.

中文：复用遥测类型与 CSV 分隔函数，合并图例和功耗序列响应构造；保留各视图的控件 ID、API 内容及缓存头，并覆盖英文桌面和中文手机端的视图切换。
---
 packages/app/cypress/e2e/gpu-power.cy.ts      |  52 +++++++
 packages/app/src/app/api/gpu-metrics/route.ts |  61 ++++----
 .../components/gpu-power/GpuPowerDisplay.tsx  | 130 +++++++-----------
 .../app/src/components/gpu-power/types.ts     |  65 ++-------
 packages/app/src/lib/api-route-catalog.ts     |   6 +-
 5 files changed, 135 insertions(+), 179 deletions(-)

diff --git a/packages/app/cypress/e2e/gpu-power.cy.ts b/packages/app/cypress/e2e/gpu-power.cy.ts
index eb769267b..3449ecd82 100644
--- a/packages/app/cypress/e2e/gpu-power.cy.ts
+++ b/packages/app/cypress/e2e/gpu-power.cy.ts
@@ -167,6 +167,58 @@ const gpuMetricsResponse = {
   ],
 };
 
+describe('PowerX legend view switching', () => {
+  for (const { locale, width, correlation, line } of [
+    { locale: '', width: 1280, correlation: 'Correlation scatter', line: 'Line chart' },
+    { locale: '/zh', width: 390, correlation: '相关性散点图', line: '折线图' },
+  ]) {
+    it(`preserves filtering and downsampling across views at ${width}px`, () => {
+      cy.viewport(width, 844);
+      cy.intercept('GET', '**/api/gpu-metrics?runId=12345', {
+        ...gpuMetricsResponse,
+        artifacts: gpuMetricsResponse.artifacts.map((artifact) => ({
+          ...artifact,
+          data: artifact.data.flatMap((row) => [row, { ...row, index: 1, power: row.power + 20 }]),
+        })),
+      }).as('gpuMetrics');
+      cy.visit(`${locale}/gpu-metrics?gm_runId=12345`, {
+        onBeforeLoad(win) {
+          win.localStorage.setItem('inferencex-feature-gate', '1');
+          win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
+        },
+      });
+      cy.wait('@gpuMetrics');
+      cy.get('[data-testid="chart-legend"] label[for="checkbox-1"]').click();
+      cy.get('#checkbox-1').should('not.be.checked');
+      cy.get('[data-testid="gpu-metrics-reset-filter"]').should('be.visible');
+      cy.get('[data-testid="gpu-metrics-downsample"]')
+        .click()
+        .should('have.attr', 'aria-checked', 'false');
+
+      cy.get(`button[title="${correlation}"]`).click();
+      cy.get('#checkbox-1').should('not.be.checked');
+      cy.get('[data-testid="gpu-metrics-downsample-corr"]').should(
+        'have.attr',
+        'aria-checked',
+        'false',
+      );
+      cy.get('[data-testid="gpu-metrics-reset-filter-2"]').click();
+      cy.get('#checkbox-1').should('be.checked');
+      cy.get('[data-testid="gpu-metrics-reset-filter-2"]').should('not.exist');
+
+      cy.get('[data-testid="chart-legend"] label[for="checkbox-1"]').click();
+      cy.get(`button[title="${line}"]`).click();
+      cy.get('[data-testid="gpu-metrics-reset-filter"]').click();
+      cy.get('#checkbox-1').should('be.checked');
+      cy.get('[data-testid="gpu-metrics-downsample"]').should('have.attr', 'aria-checked', 'false');
+      cy.document().then((doc) => {
+        expect(doc.documentElement.scrollWidth).to.be.at.most(doc.documentElement.clientWidth);
+      });
+      cy.screenshot(`powerx-legend-${width}`);
+    });
+  }
+});
+
 describe('PowerX Chinese route', () => {
   beforeEach(() => {
     cy.viewport(390, 844);
diff --git a/packages/app/src/app/api/gpu-metrics/route.ts b/packages/app/src/app/api/gpu-metrics/route.ts
index 202400433..49f7e510c 100644
--- a/packages/app/src/app/api/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.ts
@@ -41,11 +41,15 @@ import { type NextRequest, NextResponse } from 'next/server';
 import { getDb } from '@semianalysisai/inferencex-db/connection';
 import {
   getGpuMetricsForRun,
-  type GpuMetricSeries,
   type GpuMetricsRunPayload,
 } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
 
-import { type GpuMetricRow, type GpuPowerRunInfo } from '@/components/gpu-power/types';
+import type {
+  GpuMetricRow,
+  GpuPowerRunInfo,
+  GpuMetricsArtifact,
+  GpuPowerApiResponse,
+} from '@/components/gpu-power/types';
 import {
   cutPowerAuditBundle,
   isPowerAuditBundleEntry,
@@ -88,16 +92,9 @@ const MAX_REQUEST_BYTES = 256 * 1024;
 
 export type GpuMetricsSource = 'database' | 'github';
 
-export interface GpuMetricsArtifactPayload {
-  name: string;
-  data: GpuMetricRow[];
-  /** Present only for database-backed artifacts. */
-  series?: Omit<GpuMetricSeries, 'data'>;
-}
+export type GpuMetricsArtifactPayload = GpuMetricsArtifact;
 
-export interface GpuMetricsRouteResponse {
-  runInfo: GpuPowerRunInfo;
-  artifacts: GpuMetricsArtifactPayload[];
+export interface GpuMetricsRouteResponse extends GpuPowerApiResponse {
   source: GpuMetricsSource;
 }
 
@@ -301,6 +298,18 @@ function sourceCoverage(series: GpuPowerSeries[], sources: string[] | null) {
   };
 }
 
+function powerSeriesResponse(
+  source: GpuMetricsSource,
+  runInfo: GpuPowerRunInfo,
+  series: GpuPowerSeries[],
+  sources: string[] | null,
+) {
+  return NextResponse.json(
+    { source, runInfo, series, sourceCoverage: sourceCoverage(series, sources) },
+    { headers: { 'Cache-Control': 'no-store' } },
+  );
+}
+
 /**
  * Narrows a stored run to the artifacts a `prefix` names, mirroring the GitHub
  * listing filter so both sources answer the same request the same way.
@@ -502,15 +511,7 @@ async function readGpuMetrics(request: NextRequest, sources: string[] | null) {
           databaseSeries.length > 0 &&
           sourceCoverage(databaseSeries, sources).missingSources.length === 0
         ) {
-          return NextResponse.json(
-            {
-              source: 'database',
-              runInfo: stored.runInfo,
-              series: databaseSeries,
-              sourceCoverage: sourceCoverage(databaseSeries, sources),
-            },
-            { headers: { 'Cache-Control': 'no-store' } },
-          );
+          return powerSeriesResponse('database', stored.runInfo, databaseSeries, sources);
         }
       } else if (artifacts.length > 0) {
         return NextResponse.json(
@@ -578,15 +579,7 @@ async function readGpuMetrics(request: NextRequest, sources: string[] | null) {
         )
           throw missing;
       }
-      return NextResponse.json(
-        {
-          source: 'github',
-          runInfo,
-          series: combined,
-          sourceCoverage: sourceCoverage(combined, sources),
-        },
-        { headers: { 'Cache-Control': 'no-store' } },
-      );
+      return powerSeriesResponse('github', runInfo, combined, sources);
     }
     const live = await fetchGpuMetricsFromGithub(runId, prefix, false);
     return NextResponse.json(
@@ -606,15 +599,7 @@ async function readGpuMetrics(request: NextRequest, sources: string[] | null) {
     console.error('Error fetching GPU power data:', error);
     const missing = error instanceof StoredTelemetryIncompleteError ? error : incomplete[0];
     if (githubFallbackStarted && !missing && stored && databaseSeries.length > 0) {
-      return NextResponse.json(
-        {
-          source: 'database',
-          runInfo: stored.runInfo,
-          series: databaseSeries,
-          sourceCoverage: sourceCoverage(databaseSeries, sources),
-        },
-        { headers: { 'Cache-Control': 'no-store' } },
-      );
+      return powerSeriesResponse('database', stored.runInfo, databaseSeries, sources);
     }
     return NextResponse.json(
       missing
diff --git a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
index ec039bc6f..d28dbf25d 100644
--- a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
@@ -372,6 +372,52 @@ export default function GpuMetricsDisplay() {
     else setCorrYMetric(value as GpuMetricKey);
   }, []);
 
+  const legendElement = (
+    <ChartLegend
+      variant="sidebar"
+      onItemRemove={removeGpu}
+      legendItems={allGpuIndices.map((gpuIndex) => ({
+        name: `${t.chip} ${gpuIndex}`,
+        hw: String(gpuIndex),
+        label: `${t.chip} ${gpuIndex}`,
+        color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
+        isActive: visibleGpus.has(gpuIndex),
+        onClick: () => toggleGpu(gpuIndex),
+      }))}
+      isLegendExpanded={isLegendExpanded}
+      onExpandedChange={(expanded) => {
+        setIsLegendExpanded(expanded);
+        track('gpu_metrics_legend_expanded', { expanded });
+      }}
+      actions={
+        allGpusSelected
+          ? []
+          : [
+              {
+                id:
+                  chartView === 'correlation'
+                    ? 'gpu-metrics-reset-filter-2'
+                    : 'gpu-metrics-reset-filter',
+                label: t.resetFilter,
+                onClick: selectAllGpus,
+              },
+            ]
+      }
+      switches={[
+        {
+          id:
+            chartView === 'correlation' ? 'gpu-metrics-downsample-corr' : 'gpu-metrics-downsample',
+          label: t.downsample,
+          checked: downsample,
+          onCheckedChange: (c) => {
+            setDownsample(c);
+            track('gpu_metrics_downsample_toggled', { enabled: c });
+          },
+        },
+      ]}
+    />
+  );
+
   return (
     <section data-testid="gpu-metrics-display">
       <Card className="mb-4">
@@ -668,47 +714,7 @@ export default function GpuMetricsDisplay() {
                     <UnofficialDomainNotice />
                   </>
                 }
-                legendElement={
-                  <ChartLegend
-                    variant="sidebar"
-                    onItemRemove={removeGpu}
-                    legendItems={allGpuIndices.map((gpuIndex) => ({
-                      name: `${t.chip} ${gpuIndex}`,
-                      hw: String(gpuIndex),
-                      label: `${t.chip} ${gpuIndex}`,
-                      color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
-                      isActive: visibleGpus.has(gpuIndex),
-                      onClick: () => toggleGpu(gpuIndex),
-                    }))}
-                    isLegendExpanded={isLegendExpanded}
-                    onExpandedChange={(expanded) => {
-                      setIsLegendExpanded(expanded);
-                      track('gpu_metrics_legend_expanded', { expanded });
-                    }}
-                    actions={
-                      allGpusSelected
-                        ? []
-                        : [
-                            {
-                              id: 'gpu-metrics-reset-filter',
-                              label: t.resetFilter,
-                              onClick: selectAllGpus,
-                            },
-                          ]
-                    }
-                    switches={[
-                      {
-                        id: 'gpu-metrics-downsample',
-                        label: t.downsample,
-                        checked: downsample,
-                        onCheckedChange: (c) => {
-                          setDownsample(c);
-                          track('gpu_metrics_downsample_toggled', { enabled: c });
-                        },
-                      },
-                    ]}
-                  />
-                }
+                legendElement={legendElement}
               />
             )}
             {chartView === 'correlation' && (
@@ -724,47 +730,7 @@ export default function GpuMetricsDisplay() {
                     <UnofficialDomainNotice />
                   </>
                 }
-                legendElement={
-                  <ChartLegend
-                    variant="sidebar"
-                    onItemRemove={removeGpu}
-                    legendItems={allGpuIndices.map((gpuIndex) => ({
-                      name: `${t.chip} ${gpuIndex}`,
-                      hw: String(gpuIndex),
-                      label: `${t.chip} ${gpuIndex}`,
-                      color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
-                      isActive: visibleGpus.has(gpuIndex),
-                      onClick: () => toggleGpu(gpuIndex),
-                    }))}
-                    isLegendExpanded={isLegendExpanded}
-                    onExpandedChange={(expanded) => {
-                      setIsLegendExpanded(expanded);
-                      track('gpu_metrics_legend_expanded', { expanded });
-                    }}
-                    actions={
-                      allGpusSelected
-                        ? []
-                        : [
-                            {
-                              id: 'gpu-metrics-reset-filter-2',
-                              label: t.resetFilter,
-                              onClick: selectAllGpus,
-                            },
-                          ]
-                    }
-                    switches={[
-                      {
-                        id: 'gpu-metrics-downsample-corr',
-                        label: t.downsample,
-                        checked: downsample,
-                        onCheckedChange: (c) => {
-                          setDownsample(c);
-                          track('gpu_metrics_downsample_toggled', { enabled: c });
-                        },
-                      },
-                    ]}
-                  />
-                }
+                legendElement={legendElement}
               />
             )}
           </Card>
diff --git a/packages/app/src/components/gpu-power/types.ts b/packages/app/src/components/gpu-power/types.ts
index 7c95b7ce3..6c82d5616 100644
--- a/packages/app/src/components/gpu-power/types.ts
+++ b/packages/app/src/components/gpu-power/types.ts
@@ -2,30 +2,15 @@ import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
 import {
   parseAmdTimestamp,
   parseNvidiaTimestamp,
+  splitCsvLine,
 } from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
-import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
-
-export interface GpuMetricRow {
-  timestamp: string;
-  index: number;
-  power: number;
-  // Absent when the collector did not sample the metric (multinode DCGM
-  // bundles are power-only); a missing value is never plotted as 0.
-  temperature?: number;
-  smClock?: number;
-  memClock?: number;
-  gpuUtil?: number;
-  memUtil?: number;
-  // AMD-specific optional fields
-  edgeTemp?: number;
-  memTemp?: number;
-  gfxVoltage?: number;
-  socVoltage?: number;
-  memVoltage?: number;
-  fclk?: number;
-  socClk?: number;
-  mmActivity?: number;
-}
+import type {
+  GpuMetricSampleRow,
+  GpuMetricSeries,
+  GpuMetricStatRow,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+export type GpuMetricRow = GpuMetricSampleRow;
 
 export interface GpuPowerRunInfo {
   id: number;
@@ -248,28 +233,6 @@ function parseTimestampToMs(raw: string): number | null {
   return null;
 }
 
-/**
- * Split a CSV line respecting double-quoted fields (which may contain commas).
- * Required for AMD amd-smi CSV where array fields like "['N/A', 'N/A']" are quoted.
- */
-function splitCsvLine(line: string): string[] {
-  const result: string[] = [];
-  let current = '';
-  let inQuotes = false;
-  for (const char of line) {
-    if (char === '"') {
-      inQuotes = !inQuotes;
-    } else if (char === ',' && !inQuotes) {
-      result.push(current.trim());
-      current = '';
-    } else {
-      current += char;
-    }
-  }
-  result.push(current.trim());
-  return result;
-}
-
 /**
  * Build a column-index lookup from a CSV header line.
  * Returns a map of header name → column index.
@@ -439,17 +402,7 @@ export function parseCsvData(csvText: string): GpuMetricRow[] {
 
 // --- Statistics ---
 
-export interface GpuStats {
-  gpuIndex: number;
-  count: number;
-  min: number;
-  max: number;
-  mean: number;
-  median: number;
-  p95: number;
-  p99: number;
-  stddev: number;
-}
+export type GpuStats = Omit<GpuMetricStatRow, 'metric'>;
 
 function percentile(sorted: number[], p: number): number {
   const idx = (p / 100) * (sorted.length - 1);
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 6323c04c2..e4f0ca1b4 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -239,7 +239,7 @@ export const apiRouteCatalog = [
       en: 'UI-only PowerX raw/series=power read: DB-first with artifact fallback, separate host/GPU identities and adjacent CSV context timezone normalization. GET has no expected identities and reports sourceCoverage unknown. Healthy stored windows survive fallback; known-incomplete CSVs require retained file/sample inventory and known-incomplete bundles require re-ingest. DB failures return 503 DATABASE_UNAVAILABLE; unresolved stored gaps return 503 STORED_TELEMETRY_INCOMPLETE. Responses use no-store. This is not a stable public API.',
       zh: '仅供 PowerX 界面读取原始遥测或 series=power：优先 DB，缺失时回退产物，保留主机/GPU 身份，并按相邻 CSV context 规范化时区。GET 没有预期身份清单，sourceCoverage 为 unknown。回退保留健康存储窗口；已知不完整 CSV 须满足文件/样本清单，已知不完整 bundle 须重新 ingest。数据库故障返回 503 DATABASE_UNAVAILABLE，未恢复的存储缺口返回 503 STORED_TELEMETRY_INCOMPLETE。响应使用 no-store，不作为稳定公开 API。',
     },
-    sourceSha256: '12a04eb419e8339c1e2f7d9b8f4b295c0abd899f1606e919df21ebf8a2acde6e',
+    sourceSha256: '48930ca8c5c7fb26ab193f872271e21aefadc306d760ad9a7365c7cba4e4029b',
   },
   {
     source: 'src/app/api/gpu-metrics/route.ts',
@@ -250,7 +250,7 @@ export const apiRouteCatalog = [
       en: 'Read-only Timeline transport with runId, series=power and optional prefix in the query; JSON sources contains 1–1000 validation basenames with RESULT_FILENAME up to 200 ASCII letters/digits/dot/underscore/hyphen, matching prefix. Invalid input returns 400; bodies over 256 KiB return 413. Fully covered DB reads skip GitHub; missing identities fall back and merge by validation source, preserving stored sibling windows. Offline GitHub preserves healthy DB series with incomplete sourceCoverage. Coverage describes only requested identities, never whole-run/sample completeness. The GET no-store/error/inventory guarantees also apply. UI-owned, excluded from the stable public API.',
       zh: 'Timeline 只读传输：查询参数为 runId、series=power 和可选 prefix；JSON sources 含 1–1000 个验证文件 basename，RESULT_FILENAME 最长 200 个 ASCII 字母/数字/点/下划线/连字符，且须匹配 prefix。输入错误返回 400，正文超过 256 KiB 返回 413。DB 已覆盖请求时跳过 GitHub，否则按缺失身份回退，以 validation source 为键合并，并保留已存储的同 bundle 兄弟窗口。GitHub 离线仍返回健康 DB 序列，sourceCoverage 标记 incomplete。覆盖仅针对请求身份，不代表整次 run 或样本完整性。沿用 GET 的 no-store、错误和清单约束；属于界面接口，不纳入稳定公开 API。',
     },
-    sourceSha256: '12a04eb419e8339c1e2f7d9b8f4b295c0abd899f1606e919df21ebf8a2acde6e',
+    sourceSha256: '48930ca8c5c7fb26ab193f872271e21aefadc306d760ad9a7365c7cba4e4029b',
   },
   {
     source: 'src/app/api/openapi.json/route.ts',
@@ -830,7 +830,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/gpu-power/types.ts',
-    sourceSha256: '226120667c2b6183ead6f86b6c78913c822c7deed0f27ac9d6226fe63e858fd2',
+    sourceSha256: 'e8c5460821f5d8228bcf8b7dd087abe14e29a8e220e1d8bcd75112fb5ead1baa',
     reviewArea: {
       en: 'GPU telemetry units, missing values, timestamp deduplication, and full-record live statistics definitions.',
       zh: 'GPU 遥测单位、缺失值、时间戳去重，以及实时产物全记录统计的定义。',

From be14a8bea3a510520c1539f99666001c35ebe09c Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Wed, 23 Sep 2026 14:46:55 -0700
Subject: [PATCH 032/103] feat: add PowerX service comparisons and load
 diagnostics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：新增 PowerX 服务指标对比与负载诊断。
支持平均值/中位数服务指标、同等服务水平下的功耗与能耗对比、prefill 能耗占比、精确拓扑筛选和并发诊断。
同步只读 API、可共享 Timeline 状态、测试与文档；不包含演示数据或新增基准测试结果。
---
 docs/d3-charts.md                             |  10 +-
 docs/dashboard-readonly-views.md              | 129 ++++-
 docs/data-transforms.md                       |   6 +-
 .../component/power-service-comparison.cy.tsx | 254 +++++++++
 .../cypress/component/power-timeline.cy.tsx   |  70 +++
 .../component/quick-filters-dialog.cy.tsx     |  77 +++
 .../cypress/component/scatter-graph.cy.tsx    |  52 ++
 .../app/cypress/e2e/inference-chart.cy.ts     | 206 +++++++
 .../app/cypress/e2e/powerx-timeline.cy.ts     |  29 +-
 packages/app/cypress/support/e2e.ts           |   2 +-
 packages/app/cypress/support/mock-data.ts     |  16 +-
 .../app/api/v1/views/inference/route.test.ts  | 259 +++++++++
 .../src/app/api/v1/views/inference/route.ts   | 149 ++++-
 .../app/api/v1/views/options/route.test.ts    |   4 +
 .../app/src/app/api/v1/views/options/route.ts |   4 +
 .../inference/InferenceContext.test.ts        |   9 +
 .../components/inference/InferenceContext.tsx |  30 +-
 .../axis-metric-explanations.test.ts          |   3 +
 .../inference/axis-metric-explanations.ts     |  25 +-
 .../inference/hooks/chart-data-core.ts        |  10 +-
 .../inference/hooks/useChartData.ts           |  43 +-
 .../hooks/useChartData.x-axis-wiring.test.tsx |  74 ++-
 .../inference/perf-ruler-store.test.ts        |   5 +
 .../app/src/components/inference/types.ts     |  17 +-
 .../inference/ui/ActiveQuickFilters.tsx       |   3 +-
 .../components/inference/ui/ChartDisplay.tsx  |  56 +-
 .../src/components/inference/ui/GPUGraph.tsx  |   4 +
 .../inference/ui/PowerServiceComparison.tsx   | 538 ++++++++++++++++++
 .../components/inference/ui/PowerTimeline.tsx | 184 ++++--
 .../inference/ui/QuickFiltersDialog.tsx       |  57 +-
 .../components/inference/ui/ScatterGraph.tsx  | 110 +++-
 .../inference/ui/XAxisModeSelector.tsx        | 137 +++--
 .../src/components/inference/utils.test.ts    | 104 ++++
 .../app/src/components/inference/utils.ts     |  24 +-
 .../inference/utils/concurrency-series.ts     |  36 ++
 .../utils/equal-service-comparison.test.ts    | 295 ++++++++++
 .../utils/equal-service-comparison.ts         | 252 ++++++++
 .../inference/utils/powerCurves.test.ts       |  43 ++
 .../inference/utils/powerTimeline.test.ts     |  80 +++
 .../inference/utils/powerTimeline.ts          |  69 ++-
 .../inference/utils/quick-filter-summary.ts   |  13 +-
 .../inference/utils/quickFilters.test.ts      | 127 ++++-
 .../inference/utils/quickFilters.ts           |   8 +-
 .../inference/utils/resolveXAxisField.ts      |  42 +-
 .../inference/utils/topology-filter.ts        |  82 +++
 .../inference/utils/x-axis-scale.test.ts      |  11 +
 .../inference/utils/x-axis-scale.ts           |   1 +
 packages/app/src/lib/api-route-catalog.ts     |  42 +-
 .../app/src/lib/benchmark-transform.test.ts   |  32 ++
 packages/app/src/lib/benchmark-transform.ts   |   3 +
 packages/app/src/lib/chart-utils.ts           |  19 +-
 packages/app/src/lib/url-state.test.ts        |   9 +
 packages/app/src/lib/url-state.ts             |  24 +
 .../app/src/lib/views-api/docs/extensions.ts  |   8 +-
 .../app/src/lib/views-api/docs/inference.ts   | 181 +++++-
 .../app/src/lib/views-api/docs/options.ts     |   5 +
 packages/app/src/lib/views-api/registry.ts    |   7 +
 packages/app/src/lib/views-api/series.test.ts |  76 +++
 packages/app/src/lib/views-api/series.ts      |  86 ++-
 .../skills/inferencex-api/integrity.json      |   2 +-
 .../references/dashboard-views.md             |  87 ++-
 61 files changed, 4042 insertions(+), 298 deletions(-)
 create mode 100644 packages/app/cypress/component/power-service-comparison.cy.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerServiceComparison.tsx
 create mode 100644 packages/app/src/components/inference/utils/concurrency-series.ts
 create mode 100644 packages/app/src/components/inference/utils/equal-service-comparison.test.ts
 create mode 100644 packages/app/src/components/inference/utils/equal-service-comparison.ts
 create mode 100644 packages/app/src/components/inference/utils/topology-filter.ts

diff --git a/docs/d3-charts.md b/docs/d3-charts.md
index 58589cc35..33d0ba017 100644
--- a/docs/d3-charts.md
+++ b/docs/d3-charts.md
@@ -77,7 +77,7 @@ The metric registry declares whether higher or lower values are preferable. Char
 
 ### Global Pareto highlights
 
-Every inference scatter chart exposes a **Pareto Frontier** switch under
+Inference scatter charts with a performance-preference X axis expose a **Pareto Frontier** switch under
 **Advanced**, off by default.
 Collapsing Advanced does not turn off an enabled highlight.
 `i_frontier=1` preserves plain shading in share links; value `2` restores the scenic background.
@@ -124,6 +124,14 @@ Upper boundaries use monotone interpolation between unique-X vertices, including
 
 **Perf Ruler** is available on all six measured-power axes in both chart views. It measures the ratio of the drawn upper-boundary values at the same X coordinate, using the rendered paths after zoom; clicking an off-boundary dot selects its series' boundary, clamped to the curves' shared X range. The ratio compares power or percentage of TDP, not energy efficiency. Optimal Only changes point visibility without moving the ruler. Hidden or removed curves cannot be measured, and changing either axis clears existing rulers. Modeled chassis power keeps its existing ruler restriction while showing an upper boundary; energy and other Pareto views retain their ruler behavior.
 
+### Observed concurrency sweeps
+
+`i_xmode=concurrency` is an observed-load view, not an optimization axis. It uses the exact positive `conc` values and a linear X scale. Valid metric-bearing load points remain visible even when saved Optimal Only or Best per SKU preferences are enabled; Pareto Frontier, gradient strategy labels, Perf Ruler and Replay are unavailable in this mode. Y-axis units and measured/modelled boundaries do not change.
+
+`groupConcurrencySeries` groups straight-line segments by hardware, precision, topology (`pointTopologyKey`), recipe fingerprint, date, run and power-comparison variant. It never joins TP4 to TP8 or 4P/4D to 16P/16D. A group with repeated concurrency values, or points without run provenance, stays as markers instead of being reduced to an arbitrary average or envelope. Markers retain their original values and identities. These segments connect observations; they do not establish a hardware-controlled comparison or estimate untested loads.
+
+Official and unofficial paths share this behavior. Concurrency history comparisons use `ScatterGraph` with independent run segments, not the performance-oriented `GPUGraph` path. Exact topology quick filters retain that topology's entire load sweep. Share URLs, tables and CSV exports preserve the selected `conc` coordinates.
+
 ## Gradient Roofline Labels
 
 Parallelism strategies (TP4, TEP8, DPAEP4) color roofline paths with gradient stops and use one label per contiguous strategy segment. The reasoning:
diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 7a7167cae..e8fb77f49 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -11,29 +11,29 @@ All endpoints are GET under /api/v1/views. Unsupported and repeated keys return
 This table records accepted query names; behavioral tests exercise representative
 combinations, not the full Cartesian product of all possible filter values.
 
-| View                            | Accepted query keys                                                                                                                                                                                                                                                                                      |
-| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `cache-reuse`                   | `config`, `date`, `gpus`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                          |
-| `calculator`                    | `costProvider`, `costType`, `costcap`, `date`, `format`, `gpus`, `hideSkuAboveConfigLimit`, `mode`, `model`, `mw`, `percentile`, `precisions`, `runId`, `sequence`, `target`, `tcoBasis`, `unofficialrun`                                                                                                |
-| `collectivex`                   | `activeSeries`, `kvSeries`, `swapSeries`, `backend`, `epSize`, `kvOp`, `kvX`, `kvY`, `modes`, `operation`, `overlapIsl`, `pageTokens`, `percentile`, `phase`, `precision`, `runs`, `sku`, `suite`, `swapDirection`, `swapLayout`, `swapMetric`, `swapPercentile`, `version`, `yAxis`                     |
-| `compare`                       | `format`, `gpus`, `model`, `scenario`, `slug`, `tiers`, `variant`                                                                                                                                                                                                                                        |
-| `current-inferencex-image`      | `asOf`, `frameworks`, `hardware`, `model`, `nodeType`, `precision`, `sequence`, `spec`                                                                                                                                                                                                                   |
-| `evaluation`                    | `unofficialrun`, `benchmark`, `date`, `format`, `gpus`, `model`, `precisions`                                                                                                                                                                                                                            |
-| `first-token`                   | `caps`, `costProvider`, `costType`, `date`, `gpus`, `minInteractivity`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                            |
-| `fleet`                         | `cache`, `costProvider`, `costType`, `format`, `gpus`, `horizon`, `metric`, `model`, `mtbi`, `mw`, `oprice`, `percentile`, `precisions`, `price`, `ramp`, `recovery`, `sequence`, `target`, `tcoBasis`                                                                                                   |
-| `gpu-metrics`                   | `artifact`, `chartView`, `corrXMetric`, `corrYMetric`, `direction`, `downsample`, `gpus`, `metric`, `runId`, `sort`                                                                                                                                                                                      |
-| `gpu-specs`                     | `format`, `metric`                                                                                                                                                                                                                                                                                       |
-| `historical`                    | `deployment`, `end`, `extendToDate`, `format`, `frameworks`, `gpus`, `metric`, `model`, `precisions`, `priceSource`, `sequence`, `start`, `target`, `tcoBasis`, `vendors`                                                                                                                                |
-| `inference`                     | `allPoints`, `best`, `date`, `dates`, `deployment`, `end`, `format`, `frameworks`, `gpus`, `metric`, `model`, `optimal`, `percentile`, `power`, `precisions`, `priceSource`, `runId`, `sequence`, `spec`, `start`, `tcoBasis`, `unofficialrun`, `userCosts`, `userPowers`, `vendors`, `xmetric`, `xmode` |
-| `operatorx`                     | `backend`, `cluster`, `metric`, `operator`, `page`, `precision`, `runId`, `shape`, `status`                                                                                                                                                                                                              |
-| `options`                       | `format`                                                                                                                                                                                                                                                                                                 |
-| `overview`                      | `compare`, `engine`, `format`, `hwrows`, `models`, `ref`, `rows`, `tier`                                                                                                                                                                                                                                 |
-| `profit-estimator`              | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                           |
-| `profit-estimator-per-gigawatt` | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                           |
-| `rankings`                      | `format`, `kind`, `model`, `scenario`                                                                                                                                                                                                                                                                    |
-| `reliability`                   | `asOf`, `format`, `gpus`, `range`                                                                                                                                                                                                                                                                        |
-| `submissions`                   | `direction`, `limit`, `lines`, `mode`, `offset`, `onChangeOnly`, `search`, `sort`                                                                                                                                                                                                                        |
-| `video`                         | `artifact`, `cell`, `compare`, `costs`, `gpuBasis`, `page`, `phase`, `run`, `selected`, `slot`, `source`, `view`, `workload`, `xAxis`, `yAxis`                                                                                                                                                           |
+| View                            | Accepted query keys                                                                                                                                                                                                                                                                                                                                                                                                     |
+| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `cache-reuse`                   | `config`, `date`, `gpus`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                                                                                                                         |
+| `calculator`                    | `costProvider`, `costType`, `costcap`, `date`, `format`, `gpus`, `hideSkuAboveConfigLimit`, `mode`, `model`, `mw`, `percentile`, `precisions`, `runId`, `sequence`, `target`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                               |
+| `collectivex`                   | `activeSeries`, `kvSeries`, `swapSeries`, `backend`, `epSize`, `kvOp`, `kvX`, `kvY`, `modes`, `operation`, `overlapIsl`, `pageTokens`, `percentile`, `phase`, `precision`, `runs`, `sku`, `suite`, `swapDirection`, `swapLayout`, `swapMetric`, `swapPercentile`, `version`, `yAxis`                                                                                                                                    |
+| `compare`                       | `format`, `gpus`, `model`, `scenario`, `slug`, `tiers`, `variant`                                                                                                                                                                                                                                                                                                                                                       |
+| `current-inferencex-image`      | `asOf`, `frameworks`, `hardware`, `model`, `nodeType`, `precision`, `sequence`, `spec`                                                                                                                                                                                                                                                                                                                                  |
+| `evaluation`                    | `unofficialrun`, `benchmark`, `date`, `format`, `gpus`, `model`, `precisions`                                                                                                                                                                                                                                                                                                                                           |
+| `first-token`                   | `caps`, `costProvider`, `costType`, `date`, `gpus`, `minInteractivity`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                                                                           |
+| `fleet`                         | `cache`, `costProvider`, `costType`, `format`, `gpus`, `horizon`, `metric`, `model`, `mtbi`, `mw`, `oprice`, `percentile`, `precisions`, `price`, `ramp`, `recovery`, `sequence`, `target`, `tcoBasis`                                                                                                                                                                                                                  |
+| `gpu-metrics`                   | `artifact`, `chartView`, `corrXMetric`, `corrYMetric`, `direction`, `downsample`, `gpus`, `metric`, `runId`, `sort`                                                                                                                                                                                                                                                                                                     |
+| `gpu-specs`                     | `format`, `metric`                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `historical`                    | `deployment`, `end`, `extendToDate`, `format`, `frameworks`, `gpus`, `metric`, `model`, `precisions`, `priceSource`, `sequence`, `start`, `target`, `tcoBasis`, `vendors`                                                                                                                                                                                                                                               |
+| `inference`                     | `allPoints`, `best`, `date`, `dates`, `deployment`, `end`, `format`, `frameworks`, `gpus`, `metric`, `model`, `optimal`, `percentile`, `power`, `precisions`, `priceSource`, `runId`, `sequence`, `spec`, `start`, `tcoBasis`, `topologies`, `unofficialrun`, `userCosts`, `userPowers`, `vendors`, `xmetric`, `xmode`, `xstat`, `serviceCompare`, `serviceBaseline`, `serviceComparator`, `serviceTarget`, `roleShare` |
+| `operatorx`                     | `backend`, `cluster`, `metric`, `operator`, `page`, `precision`, `runId`, `shape`, `status`                                                                                                                                                                                                                                                                                                                             |
+| `options`                       | `format`                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `overview`                      | `compare`, `engine`, `format`, `hwrows`, `models`, `ref`, `rows`, `tier`                                                                                                                                                                                                                                                                                                                                                |
+| `profit-estimator`              | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                                                                                                                                          |
+| `profit-estimator-per-gigawatt` | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                                                                                                                                          |
+| `rankings`                      | `format`, `kind`, `model`, `scenario`                                                                                                                                                                                                                                                                                                                                                                                   |
+| `reliability`                   | `asOf`, `format`, `gpus`, `range`                                                                                                                                                                                                                                                                                                                                                                                       |
+| `submissions`                   | `direction`, `limit`, `lines`, `mode`, `offset`, `onChangeOnly`, `search`, `sort`                                                                                                                                                                                                                                                                                                                                       |
+| `video`                         | `artifact`, `cell`, `compare`, `costs`, `gpuBasis`, `page`, `phase`, `run`, `selected`, `slot`, `source`, `view`, `workload`, `xAxis`, `yAxis`                                                                                                                                                                                                                                                                          |
 
 ## Source audit and shared computations
 
@@ -67,6 +67,79 @@ J/token and selected-time-window calculations. Run telemetry is DB-first with an
 artifact fallback for missing storage; the public view returns private, no-store
 responses and preserves upstream 503 failures.
 
+The `/inference` Power Timeline is a different surface from the raw `gpu-metrics`
+explorer. Its existing read-only `/api/gpu-metrics?series=power` source returns
+one-second per-device buckets, role assignments and validation-source identities;
+benchmark `power_audit` supplies the exact serving-window bounds. The public
+`/api/v1/views/gpu-metrics` projection alone does not return that combined evidence
+and must not be described as a serving-window or role-pool projection.
+
+Timeline share fields `i_ptaxis`, `i_ptlines`, `i_ptwindow`, `i_ptfocus` and
+`i_ptutility` are renderer state, not parameters of the raw explorer API. Window-only
+display selects retained bucket timestamps within the recorded inclusive bounds;
+serving-relative display uses `(bucket UTC ms - window start UTC ms) / 1000`.
+Missing, nonfinite or non-increasing bounds omit that trace in either mode.
+No boundary samples are interpolated, and no window statistics or energy values
+are recomputed. Per-GPU/mean/role-pool modes reuse the existing device identity and
+pool-sum calculations. Focus only dims other traces and the utility toggle only
+adds registry references. Raw telemetry, full-record statistics and API responses
+are unchanged by all five display settings. The reusable client helpers are
+`parsePowerTimelineParams`, `powerTimelineSampleX` and `tracePools` in
+`components/inference/utils/powerTimeline.ts`, and `sumPowerAt` in
+`components/gpu-power/power-series.ts`.
+
+## Fixed-sequence service comparisons
+
+The inference view exposes the same mean/median selector as the dashboard through
+`xstat=median|mean` (default median). Mean streaming speed is **1 / mean TPOT**;
+it is not the arithmetic mean of per-request speeds. Mean TTFT and E2E use their
+recorded mean values. Missing means remain missing; the view never substitutes a
+median. AgentX keeps its selected `percentile`, and concurrency has no statistic:
+`params.xstat` resolves to null in both cases, while `xAxis.statistic` records the
+effective percentile or null.
+
+`serviceCompare=true` adds `serviceSources`, `equalServiceCurve`, and (when
+`serviceTarget` is present) `equalServiceComparison`. Select exact opaque
+`serviceBaseline` and `serviceComparator` keys returned by `serviceSources`,
+encoded with `URLSearchParams`; omitted selections use its first two entries.
+Stale explicit selections remain unavailable. Missing target returns null, not an
+invented operating point. Streaming-speed targets are tok/s/user; TTFT/E2E targets
+are seconds. Concurrency remains a separate observed-load diagnostic, not an
+equal-service comparison axis.
+
+The dashboard and API share `equal-service-comparison.ts`: both consume scoped
+observed points after chart coverage/limits, before frontier and best-per-SKU
+pruning, with power-comparison clones excluded. `allPoints=true` restores clipped
+observations. Source keys retain hardware, precision, exact run, actual source
+date, recipe, topology and workload identity; changing display dates does not
+create a new measured source. Comparisons never join different sources into one
+interpolation bracket. All three metrics use bounded numerical linear
+interpolation of the underlying quantities, then compute
+`100 × (comparator / baseline − 1)`. No log-axis interpolation, extrapolation,
+missing-endpoint bridging or averaging of conflicting duplicate x-values occurs.
+
+Metrics are mean measured GPU board W/GPU, whole-deployment output tokens/s, and
+validated measured GPU J/output token. Each estimate returns its bracket point
+IDs, source/run/topology/recipe identities, endpoint x/value, and whether it was
+interpolated. Unavailable comparisons return explicit reasons and null metrics,
+not zero. This is an operating-point comparison, not proof of a hardware-only
+causal effect. Official, historical and unofficial source identities remain
+visible.
+
+`roleShare=true` returns `roleEnergyShares` through the same shared role helper.
+Validated disaggregated prefill J/input is multiplied by same-window aggregate
+J/output ÷ J/input, then compared with decode J/output. The percentage denominator
+is reconstructed prefill + decode energy on one output-token basis. Missing or
+invalid role measurements are omitted. This view does not mix pool-local token
+denominators or claim the reconstructed sum was independently measured.
+
+These panel results are JSON-only: `format=csv` with either panel enabled returns
+400, rather than silently exporting only the primary chart. Ordinary CSV retains
+its existing plotted-point contract. Share controls map directly:
+`i_mstat` → `xstat`, `i_servicecompare` → `serviceCompare`, `i_servicebase` →
+`serviceBaseline`, `i_servicepeer` → `serviceComparator`, `i_servicetarget` →
+`serviceTarget`, and `i_roleshare` → `roleShare`.
+
 ## Verification scope
 
 Route tests cover baseline views and selected extension behavior, including
@@ -88,6 +161,16 @@ those properties.
 GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全记录统计使用所选文件、
 主机序列的全部芯片摘要，包含启动与 warmup；已有摘要为空时不补算，缺失读数不补零。
 芯片显隐和图表降采样不改变该统计，也不改变 serving-window 或 J/token 的计算口径。
+
+`/inference` 的 Power Timeline 与原始 `gpu-metrics` 浏览器是两个不同视图。
+时间线通过现有只读 `/api/gpu-metrics?series=power` 获取逐秒采样、设备角色和验证来源，
+再结合基准测试 `power_audit` 中的服务窗口边界；公开的 `/api/v1/views/gpu-metrics`
+本身不返回这组完整证据，不能称为服务窗口或 GPU 池投影视图。
+五个 `i_pt*` 分享字段只控制显示，不是原始浏览器 API 的参数。窗口模式仅显示已记录
+边界内的采样点（含边界），服务起点模式将 UTC 时间减去窗口起点后换算为秒。
+边界缺失、非有限值或结束不晚于开始时，不绘制对应曲线；不插值补点，也不重算窗口
+统计或能耗。GPU 池模式复用已有设备角色和求和函数；聚焦仅调暗其他曲线，参考线
+使用硬件注册表。原始遥测、全记录统计和 API 响应均不因这些显示设置而改变。
 响应使用 private, no-store，上游 503 保留为错误响应。
 
 测试覆盖契约同步及代表性的筛选行为，并未穷举所有参数组合。生产数据库上的
diff --git a/docs/data-transforms.md b/docs/data-transforms.md
index f5dcd0935..ebf7e541e 100644
--- a/docs/data-transforms.md
+++ b/docs/data-transforms.md
@@ -159,6 +159,10 @@ Both charts share the same Y-axis options. The `y` field is the default `AggData
 - `title` / `titleZh`: bilingual dropdown and chart titles.
 - `polarity`: whether higher or lower values are preferable. The derived chart definitions combine this with x-axis polarity to produce the concrete Pareto corner.
 
-**X-axis selection** takes precedence over the Y metric: selecting an input-energy metric keeps the chosen Interactivity, TTFT, or E2E axis. Fixed-sequence TTFT uses the measured median; agentic TTFT uses the selected percentile. Official data, unofficial overlays, and Replay share the resolved axis. Missing or zero-filled TTFT values are omitted instead of becoming plotted latency measurements. The legacy input-metric override (`inputTputPerGpu` declares `p90_ttft`) applies only to callers without a global x-axis mode.
+**X-axis selection** takes precedence over the Y metric: selecting an input-energy metric keeps the chosen Interactivity, TTFT, or E2E axis. Fixed-sequence service axes use `i_mstat=median|mean` (default `median`); Agentic axes keep the selected percentile. Mean interactivity resolves the separate `mean_tpot_intvty` field, derived as `1 / mean_tpot` with TPOT in seconds, not the arithmetic mean of per-request speeds (`mean_intvty`, retained unchanged). Mean TTFT and E2E use the explicit `mean_ttft` and `mean_e2el` measurements. Missing, non-finite or nonpositive mean measurements are omitted, never replaced by median or raw interactivity. Axes and headings identify Mean/Median; changing the effective field clears Perf Rulers. Official data, unofficial overlays, Replay, tables and CSV share the resolved axis. Concurrency ignores this statistic. Missing or zero-filled TTFT values are omitted instead of becoming plotted latency measurements. The legacy input-metric override (`inputTputPerGpu` declares `p90_ttft`) applies only to callers without a global x-axis mode.
+
+**Observed concurrency** — `i_xmode=concurrency` / API `xmode=concurrency` resolves `conc` through the same `resolveXAxisField` helper for official data, unofficial overlays and the read-only inference view. It has no percentile prefix or preferred X direction: `useChartData` removes roofline directions, and the API returns no frontier/best flags and resolves optimal/best filtering off. Missing, non-finite or nonpositive concurrency is not replaced with latency. Metric-bearing observed loads bypass cost/latency display clipping; tables and CSV retain the same X values. Replay is not offered for this mode.
+
+`pointTopologyKey` supplies exact topology filter keys without concurrency, hardware, precision, date, run or recipe identity. The API includes `topologyKey` on each point so a caller can reuse it as a selector. Rendering adds the omitted identity dimensions before joining observed loads; see [Observed concurrency sweeps](d3-charts.md#observed-concurrency-sweeps). A topology filter does not imply that two platforms' measured concurrency sets, software or other experimental conditions match.
 
 **Limits** — both charts include `y_cost_limit: 5` (clip cost-per-million metrics above $5/M tokens) and `y_latency_limit: 60` (clip x-axis outliers beyond 60s when TTFT is on x). Tokens-per-dollar metrics are not cost-clipped; clipped cost points remain available to the dashed continuation layer.
diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
new file mode 100644
index 000000000..9d631ceaa
--- /dev/null
+++ b/packages/app/cypress/component/power-service-comparison.cy.tsx
@@ -0,0 +1,254 @@
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+
+import type { AggDataEntry, InferenceData } from '@/components/inference/types';
+import PowerServiceComparison from '@/components/inference/ui/PowerServiceComparison';
+import { equalServiceSourceKey } from '@/components/inference/utils/equal-service-comparison';
+import { buildShareUrl, readUrlParams, writeUrlParams } from '@/lib/url-state';
+import { createMockInferenceData } from '../support/mock-data';
+import { mountWithProviders } from '../support/test-utils';
+
+const metric = (y: number) => ({ y, roof: false });
+const point = (overrides: Partial<InferenceData> = {}) =>
+  createMockInferenceData({
+    hwKey: 'b200_sglang',
+    hw: 'B200',
+    framework: 'sglang',
+    precision: 'fp8',
+    physicalChips: 4,
+    tp: 4,
+    decode_tp: 4,
+    conc: 8,
+    date: '2026-09-23',
+    run_url: 'https://example.invalid/runs/900000001',
+    benchmark_type: 'single_turn',
+    mean_tpot_intvty: 20,
+    output_tput_per_gpu: 50,
+    measuredAvgPower: metric(400),
+    measuredJPerOutputToken: metric(10),
+    ...overrides,
+  });
+const baseline = [
+  point({ id: 1 }),
+  point({
+    id: 2,
+    conc: 1,
+    mean_tpot_intvty: 60,
+    measuredAvgPower: metric(800),
+    output_tput_per_gpu: 150,
+    measuredJPerOutputToken: metric(30),
+  }),
+];
+const comparator = [
+  point({
+    id: 3,
+    hwKey: 'b300_sglang',
+    run_url: 'https://example.invalid/runs/900000002',
+    measuredAvgPower: metric(800),
+    output_tput_per_gpu: 100,
+    measuredJPerOutputToken: metric(8),
+  }),
+  point({
+    id: 4,
+    hwKey: 'b300_sglang',
+    run_url: 'https://example.invalid/runs/900000002',
+    mean_tpot_intvty: 60,
+    conc: 1,
+    measuredAvgPower: metric(1000),
+    output_tput_per_gpu: 200,
+    measuredJPerOutputToken: metric(16),
+  }),
+];
+const data = [...baseline, ...comparator];
+const baseKey = equalServiceSourceKey(baseline[0]);
+const peerKey = equalServiceSourceKey(comparator[0]);
+const roles = [40, 50, 60].map((share, index) =>
+  point({
+    id: 10 + index,
+    hwKey: 'gb200',
+    disagg: true,
+    physicalChips: 8,
+    num_prefill_gpu: 4,
+    num_decode_gpu: 4,
+    mean_tpot_intvty: 20 + index * 20,
+    conc: 2 ** index,
+    power_valid: 1,
+    power_metric_schema_version: 2,
+    joules_per_input_token: 2,
+    joules_per_output_token: 10,
+    prefill_joules_per_input_token: share / 50,
+    decode_joules_per_output_token: 10 - share / 10,
+  }),
+);
+
+function mountComparison(points = data, xField: keyof AggDataEntry = 'mean_tpot_intvty') {
+  mountWithProviders(
+    <PathnameContext.Provider value="/inference">
+      <div style={{ width: '100%', maxWidth: 1120, padding: 12, boxSizing: 'border-box' }}>
+        <PowerServiceComparison
+          data={points}
+          xField={xField}
+          xLabel={xField === 'conc' ? 'Concurrency' : 'Mean interactivity (output tok/s/user)'}
+          chartId="power-service-test"
+        />
+      </div>
+    </PathnameContext.Provider>,
+    { inference: {}, unofficial: {} },
+  );
+}
+const normalizedText = (element: JQuery<HTMLElement>) => element.text().replaceAll('−', '-');
+const target = () => cy.get('[data-testid="equal-service-target"]');
+const row = (metricName: string) => cy.get(`[data-testid="equal-service-${metricName}"]`);
+const roleSvg = () => cy.get('[data-testid="power-service-test-role-share-plot"]');
+
+function checkNoHorizontalOverflow() {
+  cy.document().should((doc) => {
+    expect(doc.documentElement.scrollWidth).to.be.at.most(doc.documentElement.clientWidth + 1);
+  });
+  cy.get('[data-testid="power-service-comparison"]').should(($panel) => {
+    const rect = $panel[0].getBoundingClientRect();
+    expect(rect.left).to.be.at.least(0);
+    expect(rect.right).to.be.at.most($panel[0].ownerDocument.documentElement.clientWidth + 1);
+  });
+}
+
+describe('PowerServiceComparison', () => {
+  beforeEach(() => {
+    writeUrlParams({
+      i_servicecompare: '0',
+      i_roleshare: '0',
+      i_servicebase: '',
+      i_servicepeer: '',
+      i_servicetarget: '',
+    });
+    readUrlParams();
+    cy.on('uncaught:exception', (error) => {
+      if (error.message.includes('ResizeObserver loop')) return false;
+    });
+  });
+
+  for (const width of [1280, 390]) {
+    it(`shows raw interpolation, signed deltas and source endpoints without page overflow (${width}px)`, () => {
+      cy.viewport(width, 1000);
+      mountComparison();
+      cy.get('[data-testid="equal-service-toggle"]').check();
+      target().type('40');
+      row('meanWattsPerGpu').within(() => {
+        cy.get('td')
+          .eq(0)
+          .should('contain.text', '600')
+          .and('contain.text', 'Interpolated')
+          .and('contain.text', 'Observation 1: 20 · c8')
+          .and('contain.text', 'Observation 2: 60 · c1');
+        cy.get('td').eq(1).should('contain.text', '900');
+        cy.get('td').eq(2).should('have.text', '+50.00%');
+      });
+      row('outputTokensPerSecond').within(() => {
+        cy.get('td strong').eq(0).should('have.text', '400');
+        cy.get('td strong').eq(1).should('have.text', '600');
+        cy.get('td').eq(2).should('have.text', '+50.00%');
+      });
+      row('joulesPerOutputToken').should(($row) =>
+        expect(normalizedText($row)).to.include('-40.00%'),
+      );
+      cy.get('[data-testid="power-service-test-service-plot"] circle.point').should(
+        'have.length',
+        9,
+      );
+      cy.get('[data-testid="power-service-test-service-plot"] circle.point[r="6"]')
+        .should('have.length', 3)
+        .and(($points) => {
+          const values = Array.from(
+            $points,
+            (element) => (element as unknown as { __data__: { x: number; y: number } }).__data__,
+          );
+          expect(values.map((entry) => entry.x)).to.deep.equal([40, 40, 40]);
+          expect(values.map((entry) => entry.y)).to.deep.equal([50, 50, -40]);
+        });
+      checkNoHorizontalOverflow();
+      cy.get('[data-testid="power-service-comparison"]').screenshot(`equal-service-${width}`, {
+        overwrite: true,
+      });
+    });
+  }
+
+  it('marks out-of-range values unavailable instead of extrapolating', () => {
+    mountComparison();
+    cy.get('[data-testid="equal-service-toggle"]').check();
+    target().type('80');
+    cy.get('[data-testid="equal-service-table"] tbody tr').each(($row) => {
+      cy.wrap($row).find('td').eq(2).should('have.text', 'Target is outside a source range.');
+      cy.wrap($row).find('strong').should('not.exist');
+    });
+  });
+
+  it('changes comparison direction and persists exact source keys and target in a share URL', () => {
+    mountComparison();
+    cy.get('[data-testid="equal-service-toggle"]').check();
+    target().type('40');
+    cy.get('[data-testid="equal-service-baseline"]').select(peerKey);
+    cy.get('[data-testid="equal-service-comparator"]').select(baseKey);
+    row('meanWattsPerGpu').should(($row) => expect(normalizedText($row)).to.include('-33.33%'));
+    row('joulesPerOutputToken').should('contain.text', '+66.67%');
+    cy.then(() => {
+      const params = new URL(buildShareUrl()).searchParams;
+      expect(params.get('i_servicebase')).to.equal(peerKey);
+      expect(params.get('i_servicepeer')).to.equal(baseKey);
+      expect(params.get('i_servicetarget')).to.equal('40');
+      expect(params.get('i_servicecompare')).to.equal('1');
+    });
+  });
+
+  it('restores source direction and target from a shared comparison URL', () => {
+    writeUrlParams({
+      i_servicecompare: '1',
+      i_servicebase: peerKey,
+      i_servicepeer: baseKey,
+      i_servicetarget: '40',
+    });
+    readUrlParams();
+    mountComparison();
+    cy.get('[data-testid="equal-service-baseline"]').should('have.value', peerKey);
+    target().should('have.value', '40');
+    row('joulesPerOutputToken').should('contain.text', '+66.67%');
+  });
+
+  it('draws observed role shares with a 50% equality reference and omits invalid telemetry', () => {
+    cy.viewport(1280, 1000);
+    mountComparison([...roles, { ...roles[0], id: 99, power_valid: 0 }]);
+    cy.get('[data-testid="role-share-toggle"]').check();
+    roleSvg()
+      .find('circle.point')
+      .should('have.length', 3)
+      .then(($points) => {
+        const values = [...$points].map(
+          (element) => (element as unknown as { __data__: { y: number } }).__data__.y,
+        );
+        expect(values).to.deep.equal([40, 50, 60]);
+        const center = Number($points[1].getAttribute('cy'));
+        roleSvg()
+          .find('line[stroke-dasharray="5,4"]')
+          .should('have.length', 1)
+          .should(($line) => {
+            expect(Number($line.attr('y1'))).to.be.closeTo(center, 0.5);
+            expect(Number($line.attr('y2'))).to.be.closeTo(center, 0.5);
+          });
+      });
+    checkNoHorizontalOverflow();
+  });
+
+  it('keeps concurrency diagnostic role shares while suppressing equal-service comparisons on mobile', () => {
+    cy.viewport(390, 1000);
+    mountComparison(roles, 'conc');
+    cy.get('[data-testid="equal-service-toggle"]').check();
+    cy.get('[data-testid="equal-service-concurrency-note"]')
+      .should('be.visible')
+      .and('contain.text', 'load diagnostic');
+    cy.get('[data-testid="equal-service-panel"]').should('not.exist');
+    cy.get('[data-testid="role-share-toggle"]').check();
+    roleSvg().find('circle.point').should('have.length', 3);
+    checkNoHorizontalOverflow();
+    cy.get('[data-testid="prefill-share-panel"]').screenshot('prefill-share-mobile', {
+      overwrite: true,
+    });
+  });
+});
diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index adab6f6ac..e152b1285 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -15,6 +15,7 @@ import {
 } from '@/components/inference/utils/powerTimeline';
 import { Model, Precision, Sequence } from '@/lib/data-mappings';
 import { overlayRunColor } from '@/lib/overlay-run-style';
+import { buildShareUrl, readUrlParams, writeUrlParams } from '@/lib/url-state';
 
 import {
   createMockHardwareConfig,
@@ -205,11 +206,80 @@ const svg = () => cy.get('[data-testid="power-timeline-chart-svg"]');
 
 describe('PowerTimeline', () => {
   beforeEach(() => {
+    writeUrlParams({ i_ptaxis: '', i_ptlines: '', i_ptwindow: '', i_ptfocus: '', i_ptutility: '' });
+    readUrlParams();
     cy.on('uncaught:exception', (error) => {
       if (error.message.includes('ResizeObserver loop')) return false;
     });
   });
 
+  it('restores a shared pool view and plots only the validated window from its serving origin', () => {
+    const point = disaggPoint(8, 800);
+    const focus = traceKeyForPoint(point)!;
+    writeUrlParams({
+      i_ptaxis: 'serving',
+      i_ptlines: 'pool',
+      i_ptwindow: 'window',
+      i_ptfocus: focus,
+    });
+    cy.intercept('POST', '/api/gpu-metrics*', { body: poolResponse }).as('series');
+    mountTimeline([point]);
+    cy.wait('@series');
+    cy.get('[data-testid="power-timeline-pools"]').should('have.attr', 'data-state', 'checked');
+    cy.get('[data-testid="power-timeline-window-only"]').should(
+      'have.attr',
+      'data-state',
+      'checked',
+    );
+    cy.get('[data-testid="power-timeline-focus"]').should('contain.text', 'c8');
+    svg().find('path.power-trace[data-segment="full"]').should('not.exist');
+    svg()
+      .find('path.power-trace[data-segment="window"]')
+      .should('have.length', 2)
+      .each(($path) => {
+        const points = ($path[0] as unknown as { __data__: { points: { x: number }[] } }).__data__
+          .points;
+        expect(points[0].x).to.eq(0);
+        expect(points.at(-1)!.x).to.eq(20);
+      });
+    cy.then(() => {
+      const params = new URL(buildShareUrl()).searchParams;
+      expect(params.get('i_ptlines')).to.eq('pool');
+      expect(params.get('i_ptaxis')).to.eq('serving');
+      expect(params.get('i_ptwindow')).to.eq('window');
+      expect(params.get('i_ptfocus')).to.eq(focus);
+    });
+    svg().screenshot('power-timeline-shared-serving-window');
+  });
+
+  it('does not change an explicitly shared per-GPU view to pool mode when focus resolves', () => {
+    const point = disaggPoint(8, 800);
+    writeUrlParams({ i_ptlines: 'gpu', i_ptfocus: traceKeyForPoint(point)! });
+    cy.intercept('POST', '/api/gpu-metrics*', { body: poolResponse }).as('series');
+    mountTimeline([point]);
+    cy.wait('@series');
+    cy.get('[data-testid="power-timeline-per-gpu"]').should('have.attr', 'data-state', 'checked');
+    svg().find('path.power-trace[data-segment="window"]').should('have.length', 8);
+    cy.get('[data-testid="power-timeline-focus-clear"]').click();
+    cy.then(() => expect(new URL(buildShareUrl()).searchParams.has('i_ptfocus')).to.eq(false));
+  });
+
+  it('omits traces without a retained serving window instead of using telemetry start', () => {
+    writeUrlParams({ i_ptaxis: 'serving', i_ptwindow: 'window' });
+    cy.intercept('POST', '/api/gpu-metrics*', { body: response }).as('series');
+    mountTimeline([
+      measuredPoint('b200', 16, 700, {
+        power_audit: { source: `power_validation_${resultName('b200', 16)}.json` },
+      }),
+    ]);
+    cy.wait('@series');
+    cy.get('[data-testid="power-timeline-window-missing"]').should(
+      'contain.text',
+      'no valid serving-window bounds',
+    );
+    svg().find('path.power-trace').should('not.exist');
+  });
+
   it('distinguishes dates when wall-clock traces span multiple days', () => {
     cy.intercept('POST', '/api/gpu-metrics*', {
       body: {
diff --git a/packages/app/cypress/component/quick-filters-dialog.cy.tsx b/packages/app/cypress/component/quick-filters-dialog.cy.tsx
index 7fb249e45..6617c4a43 100644
--- a/packages/app/cypress/component/quick-filters-dialog.cy.tsx
+++ b/packages/app/cypress/component/quick-filters-dialog.cy.tsx
@@ -2,7 +2,9 @@ import { QuickFiltersDialog } from '@/components/inference/ui/QuickFiltersDialog
 import { ActiveQuickFilters } from '@/components/inference/ui/ActiveQuickFilters';
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
 import type { QuickFilters } from '@/components/inference/types';
+import { pointTopologyKey } from '@/components/inference/utils/topology-filter';
 import { Sequence } from '@/lib/data-mappings';
+import { createMockInferenceData } from '../support/mock-data';
 import { mountWithProviders } from '../support/test-utils';
 
 const availableQuickFilters: QuickFilters = {
@@ -14,6 +16,81 @@ const availableQuickFilters: QuickFilters = {
 };
 
 describe('QuickFiltersDialog', () => {
+  for (const width of [390, 1280]) {
+    it(`wraps long topology options without overlap and scrolls to exact selection (${width}px)`, () => {
+      cy.viewport(width, 900);
+      const topologies = Array.from({ length: 12 }, (_, index) =>
+        pointTopologyKey(
+          createMockInferenceData({
+            disagg: true,
+            physicalChips: 8 * (index + 1),
+            num_prefill_gpu: 4 * (index + 1),
+            num_decode_gpu: 4 * (index + 1),
+            prefill_num_workers: index + 1,
+            decode_num_workers: index + 1,
+            prefill_tp: 4,
+            decode_tp: 4,
+            prefill_ep: 1 + (index % 2),
+            decode_ep: 1 + (index % 2),
+            prefill_pp: 1 + (index % 2),
+            decode_pp: 1 + (index % 2),
+            prefill_dcp_size: 1 + (index % 2),
+            decode_dcp_size: 1 + (index % 2),
+            prefill_pcp_size: 1 + (index % 2),
+            decode_pcp_size: 1 + (index % 2),
+            prefill_dp_attention: index % 2 === 0,
+            decode_dp_attention: index % 2 === 0,
+            offload_mode: index % 2 === 0 ? 'off' : 'on',
+          }),
+        ),
+      );
+      mountWithProviders(<QuickFiltersDialog open onOpenChange={cy.stub()} />, {
+        inference: { availableQuickFilters: { ...availableQuickFilters, topologies } },
+      });
+
+      cy.get('[data-testid="quick-filter-topology-options"]')
+        .scrollIntoView()
+        .should(($options) => {
+          const options = $options[0];
+          expect(options.scrollHeight).to.be.greaterThan(options.clientHeight);
+          expect(options.scrollWidth).to.be.at.most(options.clientWidth + 1);
+          const buttons = [...options.querySelectorAll('button')];
+          const bounds = buttons.map((button) => button.getBoundingClientRect());
+          expect(bounds[0].height, 'fixture exercises a multiline label').to.be.greaterThan(32);
+          buttons.forEach((button, index) => {
+            const range = button.ownerDocument.createRange();
+            range.selectNodeContents(button);
+            const text = range.getBoundingClientRect();
+            expect(text.top, 'label stays inside button').to.be.at.least(bounds[index].top - 1);
+            expect(text.bottom).to.be.at.most(bounds[index].bottom + 1);
+            expect(text.left).to.be.at.least(bounds[index].left - 1);
+            expect(text.right).to.be.at.most(bounds[index].right + 1);
+            for (const other of bounds.slice(index + 1)) {
+              const overlapX =
+                Math.min(bounds[index].right, other.right) -
+                Math.max(bounds[index].left, other.left);
+              const overlapY =
+                Math.min(bounds[index].bottom, other.bottom) -
+                Math.max(bounds[index].top, other.top);
+              expect(overlapX > 1 && overlapY > 1, 'topology buttons do not overlap').to.equal(
+                false,
+              );
+            }
+          });
+        })
+        .scrollTo('bottom')
+        .should(($options) => expect($options[0].scrollTop).to.be.greaterThan(0))
+        .find('button')
+        .last()
+        .should('be.visible')
+        .click();
+      cy.get('@setQuickFilterTopologies').should('have.been.calledOnceWith', [topologies.at(-1)!]);
+      cy.get('[data-testid="quick-filters-dialog"]')
+        .scrollTo('bottom')
+        .screenshot(`topology-options-${width}`, { overwrite: true });
+    });
+  }
+
   for (const locale of ['en', 'zh'] as const) {
     for (const width of [390, 1280]) {
       it(`explains every filter on hover without changing selections (${locale}, ${width}px)`, () => {
diff --git a/packages/app/cypress/component/scatter-graph.cy.tsx b/packages/app/cypress/component/scatter-graph.cy.tsx
index 71dbdfca2..b45cb77d5 100644
--- a/packages/app/cypress/component/scatter-graph.cy.tsx
+++ b/packages/app/cypress/component/scatter-graph.cy.tsx
@@ -45,6 +45,58 @@ const threePointCurve = (hwKey: string, ys: number[], extra: Partial<{ run_url:
   );
 
 describe('ScatterGraph', () => {
+  it('retains the explicit observed-concurrency sweep without frontier or ruler controls', () => {
+    const data = [1, 4, 128].map((conc, index) =>
+      createMockInferenceData({
+        id: 9000 + index,
+        hwKey: 'h100',
+        precision: Precision.FP4,
+        conc,
+        x: conc,
+        y: [500, 600, 470][index],
+        run_url: 'https://github.com/org/repo/actions/runs/123',
+      }),
+    );
+    mountWithProviders(
+      <div style={{ width: 1000 }}>
+        <ScatterGraph
+          chartId="observed-load-test"
+          modelLabel="DeepSeek R1"
+          data={data}
+          xLabel="Concurrency"
+          yLabel="Throughput / Chip (tok/s)"
+          chartDefinition={createMockChartDefinition({ x: 'conc' })}
+          transitionDuration={0}
+        />
+      </div>,
+      {
+        inference: {
+          activeHwTypes: new Set(['h100']),
+          hwTypesWithData: new Set(['h100']),
+          selectedXAxisMode: 'concurrency',
+          hideNonOptimal: true,
+          showParetoFrontier: true,
+          hardwareConfig: hwConfig,
+        },
+        unofficial: {},
+      },
+    );
+    cy.get('#observed-load-test .dot-group')
+      .should('have.length', 3)
+      .each(($point) => {
+        cy.wrap($point).should('have.css', 'opacity', '1');
+      });
+    cy.get('#observed-load-test path[data-curve-kind="observed-load"]')
+      .should('have.length', 1)
+      .invoke('attr', 'd')
+      .should('not.match', /[CQ]/u);
+    expandLegendAdvanced();
+    cy.get(
+      '#scatter-hide-non-optimal, #scatter-perf-ruler, #observed-load-test-pareto-frontier',
+    ).should('not.exist');
+    cy.get('.global-pareto-frontier').should('not.exist');
+  });
+
   it('keeps the frontier modes and overlay winners without exposing the retired hinterland', () => {
     const official = [
       createMockInferenceData({ hwKey: 'h100', precision: Precision.FP8, x: 20, y: 80 }),
diff --git a/packages/app/cypress/e2e/inference-chart.cy.ts b/packages/app/cypress/e2e/inference-chart.cy.ts
index bd8946401..983c9ff42 100644
--- a/packages/app/cypress/e2e/inference-chart.cy.ts
+++ b/packages/app/cypress/e2e/inference-chart.cy.ts
@@ -1,3 +1,5 @@
+import type { InferenceData } from '@/components/inference/types';
+import { expandLegendAdvanced } from '../support/legend-advanced';
 import {
   interceptVrPublicationData,
   VR_FIXTURE_DATE,
@@ -107,11 +109,14 @@ function assertVisibleMeasuredValues(selector: string, expected: number[]) {
 
 describe('Inference Chart', () => {
   before(() => {
+    cy.intercept('GET', '/api/v1/availability').as('chartAvailability');
+    cy.intercept('GET', '/api/v1/benchmarks*').as('chartBenchmarks');
     cy.viewport(1440, 900);
     cy.window().then((win) => {
       win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
     });
     cy.visit('/inference');
+    cy.wait(['@chartAvailability', '@chartBenchmarks']);
   });
 
   it('renders the inference chart display wrapper', () => {
@@ -581,6 +586,8 @@ describe('AgentX replaces a complete curve while preserving an unofficial compar
 });
 
 it('hydrates a direct PowerX metric link and shows availability for the selected workload', () => {
+  cy.intercept('GET', '/api/v1/availability').as('powerLinkAvailability');
+  cy.intercept('GET', '/api/v1/benchmarks*').as('powerLinkBenchmarks');
   cy.viewport(1440, 900);
   cy.visit('/inference/qwen-3-5?i_seq=8k%2F1k&i_prec=fp8&i_metric=y_measuredPowerPercentTdp', {
     onBeforeLoad(win) {
@@ -589,6 +596,7 @@ it('hydrates a direct PowerX metric link and shows availability for the selected
       cy.spy(win.console, 'error').as('powerLinkConsoleErrors');
     },
   });
+  cy.wait(['@powerLinkAvailability', '@powerLinkBenchmarks']);
   cy.get('[data-testid="yaxis-metric-selector"]').should('contain', 'Measured Power');
   cy.get('[data-testid="measured-power-display"]').should('contain', 'TDP');
   cy.get('[data-testid="measured-power-statistic-average"]').should(
@@ -826,3 +834,201 @@ describe('VR default date preference', () => {
     assertVrDate(VR_LATEST_FIXTURE_DATE);
   });
 });
+
+const withTp4 = (rows: ReturnType<typeof boundaryRows>) => [
+  ...rows,
+  ...rows.map((row) => ({
+    ...row,
+    id: row.id + 10000,
+    prefill_tp: 4,
+    decode_tp: 4,
+    num_prefill_gpu: 4,
+    num_decode_gpu: 4,
+  })),
+];
+
+const assertObservedLoads = (expected: number[]) => {
+  for (const selector of ['.dot-group', '.unofficial-overlay-pt']) {
+    cy.get<SVGElement & { __data__: InferenceData }>(
+      `[data-testid="inference-chart-display"] svg ${selector}`,
+    ).should(($points) => {
+      expect($points).to.have.length(expected.length);
+      expect([...$points].map((element) => element.__data__.x).sort((a, b) => a - b)).to.deep.equal(
+        expected,
+      );
+      for (const element of $points) expect(getComputedStyle(element).opacity).to.equal('1');
+    });
+  }
+};
+
+describe('Observed concurrency and exact topology', () => {
+  for (const locale of ['en', 'zh'] as const) {
+    it(`preserves official and overlay loads, topology and share state in ${locale}`, () => {
+      const officialRun = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/800001';
+      const officialBase = boundaryRows(null).map((row) => ({ ...row, run_url: officialRun }));
+      const overlayBase = boundaryRows(OVERLAY_RUN_URL);
+      interceptMeasuredComparison(withTp4(officialBase), withTp4(overlayBase));
+      cy.viewport(1440, 900);
+      cy.visit(
+        `${locale === 'zh' ? '/zh' : ''}/inference?g_model=DeepSeek-V4-Pro&unofficialrun=${OVERLAY_RUN_ID}&i_seq=1k%2F1k&i_prec=fp4&i_metric=y_measuredAvgPower&i_xmode=concurrency&i_optimal=1&i_best=1`,
+        { onBeforeLoad: unlockAgenticGate },
+      );
+      cy.wait('@measuredOverlay');
+      cy.get('[data-testid="x-axis-mode-selector"]')
+        .should('have.attr', 'data-value', 'concurrency')
+        .and('contain.text', locale === 'zh' ? '并发数' : 'Concurrency');
+      cy.get('[data-testid="chart-figure"] h2').should(
+        'contain.text',
+        locale === 'zh' ? '与并发数的关系' : 'vs. Concurrency',
+      );
+
+      assertObservedLoads([1, 1, 2, 2, 8, 8, 48, 48]);
+      cy.get<SVGPathElement & { __data__: { points: InferenceData[] } }>(
+        '[data-testid="inference-chart-display"] path[data-curve-kind="observed-load"]',
+      )
+        .should('have.length', 4)
+        .and(($curves) => {
+          for (const curve of $curves) {
+            expect(new Set(curve.__data__.points.map((point) => point.tp)).size).to.equal(1);
+            expect(curve.__data__.points.map((point) => point.x)).to.deep.equal([1, 2, 8, 48]);
+            expect(curve.getAttribute('d')).to.be.a('string').and.not.match(/[CQ]/u);
+          }
+        });
+      expandLegendAdvanced();
+      cy.get('#scatter-hide-non-optimal, #scatter-perf-ruler, #chart-0-pareto-frontier').should(
+        'not.exist',
+      );
+      cy.get('[data-testid="scatter-quick-filters"]').click();
+      cy.get('[data-testid="quick-filter-best-per-sku"]').should('not.exist');
+      cy.get('[data-testid="quick-filter-topology-options"] button').should('have.length', 2);
+      cy.contains('[data-testid="quick-filter-topology-options"] button', /GPU=?4.*TP=?4/u).click();
+      cy.get('body').type('{esc}');
+      cy.get('[data-testid="quick-filters-dialog"]').should('not.exist');
+      assertObservedLoads([1, 2, 8, 48]);
+      cy.get('[data-testid="chart-figure"]')
+        .first()
+        .screenshot(`powerx-concurrency-${locale}-desktop`);
+      cy.viewport(390, 844);
+      assertObservedLoads([1, 2, 8, 48]);
+      expectNoPageOverflow();
+      cy.get('[data-testid="chart-figure"]')
+        .first()
+        .screenshot(`powerx-concurrency-${locale}-mobile`);
+      cy.viewport(1440, 900);
+      // The address bar stays clean: Share flushes the in-memory filter state.
+      cy.get('[data-testid="share-button"]').first().click();
+      cy.get('[data-testid="share-url-input"]')
+        .invoke('val')
+        .should((value) => {
+          const params = new URL(String(value)).searchParams;
+          expect(params.get('i_xmode')).to.equal('concurrency');
+          expect(params.get('i_topology')).to.include('GPU=4');
+        })
+        .then((value) => {
+          const shared = new URL(String(value));
+          cy.visit(`${shared.pathname}${shared.search}`, { onBeforeLoad: unlockAgenticGate });
+        });
+      cy.wait('@measuredOverlay');
+      assertObservedLoads([1, 2, 8, 48]);
+      cy.get('[data-testid="x-axis-mode-selector"]').should(
+        'have.attr',
+        'data-value',
+        'concurrency',
+      );
+      selectXAxisMode('interactivity');
+      cy.get(
+        '[data-testid="inference-chart-display"] svg path[data-curve-kind="observed-load"]',
+      ).should('not.exist');
+      cy.get('#scatter-hide-non-optimal').should('exist');
+      cy.get<SVGElement & { __data__: InferenceData }>(
+        '[data-testid="inference-chart-display"] svg .dot-group',
+      ).should(($points) => {
+        expect(
+          [...$points].map((element) => element.__data__.x).sort((a, b) => a - b),
+        ).to.deep.equal([10.6, 68.5, 111.1, 130.2]);
+      });
+      selectXAxisMode('concurrency', locale === 'zh' ? '并发数' : 'Concurrency');
+      assertObservedLoads([1, 2, 8, 48]);
+      cy.get('#scatter-hide-non-optimal, #scatter-perf-ruler').should('not.exist');
+      cy.get('[data-testid="inference-view-toggle-0"]')
+        .contains(locale === 'zh' ? '表格' : 'Table')
+        .click();
+      cy.get('[data-testid="inference-results-table"] tbody tr').should('have.length', 8);
+      cy.get('[data-testid="inference-results-table"]').should(
+        'contain.text',
+        locale === 'zh' ? '并发数' : 'Concurrency',
+      );
+    });
+  }
+});
+
+describe('Fixed-sequence service statistics', () => {
+  for (const locale of ['en', 'zh'] as const) {
+    it(`shares mean TPOT-derived speed and switches statistics on desktop/mobile in ${locale}`, () => {
+      const withMeans = (runUrl: string | null) =>
+        measuredRows(runUrl).map((row, index) => ({
+          ...row,
+          metrics: {
+            ...row.metrics,
+            mean_intvty: 999,
+            ...(index < 3
+              ? {
+                  mean_tpot: 1 / [20, 40, 80][index],
+                  mean_ttft: [1, 2, 4][index],
+                  mean_e2el: [10, 20, 40][index],
+                }
+              : {}),
+          },
+        }));
+      const official = withMeans(null);
+      interceptMeasuredComparison(official, withMeans(OVERLAY_RUN_URL));
+      cy.viewport(1440, 900);
+      cy.visit(
+        `${locale === 'zh' ? '/zh' : ''}/inference?g_model=DeepSeek-V4-Pro&unofficialrun=${OVERLAY_RUN_ID}&i_seq=1k%2F1k&i_prec=fp4&i_metric=y_measuredAvgPower&i_xmode=interactivity&i_mstat=mean&i_optimal=0&i_best=0`,
+        { onBeforeLoad: unlockAgenticGate },
+      );
+      cy.wait('@measuredOverlay');
+      cy.get('[data-testid="fixed-sequence-statistic-selector"]')
+        .should('have.attr', 'data-value', 'mean')
+        .and('contain.text', locale === 'zh' ? '平均值' : 'Mean');
+      cy.get('[data-testid="chart-figure"] h2').should(
+        'contain.text',
+        locale === 'zh' ? '平均交互性' : 'Mean Interactivity',
+      );
+      assertObservedLoads([20, 40, 80]);
+      cy.get('[data-testid="fixed-sequence-statistic-selector"]').click();
+      cy.get('[data-testid="fixed-sequence-statistic-median"]').click();
+      assertObservedLoads(
+        singleTurnRows(null)
+          .map((row) => row.metrics.median_intvty)
+          .sort((a, b) => a - b),
+      );
+      cy.viewport(390, 844);
+      selectXAxisMode('interactivity');
+      cy.get('[data-testid="fixed-sequence-statistic-selector"]').click();
+      cy.get('[data-testid="fixed-sequence-statistic-mean"]').click();
+      assertObservedLoads([20, 40, 80]);
+      expectNoPageOverflow();
+      cy.viewport(1440, 900);
+      selectXAxisMode('ttft');
+      assertObservedLoads([1, 2, 4]);
+      selectXAxisMode('e2e');
+      assertObservedLoads([10, 20, 40]);
+      cy.get('[data-testid="share-button"]').first().click();
+      cy.get('[data-testid="share-url-input"]')
+        .invoke('val')
+        .then((value) => {
+          const shared = new URL(String(value));
+          expect(shared.searchParams.get('i_mstat')).to.equal('mean');
+          cy.visit(`${shared.pathname}${shared.search}`, { onBeforeLoad: unlockAgenticGate });
+        });
+      cy.wait('@measuredOverlay');
+      assertObservedLoads([10, 20, 40]);
+      // Click the chevron, away from the label's separate help button and sticky header.
+      cy.get('[data-testid="x-axis-mode-selector"]').click('right', { scrollBehavior: 'center' });
+      cy.get('[data-testid="x-axis-mode-concurrency"]').click();
+      cy.get('[data-testid="fixed-sequence-statistic-selector"]').should('not.exist');
+      assertObservedLoads(official.map((row) => row.conc).sort((a, b) => a - b));
+    });
+  }
+});
diff --git a/packages/app/cypress/e2e/powerx-timeline.cy.ts b/packages/app/cypress/e2e/powerx-timeline.cy.ts
index 5e2267dec..00fcabd6b 100644
--- a/packages/app/cypress/e2e/powerx-timeline.cy.ts
+++ b/packages/app/cypress/e2e/powerx-timeline.cy.ts
@@ -1,4 +1,4 @@
-import { assertShareLinkMetric } from '../support/share-link';
+import { assertShareLinkMetric, assertShareLinkParams } from '../support/share-link';
 
 // The Measured Power "Timeline" display (`y_measuredPowerTimeline`) inside the
 // gated Measured Energy group. Deterministic intercepted rows carry validated
@@ -213,6 +213,33 @@ describe('PowerX measured power timeline', () => {
     });
   });
 
+  it('restores the shared serving-window view and focus on an unofficial trace', () => {
+    interceptOverlay();
+    const focus = `${OVERLAY_RUN_ID}:${resultName('h200', 64)}`;
+    visitChart({
+      extraParams: `&i_metric=y_measuredPowerTimeline&unofficialrun=${OVERLAY_RUN_ID}&i_ptaxis=serving&i_ptlines=gpu&i_ptwindow=window&i_ptfocus=${encodeURIComponent(focus)}`,
+    });
+    cy.wait(['@series', '@unofficialRun', '@overlaySeries']);
+    cy.get('[data-testid="power-timeline-focus"]').should('contain.text', 'c64');
+    cy.get('[data-testid="power-timeline-per-gpu"]').should('have.attr', 'data-state', 'checked');
+    cy.get('[data-testid="power-timeline-window-only"]').should(
+      'have.attr',
+      'data-state',
+      'checked',
+    );
+    cy.get('path.power-trace[data-segment="full"]').should('not.exist');
+    cy.get('path.power-trace[data-run-index="0"][data-segment="window"]').should('exist');
+    assertShareLinkParams({
+      i_metric: 'y_measuredPowerTimeline',
+      i_ptaxis: 'serving',
+      i_ptlines: 'gpu',
+      i_ptwindow: 'window',
+      i_ptfocus: focus,
+    });
+    cy.get('[data-testid="power-timeline-focus-clear"]').click();
+    assertShareLinkParams({ i_ptfocus: null, i_ptlines: 'gpu', i_ptwindow: 'window' });
+  });
+
   it('switches the Display control to Timeline and renders the per-second traces', () => {
     visitChart({ extraParams: '&i_metric=y_measuredAvgPower' });
     cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
diff --git a/packages/app/cypress/support/e2e.ts b/packages/app/cypress/support/e2e.ts
index 17f3f55c2..48a6c72c1 100644
--- a/packages/app/cypress/support/e2e.ts
+++ b/packages/app/cypress/support/e2e.ts
@@ -164,7 +164,7 @@ export function openXAxisMenu(): void {
 
 /** Select an axis and verify that the single-select menu closes immediately. */
 export function selectXAxisMode(
-  mode: 'interactivity' | 'e2e' | 'ttft' | 'e2e-normalized-interactivity',
+  mode: 'interactivity' | 'e2e' | 'ttft' | 'e2e-normalized-interactivity' | 'concurrency',
   label?: string,
 ): void {
   openXAxisMenu();
diff --git a/packages/app/cypress/support/mock-data.ts b/packages/app/cypress/support/mock-data.ts
index 733d04e49..5fffbf9f2 100644
--- a/packages/app/cypress/support/mock-data.ts
+++ b/packages/app/cypress/support/mock-data.ts
@@ -91,11 +91,13 @@ export function createMockHardwareConfig(): HardwareConfig {
 // ---------------------------------------------------------------------------
 
 export function createMockChartDefinition(overrides?: Partial<ChartDefinition>): ChartDefinition {
+  const chartType = overrides?.chartType ?? 'e2e';
+  const x = overrides?.x ?? (chartType === 'interactivity' ? 'median_intvty' : 'median_e2el');
   return {
-    chartType: 'e2e',
+    chartType,
     heading: 'End-to-End Latency vs Throughput',
-    x: 'conc' as keyof AggDataEntry,
-    x_label: 'Concurrency',
+    x,
+    x_label: chartType === 'interactivity' ? 'Interactivity' : 'End-to-end Latency (s)',
     y: 'mean_e2el' as keyof AggDataEntry,
     y_label: 'Mean E2E Latency (ms)',
     y_tpPerGpu: 'tput_per_gpu',
@@ -103,8 +105,9 @@ export function createMockChartDefinition(overrides?: Partial<ChartDefinition>):
     y_tpPerGpu_title: 'Throughput per Chip',
     y_tpPerGpu_roofline: 'upper_right',
     ...overrides,
-    x_scale_field: overrides?.x_scale_field ?? String(overrides?.x ?? 'conc'),
-    x_labelZh: overrides?.x_labelZh ?? '并发数',
+    x_scale_field: overrides?.x_scale_field ?? String(x),
+    x_labelZh:
+      overrides?.x_labelZh ?? (chartType === 'interactivity' ? '交互性' : '端到端延迟（s）'),
   };
 }
 
@@ -224,6 +227,8 @@ export function createMockInferenceContextValues(
     openRouterPricingError: null,
     setTokenRevenuePriceSource: namedStub('setTokenRevenuePriceSource'),
     selectedPercentile: 'p90',
+    fixedSequenceStatistic: 'median',
+    setFixedSequenceStatistic: namedStub('setFixedSequenceStatistic'),
     setSelectedPercentile: namedStub('setSelectedPercentile'),
     selectedXAxisMetric: null,
     setSelectedXAxisMetric: namedStub('setSelectedXAxisMetric'),
@@ -241,6 +246,7 @@ export function createMockInferenceContextValues(
     setQuickFilterDeployment: namedStub('setQuickFilterDeployment'),
     setQuickFilterSpec: namedStub('setQuickFilterSpec'),
     setQuickFilterPower: namedStub('setQuickFilterPower'),
+    setQuickFilterTopologies: namedStub('setQuickFilterTopologies'),
     isLegendExpanded: true,
     setIsLegendExpanded: namedStub('setIsLegendExpanded'),
     hideNonOptimal: false,
diff --git a/packages/app/src/app/api/v1/views/inference/route.test.ts b/packages/app/src/app/api/v1/views/inference/route.test.ts
index ae78ce0f3..3bfb6ea21 100644
--- a/packages/app/src/app/api/v1/views/inference/route.test.ts
+++ b/packages/app/src/app/api/v1/views/inference/route.test.ts
@@ -1,6 +1,12 @@
 import { NextRequest } from 'next/server';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
+import {
+  buildEqualServiceComparison,
+  getEqualServiceSources,
+} from '@/components/inference/utils/equal-service-comparison';
+import { buildInferenceSeries } from '@/lib/views-api/series';
+import { Sequence } from '@/lib/data-mappings';
 import type { BenchmarkRow } from '@/lib/api';
 
 const { mockGetLatestBenchmarks, mockGetBenchmarksForRun, mockUnofficialRun, mockGetDb } =
@@ -96,6 +102,211 @@ beforeEach(() => {
 });
 
 describe('GET /api/v1/views/inference', () => {
+  it('calculates equal-service panels from observed points before frontier pruning with endpoint provenance', async () => {
+    const rows = ['h200', 'mi300x'].flatMap((hardware, index) =>
+      [20, 60].map((x, position) =>
+        makeRow({
+          hardware,
+          conc: position + 1,
+          metrics: {
+            ...makeRow().metrics,
+            median_intvty: x,
+            avg_power_w: 200 + 200 * position + 50 * index,
+            output_tput_per_gpu: 100 + 100 * position + 50 * index,
+            joules_per_output_token: 4 - 2 * position - index,
+            power_valid: 1,
+            power_metric_schema_version: 2,
+          },
+        }),
+      ),
+    );
+    mockGetLatestBenchmarks.mockResolvedValue(rows);
+    const projected = buildInferenceSeries(rows, {
+      sequence: Sequence.EightK_OneK,
+      percentile: 'p90',
+      precisions: ['fp8'],
+      metricConfigKey: 'y_measuredAvgPower',
+      xmode: 'interactivity',
+      xmetric: 'p90_ttft',
+      gpus: [],
+      quickFilters: { vendors: [], frameworks: [], deployment: [], spec: [], power: [] },
+      optimal: true,
+      best: true,
+    });
+    const sources = getEqualServiceSources(projected.observedPoints);
+    const expected = buildEqualServiceComparison(projected.observedPoints, {
+      baseline: sources[0].key,
+      comparator: sources[1].key,
+      target: 40,
+      xField: 'median_intvty',
+    });
+    const response = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=measuredAvgPower&serviceCompare=true&serviceTarget=40',
+      ),
+    );
+    const body = await response.json();
+    expect(response.status).toBe(200);
+    expect(body.serviceSources).toEqual(sources);
+    expect(body.equalServiceComparison.metrics.meanWattsPerGpu.changePercent).toBeCloseTo(100 / 6);
+    expect(body.equalServiceComparison.metrics.outputTokensPerSecond.changePercent).toBeCloseTo(
+      100 / 3,
+    );
+    expect(body.equalServiceComparison.metrics.joulesPerOutputToken.changePercent).toBeCloseTo(
+      -100 / 3,
+    );
+    for (const [metric, values] of Object.entries(expected.metrics)) {
+      expect(body.equalServiceComparison.metrics[metric].changePercent).toBe(values.changePercent);
+      expect(body.equalServiceComparison.metrics[metric].baseline.value).toBe(
+        values.baseline?.value,
+      );
+    }
+    expect(
+      body.equalServiceComparison.metrics.meanWattsPerGpu.baseline.endpoints.map(
+        (endpoint: { point: { id: number } }) => endpoint.point.id,
+      ),
+    ).toEqual(rows.slice(0, 2).map((row) => row.id));
+    expect(
+      body.equalServiceComparison.metrics.meanWattsPerGpu.baseline.endpoints[0].point.runUrl,
+    ).toBe(rows[0].run_url);
+    expect(body).not.toHaveProperty('observedPoints');
+    expect(body.equalServiceCurve).toHaveLength(2);
+  });
+
+  it('preserves explicit unavailable sources, omits target by default and rejects unsupported CSV panels', async () => {
+    const response = await GET(
+      request('/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&serviceCompare=true'),
+    );
+    const responseBody = await response.json();
+    expect(responseBody.equalServiceComparison).toBeNull();
+    const stale = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&serviceCompare=true&serviceBaseline=missing&serviceTarget=40',
+      ),
+    );
+    const body = await stale.json();
+    expect(body.params.serviceBaseline).toBe('missing');
+    expect(body.equalServiceComparison.reason).toBe('unknown-source');
+    const diagnostic = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&serviceCompare=true&serviceTarget=40&xmode=concurrency',
+      ),
+    );
+    const diagnosticBody = await diagnostic.json();
+    expect(diagnosticBody.equalServiceComparison.reason).toBe('unsupported-axis');
+    for (const extra of [
+      'format=csv&serviceCompare=true',
+      'format=csv&roleShare=true',
+      'serviceTarget=0',
+      'serviceTarget=',
+      'serviceTarget=NaN',
+    ]) {
+      const invalid = await GET(request(`/api/v1/views/inference?model=DeepSeek-R1-0528&${extra}`));
+      expect(invalid.status).toBe(400);
+    }
+  });
+
+  it('includes unofficial sources and validated role shares using one output-token denominator', async () => {
+    const row = makeRow({
+      hardware: 'gb200',
+      framework: 'trt',
+      disagg: true,
+      num_prefill_gpu: 4,
+      num_decode_gpu: 4,
+      prefill_num_workers: 1,
+      decode_num_workers: 1,
+      metrics: {
+        ...makeRow().metrics,
+        avg_power_w: 400,
+        power_valid: 1,
+        power_metric_schema_version: 2,
+        joules_per_input_token: 1,
+        joules_per_output_token: 8,
+        prefill_joules_per_input_token: 0.4,
+        decode_joules_per_output_token: 4.8,
+      },
+    });
+    mockGetLatestBenchmarks.mockResolvedValue([row]);
+    mockUnofficialRun.mockImplementation(() =>
+      Response.json({
+        benchmarks: [{ ...row, id: 999, run_url: 'https://github.com/org/repo/actions/runs/999' }],
+        evaluations: [],
+      }),
+    );
+    const response = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=measuredAvgPower&serviceCompare=true&roleShare=true&unofficialrun=999',
+      ),
+    );
+    const body = await response.json();
+    expect(response.status).toBe(200);
+    expect(body.serviceSources).toHaveLength(2);
+    expect(body.roleEnergyShares).toHaveLength(2);
+    expect(
+      body.roleEnergyShares
+        .map((item: { point: { id: number } }) => item.point.id)
+        .sort((a: number, b: number) => a - b),
+    ).toEqual([row.id, 999].sort((a, b) => a - b));
+    for (const share of body.roleEnergyShares) {
+      expect(share).toMatchObject({
+        prefill: 3.2,
+        decode: 4.8,
+        total: 8,
+        prefillShare: 40,
+        decodeShare: 60,
+      });
+    }
+    expect(body.overlays[0]).not.toHaveProperty('observedPoints');
+  });
+
+  it('resolves the fixed-sequence statistic and rejects unknown values', async () => {
+    mockGetLatestBenchmarks.mockResolvedValue([
+      makeRow({ metrics: { ...makeRow().metrics, mean_tpot: 0.025, mean_intvty: 99 } }),
+    ]);
+    const response = await GET(
+      request('/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&xstat=mean'),
+    );
+    const body = await response.json();
+    expect(body.params.xstat).toBe('mean');
+    expect(body.xAxis).toMatchObject({ field: 'mean_tpot_intvty', statistic: 'mean' });
+    expect(body.series[0].points[0].x).toBe(40);
+    const diagnostic = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&xstat=mean&xmode=concurrency',
+      ),
+    );
+    const diagnosticBody = await diagnostic.json();
+    expect(diagnosticBody.params.xstat).toBeNull();
+    expect(diagnosticBody.xAxis.statistic).toBeNull();
+    const invalid = await GET(
+      request('/api/v1/views/inference?model=DeepSeek-R1-0528&xstat=average'),
+    );
+    expect(invalid.status).toBe(400);
+    const invalidBody = await invalid.json();
+    expect(invalidBody.param).toBe('xstat');
+  });
+
+  it('keeps AgentX percentile selection independent of fixed-sequence xstat', async () => {
+    mockGetLatestBenchmarks.mockResolvedValue([
+      makeRow({
+        benchmark_type: 'agentic_traces',
+        isl: null,
+        osl: null,
+        metrics: { ...makeRow().metrics, p75_itl: 1 / 35, mean_tpot: 0.025 },
+      }),
+    ]);
+    const response = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&sequence=agentic&metric=tpPerGpu&xstat=mean&percentile=p75',
+      ),
+    );
+    const body = await response.json();
+    expect(response.status).toBe(200);
+    expect(body.params.xstat).toBeNull();
+    expect(body.xAxis).toMatchObject({ field: 'p75_intvty', statistic: 'p75' });
+    expect(body.series[0].points[0].x).toBe(35);
+  });
+
   it('returns chart-ready series with resolved params for the default selection', async () => {
     const res = await GET(
       request('/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu'),
@@ -242,6 +453,54 @@ describe('GET /api/v1/views/inference', () => {
     expect(body.series[0].gpu).toBe('mi300x');
   });
 
+  it('discovers exact topology keys and retains every observed concurrency in that topology', async () => {
+    const discover = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&xmode=concurrency&optimal=true&best=true',
+      ),
+    );
+    const initial = await discover.json();
+    const key = initial.series[0].points[0].topologyKey;
+    expect(typeof key).toBe('string');
+    const otherTopology = makeRow({
+      decode_tp: 4,
+      num_decode_gpu: 4,
+      num_prefill_gpu: 4,
+      conc: 128,
+    });
+    mockGetLatestBenchmarks.mockResolvedValue([...ROWS, otherTopology]);
+    const query = new URLSearchParams({
+      model: 'DeepSeek-R1-0528',
+      metric: 'tpPerGpu',
+      xmode: 'concurrency',
+      optimal: 'true',
+      best: 'true',
+      topologies: key,
+    });
+    const response = await GET(request(`/api/v1/views/inference?${query}`));
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body.params).toMatchObject({ optimal: false, best: false, topologies: [key] });
+    expect(body.xAxis).toMatchObject({ mode: 'concurrency', field: 'conc' });
+    expect(body.frontier).toEqual({ direction: null, points: 0 });
+    expect(body.count).toBe(3);
+    const points = body.series.flatMap(
+      (series: { points: { x: number; concurrency: number; topologyKey: string }[] }) =>
+        series.points,
+    );
+    expect(
+      points.map((point: { x: number }) => point.x).sort((a: number, b: number) => a - b),
+    ).toEqual([16, 32, 64]);
+    for (const point of points) {
+      expect(point.x).toBe(point.concurrency);
+      expect(point.topologyKey).toBe(key);
+    }
+    query.set('topologies', 'unavailable-topology');
+    const missing = await GET(request(`/api/v1/views/inference?${query}`));
+    const missingBody = await missing.json();
+    expect(missingBody.count).toBe(0);
+  });
+
   it('case-folds the gpus filter: uppercase base keys select the same series', async () => {
     const upperRes = await GET(
       request('/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&gpus=MI300X'),
diff --git a/packages/app/src/app/api/v1/views/inference/route.ts b/packages/app/src/app/api/v1/views/inference/route.ts
index 14c3f61a1..a8a54f817 100644
--- a/packages/app/src/app/api/v1/views/inference/route.ts
+++ b/packages/app/src/app/api/v1/views/inference/route.ts
@@ -1,7 +1,21 @@
 import { GET as derived } from '@/app/api/v1/derived-agentic-metrics/route';
 import { preferVrDefaultRun, VR_DEFAULT_RUN } from '@/components/inference/default-run-preference';
 import { NORMALIZED_TOKEN_REVENUE_PRICING } from '@/components/inference/token-revenue';
-import type { TokenRevenuePricing } from '@/components/inference/types';
+import {
+  buildEqualServiceComparison,
+  equalServiceSourceKey,
+  getEqualServiceComparisonCurve,
+  getEqualServiceSources,
+  getPrefillSharePoints,
+  type EqualServiceComparison,
+  type EqualServiceEstimate,
+} from '@/components/inference/utils/equal-service-comparison';
+import { pointTopologyKey } from '@/components/inference/utils/topology-filter';
+import type {
+  InferenceData,
+  AggDataEntry,
+  TokenRevenuePricing,
+} from '@/components/inference/types';
 import type { DerivedAgenticMetricMap } from '@/hooks/api/use-derived-agentic-metrics';
 import { fetchOpenRouterPricing } from '@/hooks/api/use-openrouter-pricing';
 import type { TcoBasis } from '@/lib/constants';
@@ -16,6 +30,7 @@ import {
 import { ViewsApiParamError, runViewsRoute } from '@/lib/views-api/errors';
 import {
   parseNumberMap,
+  parseNumberParam,
   validateParams as validateViewParams,
   parseBoolParam,
   parseDateParam,
@@ -91,6 +106,7 @@ interface InferenceViewParams {
   readonly precisionsExplicit: boolean;
   readonly metric: string;
   readonly xmode: SeriesXMode;
+  readonly xstat: 'mean' | 'median';
   readonly xmetric: string;
   readonly percentile: string;
   readonly date?: string;
@@ -105,6 +121,7 @@ interface InferenceViewParams {
   readonly best: boolean;
   readonly tcoBasis: TcoBasis;
   readonly power: readonly ('certified' | 'legacy')[];
+  readonly topologies: readonly string[];
   readonly allPoints: boolean;
   readonly userCosts: Record<string, number>;
   readonly userPowers: Record<string, number>;
@@ -146,6 +163,7 @@ function buildView(
     precisions: resolvedPrecisions,
     metricConfigKey: parseMetricParam(params.metric),
     xmode: params.xmode,
+    fixedSequenceStatistic: params.xstat,
     xmetric: params.xmetric,
     gpus: params.gpus,
     quickFilters: {
@@ -156,6 +174,7 @@ function buildView(
       // Measured-power tier pills are a dashboard-only affordance; the API
       // returns every row regardless of power certification, like the default view.
       power: [...params.power],
+      topologies: [...params.topologies],
     },
     optimal: params.optimal,
     best: params.best,
@@ -170,7 +189,7 @@ function buildView(
   return { resolvedPrecisions, result };
 }
 
-function csvRows(data: InferenceViewData) {
+function csvRows(data: { result: Pick<InferenceSeriesResult, 'series'> }) {
   return data.result.series.flatMap((entry) =>
     entry.points.map((point) => ({
       hwKey: entry.hwKey,
@@ -184,6 +203,7 @@ function csvRows(data: InferenceViewData) {
       x: point.x,
       y: point.y,
       concurrency: point.concurrency,
+      topologyKey: point.topologyKey,
       tp: point.tp,
       date: point.date,
       runId: point.runId ?? '',
@@ -196,6 +216,44 @@ function csvRows(data: InferenceViewData) {
   );
 }
 
+/** Keep public endpoint provenance without serializing internal chart objects. */
+function observedPointIdentity(point: InferenceData) {
+  return {
+    id: point.id ?? null,
+    sourceKey: equalServiceSourceKey(point),
+    hwKey: point.hwKey,
+    precision: point.precision,
+    concurrency: point.conc,
+    topologyKey: pointTopologyKey(point),
+    date: point.actualDate ?? point.date,
+    runUrl: point.run_url ?? null,
+    recipeFingerprint: point.recipe_fingerprint ?? null,
+    image: point.image ?? null,
+  };
+}
+
+function publicServiceComparison(comparison: EqualServiceComparison) {
+  const estimate = (value: EqualServiceEstimate | null) =>
+    value === null
+      ? null
+      : {
+          ...value,
+          endpoints: value.endpoints.map(({ point, ...endpoint }) => ({
+            ...endpoint,
+            point: observedPointIdentity(point),
+          })),
+        };
+  return {
+    ...comparison,
+    metrics: Object.fromEntries(
+      Object.entries(comparison.metrics).map(([key, metric]) => [
+        key,
+        { ...metric, baseline: estimate(metric.baseline), comparator: estimate(metric.comparator) },
+      ]),
+    ),
+  };
+}
+
 export function GET(request: NextRequest) {
   return runViewsRoute('inference', async () => {
     validateViewParams(request.nextUrl.searchParams, VIEW_QUERY_PARAMS['inference']);
@@ -217,6 +275,7 @@ export function GET(request: NextRequest) {
       requestedXMode === 'e2e-normalized-interactivity' && sequence !== Sequence.AgenticTraces
         ? 'interactivity'
         : requestedXMode;
+    const xstat = parseEnumParam(search.get('xstat'), 'xstat', ['mean', 'median'], 'median');
     const xmetric = parseEnumParam(search.get('xmetric'), 'xmetric', XMETRIC_VALUES, 'p90_ttft');
     const percentile = parseEnumParam(
       search.get('percentile'),
@@ -231,15 +290,40 @@ export function GET(request: NextRequest) {
     const frameworks = parseFrameworkFamiliesParam(search.get('frameworks'));
     const deployment = parseDeploymentParam(search.get('deployment'));
     const spec = parseSpecModesParam(search.get('spec'));
-    const optimal = parseBoolParam(search.get('optimal'), 'optimal', true);
-    const best = parseBoolParam(
+    const requestedOptimal = parseBoolParam(search.get('optimal'), 'optimal', true);
+    const requestedBest = parseBoolParam(
       search.get('best'),
       'best',
       !isBestPerSkuDefaultOff(displayName as Model, sequence),
     );
     const format = parseFormatParam(search.get('format'));
+    const serviceCompare = parseBoolParam(search.get('serviceCompare'), 'serviceCompare', false);
+    const roleShare = parseBoolParam(search.get('roleShare'), 'roleShare', false);
+    const requestedServiceBaseline = search.get('serviceBaseline') ?? null;
+    const requestedServiceComparator = search.get('serviceComparator') ?? null;
+    const serviceTarget = search.has('serviceTarget')
+      ? parseNumberParam(search.get('serviceTarget'), 'serviceTarget', 0, { min: Number.MIN_VALUE })
+      : null;
+    if (serviceTarget !== null && serviceTarget <= 0)
+      throw new ViewsApiParamError('serviceTarget', 'serviceTarget must be positive');
+    if (format === 'csv' && (serviceCompare || roleShare))
+      throw new ViewsApiParamError(
+        'format',
+        'Equal-service and role-share panels require format=json',
+      );
     const tcoBasis = parseTcoBasisParam(search.get('tcoBasis'));
     const power = parseListParam(search.get('power'), 'power', POWER_TIER_ORDER);
+    // Topology keys are opaque values returned by this view, not case-folded names.
+    const topologies = [
+      ...new Set(
+        (search.get('topologies') ?? '')
+          .split(',')
+          .map((key) => key.trim())
+          .filter(Boolean),
+      ),
+    ].toSorted();
+    const optimal = xmode === 'concurrency' ? false : requestedOptimal;
+    const best = xmode === 'concurrency' ? false : requestedBest;
     const allPoints = parseBoolParam(search.get('allPoints'), 'allPoints', false);
     const userCosts = parseNumberMap(search.get('userCosts'), 'userCosts');
     const userPowers = parseNumberMap(search.get('userPowers'), 'userPowers');
@@ -265,6 +349,7 @@ export function GET(request: NextRequest) {
       precisionsExplicit: precisions.length > 0,
       metric,
       xmode,
+      xstat,
       xmetric,
       percentile,
       ...(date ? { date } : {}),
@@ -278,6 +363,7 @@ export function GET(request: NextRequest) {
       best,
       tcoBasis,
       power,
+      topologies,
       allPoints,
       userCosts,
       userPowers,
@@ -326,10 +412,13 @@ export function GET(request: NextRequest) {
         await getCachedBenchmarks([...dbModelKeys], VR_DEFAULT_RUN.date, true),
       );
     const data = await project(rows, params);
+    const observedPoints = [...data.result.observedPoints];
     const comparisons = await Promise.all(
       scopes.map(async (scope) => {
         const comparison = await project(await fetchRows(scope.params), scope.params);
-        return { entry: scope.entry, ...comparison.result };
+        observedPoints.push(...comparison.result.observedPoints);
+        const { observedPoints: _observedPoints, ...result } = comparison.result;
+        return { entry: scope.entry, ...result };
       }),
     );
     const overlayRows = await unofficialRows(request);
@@ -339,16 +428,56 @@ export function GET(request: NextRequest) {
           overlayRows.filter((row) => row.run_url === url),
           params,
         );
-        return { runUrl: url, ...overlay.result };
+        observedPoints.push(...overlay.result.observedPoints);
+        const { observedPoints: _observedPoints, ...result } = overlay.result;
+        return { runUrl: url, ...result };
       }),
     );
 
+    const serviceSources = serviceCompare ? getEqualServiceSources(observedPoints) : [];
+    const serviceBaseline = requestedServiceBaseline ?? serviceSources[0]?.key ?? '';
+    const serviceComparator = requestedServiceComparator ?? serviceSources[1]?.key ?? '';
+    const serviceOptions = {
+      baseline: serviceBaseline,
+      comparator: serviceComparator,
+      xField: data.result.xAxis.field as keyof AggDataEntry,
+    };
+    const servicePanels = serviceCompare
+      ? {
+          serviceSources,
+          equalServiceComparison:
+            serviceTarget === null
+              ? null
+              : publicServiceComparison(
+                  buildEqualServiceComparison(observedPoints, {
+                    ...serviceOptions,
+                    target: serviceTarget,
+                  }),
+                ),
+          equalServiceCurve: getEqualServiceComparisonCurve(observedPoints, serviceOptions).map(
+            publicServiceComparison,
+          ),
+        }
+      : {};
+    const rolePanel = roleShare
+      ? {
+          roleEnergyShares: getPrefillSharePoints(observedPoints, serviceOptions.xField).map(
+            ({ point, ...energy }) => ({
+              ...energy,
+              point: observedPointIdentity(point),
+              decodeShare: 100 - energy.prefillShare,
+            }),
+          ),
+        }
+      : {};
+
     const resolvedParams = {
       model: displayName,
       sequence: sequence as string,
       precisions: data.resolvedPrecisions,
       metric,
       xmode,
+      xstat: sequence === Sequence.AgenticTraces || xmode === 'concurrency' ? null : xstat,
       xmetric,
       percentile,
       date: date ?? null,
@@ -358,6 +487,7 @@ export function GET(request: NextRequest) {
       frameworks,
       deployment,
       spec,
+      topologies,
       optimal,
       best,
       format,
@@ -369,6 +499,11 @@ export function GET(request: NextRequest) {
       priceSource,
       dates,
       unofficialrun: search.get('unofficialrun') ?? null,
+      serviceCompare,
+      serviceBaseline: serviceCompare ? serviceBaseline : null,
+      serviceComparator: serviceCompare ? serviceComparator : null,
+      serviceTarget: serviceCompare ? serviceTarget : null,
+      roleShare,
     };
 
     if (format === 'csv') {
@@ -396,6 +531,8 @@ export function GET(request: NextRequest) {
       comparisons,
       overlays,
       pricing,
+      ...servicePanels,
+      ...rolePanel,
     });
   });
 }
diff --git a/packages/app/src/app/api/v1/views/options/route.test.ts b/packages/app/src/app/api/v1/views/options/route.test.ts
index 24469746f..612016adc 100644
--- a/packages/app/src/app/api/v1/views/options/route.test.ts
+++ b/packages/app/src/app/api/v1/views/options/route.test.ts
@@ -86,12 +86,16 @@ describe('GET /api/v1/views/options', () => {
   it('exposes dashboard-parity defaults', async () => {
     const bodyRes = await GET(request('/api/v1/views/options'));
     const body = await bodyRes.json();
+    expect(body.fixedSequenceStatistics).toEqual(['median', 'mean']);
     expect(body.defaults).toMatchObject({
       model: 'DeepSeek-V4-Pro',
       sequence: '8k/1k',
       metric: 'y_tokensPerDollarH',
       percentile: 'p90',
       xmode: 'interactivity',
+      xstat: 'median',
+      serviceCompare: false,
+      roleShare: false,
     });
     // Same vendors, in the dashboard's quick-filter pill order.
     expect(body.quickFilters.vendors).toEqual(VENDOR_ORDER);
diff --git a/packages/app/src/app/api/v1/views/options/route.ts b/packages/app/src/app/api/v1/views/options/route.ts
index 90bde1be0..6af689edb 100644
--- a/packages/app/src/app/api/v1/views/options/route.ts
+++ b/packages/app/src/app/api/v1/views/options/route.ts
@@ -152,6 +152,7 @@ function buildOptionsPayload() {
     specMethods: [...SPEC_METHOD_KEYS].toSorted(),
     percentiles: PERCENTILE_OPTIONS,
     xAxisModes: X_AXIS_MODES,
+    fixedSequenceStatistics: ['median', 'mean'],
     scaleModes: ['auto', 'linear', 'log'],
     metrics,
     quickFilters: {
@@ -190,6 +191,9 @@ function buildOptionsPayload() {
       metric: DEFAULT_METRIC_CONFIG_KEY,
       percentile: 'p90',
       xmode: 'interactivity',
+      xstat: 'median',
+      serviceCompare: false,
+      roleShare: false,
       xmetric: 'p90_ttft',
       scale: 'auto',
       precisions: 'auto',
diff --git a/packages/app/src/components/inference/InferenceContext.test.ts b/packages/app/src/components/inference/InferenceContext.test.ts
index ecc2eee41..c0e18de60 100644
--- a/packages/app/src/components/inference/InferenceContext.test.ts
+++ b/packages/app/src/components/inference/InferenceContext.test.ts
@@ -66,6 +66,15 @@ describe('inference requested and effective axis selectors', () => {
     );
   });
 
+  it('uses fixed-sequence mean TTFT without changing Agentic percentile semantics', () => {
+    expect(resolveE2eXAxisMetric(null, 'ttft', Sequence.EightK_OneK, 'p90', 'mean')).toBe(
+      'mean_ttft',
+    );
+    expect(resolveE2eXAxisMetric(null, 'ttft', Sequence.AgenticTraces, 'p90', 'mean')).toBe(
+      'p90_ttft',
+    );
+  });
+
   it('uses natural E2E x-axis and preserves inactive requested metric', () => {
     expect(resolveE2eXAxisMetric('p90_ttft', 'e2e', Sequence.AgenticTraces, 'p75')).toBeNull();
     expect(resolveE2eXAxisMetric('p90_ttft', 'interactivity', Sequence.AgenticTraces, 'p75')).toBe(
diff --git a/packages/app/src/components/inference/InferenceContext.tsx b/packages/app/src/components/inference/InferenceContext.tsx
index 334a54389..4db326d7f 100644
--- a/packages/app/src/components/inference/InferenceContext.tsx
+++ b/packages/app/src/components/inference/InferenceContext.tsx
@@ -57,6 +57,7 @@ import {
 } from '@/hooks/useChartContext';
 import { useUrlState } from '@/hooks/useUrlState';
 import { serializePerfRulers } from '@/lib/d3-chart/layers/perf-ruler';
+import type { FixedSequenceStatistic } from '@/components/inference/utils/resolveXAxisField';
 import { parsePowerCompare } from '@/components/inference/utils/power-compare';
 import {
   PERSISTED_PERF_RULER_CHART_ID,
@@ -201,9 +202,12 @@ export function resolveE2eXAxisMetric(
   mode: XAxisMode,
   sequence: Parameters<typeof sequenceKind>[0],
   percentile: string,
+  fixedSequenceStatistic: FixedSequenceStatistic = 'median',
 ): string | null {
   if (mode === 'ttft') {
-    return sequenceKind(sequence) === 'agentic' ? `${percentile}_ttft` : 'median_ttft';
+    return sequenceKind(sequence) === 'agentic'
+      ? `${percentile}_ttft`
+      : `${fixedSequenceStatistic}_ttft`;
   }
   if (mode === 'e2e') return null;
   return requestedMetric;
@@ -472,6 +476,13 @@ export function InferenceProvider({
     xAxisModeFromUrlRef.current = true;
     setRequestedXAxisMode(mode);
   }, []);
+  const [fixedSequenceStatistic, setFixedSequenceStatistic] =
+    useState<FixedSequenceStatistic>('median');
+  useEffect(() => {
+    setFixedSequenceStatistic(getUrlParam('i_mstat') === 'mean' ? 'mean' : 'median');
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   // Latency percentile applied to the chart x-axis for agentic scenarios.
   // Values: 'p90' | 'p99'. Non-agentic charts ignore.
   const [selectedPercentile, setSelectedPercentile] = useState<string>(
@@ -482,6 +493,7 @@ export function InferenceProvider({
     selectedXAxisMode,
     effectiveSequence,
     selectedPercentile,
+    fixedSequenceStatistic,
   );
   const [scaleType, setScaleType] = useState<'auto' | 'linear' | 'log'>(
     () => (getUrlParam('i_scale') as 'auto' | 'linear' | 'log') || 'auto',
@@ -520,8 +532,9 @@ export function InferenceProvider({
   const [quickFilterDeployment, setQuickFilterDeployment] = useState<DeploymentMode[]>([]);
   const [quickFilterSpec, setQuickFilterSpec] = useState<SpecMode[]>([]);
   const [quickFilterPower, setQuickFilterPower] = useState<PowerTier[]>([]);
+  const [quickFilterTopologies, setQuickFilterTopologies] = useState<string[]>([]);
   useEffect(() => {
-    const parse = (key: 'i_vendor' | 'i_fw' | 'i_disagg' | 'i_spec' | 'i_power') => {
+    const parse = (key: 'i_vendor' | 'i_fw' | 'i_disagg' | 'i_spec' | 'i_power' | 'i_topology') => {
       const v = getUrlParam(key);
       return v ? v.split(',').filter(Boolean) : [];
     };
@@ -532,11 +545,13 @@ export function InferenceProvider({
     const deployment = parseDeploymentModes(parse('i_disagg'));
     const spec = parse('i_spec') as SpecMode[];
     const power = parsePowerTiers(parse('i_power'));
+    const topologies = parse('i_topology');
     if (vendors.length > 0) setQuickFilterVendors(vendors);
     if (frameworks.length > 0) setQuickFilterFrameworks(frameworks);
     if (deployment.length > 0) setQuickFilterDeployment(deployment);
     if (spec.length > 0) setQuickFilterSpec(spec);
     if (power.length > 0) setQuickFilterPower(power);
+    if (topologies.length > 0) setQuickFilterTopologies(topologies);
   }, [getUrlParam, setQuickFilterFrameworks]);
   const quickFilters = useMemo<QuickFilters>(
     () => ({
@@ -545,6 +560,7 @@ export function InferenceProvider({
       deployment: quickFilterDeployment,
       spec: quickFilterSpec,
       power: quickFilterPower,
+      topologies: quickFilterTopologies,
     }),
     [
       quickFilterVendors,
@@ -552,6 +568,7 @@ export function InferenceProvider({
       quickFilterDeployment,
       quickFilterSpec,
       quickFilterPower,
+      quickFilterTopologies,
     ],
   );
   // Historical Trends hides Quick Filters, so never apply invisible selections there.
@@ -780,6 +797,7 @@ export function InferenceProvider({
       !hasExplicitRunSelection &&
       selectedRunDateRev === 0,
     powerCompare,
+    fixedSequenceStatistic,
   );
 
   // For GPU comparison date picker — use shared availability data from global filters
@@ -1594,6 +1612,7 @@ export function InferenceProvider({
       i_metric: selectedYAxisMetric,
       i_revenue: usesTokenSalePricing(selectedYAxisMetric) ? tokenRevenuePriceSource : 'normalized',
       i_pctl: selectedPercentile,
+      i_mstat: fixedSequenceStatistic,
       i_gpus: selectedGPUs.join(','),
       i_dates: selectedDates.join(','),
       i_dstart: selectedDateRange.startDate,
@@ -1625,6 +1644,7 @@ export function InferenceProvider({
       i_disagg: quickFilterDeployment.join(','),
       i_spec: quickFilterSpec.join(','),
       i_power: quickFilterPower.join(','),
+      i_topology: quickFilterTopologies.join(','),
       i_rulers: iRulersStr,
       i_pcompare: powerCompare === 'none' ? '' : powerCompare,
     },
@@ -1634,6 +1654,7 @@ export function InferenceProvider({
       selectedXAxisMetric,
       selectedE2eXAxisMetric,
       selectedXAxisMode,
+      fixedSequenceStatistic,
       scaleType,
       selectedGPUs,
       selectedDates,
@@ -1658,6 +1679,7 @@ export function InferenceProvider({
       quickFilterDeployment,
       quickFilterSpec,
       quickFilterPower,
+      quickFilterTopologies,
       iRulersStr,
       powerCompare,
     ],
@@ -1874,6 +1896,7 @@ export function InferenceProvider({
       selectedXAxisMetric,
       selectedE2eXAxisMetric,
       selectedXAxisMode,
+      fixedSequenceStatistic,
       scaleType,
       powerCompare,
       isLegendExpanded,
@@ -1900,6 +1923,7 @@ export function InferenceProvider({
       selectedXAxisMetric,
       selectedE2eXAxisMetric,
       selectedXAxisMode,
+      fixedSequenceStatistic,
       scaleType,
       powerCompare,
       isLegendExpanded,
@@ -1933,6 +1957,7 @@ export function InferenceProvider({
     setSelectedYAxisMetric: setSelectedYAxisMetricAndClear,
     setTokenRevenuePriceSource,
     setSelectedPercentile,
+    setFixedSequenceStatistic,
     setSelectedXAxisMetric,
     setSelectedXAxisMode: handleSetXAxisMode,
     setScaleType,
@@ -1942,6 +1967,7 @@ export function InferenceProvider({
     setQuickFilterDeployment,
     setQuickFilterSpec,
     setQuickFilterPower,
+    setQuickFilterTopologies,
     setIsLegendExpanded,
     setHideNonOptimal,
     setShowAllMeasurements,
diff --git a/packages/app/src/components/inference/axis-metric-explanations.test.ts b/packages/app/src/components/inference/axis-metric-explanations.test.ts
index e5c12cfe6..3051bc9d8 100644
--- a/packages/app/src/components/inference/axis-metric-explanations.test.ts
+++ b/packages/app/src/components/inference/axis-metric-explanations.test.ts
@@ -165,6 +165,9 @@ describe('xAxisPercentileFromLabel', () => {
   it('extracts percentile words', () => {
     expect(xAxisPercentileFromLabel('P90 Time To First Token (s)')).toBe('P90');
     expect(xAxisPercentileFromLabel('Median Time To First Token (s)')).toBe('Median');
+    expect(xAxisPercentileFromLabel('Mean Interactivity (tok/s/user)')).toBe('Mean');
+    expect(xAxisPercentileFromLabel('平均交互性（tok/s/user）')).toBe('Mean');
+    expect(xAxisPercentileFromLabel('中位首 token 延迟 (s)')).toBe('Median');
     expect(xAxisPercentileFromLabel('P75 E2E Normalized Interactivity (tok/s/user)')).toBe('P75');
     expect(xAxisPercentileFromLabel('P99.9 End-to-end Latency (s)')).toBe('P99.9');
   });
diff --git a/packages/app/src/components/inference/axis-metric-explanations.ts b/packages/app/src/components/inference/axis-metric-explanations.ts
index 5ce643e70..cc198bb05 100644
--- a/packages/app/src/components/inference/axis-metric-explanations.ts
+++ b/packages/app/src/components/inference/axis-metric-explanations.ts
@@ -548,9 +548,15 @@ export const METRIC_EXPLANATIONS: Record<MetricKey, MetricExplanation> = {
  * the percentile prefix. Mirrors the branch logic in `resolveXAxisField` plus
  * the derived agentic x-axis mode handled in `ChartDisplay`.
  */
-export type XAxisKind = 'interactivity' | 'e2eLatency' | 'ttft' | 'e2eNormalizedInteractivity';
+export type XAxisKind =
+  | 'concurrency'
+  | 'interactivity'
+  | 'e2eLatency'
+  | 'ttft'
+  | 'e2eNormalizedInteractivity';
 
 export const X_AXIS_KINDS: readonly XAxisKind[] = [
+  'concurrency',
   'interactivity',
   'e2eLatency',
   'ttft',
@@ -567,11 +573,18 @@ export interface XAxisExplanation {
 }
 
 const zhPctl = (pctl: string | null): string =>
-  pctl === null ? '' : pctl === 'Median' ? '中位' : `${pctl} `;
+  pctl === null ? '' : pctl === 'Median' ? '中位' : pctl === 'Mean' ? '平均' : `${pctl} `;
 
 const enPctl = (pctl: string | null): string => (pctl === null ? '' : `${pctl} `);
 
 export const X_AXIS_EXPLANATIONS: Record<XAxisKind, XAxisExplanation> = {
+  concurrency: {
+    name: { en: () => 'Concurrency', zh: () => '并发数' },
+    description: {
+      en: 'The configured number of concurrent requests in each observed benchmark. This is a load setting, not a higher-is-better score. All observed load points are retained; lines only connect the same serving topology and run.',
+      zh: '每个实测基准配置的并发请求数。这是负载设置，不是越高越好的性能分数。保留全部实测负载点，连线仅连接同一服务拓扑、同一次运行的数据。',
+    },
+  },
   interactivity: {
     name: {
       en: (pctl) => `${enPctl(pctl)}Interactivity (tok/s/user)`,
@@ -581,7 +594,8 @@ export const X_AXIS_EXPLANATIONS: Record<XAxisKind, XAxisExplanation> = {
       en:
         'Interactivity is the rate at which a single user receives generated tokens while the ' +
         'model streams its answer — how quickly new words appear on screen. Higher values feel ' +
-        'snappier; operators trade it against batch throughput.',
+        'snappier; operators trade it against batch throughput. For fixed-sequence Mean, the rate ' +
+        'is 1 divided by mean TPOT in seconds, not the arithmetic mean of per-request rates.',
       zh:
         '交互性（interactivity）指模型流式输出回答时，单个用户接收生成 token 的速率——' +
         '即新内容出现在屏幕上的快慢。数值越高体验越流畅；运营方需要在交互性与批量吞吐量之间权衡。',
@@ -655,6 +669,7 @@ export function resolveXAxisKind(
     isDerivedNormalizedInteractivity: boolean;
   },
 ): XAxisKind {
+  if (opts.xAxisField === 'conc') return 'concurrency';
   if (opts.isDerivedNormalizedInteractivity) return 'e2eNormalizedInteractivity';
   if (opts.xAxisField.endsWith('ttft')) return 'ttft';
   return chartType === 'e2e' ? 'e2eLatency' : 'interactivity';
@@ -663,9 +678,11 @@ export function resolveXAxisKind(
 /**
  * Extract the percentile word from a resolved x-axis label (e.g.
  * "P90 Time To First Token (s)" → "P90"). The chart pipelines always render
- * the percentile prefix in this English form, including on /zh pages.
+ * percentiles in English; fixed-sequence statistics are localized on /zh.
  */
 export function xAxisPercentileFromLabel(xAxisLabel: string): string | null {
+  if (xAxisLabel.startsWith('平均')) return 'Mean';
+  if (xAxisLabel.startsWith('中位')) return 'Median';
   const match = /^(?<pctl>Median|Mean|P\d+(?:\.\d+)?)\s/iu.exec(xAxisLabel);
   if (!match?.groups?.pctl) return null;
   const pctl = match.groups.pctl;
diff --git a/packages/app/src/components/inference/hooks/chart-data-core.ts b/packages/app/src/components/inference/hooks/chart-data-core.ts
index 0851b8040..45d7499aa 100644
--- a/packages/app/src/components/inference/hooks/chart-data-core.ts
+++ b/packages/app/src/components/inference/hooks/chart-data-core.ts
@@ -12,9 +12,15 @@ import { supportsChartTokenMetric, type TokenMetricType } from '@/lib/supplement
  * Chart x-axis variant selected by the dropdown in the Chart panel. The
  * inference provider and ChartDisplay import this single definition.
  */
-export type XAxisMode = 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity';
+export type XAxisMode =
+  | 'ttft'
+  | 'e2e'
+  | 'interactivity'
+  | 'e2e-normalized-interactivity'
+  | 'concurrency';
 
 export const X_AXIS_MODES: readonly XAxisMode[] = [
+  'concurrency',
   'ttft',
   'e2e',
   'interactivity',
@@ -115,7 +121,7 @@ const X_LABEL_STAT_PREFIX_RE = /^(?:Median|Mean|P75|P90|P95|P99(?:\.9)?)\b\s*/iu
  * existing leading statistic word (e.g. the TTFT override's "P90 Time To
  * First Token (s)") or prefixes the percentile when the configured label has
  * none (e.g. "Interactivity (tok/s/user)" → "P90 Interactivity (tok/s/user)").
- * Only call for agentic sequences — fixed-seq labels must stay untouched.
+ * Also used for the explicit Mean/Median labels on fixed-sequence service axes.
  */
 export function applyAgenticPercentileToXLabel(label: string, pctlWord: string): string {
   return X_LABEL_STAT_PREFIX_RE.test(label)
diff --git a/packages/app/src/components/inference/hooks/useChartData.ts b/packages/app/src/components/inference/hooks/useChartData.ts
index 791b14be6..bb4b97503 100644
--- a/packages/app/src/components/inference/hooks/useChartData.ts
+++ b/packages/app/src/components/inference/hooks/useChartData.ts
@@ -41,7 +41,10 @@ import {
   EMPTY_QUICK_FILTERS,
   type QuickFilters,
 } from '@/components/inference/utils/quickFilters';
-import { resolveXAxisField } from '@/components/inference/utils/resolveXAxisField';
+import {
+  resolveXAxisField,
+  type FixedSequenceStatistic,
+} from '@/components/inference/utils/resolveXAxisField';
 import { benchmarkQueryOptions, useBenchmarks } from '@/hooks/api/use-benchmarks';
 import type { BenchmarkRow } from '@/lib/api';
 import { benchmarkCurveDate, dedupeAgenticHistoryRuns } from '@/lib/benchmark-run-selection';
@@ -120,6 +123,7 @@ export function useChartData(
   allowDefaultRunPreference = false,
   /** Sibling boundary / role series appended to a gated power metric (`i_pcompare`). */
   powerCompare: PowerCompare = 'none',
+  fixedSequenceStatistic: FixedSequenceStatistic = 'median',
 ) {
   // When the selected date is the latest available, use '' (empty string) to match
   // the initial no-date query key, reusing the eagerly-fetched benchmarks from the
@@ -358,19 +362,24 @@ export function useChartData(
           isAgentic,
           percentile: selectedPercentile,
           xAxisMode: selectedXAxisMode,
+          fixedSequenceStatistic,
         });
         const naturalX = resolved.naturalX as keyof AggDataEntry;
         const xAxisField = resolved.xAxisField as keyof AggDataEntry;
         const { isTtftOverride } = resolved;
 
         const ttftPctl = isTtftOverride ? xAxisField.replace(/_ttft$/u, '') : 'p90';
-        const ttftPctlWord = ttftPctl === 'median' ? 'Median' : ttftPctl.toUpperCase();
+        const ttftPctlWord =
+          ttftPctl === 'median' ? 'Median' : ttftPctl === 'mean' ? 'Mean' : ttftPctl.toUpperCase();
         const ttftLabel = `${ttftPctlWord} Time To First Token (s)`;
         const ttftLabelZh = `${ttftPctlWord} 首 token 延迟 (s)`;
 
         let xAxisLabel = chartDef.x_label;
         let xAxisLabelZh = chartDef.x_labelZh;
-        if (resolved.branch === 'user-input-override') {
+        if (resolved.branch === 'concurrency') {
+          xAxisLabel = 'Concurrency';
+          xAxisLabelZh = '并发数';
+        } else if (resolved.branch === 'user-input-override') {
           const labelKey = `${selectedYAxisMetric}_x_label` as keyof ChartDefinition;
           const labelZhKey = `${selectedYAxisMetric}_x_labelZh` as keyof ChartDefinition;
           if (effectiveXMetric === chartDef[`${selectedYAxisMetric}_x` as keyof ChartDefinition]) {
@@ -402,7 +411,8 @@ export function useChartData(
           : selectedXAxisMode === undefined
             ? (chartDef[headingKey] as string) || chartDef.heading
             : chartDef.heading;
-        if (isAgentic) {
+        if (resolved.branch === 'concurrency') chartHeading = 'vs. Concurrency';
+        if (isAgentic && resolved.branch !== 'concurrency') {
           const pctlWord = selectedPercentile.toUpperCase();
           xAxisLabel = applyAgenticPercentileToXLabel(xAxisLabel, pctlWord);
           xAxisLabelZh = applyAgenticPercentileToXLabel(xAxisLabelZh, pctlWord);
@@ -412,6 +422,24 @@ export function useChartData(
           );
         }
 
+        if (!isAgentic && resolved.branch !== 'concurrency') {
+          const word = xAxisField.startsWith('mean_')
+            ? 'Mean'
+            : xAxisField.startsWith('median_')
+              ? 'Median'
+              : xAxisField.split('_')[0].toUpperCase();
+          const wordZh = word === 'Mean' ? '平均' : '中位';
+          xAxisLabel = applyAgenticPercentileToXLabel(xAxisLabel, word);
+          xAxisLabelZh = applyAgenticPercentileToXLabel(xAxisLabelZh, word).replace(
+            /^(?:Mean|Median)\s+/u,
+            wordZh,
+          );
+          chartHeading = chartHeading.replace(
+            /^(?<vsPrefix>vs\.\s+)(?:(?:Median|Mean|P75|P90|P95|P99(?:\.9)?)\s+)?/iu,
+            `$1${word} `,
+          );
+        }
+
         // The x-axis is "flipped" only when the good-direction reverses
         // (e.g. interactivity → TTFT: "higher is better" → "lower is better").
         // E2EL → TTFT keeps the same direction ("lower is better" for both),
@@ -422,11 +450,13 @@ export function useChartData(
           xAxisField !== naturalX && !(chartDef.chartType === 'e2e' && isTtftOverride);
 
         const rooflineOverrides: Partial<ChartDefinition> = {};
-        if (xAxisFlipped) {
+        if (xAxisFlipped || resolved.branch === 'concurrency') {
           for (const key of Object.keys(chartDef) as (keyof ChartDefinition)[]) {
             if (typeof key === 'string' && key.endsWith('_roofline')) {
               const dir = chartDef[key] as string | undefined;
-              if (dir && dir in FLIP_MAP) {
+              if (resolved.branch === 'concurrency') {
+                (rooflineOverrides as any)[key] = undefined;
+              } else if (dir && dir in FLIP_MAP) {
                 (rooflineOverrides as any)[key] = flipRooflineDirection(dir as RooflineDirection);
               }
             }
@@ -489,6 +519,7 @@ export function useChartData(
       selectedXAxisMetric,
       selectedE2eXAxisMetric,
       selectedPercentile,
+      fixedSequenceStatistic,
       selectedSequence,
       tokenRevenuePriceSource,
     ],
diff --git a/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx b/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx
index 88412ce51..d716c5bef 100644
--- a/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx
+++ b/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx
@@ -7,6 +7,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { BenchmarkRow } from '@/lib/api';
 import { Model, Sequence } from '@/lib/data-mappings';
 import { resolveScatterXAxisScale } from '@/components/inference/utils/x-axis-scale';
+import { processOverlayChartData } from '@/components/inference/utils';
+import { transformBenchmarkRows } from '@/lib/benchmark-transform';
 import { buildReplayTimeline } from '@/components/inference/replay/buildReplayTimeline';
 
 const mocks = vi.hoisted(() => ({
@@ -107,9 +109,11 @@ let result: ReturnType<typeof useChartData> | undefined;
 function Probe({
   mode,
   energy = false,
+  statistic = 'median',
   metric = energy ? 'y_measuredPrefillJPerInputToken' : 'y_inputTputPerGpu',
 }: {
   mode?: XAxisMode;
+  statistic?: 'mean' | 'median';
   energy?: boolean;
   metric?: string;
 }) {
@@ -135,6 +139,15 @@ function Probe({
     undefined,
     undefined,
     mode,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    statistic,
   );
   return null;
 }
@@ -154,6 +167,59 @@ afterEach(() => {
 });
 
 describe('useChartData x-axis scale wiring', () => {
+  it.each([
+    ['interactivity', 'interactivity', 'mean_tpot_intvty', 25, 'Mean Interactivity'],
+    ['ttft', 'e2e', 'mean_ttft', 8, 'Mean Time To First Token'],
+    ['e2e', 'e2e', 'mean_e2el', 30, 'Mean End-to-end Latency'],
+  ] as const)(
+    'keeps official, overlay and replay mean %s numerically aligned',
+    (mode, chartType, field, expectedX, label) => {
+      mocks.rows[0].metrics = {
+        ...mocks.rows[0].metrics,
+        mean_tpot: 0.04,
+        mean_intvty: 777,
+        mean_ttft: 8,
+        mean_e2el: 30,
+      };
+      mocks.rows[1].metrics = { ...mocks.rows[1].metrics, mean_intvty: 888 };
+      act(() => root.render(<Probe mode={mode} statistic="mean" metric="y_tpPerGpu" />));
+      const graph = result!.graphs.find((g) => g.chartDefinition.chartType === chartType)!;
+      expect(graph.chartDefinition.x_scale_field).toBe(field);
+      expect(graph.chartDefinition.x_label).toContain(label);
+      expect(graph.chartDefinition.heading).toContain(label);
+      expect(graph.data.map((point) => point.x)).toEqual([expectedX]);
+      expect(graph.data[0].mean_intvty).toBe(777);
+      const { chartData } = transformBenchmarkRows(mocks.rows);
+      const overlay = processOverlayChartData(
+        chartData[chartType === 'interactivity' ? 0 : 1],
+        chartType,
+        'y_tpPerGpu',
+        null,
+        {
+          selectedXAxisMode: mode,
+          fixedSequenceStatistic: 'mean',
+        },
+      );
+      expect(overlay.map((point) => point.x)).toEqual([expectedX]);
+      const replay = buildReplayTimeline(mocks.rows, graph.chartDefinition, 'y_tpPerGpu', null, [
+        'fp8',
+      ]);
+      expect(replay.configs.map((series) => series.template.x)).toEqual([expectedX]);
+    },
+  );
+
+  it('uses observed concurrency, preserves every point and removes preference directions', () => {
+    act(() => root.render(<Probe mode="concurrency" />));
+    for (const graph of result!.graphs) {
+      expect(graph.data.map((point) => point.x)).toEqual([8, 16]);
+      expect(graph.chartDefinition.x_scale_field).toBe('conc');
+      expect(graph.chartDefinition.x_label).toBe('Concurrency');
+      expect(graph.chartDefinition.x_labelZh).toBe('并发数');
+      expect(graph.chartDefinition.y_inputTputPerGpu_roofline).toBeUndefined();
+      expect(graph.clippedData).toEqual([]);
+    }
+  });
+
   it.each([
     ['interactivity', 'interactivity', 'median_intvty'],
     ['ttft', 'e2e', 'median_ttft'],
@@ -204,8 +270,8 @@ describe('useChartData x-axis scale wiring', () => {
     ]);
     expect(energyGraph?.chartDefinition).toMatchObject({
       x_scale_field: 'median_intvty',
-      x_label: 'Interactivity (tok/s/user)',
-      heading: 'vs. Interactivity',
+      x_label: 'Median Interactivity (tok/s/user)',
+      heading: 'vs. Median Interactivity',
       y_measuredPrefillJPerInputToken_roofline: 'lower_right',
     });
     if (!energyGraph) throw new Error('useChartData did not produce the interactivity graph');
@@ -252,8 +318,8 @@ describe('useChartData x-axis scale wiring', () => {
     expect(graph?.data.map((point) => point.x)).toEqual([12, 12]);
     expect(graph?.chartDefinition).toMatchObject({
       x_scale_field: 'median_e2el',
-      x_label: 'End-to-end Latency (s)',
-      heading: 'vs. End-to-end Latency',
+      x_label: 'Median End-to-end Latency (s)',
+      heading: 'vs. Median End-to-end Latency',
     });
   });
 
diff --git a/packages/app/src/components/inference/perf-ruler-store.test.ts b/packages/app/src/components/inference/perf-ruler-store.test.ts
index 22e50d0e8..01a2ac906 100644
--- a/packages/app/src/components/inference/perf-ruler-store.test.ts
+++ b/packages/app/src/components/inference/perf-ruler-store.test.ts
@@ -212,6 +212,11 @@ describe('persisted perf-ruler store', () => {
       expect(persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', Y)).toBe(e2e);
     });
 
+    it('changes when the effective fixed-sequence statistic changes', () => {
+      const median = persistedPerfRulerAxisKey(graphs('median_e2el'), 'e2e', Y);
+      expect(persistedPerfRulerAxisKey(graphs('mean_e2el'), 'e2e', Y)).not.toBe(median);
+    });
+
     it('changes with the percentile and the y metric', () => {
       const base = persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', Y);
       expect(persistedPerfRulerAxisKey(graphs('p99_e2el'), 'e2e', Y)).not.toBe(base);
diff --git a/packages/app/src/components/inference/types.ts b/packages/app/src/components/inference/types.ts
index cebfb7336..6febc4514 100644
--- a/packages/app/src/components/inference/types.ts
+++ b/packages/app/src/components/inference/types.ts
@@ -6,6 +6,7 @@ import type { Model, Sequence } from '@/lib/data-mappings';
 import type { PowerTier } from '@/lib/power-tier';
 import type { SystemPowerEstimate } from '@/lib/modeled-system-power';
 import type { MetricKey } from './metric-registry';
+import type { FixedSequenceStatistic } from './utils/resolveXAxisField';
 import type { PowerBasis } from '@/lib/power-basis';
 
 export type { WorkerPower };
@@ -88,6 +89,8 @@ export interface AggDataEntry {
   'p99.9_ttft': number;
   mean_tpot: number;
   mean_intvty: number;
+  /** Reciprocal of finite positive mean TPOT (seconds), not raw mean_intvty. */
+  mean_tpot_intvty?: number;
   median_tpot: number;
   median_intvty: number;
   std_tpot: number;
@@ -641,6 +644,8 @@ export interface QuickFilters {
   spec: SpecMode[];
   /** Measured-power certification tiers (see `@/lib/power-tier`). */
   power: PowerTier[];
+  /** Exact allocation and parallelism identities; absent means no constraint. */
+  topologies?: string[];
 }
 
 /**
@@ -710,9 +715,15 @@ export interface InferenceDisplayContextType {
   openRouterPricingLoading: boolean;
   openRouterPricingError: string | null;
   selectedPercentile: string;
+  fixedSequenceStatistic: FixedSequenceStatistic;
   selectedXAxisMetric: string | null;
   selectedE2eXAxisMetric: string | null;
-  selectedXAxisMode: 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity';
+  selectedXAxisMode:
+    | 'ttft'
+    | 'e2e'
+    | 'interactivity'
+    | 'e2e-normalized-interactivity'
+    | 'concurrency';
   scaleType: 'auto' | 'linear' | 'log';
   /** Comparison series overlaid on a gated power metric (`i_pcompare`). */
   powerCompare: PowerCompare;
@@ -754,9 +765,10 @@ export interface InferenceActionsContextType {
   setSelectedYAxisMetric: (metric: string) => void;
   setTokenRevenuePriceSource: (source: TokenRevenuePriceSource) => void;
   setSelectedPercentile: (percentile: string) => void;
+  setFixedSequenceStatistic: (statistic: FixedSequenceStatistic) => void;
   setSelectedXAxisMetric: (metric: string | null) => void;
   setSelectedXAxisMode: (
-    mode: 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity',
+    mode: 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity' | 'concurrency',
   ) => void;
   setScaleType: (type: 'auto' | 'linear' | 'log') => void;
   setPowerCompare: (mode: PowerCompare) => void;
@@ -765,6 +777,7 @@ export interface InferenceActionsContextType {
   setQuickFilterDeployment: (modes: DeploymentMode[]) => void;
   setQuickFilterSpec: (modes: SpecMode[]) => void;
   setQuickFilterPower: (tiers: PowerTier[]) => void;
+  setQuickFilterTopologies: (topologies: string[]) => void;
   setIsLegendExpanded: (expanded: boolean) => void;
   setHideNonOptimal: (hide: boolean) => void;
   setShowAllMeasurements: (show: boolean) => void;
diff --git a/packages/app/src/components/inference/ui/ActiveQuickFilters.tsx b/packages/app/src/components/inference/ui/ActiveQuickFilters.tsx
index 2160444ee..a8f1eda3b 100644
--- a/packages/app/src/components/inference/ui/ActiveQuickFilters.tsx
+++ b/packages/app/src/components/inference/ui/ActiveQuickFilters.tsx
@@ -34,6 +34,7 @@ export function ActiveQuickFilters() {
     else if (category === 'deployment')
       actions.setQuickFilterDeployment(values as DeploymentMode[]);
     else if (category === 'spec') actions.setQuickFilterSpec(values as SpecMode[]);
+    else if (category === 'topologies') actions.setQuickFilterTopologies(values);
     else actions.setQuickFilterPower(values as PowerTier[]);
   };
 
@@ -56,7 +57,7 @@ export function ActiveQuickFilters() {
           onClick={() => {
             setCategory(
               category,
-              quickFilters[category].filter((item) => item !== value),
+              (quickFilters[category] ?? []).filter((item) => item !== value),
             );
             track('inference_quick_filter_removed', { category, value, source: 'result_summary' });
           }}
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index 7bb22f900..9fdabc10c 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -31,6 +31,7 @@ import {
 } from '@/components/inference/InferenceContext';
 import { useGlobalFilterSelection } from '@/components/GlobalFilterContext';
 import type {
+  AggDataEntry,
   ChartDefinition,
   HardwareConfig,
   InferenceData,
@@ -50,6 +51,7 @@ import { bestSeriesPerSku } from '@/components/inference/utils/best-series-per-s
 import InferenceTable from '@/components/inference/ui/InferenceTable';
 import ScatterGraph from '@/components/inference/ui/ScatterGraph';
 import PowerTimeline from '@/components/inference/ui/PowerTimeline';
+import PowerServiceComparison from '@/components/inference/ui/PowerServiceComparison';
 import { Card } from '@/components/ui/card';
 import { ChartButtons } from '@/components/ui/chart-buttons';
 import { ShareButton } from '@/components/ui/share-button';
@@ -213,7 +215,9 @@ function zhHeading(configured: string): string {
   const subjectZh = match?.groups && HEADING_SUBJECT_ZH[match.groups.subject];
   if (!subjectZh) return configured;
   const pctl = match.groups?.pctl;
-  return `vs. ${pctl ? `${pctl} ` : ''}${subjectZh}`;
+  const statisticZh =
+    pctl === 'Mean' ? '平均' : pctl === 'Median' ? '中位' : pctl ? `${pctl} ` : '';
+  return `vs. ${statisticZh}${subjectZh}`;
 }
 
 /** Presentation and data plumbing for trace-derived agentic x-axis modes. */
@@ -312,6 +316,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     selectedXAxisMetric,
     selectedE2eXAxisMetric,
     selectedPercentile,
+    fixedSequenceStatistic,
     selectedXAxisMode,
     tokenRevenuePricing,
     showLineLabels,
@@ -488,6 +493,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
         {
           isAgentic,
           selectedPercentile,
+          fixedSequenceStatistic,
           tcoBasis,
           selectedXAxisMode,
           powerCompare,
@@ -540,6 +546,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     selectedXAxisMetric,
     selectedE2eXAxisMetric,
     selectedPercentile,
+    fixedSequenceStatistic,
     powerCompare,
     selectedXAxisMode,
     tokenRevenuePricing,
@@ -783,7 +790,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
   const derivedSpec = useDerivedXAxis ? DERIVED_X_MODE_SPECS[selectedXAxisMode] : undefined;
 
   const renderableGraphs = useMemo(() => {
-    if (!isAgenticSequence) return visibleGraphs;
+    if (!isAgenticSequence || selectedXAxisMode === 'concurrency') return visibleGraphs;
     if (!derivedMetrics) {
       // Legacy AgentX axes can still render transient/non-persisted rows, which
       // have no ids to request.
@@ -833,6 +840,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     isAgenticSequence,
     derivedSpec,
     derivedTargetIds.length,
+    selectedXAxisMode,
     visibleGraphs,
     derivedMetrics,
     selectedYAxisMetric,
@@ -870,9 +878,15 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
         : renderableGraphs.map((graph, graphIndex) => {
             const resolvedXLabel = xAxisLabel(graph.chartDefinition, locale);
             const isTimelineMode = Boolean(
-              selectedDateRange.startDate && selectedDateRange.endDate && selectedGPUs.length > 0,
+              selectedXAxisMode !== 'concurrency' &&
+              selectedDateRange.startDate &&
+              selectedDateRange.endDate &&
+              selectedGPUs.length > 0,
             );
-            const replayAvailable = getViewMode(graphIndex) === 'chart' && !isTimelineMode;
+            const replayAvailable =
+              getViewMode(graphIndex) === 'chart' &&
+              !isTimelineMode &&
+              selectedXAxisMode !== 'concurrency';
             // Chart-level notices: the KV-offload halo
             // key, the agentic optimization note, and the ATOM engine
             // footnote. Detected from the same data the chart plots —
@@ -883,6 +897,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
             // points only — skip the unofficial overlay there so the footer
             // can't advertise a halo or ATOM series that isn't on the chart.
             const isGpuComparison =
+              selectedXAxisMode !== 'concurrency' &&
               selectedGPUs.length > 0 &&
               ((selectedDateRange.startDate && selectedDateRange.endDate) ||
                 selectedDates.length > 0);
@@ -1053,6 +1068,12 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                               {(() => {
                                 // The timeline's x axis is time, not the scatter x metric.
                                 if (isPowerTimeline) return null;
+                                if (selectedXAxisMode === 'concurrency')
+                                  return locale === 'zh' ? '与并发数的关系' : 'vs. Concurrency';
+                                if (!isAgenticSequence) {
+                                  const heading = String(graph.chartDefinition.heading);
+                                  return locale === 'zh' ? zhHeading(heading) : heading;
+                                }
                                 const xField = graph.chartDefinition.x_scale_field;
                                 if (xField?.endsWith('_ttft')) {
                                   const percentile = xField.replace(/_ttft$/u, '');
@@ -1303,6 +1324,33 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                         </div>
                       );
                     })()}
+                    {selectedMeasuredConfig &&
+                      !isPowerTimeline &&
+                      getViewMode(graphIndex) !== 'table' &&
+                      (() => {
+                        const overlay = selectUnofficialOverlayForMode(
+                          selectedXAxisMode,
+                          graph.chartDefinition.chartType,
+                          overlayDataByChartType,
+                        );
+                        const { officialRows, overlayRows } = visibleComparisonRows(
+                          isGpuComparison
+                            ? graph.data.filter((point) =>
+                                activeDates.has(`${point.date}_${point.hwKey}`),
+                              )
+                            : graph.data,
+                          isGpuComparison ? undefined : overlay,
+                        );
+                        return (
+                          <PowerServiceComparison
+                            chartId={`chart-${graphIndex}`}
+                            contextLabel={`${getModelLabel(selectedModel)} · ${getSequenceLabel(selectedSequence)}`}
+                            data={[...officialRows, ...overlayRows]}
+                            xField={graph.chartDefinition.x_scale_field as keyof AggDataEntry}
+                            xLabel={resolvedXLabel}
+                          />
+                        );
+                      })()}
                     <ChartNotices chartId={`chart-${graphIndex}`} notices={footerNotices} />
                     {replayAvailable && !minimalChrome && (
                       <ReplayLauncher
diff --git a/packages/app/src/components/inference/ui/GPUGraph.tsx b/packages/app/src/components/inference/ui/GPUGraph.tsx
index ac17588d9..6786040dd 100644
--- a/packages/app/src/components/inference/ui/GPUGraph.tsx
+++ b/packages/app/src/components/inference/ui/GPUGraph.tsx
@@ -264,6 +264,7 @@ const GPUGraph = React.memo(
       setQuickFilterDeployment,
       setQuickFilterSpec,
       setQuickFilterPower,
+      setQuickFilterTopologies,
     } = useInferenceActions();
     const locale = useLocale();
     const featureGateUnlocked = useFeatureGate();
@@ -294,6 +295,7 @@ const GPUGraph = React.memo(
       (lockedFrameworks ? 0 : quickFilters.frameworks.length) +
       quickFilters.deployment.length +
       quickFilters.power.length +
+      (quickFilters.topologies?.length ?? 0) +
       (selectedSequence === Sequence.AgenticTraces ? 0 : quickFilters.spec.length);
     const clearQuickFilters = useCallback(() => {
       setQuickFilterVendors([]);
@@ -301,12 +303,14 @@ const GPUGraph = React.memo(
       setQuickFilterDeployment([]);
       setQuickFilterSpec([]);
       setQuickFilterPower([]);
+      setQuickFilterTopologies([]);
     }, [
       setQuickFilterVendors,
       setQuickFilterFrameworks,
       setQuickFilterDeployment,
       setQuickFilterSpec,
       setQuickFilterPower,
+      setQuickFilterTopologies,
     ]);
 
     // Shared date+GPU pairs. `dates` holds comparison-series entries (plain dates
diff --git a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
new file mode 100644
index 000000000..869f60ec1
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
@@ -0,0 +1,538 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useEffect, useMemo, useRef, useState } from 'react';
+
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { Heading } from '@/components/ui/heading';
+import { useThemeColors } from '@/hooks/useThemeColors';
+import { useUrlState } from '@/hooks/useUrlState';
+import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import type { CustomLayerConfig } from '@/lib/d3-chart/D3Chart/types';
+import type { ContinuousScale } from '@/lib/d3-chart/types';
+import { useLocale } from '@/lib/use-locale';
+import type { AggDataEntry, InferenceData } from '../types';
+import {
+  buildEqualServiceComparison,
+  getEqualServiceComparisonCurve,
+  getEqualServiceSources,
+  getPrefillSharePoints,
+  type EqualServiceEstimate,
+  type EqualServiceReason,
+} from '../utils/equal-service-comparison';
+
+const STRINGS = {
+  en: {
+    compare: 'Compare at the same speed / latency',
+    share: 'Prefill energy share',
+    baseline: 'Baseline',
+    comparator: 'Comparator',
+    target: 'Target',
+    change: 'Change',
+    title: 'Power, throughput and energy at the same service point',
+    method:
+      'Change = (comparator ÷ baseline − 1) × 100%. A negative energy change means lower energy use. Matches the selected axis only; other latencies may differ.',
+    interpolation:
+      'Within each source, raw quantities are linearly interpolated between neighboring observations, then compared. No extrapolation. Larger markers show the selected target. Lines connect the derived comparisons; they are not additional measurements.',
+    roleMethod:
+      'Prefill and decode energy use the same output-token denominator. Share = prefill ÷ (prefill + decode). Points are observed configurations; the dashed line marks 50%.',
+    targetHelp:
+      'Enter a target within both source ranges to inspect values and bracketing observations.',
+    concurrency:
+      'Concurrency is a load diagnostic, not equal service. Select interactivity, TTFT or end-to-end latency for this comparison.',
+    metric: 'Metric',
+    empty: 'No comparable points in the selected sources’ overlapping range.',
+    roleEmpty: 'No validated prefill/decode energy is available for these filters.',
+    measured: 'Observed',
+    interpolated: 'Interpolated',
+    observation: 'Observation',
+    meanWattsPerGpu: 'Mean GPU power (W/GPU)',
+    outputTokensPerSecond: 'Deployment output (tok/s)',
+    joulesPerOutputToken: 'GPU energy (J/output token)',
+    percent: 'Comparator change (%)',
+    shareAxis: 'Prefill energy share (%)',
+    unavailable: 'Unavailable',
+  },
+  zh: {
+    compare: '在相同速度 / 延迟下比较',
+    share: '预填充能耗占比',
+    baseline: '基准',
+    comparator: '对比对象',
+    target: '目标值',
+    change: '变化',
+    title: '相同服务指标下的功耗、吞吐量与能耗',
+    method:
+      '变化 =（对比对象 ÷ 基准 − 1）× 100%。能耗变化率为负表示能耗更低。只匹配所选横轴，其他延迟可能不同。',
+    interpolation:
+      '各数据源在相邻观测点间对原始数值进行线性插值，再计算变化率；不做外推。大圆点标记所选目标值。连线连接推导出的比较结果，不代表额外实测。',
+    roleMethod:
+      '预填充与解码能耗均按输出 token 归一化。占比 = 预填充 ÷（预填充 + 解码）。各点为实测配置，虚线标记 50%。',
+    targetHelp: '输入两个数据源范围内的目标值，查看数值及插值两端的观测点。',
+    concurrency:
+      '并发数用于分析负载，并不代表相同服务水平。请选交互性、首 token 延迟或端到端延迟进行比较。',
+    metric: '指标',
+    empty: '所选数据源的重叠范围内没有可比较的数据。',
+    roleEmpty: '当前筛选条件下没有经过验证的预填充 / 解码能耗数据。',
+    measured: '实测',
+    interpolated: '插值',
+    observation: '观测点',
+    meanWattsPerGpu: '平均 GPU 功耗（W/GPU）',
+    outputTokensPerSecond: '部署输出吞吐量（tok/s）',
+    joulesPerOutputToken: 'GPU 能耗（J/输出 token）',
+    percent: '对比对象变化（%）',
+    shareAxis: '预填充能耗占比（%）',
+    unavailable: '不可用',
+  },
+};
+const REASONS: Record<EqualServiceReason, [string, string]> = {
+  'unsupported-axis': ['Select a service axis.', '请选择服务指标横轴。'],
+  'invalid-target': ['Enter a positive finite target.', '请输入有效的正数目标值。'],
+  'same-source': ['Choose two different sources.', '请选择两个不同的数据源。'],
+  'unknown-source': [
+    'A selected source is unavailable under these filters.',
+    '当前筛选条件下找不到所选数据源。',
+  ],
+  'out-of-range': ['Target is outside a source range.', '目标值超出数据源范围。'],
+  'ambiguous-x': [
+    'Conflicting observations at the same X; no value selected.',
+    '相同横轴值有冲突的观测数据，未选择数值。',
+  ],
+  'missing-metric': ['A required observation is missing this metric.', '所需观测点缺少该指标。'],
+};
+const METRICS = ['meanWattsPerGpu', 'outputTokensPerSecond', 'joulesPerOutputToken'] as const;
+const DASHES = ['', '6,4', '2,3'];
+const number = d3.format(',.4~g');
+const percent = d3.format('+.2f');
+interface PlotPoint {
+  x: number;
+  y: number;
+  key: string;
+  selected?: boolean;
+}
+
+function ComparisonPlot({
+  chartId,
+  points,
+  xLabel,
+  yLabel,
+  reference,
+  colors,
+  lines = true,
+}: {
+  chartId: string;
+  points: PlotPoint[];
+  xLabel: string;
+  yLabel: string;
+  reference: number;
+  colors: Record<string, string>;
+  lines?: boolean;
+}) {
+  const xs = points.map((p) => p.x).filter(Number.isFinite);
+  const ys = points.map((p) => p.y).filter(Number.isFinite);
+  const xMin = Math.min(...xs),
+    xMax = Math.max(...xs);
+  const yMin = Math.min(0, ...ys),
+    yMax = Math.max(reference, ...ys);
+  const grouped = Object.fromEntries(d3.groups(points, (p) => p.key));
+  const drawReference: NonNullable<CustomLayerConfig['render']> = (group, ctx) => {
+    const scale = (ctx.renderedYScale ?? ctx.yScale) as ContinuousScale;
+    group
+      .selectAll('line')
+      .data([reference])
+      .join('line')
+      .attr('x1', 0)
+      .attr('x2', ctx.width)
+      .attr('y1', (v) => scale(v))
+      .attr('y2', (v) => scale(v))
+      .attr('stroke', 'currentColor')
+      .attr('stroke-dasharray', '5,4')
+      .attr('opacity', 0.6);
+  };
+  return (
+    <D3Chart<PlotPoint>
+      chartId={`${chartId}-plot`}
+      data={points.filter((p) => Number.isFinite(p.y))}
+      height={360}
+      testId={`${chartId}-plot`}
+      watermark="logo"
+      zoom={{ enabled: false }}
+      grabCursor={false}
+      instructions=""
+      margin={{ top: 20, right: 18, bottom: 64, left: 65 }}
+      xScale={{
+        type: 'linear',
+        domain: xMin === xMax ? [0, xMax * 1.05] : [xMin, xMax],
+        nice: true,
+      }}
+      yScale={{
+        type: 'linear',
+        domain: lines
+          ? [yMin - (yMax - yMin || 1) * 0.1, yMax + (yMax - yMin || 1) * 0.1]
+          : [0, 100],
+        nice: true,
+      }}
+      xAxis={{ label: xLabel, tickCount: 4 }}
+      yAxis={{ label: yLabel, tickCount: 5 }}
+      layers={[
+        { type: 'custom', key: 'reference', render: drawReference },
+        ...(lines
+          ? [
+              {
+                type: 'line' as const,
+                lines: grouped,
+                config: {
+                  curve: d3.curveLinear,
+                  isDefined: (p: { x: number; y: number }) => Number.isFinite(p.y),
+                  getColor: (key: string) => colors[key],
+                  getStrokeDasharray: (key: string) =>
+                    DASHES[METRICS.indexOf(key as (typeof METRICS)[number])],
+                },
+              },
+            ]
+          : []),
+        {
+          type: 'point',
+          data: points.filter((p) => Number.isFinite(p.y)),
+          config: {
+            getCx: () => 0,
+            getCy: () => 0,
+            getX: (p) => p.x,
+            getY: (p) => p.y,
+            getRadius: (p) => (p.selected ? 6 : 3),
+            getColor: (p) => colors[p.key],
+          },
+        },
+      ]}
+    />
+  );
+}
+
+export default function PowerServiceComparison({
+  data,
+  xField,
+  xLabel,
+  chartId,
+  contextLabel,
+}: {
+  data: InferenceData[];
+  xField: keyof AggDataEntry;
+  xLabel: string;
+  chartId: string;
+  contextLabel?: string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const { getUrlParam, setUrlParams } = useUrlState();
+  const [enabled, setEnabled] = useState(() => getUrlParam('i_servicecompare') === '1');
+  const [roleShare, setRoleShare] = useState(() => getUrlParam('i_roleshare') === '1');
+  const [baseline, setBaseline] = useState(() => getUrlParam('i_servicebase') ?? '');
+  const [comparator, setComparator] = useState(() => getUrlParam('i_servicepeer') ?? '');
+  const [target, setTarget] = useState(() => getUrlParam('i_servicetarget') ?? '');
+  const sources = useMemo(() => getEqualServiceSources(data), [data]);
+  const base = baseline || sources[0]?.key || '';
+  const peer = comparator || sources[1]?.key || '';
+  const previousAxis = useRef(xField);
+  useEffect(() => {
+    if (previousAxis.current !== xField) {
+      previousAxis.current = xField;
+      setTarget('');
+      setUrlParams({ i_servicetarget: '' });
+    }
+  }, [xField, setUrlParams]);
+  useEffect(() => {
+    setUrlParams({
+      i_servicecompare: enabled ? '1' : '0',
+      i_roleshare: roleShare ? '1' : '0',
+      i_servicebase: enabled ? base : baseline,
+      i_servicepeer: enabled ? peer : comparator,
+      i_servicetarget: target,
+    });
+  }, [enabled, roleShare, base, peer, baseline, comparator, target, setUrlParams]);
+  const curve = useMemo(
+    () =>
+      enabled
+        ? getEqualServiceComparisonCurve(data, {
+            baseline: base,
+            comparator: peer,
+            xField,
+          })
+        : [],
+    [enabled, data, base, peer, xField],
+  );
+  const comparison = useMemo(
+    () =>
+      enabled && target.trim()
+        ? buildEqualServiceComparison(data, {
+            baseline: base,
+            comparator: peer,
+            xField,
+            target: Number(target),
+          })
+        : null,
+    [enabled, data, base, peer, xField, target],
+  );
+  const shares = useMemo(
+    () => (roleShare ? getPrefillSharePoints(data, xField) : []),
+    [roleShare, data, xField],
+  );
+  const { resolveColor } = useThemeColors({
+    highContrast: true,
+    identifiers: [...METRICS, ...sources.map((s) => s.key)],
+  });
+  const metricColors = Object.fromEntries(METRICS.map((key) => [key, resolveColor(key)]));
+  const sourceColors = Object.fromEntries(sources.map((s) => [s.key, resolveColor(s.key)]));
+  // The percentage of interpolated raw values is not linear in X. Include the
+  // exact selected target as a knot so its plotted marker agrees with the table.
+  const plottedCurve =
+    comparison && Object.values(comparison.metrics).some((metric) => metric.changePercent !== null)
+      ? [...curve.filter((row) => row.target !== comparison.target), comparison].sort(
+          (a, b) => a.target - b.target,
+        )
+      : curve;
+  const plotPoints = METRICS.flatMap((key) =>
+    plottedCurve.map((row) => ({
+      key,
+      x: row.target,
+      y: row.metrics[key].changePercent ?? NaN,
+      selected: row.target === comparison?.target,
+    })),
+  );
+  const reason = (value?: EqualServiceReason) =>
+    value ? REASONS[value][locale === 'zh' ? 1 : 0] : t.unavailable;
+  const estimate = (value: EqualServiceEstimate | null) =>
+    value ? (
+      <>
+        <strong>{number(value.value)}</strong>
+        <span className="block text-xs text-muted-foreground">
+          {value.interpolated ? t.interpolated : t.measured}
+        </span>
+        <span className="block text-xs text-muted-foreground">
+          {value.endpoints
+            .map(
+              (endpoint) =>
+                `${t.observation} ${endpoint.point.id ?? '—'}: ${number(endpoint.x)} · c${endpoint.point.conc}`,
+            )
+            .join(' → ')}
+        </span>
+      </>
+    ) : (
+      '—'
+    );
+  const selectClass = 'w-full min-w-0 rounded-md border bg-background p-2 text-sm';
+  const sourceSelect = (
+    value: string,
+    onChange: (value: string) => void,
+    label: string,
+    testId: string,
+  ) => (
+    <label className="min-w-0 space-y-1 text-sm">
+      <span>{label}</span>
+      <select
+        className={selectClass}
+        aria-label={label}
+        data-testid={testId}
+        value={value}
+        onChange={(event) => onChange(event.target.value)}
+      >
+        {!sources.some((source) => source.key === value) && (
+          <option value={value}>{t.unavailable}</option>
+        )}
+        {sources.map((source) => (
+          <option key={source.key} value={source.key}>
+            {source.label}
+          </option>
+        ))}
+      </select>
+    </label>
+  );
+  return (
+    <div className="mt-6 min-w-0 space-y-4 border-t pt-4" data-testid="power-service-comparison">
+      <div className="no-export flex flex-wrap gap-4 text-sm">
+        <label className="flex items-center gap-2">
+          <input
+            type="checkbox"
+            checked={enabled}
+            onChange={(e) => setEnabled(e.target.checked)}
+            data-testid="equal-service-toggle"
+          />
+          {t.compare}
+        </label>
+        <label className="flex items-center gap-2">
+          <input
+            type="checkbox"
+            checked={roleShare}
+            onChange={(e) => setRoleShare(e.target.checked)}
+            data-testid="role-share-toggle"
+          />
+          {t.share}
+        </label>
+      </div>
+      {enabled &&
+        (xField === 'conc' ? (
+          <p className="text-sm text-muted-foreground" data-testid="equal-service-concurrency-note">
+            {t.concurrency}
+          </p>
+        ) : (
+          <>
+            <div className="no-export grid min-w-0 gap-3 md:grid-cols-2">
+              {sourceSelect(base, setBaseline, t.baseline, 'equal-service-baseline')}
+              {sourceSelect(peer, setComparator, t.comparator, 'equal-service-comparator')}
+            </div>
+            <section
+              id={`${chartId}-service`}
+              className="min-w-0 space-y-3"
+              data-testid="equal-service-panel"
+            >
+              <Heading as="h3" level="card">
+                {t.title}
+              </Heading>
+              <p className="text-sm text-muted-foreground">{contextLabel}</p>
+              <p className="text-sm text-muted-foreground">{t.method}</p>
+              <p className="break-words text-sm">
+                {t.baseline}: {sources.find((s) => s.key === base)?.label ?? t.unavailable} →{' '}
+                {t.comparator}: {sources.find((s) => s.key === peer)?.label ?? t.unavailable}
+              </p>
+
+              <div className="flex flex-wrap gap-x-5 gap-y-2 text-sm">
+                {METRICS.map((key, index) => (
+                  <span key={key} className="inline-flex items-center gap-2">
+                    <svg width="28" height="10" aria-hidden="true">
+                      <line
+                        x1="0"
+                        x2="28"
+                        y1="5"
+                        y2="5"
+                        stroke={metricColors[key]}
+                        strokeWidth="2"
+                        strokeDasharray={DASHES[index]}
+                      />
+                    </svg>
+                    {t[key]}
+                  </span>
+                ))}
+              </div>
+              {plotPoints.some((p) => Number.isFinite(p.y)) ? (
+                <ComparisonPlot
+                  chartId={`${chartId}-service`}
+                  points={plotPoints}
+                  xLabel={xLabel}
+                  yLabel={t.percent}
+                  reference={0}
+                  colors={metricColors}
+                />
+              ) : (
+                <p className="py-6 text-sm text-muted-foreground">{t.empty}</p>
+              )}
+              <p className="text-xs text-muted-foreground">{t.interpolation}</p>
+              <div className="max-h-0 overflow-hidden">
+                <div id={`${chartId}-service-export`} className="p-4" />
+              </div>
+              <ChartButtons
+                chartId={`${chartId}-service`}
+                analyticsPrefix="equal_service"
+                hideZoomReset
+              />
+              <label className="no-export block max-w-lg space-y-1 text-sm">
+                {t.target} · {xLabel}
+                <input
+                  className={selectClass}
+                  type="number"
+                  min="0"
+                  step="any"
+                  value={target}
+                  onChange={(e) => setTarget(e.target.value)}
+                  data-testid="equal-service-target"
+                />
+              </label>
+              {comparison ? (
+                <div className="min-w-0">
+                  <table
+                    className="w-full table-fixed break-words text-left text-sm"
+                    data-testid="equal-service-table"
+                  >
+                    <caption className="mb-2 text-left">
+                      {xLabel}: {number(comparison.target)}
+                    </caption>
+                    <thead>
+                      <tr>
+                        <th className="p-2">{t.metric}</th>
+                        <th className="p-2">{t.baseline}</th>
+                        <th className="p-2">{t.comparator}</th>
+                        <th className="p-2">{t.change}</th>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {METRICS.map((key) => (
+                        <tr className="border-t" key={key} data-testid={`equal-service-${key}`}>
+                          <th className="p-2 font-medium">{t[key]}</th>
+                          <td className="p-2 align-top">
+                            {estimate(comparison.metrics[key].baseline)}
+                          </td>
+                          <td className="p-2 align-top">
+                            {estimate(comparison.metrics[key].comparator)}
+                          </td>
+                          <td className="p-2 align-top">
+                            {comparison.metrics[key].changePercent === null
+                              ? reason(comparison.metrics[key].reason)
+                              : `${percent(comparison.metrics[key].changePercent!)}%`}
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                </div>
+              ) : (
+                <p className="text-xs text-muted-foreground">{t.targetHelp}</p>
+              )}
+            </section>
+          </>
+        ))}
+      {roleShare && (
+        <section
+          id={`${chartId}-role-share`}
+          className="min-w-0 space-y-3"
+          data-testid="prefill-share-panel"
+        >
+          <Heading as="h3" level="card">
+            {t.share}
+          </Heading>
+          <p className="text-sm text-muted-foreground">{contextLabel}</p>
+          <p className="text-xs text-muted-foreground">{t.roleMethod}</p>
+          {shares.length > 0 ? (
+            <>
+              <div className="flex flex-wrap gap-3 text-sm">
+                {sources
+                  .filter((s) => shares.some((p) => p.sourceKey === s.key))
+                  .map((s) => (
+                    <span key={s.key} className="min-w-0 break-all">
+                      <span style={{ color: sourceColors[s.key] }}>● </span>
+                      {s.label}
+                    </span>
+                  ))}
+              </div>
+              <ComparisonPlot
+                chartId={`${chartId}-role-share`}
+                points={shares.map((p) => ({ key: p.sourceKey, x: p.x, y: p.prefillShare }))}
+                xLabel={xLabel}
+                yLabel={t.shareAxis}
+                reference={50}
+                colors={sourceColors}
+                lines={false}
+              />
+              <div className="max-h-0 overflow-hidden">
+                <div id={`${chartId}-role-share-export`} className="p-4" />
+              </div>
+              <ChartButtons
+                chartId={`${chartId}-role-share`}
+                analyticsPrefix="prefill_share"
+                hideZoomReset
+              />
+            </>
+          ) : (
+            <p className="py-6 text-sm text-muted-foreground">{t.roleEmpty}</p>
+          )}
+        </section>
+      )}
+    </div>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index 6a56f0c4d..40f075e4e 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -40,6 +40,7 @@ import { SegmentedToggle } from '@/components/ui/segmented-toggle';
 import { useUnofficialRun } from '@/components/unofficial-run-provider';
 import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
 import { useThemeColors } from '@/hooks/useThemeColors';
+import { useUrlState } from '@/hooks/useUrlState';
 import { track } from '@/lib/analytics';
 import { computeToggle } from '@/lib/toggle-set';
 import { getModelSortIndex } from '@/lib/constants';
@@ -63,6 +64,9 @@ import {
   allGpuPool,
   consumePowerTraceFocus,
   groupPoolsBySize,
+  hasPowerTimelineWindow,
+  parsePowerTimelineParams,
+  powerTimelineSampleX,
   joinPowerTimeline,
   planPowerTimelineRequests,
   prioritizeRun,
@@ -78,6 +82,8 @@ import {
   type PoolSizeGroup,
   type PowerPool,
   type PowerPoolRole,
+  type PowerTimelineAxis,
+  type PowerTimelineLines,
   type PowerTimelineRequest,
   type PowerTimelineTrace,
   type WindowPhase,
@@ -98,7 +104,18 @@ const STRINGS = {
   en: {
     timeAxis: 'Time axis',
     wall: 'Wall clock (UTC)',
-    elapsed: 'Since start',
+    elapsed: 'Since telemetry start',
+    serving: 'Since serving start',
+    xServing: 'Time since serving-window start (s)',
+    windowOnly: 'Validated window only',
+    windowOnlyHelp:
+      'Show only retained samples inside each recorded validated serving window. Traces without valid window bounds are omitted.',
+    missingWindow: (count: number) =>
+      `${count} trace${count === 1 ? '' : 's'} omitted: no valid serving-window bounds.`,
+    missingFocus:
+      'The selected trace is unavailable for these filters or has no retained telemetry.',
+    methodWindow:
+      'One-second means of GPU-board power inside each recorded validated serving window; window boundaries are not interpolated. Dashed lines: rated TDP from the hardware registry.',
     xWall: 'Time (UTC)',
     xElapsed: 'Time since telemetry start (m:ss)',
     perGpu: 'One line per GPU',
@@ -168,7 +185,15 @@ const STRINGS = {
   zh: {
     timeAxis: '时间轴',
     wall: '实际时刻（UTC）',
-    elapsed: '相对起点',
+    elapsed: '距遥测起点',
+    serving: '距服务窗口起点',
+    xServing: '距服务窗口开始的时间（秒）',
+    windowOnly: '仅显示有效测量窗口',
+    windowOnlyHelp: '仅显示已记录的有效服务窗口内保留的采样点；缺少有效窗口边界的曲线不绘制。',
+    missingWindow: (count: number) => `${count} 条曲线缺少有效服务窗口边界，未绘制。`,
+    missingFocus: '所选曲线不符合当前筛选条件，或没有保留的遥测数据。',
+    methodWindow:
+      '显示各有效服务窗口内的 GPU 板卡功耗一秒平均值，窗口边界不作插值。虚线为硬件注册表中的额定 TDP。',
     xWall: '时间（UTC）',
     xElapsed: '距遥测开始的时间（分:秒）',
     perGpu: '每个 GPU 一条线',
@@ -232,8 +257,8 @@ const STRINGS = {
   },
 } as const;
 
-type XMode = 'wall' | 'elapsed';
-type LineMode = 'mean' | 'gpu' | 'pool';
+type XMode = PowerTimelineAxis;
+type LineMode = PowerTimelineLines;
 
 interface TimelineSample {
   trace: PowerTimelineTrace;
@@ -394,10 +419,9 @@ function tracePaths(
   overlayIndex: number | null,
   xMode: XMode,
   lineMode: LineMode,
+  windowOnly: boolean,
 ): TracePath[] {
   const { series } = trace;
-  const xOf = (column: number) =>
-    xMode === 'wall' ? bucketTimeMs(series, column) : series.t[column] - series.t[0];
   const rows = traceRows(series, lineMode);
   const faint = lineMode === 'gpu' ? 0.22 : 0.32;
   const strong = lineMode === 'gpu' ? 0.85 : 1;
@@ -407,22 +431,25 @@ function tracePaths(
     const full: TracePoint[] = [];
     const window: TracePoint[] = [];
     row.values.forEach((value, column) => {
-      const point = { x: xOf(column), y: value };
+      const x = powerTimelineSampleX(trace, column, xMode, windowOnly);
+      if (x === null) return;
+      const point = { x, y: value };
       full.push(point);
       if (windowPhase(trace, bucketTimeMs(series, column)) === 'window') window.push(point);
     });
-    paths.push({
-      id: `${trace.key}:${row.id}:full`,
-      traceKey: trace.key,
-      hwKey: trace.point.hwKey,
-      overlayIndex,
-      color,
-      segment: 'full',
-      width: widths[0],
-      opacity: faint,
-      points: full,
-      pool: row.pool,
-    });
+    if (!windowOnly && full.length > 1)
+      paths.push({
+        id: `${trace.key}:${row.id}:full`,
+        traceKey: trace.key,
+        hwKey: trace.point.hwKey,
+        overlayIndex,
+        color,
+        segment: 'full',
+        width: widths[0],
+        opacity: faint,
+        points: full,
+        pool: row.pool,
+      });
     if (window.length > 1) {
       paths.push({
         id: `${trace.key}:${row.id}:window`,
@@ -451,14 +478,15 @@ function traceSamples(
   overlayIndex: number | null,
   xMode: XMode,
   lineMode: LineMode,
+  windowOnly: boolean,
 ): TimelineSample[] {
   const { series } = trace;
   if (lineMode !== 'pool') {
     const rows = series.power.map((_, row) => row);
-    return sampleRows(trace, color, overlayIndex, xMode, rows, undefined);
+    return sampleRows(trace, color, overlayIndex, xMode, windowOnly, rows, undefined);
   }
   return drawnPools(series).flatMap((pool) =>
-    sampleRows(trace, color, overlayIndex, xMode, pool.rows, {
+    sampleRows(trace, color, overlayIndex, xMode, windowOnly, pool.rows, {
       role: pool.role,
       gpuCount: pool.rows.length,
     }),
@@ -470,12 +498,15 @@ function sampleRows(
   color: string,
   overlayIndex: number | null,
   xMode: XMode,
+  windowOnly: boolean,
   rows: readonly number[],
   pool: TimelineSample['pool'],
 ): TimelineSample[] {
   const { series } = trace;
   const samples: TimelineSample[] = [];
   for (let column = 0; column < series.t.length; column++) {
+    const x = powerTimelineSampleX(trace, column, xMode, windowOnly);
+    if (x === null) continue;
     let sum = 0;
     let count = 0;
     let min = Number.POSITIVE_INFINITY;
@@ -497,7 +528,7 @@ function sampleRows(
       overlayIndex,
       column,
       timeMs,
-      x: xMode === 'wall' ? timeMs : series.t[column] - series.t[0],
+      x,
       y: pool ? sum : sum / count,
       min,
       max,
@@ -686,12 +717,23 @@ export default function PowerTimeline({
     setUnifiedOverlaySelection,
   } = useUnofficialRun();
 
-  const [xModeChoice, setXModeChoice] = useState<XMode | null>(null);
-  const [lineMode, setLineMode] = useState<LineMode>('mean');
-  const [showUtility, setShowUtility] = useState(false);
+  const { getUrlParam, setUrlParams } = useUrlState();
+  const [initialView] = useState(() =>
+    parsePowerTimelineParams({
+      i_ptaxis: getUrlParam('i_ptaxis'),
+      i_ptlines: getUrlParam('i_ptlines'),
+      i_ptwindow: getUrlParam('i_ptwindow'),
+      i_ptfocus: getUrlParam('i_ptfocus'),
+      i_ptutility: getUrlParam('i_ptutility'),
+    }),
+  );
+  const [xModeChoice, setXModeChoice] = useState<XMode | null>(initialView.axis);
+  const [lineMode, setLineMode] = useState<LineMode>(initialView.lines);
+  const [windowOnly, setWindowOnly] = useState(initialView.windowOnly);
+  const [showUtility, setShowUtility] = useState(initialView.utility);
   const [highlight, setHighlight] = useState<string | null>(null);
   /** Trace a "View power trace" deep link asked for, once the join has produced it. */
-  const [focusKey, setFocusKey] = useState<string | null>(null);
+  const [focusKey, setFocusKey] = useState<string | null>(initialView.focus);
   /** The deep-link request, read once on mount; `undefined` until read, `null` once honoured. */
   const requestedFocusRef = useRef<string | null | undefined>(undefined);
 
@@ -740,7 +782,7 @@ export default function PowerTimeline({
   if (requestedFocusRef.current === undefined) {
     requestedFocusRef.current = consumePowerTraceFocus();
   }
-  const focusRunRef = useRef(traceKeyRunId(requestedFocusRef.current));
+  const focusRun = traceKeyRunId(requestedFocusRef.current ?? focusKey);
   // Overlay runs were requested explicitly (`?unofficialrun=`), so they take
   // the cap's slots before official runs; the deep-linked run still goes first.
   const overlayRunIds = useMemo(
@@ -754,11 +796,11 @@ export default function PowerTimeline({
   );
   const fetchedRequests = useMemo(
     () =>
-      prioritizeRun(prioritizeRuns(requests, overlayRunIds), focusRunRef.current).slice(
+      prioritizeRun(prioritizeRuns(requests, overlayRunIds), focusRun).slice(
         0,
         POWER_TIMELINE_MAX_RUNS,
       ),
-    [requests, overlayRunIds],
+    [requests, overlayRunIds, focusRun],
   );
   const droppedRuns = requests.length - fetchedRequests.length;
   const queries = useQueries({
@@ -878,22 +920,33 @@ export default function PowerTimeline({
   );
   const xMode: XMode = xModeChoice ?? (visibleRunCount <= 1 ? 'wall' : 'elapsed');
 
-  // The pools switch is offered only where a visible trace carries worker roles;
-  // pool mode left without one would draw deployment totals with no way back.
+  // Retain a shared pool choice while data loads; keep its switch available even
+  // if the current selection has no role-tagged trace, so it can be turned off.
   const hasPools = useMemo(
     () => visibleTraces.some((trace) => tracePools(trace.series).length > 0),
     [visibleTraces],
   );
   useEffect(() => {
-    if (lineMode === 'pool' && !hasPools && visibleTraces.length > 0) setLineMode('mean');
-  }, [lineMode, hasPools, visibleTraces.length]);
+    setUrlParams({
+      i_ptaxis: xModeChoice ?? '',
+      i_ptlines: lineMode === 'mean' ? '' : lineMode,
+      i_ptwindow: windowOnly ? 'window' : '',
+      i_ptfocus: focusKey ?? '',
+      i_ptutility: showUtility ? '1' : '',
+    });
+  }, [xModeChoice, lineMode, windowOnly, focusKey, showUtility, setUrlParams]);
+
+  const missingWindows =
+    windowOnly || xMode === 'serving'
+      ? visibleTraces.filter((trace) => !hasPowerTimelineWindow(trace)).length
+      : 0;
 
   const model = useMemo<DrawModel>(() => {
     const paths: TracePath[] = [];
     const labels: TraceLabel[] = [];
     for (const trace of visibleTraces) {
       const { color, overlayIndex } = colorForTrace(trace);
-      const tracePathSet = tracePaths(trace, color, overlayIndex, xMode, lineMode);
+      const tracePathSet = tracePaths(trace, color, overlayIndex, xMode, lineMode, windowOnly);
       paths.push(...tracePathSet);
       if (visibleTraces.length > MAX_LABELED_TRACES) continue;
       // One end label per trace; per pool in pool mode, so the role reads off the line.
@@ -925,15 +978,15 @@ export default function PowerTimeline({
       }
     }
     return { paths, labels };
-  }, [visibleTraces, colorForTrace, xMode, lineMode, t]);
+  }, [visibleTraces, colorForTrace, xMode, lineMode, windowOnly, t]);
 
   const samples = useMemo(
     () =>
       visibleTraces.flatMap((trace) => {
         const { color, overlayIndex } = colorForTrace(trace);
-        return traceSamples(trace, color, overlayIndex, xMode, lineMode);
+        return traceSamples(trace, color, overlayIndex, xMode, lineMode, windowOnly);
       }),
-    [visibleTraces, colorForTrace, xMode, lineMode],
+    [visibleTraces, colorForTrace, xMode, lineMode, windowOnly],
   );
 
   // Rated references: per hardware in mean / per-GPU modes; per (hardware,
@@ -995,7 +1048,6 @@ export default function PowerTimeline({
     let min = Number.POSITIVE_INFINITY;
     let max = Number.NEGATIVE_INFINITY;
     for (const path of model.paths) {
-      if (path.segment !== 'full') continue;
       for (const point of path.points) {
         if (point.x < min) min = point.x;
         if (point.x > max) max = point.x;
@@ -1004,8 +1056,9 @@ export default function PowerTimeline({
     if (!Number.isFinite(min) || !Number.isFinite(max)) {
       return xMode === 'wall' ? [Date.UTC(2026, 0, 1), Date.UTC(2026, 0, 1, 0, 10)] : [0, 600];
     }
+    if (xMode === 'serving' && windowOnly) min = Math.min(0, min);
     return min === max ? [min, max + (xMode === 'wall' ? 60_000 : 60)] : [min, max];
-  }, [model.paths, xMode]);
+  }, [model.paths, xMode, windowOnly]);
   const yDomain = useMemo<[number, number]>(() => {
     let max = 0;
     for (const path of model.paths) {
@@ -1017,6 +1070,7 @@ export default function PowerTimeline({
 
   const xTickFormat = useMemo(() => {
     if (xMode === 'elapsed') return (value: d3.AxisDomain) => formatElapsed(Number(value));
+    if (xMode === 'serving') return (value: d3.AxisDomain) => d3.format('~g')(Number(value));
     const span = xDomain[1] - xDomain[0];
     const crossesDate = formatUtcDate(new Date(xDomain[0])) !== formatUtcDate(new Date(xDomain[1]));
     const format = d3.utcFormat(
@@ -1146,7 +1200,11 @@ export default function PowerTimeline({
       const elapsed = formatElapsed((sample.timeMs - trace.series.startMs) / 1000);
       const clock = `${formatUtcClock(new Date(sample.timeMs))} UTC`;
       const time =
-        xMode === 'wall' ? `${clock} · +${elapsed} ${t.sinceStart}` : `+${elapsed} · ${clock}`;
+        xMode === 'serving'
+          ? `${sample.x.toFixed(1)} s · ${t.serving} · ${clock}`
+          : xMode === 'wall'
+            ? `${clock} · +${elapsed} ${t.sinceStart}`
+            : `+${elapsed} · ${clock}`;
       const colon = locale === 'zh' ? '：' : ':';
       const validated = point.measuredAvgPower?.y;
       const { pool } = sample;
@@ -1273,7 +1331,7 @@ export default function PowerTimeline({
       infoTooltip: t.perGpuHelp,
     },
   ];
-  if (hasPools) {
+  if (hasPools || lineMode === 'pool') {
     switches.push({
       id: 'power-timeline-pools',
       label: t.pools,
@@ -1282,16 +1340,28 @@ export default function PowerTimeline({
       infoTooltip: t.poolsHelp,
     });
   }
-  switches.push({
-    id: 'power-timeline-utility',
-    label: t.utilityLines,
-    checked: showUtility,
-    onCheckedChange: (checked) => {
-      setShowUtility(checked);
-      track('inference_power_timeline_utility_toggled', { enabled: checked });
+  switches.push(
+    {
+      id: 'power-timeline-window-only',
+      label: t.windowOnly,
+      checked: windowOnly,
+      onCheckedChange: (checked) => {
+        setWindowOnly(checked);
+        track('inference_power_timeline_window_changed', { windowOnly: checked });
+      },
+      infoTooltip: t.windowOnlyHelp,
     },
-    infoTooltip: t.utilityHelp,
-  });
+    {
+      id: 'power-timeline-utility',
+      label: t.utilityLines,
+      checked: showUtility,
+      onCheckedChange: (checked) => {
+        setShowUtility(checked);
+        track('inference_power_timeline_utility_toggled', { enabled: checked });
+      },
+      infoTooltip: t.utilityHelp,
+    },
+  );
 
   const legendElement = (
     <ChartLegend
@@ -1330,6 +1400,7 @@ export default function PowerTimeline({
         options={[
           { value: 'wall', label: t.wall, testId: 'power-timeline-axis-wall' },
           { value: 'elapsed', label: t.elapsed, testId: 'power-timeline-axis-elapsed' },
+          { value: 'serving', label: t.serving, testId: 'power-timeline-axis-serving' },
         ]}
         onValueChange={(mode) => {
           setXModeChoice(mode);
@@ -1343,11 +1414,12 @@ export default function PowerTimeline({
   if (loadingRuns > 0) emptyMessage = t.loading(loadingRuns);
   else if (!hasAnyArtifact) emptyMessage = t.noArtifacts;
   else if (visibleTraces.length === 0) emptyMessage = t.noTraces;
+  else if (missingWindows === visibleTraces.length) emptyMessage = t.missingWindow(missingWindows);
 
   return (
     <div className="relative flex flex-col gap-2" data-testid="power-timeline">
       <D3Chart<TimelineSample>
-        key={`${chartId}-${xMode}-${lineMode}`}
+        key={`${chartId}-${xMode}-${lineMode}-${windowOnly}`}
         chartId={chartId}
         data={samples}
         height={CHART_HEIGHT}
@@ -1363,7 +1435,7 @@ export default function PowerTimeline({
         }
         yScale={{ type: 'linear', domain: yDomain, nice: true }}
         xAxis={{
-          label: xMode === 'wall' ? t.xWall : t.xElapsed,
+          label: xMode === 'wall' ? t.xWall : xMode === 'serving' ? t.xServing : t.xElapsed,
           tickValues: (scale) => {
             const timeScale = scale as
               | d3.ScaleTime<number, number>
@@ -1442,6 +1514,12 @@ export default function PowerTimeline({
             </button>
           </p>
         )}
+        {focusKey && !focusedTrace && loadingRuns === 0 && (
+          <p data-testid="power-timeline-focus-missing">{t.missingFocus}</p>
+        )}
+        {missingWindows > 0 && (
+          <p data-testid="power-timeline-window-missing">{t.missingWindow(missingWindows)}</p>
+        )}
         {errors.map(({ request, error }) => (
           <p key={request.runId} className="text-destructive" role="alert">
             {t.loadError(request.runId, error.message)}
@@ -1473,7 +1551,7 @@ export default function PowerTimeline({
             ))}
           </p>
         )}
-        <p>{t.method}</p>
+        <p>{windowOnly ? t.methodWindow : t.method}</p>
         {hasPools && <p>{t.methodPools}</p>}
       </div>
     </div>
diff --git a/packages/app/src/components/inference/ui/QuickFiltersDialog.tsx b/packages/app/src/components/inference/ui/QuickFiltersDialog.tsx
index 198b25d93..62daecad5 100644
--- a/packages/app/src/components/inference/ui/QuickFiltersDialog.tsx
+++ b/packages/app/src/components/inference/ui/QuickFiltersDialog.tsx
@@ -7,6 +7,7 @@ import { OptionInfo } from '@/components/ui/option-info';
 import type { DeploymentMode, SpecMode } from '@/components/inference/types';
 import type { PowerTier } from '@/lib/power-tier';
 import { FRAMEWORK_FAMILIES } from '@/components/inference/utils/quickFilters';
+import { topologyLabel } from '@/components/inference/utils/topology-filter';
 
 import {
   useInferenceActions,
@@ -56,6 +57,9 @@ const STRINGS = {
     specHelp:
       'MTP groups runs with speculative decoding enabled, including methods such as EAGLE. STP groups standard decoding without speculative decoding. Available only for fixed-sequence benchmarks.',
     power: 'Measured Power',
+    topology: 'Topology',
+    topologyHelp:
+      'Keep one GPU allocation and parallelism configuration across its observed concurrency sweep. This does not match software versions or fill missing measurements.',
     certified: 'Validated',
     legacyTier: 'Historical',
     validatedTitle: 'Validated measurement',
@@ -97,6 +101,9 @@ const STRINGS = {
     specHelp:
       'MTP 组包含启用投机解码的运行，也包括 EAGLE 等方法；STP 组为未启用投机解码的标准解码运行。该筛选仅适用于固定序列长度基准测试。',
     power: '实测功耗',
+    topology: '拓扑',
+    topologyHelp:
+      '按 GPU 分配和并行配置保留整条已测并发曲线。此筛选不会匹配软件版本，也不会补造缺失数据。',
     certified: '已验证',
     legacyTier: '历史测量',
     validatedTitle: '已验证测量',
@@ -151,6 +158,7 @@ export function QuickFiltersDialog({
     setQuickFilterDeployment,
     setQuickFilterSpec,
     setQuickFilterPower,
+    setQuickFilterTopologies,
   } = useInferenceActions();
   const { selectedSequence, quickFilters, lockedFrameworks } = useInferenceFilters();
   const { availableQuickFilters } = useInferenceData();
@@ -160,6 +168,7 @@ export function QuickFiltersDialog({
     framework: <p>{t.frameworkHelp}</p>,
     deployment: <p>{t.deploymentHelp}</p>,
     spec: <p>{t.specHelp}</p>,
+    topology: <p>{t.topologyHelp}</p>,
     power: (
       <>
         <div>
@@ -186,9 +195,12 @@ export function QuickFiltersDialog({
     label: framework.label,
     available: availableQuickFilters.frameworks.includes(framework.key),
   }));
+  const topologyKeys = [
+    ...new Set([...(availableQuickFilters.topologies ?? []), ...(quickFilters.topologies ?? [])]),
+  ];
 
   const groups: {
-    key: 'vendor' | 'framework' | 'deployment' | 'spec' | 'power';
+    key: 'vendor' | 'framework' | 'deployment' | 'spec' | 'power' | 'topology';
     label: string;
     options: readonly { value: string; label: string; available: boolean }[];
     selected: readonly string[];
@@ -254,6 +266,16 @@ export function QuickFiltersDialog({
       })),
       selected: quickFilters.power,
     },
+    {
+      key: 'topology',
+      label: t.topology,
+      options: topologyKeys.map((value) => ({
+        value,
+        label: topologyLabel(value, locale, topologyKeys),
+        available: (availableQuickFilters.topologies ?? []).includes(value),
+      })),
+      selected: quickFilters.topologies ?? [],
+    },
   ];
 
   const selectedCount = groups.reduce((count, group) => count + group.selected.length, 0);
@@ -261,26 +283,29 @@ export function QuickFiltersDialog({
   // Every option is a visible toggle: one tap adds or removes it, no dropdown
   // to open first. Empty selection in a group means "all".
   const handleToggle = (
-    category: 'vendor' | 'framework' | 'deployment' | 'spec' | 'power',
+    category: 'vendor' | 'framework' | 'deployment' | 'spec' | 'power' | 'topology',
     value: string,
   ) => {
     const previous: readonly string[] =
-      category === 'vendor'
-        ? quickFilters.vendors
-        : category === 'framework'
-          ? quickFilters.frameworks
-          : category === 'deployment'
-            ? quickFilters.deployment
-            : category === 'power'
-              ? quickFilters.power
-              : quickFilters.spec;
+      category === 'topology'
+        ? (quickFilters.topologies ?? [])
+        : category === 'vendor'
+          ? quickFilters.vendors
+          : category === 'framework'
+            ? quickFilters.frameworks
+            : category === 'deployment'
+              ? quickFilters.deployment
+              : category === 'power'
+                ? quickFilters.power
+                : quickFilters.spec;
     const values = toggleValue(previous, value);
     track('inference_quick_filter_toggled', {
       category,
       value,
       active: values.includes(value),
     });
-    if (category === 'vendor') setQuickFilterVendors(values);
+    if (category === 'topology') setQuickFilterTopologies(values);
+    else if (category === 'vendor') setQuickFilterVendors(values);
     else if (category === 'framework') setQuickFilterFrameworks(values);
     else if (category === 'deployment') setQuickFilterDeployment(values as DeploymentMode[]);
     else if (category === 'power') setQuickFilterPower(values as PowerTier[]);
@@ -293,6 +318,7 @@ export function QuickFiltersDialog({
     setQuickFilterDeployment([]);
     setQuickFilterSpec([]);
     setQuickFilterPower([]);
+    setQuickFilterTopologies([]);
     track('inference_quick_filters_cleared', { source: 'dialog' });
   };
 
@@ -366,7 +392,10 @@ export function QuickFiltersDialog({
                 role="group"
                 aria-labelledby={`quick-filter-${group.key}-label`}
                 data-testid={`quick-filter-${group.key}-options`}
-                className="flex flex-wrap gap-2"
+                className={cn(
+                  'flex min-w-0 flex-wrap gap-2',
+                  group.key === 'topology' && 'max-h-56 overflow-y-auto overscroll-contain pr-1',
+                )}
               >
                 {group.options.map((option) => {
                   const active = group.selected.includes(option.value);
@@ -382,6 +411,8 @@ export function QuickFiltersDialog({
                       title={disabled ? t.noData : undefined}
                       className={cn(
                         'rounded-full font-normal',
+                        group.key === 'topology' &&
+                          'h-auto min-h-9 max-w-full whitespace-normal break-words rounded-lg py-2 text-left md:h-auto',
                         active && 'bg-brand hover:bg-brand/90',
                       )}
                       data-testid={`quick-filter-${group.key}-${option.value}`}
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 1241d8d1c..9111bfd30 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -173,6 +173,7 @@ import {
   isRoleLocalMeasuredEnergyConfigKey,
 } from '@/components/inference/metric-registry';
 import { buildLegendPointsRows } from '@/components/inference/utils/legend-points-table';
+import { groupConcurrencySeries } from '@/components/inference/utils/concurrency-series';
 import { resolveScatterXAxisScale } from '@/components/inference/utils/x-axis-scale';
 import { pointLabelText } from './point-label';
 import {
@@ -441,6 +442,8 @@ const pointCountEn = (count: number) => `${count} ${count === 1 ? 'point' : 'poi
 
 const SCATTER_STRINGS = {
   en: {
+    concurrencyCurves:
+      'Dots are observed loads. Straight segments connect only matching topology, recipe and run; repeated loads remain separate markers. Concurrency is not a higher-is-better score.',
     logScale: 'Log Scale',
     optimalOnly: 'Optimal Only',
     paretoFrontier: 'Pareto Frontier',
@@ -479,6 +482,8 @@ const SCATTER_STRINGS = {
     viewWorkflow: 'View workflow run',
   },
   zh: {
+    concurrencyCurves:
+      '点表示实测负载；直线段仅连接相同拓扑、配方和运行的数据，重复负载保留为独立点。并发数不是越高越好的分数。',
     logScale: '对数缩放',
     optimalOnly: '仅最优',
     paretoFrontier: 'Pareto 前沿',
@@ -590,22 +595,27 @@ const ScatterGraph = React.memo(
       setQuickFilterDeployment,
       setQuickFilterSpec,
       setQuickFilterPower,
+      setQuickFilterTopologies,
       setSelectedYAxisMetric,
     } = useInferenceActions();
-    const paretoDirection = chartDefinition[`${selectedYAxisMetric}_roofline`] as
-      | ParetoDirection
-      | undefined;
+    const isConcurrencyAxis = chartDefinition.x_scale_field === 'conc';
+    const paretoDirection = (
+      isConcurrencyAxis ? undefined : chartDefinition[`${selectedYAxisMetric}_roofline`]
+    ) as ParetoDirection | undefined;
     const hideNonOptimal = preferOptimalOnly && Boolean(paretoDirection);
     const isPowerAxis = isPowerCurveMetric(selectedYAxisMetric);
     const isMeasuredPowerAxis = isMeasuredPowerCurveMetric(selectedYAxisMetric);
     // Measured power describes the load sweep. Keep its boundary fixed while
     // Optimal Only changes marker visibility, as on the other scatter charts.
-    const showPowerEnvelope = isPowerAxis && (isMeasuredPowerAxis || !hideNonOptimal);
+    const showPowerEnvelope =
+      !isConcurrencyAxis && isPowerAxis && (isMeasuredPowerAxis || !hideNonOptimal);
     const showAllMeasurements = isMeasuredPowerAxis ? !hideNonOptimal : savedShowAllMeasurements;
-    const supportsGradientLabels = !showPowerEnvelope || isMeasuredPowerAxis;
+    const supportsGradientLabels =
+      !isConcurrencyAxis && (!showPowerEnvelope || isMeasuredPowerAxis);
     const showGradientLabels = preferGradientLabels && supportsGradientLabels;
     const groupDisplayedPoints = useCallback(
       (points: InferenceData[]) => {
+        if (isConcurrencyAxis) return groupConcurrencySeries(points);
         const groups = groupPointsByDate(points);
         if (showPowerEnvelope) {
           for (const [date, samples] of groups) {
@@ -621,7 +631,7 @@ const ScatterGraph = React.memo(
         }
         return groups;
       },
-      [showPowerEnvelope, chartDefinition.chartType, selectedYAxisMetric],
+      [isConcurrencyAxis, showPowerEnvelope, chartDefinition.chartType, selectedYAxisMetric],
     );
     const locale = useLocale();
     const featureGateUnlocked = useFeatureGate();
@@ -908,7 +918,7 @@ const ScatterGraph = React.memo(
       return result;
     }, [groupedData, selectedYAxisMetric, chartDefinition]);
 
-    const displayedRooflines = showPowerEnvelope ? groupedData : rooflines;
+    const displayedRooflines = isConcurrencyAxis || showPowerEnvelope ? groupedData : rooflines;
 
     const powerEnvelopePointKeys = useMemo(() => {
       const keys = new Set<string>();
@@ -957,8 +967,13 @@ const ScatterGraph = React.memo(
       return false;
     }, [data]);
     const buildPointId = useCallback(
-      (point: InferenceData) => scatterPointJoinId(point, distinguishPointDates),
-      [distinguishPointDates],
+      (point: InferenceData) => {
+        const configId = scatterPointJoinId(point, distinguishPointDates);
+        return isConcurrencyAxis
+          ? `${configId}|observation-${point.id ?? data.indexOf(point)}|run-${point.run_url ?? ''}`
+          : configId;
+      },
+      [isConcurrencyAxis, data, distinguishPointDates],
     );
 
     // filteredData: visible points only (for scale domain calculation)
@@ -1206,7 +1221,7 @@ const ScatterGraph = React.memo(
       [overlayGroups, paretoDirection],
     );
     const displayedOverlayRooflines = useMemo(() => {
-      if (!showPowerEnvelope) return overlayRooflines;
+      if (!showPowerEnvelope && !isConcurrencyAxis) return overlayRooflines;
       return Object.fromEntries(
         Object.entries(overlayGroups).flatMap(([key, group]) =>
           [...groupDisplayedPoints(group.points)].map(([segment, points]) => [
@@ -1215,7 +1230,13 @@ const ScatterGraph = React.memo(
           ]),
         ),
       );
-    }, [showPowerEnvelope, overlayRooflines, overlayGroups, groupDisplayedPoints]);
+    }, [
+      isConcurrencyAxis,
+      showPowerEnvelope,
+      overlayRooflines,
+      overlayGroups,
+      groupDisplayedPoints,
+    ]);
 
     // Overlay counterpart of `optimalPointKeys`: the points on any overlay
     // run's drawn roofline (already e2e-restricted for agentic non-e2e modes).
@@ -1349,6 +1370,7 @@ const ScatterGraph = React.memo(
       (lockedFrameworks ? 0 : quickFilters.frameworks.length) +
       quickFilters.deployment.length +
       quickFilters.power.length +
+      (quickFilters.topologies?.length ?? 0) +
       (selectedSequence === Sequence.AgenticTraces ? 0 : quickFilters.spec.length);
     const clearQuickFilters = useCallback(() => {
       setQuickFilterVendors([]);
@@ -1356,12 +1378,14 @@ const ScatterGraph = React.memo(
       setQuickFilterDeployment([]);
       if (selectedSequence !== Sequence.AgenticTraces) setQuickFilterSpec([]);
       setQuickFilterPower([]);
+      setQuickFilterTopologies([]);
     }, [
       setQuickFilterVendors,
       setQuickFilterFrameworks,
       setQuickFilterDeployment,
       setQuickFilterSpec,
       setQuickFilterPower,
+      setQuickFilterTopologies,
       selectedSequence,
     ]);
 
@@ -1552,7 +1576,11 @@ const ScatterGraph = React.memo(
     const metricIdentity = useMemo(
       () =>
         [
-          showPowerEnvelope ? 'power-envelopes' : 'pareto-curves',
+          isConcurrencyAxis
+            ? 'observed-load'
+            : showPowerEnvelope
+              ? 'power-envelopes'
+              : 'pareto-curves',
           useAdvancedLabels ? 'advanced-labels' : 'basic-labels',
           showConcurrencyLabels ? 'conc-labels' : 'no-conc-labels',
           selectedYAxisMetric,
@@ -1570,6 +1598,7 @@ const ScatterGraph = React.memo(
           .toSorted()
           .join('|'),
       [
+        isConcurrencyAxis,
         showPowerEnvelope,
         selectedYAxisMetric,
         useAdvancedLabels,
@@ -1957,7 +1986,8 @@ const ScatterGraph = React.memo(
         persistedRulers !== undefined &&
         (persistedRulers.pending !== null || persistedRulers.state.rulers.length > 0),
     );
-    const perfRulerMode = preferPerfRulerMode && (!showPowerEnvelope || isMeasuredPowerAxis);
+    const perfRulerMode =
+      !isConcurrencyAxis && preferPerfRulerMode && (!showPowerEnvelope || isMeasuredPowerAxis);
     const [localPerfRulerState, setLocalPerfRulerState] =
       useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
     const perfRulerState = persistedRulers ? persistedRulers.state : localPerfRulerState;
@@ -2664,7 +2694,7 @@ const ScatterGraph = React.memo(
             .line<InferenceData>()
             .x((d) => xScale(d.x))
             .y((d) => yScale(d.y))
-            .curve(d3.curveMonotoneX);
+            .curve(isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX);
 
           // Ensure rooflines layer exists before dot-groups
           let rooflinesLayer = zoomGroup.select<SVGGElement>('.rooflines-layer');
@@ -2767,7 +2797,10 @@ const ScatterGraph = React.memo(
             )
             .join('path')
             .attr('class', (d) => `roofline-path roofline-${d.key}`)
-            .attr('data-curve-kind', showPowerEnvelope ? 'power-envelope' : 'pareto')
+            .attr(
+              'data-curve-kind',
+              isConcurrencyAxis ? 'observed-load' : showPowerEnvelope ? 'power-envelope' : 'pareto',
+            )
             .attr('data-hw-key', (d) => d.hw)
             .attr('data-precision', (d) => d.precision)
             .attr('data-power-variant', (d) => d.variant || null)
@@ -2866,7 +2899,10 @@ const ScatterGraph = React.memo(
               (exit) => exit.remove(),
             )
             .attr('data-seg-key', (d) => d.segKey)
-            .attr('data-curve-kind', showPowerEnvelope ? 'power-envelope' : 'pareto')
+            .attr(
+              'data-curve-kind',
+              isConcurrencyAxis ? 'observed-load' : showPowerEnvelope ? 'power-envelope' : 'pareto',
+            )
             .attr('data-hw-key', (d) => d.hw)
             .attr('data-precision', (d) => d.precision)
             .attr('transform', (d) => `translate(${d.x},${d.y})`)
@@ -3159,7 +3195,7 @@ const ScatterGraph = React.memo(
             .line<InferenceData>()
             .x((d) => newXScale(d.x))
             .y((d) => newYScale(d.y))
-            .curve(d3.curveMonotoneX);
+            .curve(isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX);
 
           // Update roofline paths — must split per-date so the zoom redraw
           // matches the per-date sub-paths created in the initial render.
@@ -3390,7 +3426,7 @@ const ScatterGraph = React.memo(
                 .line<InferenceData>()
                 .x((d) => xScale(d.x))
                 .y((d) => yScale(d.y))
-                .curve(d3.curveMonotoneX);
+                .curve(isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX);
 
               interface OvEntry {
                 key: string;
@@ -3423,7 +3459,14 @@ const ScatterGraph = React.memo(
                 .data(ovEntries, (d) => d.key)
                 .join('path')
                 .attr('class', (d) => `overlay-roofline-path overlay-roofline-${d.key}`)
-                .attr('data-curve-kind', showPowerEnvelope ? 'power-envelope' : 'pareto')
+                .attr(
+                  'data-curve-kind',
+                  isConcurrencyAxis
+                    ? 'observed-load'
+                    : showPowerEnvelope
+                      ? 'power-envelope'
+                      : 'pareto',
+                )
                 .attr('fill', 'none')
                 .attr('stroke', (d) => d.stroke)
                 .attr('stroke-width', 2)
@@ -3577,7 +3620,7 @@ const ScatterGraph = React.memo(
                 .line<InferenceData>()
                 .x((d) => newXScale(d.x))
                 .y((d) => newYScale(d.y))
-                .curve(d3.curveMonotoneX);
+                .curve(isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX);
 
               Object.entries(displayedOverlayRooflines).forEach(([key, group]) => {
                 if (group.points.length < 2) return;
@@ -3665,7 +3708,7 @@ const ScatterGraph = React.memo(
             .line<InferenceData>()
             .x((point) => xScale(point.x))
             .y((point) => yScale(point.y))
-            .curve(d3.curveMonotoneX);
+            .curve(isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX);
           const continuationPath = group
             .select<SVGPathElement>('.overflow-continuation-line')
             .attr('d', lineGenerator(entry.points) ?? '')
@@ -3806,6 +3849,7 @@ const ScatterGraph = React.memo(
       // existing DOM when it changes. Only data/structure changes recreate
       // the layers (and with them, the full chart render).
     }, [
+      isConcurrencyAxis,
       displayedRooflines,
       paretoHighlightLayer,
       groupDisplayedPoints,
@@ -4257,7 +4301,11 @@ const ScatterGraph = React.memo(
           <QuickFiltersDialog
             open={quickFiltersOpen}
             onOpenChange={setQuickFiltersOpen}
-            bestPerSku={{ checked: bestPerSku, onCheckedChange: handleBestPerSkuChange }}
+            bestPerSku={
+              isConcurrencyAxis
+                ? undefined
+                : { checked: bestPerSku, onCheckedChange: handleBestPerSkuChange }
+            }
           />
         </div>
       );
@@ -4281,14 +4329,18 @@ const ScatterGraph = React.memo(
           testId="scatter-graph"
           grabCursor={true}
           caption={
-            isPowerAxis ? (
+            isPowerAxis || isConcurrencyAxis ? (
               <>
                 {caption}
                 <p
                   data-testid="power-curve-description"
                   className="mt-2 text-2xs text-muted-foreground"
                 >
-                  {showPowerEnvelope ? legendT.powerCurves : legendT.powerOptimal}
+                  {isConcurrencyAxis
+                    ? legendT.concurrencyCurves
+                    : showPowerEnvelope
+                      ? legendT.powerCurves
+                      : legendT.powerOptimal}
                 </p>
               </>
             ) : (
@@ -4563,7 +4615,7 @@ const ScatterGraph = React.memo(
                     track('latency_line_labels_toggled', { enabled: checked });
                   },
                 },
-                ...(showPowerEnvelope && !isMeasuredPowerAxis
+                ...(isConcurrencyAxis || (showPowerEnvelope && !isMeasuredPowerAxis)
                   ? []
                   : [
                       {
@@ -4653,14 +4705,18 @@ const ScatterGraph = React.memo(
           <MeasuredPowerSummary
             total={powerTierCounts.total}
             visible={powerTierCounts.visible}
-            bestPerSku={bestPerSku}
+            bestPerSku={!isConcurrencyAxis && bestPerSku}
             optimalOnly={hideNonOptimal}
           />
         )}
         <QuickFiltersDialog
           open={quickFiltersOpen}
           onOpenChange={setQuickFiltersOpen}
-          bestPerSku={{ checked: bestPerSku, onCheckedChange: handleBestPerSkuChange }}
+          bestPerSku={
+            isConcurrencyAxis
+              ? undefined
+              : { checked: bestPerSku, onCheckedChange: handleBestPerSkuChange }
+          }
         />
         {pointsTable && (
           <LegendPointsDialog
diff --git a/packages/app/src/components/inference/ui/XAxisModeSelector.tsx b/packages/app/src/components/inference/ui/XAxisModeSelector.tsx
index 70bfb757f..418b48fae 100644
--- a/packages/app/src/components/inference/ui/XAxisModeSelector.tsx
+++ b/packages/app/src/components/inference/ui/XAxisModeSelector.tsx
@@ -10,6 +10,7 @@ import { SearchableSelect } from '@/components/ui/searchable-select';
 import { X_AXIS_EXPLANATIONS, type XAxisKind } from '../axis-metric-explanations';
 import { isAgenticOnlyXAxisMode, type XAxisMode } from '../hooks/useChartData';
 import { useLocale } from '@/lib/use-locale';
+import type { FixedSequenceStatistic } from '../utils/resolveXAxisField';
 import { NormalizedInteractivityHelpLink } from './NormalizedInteractivityHelpLink';
 
 const X_AXIS_OPTIONS: { value: XAxisMode; kind: XAxisKind; label: string; labelZh: string }[] = [
@@ -19,6 +20,7 @@ const X_AXIS_OPTIONS: { value: XAxisMode; kind: XAxisKind; label: string; labelZ
     label: 'E2E Normalized Interactivity',
     labelZh: '端到端归一化交互性',
   },
+  { value: 'concurrency', kind: 'concurrency', label: 'Concurrency', labelZh: '并发数' },
   { value: 'interactivity', kind: 'interactivity', label: 'Interactivity', labelZh: '交互性' },
   { value: 'e2e', kind: 'e2eLatency', label: 'E2E Latency', labelZh: '端到端延迟' },
   { value: 'ttft', kind: 'ttft', label: 'TTFT', labelZh: 'TTFT' },
@@ -27,17 +29,31 @@ const X_AXIS_OPTIONS: { value: XAxisMode; kind: XAxisKind; label: string; labelZ
 const STRINGS = {
   en: {
     label: 'X-Axis Metric',
-    help: 'Choose the horizontal axis: Interactivity, end-to-end latency, or Time To First Token (TTFT). Agentic scenarios also offer E2E Normalized Interactivity.',
+    statistic: 'Service Statistic',
+    mean: 'Mean',
+    median: 'Median',
+    statisticHelp:
+      'Mean interactivity is 1 ÷ mean time per output token (TPOT, in seconds), not the arithmetic mean of per-request token rates. Mean TTFT and E2E use their reported means; unavailable measurements are omitted. Median uses the reported median for each metric.',
+    help: 'Choose the horizontal axis: Concurrency, Interactivity, end-to-end latency, or Time To First Token (TTFT). Agentic scenarios also offer E2E Normalized Interactivity.',
   },
   zh: {
     label: 'X 轴指标',
-    help: '选择横轴指标：交互性、端到端延迟或首 token 延迟（TTFT）。Agentic 场景还支持端到端归一化交互性。',
+    statistic: '服务指标统计量',
+    mean: '平均值',
+    median: '中位数',
+    statisticHelp:
+      '平均交互性 = 1 ÷ 平均每输出 token 耗时（TPOT，单位为秒），不是逐请求 token 速率的算术平均值。平均 TTFT 和端到端延迟使用各自上报的平均值；缺失的数据点不显示。中位数选项使用各指标上报的中位数。',
+    help: '选择横轴指标：并发数、交互性、端到端延迟或首 token 延迟（TTFT）。Agentic 场景还支持端到端归一化交互性。',
   },
 } as const;
 
 export function XAxisModeSelector() {
-  const { selectedXAxisMode: value, selectedPercentile } = useInferenceDisplay();
-  const { setSelectedXAxisMode } = useInferenceActions();
+  const {
+    selectedXAxisMode: value,
+    selectedPercentile,
+    fixedSequenceStatistic,
+  } = useInferenceDisplay();
+  const { setSelectedXAxisMode, setFixedSequenceStatistic } = useInferenceActions();
   const { selectedSequence } = useInferenceFilters();
   const isAgentic = selectedSequence === Sequence.AgenticTraces;
   const [mounted, setMounted] = useState(false);
@@ -51,45 +67,82 @@ export function XAxisModeSelector() {
 
   return (
     <TooltipProvider delayDuration={0}>
-      <div
-        className={`flex w-full min-w-0 flex-col space-y-1.5 ${isAgentic ? 'max-w-72' : 'max-w-44'}`}
-      >
-        <LabelWithTooltip htmlFor="x-axis-mode-select" label={t.label} tooltip={t.help} />
-        <SearchableSelect
-          value={value}
-          triggerId="x-axis-mode-select"
-          triggerTestId="x-axis-mode-selector"
-          placeholder={t.label}
-          initialLabel={locale === 'zh' ? '交互性' : 'Interactivity'}
-          searchable={false}
-          onValueChange={(mode) => {
-            setSelectedXAxisMode(mode as XAxisMode);
-            track('latency_x_axis_mode_selected', { mode });
-          }}
-          groups={[
-            {
-              label: '',
-              options: options.map(({ value: option, kind, label, labelZh }) => ({
-                value: option,
-                label: locale === 'zh' ? labelZh : label,
-                testId: `x-axis-mode-${option}`,
-                help: (
-                  <>
-                    <p className="text-xs">
-                      {X_AXIS_EXPLANATIONS[kind].name[locale](
-                        isAgentic ? selectedPercentile.toUpperCase() : null,
+      <div className="flex w-full flex-wrap gap-4">
+        <div
+          className={`flex w-full min-w-0 flex-col space-y-1.5 ${isAgentic ? 'max-w-72' : 'max-w-44'}`}
+        >
+          <LabelWithTooltip htmlFor="x-axis-mode-select" label={t.label} tooltip={t.help} />
+          <SearchableSelect
+            value={value}
+            triggerId="x-axis-mode-select"
+            triggerTestId="x-axis-mode-selector"
+            placeholder={t.label}
+            initialLabel={locale === 'zh' ? '交互性' : 'Interactivity'}
+            searchable={false}
+            onValueChange={(mode) => {
+              setSelectedXAxisMode(mode as XAxisMode);
+              track('latency_x_axis_mode_selected', { mode });
+            }}
+            groups={[
+              {
+                label: '',
+                options: options.map(({ value: option, kind, label, labelZh }) => ({
+                  value: option,
+                  label: locale === 'zh' ? labelZh : label,
+                  testId: `x-axis-mode-${option}`,
+                  help: (
+                    <>
+                      <p className="text-xs">
+                        {X_AXIS_EXPLANATIONS[kind].name[locale](
+                          isAgentic
+                            ? selectedPercentile.toUpperCase()
+                            : fixedSequenceStatistic === 'mean'
+                              ? 'Mean'
+                              : 'Median',
+                        )}
+                      </p>
+                      <p>{X_AXIS_EXPLANATIONS[kind].description[locale]}</p>
+                      {isAgenticOnlyXAxisMode(option) && (
+                        <NormalizedInteractivityHelpLink locale={locale} />
                       )}
-                    </p>
-                    <p>{X_AXIS_EXPLANATIONS[kind].description[locale]}</p>
-                    {isAgenticOnlyXAxisMode(option) && (
-                      <NormalizedInteractivityHelpLink locale={locale} />
-                    )}
-                  </>
-                ),
-              })),
-            },
-          ]}
-        />
+                    </>
+                  ),
+                })),
+              },
+            ]}
+          />
+        </div>
+        {mounted && !isAgentic && value !== 'concurrency' && (
+          <div className="flex w-full max-w-44 min-w-0 flex-col space-y-1.5">
+            <LabelWithTooltip
+              htmlFor="fixed-sequence-statistic-select"
+              label={t.statistic}
+              tooltip={t.statisticHelp}
+            />
+            <SearchableSelect
+              value={fixedSequenceStatistic}
+              triggerId="fixed-sequence-statistic-select"
+              triggerTestId="fixed-sequence-statistic-selector"
+              placeholder={t.statistic}
+              searchable={false}
+              onValueChange={(statistic) => {
+                setFixedSequenceStatistic(statistic as FixedSequenceStatistic);
+                track('latency_service_statistic_selected', { statistic });
+              }}
+              groups={[
+                {
+                  label: '',
+                  options: (['median', 'mean'] as const).map((statistic) => ({
+                    value: statistic,
+                    label: t[statistic],
+                    testId: `fixed-sequence-statistic-${statistic}`,
+                    help: <p>{t.statisticHelp}</p>,
+                  })),
+                },
+              ]}
+            />
+          </div>
+        )}
       </div>
     </TooltipProvider>
   );
diff --git a/packages/app/src/components/inference/utils.test.ts b/packages/app/src/components/inference/utils.test.ts
index f1560a7fb..3af37c473 100644
--- a/packages/app/src/components/inference/utils.test.ts
+++ b/packages/app/src/components/inference/utils.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest';
 
 import type { ChartDefinition, InferenceData } from '@/components/inference/types';
+import { resolveXAxisField } from './utils/resolveXAxisField';
 import {
   filterDataByCostLimit,
   partitionChartDataByLimits,
@@ -226,6 +227,38 @@ describe('processOverlayChartData', () => {
     expect(result.clippedData).toEqual([]);
   });
 
+  it('retains exact concurrency in unofficial overlays regardless of latency or optimization stamps', () => {
+    const points = [1, 4, 128].map((conc) => ({
+      ...prefillEnergyPoint(68, 120),
+      conc,
+      isOnNormalizedInteractivityFrontier: false,
+    }));
+    const result = processOverlayChartDataWithClipping(
+      points,
+      'e2e',
+      'y_measuredPrefillJPerInputToken',
+      'p90_ttft',
+      { isAgentic: false, selectedPercentile: 'p90', selectedXAxisMode: 'concurrency' },
+    );
+    expect(result.data.map((point) => [point.x, point.y])).toEqual([
+      [1, 0.2],
+      [4, 0.2],
+      [128, 0.2],
+    ]);
+    expect(result.clippedData).toEqual([]);
+  });
+
+  it('never substitutes latency coordinates for missing concurrency', () => {
+    const result = processOverlayChartDataWithClipping(
+      [{ ...prefillEnergyPoint(68, 120), conc: Number.NaN }],
+      'e2e',
+      'y_measuredPrefillJPerInputToken',
+      null,
+      { selectedXAxisMode: 'concurrency' },
+    );
+    expect(result.data).toEqual([]);
+  });
+
   it('uses median TTFT for fixed-sequence overlays in TTFT mode and omits missing measurements', () => {
     const result = processOverlayChartDataWithClipping(
       [prefillEnergyPoint(68, 1.5), prefillEnergyPoint(55)],
@@ -623,3 +656,74 @@ describe('TPUv7 overlay TCO basis', () => {
     ).toBe(1.21);
   });
 });
+
+describe('fixed-sequence service statistic resolution', () => {
+  it.each([
+    ['interactivity', 'interactivity', 'median_intvty', 'mean_tpot_intvty'],
+    ['e2e', 'e2e', 'median_e2el', 'mean_e2el'],
+    ['ttft', 'e2e', 'median_e2el', 'mean_ttft'],
+  ] as const)(
+    'resolves mean %s without changing its preference direction',
+    (mode, type, natural, mean) => {
+      const definition = chartDef({ chartType: type, x: natural });
+      const resolved = resolveXAxisField(definition, 'y_tpPerGpu', 'p90_ttft', {
+        isAgentic: false,
+        percentile: 'p90',
+        xAxisMode: mode,
+        fixedSequenceStatistic: 'mean',
+      });
+      expect(resolved.xAxisField).toBe(mean);
+      expect(
+        resolveXAxisField(definition, 'y_tpPerGpu', null, {
+          isAgentic: false,
+          percentile: 'p90',
+          xAxisMode: mode,
+        }).xAxisField,
+      ).toBe(mode === 'ttft' ? 'median_ttft' : natural);
+      if (mode !== 'ttft') expect(resolved.naturalX).toBe(mean);
+    },
+  );
+
+  it('does not apply fixed-sequence means to agentic percentiles or observed concurrency', () => {
+    const definition = chartDef({ chartType: 'interactivity', x: 'median_intvty' });
+    expect(
+      resolveXAxisField(definition, 'y_tpPerGpu', null, {
+        isAgentic: true,
+        percentile: 'p90',
+        xAxisMode: 'interactivity',
+        fixedSequenceStatistic: 'mean',
+      }).xAxisField,
+    ).toBe('p90_intvty');
+    expect(
+      resolveXAxisField(definition, 'y_tpPerGpu', null, {
+        isAgentic: false,
+        percentile: 'p90',
+        xAxisMode: 'concurrency',
+        fixedSequenceStatistic: 'mean',
+      }).xAxisField,
+    ).toBe('conc');
+  });
+
+  it.each(['mean_tpot_intvty', 'mean_ttft', 'mean_e2el'] as const)(
+    'omits missing/invalid %s from overlays rather than reusing median or raw speed',
+    (field) => {
+      const mode =
+        field === 'mean_tpot_intvty' ? 'interactivity' : field === 'mean_ttft' ? 'ttft' : 'e2e';
+      const type = mode === 'interactivity' ? 'interactivity' : 'e2e';
+      const points = [undefined, 0, -1, NaN, Infinity, 4].map((value) =>
+        pt({
+          [field]: value,
+          mean_intvty: 999,
+          median_intvty: 100,
+          median_ttft: 1,
+          median_e2el: 3,
+        }),
+      );
+      const result = processOverlayChartData(points, type, 'y_tpPerGpu', null, {
+        selectedXAxisMode: mode,
+        fixedSequenceStatistic: 'mean',
+      });
+      expect(result.map((point) => point.x)).toEqual([4]);
+    },
+  );
+});
diff --git a/packages/app/src/components/inference/utils.ts b/packages/app/src/components/inference/utils.ts
index 1794cd585..f459b5639 100644
--- a/packages/app/src/components/inference/utils.ts
+++ b/packages/app/src/components/inference/utils.ts
@@ -6,7 +6,10 @@ import { getGpuSpecs, type TcoBasis } from '@/lib/constants';
  */
 
 import chartDefinitions from '@/components/inference/metric-registry';
-import { resolveXAxisField } from '@/components/inference/utils/resolveXAxisField';
+import {
+  resolveXAxisField,
+  type FixedSequenceStatistic,
+} from '@/components/inference/utils/resolveXAxisField';
 import { remapInferencePoint } from '@/lib/chart-utils';
 import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
 
@@ -103,6 +106,9 @@ export function partitionChartDataByLimits(
   selectedYAxisMetric: string,
   options: { isTtftX: boolean; isAgentic: boolean },
 ): ProcessedChartData {
+  if (chartDefinition.x_scale_field === 'conc') {
+    return { data: data.filter((point) => Number.isFinite(point.x)), clippedData: [] };
+  }
   const costLimitApplies =
     selectedYAxisMetric.includes('cost') &&
     selectedYAxisMetric !== 'y_costUser' &&
@@ -150,6 +156,7 @@ export function processOverlayChartData(
     isAgentic?: boolean;
     selectedPercentile?: string;
     selectedXAxisMode?: XAxisMode;
+    fixedSequenceStatistic?: FixedSequenceStatistic;
     restrictToNormalizedFrontier?: boolean;
     tcoBasis?: TcoBasis;
     powerCompare?: PowerCompare;
@@ -177,6 +184,7 @@ export function processOverlayChartDataWithClipping(
     isAgentic?: boolean;
     selectedPercentile?: string;
     selectedXAxisMode?: XAxisMode;
+    fixedSequenceStatistic?: FixedSequenceStatistic;
     restrictToNormalizedFrontier?: boolean;
     tcoBasis?: TcoBasis;
     /** Sibling boundary / role series, mirroring the official path in useChartData. */
@@ -226,6 +234,7 @@ export function processOverlayChartDataWithClipping(
     isAgentic,
     percentile: selectedPercentile,
     xAxisMode: options?.selectedXAxisMode,
+    fixedSequenceStatistic: options?.fixedSequenceStatistic,
   });
 
   // The latency limit targets overload outliers on the TTFT axis only; skip it
@@ -251,8 +260,13 @@ export function processOverlayChartDataWithClipping(
     }
   }
 
-  return partitionChartDataByLimits(processedData, chartDef, selectedYAxisMetric, {
-    isTtftX,
-    isAgentic,
-  });
+  return partitionChartDataByLimits(
+    processedData,
+    { ...chartDef, x_scale_field: xAxisField },
+    selectedYAxisMetric,
+    {
+      isTtftX,
+      isAgentic,
+    },
+  );
 }
diff --git a/packages/app/src/components/inference/utils/concurrency-series.ts b/packages/app/src/components/inference/utils/concurrency-series.ts
new file mode 100644
index 000000000..94d46e18a
--- /dev/null
+++ b/packages/app/src/components/inference/utils/concurrency-series.ts
@@ -0,0 +1,36 @@
+import type { InferenceData } from '../types';
+import { pointTopologyKey } from './topology-filter';
+
+/** Observed load sweeps, never a Pareto frontier or an envelope. */
+export function groupConcurrencySeries(
+  points: readonly InferenceData[],
+): Map<string, InferenceData[]> {
+  const groups = new Map<string, InferenceData[]>();
+  for (const [index, point] of points.entries()) {
+    // Unknown provenance cannot establish a controlled sweep. Keep its marker.
+    const run = point.run_url || `unknown-run-${index}`;
+    const key = JSON.stringify([
+      point.hwKey,
+      point.precision,
+      point.date,
+      run,
+      pointTopologyKey(point),
+      point.recipe_fingerprint ?? null,
+      point.powerVariant?.id ?? null,
+    ]);
+    const group = groups.get(key);
+    if (group) group.push(point);
+    else groups.set(key, [point]);
+  }
+  const segments = new Map<string, InferenceData[]>();
+  for (const [key, group] of groups) {
+    const sorted = group.toSorted((a, b) => a.x - b.x);
+    if (new Set(sorted.map((point) => point.x)).size === sorted.length) {
+      segments.set(key, sorted);
+    } else {
+      // Repeats at the same load are distinct observations, not a fitted mean.
+      sorted.forEach((point, index) => segments.set(`${key}:${index}`, [point]));
+    }
+  }
+  return segments;
+}
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
new file mode 100644
index 000000000..f202b7b30
--- /dev/null
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
@@ -0,0 +1,295 @@
+import { describe, expect, it } from 'vitest';
+import type { InferenceData } from '../types';
+import {
+  buildEqualServiceComparison,
+  equalServiceSourceKey,
+  getEqualServiceComparisonCurve,
+  getEqualServiceSources,
+  getPrefillSharePoints,
+} from './equal-service-comparison';
+
+const metric = (y: number) => ({ y, roof: false });
+function point(overrides: Partial<InferenceData> = {}): InferenceData {
+  return {
+    x: 20,
+    y: 500,
+    hwKey: 'b200_sglang',
+    date: '2026-09-23',
+    tp: 4,
+    physicalChips: 4,
+    precision: 'fp8',
+    conc: 8,
+    run_url: 'https://example.invalid/runs/1',
+    model: 'qwen3.5',
+    benchmark_type: 'single_turn',
+    isl: 8192,
+    osl: 1024,
+    decode_tp: 4,
+    mean_intvty: 20,
+    output_tput_per_gpu: 50,
+    measuredAvgPower: metric(400),
+    measuredJPerOutputToken: metric(10),
+    tpPerGpu: metric(50),
+    tpPerMw: metric(50),
+    costh: metric(1),
+    costr: metric(1),
+    costhi: metric(1),
+    costri: metric(1),
+    ...overrides,
+  };
+}
+const a = [
+  point({ id: 1 }),
+  point({
+    id: 2,
+    mean_intvty: 60,
+    conc: 1,
+    measuredAvgPower: metric(800),
+    output_tput_per_gpu: 150,
+    measuredJPerOutputToken: metric(30),
+  }),
+];
+const b = [
+  point({
+    id: 3,
+    hwKey: 'b300_sglang',
+    run_url: 'https://example.invalid/runs/2',
+    measuredAvgPower: metric(800),
+    output_tput_per_gpu: 100,
+    measuredJPerOutputToken: metric(8),
+  }),
+  point({
+    id: 4,
+    hwKey: 'b300_sglang',
+    run_url: 'https://example.invalid/runs/2',
+    mean_intvty: 60,
+    conc: 1,
+    measuredAvgPower: metric(1000),
+    output_tput_per_gpu: 200,
+    measuredJPerOutputToken: metric(16),
+  }),
+];
+const options = {
+  baseline: equalServiceSourceKey(a[0]),
+  comparator: equalServiceSourceKey(b[0]),
+  target: 40,
+  xField: 'mean_intvty' as const,
+};
+
+describe('equal-service comparison', () => {
+  it('interpolates each raw quantity first, retains endpoints, and uses one percentage sign convention', () => {
+    const result = buildEqualServiceComparison([...a, ...b], options);
+    expect(result.metrics.meanWattsPerGpu).toMatchObject({
+      baseline: { value: 600, interpolated: true },
+      comparator: { value: 900 },
+      changePercent: 50,
+    });
+    expect(result.metrics.outputTokensPerSecond).toMatchObject({
+      baseline: { value: 400 },
+      comparator: { value: 600 },
+      changePercent: 50,
+    });
+    expect(result.metrics.joulesPerOutputToken).toMatchObject({
+      baseline: { value: 20 },
+      comparator: { value: 12 },
+      changePercent: -40,
+    });
+    expect(
+      result.metrics.meanWattsPerGpu.baseline?.endpoints.map(({ point: p }) => [
+        p.id,
+        p.conc,
+        p.run_url,
+      ]),
+    ).toEqual([
+      [1, 8, a[0].run_url],
+      [2, 1, a[1].run_url],
+    ]);
+    // Interpolating the endpoint percentages instead would incorrectly give 62.5%.
+    expect(result.metrics.meanWattsPerGpu.changePercent).not.toBe(62.5);
+  });
+
+  it('uses exact observations without interpolation and accepts consistent repeated observations', () => {
+    const result = buildEqualServiceComparison([...a, { ...a[0], id: 5 }, ...b], {
+      ...options,
+      target: 20,
+    });
+    expect(result.metrics.meanWattsPerGpu.baseline).toMatchObject({
+      value: 400,
+      interpolated: false,
+    });
+    expect(result.metrics.meanWattsPerGpu.baseline?.endpoints.map(({ point: p }) => p.id)).toEqual([
+      1, 5,
+    ]);
+  });
+
+  it('does not skip a missing interior measurement or turn it into zero', () => {
+    const gap = point({ id: 5, mean_intvty: 40, measuredAvgPower: undefined });
+    const result = buildEqualServiceComparison([...a, gap, ...b], { ...options, target: 50 });
+    expect(result.metrics.meanWattsPerGpu).toMatchObject({
+      baseline: null,
+      changePercent: null,
+      reason: 'missing-metric',
+    });
+    expect(result.metrics.outputTokensPerSecond.changePercent).not.toBeNull();
+  });
+
+  it('rejects conflicting duplicate X per quantity instead of averaging them', () => {
+    const conflict = point({ ...a[0], id: 5, measuredAvgPower: metric(401) });
+    const result = buildEqualServiceComparison([...a, conflict, ...b], options);
+    expect(result.metrics.meanWattsPerGpu.reason).toBe('ambiguous-x');
+    expect(result.metrics.meanWattsPerGpu.changePercent).toBeNull();
+    expect(result.metrics.joulesPerOutputToken.changePercent).toBe(-40);
+  });
+
+  it.each([0, -1, Number.NaN, Number.POSITIVE_INFINITY])('withholds invalid metric %s', (value) => {
+    const rows = a.map((p) => ({ ...p, measuredAvgPower: metric(value) }));
+    expect(
+      buildEqualServiceComparison([...rows, ...b], options).metrics.meanWattsPerGpu.reason,
+    ).toBe('missing-metric');
+  });
+
+  it('rejects extrapolation, invalid target, same source, unknown source and concurrency as service', () => {
+    expect(
+      buildEqualServiceComparison([...a, ...b], { ...options, target: 61 }).metrics.meanWattsPerGpu
+        .reason,
+    ).toBe('out-of-range');
+    expect(buildEqualServiceComparison([...a, ...b], { ...options, target: NaN }).reason).toBe(
+      'invalid-target',
+    );
+    expect(
+      buildEqualServiceComparison([...a, ...b], { ...options, comparator: options.baseline })
+        .reason,
+    ).toBe('same-source');
+    expect(
+      buildEqualServiceComparison([...a, ...b], { ...options, comparator: 'missing' }).reason,
+    ).toBe('unknown-source');
+    expect(buildEqualServiceComparison([...a, ...b], { ...options, xField: 'conc' }).reason).toBe(
+      'unsupported-axis',
+    );
+  });
+
+  it('keeps run, actual date, topology, recipe, image, runtime and attempt isolated', () => {
+    const variants = [
+      { run_url: 'https://example.invalid/runs/3' },
+      { actualDate: '2026-09-22' },
+      { decode_pp: 2 },
+      { recipe_fingerprint: 'recipe-2' },
+      { image: 'new-image' },
+      { spec_decoding: 'mtp' },
+      { kv_offload_backend: 'other' },
+    ];
+    for (const variant of variants) {
+      const altered = point({ ...a[1], ...variant });
+      expect(equalServiceSourceKey(altered)).not.toBe(options.baseline);
+      expect(
+        buildEqualServiceComparison([a[0], altered, ...b], options).metrics.meanWattsPerGpu.reason,
+      ).toBe('out-of-range');
+    }
+    const attempted = { ...a[0], run_attempt: 2 };
+    expect(equalServiceSourceKey(attempted)).not.toBe(options.baseline);
+    expect(equalServiceSourceKey(point({ id: 1, run_url: undefined }))).not.toBe(
+      equalServiceSourceKey(point({ id: 2, run_url: undefined })),
+    );
+    expect(getEqualServiceSources([...b, ...a])).toEqual(getEqualServiceSources([...a, ...b]));
+  });
+
+  it('keeps source keys stable across UI display-date overrides and uses the requested mean basis', () => {
+    expect(equalServiceSourceKey({ ...a[0], date: '2026-09-24', actualDate: a[0].date })).toBe(
+      equalServiceSourceKey(a[0]),
+    );
+    const rows = [...a, ...b].map((p) => ({ ...p, mean_tpot_intvty: p.mean_intvty! / 2 }));
+    const result = buildEqualServiceComparison(rows, {
+      ...options,
+      xField: 'mean_tpot_intvty',
+      target: 20,
+    });
+    expect(result.metrics.meanWattsPerGpu.baseline?.value).toBe(600);
+    expect(result.metrics.meanWattsPerGpu.changePercent).toBe(50);
+  });
+
+  it('ignores comparison clones and hidden sources, supports ordinary overlay run URLs', () => {
+    const overlay = a.map((p) => ({
+      ...p,
+      id: undefined,
+      run_url: 'https://example.invalid/runs/overlay',
+    }));
+    const result = buildEqualServiceComparison(
+      [
+        ...overlay,
+        ...b,
+        { ...a[0], powerVariant: { kind: 'basis', id: 'gpu-provisioned' } },
+        { ...a[1], hidden: true },
+      ],
+      { ...options, baseline: equalServiceSourceKey(overlay[0]) },
+    );
+    expect(result.metrics.meanWattsPerGpu.changePercent).toBe(50);
+    expect(result.baseline?.label).toContain('overlay');
+  });
+
+  it('scales aggregate output by physical chips, but PD output by decode GPUs only', () => {
+    const aggregate = point({ physicalChips: 8, tp: 2 });
+    const pd = point({
+      hwKey: 'gb200',
+      disagg: true,
+      physicalChips: 8,
+      num_prefill_gpu: 4,
+      num_decode_gpu: 4,
+    });
+    const result = buildEqualServiceComparison([aggregate, pd], {
+      ...options,
+      baseline: equalServiceSourceKey(aggregate),
+      comparator: equalServiceSourceKey(pd),
+      target: 20,
+    });
+    expect(result.metrics.outputTokensPerSecond).toMatchObject({
+      baseline: { value: 400 },
+      comparator: { value: 200 },
+      changePercent: -50,
+    });
+    const invalid = { ...pd, num_decode_gpu: 0 };
+    expect(
+      buildEqualServiceComparison([aggregate, invalid], {
+        ...options,
+        baseline: equalServiceSourceKey(aggregate),
+        comparator: equalServiceSourceKey(invalid),
+        target: 20,
+      }).metrics.outputTokensPerSecond.reason,
+    ).toBe('missing-metric');
+  });
+
+  it('evaluates sorted observed-X union only within overlap and retains missing knots', () => {
+    const inner = b.map((p, i) => ({ ...p, mean_intvty: i ? 50 : 30 }));
+    const curve = getEqualServiceComparisonCurve(
+      [...a, ...inner, point({ id: 5, mean_intvty: 40, measuredAvgPower: undefined })],
+      options,
+    );
+    expect(curve.map((row) => row.target)).toEqual([30, 40, 50]);
+    expect(curve[1].metrics.meanWattsPerGpu.reason).toBe('missing-metric');
+    expect(getEqualServiceComparisonCurve([...a, ...b], { ...options, xField: 'conc' })).toEqual(
+      [],
+    );
+  });
+
+  it('reuses measured same-window role accounting, not the nominal input:output ratio', () => {
+    const pd = point({
+      disagg: true,
+      power_valid: 1,
+      power_metric_schema_version: 2,
+      joules_per_input_token: 2,
+      joules_per_output_token: 10,
+      prefill_joules_per_input_token: 1,
+      decode_joules_per_output_token: 5,
+    });
+    const [share] = getPrefillSharePoints([pd, { ...pd, power_valid: 0 }], 'mean_intvty');
+    expect(share).toMatchObject({
+      x: 20,
+      prefill: 5,
+      decode: 5,
+      total: 10,
+      prefillShare: 50,
+      sourceKey: equalServiceSourceKey(pd),
+      point: pd,
+    });
+    expect(getPrefillSharePoints([pd], 'conc')[0]).toMatchObject({ x: pd.conc, prefillShare: 50 });
+  });
+});
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.ts b/packages/app/src/components/inference/utils/equal-service-comparison.ts
new file mode 100644
index 000000000..77af25a63
--- /dev/null
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.ts
@@ -0,0 +1,252 @@
+import type { AggDataEntry, InferenceData } from '../types';
+import { chipCounts } from '@/lib/chip-counts';
+import { powerBasisNormalization } from '@/lib/power-basis';
+import { reconstructedRoleEnergy } from './role-energy';
+import { pointTopologyKey, topologyLabel } from './topology-filter';
+
+export interface EqualServiceSource {
+  key: string;
+  label: string;
+}
+export interface EqualServiceEstimate {
+  value: number;
+  interpolated: boolean;
+  endpoints: { x: number; value: number; point: InferenceData }[];
+}
+export type EqualServiceReason =
+  | 'unsupported-axis'
+  | 'invalid-target'
+  | 'same-source'
+  | 'unknown-source'
+  | 'out-of-range'
+  | 'ambiguous-x'
+  | 'missing-metric';
+export interface EqualServiceMetric {
+  baseline: EqualServiceEstimate | null;
+  comparator: EqualServiceEstimate | null;
+  /** Comparator change relative to baseline; negative energy means less energy. */
+  changePercent: number | null;
+  reason?: EqualServiceReason;
+}
+export interface EqualServiceOptions {
+  baseline: string;
+  comparator: string;
+  target: number;
+  xField: keyof AggDataEntry;
+}
+export interface EqualServiceComparison {
+  target: number;
+  xField: keyof AggDataEntry;
+  baseline: EqualServiceSource | null;
+  comparator: EqualServiceSource | null;
+  reason?: EqualServiceReason;
+  metrics: Record<
+    'meanWattsPerGpu' | 'outputTokensPerSecond' | 'joulesPerOutputToken',
+    EqualServiceMetric
+  >;
+}
+const positive = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isFinite(value) && value > 0;
+const serviceAxis = (field: string) =>
+  field === 'mean_tpot_intvty' ||
+  /^(?:mean|median|p\d+(?:\.\d+)?)_(?:intvty|tpot|ttft|e2el|itl)$/u.test(field);
+const observed = (points: readonly InferenceData[]) =>
+  points.filter((point) => !point.hidden && !point.powerVariant);
+
+/** Concurrency is excluded; unknown run identity must never join distinct rows. */
+export function equalServiceSourceKey(point: InferenceData): string {
+  const attempt = 'run_attempt' in point ? point.run_attempt : null;
+  return JSON.stringify([
+    point.hwKey,
+    point.model ?? null,
+    point.framework ?? null,
+    point.precision,
+    point.benchmark_type ?? null,
+    point.isl ?? null,
+    point.osl ?? null,
+    point.actualDate ?? point.date,
+    point.run_url || `unknown-run-point-${point.id ?? JSON.stringify(point)}`,
+    attempt,
+    pointTopologyKey(point),
+    point.recipe_fingerprint ?? null,
+    point.image ?? null,
+    point.mtp ?? null,
+    point.spec_decoding ?? null,
+    point.kv_offloading ?? null,
+    point.kv_offload_backend ?? null,
+    point.kv_offload_backend_version ?? null,
+    point.kv_p2p_transfer ?? null,
+    point.router_name ?? null,
+    point.router_version ?? null,
+    point.power_audit?.producer_sha ?? null,
+    point.power_audit?.exporter_image_sha256 ?? null,
+  ]);
+}
+
+export function getEqualServiceSources(points: readonly InferenceData[]): EqualServiceSource[] {
+  const sources = new Map(observed(points).map((point) => [equalServiceSourceKey(point), point]));
+  const topologies = [...sources.values()].map(pointTopologyKey);
+  return [...sources]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, point]) => ({
+      key,
+      label: [
+        point.hwKey,
+        point.precision.toUpperCase(),
+        topologyLabel(pointTopologyKey(point), 'en', topologies),
+        point.actualDate ?? point.date,
+        point.run_url ?? `Point ${point.id ?? '?'}`,
+        'run_attempt' in point ? `Attempt ${point.run_attempt}` : null,
+        point.recipe_fingerprint ? `Recipe ${point.recipe_fingerprint}` : null,
+        point.image ?? null,
+      ]
+        .filter(Boolean)
+        .join(' · '),
+    }));
+}
+
+function deploymentOutput(point: InferenceData): number | undefined {
+  if (!positive(point.output_tput_per_gpu)) return undefined;
+  if (point.disagg) {
+    return (
+      powerBasisNormalization({
+        output_tput_per_gpu: point.output_tput_per_gpu,
+        disagg: true,
+        benchmark_type: point.benchmark_type,
+        num_prefill_gpu: point.num_prefill_gpu ?? 0,
+        num_decode_gpu: point.num_decode_gpu ?? 0,
+      }).totalOutputTokPerSec ?? undefined
+    );
+  }
+  const count = chipCounts(point, false).physical;
+  return positive(count) && Number.isSafeInteger(count)
+    ? point.output_tput_per_gpu * count
+    : undefined;
+}
+const metrics = {
+  meanWattsPerGpu: (point: InferenceData) => point.measuredAvgPower?.y,
+  outputTokensPerSecond: deploymentOutput,
+  joulesPerOutputToken: (point: InferenceData) => point.measuredJPerOutputToken?.y,
+};
+
+function estimate(
+  points: readonly InferenceData[],
+  field: keyof AggDataEntry,
+  target: number,
+  quantity: (point: InferenceData) => number | undefined,
+): { estimate: EqualServiceEstimate | null; reason?: EqualServiceReason } {
+  const rows = points
+    .flatMap((point) => {
+      const x = point[field];
+      return positive(x) ? [{ point, x, value: quantity(point) }] : [];
+    })
+    .sort((a, b) => a.x - b.x || (a.point.id ?? 0) - (b.point.id ?? 0));
+  const xs = [...new Set(rows.map((row) => row.x))];
+  if (xs.length === 0 || target < xs[0] || target > xs.at(-1)!)
+    return { estimate: null, reason: 'out-of-range' };
+  const upper = xs.findIndex((x) => x >= target);
+  const brackets = xs[upper] === target ? [target] : [xs[upper - 1], xs[upper]];
+  const endpoints: EqualServiceEstimate['endpoints'] = [];
+  for (const x of brackets) {
+    const matches = rows.filter((row) => row.x === x);
+    if (matches.some((row) => !Object.is(row.value, matches[0].value)))
+      return { estimate: null, reason: 'ambiguous-x' };
+    for (const row of matches) {
+      if (!positive(row.value)) return { estimate: null, reason: 'missing-metric' };
+      endpoints.push({ ...row, value: row.value });
+    }
+  }
+  const left = endpoints[0],
+    right = endpoints.at(-1)!;
+  const value =
+    brackets.length === 1
+      ? left.value
+      : left.value + (right.value - left.value) * ((target - left.x) / (right.x - left.x));
+  return positive(value)
+    ? { estimate: { value, interpolated: brackets.length === 2, endpoints } }
+    : { estimate: null, reason: 'missing-metric' };
+}
+
+/** Numerical linear interpolation of raw quantities, then ratios; never extrapolation. */
+export function buildEqualServiceComparison(
+  points: readonly InferenceData[],
+  options: EqualServiceOptions,
+): EqualServiceComparison {
+  const { baseline, comparator, target, xField } = options;
+  const sources = getEqualServiceSources(points);
+  const sourceA = sources.find((source) => source.key === baseline) ?? null;
+  const sourceB = sources.find((source) => source.key === comparator) ?? null;
+  let reason: EqualServiceReason | undefined;
+  if (!serviceAxis(xField)) reason = 'unsupported-axis';
+  else if (!positive(target)) reason = 'invalid-target';
+  else if (baseline === comparator) reason = 'same-source';
+  else if (!sourceA || !sourceB) reason = 'unknown-source';
+  const rows = observed(points);
+  const a = rows.filter((point) => equalServiceSourceKey(point) === baseline);
+  const b = rows.filter((point) => equalServiceSourceKey(point) === comparator);
+  const compare = (quantity: (point: InferenceData) => number | undefined): EqualServiceMetric => {
+    if (reason) return { baseline: null, comparator: null, changePercent: null, reason };
+    const left = estimate(a, xField, target, quantity);
+    const right = estimate(b, xField, target, quantity);
+    const change =
+      left.estimate && right.estimate
+        ? 100 * (right.estimate.value / left.estimate.value - 1)
+        : null;
+    return {
+      baseline: left.estimate,
+      comparator: right.estimate,
+      changePercent: change !== null && Number.isFinite(change) ? change : null,
+      ...(left.reason || right.reason ? { reason: left.reason ?? right.reason } : {}),
+    };
+  };
+  return {
+    target,
+    xField,
+    baseline: sourceA,
+    comparator: sourceB,
+    ...(reason ? { reason } : {}),
+    metrics: {
+      meanWattsPerGpu: compare(metrics.meanWattsPerGpu),
+      outputTokensPerSecond: compare(metrics.outputTokensPerSecond),
+      joulesPerOutputToken: compare(metrics.joulesPerOutputToken),
+    },
+  };
+}
+
+/** Knots are observed X values within both source ranges, not a fitted hardware model. */
+export function getEqualServiceComparisonCurve(
+  points: readonly InferenceData[],
+  options: Omit<EqualServiceOptions, 'target'>,
+): EqualServiceComparison[] {
+  if (!serviceAxis(options.xField) || options.baseline === options.comparator) return [];
+  const xs = (key: string) =>
+    observed(points)
+      .filter((point) => equalServiceSourceKey(point) === key)
+      .map((point) => point[options.xField])
+      .filter(positive);
+  const a = xs(options.baseline),
+    b = xs(options.comparator);
+  if (a.length === 0 || b.length === 0) return [];
+  const lower = Math.max(Math.min(...a), Math.min(...b));
+  const upper = Math.min(Math.max(...a), Math.max(...b));
+  return [...new Set([...a, ...b])]
+    .filter((x) => x >= lower && x <= upper)
+    .sort((x, y) => x - y)
+    .map((target) => buildEqualServiceComparison(points, { ...options, target }));
+}
+
+export function getPrefillSharePoints(
+  points: readonly InferenceData[],
+  xField: keyof AggDataEntry,
+) {
+  if (!serviceAxis(xField) && xField !== 'conc') return [];
+  return observed(points)
+    .flatMap((point) => {
+      const x = point[xField];
+      const energy = reconstructedRoleEnergy(point);
+      return positive(x) && energy
+        ? [{ x, sourceKey: equalServiceSourceKey(point), point, ...energy }]
+        : [];
+    })
+    .sort((a, b) => a.sourceKey.localeCompare(b.sourceKey) || a.x - b.x);
+}
diff --git a/packages/app/src/components/inference/utils/powerCurves.test.ts b/packages/app/src/components/inference/utils/powerCurves.test.ts
index 21356f6b5..52436d840 100644
--- a/packages/app/src/components/inference/utils/powerCurves.test.ts
+++ b/packages/app/src/components/inference/utils/powerCurves.test.ts
@@ -1,3 +1,4 @@
+import { groupConcurrencySeries } from './concurrency-series';
 import { describe, expect, it } from 'vitest';
 
 import type { InferenceData } from '@/components/inference/types';
@@ -185,3 +186,45 @@ describe('upper power envelope', () => {
     ).toEqual([valid]);
   });
 });
+
+describe('observed concurrency series', () => {
+  const load = (conc: number, overrides: Partial<InferenceData> = {}) =>
+    point(conc, conc, 500, {
+      run_url: 'https://github.com/org/repo/actions/runs/123',
+      ...overrides,
+    });
+
+  it('retains non-monotonic measured points and sorts by exact load', () => {
+    const points = [load(128, { y: 470 }), load(1, { y: 500 }), load(4, { y: 600 })];
+    const segments = [...groupConcurrencySeries(points).values()];
+    expect(segments).toHaveLength(1);
+    expect(segments[0].map((sample) => [sample.x, sample.y])).toEqual([
+      [1, 500],
+      [4, 600],
+      [128, 470],
+    ]);
+  });
+
+  it('never connects different topology, recipes, runs, dates or role variants', () => {
+    const base = load(1);
+    const points = [
+      base,
+      load(4, { tp: 4 }),
+      load(8, { recipe_fingerprint: 'other-recipe' }),
+      load(16, { run_url: 'https://github.com/org/repo/actions/runs/456' }),
+      load(32, { date: '2026-09-11' }),
+      load(64, { powerVariant: { kind: 'role', id: 'prefill' } }),
+    ];
+    const segments = [...groupConcurrencySeries(points).values()];
+    expect(segments).toHaveLength(points.length);
+    expect(segments.flat()).toEqual(points);
+  });
+
+  it('keeps repeated load observations and unknown runs as markers, not an arbitrary average', () => {
+    const points = [load(4), load(4, { y: 650 }), load(8), load(16, { run_url: undefined })];
+    const segments = [...groupConcurrencySeries(points).values()];
+    expect(segments.every((segment) => segment.length === 1)).toBe(true);
+    expect(segments.flat()).toHaveLength(points.length);
+    expect(segments.flat().map((sample) => sample.y)).toEqual([500, 650, 500, 500]);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/powerTimeline.test.ts b/packages/app/src/components/inference/utils/powerTimeline.test.ts
index def7e63cc..a1f880247 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.test.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.test.ts
@@ -6,10 +6,13 @@ import type { InferenceData } from '@/components/inference/types';
 import {
   allGpuPool,
   consumePowerTraceFocus,
+  hasPowerTimelineWindow,
   joinPowerTimeline,
   longestCommonPrefix,
   groupPoolsBySize,
   planPowerTimelineRequests,
+  parsePowerTimelineParams,
+  powerTimelineSampleX,
   prioritizeRun,
   prioritizeRuns,
   referenceLabelSlots,
@@ -21,6 +24,7 @@ import {
   traceKeyRunId,
   tracePools,
   windowPhase,
+  type PowerTimelineTrace,
 } from './powerTimeline';
 
 const RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34716669498';
@@ -54,6 +58,82 @@ const runInfo: GpuPowerSeriesResponse['runInfo'] = {
   status: 'completed',
 };
 
+describe('shared timeline view', () => {
+  const trace: PowerTimelineTrace = {
+    key: `34716669498:${NAME_A}`,
+    point: point({}),
+    runId: '34716669498',
+    series: {
+      artifact: `gpu_metrics_${NAME_A}`,
+      startMs: 100_000,
+      bucketSeconds: 1,
+      gpus: [0],
+      t: [2, 3, 4, 5],
+      power: [[100, 200, 300, 400]],
+    },
+    windowStartMs: 103_000,
+    windowEndMs: 104_500,
+  };
+
+  it('restores independent pool, axis, window, focus and reference settings', () => {
+    expect(
+      parsePowerTimelineParams({
+        i_ptlines: 'pool',
+        i_ptaxis: 'serving',
+        i_ptwindow: 'window',
+        i_ptfocus: trace.key,
+        i_ptutility: '1',
+      }),
+    ).toEqual({
+      axis: 'serving',
+      lines: 'pool',
+      windowOnly: true,
+      focus: trace.key,
+      utility: true,
+    });
+    expect(parsePowerTimelineParams({ i_ptlines: 'gpu', i_ptfocus: trace.key }).lines).toBe('gpu');
+  });
+
+  it('rejects unsupported URL values without inventing a trace identity', () => {
+    expect(
+      parsePowerTimelineParams({
+        i_ptaxis: 'guess',
+        i_ptlines: 'phase',
+        i_ptwindow: 'all',
+        i_ptfocus: 'not-a-run:../../../secret',
+        i_ptutility: 'true',
+      }),
+    ).toEqual({ axis: null, lines: 'mean', windowOnly: false, focus: null, utility: false });
+  });
+
+  it('uses the retained serving origin, distinct from telemetry origin', () => {
+    expect(powerTimelineSampleX(trace, 0, 'wall', false)).toBe(102_000);
+    expect(powerTimelineSampleX(trace, 0, 'elapsed', false)).toBe(0);
+    expect(powerTimelineSampleX(trace, 0, 'serving', false)).toBe(-1);
+    expect(powerTimelineSampleX(trace, 2, 'serving', true)).toBe(1);
+  });
+
+  it('keeps only retained buckets inside exact audit bounds without interpolating', () => {
+    expect(
+      trace.series.t.map((_, column) => powerTimelineSampleX(trace, column, 'serving', true)),
+    ).toEqual([null, 0, 1, null]);
+  });
+
+  it.each([
+    { windowStartMs: null, windowEndMs: null },
+    { windowStartMs: 103_000, windowEndMs: 103_000 },
+    { windowStartMs: 105_000, windowEndMs: 103_000 },
+    { windowStartMs: Number.NaN, windowEndMs: 104_500 },
+  ])('does not derive a serving window from missing or invalid bounds %j', (bounds) => {
+    const invalid = { ...trace, ...bounds };
+    expect(hasPowerTimelineWindow(invalid)).toBe(false);
+    expect(powerTimelineSampleX(invalid, 1, 'serving', false)).toBeNull();
+    expect(powerTimelineSampleX(invalid, 1, 'elapsed', true)).toBeNull();
+    expect(powerTimelineSampleX(invalid, 1, 'elapsed', false)).toBe(1);
+    expect(windowPhase(invalid, 103_000)).toBe('unknown');
+  });
+});
+
 describe('telemetryArtifactForPoint', () => {
   it('maps the power-audit source to the gpu_metrics artifact of the same RESULT_FILENAME', () => {
     expect(
diff --git a/packages/app/src/components/inference/utils/powerTimeline.ts b/packages/app/src/components/inference/utils/powerTimeline.ts
index cff71ac26..dfa7b8141 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.ts
@@ -13,10 +13,11 @@
  * Nothing is matched by hardware or concurrency; points whose telemetry is
  * missing (expired artifact, another collector) are reported, not guessed.
  */
-import type {
-  GpuPowerRole,
-  GpuPowerSeries,
-  GpuPowerSeriesResponse,
+import {
+  bucketTimeMs,
+  type GpuPowerRole,
+  type GpuPowerSeries,
+  type GpuPowerSeriesResponse,
 } from '@/components/gpu-power/power-series';
 import type { InferenceData } from '@/components/inference/types';
 
@@ -154,6 +155,56 @@ export interface PowerTimelineTrace {
   windowEndMs: number | null;
 }
 
+export type PowerTimelineAxis = 'wall' | 'elapsed' | 'serving';
+export type PowerTimelineLines = 'mean' | 'gpu' | 'pool';
+
+/** URL input is optional: an omitted axis retains the existing per-run default. */
+export function parsePowerTimelineParams(params: {
+  i_ptaxis?: string;
+  i_ptlines?: string;
+  i_ptwindow?: string;
+  i_ptfocus?: string;
+  i_ptutility?: string;
+}) {
+  return {
+    axis: (['wall', 'elapsed', 'serving'].includes(params.i_ptaxis ?? '')
+      ? params.i_ptaxis
+      : null) as PowerTimelineAxis | null,
+    lines: (params.i_ptlines === 'gpu' || params.i_ptlines === 'pool'
+      ? params.i_ptlines
+      : 'mean') as PowerTimelineLines,
+    windowOnly: params.i_ptwindow === 'window',
+    focus:
+      params.i_ptfocus && /^[1-9]\d*:[\w.-]+$/u.test(params.i_ptfocus) ? params.i_ptfocus : null,
+    utility: params.i_ptutility === '1',
+  };
+}
+
+export function hasPowerTimelineWindow(trace: PowerTimelineTrace): boolean {
+  return (
+    trace.windowStartMs !== null &&
+    trace.windowEndMs !== null &&
+    Number.isFinite(trace.windowStartMs) &&
+    Number.isFinite(trace.windowEndMs) &&
+    trace.windowEndMs > trace.windowStartMs
+  );
+}
+
+/** Filter and position retained buckets only; never infer a missing serving origin. */
+export function powerTimelineSampleX(
+  trace: PowerTimelineTrace,
+  column: number,
+  axis: PowerTimelineAxis,
+  windowOnly: boolean,
+): number | null {
+  const timeMs = bucketTimeMs(trace.series, column);
+  if ((axis === 'serving' || windowOnly) && !hasPowerTimelineWindow(trace)) return null;
+  if (windowOnly && windowPhase(trace, timeMs) !== 'window') return null;
+  if (axis === 'wall') return timeMs;
+  const origin = axis === 'serving' ? trace.windowStartMs! : bucketTimeMs(trace.series, 0);
+  return (timeMs - origin) / 1000;
+}
+
 /**
  * Why a validated point has no trace:
  * - `no-source`: the row predates `power_audit.source` (older schema), so no
@@ -233,9 +284,9 @@ function unixSecondsToMs(seconds: number | undefined): number | null {
 export type WindowPhase = 'before' | 'window' | 'after' | 'unknown';
 
 export function windowPhase(trace: PowerTimelineTrace, timeMs: number): WindowPhase {
-  if (trace.windowStartMs === null || trace.windowEndMs === null) return 'unknown';
-  if (timeMs < trace.windowStartMs) return 'before';
-  if (timeMs > trace.windowEndMs) return 'after';
+  if (!hasPowerTimelineWindow(trace)) return 'unknown';
+  if (timeMs < trace.windowStartMs!) return 'before';
+  if (timeMs > trace.windowEndMs!) return 'after';
   return 'window';
 }
 
@@ -327,8 +378,8 @@ export function allGpuPool(series: Pick<GpuPowerSeries, 'power'>): PowerPool {
 //
 // "View power trace" on a pinned tooltip switches the metric to the Timeline
 // display; the timeline mounts afterwards and reads the requested trace here
-// so it can emphasise that config. Module state rather than URL state: the
-// focus is a one-shot gesture, and the share link stays `i_metric` alone.
+// so it can emphasise that config. The one-shot gesture takes precedence over
+// restored URL focus; the mounted timeline then persists it with its view state.
 
 let pendingFocus: string | null = null;
 
diff --git a/packages/app/src/components/inference/utils/quick-filter-summary.ts b/packages/app/src/components/inference/utils/quick-filter-summary.ts
index ba6b3bbac..e843dc9af 100644
--- a/packages/app/src/components/inference/utils/quick-filter-summary.ts
+++ b/packages/app/src/components/inference/utils/quick-filter-summary.ts
@@ -1,5 +1,6 @@
 import type { QuickFilters } from '../types';
 import { FRAMEWORK_FAMILIES } from './quickFilters';
+import { topologyLabel } from './topology-filter';
 
 const LABELS = {
   en: {
@@ -8,6 +9,7 @@ const LABELS = {
     deployment: 'Deployment',
     spec: 'Spec Decoding',
     power: 'Measured Power',
+    topologies: 'Topology',
     'single-node': 'Single-node',
     'multi-node': 'Multi-node',
     disagg: 'Disaggregated',
@@ -22,6 +24,7 @@ const LABELS = {
     deployment: '部署模式',
     spec: '投机解码',
     power: '实测功耗',
+    topologies: '拓扑',
     'single-node': '单节点',
     'multi-node': '多节点聚合',
     disagg: '分离式',
@@ -37,14 +40,16 @@ export function quickFilterSummary(filters: QuickFilters, locale: 'en' | 'zh', a
   const labels = LABELS[locale];
   return (Object.keys(filters) as (keyof QuickFilters)[]).flatMap((category) => {
     if (agentic && category === 'spec') return [];
-    return filters[category].map((value) => ({
+    return (filters[category] ?? []).map((value) => ({
       category,
       value,
       categoryLabel: labels[category],
       label:
-        category === 'frameworks'
-          ? (FRAMEWORK_FAMILIES.find((family) => family.key === value)?.label ?? value)
-          : (labels[value as keyof typeof labels] ?? value),
+        category === 'topologies'
+          ? topologyLabel(value, locale)
+          : category === 'frameworks'
+            ? (FRAMEWORK_FAMILIES.find((family) => family.key === value)?.label ?? value)
+            : (labels[value as keyof typeof labels] ?? value),
     }));
   });
 }
diff --git a/packages/app/src/components/inference/utils/quickFilters.test.ts b/packages/app/src/components/inference/utils/quickFilters.test.ts
index 82490d6f0..6c1c61ce0 100644
--- a/packages/app/src/components/inference/utils/quickFilters.test.ts
+++ b/packages/app/src/components/inference/utils/quickFilters.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest';
 
 import type { InferenceData } from '@/components/inference/types';
+import { pointTopologyKey, topologyLabel } from './topology-filter';
 
 import {
   EMPTY_QUICK_FILTERS,
@@ -72,7 +73,7 @@ describe('computeAvailableQuickFilters', () => {
         power_tier: 'certified',
       }),
     ];
-    expect(computeAvailableQuickFilters(points)).toEqual({
+    expect(computeAvailableQuickFilters(points)).toMatchObject({
       vendors: ['NVIDIA', 'AMD'],
       frameworks: ['vllm', 'trt', 'atom'],
       deployment: ['single-node', 'multi-node', 'disagg'],
@@ -85,7 +86,7 @@ describe('computeAvailableQuickFilters', () => {
     const points = [
       point({ hwKey: 'h100_vllm', framework: 'vllm', disagg: false, spec_decoding: 'none' }),
     ];
-    expect(computeAvailableQuickFilters(points)).toEqual({
+    expect(computeAvailableQuickFilters(points)).toMatchObject({
       vendors: ['NVIDIA'],
       frameworks: ['vllm'],
       deployment: ['single-node'],
@@ -112,10 +113,132 @@ describe('computeAvailableQuickFilters', () => {
       deployment: [],
       spec: [],
       power: [],
+      topologies: [],
     });
   });
 });
 
+describe('exact topology filtering', () => {
+  it('retains shared TP4 loads across hardware but excludes TP8 and different EP', () => {
+    const b200 = point({
+      hwKey: 'b200_sglang',
+      physicalChips: 4,
+      decode_tp: 4,
+      decode_ep: 1,
+      conc: 4,
+    });
+    const mi355x = point({ ...b200, hwKey: 'mi355x_sglang', conc: 256 });
+    const tp8 = point({ ...b200, physicalChips: 8, decode_tp: 8 });
+    const ep4 = point({ ...b200, decode_ep: 4 });
+    const selected = filters({ topologies: [pointTopologyKey(b200)] });
+    expect(quickFiltersActive(selected)).toBe(true);
+    expect(applyQuickFilters([b200, mi355x, tp8, ep4], selected)).toEqual([b200, mi355x]);
+    expect(computeAvailableQuickFilters([b200, mi355x, tp8, ep4]).topologies).toHaveLength(3);
+  });
+
+  it('does not mix 4P+4D with 16P+16D or another pool allocation', () => {
+    const gb200 = point({
+      hwKey: 'gb200_dynamo-sglang',
+      physicalChips: 8,
+      disagg: true,
+      num_prefill_gpu: 4,
+      num_decode_gpu: 4,
+    });
+    const gb300 = point({ ...gb200, hwKey: 'gb300_dynamo-sglang', conc: 128 });
+    const larger = point({ ...gb200, physicalChips: 32, num_prefill_gpu: 16, num_decode_gpu: 16 });
+    const unbalanced = point({ ...gb200, num_prefill_gpu: 2, num_decode_gpu: 6 });
+    expect(
+      applyQuickFilters(
+        [gb200, gb300, larger, unbalanced],
+        filters({ topologies: [pointTopologyKey(gb200)] }),
+      ),
+    ).toEqual([gb200, gb300]);
+    expect(applyQuickFilters([gb200], filters({ topologies: ['missing-topology'] }))).toEqual([]);
+  });
+
+  it('does not treat absent physical or parallelism metadata as a measured size', () => {
+    const unknown = point({ tp: 4 });
+    const known = point({ tp: 4, decode_tp: 4, decode_ep: 1 });
+    expect(pointTopologyKey(unknown)).not.toBe(pointTopologyKey(known));
+  });
+
+  it('resolves aggregate context parallelism from either schema side without mixing widths', () => {
+    const prefillShaped = point({
+      physicalChips: 8,
+      decode_tp: 8,
+      prefill_dcp_size: 8,
+      decode_dcp_size: 1,
+      prefill_pcp_size: 4,
+      decode_pcp_size: 1,
+    });
+    const decodeShaped = point({
+      ...prefillShaped,
+      prefill_dcp_size: 1,
+      decode_dcp_size: 8,
+      prefill_pcp_size: 1,
+      decode_pcp_size: 4,
+    });
+    const unpartitioned = point({ ...prefillShaped, prefill_dcp_size: 1, prefill_pcp_size: 1 });
+    expect(
+      applyQuickFilters(
+        [prefillShaped, decodeShaped, unpartitioned],
+        filters({ topologies: [pointTopologyKey(prefillShaped)] }),
+      ),
+    ).toEqual([prefillShaped, decodeShaped]);
+    expect(pointTopologyKey(point({ ...prefillShaped, disagg: true }))).not.toBe(
+      pointTopologyKey(point({ ...decodeShaped, disagg: true })),
+    );
+  });
+
+  it.each(['en', 'zh'] as const)(
+    'keeps distinct default, unknown, DPA and offload configurations visibly distinct in %s',
+    (locale) => {
+      const base = point({
+        physicalChips: 8,
+        decode_tp: 8,
+        decode_ep: 1,
+        decode_pp: 1,
+        decode_dp_attention: false,
+        offload_mode: 'off',
+      });
+      const variants = [
+        base,
+        point({ ...base, decode_dp_attention: true }),
+        point({ ...base, decode_dp_attention: undefined }),
+        point({ ...base, decode_pp: undefined }),
+        point({ ...base, offload_mode: undefined }),
+        point({ ...base, offload_mode: 'on' }),
+      ];
+      const keys = variants.map(pointTopologyKey);
+      for (const siblings of [undefined, keys]) {
+        const labels = keys.map((key) => topologyLabel(key, locale, siblings));
+        expect(new Set(labels).size).toBe(variants.length);
+      }
+    },
+  );
+
+  it.each(['en', 'zh'] as const)(
+    'omits shared details but retains allocation, widths and every differing field in %s',
+    (locale) => {
+      const base = point({
+        physicalChips: 4,
+        decode_tp: 4,
+        decode_ep: 1,
+        decode_pp: 1,
+        decode_dp_attention: false,
+        offload_mode: 'off',
+      });
+      const keys = [base, point({ ...base, decode_dp_attention: true })].map(pointTopologyKey);
+      const label = topologyLabel(keys[0], locale, keys);
+      expect(label).toContain('GPU4 · TP4 · EP1');
+      expect(label).toContain('DPA0');
+      expect(label).not.toMatch(/PP1|DP\?|offload/u);
+      expect(topologyLabel(keys[1], locale, keys)).toContain('DPA1');
+      expect(topologyLabel(keys[0], locale)).toContain('PP1');
+    },
+  );
+});
+
 describe('quickFiltersActive', () => {
   it('is false only when every category is empty', () => {
     expect(quickFiltersActive(EMPTY_QUICK_FILTERS)).toBe(false);
diff --git a/packages/app/src/components/inference/utils/quickFilters.ts b/packages/app/src/components/inference/utils/quickFilters.ts
index 479b06d9b..50513bb82 100644
--- a/packages/app/src/components/inference/utils/quickFilters.ts
+++ b/packages/app/src/components/inference/utils/quickFilters.ts
@@ -9,6 +9,7 @@ import type {
 } from '@/components/inference/types';
 import { frameworkFamily } from '@/lib/framework-family';
 import type { PowerTier } from '@/lib/power-tier';
+import { pointTopologyKey } from './topology-filter';
 
 export type { AvailableQuickFilters, DeploymentMode, PowerTier, QuickFilters, SpecMode };
 
@@ -64,6 +65,7 @@ export function computeAvailableQuickFilters(
 ): AvailableQuickFilters {
   const vendors = new Set<string>();
   const frameworks = new Set<string>();
+  const topologies = new Set<string>();
   let hasSingleNode = false;
   let hasMultiNode = false;
   let hasDisagg = false;
@@ -72,6 +74,7 @@ export function computeAvailableQuickFilters(
   let hasCertified = false;
   let hasLegacy = false;
   for (const p of points) {
+    topologies.add(pointTopologyKey(p));
     const vendor = pointVendor(String(p.hwKey));
     if (vendor) vendors.add(vendor);
     const fam = frameworkFamily(p.framework);
@@ -98,6 +101,7 @@ export function computeAvailableQuickFilters(
     deployment,
     spec,
     power: POWER_TIER_ORDER.filter((tier) => (tier === 'certified' ? hasCertified : hasLegacy)),
+    topologies: [...topologies].toSorted(),
   };
 }
 
@@ -108,7 +112,8 @@ export function quickFiltersActive(f: QuickFilters): boolean {
     f.frameworks.length > 0 ||
     f.deployment.length > 0 ||
     f.spec.length > 0 ||
-    f.power.length > 0
+    f.power.length > 0 ||
+    (f.topologies?.length ?? 0) > 0
   );
 }
 
@@ -159,6 +164,7 @@ export function parsePowerTiers(values: readonly string[]): PowerTier[] {
 
 /** Whether a single data point satisfies every active quick-filter category. */
 export function matchesQuickFilters(point: InferenceData, f: QuickFilters): boolean {
+  if (f.topologies?.length && !f.topologies.includes(pointTopologyKey(point))) return false;
   if (f.vendors.length > 0) {
     const vendor = pointVendor(String(point.hwKey));
     if (!vendor || !f.vendors.includes(vendor)) return false;
diff --git a/packages/app/src/components/inference/utils/resolveXAxisField.ts b/packages/app/src/components/inference/utils/resolveXAxisField.ts
index 282b778a7..834befae2 100644
--- a/packages/app/src/components/inference/utils/resolveXAxisField.ts
+++ b/packages/app/src/components/inference/utils/resolveXAxisField.ts
@@ -17,8 +17,11 @@ import { withPercentile } from '@/lib/benchmark-transform';
 import type { AggDataEntry, ChartDefinition } from '../types';
 import type { XAxisMode } from '../hooks/useChartData';
 
+export type FixedSequenceStatistic = 'mean' | 'median';
+
 /** Which rung of the branch ladder chose the x field (drives label choice). */
 export type XAxisBranch =
+  | 'concurrency'
   | 'natural'
   | 'user-input-override'
   | 'config-input-override'
@@ -39,10 +42,10 @@ export interface ResolvedXAxis {
  *
  * Rules, in order:
  * - The global x-axis mode takes precedence over legacy per-input-metric
- *   overrides. TTFT uses median for fixed-sequence runs.
+ *   overrides. Fixed-sequence service axes use the selected mean/median statistic.
  * - Natural x = the chart's latency metric at the selected percentile for
- *   agentic, forced to median for fixed-seq, where percentile-specific
- *   columns are not guaranteed to exist.
+ *   agentic, mean or median for fixed-sequence. Mean interactivity uses
+ *   reciprocal mean TPOT, never the raw arithmetic-mean interactivity field.
  * - Without a global mode, input metrics on the interactivity chart override x to a TTFT column:
  *   the user-picked metric for fixed-seq (the manual dropdown is hidden in
  *   agentic mode), else the config default.
@@ -58,13 +61,22 @@ export function resolveXAxisField(
   chartDef: ChartDefinition,
   selectedYAxisMetric: string,
   effectiveXMetric: string | null,
-  opts: { isAgentic: boolean; percentile: string; xAxisMode?: XAxisMode },
+  opts: {
+    isAgentic: boolean;
+    percentile: string;
+    xAxisMode?: XAxisMode;
+    fixedSequenceStatistic?: FixedSequenceStatistic;
+  },
 ): ResolvedXAxis {
-  const { isAgentic, percentile, xAxisMode } = opts;
-  const naturalX = withPercentile(
-    chartDef.x,
-    isAgentic ? percentile : 'median',
-  ) as keyof AggDataEntry;
+  const { isAgentic, percentile, xAxisMode, fixedSequenceStatistic = 'median' } = opts;
+  const statistic = isAgentic ? percentile : fixedSequenceStatistic;
+  const serviceField = (field: string): keyof AggDataEntry => {
+    const resolved = withPercentile(field, statistic);
+    return (
+      !isAgentic && resolved === 'mean_intvty' ? 'mean_tpot_intvty' : resolved
+    ) as keyof AggDataEntry;
+  };
+  const naturalX = serviceField(chartDef.x);
 
   const metricTitle =
     (chartDef[`${selectedYAxisMetric}_title` as keyof ChartDefinition] as string) || '';
@@ -77,11 +89,11 @@ export function resolveXAxisField(
   let xAxisField: keyof AggDataEntry = naturalX;
   let branch: XAxisBranch = 'natural';
   if (xAxisMode !== undefined) {
-    if (xAxisMode === 'ttft' && chartDef.chartType === 'e2e') {
-      xAxisField = withPercentile(
-        'median_ttft',
-        isAgentic ? percentile : 'median',
-      ) as keyof AggDataEntry;
+    if (xAxisMode === 'concurrency') {
+      xAxisField = 'conc';
+      branch = 'concurrency';
+    } else if (xAxisMode === 'ttft' && chartDef.chartType === 'e2e') {
+      xAxisField = serviceField('median_ttft');
       branch = 'e2e-ttft-override';
     }
   } else if (
@@ -101,7 +113,7 @@ export function resolveXAxisField(
     branch = 'e2e-ttft-override';
   }
 
-  if (isAgentic) {
+  if (isAgentic && xAxisMode !== 'concurrency') {
     xAxisField = withPercentile(xAxisField, percentile) as keyof AggDataEntry;
   }
 
diff --git a/packages/app/src/components/inference/utils/topology-filter.ts b/packages/app/src/components/inference/utils/topology-filter.ts
new file mode 100644
index 000000000..c5f731f4c
--- /dev/null
+++ b/packages/app/src/components/inference/utils/topology-filter.ts
@@ -0,0 +1,82 @@
+import type { InferenceData } from '../types';
+import { meaningfulParallelismSize } from './parallelism-label';
+
+function topologyValue(value: number | boolean | undefined) {
+  return value === undefined || value === null || !Number.isFinite(Number(value))
+    ? '?'
+    : Number(value);
+}
+
+/** Load is deliberately excluded: a topology filter retains its whole concurrency sweep. */
+export function pointTopologyKey(point: InferenceData): string {
+  const fields: [string, number | boolean | undefined][] = [
+    ['GPU', point.physicalChips ?? point.tp],
+    ['DP', point.dp],
+    ['TP', point.decode_tp],
+    ['EP', point.decode_ep ?? point.ep],
+    ['PP', point.decode_pp ?? point.pp],
+    [
+      'DCP',
+      point.disagg
+        ? point.decode_dcp_size
+        : (meaningfulParallelismSize(point.prefill_dcp_size, point.decode_dcp_size) ??
+          point.decode_dcp_size ??
+          point.prefill_dcp_size),
+    ],
+    [
+      'PCP',
+      point.disagg
+        ? point.decode_pcp_size
+        : (meaningfulParallelismSize(point.prefill_pcp_size, point.decode_pcp_size) ??
+          point.decode_pcp_size ??
+          point.prefill_pcp_size),
+    ],
+    ['DPA', point.decode_dp_attention ?? point.dp_attention],
+  ];
+  if (point.disagg)
+    fields.push(
+      ['P-GPU', point.num_prefill_gpu],
+      ['D-GPU', point.num_decode_gpu],
+      ['P-workers', point.prefill_num_workers],
+      ['D-workers', point.decode_num_workers],
+      ['P-TP', point.prefill_tp],
+      ['P-EP', point.prefill_ep],
+      ['P-PP', point.prefill_pp],
+      ['P-DCP', point.prefill_dcp_size],
+      ['P-PCP', point.prefill_pcp_size],
+      ['P-DPA', point.prefill_dp_attention],
+    );
+  const mode = point.disagg ? 'PD' : point.is_multinode ? 'Multi' : 'Single';
+  return [
+    mode,
+    ...fields.map(([key, v]) => `${key}=${topologyValue(v)}`),
+    `offload=${point.offload_mode ?? '?'}`,
+  ].join('|');
+}
+
+/** Values stay human-readable in share links and exported filter metadata. */
+export function topologyLabel(
+  key: string,
+  locale: 'en' | 'zh',
+  availableKeys?: readonly string[],
+): string {
+  const [mode, ...parts] = key.split('|');
+  const modes =
+    locale === 'zh'
+      ? { PD: '分离式', Multi: '多节点', Single: '单节点' }
+      : { PD: 'Disaggregated', Multi: 'Multi-node', Single: 'Single-node' };
+  // Hide shared detail, never a difference: defaults and unknowns distinguish options too.
+  const peers = availableKeys?.filter((sibling) => sibling.split('|')[0] === mode);
+  const visible = parts.filter((part) => {
+    const name = part.split('=')[0];
+    return (
+      ['GPU', 'TP', 'EP', 'P-GPU', 'D-GPU', 'P-TP', 'P-EP'].includes(name) ||
+      !peers?.length ||
+      !peers.every((sibling) => sibling.split('|').includes(part))
+    );
+  });
+  return [
+    modes[mode as keyof typeof modes] ?? mode,
+    ...visible.map((part) => part.replace('=', '')),
+  ].join(' · ');
+}
diff --git a/packages/app/src/components/inference/utils/x-axis-scale.test.ts b/packages/app/src/components/inference/utils/x-axis-scale.test.ts
index f94310d9f..78897dd09 100644
--- a/packages/app/src/components/inference/utils/x-axis-scale.test.ts
+++ b/packages/app/src/components/inference/utils/x-axis-scale.test.ts
@@ -3,6 +3,17 @@ import { describe, expect, it } from 'vitest';
 import { resolveScatterXAxisScale } from './x-axis-scale';
 
 describe('resolveScatterXAxisScale', () => {
+  it('keeps observed concurrency linear despite a saved latency log preference', () => {
+    expect(
+      resolveScatterXAxisScale({
+        extent: [1, 128],
+        selectedYAxisMetric: 'y_inputTputPerGpu',
+        xAxisField: 'conc',
+        scaleType: 'log',
+      }),
+    ).toBe('linear');
+  });
+
   it.each(['P90 Time To First Token (s)', 'P90 首 token 延迟 (s)'])(
     'selects log for wide-range TTFT independently of the %s display label',
     (displayLabel) => {
diff --git a/packages/app/src/components/inference/utils/x-axis-scale.ts b/packages/app/src/components/inference/utils/x-axis-scale.ts
index 205c803ae..9b089a60b 100644
--- a/packages/app/src/components/inference/utils/x-axis-scale.ts
+++ b/packages/app/src/components/inference/utils/x-axis-scale.ts
@@ -18,6 +18,7 @@ export function resolveScatterXAxisScale({
   xAxisField,
   scaleType,
 }: ResolveScatterXAxisScaleOptions): ScatterXAxisScale {
+  if (xAxisField === 'conc') return 'linear';
   if (selectedYAxisMetric !== 'y_inputTputPerGpu') return 'linear';
   if (scaleType === 'linear') return 'linear';
   if (scaleType === 'log') return extent[0] > 0 ? 'log' : 'linear';
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index e4f0ca1b4..4e90268c3 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -139,7 +139,7 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'published-read',
     operationId: 'get-inference-view',
-    sourceSha256: 'de9192086b27e530ad6b1ece082b4989b3a9771a78195ae9f6d1c3899519588f',
+    sourceSha256: '7b3f1ba020dee0f3ad5b62249294d8532cb1ae40f22f182f70b218fc3426cb1d',
   },
   {
     source: 'src/app/api/v1/views/operatorx/route.ts',
@@ -155,7 +155,7 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'published-read',
     operationId: 'get-view-options',
-    sourceSha256: '79571c3e6faf5af977c1afc9c29ebd6c1bfeb54ccf389711fa49668466fb58f4',
+    sourceSha256: '1f441c8726e6adb69d68660e80e854582bbacaba842cea5ec6f3ad2512ff1b5c',
   },
   {
     source: 'src/app/api/v1/views/overview/route.ts',
@@ -804,6 +804,38 @@ export interface ApiContractSourceDigest {
  * touching a route module. Digest changes require an explicit documentation review.
  */
 export const apiContractSourceDigests = [
+  {
+    source: 'src/components/inference/utils/resolveXAxisField.ts',
+    sourceSha256: 'd59ad021fbe8e8547a811fc83ce63adb2373c3005d2668844f2dcbcb61448e1f',
+    reviewArea: {
+      en: 'Shared service-axis resolution: fixed-sequence mean/median, reciprocal mean TPOT, and AgentX percentile isolation.',
+      zh: '共用服务轴解析：固定长度工作负载 mean/median、mean TPOT 的倒数，以及 AgentX 独立的分位数选择。',
+    },
+  },
+  {
+    source: 'src/components/inference/utils/equal-service-comparison.ts',
+    sourceSha256: '706ba422ba200845d0eca4b24c95b35feef83a39bcfce61499eb6f5c482f525b',
+    reviewArea: {
+      en: 'Source-scoped equal-service interpolation, comparator-relative changes, endpoint provenance, and prefill share projection.',
+      zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源，以及 prefill 占比视图。',
+    },
+  },
+  {
+    source: 'src/components/inference/utils/role-energy.ts',
+    sourceSha256: 'd3d731769fa5aed6f4d1c94fe3f80c5316beb3dbbf52a9f8f3a9c024362b4825',
+    reviewArea: {
+      en: 'Validated prefill/decode energy reconstruction and shares on a common output-token denominator.',
+      zh: '使用统一 output token 分母的已验证 prefill/decode 能耗重建与占比。',
+    },
+  },
+  {
+    source: 'src/lib/benchmark-transform.ts',
+    sourceSha256: '21f1fe4d63737c74efb2251a64f79eef1b5e9c565769be9b4fb500b1fa4ecc89',
+    reviewArea: {
+      en: 'Raw benchmark means and derived reciprocal mean-TPOT interactivity used by Dashboard and read-only views.',
+      zh: '仪表板和只读视图共用的原始 benchmark 均值与 mean TPOT 倒数形式的 interactivity。',
+    },
+  },
   {
     source: '../db/src/etl/power-audit-validations.ts',
     sourceSha256: '44a607747b79d038bb8f4e53590efba689d376c143f50a5d750d3552faa0c442',
@@ -901,7 +933,7 @@ export const apiContractSourceDigests = [
 
   {
     source: 'src/components/inference/hooks/chart-data-core.ts',
-    sourceSha256: '0c86987ed025557172a8d020144ca462be1ecac880d53b7d929f93a617086c33',
+    sourceSha256: '8601c33f6979541786362276697e4d4a21278de1d57b50d31f705391b5da041d',
     reviewArea: {
       en: 'Dashboard read-only selector and calculation parity.',
       zh: '仪表板只读接口的选择项与计算一致性。',
@@ -955,7 +987,7 @@ export const apiContractSourceDigests = [
 
   {
     source: 'src/lib/views-api/series.ts',
-    sourceSha256: 'b5ebddee9d9ea6b85a8fdab2cf8fcc50bbf05e0fa10564987698abd38a6d4488',
+    sourceSha256: '9974fe5166ac847f4b9284eda8a901ee0f9c8b432567ef184890453c715d2f4f',
     reviewArea: {
       en: 'Dashboard read-only selector and calculation parity.',
       zh: '仪表板只读接口的选择项与计算一致性。',
@@ -964,7 +996,7 @@ export const apiContractSourceDigests = [
 
   {
     source: 'src/lib/views-api/registry.ts',
-    sourceSha256: 'e7494504b118a7706742e542b3cc3b2543823d8463ac5b32b13ebdb971c84aed',
+    sourceSha256: '266305115106c86b18d1131e3a8916a756b847f569e7de02c82ec74dad1bcf17',
     reviewArea: {
       en: 'Dashboard read-only selector and calculation parity.',
       zh: '仪表板只读接口的选择项与计算一致性。',
diff --git a/packages/app/src/lib/benchmark-transform.test.ts b/packages/app/src/lib/benchmark-transform.test.ts
index 5054825f7..1ac13bbaf 100644
--- a/packages/app/src/lib/benchmark-transform.test.ts
+++ b/packages/app/src/lib/benchmark-transform.test.ts
@@ -69,6 +69,38 @@ function makeRow(overrides: Partial<BenchmarkRow> = {}): BenchmarkRow {
 }
 
 describe('rowToAggDataEntry', () => {
+  it('preserves raw interactivity and derives reciprocal mean TPOT separately', () => {
+    const entry = rowToAggDataEntry(
+      makeRow({
+        metrics: {
+          mean_tpot: 0.04,
+          mean_intvty: 777,
+          median_intvty: 12.5,
+        },
+      }),
+    );
+    expect(entry.mean_tpot_intvty).toBe(25);
+    expect(entry.mean_intvty).toBe(777);
+    expect(entry.median_intvty).toBe(12.5);
+  });
+
+  it.each([undefined, 0, -1, NaN, Infinity])(
+    'does not invent speed for invalid mean TPOT %s',
+    (mean_tpot) => {
+      const entry = rowToAggDataEntry(
+        makeRow({
+          metrics: {
+            ...(mean_tpot === undefined ? {} : { mean_tpot }),
+            mean_intvty: 777,
+            median_intvty: 12.5,
+          },
+        }),
+      );
+      expect(entry).not.toHaveProperty('mean_tpot_intvty');
+      expect(entry.mean_intvty).toBe(777);
+    },
+  );
+
   it.each([1, undefined])(
     'keeps canonical identity but labels UMBP for official/overlay rows (DB id %s)',
     (id) => {
diff --git a/packages/app/src/lib/benchmark-transform.ts b/packages/app/src/lib/benchmark-transform.ts
index f1712e306..ab974f8d4 100644
--- a/packages/app/src/lib/benchmark-transform.ts
+++ b/packages/app/src/lib/benchmark-transform.ts
@@ -199,6 +199,9 @@ export function rowToAggDataEntry(row: BenchmarkRow): AggDataEntry {
     p99_tpot: m.p99_tpot ?? 0,
     'p99.9_tpot': m['p99.9_tpot'] ?? 0,
     mean_intvty: m.mean_intvty ?? 0,
+    ...(typeof m.mean_tpot === 'number' && Number.isFinite(m.mean_tpot) && m.mean_tpot > 0
+      ? { mean_tpot_intvty: 1 / m.mean_tpot }
+      : {}),
     median_intvty: m.median_intvty ?? 0,
     std_intvty: m.std_intvty ?? 0,
     p75_intvty: m.p75_intvty ?? 0,
diff --git a/packages/app/src/lib/chart-utils.ts b/packages/app/src/lib/chart-utils.ts
index 78b62b2d8..7f6598824 100644
--- a/packages/app/src/lib/chart-utils.ts
+++ b/packages/app/src/lib/chart-utils.ts
@@ -624,13 +624,24 @@ export function remapInferencePoint(
   const xCandidate = (point as Partial<AggDataEntry>)[xAxisField];
   // Absent TTFT values are zero-filled by the row transform. Neither that
   // sentinel nor an unrelated fallback coordinate is a latency measurement.
-  const missingTtft =
-    xAxisField.endsWith('_ttft') && (typeof xCandidate !== 'number' || xCandidate <= 0);
+  const missingConcurrency =
+    xAxisField === 'conc' &&
+    (typeof xCandidate !== 'number' || !Number.isFinite(xCandidate) || xCandidate <= 0);
+  const requiresMeasuredServiceValue =
+    xAxisField.endsWith('_ttft') || xAxisField === 'mean_e2el' || xAxisField === 'mean_tpot_intvty';
+  const missingServiceValue =
+    requiresMeasuredServiceValue &&
+    (typeof xCandidate !== 'number' || !Number.isFinite(xCandidate) || xCandidate <= 0);
   return {
     ...point,
-    x: missingTtft ? NaN : typeof xCandidate === 'number' ? xCandidate : point.x,
+    x:
+      missingServiceValue || missingConcurrency
+        ? NaN
+        : typeof xCandidate === 'number'
+          ? xCandidate
+          : point.x,
     y: metric?.y ?? point.y,
-    roof: metric?.roof ?? false,
+    roof: xAxisField === 'conc' ? false : (metric?.roof ?? false),
   };
 }
 
diff --git a/packages/app/src/lib/url-state.test.ts b/packages/app/src/lib/url-state.test.ts
index 392b1bf94..a9e6dad17 100644
--- a/packages/app/src/lib/url-state.test.ts
+++ b/packages/app/src/lib/url-state.test.ts
@@ -26,6 +26,15 @@ describe('PARAM_DEFAULTS', () => {
     vi.unstubAllGlobals();
   });
 
+  it('round-trips mean service statistics while omitting the median default', async () => {
+    setupWindow('?i_mstat=mean');
+    const { readUrlParams, buildShareUrl, writeUrlParams } = await import('@/lib/url-state');
+    expect(readUrlParams().i_mstat).toBe('mean');
+    expect(new URL(buildShareUrl()).searchParams.get('i_mstat')).toBe('mean');
+    writeUrlParams({ i_mstat: 'median' });
+    expect(new URL(buildShareUrl()).searchParams.has('i_mstat')).toBe(false);
+  });
+
   it('has expected default for g_model', async () => {
     const { PARAM_DEFAULTS } = await import('@/lib/url-state');
     expect(PARAM_DEFAULTS.g_model).toBe('DeepSeek-V4-Pro');
diff --git a/packages/app/src/lib/url-state.ts b/packages/app/src/lib/url-state.ts
index 78755aa95..187d315da 100644
--- a/packages/app/src/lib/url-state.ts
+++ b/packages/app/src/lib/url-state.ts
@@ -30,6 +30,12 @@ const URL_STATE_KEYS = [
   // Token-revenue sale-price source: normalized $1/M or live OpenRouter catalog.
   'i_revenue',
   'i_pctl',
+  'i_mstat',
+  'i_servicecompare',
+  'i_servicebase',
+  'i_servicepeer',
+  'i_servicetarget',
+  'i_roleshare',
   'i_xmetric',
   'i_e2e_xmetric',
   'i_xmode',
@@ -63,6 +69,12 @@ const URL_STATE_KEYS = [
   'i_spec',
   // Measured-power certification tiers ('certified' / 'legacy', comma-joined).
   'i_power',
+  'i_topology',
+  'i_ptlines',
+  'i_ptaxis',
+  'i_ptwindow',
+  'i_ptfocus',
+  'i_ptutility',
   // Completed Perf Rulers on the primary inference chart: `isoX|curveA|curveB`
   // entries joined by `;` (see serializePerfRulers in d3-chart/layers/perf-ruler).
   'i_rulers',
@@ -156,6 +168,12 @@ export const PARAM_DEFAULTS: Record<UrlStateKey, string> = {
   i_metric: DEFAULT_Y_AXIS_METRIC,
   i_revenue: 'normalized',
   i_pctl: 'p90',
+  i_mstat: 'median',
+  i_servicecompare: '0',
+  i_servicebase: '',
+  i_servicepeer: '',
+  i_servicetarget: '',
+  i_roleshare: '0',
   i_xmetric: 'p90_ttft',
   i_e2e_xmetric: 'p90_ttft',
   i_xmode: '',
@@ -183,6 +201,12 @@ export const PARAM_DEFAULTS: Record<UrlStateKey, string> = {
   i_disagg: '',
   i_spec: '',
   i_power: '',
+  i_topology: '',
+  i_ptlines: '',
+  i_ptaxis: '',
+  i_ptwindow: '',
+  i_ptfocus: '',
+  i_ptutility: '',
   i_rulers: '',
   i_pcompare: '',
   i_overview_current: '',
diff --git a/packages/app/src/lib/views-api/docs/extensions.ts b/packages/app/src/lib/views-api/docs/extensions.ts
index 40b9fd9df..78d273843 100644
--- a/packages/app/src/lib/views-api/docs/extensions.ts
+++ b/packages/app/src/lib/views-api/docs/extensions.ts
@@ -129,6 +129,10 @@ const PARAMETER_NOTES: Record<string, [string, string]> = {
     'Comma-separated certified and/or legacy power tiers. Omit for all tiers.',
     '以逗号分隔的 certified、legacy 功率数据等级。省略时选择全部等级。',
   ],
+  topologies: [
+    'Comma-separated exact topology keys from the Dashboard topology selector or view point topologyKey. Filters allocation and parallelism without filtering concurrency; omitted means all. Preserve the keys verbatim. Unknown keys return no matching points.',
+    '逗号分隔的精确拓扑键，取自仪表盘拓扑选择器或数据点的 topologyKey。按 GPU 分配和并行配置筛选，保留全部已测并发；省略时不限制拓扑。原样使用这些键，未知键不会匹配数据点。',
+  ],
   allPoints: [
     'Boolean, default false. Include points clipped by dashboard limits; optimal and best still apply independently.',
     '布尔值，默认为 false。包括被图表范围裁剪的数据点；optimal 和 best 仍独立生效。',
@@ -432,14 +436,14 @@ export const operations: ApiOperation[] = Object.entries(NEW_VIEWS).map(
           view === 'video'
             ? ' Only already published artifacts are read. Cell, phase, slot and GPU-basis choices select result evidence and normalized serving rates; x/y/cost/workload filters produce computed tradeoff points. Local bundles and arbitrary URLs are excluded. Responses are no-store.'
             : view === 'gpu-metrics'
-              ? ' Telemetry reads stored DB series first and falls back to GitHub artifacts when storage is absent. Responses use private, no-store; an upstream database failure remains HTTP 503 rather than an empty dataset. File/host series retain separate identities. Full-record statistics include startup and warmup and use the stored per-GPU digest when present; an empty or missing metric digest stays empty. Only live artifacts compute statistics from samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings.'
+              ? ' Telemetry reads stored DB series first and falls back to GitHub artifacts when storage is absent. Responses use private, no-store; an upstream database failure remains HTTP 503 rather than an empty dataset. File/host series retain separate identities. Full-record statistics include startup and warmup and use the stored per-GPU digest when present; an empty or missing metric digest stays empty. Only live artifacts compute statistics from samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings. This endpoint projects the raw GPU-metrics explorer, not the inference Power Timeline. Timeline role/window evidence comes from its existing series=power read plus benchmark power_audit. Timeline i_ptaxis, i_ptlines, i_ptwindow, i_ptfocus and i_ptutility share fields control client rendering only and are not accepted here; they do not change raw telemetry or full-record statistics.'
               : ''
         }`,
         `只读${zh}，使用仪表板的数据读取和计算函数。未知或重复查询键返回 400；响应包含解析后的参数，保留缺失数据。仅影响样式的控件不作为 API 参数。${
           view === 'video'
             ? ' 仅读取已发布产物。cell、阶段、slot 和 GPU 口径选择对应结果证据，并计算 serving 归一化速率；x/y、成本及工作负载筛选生成权衡图数据点。不读取本地数据包或任意 URL。响应不缓存。'
             : view === 'gpu-metrics'
-              ? ' 遥测优先读取数据库中已存储的序列；缺少存储数据时回退到 GitHub 产物。响应使用 private, no-store；上游数据库故障保留 HTTP 503，不作为空数据返回。各文件、主机的序列身份独立保留。全记录统计包含服务启动与 warmup，已有数据使用数据库中的每 GPU 统计摘要；摘要为空或缺少所选指标时仍返回空统计数组。仅实时产物按样本计算统计。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。'
+              ? ' 遥测优先读取数据库中已存储的序列；缺少存储数据时回退到 GitHub 产物。响应使用 private, no-store；上游数据库故障保留 HTTP 503，不作为空数据返回。各文件、主机的序列身份独立保留。全记录统计包含服务启动与 warmup，已有数据使用数据库中的每 GPU 统计摘要；摘要为空或缺少所选指标时仍返回空统计数组。仅实时产物按样本计算统计。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。 本接口投影原始 GPU-metrics 浏览器，不是推理页的 Power Timeline。时间线通过现有 series=power 读取和基准测试 power_audit 获取角色与窗口证据；i_ptaxis、i_ptlines、i_ptwindow、i_ptfocus 和 i_ptutility 分享字段仅控制客户端显示，本接口不接受这些参数。它们不改变原始遥测或全记录统计。'
               : ''
         }`,
       ),
diff --git a/packages/app/src/lib/views-api/docs/inference.ts b/packages/app/src/lib/views-api/docs/inference.ts
index 3bca9a30b..e8ea04b6f 100644
--- a/packages/app/src/lib/views-api/docs/inference.ts
+++ b/packages/app/src/lib/views-api/docs/inference.ts
@@ -21,7 +21,13 @@ import {
 
 const VIEWS_GROUP: ApiOperation['group'] = 'views';
 
-const X_MODE_ENUM = ['interactivity', 'ttft', 'e2e', 'e2e-normalized-interactivity'] as const;
+const X_MODE_ENUM = [
+  'interactivity',
+  'ttft',
+  'e2e',
+  'e2e-normalized-interactivity',
+  'concurrency',
+] as const;
 
 const parameters: readonly ApiParameter[] = [
   {
@@ -82,12 +88,24 @@ const parameters: readonly ApiParameter[] = [
     required: false,
     type: 'enum',
     description: text(
-      'X-axis mode. e2e-normalized-interactivity uses persisted derived AgentX metrics; points without eligible derived values are omitted.',
-      'X 轴模式。e2e-normalized-interactivity 使用已持久化的 AgentX 派生指标；没有合格派生值的数据点不参与此视图。',
+      'X-axis mode. concurrency uses observed load levels, with no interpolation or optimization ranking; optimal and best resolve to false. e2e-normalized-interactivity uses persisted derived AgentX metrics; points without eligible derived values are omitted.',
+      'X 轴模式。concurrency 使用实测并发值，不插值、不作优化排名；optimal 和 best 均解析为 false。e2e-normalized-interactivity 使用已持久化的 AgentX 派生指标；没有合格派生值的数据点不参与此视图。',
     ),
     schema: { type: 'string', enum: X_MODE_ENUM, default: 'interactivity' },
     example: 'e2e',
   },
+  {
+    name: 'xstat',
+    location: 'query',
+    required: false,
+    type: 'enum',
+    description: text(
+      'Fixed-sequence service-axis statistic: median (default) or mean. Mean streaming speed is 1 / mean TPOT, not the arithmetic mean of per-request speeds. Mean TTFT and E2E use their recorded mean fields. Missing values are omitted, never replaced with median. Ignored for AgentX and concurrency; params.xstat then resolves to null and xAxis.statistic records the effective percentile or null.',
+      '固定长度工作负载服务轴的统计量：median（默认）或 mean。Mean streaming speed 为 1 / mean TPOT，不是各请求速度的算术平均；mean TTFT 和 E2E 使用各自记录的均值。缺失时不回退到 median。AgentX 和 concurrency 不使用此参数，params.xstat 为 null，xAxis.statistic 返回实际分位数或 null。',
+    ),
+    schema: { type: 'string', enum: ['mean', 'median'], default: 'median' },
+    example: 'mean',
+  },
   {
     name: 'xmetric',
     location: 'query',
@@ -197,14 +215,74 @@ const parameters: readonly ApiParameter[] = [
     schema: { type: 'boolean' },
     example: 'true',
   },
+  {
+    name: 'serviceCompare',
+    location: 'query',
+    required: false,
+    type: 'boolean',
+    description: text(
+      'Include source options, equal-service percentage curves and an optional target comparison, using the same helper as the dashboard. Uses scoped observed points before frontier/best pruning. JSON only.',
+      '返回来源选项、同等服务条件下的百分比对比曲线，以及可选目标值对比；复用仪表板计算逻辑，使用筛选后、前沿和 best 筛选前的实测点。仅支持 JSON。',
+    ),
+    schema: { type: 'boolean', default: false },
+    example: 'true',
+  },
+  {
+    name: 'serviceBaseline',
+    location: 'query',
+    required: false,
+    type: 'string',
+    description: text(
+      'Exact baseline key from serviceSources. Omitted selects the first deterministic source; an unknown explicit key remains unavailable. Percent change is 100 × (comparator / baseline − 1).',
+      'serviceSources 中的完整基准来源键。省略时按确定性顺序选择首项；显式未知键保持不可用。变化百分比为 100 ×（对比值 / 基准值 − 1）。',
+    ),
+    schema: stringSchema,
+    example: 'Exact key returned in serviceSources',
+  },
+  {
+    name: 'serviceComparator',
+    location: 'query',
+    required: false,
+    type: 'string',
+    description: text(
+      'Exact comparator key from serviceSources. Omitted selects the second deterministic source. Keys retain hardware, source run, recipe, topology and workload identity; never replace them with a hardware name.',
+      'serviceSources 中的完整对比来源键。省略时按确定性顺序选择第二项。来源键保留硬件、运行、配置配方、拓扑和工作负载标识，不能用硬件名称代替。',
+    ),
+    schema: stringSchema,
+    example: 'Exact key returned in serviceSources',
+  },
+  {
+    name: 'serviceTarget',
+    location: 'query',
+    required: false,
+    type: 'number',
+    description: text(
+      'Positive finite service-axis target: tok/s/user for streaming speed, seconds for TTFT/E2E. Omitted returns the curve and null target comparison. Numerical linear interpolation is bounded by each exact source; no extrapolation or interpolation across missing metric endpoints. Concurrency is unsupported.',
+      '有限正数服务轴目标：streaming speed 单位为 tok/s/user，TTFT/E2E 单位为秒。省略时返回曲线，目标值对比为 null。仅在各完整来源的实测范围内做数值线性插值，不外推、不跨越缺失指标端点。并发轴不适用。',
+    ),
+    schema: { type: 'number', minimum: Number.MIN_VALUE },
+    example: 40,
+  },
+  {
+    name: 'roleShare',
+    location: 'query',
+    required: false,
+    type: 'boolean',
+    description: text(
+      'Include validated disaggregated prefill/decode energy shares on one output-token denominator. Uses same-window aggregate J/output ÷ J/input to convert prefill J/input; share denominator is reconstructed prefill + decode energy, not pool-local token counts. Missing/invalid data is omitted. JSON only.',
+      '返回通过验证的分离式 prefill/decode 能耗占比，统一使用 output token 分母。用同窗口总 J/output ÷ J/input 将 prefill J/input 转换为 J/output；占比分母为重建的 prefill + decode 能耗，不使用各池独立的 token 数。缺失或无效数据不返回，仅支持 JSON。',
+    ),
+    schema: { type: 'boolean', default: false },
+    example: 'true',
+  },
   {
     name: 'format',
     location: 'query',
     required: false,
     type: 'enum',
     description: text(
-      'Response encoding. csv returns one flat row per point.',
-      '响应编码。csv 为每个数据点返回一行平面数据。',
+      'Response encoding. csv returns one flat row per plotted point; serviceCompare and roleShare panels require JSON and return 400 with CSV.',
+      '响应编码。csv 为每个图表点返回一行平面数据；serviceCompare 和 roleShare 面板仅支持 JSON，与 CSV 同用时返回 400。',
     ),
     schema: { type: 'string', enum: ['json', 'csv'], default: 'json' },
     example: 'csv',
@@ -218,6 +296,7 @@ const pointSchema = objectSchema(
     x: numberSchema,
     y: numberSchema,
     concurrency: numberSchema,
+    topologyKey: stringSchema,
     tp: numberSchema,
     date: { type: 'string', format: 'date' },
     runId: integerSchema,
@@ -225,7 +304,7 @@ const pointSchema = objectSchema(
     bestPerSku: booleanSchema,
     metrics: { type: 'object', additionalProperties: numberSchema },
   },
-  ['x', 'y', 'concurrency', 'tp', 'date', 'frontier', 'bestPerSku', 'metrics'],
+  ['x', 'y', 'concurrency', 'topologyKey', 'tp', 'date', 'frontier', 'bestPerSku', 'metrics'],
 );
 
 const seriesSchema = objectSchema(
@@ -254,6 +333,55 @@ const seriesSchema = objectSchema(
   ],
 );
 
+const sourceSchema = objectSchema({ key: stringSchema, label: stringSchema }, ['key', 'label']);
+const identitySchema = objectSchema({
+  id: { type: ['integer', 'null'] },
+  sourceKey: stringSchema,
+  hwKey: stringSchema,
+  precision: stringSchema,
+  concurrency: numberSchema,
+  topologyKey: stringSchema,
+  date: stringSchema,
+  runUrl: { type: ['string', 'null'] },
+  recipeFingerprint: { type: ['string', 'null'] },
+  image: { type: ['string', 'null'] },
+});
+const estimateSchema = {
+  ...objectSchema({
+    value: numberSchema,
+    interpolated: booleanSchema,
+    endpoints: arraySchema(
+      objectSchema({ x: numberSchema, value: numberSchema, point: identitySchema }),
+    ),
+  }),
+  type: ['object', 'null'] as const,
+};
+const serviceMetricSchema = objectSchema({
+  baseline: estimateSchema,
+  comparator: estimateSchema,
+  changePercent: { type: ['number', 'null'] },
+  reason: stringSchema,
+});
+const comparisonSchema = objectSchema({
+  target: numberSchema,
+  xField: stringSchema,
+  baseline: { ...sourceSchema, type: ['object', 'null'] },
+  comparator: { ...sourceSchema, type: ['object', 'null'] },
+  reason: stringSchema,
+  metrics: objectSchema({
+    meanWattsPerGpu: { ...serviceMetricSchema, description: 'Mean measured GPU board W/GPU.' },
+    outputTokensPerSecond: {
+      ...serviceMetricSchema,
+      description:
+        'Whole-deployment output tokens/s; disaggregated GPU-count normalization preserves the workload denominator.',
+    },
+    joulesPerOutputToken: {
+      ...serviceMetricSchema,
+      description: 'Validated measured GPU joules per output token.',
+    },
+  }),
+});
+
 const responseSchema = objectSchema(
   {
     view: { type: 'string', enum: ['inference'] },
@@ -274,12 +402,17 @@ const responseSchema = objectSchema(
       },
       ['key', 'configKey', 'label', 'labelZh'],
     ),
-    xAxis: objectSchema({ mode: stringSchema, field: stringSchema, label: stringSchema }),
+    xAxis: objectSchema({
+      mode: stringSchema,
+      field: stringSchema,
+      label: stringSchema,
+      statistic: { type: ['string', 'null'] },
+    }),
     frontier: objectSchema({
       direction: {
         type: ['string', 'null'],
         description:
-          'Selected boundary direction. Measured-power gauges use upper_right for interactivity or upper_left for latency, independently of metric.direction.',
+          'Selected boundary direction; null for observed concurrency, which has no preferred direction. Measured-power gauges use upper_right for interactivity or upper_left for latency, independently of metric.direction.',
       },
       points: integerSchema,
     }),
@@ -291,6 +424,27 @@ const responseSchema = objectSchema(
     ),
     series: arraySchema(seriesSchema),
     count: integerSchema,
+    serviceSources: arraySchema(sourceSchema),
+    equalServiceComparison: { ...comparisonSchema, type: ['object', 'null'] },
+    equalServiceCurve: arraySchema(comparisonSchema),
+    roleEnergyShares: arraySchema(
+      objectSchema({
+        x: numberSchema,
+        sourceKey: stringSchema,
+        point: identitySchema,
+        prefill: { ...numberSchema, description: 'Prefill energy in J/output token.' },
+        decode: { ...numberSchema, description: 'Decode energy in J/output token.' },
+        total: {
+          ...numberSchema,
+          description: 'Reconstructed prefill + decode energy in J/output token.',
+        },
+        prefillShare: {
+          ...numberSchema,
+          description: 'Prefill percentage of reconstructed total.',
+        },
+        decodeShare: { ...numberSchema, description: 'Decode percentage of reconstructed total.' },
+      }),
+    ),
     pricing: { type: ['object', 'null'], additionalProperties: true },
     comparisons: arraySchema({ type: 'object', additionalProperties: true }),
     overlays: arraySchema({ type: 'object', additionalProperties: true }),
@@ -307,6 +461,7 @@ const responseExample = {
     precisions: ['fp8'],
     metric: 'y_tpPerGpu',
     xmode: 'interactivity',
+    xstat: 'median',
     xmetric: 'p90_ttft',
     percentile: 'p90',
     date: null,
@@ -316,9 +471,15 @@ const responseExample = {
     frameworks: [],
     deployment: [],
     spec: [],
+    topologies: [],
     optimal: true,
     best: true,
     format: 'json',
+    serviceCompare: false,
+    serviceBaseline: null,
+    serviceComparator: null,
+    serviceTarget: null,
+    roleShare: false,
   },
   metric: {
     key: 'tpPerGpu',
@@ -332,6 +493,7 @@ const responseExample = {
   xAxis: {
     mode: 'interactivity',
     field: 'median_intvty',
+    statistic: 'median',
     label: 'Median Interactivity (tok/s/user)',
   },
   frontier: { direction: 'upper_left', points: 14 },
@@ -352,6 +514,7 @@ const responseExample = {
           x: 12.5,
           y: 450.5,
           concurrency: 64,
+          topologyKey: 'Single|GPU=8|DP=?|TP=8|EP=1|PP=?|DCP=?|PCP=?|DPA=0|offload=off',
           tp: 8,
           date: '2026-08-20',
           runId: 12345678,
@@ -380,7 +543,7 @@ const responses: readonly ApiResponse[] = [
         mediaType: 'text/csv',
         schema: stringSchema,
         example:
-          'hwKey,gpu,framework,specMethod,label,vendor,deployment,kvOffload,x,y,concurrency,tp,date,runId,frontier,bestPerSku,metric_tpPerGpu\r\nh200_trt,h200,trt,none,H200 (TRTLLM),NVIDIA,single-node,false,12.5,450.5,64,8,2026-08-20,12345678,true,true,450.5',
+          'hwKey,gpu,framework,specMethod,label,vendor,deployment,kvOffload,x,y,concurrency,topologyKey,tp,date,runId,frontier,bestPerSku,metric_tpPerGpu\r\nh200_trt,h200,trt,none,H200 (TRTLLM),NVIDIA,single-node,false,12.5,450.5,64,Single|GPU=8|DP=?|TP=8|EP=1|PP=?|DCP=?|PCP=?|DPA=0|offload=off,8,2026-08-20,12345678,true,true,450.5',
       },
     ],
   },
diff --git a/packages/app/src/lib/views-api/docs/options.ts b/packages/app/src/lib/views-api/docs/options.ts
index bfd72e0be..86721ff40 100644
--- a/packages/app/src/lib/views-api/docs/options.ts
+++ b/packages/app/src/lib/views-api/docs/options.ts
@@ -78,6 +78,7 @@ const responseSchema = objectSchema(
     specMethods: arraySchema(stringSchema),
     percentiles: arraySchema(stringSchema),
     xAxisModes: arraySchema(stringSchema),
+    fixedSequenceStatistics: arraySchema(stringSchema),
     scaleModes: arraySchema(stringSchema),
     metrics: arraySchema(
       objectSchema({
@@ -157,6 +158,7 @@ const responseExample = {
   specMethods: ['mtp', 'none'],
   percentiles: ['p75', 'p90'],
   xAxisModes: ['interactivity', 'ttft', 'e2e', 'e2e-normalized-interactivity'],
+  fixedSequenceStatistics: ['median', 'mean'],
   scaleModes: ['auto', 'linear', 'log'],
   metrics: [
     {
@@ -183,6 +185,9 @@ const responseExample = {
     metric: 'y_tokensPerDollarH',
     percentile: 'p90',
     xmode: 'interactivity',
+    xstat: 'median',
+    serviceCompare: false,
+    roleShare: false,
   },
 };
 
diff --git a/packages/app/src/lib/views-api/registry.ts b/packages/app/src/lib/views-api/registry.ts
index 3de5ff468..4e5d0952b 100644
--- a/packages/app/src/lib/views-api/registry.ts
+++ b/packages/app/src/lib/views-api/registry.ts
@@ -139,6 +139,7 @@ export const VIEW_QUERY_PARAMS = {
     'vendors',
   ],
   inference: [
+    'topologies',
     'allPoints',
     'best',
     'date',
@@ -166,6 +167,12 @@ export const VIEW_QUERY_PARAMS = {
     'vendors',
     'xmetric',
     'xmode',
+    'xstat',
+    'serviceCompare',
+    'serviceBaseline',
+    'serviceComparator',
+    'serviceTarget',
+    'roleShare',
   ],
   operatorx: [
     'backend',
diff --git a/packages/app/src/lib/views-api/series.test.ts b/packages/app/src/lib/views-api/series.test.ts
index 78a4c5c7a..4df0c2b2f 100644
--- a/packages/app/src/lib/views-api/series.test.ts
+++ b/packages/app/src/lib/views-api/series.test.ts
@@ -116,6 +116,29 @@ function powerSweepRows(): BenchmarkRow[] {
 }
 
 describe('buildInferenceSeries', () => {
+  it.each([
+    ['interactivity', 'mean_tpot_intvty', 20],
+    ['ttft', 'mean_ttft', 0.6],
+    ['e2e', 'mean_e2el', 5],
+  ] as const)('uses recorded means without median fallback for %s', (xmode, field, expected) => {
+    const rows = [
+      makeRow({
+        conc: 1,
+        metrics: metrics({ mean_tpot: 0.05, mean_intvty: 77, mean_ttft: 0.6, mean_e2el: 5 }),
+      }),
+      makeRow({ conc: 2 }),
+    ];
+    const result = buildInferenceSeries(rows, {
+      ...BASE_OPTIONS,
+      xmode,
+      fixedSequenceStatistic: 'mean',
+    });
+    expect(result.xAxis).toMatchObject({ field, statistic: 'mean' });
+    expect(result.series.flatMap((entry) => entry.points).map((point) => point.x)).toEqual([
+      expected,
+    ]);
+  });
+
   it('assembles one series per hardware config with x-sorted points', () => {
     const result = buildInferenceSeries(fixtureRows(), BASE_OPTIONS);
 
@@ -288,6 +311,59 @@ describe('buildInferenceSeries', () => {
     expect(best.series[0].bestPerSku).toBe(true);
   });
 
+  it.each(['y_measuredAvgPower', 'y_measuredJPerOutputToken'] as const)(
+    'retains all observed loads for %s without optimal/best ranking',
+    (metricConfigKey) => {
+      const rows = powerSweepRows();
+      const result = buildInferenceSeries(rows, {
+        ...BASE_OPTIONS,
+        xmode: 'concurrency',
+        metricConfigKey,
+        optimal: true,
+        best: true,
+      });
+      expect(result.xAxis).toEqual({
+        mode: 'concurrency',
+        field: 'conc',
+        label: 'Concurrency',
+        statistic: null,
+      });
+      expect(result.count).toBe(rows.length);
+      const points = result.series.flatMap((series) => series.points);
+      expect(points.map((point) => point.x)).toEqual(
+        rows.map((row) => row.conc).toSorted((a, b) => a - b),
+      );
+      expect(points.every((point) => !point.frontier && !point.bestPerSku)).toBe(true);
+      expect(result.frontier).toEqual({ direction: null, points: 0 });
+      expect(result.metric.direction).toBeNull();
+    },
+  );
+
+  it('exports reusable topology keys and preserves every load within the chosen topology', () => {
+    const rows = [
+      makeRow({ conc: 1 }),
+      makeRow({ conc: 4 }),
+      makeRow({ conc: 4, prefill_tp: 4, decode_tp: 4, num_prefill_gpu: 4, num_decode_gpu: 4 }),
+    ];
+    const all = buildInferenceSeries(rows, { ...BASE_OPTIONS, xmode: 'concurrency' });
+    const points = all.series.flatMap((series) => series.points);
+    expect(new Set(points.map((point) => point.topologyKey)).size).toBe(2);
+    const topology = points.find((point) => point.concurrency === 1)!.topologyKey;
+    const filtered = buildInferenceSeries(rows, {
+      ...BASE_OPTIONS,
+      xmode: 'concurrency',
+      quickFilters: { ...BASE_OPTIONS.quickFilters, topologies: [topology] },
+    });
+    expect(filtered.series.flatMap((series) => series.points).map((point) => point.x)).toEqual([
+      1, 4,
+    ]);
+    expect(
+      filtered.series
+        .flatMap((series) => series.points)
+        .every((point) => point.topologyKey === topology),
+    ).toBe(true);
+  });
+
   it('switches x axis per xmode', () => {
     const rows = fixtureRows();
 
diff --git a/packages/app/src/lib/views-api/series.ts b/packages/app/src/lib/views-api/series.ts
index acdb88abe..54cc033e4 100644
--- a/packages/app/src/lib/views-api/series.ts
+++ b/packages/app/src/lib/views-api/series.ts
@@ -30,7 +30,11 @@ import {
   upperPowerEnvelope,
 } from '@/components/inference/utils/powerCurves';
 import { pointDeploymentMode, type QuickFilters } from '@/components/inference/utils/quickFilters';
-import { resolveXAxisField } from '@/components/inference/utils/resolveXAxisField';
+import { pointTopologyKey } from '@/components/inference/utils/topology-filter';
+import {
+  resolveXAxisField,
+  type FixedSequenceStatistic,
+} from '@/components/inference/utils/resolveXAxisField';
 import type { DerivedAgenticMetricMap } from '@/hooks/api/use-derived-agentic-metrics';
 import type { BenchmarkRow } from '@/lib/api';
 import { transformBenchmarkRows } from '@/lib/benchmark-transform';
@@ -61,7 +65,12 @@ import { hardwareLegendLabel, unitFromLabel } from '@/lib/views-api/legend';
 
 /** X-axis modes the API serves. `e2e-normalized-interactivity` is trace-derived
  * client-side and has no server-side data source, so it is not accepted here. */
-export type SeriesXMode = 'interactivity' | 'ttft' | 'e2e' | 'e2e-normalized-interactivity';
+export type SeriesXMode =
+  | 'interactivity'
+  | 'ttft'
+  | 'e2e'
+  | 'e2e-normalized-interactivity'
+  | 'concurrency';
 
 export interface InferenceSeriesOptions {
   readonly sequence: Sequence;
@@ -71,6 +80,8 @@ export interface InferenceSeriesOptions {
   readonly precisions: readonly string[];
   readonly metricConfigKey: MetricConfigKey;
   readonly xmode: SeriesXMode;
+  /** Fixed-sequence service-axis statistic; ignored for Agentic and concurrency. */
+  readonly fixedSequenceStatistic?: FixedSequenceStatistic;
   /** TTFT x metric override (e.g. `p90_ttft`); used by `ttft` mode and input metrics. */
   readonly xmetric: string;
   /** Explicit hwKey / bare-GPU selection; empty = all. */
@@ -94,6 +105,7 @@ export interface InferenceSeriesPoint {
   readonly x: number;
   readonly y: number;
   readonly concurrency: number;
+  readonly topologyKey: string;
   readonly tp: number;
   readonly date: string;
   readonly runId?: number;
@@ -130,7 +142,9 @@ export interface InferenceSeriesResult {
   readonly hardware: readonly { key: string; label: string; vendor?: string }[];
   readonly frontier: { direction: ParetoDirection | null; points: number };
   readonly metric: InferenceSeriesMetricMeta;
-  readonly xAxis: { mode: SeriesXMode; field: string; label: string };
+  readonly xAxis: { mode: SeriesXMode; field: string; label: string; statistic: string | null };
+  /** Scoped observed points before frontier/best-only pruning; not a public raw-row payload. */
+  readonly observedPoints: readonly InferenceData[];
   readonly count: number;
 }
 
@@ -171,16 +185,19 @@ function resolveXAxisLabel(
   effectiveXMetric: string | null,
   isAgentic: boolean,
   percentile: string,
+  xAxisField: string,
 ): string {
+  if (branch === 'concurrency') return 'Concurrency';
   let label = chartDef.x_label;
   if (branch === 'e2e-ttft-override') {
     const pctl = (effectiveXMetric ?? 'p90_ttft').replace(/_ttft$/u, '');
     const pctlWord = pctl === 'median' ? 'Median' : pctl.toUpperCase();
     label = `${pctlWord} Time To First Token (s)`;
   }
-  if (isAgentic) {
-    label = applyAgenticPercentileToXLabel(label, percentile.toUpperCase());
-  }
+  label = applyAgenticPercentileToXLabel(
+    label,
+    isAgentic ? percentile.toUpperCase() : xAxisField.startsWith('mean_') ? 'Mean' : 'Median',
+  );
   return label;
 }
 
@@ -221,6 +238,7 @@ export function buildInferenceSeries(
     isAgentic,
     percentile,
     xAxisMode: xmode,
+    fixedSequenceStatistic: options.fixedSequenceStatistic,
   });
 
   // 4. Precision + scope filters (GPU picks and vendor/framework/deployment/spec pills).
@@ -259,10 +277,15 @@ export function buildInferenceSeries(
   const remapped = scoped
     .filter((point) => metricKey in point && supportsPointTokenMetric(point, tokenType))
     .map((point) => remapInferencePoint(point, metricKey, resolved.xAxisField));
-  const partition = partitionChartDataByLimits(remapped, chartDef, metricConfigKey, {
-    isTtftX: resolved.xAxisField.endsWith('_ttft'),
-    isAgentic,
-  });
+  const partition = partitionChartDataByLimits(
+    remapped,
+    { ...chartDef, x_scale_field: resolved.xAxisField },
+    metricConfigKey,
+    {
+      isTtftX: resolved.xAxisField.endsWith('_ttft'),
+      isAgentic,
+    },
+  );
   let mapped = options.allPoints ? remapped : partition.data;
   if (xmode === 'e2e-normalized-interactivity')
     mapped = mapped.flatMap((point) => {
@@ -280,19 +303,24 @@ export function buildInferenceSeries(
     resolved.xAxisField !== resolved.naturalX &&
     !(chartDef.chartType === 'e2e' && resolved.isTtftOverride);
   const direction =
-    configuredDirection && xAxisFlipped
-      ? flipRooflineDirection(configuredDirection)
-      : (configuredDirection ?? null);
+    xmode === 'concurrency'
+      ? null
+      : configuredDirection && xAxisFlipped
+        ? flipRooflineDirection(configuredDirection)
+        : (configuredDirection ?? null);
 
   // 7. Frontier flags, scoped per (hwKey, precision, date) like ScatterGraph.
   // Measured power represents load demand, so retain its upper boundary.
   const isMeasuredPower = isMeasuredPowerCurveMetric(metricConfigKey);
   const maximizePowerX = chartDef.chartType !== 'e2e';
-  const frontierDirection = isMeasuredPower
-    ? maximizePowerX
-      ? 'upper_right'
-      : 'upper_left'
-    : direction;
+  const frontierDirection =
+    xmode === 'concurrency'
+      ? null
+      : isMeasuredPower
+        ? maximizePowerX
+          ? 'upper_right'
+          : 'upper_left'
+        : direction;
   const frontierPoints = new Set<InferenceData>();
   if (direction) {
     const frontierFn = paretoFrontForDirection(direction);
@@ -334,7 +362,10 @@ export function buildInferenceSeries(
     if (best && bestHwKeys.size > 0 && !seriesIsBest) continue;
 
     const allPoints = byHwKey.get(hwKey)!;
-    const kept = optimal ? allPoints.filter((point) => frontierPoints.has(point)) : allPoints;
+    const kept =
+      optimal && xmode !== 'concurrency'
+        ? allPoints.filter((point) => frontierPoints.has(point))
+        : allPoints;
     if (kept.length === 0) continue;
 
     const sample = kept[0];
@@ -363,6 +394,7 @@ export function buildInferenceSeries(
           x: point.x,
           y: point.y,
           concurrency: point.conc ?? 0,
+          topologyKey: pointTopologyKey(point),
           tp: point.tp ?? 0,
           date: point.date ?? '',
           ...(runIdFromUrl(point.run_url) === undefined
@@ -396,6 +428,12 @@ export function buildInferenceSeries(
     },
     xAxis: {
       mode: xmode,
+      statistic:
+        xmode === 'concurrency'
+          ? null
+          : isAgentic
+            ? percentile
+            : (options.fixedSequenceStatistic ?? 'median'),
       field:
         xmode === 'e2e-normalized-interactivity'
           ? `${percentile}_e2e_norm_intvty`
@@ -403,8 +441,16 @@ export function buildInferenceSeries(
       label:
         xmode === 'e2e-normalized-interactivity'
           ? `${percentile.toUpperCase()} E2E Normalized Interactivity (tok/s/user)`
-          : resolveXAxisLabel(chartDef, resolved.branch, effectiveXMetric, isAgentic, percentile),
+          : resolveXAxisLabel(
+              chartDef,
+              resolved.branch,
+              effectiveXMetric,
+              isAgentic,
+              percentile,
+              String(resolved.xAxisField),
+            ),
     },
+    observedPoints: mapped,
     count,
   };
 }
diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index 1b8c97b2a..cee8532c2 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -7,7 +7,7 @@
     "references/cli-contract.md": "82e0016e42bc1d06c3ac53b33473a0a56d0df422c6006fc74b5f3a75ac21b8d9",
     "references/cli.md": "580ea3492c3835ccc45298b339fa2a8c6fc457079a547cb04be3432a263752b0",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "68b51d04395e6a5f3bc7255194333a0a26a83e24094803fcd3bf29e5af333b15",
+    "references/dashboard-views.md": "8703d877157ecd63fdda4b4596a2b7dd9b089850b4a13748f40589a9d29e0108",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/powerx.md": "f04f89ce77590d6898a776f892749722f4f4303e40e7daeeb576cbcff5d098cf",
     "references/provenance.md": "da4e9d078b31f234727706593f77ca9d5fdac611921783aaa09b5741de58b69a",
diff --git a/packages/skills/skills/inferencex-api/references/dashboard-views.md b/packages/skills/skills/inferencex-api/references/dashboard-views.md
index 5eec9cf6d..7dcd10b5c 100644
--- a/packages/skills/skills/inferencex-api/references/dashboard-views.md
+++ b/packages/skills/skills/inferencex-api/references/dashboard-views.md
@@ -39,29 +39,29 @@ All paths below are relative to `/api/v1/views/`. The maintained exhaustive
 query-key list is in the app's OpenAPI contract. The following groups explain
 which controls belong together.
 
-| View                            | Selection and calculation                                                                                                                                                                                                                                 |
-| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `options`                       | Static registries and defaults, JSON only. Data-dependent run/config choices come from their own views.                                                                                                                                                   |
-| `inference`                     | Model, sequence, precisions, date/exact run, GPU/vendor/framework/deployment/spec/power filters; metric, xmode, xmetric, percentile, optimal/best/allPoints; TCO, custom costs/powers, pricing, unofficial runs, comparison dates/endpoints. JSON or CSV. |
-| `historical`                    | Model, sequence, target, metric, precisions, GPUs/vendors/frameworks/deployment, start/end, TCO and pricing. `extendToDate` labels synthetic extension, defaults to current UTC date. JSON or CSV.                                                        |
-| `calculator`                    | Model/sequence/run/date, precisions/GPUs, percentile, target/mode, token type, owning/renting cost, TCO, power budget, cost cap, hide-above-limit and public unofficial runs. JSON or CSV.                                                                |
-| `first-token`                   | Benchmark selection plus 1–8 positive TTFT caps in seconds, minimum interactivity, cost provider and token type. Shared dashboard winner selection.                                                                                                       |
-| `cache-reuse`                   | AgentX selection plus exact `config` from returned configurations. Cache-reuse curves retain official versus unofficial evidence.                                                                                                                         |
-| `profit-estimator`              | AgentX selection, comparison dates/runs, target, utilization, lab revenue share, list/OpenRouter/custom token prices, own/rent/custom chip costs, TCO and provisioned/modeled/compare power. USD/chip-hour.                                               |
-| `profit-estimator-per-gigawatt` | Same selectors; USD/GW-year basis and owning-cost default.                                                                                                                                                                                                |
-| `fleet`                         | Model/sequence/precision/GPUs, target/percentile, TCO/token type/cost provider, MW, input/output prices, ramp, cache discount, MTBI, recovery, horizon and metric. JSON or CSV.                                                                           |
-| `evaluation`                    | Model, task, date, precision and GPU selection; public unofficial runs remain separately labeled and independent of the official date cutoff. JSON or CSV.                                                                                                |
-| `reliability`                   | Rolling range, GPU selection and optional `asOf` date for reproducibility. JSON or CSV.                                                                                                                                                                   |
-| `gpu-specs`                     | Full hardware properties or selected metric ranking; table/radar/bar are renderings of these values. JSON or CSV.                                                                                                                                         |
-| `overview`                      | Models, model/hardware row limits, hardware tier, engine, comparison mode and reference. JSON or CSV.                                                                                                                                                     |
-| `rankings`                      | Ranking kind (model or chip), selected model/scenario and format. Use the exact values in OpenAPI.                                                                                                                                                        |
-| `compare`                       | GPU pairs, model/slug, scenario, tier selection and variant. JSON or CSV.                                                                                                                                                                                 |
-| `operatorx`                     | Exact/default measured run, operator, precision, shape, backend, cluster, status, throughput/latency and zero-based table page.                                                                                                                           |
-| `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                               |
-| `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                    |
-| `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                 |
-| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first telemetry; full-record statistics use stored digests. Responses are no-store.                 |
-| `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                    |
+| View                            | Selection and calculation                                                                                                                                                                                                                                                                                    |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `options`                       | Static registries and defaults, JSON only. Data-dependent run/config choices come from their own views.                                                                                                                                                                                                      |
+| `inference`                     | Model, sequence, precisions, date/exact run, GPU/vendor/framework/deployment/spec/power filters; metric, xmode, xstat, xmetric, percentile, optimal/best/allPoints; equal-service sources/target and roleShare; TCO, custom costs/powers, pricing, unofficial runs, comparison dates/endpoints. JSON or CSV. |
+| `historical`                    | Model, sequence, target, metric, precisions, GPUs/vendors/frameworks/deployment, start/end, TCO and pricing. `extendToDate` labels synthetic extension, defaults to current UTC date. JSON or CSV.                                                                                                           |
+| `calculator`                    | Model/sequence/run/date, precisions/GPUs, percentile, target/mode, token type, owning/renting cost, TCO, power budget, cost cap, hide-above-limit and public unofficial runs. JSON or CSV.                                                                                                                   |
+| `first-token`                   | Benchmark selection plus 1–8 positive TTFT caps in seconds, minimum interactivity, cost provider and token type. Shared dashboard winner selection.                                                                                                                                                          |
+| `cache-reuse`                   | AgentX selection plus exact `config` from returned configurations. Cache-reuse curves retain official versus unofficial evidence.                                                                                                                                                                            |
+| `profit-estimator`              | AgentX selection, comparison dates/runs, target, utilization, lab revenue share, list/OpenRouter/custom token prices, own/rent/custom chip costs, TCO and provisioned/modeled/compare power. USD/chip-hour.                                                                                                  |
+| `profit-estimator-per-gigawatt` | Same selectors; USD/GW-year basis and owning-cost default.                                                                                                                                                                                                                                                   |
+| `fleet`                         | Model/sequence/precision/GPUs, target/percentile, TCO/token type/cost provider, MW, input/output prices, ramp, cache discount, MTBI, recovery, horizon and metric. JSON or CSV.                                                                                                                              |
+| `evaluation`                    | Model, task, date, precision and GPU selection; public unofficial runs remain separately labeled and independent of the official date cutoff. JSON or CSV.                                                                                                                                                   |
+| `reliability`                   | Rolling range, GPU selection and optional `asOf` date for reproducibility. JSON or CSV.                                                                                                                                                                                                                      |
+| `gpu-specs`                     | Full hardware properties or selected metric ranking; table/radar/bar are renderings of these values. JSON or CSV.                                                                                                                                                                                            |
+| `overview`                      | Models, model/hardware row limits, hardware tier, engine, comparison mode and reference. JSON or CSV.                                                                                                                                                                                                        |
+| `rankings`                      | Ranking kind (model or chip), selected model/scenario and format. Use the exact values in OpenAPI.                                                                                                                                                                                                           |
+| `compare`                       | GPU pairs, model/slug, scenario, tier selection and variant. JSON or CSV.                                                                                                                                                                                                                                    |
+| `operatorx`                     | Exact/default measured run, operator, precision, shape, backend, cluster, status, throughput/latency and zero-based table page.                                                                                                                                                                              |
+| `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                                                                                  |
+| `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                                                                       |
+| `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                                                                    |
+| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first raw-explorer projection; full-record statistics use stored digests. Not a serving-window/role-pool projection. Responses are no-store.           |
+| `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                                                                       |
 
 ## Interpretation and maintenance
 
@@ -82,6 +82,47 @@ envelope. `frontier.direction` describes that boundary; `metric.direction` retai
 the optimization direction used by `best=true`. Interpret the envelope as a load
 boundary, not evidence that those points are more energy efficient.
 
+Prefer equal-service comparisons for article-facing hardware analysis. Use
+`xstat=mean` only for fixed-sequence service axes when that statistic is intended:
+streaming speed then means **1 / mean TPOT**, not arithmetic mean request speed.
+TTFT/E2E use recorded means. Default is median; absent means are not replaced.
+AgentX still uses `percentile`; concurrency uses no statistic. Check resolved
+`params.xstat` and `xAxis.statistic`, not the requested parameter alone.
+
+`serviceCompare=true` returns exact opaque `serviceSources` keys, an
+`equalServiceCurve`, and an optional `equalServiceComparison` at `serviceTarget`.
+Use returned keys verbatim for `serviceBaseline` and `serviceComparator` via
+`URLSearchParams`; never substitute bare GPU names. Omitted keys select the first
+two sources; unknown explicit keys stay unavailable. Omitted target means no
+selected-target result. Targets are tok/s/user for streaming speed, seconds for
+TTFT/E2E. Concurrency is unsupported for equal-service interpolation.
+
+The same dashboard helper uses scoped observed points before frontier/best
+pruning, with no power-comparison clones. It interpolates raw quantities
+linearly only inside each exact source range, then reports signed
+`100 × (comparator / baseline − 1)`. Metrics are measured GPU W/GPU,
+whole-deployment output tokens/s, and validated GPU J/output token. Negative energy
+change means lower comparator energy. Preserve bracket endpoint identities,
+`interpolated`, missing reasons and nulls. Never call interpolated points new
+measurements or bridge different runs, recipes, topologies or missing endpoints.
+
+`roleShare=true` returns validated disaggregated prefill/decode J/output and their
+shares of reconstructed total energy. It converts prefill J/input using the
+same-window aggregate J/output-to-J/input ratio; it does not compare unlike token
+denominators. Missing roles are omitted. Both panels require JSON; enabling
+either with CSV returns 400. Existing CSV remains a plotted-point export.
+
+For exact-load comparisons, use `xmode=concurrency`. The response resolves
+`optimal=false` and `best=false`, retains every eligible observed load, and sets
+`frontier.direction=null`; concurrency is not a speed or quality preference.
+Filter `topologies` with one or more exact `point.topologyKey` values from a first
+response (encode with `URLSearchParams`). This selects the same GPU count,
+parallelism, role-pool split and offload mode across hardware without removing
+loads. Unknown metadata stays unknown, not equivalent to an explicit setting.
+Keep hardware, precision, recipe, run/date and software provenance separate;
+matching topology alone does not establish a controlled hardware comparison.
+Missing concurrency points must remain absent, not interpolated or extrapolated.
+
 Fleet lifecycle defaults (ramp, cached-input percent, MTBI, recovery) follow the
 dashboard's lifecycle panel; read the current values from `/api/v1/views/options`
 rather than hard-coding them.

From 8ed449cb545b57a4cb18f3f3adf4cc835fefdff8 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Wed, 23 Sep 2026 23:35:33 +0000
Subject: [PATCH 033/103] refactor: deslop PowerX telemetry PR (dedupe helpers,
 drop dead code, trim doc repeats)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Behaviour-preserving cleanup across the PowerX telemetry changes: fold copy-pasted directory walkers, sample builders, positive-finite predicates and Cypress overlay fixtures into shared helpers; derive union types from their as-const arrays; drop unused aliases, casts and banner comments; trim doc paragraphs that restated powerx-persistence-recovery.md; correct the state-ownership and permanent-view docs, which claimed the Timeline i_pt* settings never enter the URL; refresh the api-route-catalog digests for the touched shared-contract sources. No test assertions, DB statements, API shapes, Chinese copy or analytics calls change.

中文：对 PowerX 遥测改动做保持行为不变的清理：把重复的目录遍历、样本构造、正有限数判断和 Cypress overlay fixture 合并为共享 helper；联合类型改为从 as-const 数组推导；删除未使用的别名、类型断言和分隔注释；精简重复 powerx-persistence-recovery.md 的文档段落；修正 state-ownership 与 permanent-view 文档中"Timeline 的 i_pt* 设置不会进入 URL"的错误说法；刷新受影响共享契约源文件的 api-route-catalog 摘要。测试断言、数据库语句、API 形状、中文文案和埋点调用均未改动。

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016n6GykxDSzib8Kz5WntoJq
---
 docs/data-pipeline.md                         |  47 +---
 docs/powerx-permanent-view.md                 |  15 +-
 docs/powerx-persistence-recovery.md           |  10 +-
 docs/state-ownership.md                       |   2 +-
 .../cypress/component/gpu-metrics-axis.cy.tsx |   9 +-
 .../cypress/component/power-compare.cy.tsx    |  16 +-
 .../power-metric-availability.cy.tsx          |  34 +--
 .../component/power-service-comparison.cy.tsx |  15 +-
 .../cypress/component/power-timeline.cy.tsx   | 218 ++++++------------
 packages/app/cypress/e2e/powerx-basis.cy.ts   |   6 +-
 packages/app/scripts/powerx-db-acceptance.ts  |  15 +-
 packages/app/scripts/powerx-db-fixture.ts     |   5 +-
 .../app/src/app/api/gpu-metrics/route.test.ts |  19 +-
 packages/app/src/app/api/gpu-metrics/route.ts |  18 +-
 .../src/app/api/v1/views/inference/route.ts   |  17 +-
 .../gpu-power/power-audit-bundle.ts           |  22 +-
 .../gpu-power/stored-power-series.ts          |   5 +-
 .../app/src/components/gpu-power/types.ts     |  13 +-
 .../agentic-point/overlay-sources.ts          |   5 -
 .../agentic-point/power-telemetry-view.tsx    |   6 +-
 .../agentic-point/use-detail-view.ts          |   9 +-
 .../inference/hooks/useChartData.ts           |   9 +-
 .../app/src/components/inference/types.ts     |  12 +-
 .../components/inference/ui/ChartDisplay.tsx  |   4 +-
 .../inference/ui/PowerMetricAvailability.tsx  |  16 +-
 .../inference/ui/PowerServiceComparison.tsx   |   5 +-
 .../components/inference/ui/PowerTimeline.tsx |  23 +-
 .../components/inference/ui/ScatterGraph.tsx  |  36 ++-
 .../utils/equal-service-comparison.ts         |  20 +-
 .../components/inference/utils/powerCurves.ts |   5 +-
 .../inference/utils/powerTimeline.test.ts     |  14 +-
 .../inference/utils/powerTimeline.ts          |   2 -
 .../components/inference/utils/role-energy.ts |   9 +-
 packages/app/src/lib/api-route-catalog.ts     |  14 +-
 packages/app/src/lib/chart-utils.ts           |  46 ++--
 packages/app/src/lib/inference-labels.ts      |   2 +-
 packages/app/src/lib/power-basis.ts           |  26 ++-
 packages/db/src/backfill-gpu-metrics.ts       |  22 +-
 packages/db/src/etl/gpu-metrics-artifacts.ts  |  55 ++---
 packages/db/src/etl/gpu-metrics-csv.ts        |   2 +-
 packages/db/src/etl/gpu-metrics-ingest.ts     | 103 +++++----
 .../db/src/etl/multinode-power-samples.ts     |  30 +--
 packages/db/src/etl/power-audit-recovery.ts   |  18 +-
 packages/db/src/etl/power-publication.ts      |   7 +-
 .../etl/required-power-publication.test.ts    |  22 +-
 .../db/src/etl/required-power-publication.ts  |   2 +-
 packages/db/src/ingest-ci-run.ts              |  12 +-
 packages/db/src/ingest-ci-telemetry.test.ts   |   5 +-
 .../db/src/lib/backfill-benchmark-refresh.ts  |   9 +-
 packages/db/src/lib/backfill-runner.ts        |  10 +-
 packages/db/src/lib/telemetry-purge.ts        |  19 +-
 packages/db/src/queries/gpu-metrics.ts        |  30 +--
 packages/db/src/verify-power-publication.ts   |   3 +-
 53 files changed, 425 insertions(+), 673 deletions(-)

diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index 8b4fac9f2..81957fe67 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -589,46 +589,13 @@ run — are never copied. Our own GCS reader (`lib/gcs-artifacts.ts`) additional
 ignores everything but `bmk_`/`server_logs_` objects, so widening the mirror's run
 filter would also need a reader change before backfill could use it.
 
-Readers: `/api/gpu-metrics?runId=` serves stored telemetry first, including
-`series=power` Timeline buckets reconstructed with retained windows and device
-identities. Missing storage falls back to GitHub artifacts. Known-incomplete CSV
-fallback must match retained filenames and sample counts; known-incomplete bundles
-need exact-source re-ingest. Healthy DB series remain in mixed fallback responses.
-Database failures return `503 DATABASE_UNAVAILABLE`; incomplete storage without
-usable fallback returns `503 STORED_TELEMETRY_INCOMPLETE` with re-ingest guidance.
-Timeline requests use read-only POST with sorted validation basenames in a `sources`
-JSON body. Stored coverage of those identities permits an artifact-independent response;
-missing siblings, including other windows in the same bundle, use source-level DB-first
-merging. Unavailable artifacts leave healthy DB traces readable with explicit missing
-sources. `sourceCoverage` describes only the requested identities; legacy GET reports
-coverage unknown. Plain CSV fallback applies the adjacent context timezone just like
-ingest and bundle reads. Raw multi-file artifacts retain separate file/host series.
-Successful reads and storage errors use no-store.
-
-AgentX nested validation documents are matched to the exact root result and retained
-window before receiving a canonical validation filename alias. Original path, result
-filename and validation hash remain in stored sidecars. CI attaches recovered source
-and window metadata before benchmark publication/upsert; targeted telemetry re-ingest
-fills only NULL provenance for a unique explicit run/result/concurrency match, even
-when samples are unchanged. Metrics and validity remain untouched. Benchmark metadata
-repair additionally needs the existing materialized-view refresh and benchmark-cache
-invalidation before the UI planner can discover the restored Timeline source.
-
-`/api/v1/gpu-metrics-point?id=` powers the PowerX point-detail tab. Every request
-checks the current DB revision before reading its Blob payload cache. Sidecar repairs,
-new point links and shared-series changes therefore select fresh payloads without a
-manual purge. Success, missing-point and error responses use no-store; missing data
-is 404 and database failures remain errors. Cache-write failures log a warning and
-serve the fresh uncached result; the next request retries cache population.
-
-The public `/api/v1/views/gpu-metrics` projection and full-record UI table use the
-same stored per-GPU statistics digest for the selected file/host series. Empty or
-missing metric digests remain empty; only live artifacts calculate from samples.
-Statistics include startup and warmup, retain measured zero, and exclude missing
-readings per metric after first-wins timestamp/GPU deduplication. Mean is
-sample-weighted, percentiles interpolate at `p * (N - 1)`, and standard deviation
-divides by `N`. GPU visibility and chart downsampling do not alter this population.
-Serving-window power, J/token and selected-time-window calculations remain separate.
+Readers — `/api/gpu-metrics?runId=` (including the `series=power` Timeline POST),
+the `/api/v1/gpu-metrics-point?id=` point-detail cache and the public
+`/api/v1/views/gpu-metrics` statistics projection — serve stored telemetry first and
+fall back to GitHub artifacts only for storage that is missing; database failures are
+`503` errors, never an empty result. Fallback and coverage rules, AgentX nested
+validation aliases, cache-revision checks and the full-record statistics definitions
+are in [PowerX persistence and repair](./powerx-persistence-recovery.md).
 
 中文：历史遥测和 Timeline 优先读取数据库；缺少存储数据时回退到 GitHub 产物，
 文件、主机与 GPU 的身份保持独立。数据库故障返回 503；已知存储不完整且无法恢复时，
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 7ded29c2c..bfd24f917 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -260,11 +260,16 @@ config is `display: 'timeline'`.
   one-shot module store (`requestPowerTraceFocus`); the timeline consumes it on mount, dims
   every other trace, switches to pool mode when the trace has roles, and shows a _Focused on …_
   chip (`data-testid="power-timeline-focus"`) with _Show all_ to clear. The link's `href` is
-  the current page with `i_metric=y_measuredPowerTimeline`, so open-in-new-tab lands on the
-  timeline (unfocused: the focus is a gesture, not URL state).
-- **State.** Axis mode, line mode (mean / per GPU / pools), the all-in switch, the focused
-  trace and hover highlight are component state, not URL state: the share link is `i_metric=y_measuredPowerTimeline` plus the usual
-  scope, and a reader lands on the same defaults.
+  the current page with `i_metric=y_measuredPowerTimeline` only, so open-in-new-tab lands on
+  the unfocused timeline; once the focus is applied it is written to `i_ptfocus` like the other
+  timeline settings.
+- **State.** Axis mode (`i_ptaxis`), line mode (`i_ptlines`: mean / `gpu` / `pool`), window-only
+  display (`i_ptwindow`), the focused trace (`i_ptfocus`) and the all-in switch (`i_ptutility`)
+  are `PowerTimeline` component state mirrored into the URL by the component itself
+  (`parsePowerTimelineParams` on mount, `setUrlParams` on change); defaults serialize as `''`.
+  Hover highlight is never shared. See
+  [Dashboard read-only views](./dashboard-readonly-views.md) for the renderer-only status of
+  these fields against the raw `gpu-metrics` API.
 - **Analytics.** `inference_power_timeline_loaded { traces, missing, runs }`,
   `inference_power_timeline_axis_changed { mode }`,
   `inference_power_timeline_lines_changed { lines: 'mean' | 'gpu' | 'pool' }`,
diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
index 06f5ee1bd..600ff0a37 100644
--- a/docs/powerx-persistence-recovery.md
+++ b/docs/powerx-persistence-recovery.md
@@ -4,8 +4,7 @@ PowerX point detail, the run explorer and Power Timeline read migration-016 tele
 from the database. Timeline applies the same prefix selection, validation-window cuts,
 60-second padding and one-second per-device means as the artifact path. Stored samples
 retain UTC timestamps, original units and separate host-local GPU identities. GitHub
-remains the fallback for telemetry that has not been stored. Database failures return an
-error, not an empty result or an artifact fallback.
+remains the fallback for telemetry that has not been stored.
 
 Timeline sends a read-only `POST /api/gpu-metrics?runId=RUN_ID&series=power&prefix=PREFIX`
 with JSON `{ "sources": ["power_validation_RESULT_FILENAME.json"] }`. The planner sorts
@@ -131,7 +130,6 @@ the unknown denominator.
 This also applies on the first receipt: a selected expired benchmark sibling records
 an expectation error without attempting a download. Superseded retries and unrelated
 targets remain excluded by the existing logical-name and artifact filters.
-Known failed benchmark rows remain excluded, matching normal CI.
 
 Historical backfill retains the resolver's exact-first, unique-fallback offload matching.
 A proven fallback uses the persisted point's offload identity before receipt counting
@@ -201,12 +199,6 @@ float32 tolerance rather than the tighter tolerance of the in-memory parser test
 From the repository root:
 
 ```sh
-bun install --frozen-lockfile --ignore-scripts
-bun run test:unit
-bun run typecheck
-bun run lint
-bun run fmt
-bun run check:typography
 bun run --cwd packages/app test:unit src/app/api/v1/gpu-metrics-point/route.test.ts
 bun run --cwd packages/app test:unit src/app/api/v1/views/gpu-metrics/route.test.ts
 bun run --cwd packages/db test:unit src/queries/gpu-metrics-timeline.test.ts src/etl/telemetry-receipt.test.ts
diff --git a/docs/state-ownership.md b/docs/state-ownership.md
index 4c8ff69d5..c5fac4f21 100644
--- a/docs/state-ownership.md
+++ b/docs/state-ownership.md
@@ -114,7 +114,7 @@ Axis and presentation state:
 
 - selected x-axis and y-axis metrics, percentile, and effective x-axis mode
 - the Measured controls (Boundary / Per / Scope / Statistic / Display / Unit) own no state: `measured-metric-config.ts` resolves each selection to the nearest registered metric key and writes it back to `selectedYAxisMetric`, so the power boundary rides on `i_metric` (there is deliberately no `i_pbasis`; see [PowerX Permanent View](./powerx-permanent-view.md))
-- the Measured Power Display value `timeline` (`y_measuredPowerTimeline`) swaps the chart body for `PowerTimeline`; its axis mode, per-GPU lines and all-in reference switch are component state and never enter the URL
+- the Measured Power Display value `timeline` (`y_measuredPowerTimeline`) swaps the chart body for `PowerTimeline`; its axis mode, line mode, window-only display, focused trace and all-in reference switch are component state that `PowerTimeline` itself reads and writes through `useUrlState` as `i_ptaxis` / `i_ptlines` / `i_ptwindow` / `i_ptfocus` / `i_ptutility`, so they never pass through the display domain
 - token-revenue price source (`i_revenue`): normalized uncached/cached/output pricing or the selected model's live OpenRouter catalog prices
 - scale, optimal-point, label, contrast, legend, and overlay controls
 
diff --git a/packages/app/cypress/component/gpu-metrics-axis.cy.tsx b/packages/app/cypress/component/gpu-metrics-axis.cy.tsx
index 3513fa5bb..f41f8e6c6 100644
--- a/packages/app/cypress/component/gpu-metrics-axis.cy.tsx
+++ b/packages/app/cypress/component/gpu-metrics-axis.cy.tsx
@@ -4,6 +4,7 @@ import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
 import { useState } from 'react';
 
 const svg = () => cy.get('[data-testid="gpu-metrics-chart-svg"]');
+const ALL_GPUS = new Set([0, 1, 2, 3, 4, 5, 6, 7]);
 
 function samples(clock: (sample: number) => number): GpuMetricRow[] {
   return Array.from({ length: 8 }, (_chip, index) =>
@@ -20,7 +21,7 @@ function mountClock(data: GpuMetricRow[]) {
   cy.mount(
     <GpuMetricsChart
       data={data}
-      visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
+      visibleGpus={ALL_GPUS}
       metricKey="memClock"
       artifactName="gpu_metrics_b200"
       display={{ mode: 'rolling', windowS: 300, series: 'chips' }}
@@ -67,7 +68,7 @@ describe('PowerX telemetry axis', () => {
         <div style={{ width: '100%', padding: 33 }}>
           <GpuMetricsChart
             data={data}
-            visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
+            visibleGpus={ALL_GPUS}
             metricKey="power"
             artifactName="gpu_metrics_h200"
             overlay={{
@@ -112,7 +113,7 @@ describe('PowerX telemetry axis', () => {
     cy.mount(
       <GpuMetricsChart
         data={samples(() => 390)}
-        visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
+        visibleGpus={ALL_GPUS}
         metricKey="power"
         artifactName="gpu_metrics_b200"
         display={{ mode: 'points', windowS: 300, series: 'chips' }}
@@ -139,7 +140,7 @@ describe('PowerX telemetry axis', () => {
           </button>
           <GpuMetricsChart
             data={samples(() => 3996)}
-            visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
+            visibleGpus={ALL_GPUS}
             metricKey={metric}
             artifactName="gpu_metrics_b200"
             display={{ mode: 'rolling', windowS: 300, series: 'chips' }}
diff --git a/packages/app/cypress/component/power-compare.cy.tsx b/packages/app/cypress/component/power-compare.cy.tsx
index 825d6c56b..88600af81 100644
--- a/packages/app/cypress/component/power-compare.cy.tsx
+++ b/packages/app/cypress/component/power-compare.cy.tsx
@@ -132,6 +132,8 @@ function mountCompare(
   } = {},
 ) {
   const metricKey = options.metric ?? 'y_measuredAvgPower';
+  const extraRuns = options.extraRuns ?? [];
+  const overlayHwTypes = new Set(['h100', ...extraRuns.flatMap((run) => run.hwKeys)]);
   mountWithProviders(
     <PathnameContext.Provider value={options.pathname ?? '/inference'}>
       <div style={{ width: options.width ?? 1000, height: 640 }}>
@@ -168,19 +170,13 @@ function mountCompare(
       unofficial: options.overlay
         ? {
             isUnofficialRun: true,
-            activeOverlayHwTypes: new Set([
-              'h100',
-              ...(options.extraRuns ?? []).flatMap((run) => run.hwKeys),
-            ]),
-            allOverlayHwTypes: new Set([
-              'h100',
-              ...(options.extraRuns ?? []).flatMap((run) => run.hwKeys),
-            ]),
+            activeOverlayHwTypes: overlayHwTypes,
+            allOverlayHwTypes: overlayHwTypes,
             runIndexByUrl: {
               [OVERLAY_RUN_URL]: 0,
               [String(OVERLAY_RUN_ID)]: 0,
               ...Object.fromEntries(
-                (options.extraRuns ?? []).flatMap((run, index) => [
+                extraRuns.flatMap((run, index) => [
                   [run.url, index + 1],
                   [String(run.id), index + 1],
                 ]),
@@ -198,7 +194,7 @@ function mountCompare(
                 status: 'completed',
                 isNonMainBranch: true,
               },
-              ...(options.extraRuns ?? []).map((run) => ({
+              ...extraRuns.map((run) => ({
                 id: run.id,
                 name: `powerx-compare-${run.id}`,
                 branch: `powerx-compare-${run.id}`,
diff --git a/packages/app/cypress/component/power-metric-availability.cy.tsx b/packages/app/cypress/component/power-metric-availability.cy.tsx
index fa2a9f3a8..b6cc2cee2 100644
--- a/packages/app/cypress/component/power-metric-availability.cy.tsx
+++ b/packages/app/cypress/component/power-metric-availability.cy.tsx
@@ -1,5 +1,6 @@
 import { useState } from 'react';
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+import type { InferenceData } from '@/components/inference/types';
 import {
   PowerMetricAvailability,
   PowerMetricAvailabilityPanel,
@@ -79,30 +80,17 @@ const agenticDisagg = createMockInferenceData({
   modeledSystemPower: { status: 'unsupported', reason: 'workload', modelRevision: 'abc1234' },
 });
 const unregistered = createMockInferenceData({ ...base, hwKey: 'unknown_hw' });
-function BoundaryPanel({ metric: initial }: { metric: string }) {
+const coverage = [missing, invalid, measured];
+const boundaryPoints = [boundaries, outsideModel, failedValidation, agenticDisagg, unregistered];
+
+function Panel({ points, metric: initial }: { points: InferenceData[]; metric: string }) {
   const [metric, select] = useState(initial);
-  return (
-    <PowerMetricAvailabilityPanel
-      points={[boundaries, outsideModel, failedValidation, agenticDisagg, unregistered]}
-      metric={metric}
-      onSelect={select}
-    />
-  );
-}
-function Panel() {
-  const [metric, select] = useState('y_measuredAvgPower');
-  return (
-    <PowerMetricAvailabilityPanel
-      points={[missing, invalid, measured]}
-      metric={metric}
-      onSelect={select}
-    />
-  );
+  return <PowerMetricAvailabilityPanel points={points} metric={metric} onSelect={select} />;
 }
 
 describe('PowerX metric availability', () => {
   it('explains missing GB and withheld AMD data, exposes source links, and switches metrics', () => {
-    cy.mount(<Panel />);
+    cy.mount(<Panel points={coverage} metric="y_measuredAvgPower" />);
     cy.contains('1 of 3 points have this metric');
     cy.contains('Validation failed: 1');
     cy.contains('Metric not reported: 1');
@@ -117,7 +105,7 @@ describe('PowerX metric availability', () => {
   it('uses Chinese copy for the same coverage states', () => {
     cy.mount(
       <PathnameContext.Provider value="/zh/inference/qwen-3-5">
-        <Panel />
+        <Panel points={coverage} metric="y_measuredAvgPower" />
       </PathnameContext.Provider>,
     );
     cy.contains('3 个数据点中有 1 个提供此指标');
@@ -126,7 +114,7 @@ describe('PowerX metric availability', () => {
     cy.contains('缺失值不会被替换为零或 TDP 估算值');
   });
   it('explains why derived power boundaries are missing per point', () => {
-    cy.mount(<BoundaryPanel metric="y_utilityModeledWatts" />);
+    cy.mount(<Panel points={boundaryPoints} metric="y_utilityModeledWatts" />);
     // B4 follows the chassis model and the telemetry verdict.
     cy.contains('1 of 5 points have this metric');
     cy.contains('Value available: 1');
@@ -162,7 +150,7 @@ describe('PowerX metric availability', () => {
   it('uses Chinese copy for the derived boundary states', () => {
     cy.mount(
       <PathnameContext.Provider value="/zh/inference/qwen-3-5">
-        <BoundaryPanel metric="y_utilityModeledJPerOutputToken" />
+        <Panel points={boundaryPoints} metric="y_utilityModeledJPerOutputToken" />
       </PathnameContext.Provider>,
     );
     cy.contains('5 个数据点中有 1 个提供此指标');
@@ -185,7 +173,7 @@ describe('PowerX metric availability', () => {
     // Only the registered B200 and the disaggregated AgentX row carry
     // validated telemetry; the GB200 and the unregistered hardware report
     // nothing and the AMD row failed validation.
-    cy.mount(<BoundaryPanel metric="y_measuredAvgPower" />);
+    cy.mount(<Panel points={boundaryPoints} metric="y_measuredAvgPower" />);
     cy.contains('2 of 5 points have this metric');
     cy.contains('Validation failed: 1');
     cy.contains('Metric not reported: 2');
diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
index 9d631ceaa..3ca436d2e 100644
--- a/packages/app/cypress/component/power-service-comparison.cy.tsx
+++ b/packages/app/cypress/component/power-service-comparison.cy.tsx
@@ -154,13 +154,12 @@ describe('PowerServiceComparison', () => {
         'have.length',
         9,
       );
-      cy.get('[data-testid="power-service-test-service-plot"] circle.point[r="6"]')
+      cy.get<SVGCircleElement & { __data__: { x: number; y: number } }>(
+        '[data-testid="power-service-test-service-plot"] circle.point[r="6"]',
+      )
         .should('have.length', 3)
         .and(($points) => {
-          const values = Array.from(
-            $points,
-            (element) => (element as unknown as { __data__: { x: number; y: number } }).__data__,
-          );
+          const values = Array.from($points, (element) => element.__data__);
           expect(values.map((entry) => entry.x)).to.deep.equal([40, 40, 40]);
           expect(values.map((entry) => entry.y)).to.deep.equal([50, 50, -40]);
         });
@@ -217,12 +216,10 @@ describe('PowerServiceComparison', () => {
     mountComparison([...roles, { ...roles[0], id: 99, power_valid: 0 }]);
     cy.get('[data-testid="role-share-toggle"]').check();
     roleSvg()
-      .find('circle.point')
+      .find<SVGCircleElement & { __data__: { y: number } }>('circle.point')
       .should('have.length', 3)
       .then(($points) => {
-        const values = [...$points].map(
-          (element) => (element as unknown as { __data__: { y: number } }).__data__.y,
-        );
+        const values = [...$points].map((element) => element.__data__.y);
         expect(values).to.deep.equal([40, 50, 60]);
         const center = Number($points[1].getAttribute('cy'));
         roleSvg()
diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index e152b1285..e23349b77 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -101,9 +101,11 @@ function disaggPoint(
   });
 }
 
-/** 61 one-second buckets: idle 200 W, ramps to `peak` inside the window. */
+/** One-second buckets for a 60 s job. */
+const t = Array.from({ length: 61 }, (_, i) => i);
+
+/** Idle 200 W, ramps to `peak` inside the window. */
 function series(hwKey: string, conc: number, peak: number, gpus = [0, 1]): GpuPowerSeries {
-  const t = Array.from({ length: 61 }, (_, i) => i);
   return {
     artifact: `gpu_metrics_${resultName(hwKey.split('_')[0], conc)}`,
     startMs: START_MS,
@@ -120,7 +122,6 @@ function series(hwKey: string, conc: number, peak: number, gpus = [0, 1]): GpuPo
  * the window are 3606 W and 2822 W.
  */
 function poolSeries(conc: number, prefillCount = 4): GpuPowerSeries {
-  const t = Array.from({ length: 61 }, (_, i) => i);
   const devices: GpuPowerDevice[] = Array.from({ length: 8 }, (_, i) => ({
     id: `${HOST}/GPU-${String(i).padStart(8, '0')}-d62f-0ff2-b4e5-e36f6fac8f1b`,
     role: i < prefillCount ? 'prefill' : 'decode',
@@ -162,6 +163,52 @@ const poolResponse: GpuPowerSeriesResponse = {
   series: [series('b200', 16, 700), poolSeries(8)],
 };
 
+/** Traces of the same shape two days apart, so wall-clock ticks must carry dates. */
+const multiDayResponse: GpuPowerSeriesResponse = {
+  ...response,
+  series: response.series.map((trace, index) => ({
+    ...trace,
+    startMs: trace.startMs + index * 2 * 24 * 60 * 60_000,
+  })),
+};
+
+const overlayResponse = (traces: GpuPowerSeries[]): GpuPowerSeriesResponse => ({
+  runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
+  series: traces,
+});
+
+const overlayData = (data: InferenceData[], label = 'powerx-timeline') => ({
+  data,
+  hardwareConfig: hwConfig,
+  label,
+  runUrl: OVERLAY_RUN_URL,
+});
+
+/** Context overrides for one loaded `?unofficialrun=` whose overlay legend shows `hw`. */
+function overlayRun(
+  hw: string,
+  name = 'powerx-timeline',
+): Parameters<typeof createMockUnofficialRunContext>[0] {
+  return {
+    isUnofficialRun: true,
+    unofficialRunInfos: [
+      {
+        id: Number(OVERLAY_RUN_ID),
+        name,
+        branch: name,
+        sha: 'abc000',
+        createdAt: '2026-09-12T00:00:00Z',
+        url: OVERLAY_RUN_URL,
+        conclusion: 'success',
+        status: 'completed',
+        isNonMainBranch: true,
+      },
+    ],
+    runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
+    activeOverlayHwTypes: new Set([hw]),
+  };
+}
+
 const GB200_TDP = HW_REGISTRY.gb200?.tdp || HW_REGISTRY.b200.tdp;
 
 function mountTimeline(
@@ -281,15 +328,7 @@ describe('PowerTimeline', () => {
   });
 
   it('distinguishes dates when wall-clock traces span multiple days', () => {
-    cy.intercept('POST', '/api/gpu-metrics*', {
-      body: {
-        ...response,
-        series: response.series.map((trace, index) => ({
-          ...trace,
-          startMs: trace.startMs + index * 2 * 24 * 60 * 60_000,
-        })),
-      },
-    }).as('series');
+    cy.intercept('POST', '/api/gpu-metrics*', { body: multiDayResponse }).as('series');
     mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('b200', 64, 900)]);
     cy.wait('@series');
     cy.get('[data-testid="power-timeline-axis-wall"]').click();
@@ -306,15 +345,7 @@ describe('PowerTimeline', () => {
 
   it('keeps mobile wall-clock dates separated', () => {
     cy.viewport(390, 844);
-    cy.intercept('POST', '/api/gpu-metrics*', {
-      body: {
-        ...response,
-        series: response.series.map((trace, index) => ({
-          ...trace,
-          startMs: trace.startMs + index * 2 * 24 * 60 * 60_000,
-        })),
-      },
-    }).as('series');
+    cy.intercept('POST', '/api/gpu-metrics*', { body: multiDayResponse }).as('series');
     mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('b200', 64, 900)], {
       width: 324,
     });
@@ -498,46 +529,14 @@ describe('PowerTimeline', () => {
   }
 
   it('colours overlay-run traces by run and honours the overlay hardware filter', () => {
-    const overlayPoint = measuredPoint('h200', 16, 500, {
-      run_url: OVERLAY_RUN_URL,
-      power_audit: {
-        source: `power_validation_${resultName('h200', 16)}.json`,
-        ...WINDOW,
-      },
-    });
-    const overlayResponse: GpuPowerSeriesResponse = {
-      runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
-      series: [series('h200', 16, 500)],
-    };
+    const overlayPoint = measuredPoint('h200', 16, 500, { run_url: OVERLAY_RUN_URL });
     cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
     cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
-      body: overlayResponse,
+      body: overlayResponse([series('h200', 16, 500)]),
     }).as('overlay');
     mountTimeline([measuredPoint('b200', 16, 700)], {
-      overlay: {
-        data: [overlayPoint],
-        hardwareConfig: hwConfig,
-        label: 'powerx-timeline',
-        runUrl: OVERLAY_RUN_URL,
-      },
-      unofficial: createMockUnofficialRunContext({
-        isUnofficialRun: true,
-        unofficialRunInfos: [
-          {
-            id: Number(OVERLAY_RUN_ID),
-            name: 'powerx-timeline',
-            branch: 'powerx-timeline',
-            sha: 'abc000',
-            createdAt: '2026-09-12T00:00:00Z',
-            url: OVERLAY_RUN_URL,
-            conclusion: 'success',
-            status: 'completed',
-            isNonMainBranch: true,
-          },
-        ],
-        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
-        activeOverlayHwTypes: new Set(['h200']),
-      }),
+      overlay: overlayData([overlayPoint]),
+      unofficial: createMockUnofficialRunContext(overlayRun('h200')),
     });
     cy.wait(['@official', '@overlay']);
 
@@ -557,41 +556,13 @@ describe('PowerTimeline', () => {
   it('solos an official row through the unified overlay selection while an overlay is loaded', () => {
     // localOfficialOverride shadows activeHwTypes once an overlay is in, so the
     // context toggle would be invisible: the legend must write both selections.
-    const overlayPoint = measuredPoint('h200', 16, 500, {
-      run_url: OVERLAY_RUN_URL,
-      power_audit: {
-        source: `power_validation_${resultName('h200', 16)}.json`,
-        ...WINDOW,
-      },
-    });
+    const overlayPoint = measuredPoint('h200', 16, 500, { run_url: OVERLAY_RUN_URL });
     cy.intercept('POST', '/api/gpu-metrics*', { body: response }).as('series');
     mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('h100', 16, 600)], {
-      overlay: {
-        data: [overlayPoint],
-        hardwareConfig: hwConfig,
-        label: 'powerx-timeline',
-        runUrl: OVERLAY_RUN_URL,
-      },
+      overlay: overlayData([overlayPoint]),
       // Plain overrides: mountWithProviders builds the context itself, so the
       // aliased stubs below are the ones the component receives.
-      unofficial: {
-        isUnofficialRun: true,
-        unofficialRunInfos: [
-          {
-            id: Number(OVERLAY_RUN_ID),
-            name: 'powerx-timeline',
-            branch: 'powerx-timeline',
-            sha: 'abc000',
-            createdAt: '2026-09-12T00:00:00Z',
-            url: OVERLAY_RUN_URL,
-            conclusion: 'success',
-            status: 'completed',
-            isNonMainBranch: true,
-          },
-        ],
-        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
-        activeOverlayHwTypes: new Set(['h200']),
-      },
+      unofficial: overlayRun('h200'),
     });
     cy.wait('@series');
 
@@ -624,44 +595,13 @@ describe('PowerTimeline', () => {
         } satisfies GpuPowerSeriesResponse,
       }).as(`official${index}`);
     });
-    const overlayPoint = measuredPoint('h200', 16, 500, {
-      run_url: OVERLAY_RUN_URL,
-      power_audit: {
-        source: `power_validation_${resultName('h200', 16)}.json`,
-        ...WINDOW,
-      },
-    });
+    const overlayPoint = measuredPoint('h200', 16, 500, { run_url: OVERLAY_RUN_URL });
     cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
-      body: {
-        runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
-        series: [series('h200', 16, 500)],
-      } satisfies GpuPowerSeriesResponse,
+      body: overlayResponse([series('h200', 16, 500)]),
     }).as('overlay');
     mountTimeline(officialPoints, {
-      overlay: {
-        data: [overlayPoint],
-        hardwareConfig: hwConfig,
-        label: 'powerx-timeline',
-        runUrl: OVERLAY_RUN_URL,
-      },
-      unofficial: createMockUnofficialRunContext({
-        isUnofficialRun: true,
-        unofficialRunInfos: [
-          {
-            id: Number(OVERLAY_RUN_ID),
-            name: 'powerx-timeline',
-            branch: 'powerx-timeline',
-            sha: 'abc000',
-            createdAt: '2026-09-12T00:00:00Z',
-            url: OVERLAY_RUN_URL,
-            conclusion: 'success',
-            status: 'completed',
-            isNonMainBranch: true,
-          },
-        ],
-        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
-        activeOverlayHwTypes: new Set(['h200']),
-      }),
+      overlay: overlayData([overlayPoint]),
+      unofficial: createMockUnofficialRunContext(overlayRun('h200')),
     });
     cy.wait(['@overlay', '@official0', '@official1', '@official2']);
 
@@ -809,39 +749,13 @@ describe('PowerTimeline', () => {
 
   it('draws an overlay-run pool trace in the run colour', () => {
     const overlayPoint = disaggPoint(8, 800, { run_url: OVERLAY_RUN_URL });
-    const overlayResponse: GpuPowerSeriesResponse = {
-      runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
-      series: [poolSeries(8)],
-    };
     cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
     cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
-      body: overlayResponse,
+      body: overlayResponse([poolSeries(8)]),
     }).as('overlay');
     mountTimeline([measuredPoint('b200', 16, 700)], {
-      overlay: {
-        data: [overlayPoint],
-        hardwareConfig: hwConfig,
-        label: 'powerx-pools',
-        runUrl: OVERLAY_RUN_URL,
-      },
-      unofficial: createMockUnofficialRunContext({
-        isUnofficialRun: true,
-        unofficialRunInfos: [
-          {
-            id: Number(OVERLAY_RUN_ID),
-            name: 'powerx-pools',
-            branch: 'powerx-pools',
-            sha: 'abc000',
-            createdAt: '2026-09-12T00:00:00Z',
-            url: OVERLAY_RUN_URL,
-            conclusion: 'success',
-            status: 'completed',
-            isNonMainBranch: true,
-          },
-        ],
-        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
-        activeOverlayHwTypes: new Set(['gb200']),
-      }),
+      overlay: overlayData([overlayPoint], 'powerx-pools'),
+      unofficial: createMockUnofficialRunContext(overlayRun('gb200', 'powerx-pools')),
     });
     cy.wait(['@official', '@overlay']);
 
diff --git a/packages/app/cypress/e2e/powerx-basis.cy.ts b/packages/app/cypress/e2e/powerx-basis.cy.ts
index 41fc06b9e..e72d0c373 100644
--- a/packages/app/cypress/e2e/powerx-basis.cy.ts
+++ b/packages/app/cypress/e2e/powerx-basis.cy.ts
@@ -139,12 +139,14 @@ function visitBasisChart({
   cy.get('[data-testid="chart-figure"]').should('have.length.at.least', 1);
 }
 
+const sortedAsc = (values: number[]) => [...values].sort((a, b) => a - b);
+
 /** Plotted y values (sorted) of every point matching `selector`, visible or not. */
 function assertPlottedValues(selector: string, expected: number[]) {
   cy.get<SVGElement & { __data__: { y: number } }>(
     `[data-testid="inference-chart-display"] svg ${selector}`,
   ).should(($points) => {
-    const values = Array.from($points, (point) => point.__data__.y).sort((a, b) => a - b);
+    const values = sortedAsc(Array.from($points, (point) => point.__data__.y));
     expect(values).to.have.length(expected.length);
     for (const [index, value] of values.entries()) {
       expect(value).to.be.closeTo(expected[index], 1e-6);
@@ -152,8 +154,6 @@ function assertPlottedValues(selector: string, expected: number[]) {
   });
 }
 
-const sortedAsc = (values: number[]) => [...values].sort((a, b) => a - b);
-
 describe('PowerX power boundaries in the Measured Energy group', () => {
   beforeEach(() => {
     cy.on('uncaught:exception', (error) => {
diff --git a/packages/app/scripts/powerx-db-acceptance.ts b/packages/app/scripts/powerx-db-acceptance.ts
index 6566c1eef..ecc74ba25 100644
--- a/packages/app/scripts/powerx-db-acceptance.ts
+++ b/packages/app/scripts/powerx-db-acceptance.ts
@@ -136,14 +136,13 @@ try {
   receipt.exitCode = await new Promise<number>((resolve) => {
     browser.on('exit', (code) => resolve(code ?? 1));
   });
-  const revisions = [...blob.objects.values()]
-    .map((value) => JSON.parse(value))
-    .filter((payload) => payload?.benchmarkResultId === 206885);
-  const producers = revisions.map((payload) => payload.series[0].sidecars.context.producer);
-  const retainedProducers = [...blob.objects.values()]
-    .map((value) => JSON.parse(value))
-    .filter((payload) => [206888, 206889].includes(payload?.benchmarkResultId))
-    .map((payload) => payload.series[0].sidecars.context.producer);
+  const payloads = [...blob.objects.values()].map((value) => JSON.parse(value));
+  const producersOf = (ids: number[]) =>
+    payloads
+      .filter((payload) => ids.includes(payload?.benchmarkResultId))
+      .map((payload) => payload.series[0].sidecars.context.producer);
+  const producers = producersOf([206885]);
+  const retainedProducers = producersOf([206888, 206889]);
   const cacheVerified =
     blob.counts.reads > 0 &&
     producers.includes('collector-before-repair') &&
diff --git a/packages/app/scripts/powerx-db-fixture.ts b/packages/app/scripts/powerx-db-fixture.ts
index 5ce4d65b1..dc4c4f1e5 100644
--- a/packages/app/scripts/powerx-db-fixture.ts
+++ b/packages/app/scripts/powerx-db-fixture.ts
@@ -38,7 +38,7 @@ function ingest(index: number) {
   });
 }
 
-async function ingestRetained(repaired: boolean) {
+function ingestRetained(repaired: boolean) {
   // CSV bytes are retained; sidecars deliberately inject a repair scenario.
   write(
     retainedName,
@@ -59,12 +59,11 @@ async function ingestRetained(repaired: boolean) {
       ),
     ].join('\n'),
   );
-  const result = await ingestGpuMetricsArtifact(sql, {
+  return ingestGpuMetricsArtifact(sql, {
     workflowRunId: 2,
     artifact: { artifactName: retainedName, artifactDir: path.join(artifactsDir, retainedName) },
     benchmarkResultIds: [206888, 206889],
   });
-  return result;
 }
 
 async function seed() {
diff --git a/packages/app/src/app/api/gpu-metrics/route.test.ts b/packages/app/src/app/api/gpu-metrics/route.test.ts
index 89aa6d990..cae3f22bd 100644
--- a/packages/app/src/app/api/gpu-metrics/route.test.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.test.ts
@@ -87,6 +87,9 @@ function req(url: string): NextRequest {
   return new NextRequest(new URL(url, 'http://localhost'));
 }
 
+const NVIDIA_HEADER =
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
+
 function nvidiaRow(second: number, power: number): string {
   return `2026/03/01 00:00:0${second}.000, 0, ${power} W, 65, 1500 MHz, 2000 MHz, 95 %, 80 %`;
 }
@@ -421,14 +424,14 @@ describe('GET /api/gpu-metrics — database first', () => {
     const { parseCsvData } = await vi.importActual<typeof GpuPowerTypes>(
       '@/components/gpu-power/types',
     );
-    const header =
-      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
-    const hostA = [header, nvidiaRow(0, 300), nvidiaRow(0, 999), nvidiaRow(1, 310)].join('\n');
+    const hostA = [NVIDIA_HEADER, nvidiaRow(0, 300), nvidiaRow(0, 999), nvidiaRow(1, 310)].join(
+      '\n',
+    );
     const hostB =
       coverage === 'empty host'
-        ? header
+        ? NVIDIA_HEADER
         : [
-            header,
+            NVIDIA_HEADER,
             nvidiaRow(0, 500),
             ...(coverage === 'truncated host' ? [] : [nvidiaRow(1, 510)]),
           ].join('\n');
@@ -577,11 +580,9 @@ describe('GET /api/gpu-metrics', () => {
     const { parseCsvData } = await vi.importActual<typeof GpuPowerTypes>(
       '@/components/gpu-power/types',
     );
-    const header =
-      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
     zipArchives.byKey.set('multinode-csv', [
-      { entryName: 'host-a/gpu_metrics.csv', data: [header, nvidiaRow(0, 300)].join('\n') },
-      { entryName: 'host-b/gpu_metrics.csv', data: [header, nvidiaRow(0, 500)].join('\n') },
+      { entryName: 'host-a/gpu_metrics.csv', data: [NVIDIA_HEADER, nvidiaRow(0, 300)].join('\n') },
+      { entryName: 'host-b/gpu_metrics.csv', data: [NVIDIA_HEADER, nvidiaRow(0, 500)].join('\n') },
     ]);
     mockParseCsvData.mockImplementationOnce(parseCsvData).mockImplementationOnce(parseCsvData);
     mockGithub([{ name: 'gpu_metrics_live', url: 'https://example.test/dl/multinode' }], {
diff --git a/packages/app/src/app/api/gpu-metrics/route.ts b/packages/app/src/app/api/gpu-metrics/route.ts
index 49f7e510c..142bc21a4 100644
--- a/packages/app/src/app/api/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.ts
@@ -92,8 +92,6 @@ const MAX_REQUEST_BYTES = 256 * 1024;
 
 export type GpuMetricsSource = 'database' | 'github';
 
-export type GpuMetricsArtifactPayload = GpuMetricsArtifact;
-
 export interface GpuMetricsRouteResponse extends GpuPowerApiResponse {
   source: GpuMetricsSource;
 }
@@ -143,9 +141,10 @@ interface GithubGpuMetricsResponse extends Omit<GpuMetricsRouteResponse, 'artifa
   bundleSeries: GpuPowerSeries[];
 }
 
-type TelemetryJob =
-  | { kind: 'csv'; artifact: GithubArtifact }
-  | { kind: 'bundle'; artifact: GithubArtifact };
+interface TelemetryJob {
+  kind: 'csv' | 'bundle';
+  artifact: GithubArtifact;
+}
 
 type TelemetryResult =
   | { kind: 'csv'; parsed: GithubArtifactPayload }
@@ -315,9 +314,9 @@ function powerSeriesResponse(
  * listing filter so both sources answer the same request the same way.
  */
 function filterArtifactsByPrefix(
-  artifacts: GpuMetricsArtifactPayload[],
+  artifacts: GpuMetricsArtifact[],
   prefix: string | null,
-): GpuMetricsArtifactPayload[] {
+): GpuMetricsArtifact[] {
   if (prefix === null) return artifacts;
   const wanted = `${ARTIFACT_PREFIX}${prefix}`;
   return artifacts.filter((artifact) => {
@@ -545,10 +544,9 @@ async function readGpuMetrics(request: NextRequest, sources: string[] | null) {
         ),
       ];
       for (const missing of incomplete) {
-        const incompleteArtifact = missing.artifact;
-        const live = artifacts.find((artifact) => artifact.name === incompleteArtifact);
+        const live = artifacts.find((artifact) => artifact.name === missing.artifact);
         const inventory = stored?.artifacts.find(
-          (artifact) => artifact.series?.artifactName === incompleteArtifact,
+          (artifact) => artifact.series?.artifactName === missing.artifact,
         )?.series?.sidecars.seriesInventory;
         // A matching name alone cannot prove that missing hosts/samples recovered.
         // Bundle cuts do not retain the raw inventory, so known-incomplete bundles
diff --git a/packages/app/src/app/api/v1/views/inference/route.ts b/packages/app/src/app/api/v1/views/inference/route.ts
index a8a54f817..7398a4f5d 100644
--- a/packages/app/src/app/api/v1/views/inference/route.ts
+++ b/packages/app/src/app/api/v1/views/inference/route.ts
@@ -299,8 +299,8 @@ export function GET(request: NextRequest) {
     const format = parseFormatParam(search.get('format'));
     const serviceCompare = parseBoolParam(search.get('serviceCompare'), 'serviceCompare', false);
     const roleShare = parseBoolParam(search.get('roleShare'), 'roleShare', false);
-    const requestedServiceBaseline = search.get('serviceBaseline') ?? null;
-    const requestedServiceComparator = search.get('serviceComparator') ?? null;
+    const requestedServiceBaseline = search.get('serviceBaseline');
+    const requestedServiceComparator = search.get('serviceComparator');
     const serviceTarget = search.has('serviceTarget')
       ? parseNumberParam(search.get('serviceTarget'), 'serviceTarget', 0, { min: Number.MIN_VALUE })
       : null;
@@ -413,12 +413,15 @@ export function GET(request: NextRequest) {
       );
     const data = await project(rows, params);
     const observedPoints = [...data.result.observedPoints];
+    // Service/role panels pool every scope's observed points; the payload omits them.
+    const collectObserved = ({ observedPoints: points, ...result }: InferenceSeriesResult) => {
+      observedPoints.push(...points);
+      return result;
+    };
     const comparisons = await Promise.all(
       scopes.map(async (scope) => {
         const comparison = await project(await fetchRows(scope.params), scope.params);
-        observedPoints.push(...comparison.result.observedPoints);
-        const { observedPoints: _observedPoints, ...result } = comparison.result;
-        return { entry: scope.entry, ...result };
+        return { entry: scope.entry, ...collectObserved(comparison.result) };
       }),
     );
     const overlayRows = await unofficialRows(request);
@@ -428,9 +431,7 @@ export function GET(request: NextRequest) {
           overlayRows.filter((row) => row.run_url === url),
           params,
         );
-        observedPoints.push(...overlay.result.observedPoints);
-        const { observedPoints: _observedPoints, ...result } = overlay.result;
-        return { runUrl: url, ...result };
+        return { runUrl: url, ...collectObserved(overlay.result) };
       }),
     );
 
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.ts b/packages/app/src/components/gpu-power/power-audit-bundle.ts
index f1530a7e8..ca977fb76 100644
--- a/packages/app/src/components/gpu-power/power-audit-bundle.ts
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.ts
@@ -130,22 +130,20 @@ function asRole(value: unknown): GpuPowerRole | undefined {
   return value === 'prefill' || value === 'decode' ? value : undefined;
 }
 
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
 function parseJsonObject(text: string | undefined): Record<string, unknown> | null {
   if (text === undefined) return null;
   try {
     const parsed: unknown = JSON.parse(text);
-    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
-      ? (parsed as Record<string, unknown>)
-      : null;
+    return isRecord(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
 function manifestSlot(hostname: string, gpuIndex: number): string {
   return `${hostname}#${gpuIndex}`;
 }
@@ -262,7 +260,7 @@ export function cutPowerAuditBundle(
   const manifest = parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY));
   const contextFiles = [...files]
     .filter(([name]) => isContextEntry(name))
-    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    .sort(([a], [b]) => compareText(a, b));
   const smiFiles = [...files]
     .filter(([name]) => isSmiCsv(name))
     .map(([name, text]) => {
@@ -283,13 +281,7 @@ export function cutPowerAuditBundle(
   if (samplesText === undefined) return [];
   const { samples, devices } = parseSamples(samplesText);
   if (samples.length === 0) return [];
-  return cutPowerAuditSamples(
-    artifact,
-    samples,
-    devices,
-    validations,
-    parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY)),
-  );
+  return cutPowerAuditSamples(artifact, samples, devices, validations, manifest);
 }
 
 /** Apply bundle window cuts to the richer SMI CSVs without requiring DCGM UUID sidecars. */
diff --git a/packages/app/src/components/gpu-power/stored-power-series.ts b/packages/app/src/components/gpu-power/stored-power-series.ts
index 964d44812..80dfb6b96 100644
--- a/packages/app/src/components/gpu-power/stored-power-series.ts
+++ b/packages/app/src/components/gpu-power/stored-power-series.ts
@@ -3,15 +3,12 @@ import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-
 import {
   cutPowerAuditSamples,
   cutPowerAuditCsvs,
+  isRecord,
   type PowerAuditDevice,
   type PowerAuditSample,
 } from './power-audit-bundle';
 import { bucketPowerFiles, type GpuPowerSeries } from './power-series';
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
 export class StoredTelemetryIncompleteError extends Error {
   readonly artifact: string;
 
diff --git a/packages/app/src/components/gpu-power/types.ts b/packages/app/src/components/gpu-power/types.ts
index 6c82d5616..90ebeb75b 100644
--- a/packages/app/src/components/gpu-power/types.ts
+++ b/packages/app/src/components/gpu-power/types.ts
@@ -200,17 +200,18 @@ export function getAvailableMetrics(data: GpuMetricRow[]): GpuMetricConfig[] {
   return ALL_METRIC_OPTIONS.filter((m) => data.some((row) => Number.isFinite(row[m.key])));
 }
 
-/**
- * Detect GPU SKU from an artifact name and return its TDP in watts.
- * Artifact names look like: gpu_metrics_dsr1_1k8k_fp8_sglang_tp8_..._h200-nb_0
- */
 /** TDP for a known hardware key, e.g. the benchmark point's own `hardware`. */
 export function tdpForHardware(hardware: string | undefined): { sku: string; tdp: number } | null {
   const key = hardware?.toLowerCase();
-  const entry = key ? HW_REGISTRY[key] : undefined;
-  return entry ? { sku: key!.toUpperCase(), tdp: entry.tdp } : null;
+  if (!key) return null;
+  const entry = HW_REGISTRY[key];
+  return entry ? { sku: key.toUpperCase(), tdp: entry.tdp } : null;
 }
 
+/**
+ * Detect GPU SKU from an artifact name and return its TDP in watts.
+ * Artifact names look like: gpu_metrics_dsr1_1k8k_fp8_sglang_tp8_..._h200-nb_0
+ */
 export function detectTdpFromArtifactName(
   artifactName: string,
 ): { sku: string; tdp: number } | null {
diff --git a/packages/app/src/components/inference/agentic-point/overlay-sources.ts b/packages/app/src/components/inference/agentic-point/overlay-sources.ts
index 029274f25..377df2e76 100644
--- a/packages/app/src/components/inference/agentic-point/overlay-sources.ts
+++ b/packages/app/src/components/inference/agentic-point/overlay-sources.ts
@@ -1,5 +1,4 @@
 import type { TraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
-import type { Locale } from '@/lib/i18n';
 
 /** One server-metric series that can be drawn over the chip telemetry chart. */
 export interface OverlaySource {
@@ -77,7 +76,3 @@ export function availableOverlaySources(
   if (!metrics) return [];
   return OVERLAY_SOURCES.filter((source) => source.points(metrics).length > 0);
 }
-
-export function overlaySourceLabel(source: OverlaySource, locale: Locale): string {
-  return source.label[locale];
-}
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
index 75901d338..9d68f8dd1 100644
--- a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -34,7 +34,7 @@ import {
 import { useGpuMetricsPoint, type GpuMetricSeries } from '@/hooks/api/use-gpu-metrics-point';
 import { useTraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
 
-import { availableOverlaySources, overlaySourceLabel } from './overlay-sources';
+import { availableOverlaySources } from './overlay-sources';
 import { track } from '@/lib/analytics';
 import { useLocale } from '@/lib/use-locale';
 
@@ -199,7 +199,7 @@ export function PowerTelemetryView({ id, enabled, hardware, serverMetricsEnabled
       ? serverMetrics.startNs / 1e6
       : new Date(selectedSeries.startedAt).getTime();
     return {
-      label: overlaySourceLabel(overlaySource, locale),
+      label: overlaySource.label[locale],
       unit: overlaySource.unit,
       color: overlaySource.color,
       points: toAbsoluteMs(overlaySource.points(serverMetrics), originMs),
@@ -367,7 +367,7 @@ export function PowerTelemetryView({ id, enabled, hardware, serverMetricsEnabled
                   <SelectItem value="none">{t.overlayNone}</SelectItem>
                   {overlaySources.map((source) => (
                     <SelectItem key={source.key} value={source.key}>
-                      {overlaySourceLabel(source, locale)} ({source.unit})
+                      {source.label[locale]} ({source.unit})
                     </SelectItem>
                   ))}
                 </SelectContent>
diff --git a/packages/app/src/components/inference/agentic-point/use-detail-view.ts b/packages/app/src/components/inference/agentic-point/use-detail-view.ts
index b08b3a868..cbdd7a43d 100644
--- a/packages/app/src/components/inference/agentic-point/use-detail-view.ts
+++ b/packages/app/src/components/inference/agentic-point/use-detail-view.ts
@@ -6,14 +6,11 @@ import { useClientSearchParams } from '@/hooks/useClientSearch';
 import { track } from '@/lib/analytics';
 import { replaceClientSearch } from '@/lib/client-navigation';
 
-export type DetailView = 'point' | 'timeline' | 'power' | 'aggregates' | 'logs';
+const DETAIL_VIEWS = ['point', 'timeline', 'power', 'aggregates', 'logs'] as const;
+export type DetailView = (typeof DETAIL_VIEWS)[number];
 
 const isDetailView = (value: string | null): value is DetailView =>
-  value === 'point' ||
-  value === 'timeline' ||
-  value === 'power' ||
-  value === 'aggregates' ||
-  value === 'logs';
+  (DETAIL_VIEWS as readonly string[]).includes(value ?? '');
 
 /** URL-persisted detail view (`?view=`; per-point is the unadorned default). */
 export function useDetailView(): [DetailView, (nextView: DetailView) => void] {
diff --git a/packages/app/src/components/inference/hooks/useChartData.ts b/packages/app/src/components/inference/hooks/useChartData.ts
index bb4b97503..3401a6002 100644
--- a/packages/app/src/components/inference/hooks/useChartData.ts
+++ b/packages/app/src/components/inference/hooks/useChartData.ts
@@ -411,8 +411,9 @@ export function useChartData(
           : selectedXAxisMode === undefined
             ? (chartDef[headingKey] as string) || chartDef.heading
             : chartDef.heading;
-        if (resolved.branch === 'concurrency') chartHeading = 'vs. Concurrency';
-        if (isAgentic && resolved.branch !== 'concurrency') {
+        if (resolved.branch === 'concurrency') {
+          chartHeading = 'vs. Concurrency';
+        } else if (isAgentic) {
           const pctlWord = selectedPercentile.toUpperCase();
           xAxisLabel = applyAgenticPercentileToXLabel(xAxisLabel, pctlWord);
           xAxisLabelZh = applyAgenticPercentileToXLabel(xAxisLabelZh, pctlWord);
@@ -420,9 +421,7 @@ export function useChartData(
             /^(?<vsPrefix>vs\.\s+)(?:(?:Median|Mean|P75|P90|P95|P99(?:\.9)?)\s+)?/iu,
             `$1${pctlWord} `,
           );
-        }
-
-        if (!isAgentic && resolved.branch !== 'concurrency') {
+        } else {
           const word = xAxisField.startsWith('mean_')
             ? 'Mean'
             : xAxisField.startsWith('median_')
diff --git a/packages/app/src/components/inference/types.ts b/packages/app/src/components/inference/types.ts
index 6febc4514..0062297c3 100644
--- a/packages/app/src/components/inference/types.ts
+++ b/packages/app/src/components/inference/types.ts
@@ -7,6 +7,7 @@ import type { PowerTier } from '@/lib/power-tier';
 import type { SystemPowerEstimate } from '@/lib/modeled-system-power';
 import type { MetricKey } from './metric-registry';
 import type { FixedSequenceStatistic } from './utils/resolveXAxisField';
+import type { XAxisMode } from './hooks/chart-data-core';
 import type { PowerBasis } from '@/lib/power-basis';
 
 export type { WorkerPower };
@@ -718,12 +719,7 @@ export interface InferenceDisplayContextType {
   fixedSequenceStatistic: FixedSequenceStatistic;
   selectedXAxisMetric: string | null;
   selectedE2eXAxisMetric: string | null;
-  selectedXAxisMode:
-    | 'ttft'
-    | 'e2e'
-    | 'interactivity'
-    | 'e2e-normalized-interactivity'
-    | 'concurrency';
+  selectedXAxisMode: XAxisMode;
   scaleType: 'auto' | 'linear' | 'log';
   /** Comparison series overlaid on a gated power metric (`i_pcompare`). */
   powerCompare: PowerCompare;
@@ -767,9 +763,7 @@ export interface InferenceActionsContextType {
   setSelectedPercentile: (percentile: string) => void;
   setFixedSequenceStatistic: (statistic: FixedSequenceStatistic) => void;
   setSelectedXAxisMetric: (metric: string | null) => void;
-  setSelectedXAxisMode: (
-    mode: 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity' | 'concurrency',
-  ) => void;
+  setSelectedXAxisMode: (mode: XAxisMode) => void;
   setScaleType: (type: 'auto' | 'linear' | 'log') => void;
   setPowerCompare: (mode: PowerCompare) => void;
   setQuickFilterVendors: (vendors: string[]) => void;
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index 9fdabc10c..eb1575b82 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -324,13 +324,13 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
   } = useInferenceDisplay();
   const { setSelectedDates, setSelectedDatesFromRunExpansion, setIsLegendExpanded } =
     useInferenceActions();
+  const selectedMeasuredConfig = getMeasuredMetricConfig(selectedYAxisMetric);
   // The metric key carries the power boundary; the caption discloses it for
   // the derived boundaries (there is no separate URL param).
-  const selectedPowerBasis = getMeasuredMetricConfig(selectedYAxisMetric)?.basis;
+  const selectedPowerBasis = selectedMeasuredConfig?.basis;
   // The Measured Power "Timeline" display swaps the scatter body for the
   // per-second telemetry traces (PowerTimeline); table view and captions are
   // unchanged because the metric key aliases the measured average.
-  const selectedMeasuredConfig = getMeasuredMetricConfig(selectedYAxisMetric);
   const isPowerTimeline =
     selectedMeasuredConfig?.family === 'power' && selectedMeasuredConfig.display === 'timeline';
   const selectedBenchmarkType: 'single_turn' | 'agentic_traces' =
diff --git a/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx b/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
index cad29732b..f08575523 100644
--- a/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
+++ b/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
@@ -101,18 +101,7 @@ const STRINGS = {
  * through the chassis model, so it inherits the telemetry verdict and the
  * model's own unsupported reasons.
  */
-export type PowerBasisAvailabilityState =
-  | 'available'
-  | 'noSpec'
-  | 'noThroughput'
-  | 'noNormalization'
-  | 'noTelemetry'
-  | 'invalid'
-  | 'modelWorkload'
-  | 'modelHardware'
-  | 'modelUnsupported';
-
-const POWER_BASIS_AVAILABILITY_STATES: readonly PowerBasisAvailabilityState[] = [
+const POWER_BASIS_AVAILABILITY_STATES = [
   'available',
   'noSpec',
   'noThroughput',
@@ -122,7 +111,8 @@ const POWER_BASIS_AVAILABILITY_STATES: readonly PowerBasisAvailabilityState[] =
   'modelWorkload',
   'modelHardware',
   'modelUnsupported',
-];
+] as const;
+export type PowerBasisAvailabilityState = (typeof POWER_BASIS_AVAILABILITY_STATES)[number];
 
 const hasFiniteValue = (point: InferenceData, key: MetricKey): boolean => {
   const value = point[key];
diff --git a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
index 869f60ec1..53b4c7277 100644
--- a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
+++ b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
@@ -134,6 +134,7 @@ function ComparisonPlot({
   const yMin = Math.min(0, ...ys),
     yMax = Math.max(reference, ...ys);
   const grouped = Object.fromEntries(d3.groups(points, (p) => p.key));
+  const finitePoints = points.filter((p) => Number.isFinite(p.y));
   const drawReference: NonNullable<CustomLayerConfig['render']> = (group, ctx) => {
     const scale = (ctx.renderedYScale ?? ctx.yScale) as ContinuousScale;
     group
@@ -151,7 +152,7 @@ function ComparisonPlot({
   return (
     <D3Chart<PlotPoint>
       chartId={`${chartId}-plot`}
-      data={points.filter((p) => Number.isFinite(p.y))}
+      data={finitePoints}
       height={360}
       testId={`${chartId}-plot`}
       watermark="logo"
@@ -192,7 +193,7 @@ function ComparisonPlot({
           : []),
         {
           type: 'point',
-          data: points.filter((p) => Number.isFinite(p.y)),
+          data: finitePoints,
           config: {
             getCx: () => 0,
             getCy: () => 0,
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index 40f075e4e..51d8f7102 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -575,7 +575,7 @@ function drawTraces(
     .attr('data-trace-key', (path) => path.traceKey)
     .attr('data-hw', (path) => path.hwKey)
     .attr('data-segment', (path) => path.segment)
-    .attr('data-run-index', (path) => (path.overlayIndex === null ? null : path.overlayIndex))
+    .attr('data-run-index', (path) => path.overlayIndex)
     .attr('data-pool', (path) => path.pool ?? null)
     .attr('stroke-dasharray', (path) => (path.pool ? poolDash(path.pool) : null))
     .attr('stroke', (path) => path.color)
@@ -591,6 +591,10 @@ function traceOpacity(path: TracePath, highlight: string | null): number {
     : path.opacity * 0.15;
 }
 
+function labelOpacity(label: TraceLabel, highlight: string | null): number {
+  return highlight === null || highlight === label.hwKey || highlight === label.traceKey ? 1 : 0.2;
+}
+
 function drawLabels(
   group: d3.Selection<SVGGElement, unknown, null, undefined>,
   xScale: AnyContinuousScale,
@@ -616,9 +620,7 @@ function drawLabels(
     .attr('data-hw', (label) => label.hwKey)
     .attr('data-pool', (label) => label.pool ?? null)
     .attr('fill', (label) => label.color)
-    .attr('opacity', (label) =>
-      highlight === null || highlight === label.hwKey || highlight === label.traceKey ? 1 : 0.2,
-    )
+    .attr('opacity', (label) => labelOpacity(label, highlight))
     .text((label) => label.text)
     .each(function (label) {
       const x = xScale(label.x);
@@ -775,7 +777,6 @@ export default function PowerTimeline({
     hcKeys: stableHcKeys,
   });
 
-  // ── Telemetry fetch: one request per workflow run ──────────────────────────
   const requests = useMemo(() => planPowerTimelineRequests(allPoints), [allPoints]);
   // The deep-link request is read once, before planning, so its run is fetched
   // even when the chart spans more runs than the cap.
@@ -857,7 +858,6 @@ export default function PowerTimeline({
     });
   }, [loadingRuns, responses.size, traces.length, missing.length]);
 
-  // ── Visible traces and their colours ────────────────────────────────────────
   const colorForTrace = useCallback(
     (trace: PowerTimelineTrace): { color: string; overlayIndex: number | null } => {
       if (overlayPointSet.has(trace.point)) {
@@ -1043,7 +1043,6 @@ export default function PowerTimeline({
     return lines;
   }, [visibleTraces, colorForTrace, showUtility, lineMode, t]);
 
-  // ── Scales ─────────────────────────────────────────────────────────────────
   const xDomain = useMemo<[number, number]>(() => {
     let min = Number.POSITIVE_INFINITY;
     let max = Number.NEGATIVE_INFINITY;
@@ -1080,7 +1079,6 @@ export default function PowerTimeline({
       format(value instanceof Date ? value : new Date(Number(value)));
   }, [xMode, xDomain]);
 
-  // ── Layers ─────────────────────────────────────────────────────────────────
   const highlightRef = useRef(activeHighlight);
   highlightRef.current = activeHighlight;
   const layers = useMemo<LayerConfig<TimelineSample>[]>(
@@ -1169,13 +1167,7 @@ export default function PowerTimeline({
         .attr('opacity', (path) => traceOpacity(path, activeHighlight));
       root
         .selectAll<SVGTextElement, TraceLabel>('text.power-trace-label')
-        .attr('opacity', (label) =>
-          activeHighlight === null ||
-          activeHighlight === label.hwKey ||
-          activeHighlight === label.traceKey
-            ? 1
-            : 0.2,
-        );
+        .attr('opacity', (label) => labelOpacity(label, activeHighlight));
     },
     [activeHighlight],
   );
@@ -1240,7 +1232,6 @@ export default function PowerTimeline({
     [unofficialRunInfos, xMode, t, locale, hardwareLabel],
   );
 
-  // ── Legend ─────────────────────────────────────────────────────────────────
   const legendItems = useMemo(() => {
     const overlayItems =
       overlayData && unofficialRunInfos.length > 0
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 9111bfd30..57dfc074f 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -2651,6 +2651,13 @@ const ScatterGraph = React.memo(
 
     // --- Layers ---
     const layers = useMemo((): LayerConfig<InferenceData>[] => {
+      // Observed-load segments join exact measurements; every other curve is smoothed.
+      const lineCurve = isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX;
+      const curveKind = isConcurrencyAxis
+        ? 'observed-load'
+        : showPowerEnvelope
+          ? 'power-envelope'
+          : 'pareto';
       // Line-label identity of one drawn series under a power comparison
       // (`i_pcompare`): the base series keeps the hardware key, so pinned
       // anchors and hover hooks keep working; a sibling is `<hw>::<variant>`.
@@ -2694,7 +2701,7 @@ const ScatterGraph = React.memo(
             .line<InferenceData>()
             .x((d) => xScale(d.x))
             .y((d) => yScale(d.y))
-            .curve(isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX);
+            .curve(lineCurve);
 
           // Ensure rooflines layer exists before dot-groups
           let rooflinesLayer = zoomGroup.select<SVGGElement>('.rooflines-layer');
@@ -2797,10 +2804,7 @@ const ScatterGraph = React.memo(
             )
             .join('path')
             .attr('class', (d) => `roofline-path roofline-${d.key}`)
-            .attr(
-              'data-curve-kind',
-              isConcurrencyAxis ? 'observed-load' : showPowerEnvelope ? 'power-envelope' : 'pareto',
-            )
+            .attr('data-curve-kind', curveKind)
             .attr('data-hw-key', (d) => d.hw)
             .attr('data-precision', (d) => d.precision)
             .attr('data-power-variant', (d) => d.variant || null)
@@ -2899,10 +2903,7 @@ const ScatterGraph = React.memo(
               (exit) => exit.remove(),
             )
             .attr('data-seg-key', (d) => d.segKey)
-            .attr(
-              'data-curve-kind',
-              isConcurrencyAxis ? 'observed-load' : showPowerEnvelope ? 'power-envelope' : 'pareto',
-            )
+            .attr('data-curve-kind', curveKind)
             .attr('data-hw-key', (d) => d.hw)
             .attr('data-precision', (d) => d.precision)
             .attr('transform', (d) => `translate(${d.x},${d.y})`)
@@ -3195,7 +3196,7 @@ const ScatterGraph = React.memo(
             .line<InferenceData>()
             .x((d) => newXScale(d.x))
             .y((d) => newYScale(d.y))
-            .curve(isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX);
+            .curve(lineCurve);
 
           // Update roofline paths — must split per-date so the zoom redraw
           // matches the per-date sub-paths created in the initial render.
@@ -3426,7 +3427,7 @@ const ScatterGraph = React.memo(
                 .line<InferenceData>()
                 .x((d) => xScale(d.x))
                 .y((d) => yScale(d.y))
-                .curve(isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX);
+                .curve(lineCurve);
 
               interface OvEntry {
                 key: string;
@@ -3459,14 +3460,7 @@ const ScatterGraph = React.memo(
                 .data(ovEntries, (d) => d.key)
                 .join('path')
                 .attr('class', (d) => `overlay-roofline-path overlay-roofline-${d.key}`)
-                .attr(
-                  'data-curve-kind',
-                  isConcurrencyAxis
-                    ? 'observed-load'
-                    : showPowerEnvelope
-                      ? 'power-envelope'
-                      : 'pareto',
-                )
+                .attr('data-curve-kind', curveKind)
                 .attr('fill', 'none')
                 .attr('stroke', (d) => d.stroke)
                 .attr('stroke-width', 2)
@@ -3620,7 +3614,7 @@ const ScatterGraph = React.memo(
                 .line<InferenceData>()
                 .x((d) => newXScale(d.x))
                 .y((d) => newYScale(d.y))
-                .curve(isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX);
+                .curve(lineCurve);
 
               Object.entries(displayedOverlayRooflines).forEach(([key, group]) => {
                 if (group.points.length < 2) return;
@@ -3708,7 +3702,7 @@ const ScatterGraph = React.memo(
             .line<InferenceData>()
             .x((point) => xScale(point.x))
             .y((point) => yScale(point.y))
-            .curve(isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX);
+            .curve(lineCurve);
           const continuationPath = group
             .select<SVGPathElement>('.overflow-continuation-line')
             .attr('d', lineGenerator(entry.points) ?? '')
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.ts b/packages/app/src/components/inference/utils/equal-service-comparison.ts
index 77af25a63..fff7c3e78 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.ts
@@ -1,6 +1,6 @@
 import type { AggDataEntry, InferenceData } from '../types';
 import { chipCounts } from '@/lib/chip-counts';
-import { powerBasisNormalization } from '@/lib/power-basis';
+import { isPositive, powerBasisNormalization } from '@/lib/power-basis';
 import { reconstructedRoleEnergy } from './role-energy';
 import { pointTopologyKey, topologyLabel } from './topology-filter';
 
@@ -45,8 +45,6 @@ export interface EqualServiceComparison {
     EqualServiceMetric
   >;
 }
-const positive = (value: unknown): value is number =>
-  typeof value === 'number' && Number.isFinite(value) && value > 0;
 const serviceAxis = (field: string) =>
   field === 'mean_tpot_intvty' ||
   /^(?:mean|median|p\d+(?:\.\d+)?)_(?:intvty|tpot|ttft|e2el|itl)$/u.test(field);
@@ -106,7 +104,7 @@ export function getEqualServiceSources(points: readonly InferenceData[]): EqualS
 }
 
 function deploymentOutput(point: InferenceData): number | undefined {
-  if (!positive(point.output_tput_per_gpu)) return undefined;
+  if (!isPositive(point.output_tput_per_gpu)) return undefined;
   if (point.disagg) {
     return (
       powerBasisNormalization({
@@ -119,7 +117,7 @@ function deploymentOutput(point: InferenceData): number | undefined {
     );
   }
   const count = chipCounts(point, false).physical;
-  return positive(count) && Number.isSafeInteger(count)
+  return isPositive(count) && Number.isSafeInteger(count)
     ? point.output_tput_per_gpu * count
     : undefined;
 }
@@ -138,7 +136,7 @@ function estimate(
   const rows = points
     .flatMap((point) => {
       const x = point[field];
-      return positive(x) ? [{ point, x, value: quantity(point) }] : [];
+      return isPositive(x) ? [{ point, x, value: quantity(point) }] : [];
     })
     .sort((a, b) => a.x - b.x || (a.point.id ?? 0) - (b.point.id ?? 0));
   const xs = [...new Set(rows.map((row) => row.x))];
@@ -152,7 +150,7 @@ function estimate(
     if (matches.some((row) => !Object.is(row.value, matches[0].value)))
       return { estimate: null, reason: 'ambiguous-x' };
     for (const row of matches) {
-      if (!positive(row.value)) return { estimate: null, reason: 'missing-metric' };
+      if (!isPositive(row.value)) return { estimate: null, reason: 'missing-metric' };
       endpoints.push({ ...row, value: row.value });
     }
   }
@@ -162,7 +160,7 @@ function estimate(
     brackets.length === 1
       ? left.value
       : left.value + (right.value - left.value) * ((target - left.x) / (right.x - left.x));
-  return positive(value)
+  return isPositive(value)
     ? { estimate: { value, interpolated: brackets.length === 2, endpoints } }
     : { estimate: null, reason: 'missing-metric' };
 }
@@ -178,7 +176,7 @@ export function buildEqualServiceComparison(
   const sourceB = sources.find((source) => source.key === comparator) ?? null;
   let reason: EqualServiceReason | undefined;
   if (!serviceAxis(xField)) reason = 'unsupported-axis';
-  else if (!positive(target)) reason = 'invalid-target';
+  else if (!isPositive(target)) reason = 'invalid-target';
   else if (baseline === comparator) reason = 'same-source';
   else if (!sourceA || !sourceB) reason = 'unknown-source';
   const rows = observed(points);
@@ -223,7 +221,7 @@ export function getEqualServiceComparisonCurve(
     observed(points)
       .filter((point) => equalServiceSourceKey(point) === key)
       .map((point) => point[options.xField])
-      .filter(positive);
+      .filter(isPositive);
   const a = xs(options.baseline),
     b = xs(options.comparator);
   if (a.length === 0 || b.length === 0) return [];
@@ -244,7 +242,7 @@ export function getPrefillSharePoints(
     .flatMap((point) => {
       const x = point[xField];
       const energy = reconstructedRoleEnergy(point);
-      return positive(x) && energy
+      return isPositive(x) && energy
         ? [{ x, sourceKey: equalServiceSourceKey(point), point, ...energy }]
         : [];
     })
diff --git a/packages/app/src/components/inference/utils/powerCurves.ts b/packages/app/src/components/inference/utils/powerCurves.ts
index 13ac7209e..7c251acbc 100644
--- a/packages/app/src/components/inference/utils/powerCurves.ts
+++ b/packages/app/src/components/inference/utils/powerCurves.ts
@@ -34,10 +34,7 @@ export function isPowerCurveMetric(metric: string): boolean {
  * Pareto behaviour.
  */
 export function isMeasuredPowerCurveMetric(metric: string): boolean {
-  return (
-    isPowerCurveMetric(metric) &&
-    (metric !== 'y_modeledChassisPowerPerGpu' || isPowerBasisConfigKey(metric))
-  );
+  return isPowerCurveMetric(metric) && metric !== 'y_modeledChassisPowerPerGpu';
 }
 
 /**
diff --git a/packages/app/src/components/inference/utils/powerTimeline.test.ts b/packages/app/src/components/inference/utils/powerTimeline.test.ts
index a1f880247..a407a8bb6 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.test.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.test.ts
@@ -391,13 +391,9 @@ describe('power trace focus handoff', () => {
   });
 });
 
-describe('prioritizeRuns', () => {
-  const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
-    runId,
-    prefix: '',
-    sources: [],
-  }));
+const requests = ['1', '2', '3', '4', '5'].map((runId) => ({ runId, prefix: '', sources: [] }));
 
+describe('prioritizeRuns', () => {
   it('moves overlay runs ahead of official runs and keeps both orders', () => {
     expect(prioritizeRuns(requests, new Set(['5', '3'])).map((request) => request.runId)).toEqual([
       '3',
@@ -422,12 +418,6 @@ describe('prioritizeRuns', () => {
 });
 
 describe('prioritizeRun', () => {
-  const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
-    runId,
-    prefix: '',
-    sources: [],
-  }));
-
   it('moves the deep-linked run to the front and keeps the rest in order', () => {
     expect(prioritizeRun(requests, '5').map((request) => request.runId)).toEqual([
       '5',
diff --git a/packages/app/src/components/inference/utils/powerTimeline.ts b/packages/app/src/components/inference/utils/powerTimeline.ts
index dfa7b8141..129756ce9 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.ts
@@ -299,8 +299,6 @@ export function traceConfigLabel(point: InferenceData): string {
   return parts.join(' · ');
 }
 
-// ── Worker-role pools ────────────────────────────────────────────────────────
-
 export type PowerPoolRole = GpuPowerRole | 'all';
 
 export interface PowerPool {
diff --git a/packages/app/src/components/inference/utils/role-energy.ts b/packages/app/src/components/inference/utils/role-energy.ts
index 89e6b37f2..53d719dd0 100644
--- a/packages/app/src/components/inference/utils/role-energy.ts
+++ b/packages/app/src/components/inference/utils/role-energy.ts
@@ -1,3 +1,5 @@
+import { isPositive } from '@/lib/power-basis';
+
 /**
  * Reconstructs how a disaggregated deployment's request energy splits between
  * its prefill and decode pools (PowerX Figure 7).
@@ -36,9 +38,6 @@ export interface ReconstructedRoleEnergy {
   prefillShare: number;
 }
 
-const positive = (value: unknown): value is number =>
-  typeof value === 'number' && Number.isFinite(value) && value > 0;
-
 export function reconstructedRoleEnergy(
   entry: RoleEnergyInput,
 ): ReconstructedRoleEnergy | undefined {
@@ -49,12 +48,12 @@ export function reconstructedRoleEnergy(
   const output = entry.joules_per_output_token;
   const prefill = entry.prefill_joules_per_input_token;
   const decode = entry.decode_joules_per_output_token;
-  if (!positive(input) || !positive(output) || !positive(prefill) || !positive(decode)) {
+  if (!isPositive(input) || !isPositive(output) || !isPositive(prefill) || !isPositive(decode)) {
     return undefined;
   }
   const prefillPerOutputToken = prefill * (output / input);
   const total = prefillPerOutputToken + decode;
-  if (!positive(prefillPerOutputToken) || !positive(total)) return undefined;
+  if (!isPositive(prefillPerOutputToken) || !isPositive(total)) return undefined;
   return {
     prefill: prefillPerOutputToken,
     decode,
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 4e90268c3..68cfd9d97 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -139,7 +139,7 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'published-read',
     operationId: 'get-inference-view',
-    sourceSha256: '7b3f1ba020dee0f3ad5b62249294d8532cb1ae40f22f182f70b218fc3426cb1d',
+    sourceSha256: '5f2d5997fdab9e1e94510bdbefe6e0dba394d65680fec37c5bcdeeb004eefcfd',
   },
   {
     source: 'src/app/api/v1/views/operatorx/route.ts',
@@ -239,7 +239,7 @@ export const apiRouteCatalog = [
       en: 'UI-only PowerX raw/series=power read: DB-first with artifact fallback, separate host/GPU identities and adjacent CSV context timezone normalization. GET has no expected identities and reports sourceCoverage unknown. Healthy stored windows survive fallback; known-incomplete CSVs require retained file/sample inventory and known-incomplete bundles require re-ingest. DB failures return 503 DATABASE_UNAVAILABLE; unresolved stored gaps return 503 STORED_TELEMETRY_INCOMPLETE. Responses use no-store. This is not a stable public API.',
       zh: '仅供 PowerX 界面读取原始遥测或 series=power：优先 DB，缺失时回退产物，保留主机/GPU 身份，并按相邻 CSV context 规范化时区。GET 没有预期身份清单，sourceCoverage 为 unknown。回退保留健康存储窗口；已知不完整 CSV 须满足文件/样本清单，已知不完整 bundle 须重新 ingest。数据库故障返回 503 DATABASE_UNAVAILABLE，未恢复的存储缺口返回 503 STORED_TELEMETRY_INCOMPLETE。响应使用 no-store，不作为稳定公开 API。',
     },
-    sourceSha256: '48930ca8c5c7fb26ab193f872271e21aefadc306d760ad9a7365c7cba4e4029b',
+    sourceSha256: 'e5e542173400ab5012eeff665154e68d62a402f8279e0cb7fe6e3f4dfb548adf',
   },
   {
     source: 'src/app/api/gpu-metrics/route.ts',
@@ -250,7 +250,7 @@ export const apiRouteCatalog = [
       en: 'Read-only Timeline transport with runId, series=power and optional prefix in the query; JSON sources contains 1–1000 validation basenames with RESULT_FILENAME up to 200 ASCII letters/digits/dot/underscore/hyphen, matching prefix. Invalid input returns 400; bodies over 256 KiB return 413. Fully covered DB reads skip GitHub; missing identities fall back and merge by validation source, preserving stored sibling windows. Offline GitHub preserves healthy DB series with incomplete sourceCoverage. Coverage describes only requested identities, never whole-run/sample completeness. The GET no-store/error/inventory guarantees also apply. UI-owned, excluded from the stable public API.',
       zh: 'Timeline 只读传输：查询参数为 runId、series=power 和可选 prefix；JSON sources 含 1–1000 个验证文件 basename，RESULT_FILENAME 最长 200 个 ASCII 字母/数字/点/下划线/连字符，且须匹配 prefix。输入错误返回 400，正文超过 256 KiB 返回 413。DB 已覆盖请求时跳过 GitHub，否则按缺失身份回退，以 validation source 为键合并，并保留已存储的同 bundle 兄弟窗口。GitHub 离线仍返回健康 DB 序列，sourceCoverage 标记 incomplete。覆盖仅针对请求身份，不代表整次 run 或样本完整性。沿用 GET 的 no-store、错误和清单约束；属于界面接口，不纳入稳定公开 API。',
     },
-    sourceSha256: '48930ca8c5c7fb26ab193f872271e21aefadc306d760ad9a7365c7cba4e4029b',
+    sourceSha256: 'e5e542173400ab5012eeff665154e68d62a402f8279e0cb7fe6e3f4dfb548adf',
   },
   {
     source: 'src/app/api/openapi.json/route.ts',
@@ -814,7 +814,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/inference/utils/equal-service-comparison.ts',
-    sourceSha256: '706ba422ba200845d0eca4b24c95b35feef83a39bcfce61499eb6f5c482f525b',
+    sourceSha256: 'e6e1e07a3dfaa4cfa0ea1bd9b6e8f7cc9a6fc43f043b9f07ef1651d4422c01db',
     reviewArea: {
       en: 'Source-scoped equal-service interpolation, comparator-relative changes, endpoint provenance, and prefill share projection.',
       zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源，以及 prefill 占比视图。',
@@ -822,7 +822,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/inference/utils/role-energy.ts',
-    sourceSha256: 'd3d731769fa5aed6f4d1c94fe3f80c5316beb3dbbf52a9f8f3a9c024362b4825',
+    sourceSha256: '36b1ceda97af99731482ed815167a660f1619ab94c2956afe11cf72d58fa5380',
     reviewArea: {
       en: 'Validated prefill/decode energy reconstruction and shares on a common output-token denominator.',
       zh: '使用统一 output token 分母的已验证 prefill/decode 能耗重建与占比。',
@@ -846,7 +846,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/gpu-power/power-audit-bundle.ts',
-    sourceSha256: '35901a329822ae6522fe39522eb1da5509bcecee1afda93a2ce9c0d06b0f27de',
+    sourceSha256: '2f6e82d64380c936178e26795336bb8259a316fa4e547987688effc48e4b28eb',
     reviewArea: {
       en: 'Artifact Timeline validation windows, strict nested AgentX result identity, adjacent context selection, timezone normalization and device identity semantics.',
       zh: '产物 Timeline 验证窗口、严格匹配的嵌套 AgentX result 身份、相邻 context 选择、时区规范化及设备身份语义。',
@@ -862,7 +862,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/gpu-power/types.ts',
-    sourceSha256: 'e8c5460821f5d8228bcf8b7dd087abe14e29a8e220e1d8bcd75112fb5ead1baa',
+    sourceSha256: '207d56219a78a44603bff5d61ca9017caa37ab1a6973792793a2ce2122f5475c',
     reviewArea: {
       en: 'GPU telemetry units, missing values, timestamp deduplication, and full-record live statistics definitions.',
       zh: 'GPU 遥测单位、缺失值、时间戳去重，以及实时产物全记录统计的定义。',
diff --git a/packages/app/src/lib/chart-utils.ts b/packages/app/src/lib/chart-utils.ts
index 7f6598824..a1ae03ac2 100644
--- a/packages/app/src/lib/chart-utils.ts
+++ b/packages/app/src/lib/chart-utils.ts
@@ -11,7 +11,6 @@ import type {
   AggDataEntry,
   ChartDefinition,
   InferenceData,
-  PowerBasisFieldKey,
   YAxisMetricKey,
 } from '@/components/inference/types';
 import {
@@ -292,13 +291,8 @@ export function buildAvailabilityHwKey(
   return hwKey;
 }
 
-// Power-boundary fields are derived here before the registry exposes them as
-// axes; the union collapses once METRIC_REGISTRY carries the same keys. The
-// reconstructed prefill energy is a comparison-only series (never an axis).
-export type DerivedMetricKey =
-  | BenchmarkMetricKey
-  | PowerBasisFieldKey
-  | 'reconstructedPrefillJPerOutputToken';
+// The reconstructed prefill energy is a comparison-only series (never an axis).
+export type DerivedMetricKey = BenchmarkMetricKey | 'reconstructedPrefillJPerOutputToken';
 export type DerivedChartFields = Pick<InferenceData, DerivedMetricKey>;
 
 const chartMetric = (y: number): { y: number; roof: boolean } => ({ y, roof: false });
@@ -553,6 +547,9 @@ function buildMeasuredPowerChartFields(
   entry: AggDataEntry,
   tdpWatts: number,
 ): MeasuredPowerChartFields {
+  // Prefill energy on the output-token axis, so the roles comparison can
+  // stack it against the decode pool (PowerX Figure 7).
+  const roleEnergy = reconstructedRoleEnergy(entry);
   return {
     // The timeline axis aliases the validated average: the point set (and
     // its table row) is the same, only the chart body changes.
@@ -591,14 +588,7 @@ function buildMeasuredPowerChartFields(
     ...(typeof entry.decode_joules_per_output_token === 'number'
       ? { measuredDecodeJPerOutputToken: chartMetric(entry.decode_joules_per_output_token) }
       : {}),
-    // Prefill energy on the output-token axis, so the roles comparison can
-    // stack it against the decode pool (PowerX Figure 7).
-    ...(() => {
-      const roleEnergy = reconstructedRoleEnergy(entry);
-      return roleEnergy
-        ? { reconstructedPrefillJPerOutputToken: chartMetric(roleEnergy.prefill) }
-        : {};
-    })(),
+    ...(roleEnergy ? { reconstructedPrefillJPerOutputToken: chartMetric(roleEnergy.prefill) } : {}),
     ...(typeof entry.joules_per_successful_query === 'number'
       ? {
           measuredJPerSuccessfulQuery: chartMetric(entry.joules_per_successful_query),
@@ -623,23 +613,19 @@ export function remapInferencePoint(
   const metric = point[metricKey];
   const xCandidate = (point as Partial<AggDataEntry>)[xAxisField];
   // Absent TTFT values are zero-filled by the row transform. Neither that
-  // sentinel nor an unrelated fallback coordinate is a latency measurement.
-  const missingConcurrency =
-    xAxisField === 'conc' &&
-    (typeof xCandidate !== 'number' || !Number.isFinite(xCandidate) || xCandidate <= 0);
-  const requiresMeasuredServiceValue =
-    xAxisField.endsWith('_ttft') || xAxisField === 'mean_e2el' || xAxisField === 'mean_tpot_intvty';
-  const missingServiceValue =
-    requiresMeasuredServiceValue &&
+  // sentinel nor an unrelated fallback coordinate is a latency measurement;
+  // the same holds for concurrency and the mean service fields.
+  const requiresMeasuredValue =
+    xAxisField === 'conc' ||
+    xAxisField.endsWith('_ttft') ||
+    xAxisField === 'mean_e2el' ||
+    xAxisField === 'mean_tpot_intvty';
+  const missingMeasuredValue =
+    requiresMeasuredValue &&
     (typeof xCandidate !== 'number' || !Number.isFinite(xCandidate) || xCandidate <= 0);
   return {
     ...point,
-    x:
-      missingServiceValue || missingConcurrency
-        ? NaN
-        : typeof xCandidate === 'number'
-          ? xCandidate
-          : point.x,
+    x: missingMeasuredValue ? NaN : typeof xCandidate === 'number' ? xCandidate : point.x,
     y: metric?.y ?? point.y,
     roof: xAxisField === 'conc' ? false : (metric?.roof ?? false),
   };
diff --git a/packages/app/src/lib/inference-labels.ts b/packages/app/src/lib/inference-labels.ts
index c9da78643..5bd98f563 100644
--- a/packages/app/src/lib/inference-labels.ts
+++ b/packages/app/src/lib/inference-labels.ts
@@ -23,7 +23,6 @@ export function inferenceFrameworkLabelOverride(
   return hasLabel ? 'MoRI UMBP SGLang' : undefined;
 }
 
-/** Keep unofficial-run identity/markers while making its special engine visible. */
 /** Leads every unofficial-run label, in line labels and legend rows alike. */
 export const OVERLAY_LABEL_MARKER = '✕ ';
 const RUN_TAG_MAX = 20;
@@ -66,6 +65,7 @@ export function getOverlayLineLabel(
   return `${OVERLAY_LABEL_MARKER}${hardwareLabel}${sharesHardware ? overlayRunTag(run) : ''}`;
 }
 
+/** Keep unofficial-run identity/markers while making its special engine visible. */
 export function getInferenceRunLabel(
   label: string,
   points: readonly (RunProvenance & { framework?: string })[],
diff --git a/packages/app/src/lib/power-basis.ts b/packages/app/src/lib/power-basis.ts
index 034eeca2d..256e63f2a 100644
--- a/packages/app/src/lib/power-basis.ts
+++ b/packages/app/src/lib/power-basis.ts
@@ -75,31 +75,33 @@ export interface PowerBasisInput {
 
 export type PowerBasisValues = Record<PowerBasisFieldKey, number | null>;
 
-const positive = (value: unknown): value is number =>
+export const isPositive = (value: unknown): value is number =>
   typeof value === 'number' && Number.isFinite(value) && value > 0;
-const count = (value: unknown): value is number => positive(value) && Number.isSafeInteger(value);
-const orNull = (value: number): number | null => (positive(value) ? value : null);
+const count = (value: unknown): value is number => isPositive(value) && Number.isSafeInteger(value);
+const orNull = (value: number): number | null => (isPositive(value) ? value : null);
 
 /**
  * Derives the B2–B4 boundary values from plain numbers. Any unavailable input
  * yields `null` for the values that depend on it and leaves the rest intact.
  */
 export function computePowerBasisFields(input: PowerBasisInput): PowerBasisValues {
-  const tdp = positive(input.tdpWatts) ? input.tdpWatts : null;
-  const utility = positive(input.utilityWatts) ? input.utilityWatts : null;
-  const measuredWatts = positive(input.measuredWatts) ? input.measuredWatts : null;
-  const measuredJ = positive(input.measuredJPerOutputToken) ? input.measuredJPerOutputToken : null;
+  const tdp = isPositive(input.tdpWatts) ? input.tdpWatts : null;
+  const utility = isPositive(input.utilityWatts) ? input.utilityWatts : null;
+  const measuredWatts = isPositive(input.measuredWatts) ? input.measuredWatts : null;
+  const measuredJ = isPositive(input.measuredJPerOutputToken)
+    ? input.measuredJPerOutputToken
+    : null;
   // B4 is B1 carried out to the utility meter, so it follows B1's availability:
   // no measured watts, no modeled boundary (B3 ≥ B4 ≥ B1 needs its anchor).
   const modeled =
-    measuredWatts !== null && positive(input.modeledFacilityWattsPerGpu)
+    measuredWatts !== null && isPositive(input.modeledFacilityWattsPerGpu)
       ? input.modeledFacilityWattsPerGpu
       : null;
 
   // Provisioned energy: GPU-seconds spent per output token by the whole
   // deployment (N_alloc ÷ total tok/s) × W per GPU = J per output token.
   const gpuSecondsPerOutputToken =
-    positive(input.allocatedGpus) && positive(input.totalOutputTokPerSec)
+    isPositive(input.allocatedGpus) && isPositive(input.totalOutputTokPerSec)
       ? input.allocatedGpus / input.totalOutputTokPerSec
       : null;
   const provisionedEnergy = (watts: number | null) =>
@@ -154,7 +156,7 @@ export function powerBasisNormalization(
 ): Pick<PowerBasisInput, 'allocatedGpus' | 'totalOutputTokPerSec'> {
   const perGpu = entry.output_tput_per_gpu;
   const unavailable = { allocatedGpus: null, totalOutputTokPerSec: null };
-  if (!positive(perGpu)) return unavailable;
+  if (!isPositive(perGpu)) return unavailable;
   if (!entry.disagg) return { allocatedGpus: 1, totalOutputTokPerSec: perGpu };
   if (entry.benchmark_type !== 'single_turn') return unavailable;
   const prefill = entry.num_prefill_gpu;
@@ -178,7 +180,7 @@ export function modeledFacilityWattsPerGpu(
 ): number | null {
   const model = entry.modeledSystemPower;
   if (model?.status !== 'supported') return null;
-  if (!positive(model.deploymentFacilityWatts) || !count(model.gpuCount)) return null;
+  if (!isPositive(model.deploymentFacilityWatts) || !count(model.gpuCount)) return null;
   return orNull(model.deploymentFacilityWatts / model.gpuCount);
 }
 
@@ -196,7 +198,7 @@ export function buildPowerBasisChartFields(
 ): PowerBasisChartFields {
   const values = computePowerBasisFields({
     tdpWatts: specs.tdp ?? null,
-    utilityWatts: positive(specs.power) ? specs.power * 1000 : null,
+    utilityWatts: isPositive(specs.power) ? specs.power * 1000 : null,
     ...powerBasisNormalization(entry),
     measuredWatts: entry.avg_power_w ?? null,
     measuredJPerOutputToken: entry.joules_per_output_token ?? null,
diff --git a/packages/db/src/backfill-gpu-metrics.ts b/packages/db/src/backfill-gpu-metrics.ts
index cfd53819c..3043bafcd 100644
--- a/packages/db/src/backfill-gpu-metrics.ts
+++ b/packages/db/src/backfill-gpu-metrics.ts
@@ -66,6 +66,7 @@ import { repositoryFromRunUrl } from './lib/runtime-metadata-artifacts.js';
 
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 const GITHUB_RETENTION_DAYS = 90;
+const GITHUB_RETENTION_MS = GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000;
 const sql = createAdminSql({ noSsl: hasNoSslFlag(), max: 4, onnotice: () => {} });
 
 interface CandidateRun {
@@ -129,8 +130,7 @@ function parseFlags(): BackfillFlags {
 }
 
 function isWithinGithubRetention(date: string): boolean {
-  const ageMs = Date.now() - new Date(date).getTime();
-  return ageMs <= GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+  return Date.now() - new Date(date).getTime() <= GITHUB_RETENTION_MS;
 }
 
 async function loadCandidateRuns(
@@ -138,9 +138,7 @@ async function loadCandidateRuns(
   limit: number | null,
   force: boolean,
 ): Promise<CandidateRun[]> {
-  const cutoff = new Date(Date.now() - GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000)
-    .toISOString()
-    .slice(0, 10);
+  const cutoff = new Date(Date.now() - GITHUB_RETENTION_MS).toISOString().slice(0, 10);
   const since = flags.since ?? cutoff;
   const rows = await sql<CandidateRun[]>`
     select wr.id, wr.github_run_id, wr.run_attempt, wr.html_url, wr.date::text as date,
@@ -214,13 +212,13 @@ async function processPair(
     const matchedIds: number[] = [];
     const mappedPoints: { ids: number[]; identity: Record<string, unknown> }[] = [];
     for (const row of mappedRows) {
+      const identity = benchmarkPublicationIdentity(row);
       const ids = await findBenchmarkResultIds(sql, run, [row], (id) =>
-        uniqueFallbacks.set(stablePowerPointIdentity(benchmarkPublicationIdentity(row)), id),
+        uniqueFallbacks.set(stablePowerPointIdentity(identity), id),
       );
       if (ids.length === 0) throw new Error(`${pair.gpuMetrics.name}: no matching benchmark rows`);
       matchedIds.push(...ids);
-      if (row.benchmarkType === 'agentic_traces')
-        mappedPoints.push({ ids, identity: benchmarkPublicationIdentity(row) });
+      if (row.benchmarkType === 'agentic_traces') mappedPoints.push({ ids, identity });
     }
     const resultIds = [...new Set(matchedIds)];
     if (resultIds.length === 0) {
@@ -273,16 +271,14 @@ async function processPair(
       metadataUpdatedBenchmarkResultIds: ingested.metadataUpdatedBenchmarkResultIds,
     };
   } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
     if (pointKeys.length === 0)
       expectationErrors.push({
         benchmarkArtifact: pair.benchmarks.name,
         artifactNames: [pair.gpuMetrics.name],
-        error: error instanceof Error ? error.message : String(error),
+        error: message,
       });
-    for (const key of pointKeys) {
-      const observation = observations.get(key)!;
-      observation.error = error instanceof Error ? error.message : String(error);
-    }
+    for (const key of pointKeys) observations.get(key)!.error = message;
     console.error(`  ✗ run ${run.github_run_id} artifact ${pair.gpuMetrics.name}:`, error);
     return { kind: 'failed' };
   } finally {
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.ts b/packages/db/src/etl/gpu-metrics-artifacts.ts
index d101976e4..ca38bb55d 100644
--- a/packages/db/src/etl/gpu-metrics-artifacts.ts
+++ b/packages/db/src/etl/gpu-metrics-artifacts.ts
@@ -77,19 +77,20 @@ function isGpuMetricsCsvName(fileName: string): boolean {
   return !lower.includes('_identity') && !lower.includes('_energy_');
 }
 
-/** Recursively list every telemetry CSV under an extracted artifact root. */
-export function listGpuMetricsCsvFiles(root: string): GpuMetricsCsvFile[] {
+/** Recursively list the files under `root` whose POSIX-relative name passes `matches`. */
+function listFiles(
+  root: string,
+  matches: (fileName: string, baseName: string) => boolean,
+): GpuMetricsCsvFile[] {
   if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return [];
   const files: GpuMetricsCsvFile[] = [];
   const visit = (directory: string): void => {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
       const pathname = path.join(directory, entry.name);
       if (entry.isDirectory()) visit(pathname);
-      else if (entry.isFile() && isGpuMetricsCsvName(entry.name)) {
-        files.push({
-          fileName: path.relative(root, pathname).split(path.sep).join('/'),
-          path: pathname,
-        });
+      else if (entry.isFile()) {
+        const fileName = path.relative(root, pathname).split(path.sep).join('/');
+        if (matches(fileName, entry.name)) files.push({ fileName, path: pathname });
       }
     }
   };
@@ -97,30 +98,19 @@ export function listGpuMetricsCsvFiles(root: string): GpuMetricsCsvFile[] {
   return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
 }
 
+/** Recursively list every telemetry CSV under an extracted artifact root. */
+export function listGpuMetricsCsvFiles(root: string): GpuMetricsCsvFile[] {
+  return listFiles(root, (_fileName, baseName) => isGpuMetricsCsvName(baseName));
+}
+
 /** Every multinode power CSV under an extracted `power_audit_` root. */
 export function listMultinodePowerSampleFiles(root: string): GpuMetricsCsvFile[] {
-  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return [];
-  const files: GpuMetricsCsvFile[] = [];
-  const visit = (directory: string): void => {
-    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const pathname = path.join(directory, entry.name);
-      if (entry.isDirectory()) visit(pathname);
-      else if (entry.isFile()) {
-        const fileName = path.relative(root, pathname).split(path.sep).join('/');
-        if (isMultinodePowerSamplesPath(fileName)) files.push({ fileName, path: pathname });
-      }
-    }
-  };
-  visit(root);
-  return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
+  return listFiles(root, isMultinodePowerSamplesPath);
 }
 
 /** The producer manifest next to `samples.csv`; null when absent or malformed. */
 export function readMultinodePowerManifest(samplesPath: string): Record<string, unknown> | null {
-  const parsed = readJsonIfPresent(path.join(path.dirname(samplesPath), 'manifest.json'));
-  return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
-    ? (parsed as Record<string, unknown>)
-    : null;
+  return readJsonObjectIfPresent(path.join(path.dirname(samplesPath), 'manifest.json'));
 }
 
 /** Preserve window boundaries and role overrides before GitHub artifact expiry. */
@@ -167,6 +157,14 @@ function readJsonIfPresent(pathname: string): unknown | null {
   }
 }
 
+/** Like `readJsonIfPresent`, but only a plain JSON object counts as present. */
+function readJsonObjectIfPresent(pathname: string): Record<string, unknown> | null {
+  const parsed = readJsonIfPresent(pathname);
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+    ? (parsed as Record<string, unknown>)
+    : null;
+}
+
 /** `gpu,total_energy_consumption` two-column CSV → { "<gpu>": joules }. */
 export function parseEnergyCsv(text: string): Record<string, number> | null {
   const lines = text
@@ -217,11 +215,8 @@ export function readGpuMetricsSidecars(csvPath: string): GpuMetricsSidecars {
     )
     .sort();
   for (const entry of contextFiles) {
-    const parsed = readJsonIfPresent(path.join(dir, entry));
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-      context = parsed as Record<string, unknown>;
-      break;
-    }
+    context = readJsonObjectIfPresent(path.join(dir, entry));
+    if (context) break;
   }
   const energyStartPath = path.join(dir, 'gpu_metrics_energy_start.csv');
   const energyEndPath = path.join(dir, 'gpu_metrics_energy_end.csv');
diff --git a/packages/db/src/etl/gpu-metrics-csv.ts b/packages/db/src/etl/gpu-metrics-csv.ts
index 35ec33e57..135fa5cef 100644
--- a/packages/db/src/etl/gpu-metrics-csv.ts
+++ b/packages/db/src/etl/gpu-metrics-csv.ts
@@ -139,7 +139,7 @@ export function parseAmdTimestamp(raw: string): number | null {
   return Number.isFinite(iso) ? iso : null;
 }
 
-function emptySample(timestampMs: number, gpuIndex: number): GpuMetricSample {
+export function emptySample(timestampMs: number, gpuIndex: number): GpuMetricSample {
   return {
     timestampMs,
     gpuIndex,
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
index 18f60b82d..0afce269a 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -14,9 +14,6 @@ import fs from 'node:fs';
 import type postgres from 'postgres';
 
 import type { Sql } from './db-utils.js';
-
-/** Either a pooled client or the transaction handle passed to `sql.begin` callbacks. */
-type TxLike = Sql | postgres.TransactionSql;
 import {
   computeGpuMetricStats,
   parseGpuMetricsCsv,
@@ -28,6 +25,7 @@ import {
 import {
   contextUtcOffsetMinutes,
   gpuMetricsArtifactSuffix,
+  isPowerAuditArtifact,
   listGpuMetricsCsvFiles,
   listMultinodePowerSampleFiles,
   readGpuMetricsSidecars,
@@ -39,6 +37,9 @@ import {
 import { multinodePowerVendor, parseMultinodePowerSamples } from './multinode-power-samples.js';
 import { recoveredPowerAudit } from './power-audit-validations.js';
 
+/** Either a pooled client or the transaction handle passed to `sql.begin` callbacks. */
+type TxLike = Sql | postgres.TransactionSql;
+
 /** Samples are streamed to Postgres in unnest batches of this many rows. */
 const SAMPLE_BATCH_SIZE = 5000;
 
@@ -73,6 +74,25 @@ export interface GpuMetricsIngestResult {
   metadataUpdatedBenchmarkResultIds: number[];
 }
 
+/** Dedupe, window and digest one CSV's samples; null when nothing usable remains. */
+function digestSeries(
+  base: Pick<PreparedGpuMetricSeries, 'fileName' | 'vendor' | 'csvSha256' | 'sidecars'>,
+  rawSamples: readonly GpuMetricSample[],
+): PreparedGpuMetricSeries | null {
+  const samples = uniqueSamples(rawSamples);
+  const summary = summarizeGpuMetricSamples(samples);
+  if (!summary) return null;
+  return {
+    ...base,
+    samples,
+    stats: computeGpuMetricStats(samples),
+    sampleIntervalS: summary.sampleIntervalS,
+    gpuCount: summary.gpuCount,
+    startedAtMs: summary.startedAtMs,
+    endedAtMs: summary.endedAtMs,
+  };
+}
+
 /**
  * One series per host from the multinode power bundle. The deployment-wide
  * CSV is hashed once, so every host series of one upload shares its source sha.
@@ -90,31 +110,26 @@ function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuM
     const vendor = multinodePowerVendor(manifest);
     const csvSha256 = createHash('sha256').update(csvText).digest('hex');
     for (const host of hosts) {
-      const samples = uniqueSamples(host.samples);
-      const summary = summarizeGpuMetricSamples(samples);
-      if (!summary) continue;
-      prepared.push({
-        fileName: `${file.fileName}#${host.hostname}`,
-        vendor,
-        csvSha256,
-        samples,
-        stats: computeGpuMetricStats(samples),
-        sampleIntervalS: summary.sampleIntervalS,
-        gpuCount: summary.gpuCount,
-        startedAtMs: summary.startedAtMs,
-        endedAtMs: summary.endedAtMs,
-        sidecars: {
-          context: manifest,
-          validations,
-          identity: Object.entries(host.gpuUuids).map(([index, uuid]) => ({
-            hostname: host.hostname,
-            gpu_index: Number(index),
-            gpu_uuid: uuid,
-          })),
-          energyStart: null,
-          energyEnd: null,
+      const series = digestSeries(
+        {
+          fileName: `${file.fileName}#${host.hostname}`,
+          vendor,
+          csvSha256,
+          sidecars: {
+            context: manifest,
+            validations,
+            identity: Object.entries(host.gpuUuids).map(([index, uuid]) => ({
+              hostname: host.hostname,
+              gpu_index: Number(index),
+              gpu_uuid: uuid,
+            })),
+            energyStart: null,
+            energyEnd: null,
+          },
         },
-      });
+        host.samples,
+      );
+      if (series) prepared.push(series);
     }
   }
   return prepared;
@@ -130,7 +145,7 @@ export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): Prepare
   for (const file of listGpuMetricsCsvFiles(artifact.artifactDir)) {
     const csvText = fs.readFileSync(file.path, 'utf8');
     const sidecars = readGpuMetricsSidecars(file.path);
-    if (artifact.artifactName.startsWith('power_audit_')) {
+    if (isPowerAuditArtifact(artifact.artifactName)) {
       sidecars.validations = readPowerAuditValidations(artifact.artifactDir, artifact.artifactName);
       const bundleFile = listMultinodePowerSampleFiles(artifact.artifactDir)[0];
       sidecars.powerManifest = bundleFile ? readMultinodePowerManifest(bundleFile.path) : null;
@@ -138,28 +153,22 @@ export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): Prepare
     const parsed = parseGpuMetricsCsv(csvText, {
       nvidiaUtcOffsetMinutes: contextUtcOffsetMinutes(sidecars.context),
     });
-    if (!parsed) {
-      unreadable.push(file.fileName);
-      continue;
-    }
-    const samples = uniqueSamples(parsed.samples);
-    const summary = summarizeGpuMetricSamples(samples);
-    if (!summary) {
+    const series =
+      parsed &&
+      digestSeries(
+        {
+          fileName: file.fileName,
+          vendor: parsed.vendor,
+          csvSha256: createHash('sha256').update(csvText).digest('hex'),
+          sidecars,
+        },
+        parsed.samples,
+      );
+    if (!series) {
       unreadable.push(file.fileName);
       continue;
     }
-    prepared.push({
-      fileName: file.fileName,
-      vendor: parsed.vendor,
-      csvSha256: createHash('sha256').update(csvText).digest('hex'),
-      samples,
-      stats: computeGpuMetricStats(samples),
-      sampleIntervalS: summary.sampleIntervalS,
-      gpuCount: summary.gpuCount,
-      startedAtMs: summary.startedAtMs,
-      endedAtMs: summary.endedAtMs,
-      sidecars,
-    });
+    prepared.push(series);
   }
   if (prepared.length > 0 && unreadable.length > 0) {
     throw new Error(
diff --git a/packages/db/src/etl/multinode-power-samples.ts b/packages/db/src/etl/multinode-power-samples.ts
index 9c711c4de..552588057 100644
--- a/packages/db/src/etl/multinode-power-samples.ts
+++ b/packages/db/src/etl/multinode-power-samples.ts
@@ -14,7 +14,12 @@
  * staging ("one CSV per node"). Pure module: no I/O.
  */
 
-import { splitCsvLine, type GpuMetricSample, type GpuMetricsVendor } from './gpu-metrics-csv.js';
+import {
+  emptySample,
+  splitCsvLine,
+  type GpuMetricSample,
+  type GpuMetricsVendor,
+} from './gpu-metrics-csv.js';
 
 export interface MultinodePowerHost {
   hostname: string;
@@ -32,27 +37,6 @@ export function isMultinodePowerSamplesPath(relativePath: string): boolean {
   return /^LOGS\/(?:[^/]+\/)*samples\.csv$/u.test(posix);
 }
 
-function powerOnlySample(timestampMs: number, gpuIndex: number, powerW: number): GpuMetricSample {
-  return {
-    timestampMs,
-    gpuIndex,
-    powerW,
-    temperatureC: null,
-    smClockMhz: null,
-    memClockMhz: null,
-    gpuUtilPct: null,
-    memUtilPct: null,
-    edgeTempC: null,
-    memTempC: null,
-    gfxVoltageMv: null,
-    socVoltageMv: null,
-    memVoltageMv: null,
-    fclkMhz: null,
-    socclkMhz: null,
-    mmActivityPct: null,
-  };
-}
-
 /**
  * Group the deployment-wide CSV by host. Returns null when the header is not
  * the multinode power schema; malformed rows are skipped. Hosts sort by name
@@ -90,7 +74,7 @@ export function parseMultinodePowerSamples(csvText: string): MultinodePowerHost[
       host = { hostname, samples: [], gpuUuids: {} };
       hosts.set(hostname, host);
     }
-    host.samples.push(powerOnlySample(Math.round(seconds * 1000), gpuIndex, powerW));
+    host.samples.push({ ...emptySample(Math.round(seconds * 1000), gpuIndex), powerW });
     const uuid = at(cells, 'gpu_uuid');
     if (uuid && !(gpuIndex in host.gpuUuids)) host.gpuUuids[gpuIndex] = uuid;
   }
diff --git a/packages/db/src/etl/power-audit-recovery.ts b/packages/db/src/etl/power-audit-recovery.ts
index 808be3ef7..3b1c2f5a2 100644
--- a/packages/db/src/etl/power-audit-recovery.ts
+++ b/packages/db/src/etl/power-audit-recovery.ts
@@ -19,16 +19,14 @@ export function createBenchmarkPowerAuditRecovery() {
     if (evidence) {
       const matches = Object.entries(evidence.validations).filter(([, validation]) => {
         const window = validation.selected_window;
-        if (
-          validation.result_file !== evidence.resultFile ||
-          !window ||
-          typeof window !== 'object' ||
-          Array.isArray(window) ||
-          !('concurrency' in window) ||
-          window.concurrency !== row.conc
-        )
-          return false;
-        return true;
+        return (
+          validation.result_file === evidence.resultFile &&
+          typeof window === 'object' &&
+          window !== null &&
+          !Array.isArray(window) &&
+          'concurrency' in window &&
+          window.concurrency === row.conc
+        );
       });
       // Ambiguous/missing evidence must not establish new provenance.
       if (matches.length !== 1) return row;
diff --git a/packages/db/src/etl/power-publication.ts b/packages/db/src/etl/power-publication.ts
index d4a0ba17c..0130956a1 100644
--- a/packages/db/src/etl/power-publication.ts
+++ b/packages/db/src/etl/power-publication.ts
@@ -49,11 +49,7 @@ export interface PowerPublicationManifest {
   points: PowerPublicationPoint[];
   /** Fatal: verify-power-publication exits non-zero when this is non-empty. */
   ingestErrors?: string[];
-  /**
-   * Non-fatal: PowerX telemetry digest failures. Surfaced in the verification
-   * receipt so they stay visible, but they never fail the ingest — the benchmark
-   * rows landed, and the artifact can be re-digested by the backfill.
-   */
+  /** Non-fatal PowerX telemetry digest failures; see `fatalPublicationErrors`. */
   telemetryWarnings?: string[];
   /** Attachment completeness, separate from benchmark/power publication validity. */
   telemetry?: TelemetryReceipt;
@@ -74,6 +70,7 @@ export interface PowerPublicationManifest {
     error?: string;
   };
 }
+
 /**
  * The errors that fail an ingest. `telemetryWarnings` is deliberately not among
  * them: a gpu_metrics digest failure costs one point's PowerX tab, while the
diff --git a/packages/db/src/etl/required-power-publication.test.ts b/packages/db/src/etl/required-power-publication.test.ts
index 7ad044559..731b023fa 100644
--- a/packages/db/src/etl/required-power-publication.test.ts
+++ b/packages/db/src/etl/required-power-publication.test.ts
@@ -26,6 +26,11 @@ function json(dir: string, file: string): any {
 function write(dir: string, file: string, value: unknown) {
   fs.writeFileSync(path.join(dir, file), JSON.stringify(value));
 }
+function sha256(dir: string, file: string): string {
+  return createHash('sha256')
+    .update(fs.readFileSync(path.join(dir, file)))
+    .digest('hex');
+}
 const manifestPath = 'required-power-sweep-manifest/sweep_manifest.json';
 const benchmarkPath = 'bmk_agentic_golden/agg.json';
 const auditPath = 'agentic_golden/power_validation.json';
@@ -41,10 +46,7 @@ function changeArtifact(dir: string, file: string, edit: (value: any) => void) {
   changeManifest(dir, (manifest) => {
     for (const point of manifest.points)
       for (const artifact of point.artifacts)
-        if (artifact.path === file)
-          artifact.sha256 = createHash('sha256')
-            .update(fs.readFileSync(path.join(dir, file)))
-            .digest('hex');
+        if (artifact.path === file) artifact.sha256 = sha256(dir, file);
   });
 }
 function multinodeFixture() {
@@ -103,13 +105,7 @@ function multinodeFixture() {
       { node: 'decode', gpu_uuid: 'GPU-d', role: 'decode', energy_j: 600 },
     ];
     for (const file of Object.keys(extras))
-      point.artifacts.push({
-        path: file,
-        sha256: createHash('sha256')
-          .update(fs.readFileSync(path.join(dir, file)))
-          .digest('hex'),
-        validation_state: 'valid',
-      });
+      point.artifacts.push({ path: file, sha256: sha256(dir, file), validation_state: 'valid' });
   });
   return dir;
 }
@@ -261,9 +257,7 @@ describe('required power publication contract', () => {
         'agentic_golden/power_validation_conc1.json';
       point.artifacts.push({
         path: amdPath,
-        sha256: createHash('sha256')
-          .update(fs.readFileSync(path.join(dir, amdPath)))
-          .digest('hex'),
+        sha256: sha256(dir, amdPath),
         validation_state: 'valid',
       });
     });
diff --git a/packages/db/src/etl/required-power-publication.ts b/packages/db/src/etl/required-power-publication.ts
index d8f995b8a..5794b29ec 100644
--- a/packages/db/src/etl/required-power-publication.ts
+++ b/packages/db/src/etl/required-power-publication.ts
@@ -475,7 +475,7 @@ function verifyPointEvidence(
         artifact.validation_state !== 'valid' ||
         typeof artifact.sha256 !== 'string' ||
         !/^[a-f0-9]{64}$/u.test(artifact.sha256) ||
-        createHash('sha256').update(file.contents).digest('hex') !== artifact.sha256
+        digest(file) !== artifact.sha256
       )
         throw new Error(`Required power: invalid artifact validation or hash ${relative}`);
       evidence.set(relative, file);
diff --git a/packages/db/src/ingest-ci-run.ts b/packages/db/src/ingest-ci-run.ts
index 351233bf9..ed4135fad 100644
--- a/packages/db/src/ingest-ci-run.ts
+++ b/packages/db/src/ingest-ci-run.ts
@@ -615,6 +615,8 @@ async function main(): Promise<void> {
       const parentDir = path.basename(path.dirname(file));
       const configKey = parentDir.replace(/^bmk_/u, '');
       const suffix = stripBmkAndAgenticPrefix(parentDir);
+      // Same pairing rule as server logs: `gpu_metrics_<key>` carries no
+      // `agentic_` prefix, so agentic points fall back to the bare suffix.
       const gpuMetricsArtifact =
         gpuMetricsArtifacts.get(configKey) ?? gpuMetricsArtifacts.get(suffix);
       let auditEvidence;
@@ -763,8 +765,6 @@ async function main(): Promise<void> {
                 tracker.recordDbError(`server_logs for ${configKey}`, error);
               }
             }
-            // Same pairing rule as server logs: `gpu_metrics_<key>` carries no
-            // `agentic_` prefix, so agentic points fall back to the bare suffix.
             if (gpuMetricsArtifact) {
               try {
                 const gpuMetricsStart = Date.now();
@@ -785,11 +785,9 @@ async function main(): Promise<void> {
                     `${ingested.seriesSkipped} unchanged (${elapsed(gpuMetricsStart)})`,
                 );
               } catch (error: any) {
-                // Non-fatal on purpose: this point's benchmark rows are already
-                // committed and only its telemetry tab is affected, and
-                // `admin:db:backfill-gpu-metrics --run <id>` can re-digest the
-                // artifact later. Recording it as a DB error instead would reach
-                // the publication manifest and fail the whole production ingest.
+                // Non-fatal on purpose (see `fatalPublicationErrors`): the rows are
+                // committed and `admin:db:backfill-gpu-metrics --run <id>` can
+                // re-digest the artifact. A DB error here would fail the ingest.
                 tracker.recordTelemetryError(`gpu_metrics for ${configKey}`, error);
                 for (const row of toInsert) {
                   const point = telemetryObservations.get(
diff --git a/packages/db/src/ingest-ci-telemetry.test.ts b/packages/db/src/ingest-ci-telemetry.test.ts
index 0d0506b2f..e8d51b452 100644
--- a/packages/db/src/ingest-ci-telemetry.test.ts
+++ b/packages/db/src/ingest-ci-telemetry.test.ts
@@ -14,7 +14,6 @@ const mocks = vi.hoisted(() => ({
   persistBenchmark: vi.fn(() => Promise.resolve({ newCount: 1, dupCount: 0, insertedIds: [10] })),
   configFailure: false,
   purgeExtra: false,
-  serverLogFailure: false,
 }));
 vi.mock('./etl/db-utils', async (importOriginal) => ({
   ...(await importOriginal<typeof DbUtils>()),
@@ -79,7 +78,6 @@ beforeEach(() => {
   vi.clearAllMocks();
   mocks.configFailure = false;
   mocks.purgeExtra = false;
-  mocks.serverLogFailure = false;
 });
 
 afterEach(() => {
@@ -142,7 +140,6 @@ it.each(scenarios)(
     try {
       mocks.configFailure = scenario.configFailure ?? false;
       mocks.purgeExtra = scenario.purgeExtra ?? false;
-      mocks.serverLogFailure = scenario.serverLogFailure ?? false;
       process.argv = ['bun', 'ingest-ci-run.ts'];
       process.exitCode = undefined;
       for (const [key, value] of Object.entries({
@@ -184,7 +181,7 @@ it.each(scenarios)(
             : JSON.stringify({ ...row, conc: 2, users: 2, ...scenario.extra }),
         );
       }
-      if (mocks.serverLogFailure) {
+      if (scenario.serverLogFailure) {
         fs.mkdirSync(path.join(dir, 'server_logs_golden'));
         fs.writeFileSync(path.join(dir, 'server_logs_golden', 'server.log'), 'server ready\n');
       }
diff --git a/packages/db/src/lib/backfill-benchmark-refresh.ts b/packages/db/src/lib/backfill-benchmark-refresh.ts
index 15d2d60f6..46eedcdea 100644
--- a/packages/db/src/lib/backfill-benchmark-refresh.ts
+++ b/packages/db/src/lib/backfill-benchmark-refresh.ts
@@ -121,8 +121,7 @@ export async function refreshBackfillBenchmarks(
     `;
     if (rows.length !== ids.length)
       throw new Error('Refresh receipt IDs do not belong to its run/attempt');
-    const changed = rows;
-    for (const row of changed) {
+    for (const row of rows) {
       const audit = row.power_audit;
       if (audit === null)
         throw new Error(
@@ -159,7 +158,7 @@ export async function refreshBackfillBenchmarks(
         points[0]!.power_audit = update.powerAudit;
     }
     save();
-    if (changed.length > 0) {
+    if (rows.length > 0) {
       phase = 'refresh latest_benchmarks';
       await refreshLatestBenchmarks(sql);
       phase = 'invalidate cache';
@@ -178,7 +177,7 @@ export async function refreshBackfillBenchmarks(
       )
         throw new Error('Invalid cache invalidation response');
       phase = 'verify benchmark API';
-      for (const model of new Set(changed.map((row) => row.model))) {
+      for (const model of new Set(rows.map((row) => row.model))) {
         const displayModel = DB_MODEL_TO_DISPLAY[model];
         if (!displayModel) throw new Error(`Unmapped public model: ${model}`);
         const url = new URL('/api/v1/benchmarks', endpoint);
@@ -197,7 +196,7 @@ export async function refreshBackfillBenchmarks(
         if (!api.ok) throw new Error(`HTTP ${api.status}`);
         const body: unknown = await api.json();
         if (!Array.isArray(body)) throw new Error('Invalid benchmark API response');
-        for (const row of changed.filter((entry) => entry.model === model)) {
+        for (const row of rows.filter((entry) => entry.model === model)) {
           const matches = body.filter((candidate) => {
             const raw = candidate?.id;
             const id =
diff --git a/packages/db/src/lib/backfill-runner.ts b/packages/db/src/lib/backfill-runner.ts
index 2051e493d..265cca382 100644
--- a/packages/db/src/lib/backfill-runner.ts
+++ b/packages/db/src/lib/backfill-runner.ts
@@ -166,11 +166,6 @@ export async function runCandidateIdBackfill(
   return true;
 }
 
-/**
- * jsonb parameter for a freshly computed value. `structuredClone` strips
- * class instances/prototypes so postgres.js serializes plain data only —
- * matches what the inline ingest path stores.
- */
 /**
  * List a candidate run's GitHub artifacts with transient-failure retry.
  * Returns `null` when GitHub no longer has the run at all, so a sweep over
@@ -190,6 +185,11 @@ export async function listBackfillRunArtifacts(
   }
 }
 
+/**
+ * jsonb parameter for a freshly computed value. `structuredClone` strips
+ * class instances/prototypes so postgres.js serializes plain data only —
+ * matches what the inline ingest path stores.
+ */
 export function jsonbParam(sql: Sql, value: unknown): ReturnType<Sql['json']> {
   return sql.json(structuredClone(value) as unknown as Parameters<typeof sql.json>[0]);
 }
diff --git a/packages/db/src/lib/telemetry-purge.ts b/packages/db/src/lib/telemetry-purge.ts
index 13b2b76dd..ef8b2d07a 100644
--- a/packages/db/src/lib/telemetry-purge.ts
+++ b/packages/db/src/lib/telemetry-purge.ts
@@ -28,8 +28,13 @@ export interface TelemetryPurgeCounts {
 
 export const NO_TELEMETRY: TelemetryPurgeCounts = { series: 0, samples: 0 };
 
+interface CountRow {
+  n: unknown;
+  samples: unknown;
+}
+
 /** `count`/`sum` come back as strings over the wire; `sum` is null on an empty set. */
-function toCounts(row: { n: unknown; samples: unknown } | undefined): TelemetryPurgeCounts {
+function toCounts(row: CountRow | undefined): TelemetryPurgeCounts {
   if (!row) return NO_TELEMETRY;
   return { series: Number(row.n ?? 0), samples: Number(row.samples ?? 0) };
 }
@@ -44,12 +49,12 @@ export async function countRunTelemetry(
   workflowRunIds: readonly number[],
 ): Promise<TelemetryPurgeCounts> {
   if (workflowRunIds.length === 0) return NO_TELEMETRY;
-  const [row] = await sql`
+  const [row] = await sql<CountRow[]>`
     SELECT count(*)::int AS n, coalesce(sum(sample_count), 0)::bigint AS samples
     FROM gpu_metric_series
     WHERE workflow_run_id = ANY(${[...workflowRunIds]})
   `;
-  return toCounts(row as { n: unknown; samples: unknown } | undefined);
+  return toCounts(row);
 }
 
 /**
@@ -62,7 +67,7 @@ export async function deleteRunTelemetry(
   workflowRunIds: readonly number[],
 ): Promise<TelemetryPurgeCounts> {
   if (workflowRunIds.length === 0) return NO_TELEMETRY;
-  const [row] = await sql`
+  const [row] = await sql<CountRow[]>`
     WITH deleted AS (
       DELETE FROM gpu_metric_series
       WHERE workflow_run_id = ANY(${[...workflowRunIds]})
@@ -70,7 +75,7 @@ export async function deleteRunTelemetry(
     )
     SELECT count(*)::int AS n, coalesce(sum(sample_count), 0)::bigint AS samples FROM deleted
   `;
-  return toCounts(row as { n: unknown; samples: unknown } | undefined);
+  return toCounts(row);
 }
 
 /**
@@ -83,7 +88,7 @@ export async function unlinkPointTelemetry(
   benchmarkResultIds: readonly number[],
 ): Promise<number> {
   if (benchmarkResultIds.length === 0) return 0;
-  const [row] = await sql`
+  const [row] = await sql<Pick<CountRow, 'n'>[]>`
     WITH deleted AS (
       DELETE FROM benchmark_result_gpu_metrics
       WHERE benchmark_result_id = ANY(${[...benchmarkResultIds]})
@@ -91,7 +96,7 @@ export async function unlinkPointTelemetry(
     )
     SELECT count(*)::int AS n FROM deleted
   `;
-  return Number((row as { n: unknown } | undefined)?.n ?? 0);
+  return Number(row?.n ?? 0);
 }
 
 /** One-line summary for preview and transcript output. */
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
index 37d0a141b..55850a8fe 100644
--- a/packages/db/src/queries/gpu-metrics.ts
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -174,6 +174,20 @@ function toStatRow(raw: RawStatRow): GpuMetricStatRow {
   };
 }
 
+function groupBySeries<Raw extends { series_id: number | string }, Row>(
+  rows: readonly Raw[],
+  toRow: (raw: Raw) => Row,
+): Map<number, Row[]> {
+  const groups = new Map<number, Row[]>();
+  for (const raw of rows) {
+    const key = Number(raw.series_id);
+    const bucket = groups.get(key);
+    if (bucket) bucket.push(toRow(raw));
+    else groups.set(key, [toRow(raw)]);
+  }
+  return groups;
+}
+
 async function loadSeriesDetails(
   sql: DbClient,
   seriesRows: readonly RawSeriesRow[],
@@ -198,20 +212,8 @@ async function loadSeriesDetails(
     order by series_id, sampled_at, gpu_index
   `) as unknown as RawSampleRow[];
 
-  const statsBySeries = new Map<number, GpuMetricStatRow[]>();
-  for (const raw of statRows) {
-    const key = Number(raw.series_id);
-    const bucket = statsBySeries.get(key);
-    if (bucket) bucket.push(toStatRow(raw));
-    else statsBySeries.set(key, [toStatRow(raw)]);
-  }
-  const samplesBySeries = new Map<number, GpuMetricSampleRow[]>();
-  for (const raw of sampleRows) {
-    const key = Number(raw.series_id);
-    const bucket = samplesBySeries.get(key);
-    if (bucket) bucket.push(toSampleRow(raw));
-    else samplesBySeries.set(key, [toSampleRow(raw)]);
-  }
+  const statsBySeries = groupBySeries(statRows, toStatRow);
+  const samplesBySeries = groupBySeries(sampleRows, toSampleRow);
 
   return seriesRows.map((row) => {
     const id = Number(row.id);
diff --git a/packages/db/src/verify-power-publication.ts b/packages/db/src/verify-power-publication.ts
index 41038b292..069608be4 100644
--- a/packages/db/src/verify-power-publication.ts
+++ b/packages/db/src/verify-power-publication.ts
@@ -101,8 +101,7 @@ try {
     status:
       errors.length > 0 ? 'failed' : manifest.points.length > 0 ? 'matched' : 'no_power_points',
     errors,
-    // Kept out of `errors` on purpose: a telemetry digest failure costs one
-    // point's PowerX tab, not its benchmark data, so it must not fail the ingest.
+    // Non-fatal by design; see `fatalPublicationErrors`.
     telemetryWarnings: manifest.telemetryWarnings ?? [],
     ...(manifest.telemetry ? { telemetry: manifest.telemetry } : {}),
   };

From c425cd9fabd4e3eb96c326c91b466c35fd584d62 Mon Sep 17 00:00:00 2001
From: "claude[bot]" <209825114+claude[bot]@users.noreply.github.com>
Date: Thu, 24 Sep 2026 00:43:35 -0700
Subject: [PATCH 034/103] fix(powerx): keep telemetry point and run reads at
 one series version (#1218)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Readers assembled a series from three separate autocommit statements, so a
re-ingest committing between the digest and sample reads returned the old
statistics beside the new samples. Verify the series version key
(csv_sha256, sample_count, ingested_at) after loading and retry the read
when it changed. Adds a regression test that interleaves a committed
re-ingest between the reader's statements.

中文：读取器此前通过三条独立的自动提交语句组装遥测序列，若重新导入在读取统计摘要与样本之间提交，会返回旧的统计与新的样本。现在在加载后校验序列版本键（csv_sha256、sample_count、ingested_at），若发生变化则重试读取；并新增在读取语句之间插入已提交重新导入的回归测试。


Claude-Session: https://claude.ai/code/session_014RnMNzhay2Tdden2kWyeRx

Co-authored-by: Claude <noreply@anthropic.com>
---
 docs/data-pipeline.md                         |   6 +
 docs/powerx-persistence-recovery.md           |   5 +-
 .../gpu-metrics.reingest-consistency.test.ts  | 299 ++++++++++++++++++
 packages/db/src/queries/gpu-metrics.ts        |  76 ++++-
 4 files changed, 383 insertions(+), 3 deletions(-)
 create mode 100644 packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts

diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index 8b4fac9f2..f1090f22b 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -580,6 +580,12 @@ job share one series across points. Windowing a series to the measured serving
 interval is a reader concern; the raw series deliberately includes server
 start-up and warm-up so both phases can be inspected.
 
+The point and run readers assemble a series from separate autocommit statements
+(series rows, statistics, samples). After loading, they re-read the series
+version key (`csv_sha256`, `sample_count`, `ingested_at`) and retry the whole
+read when a re-ingest committed in between, so one payload never mixes the
+statistics of one version with the samples of another.
+
 `bun run admin:db:backfill-gpu-metrics --all --yes` attaches telemetry for runs
 ingested before this migration. The reachable history is bounded by GitHub's
 90-day artifact retention (the upload step sets no `retention-days`) because the
diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
index 06f5ee1bd..e195008ff 100644
--- a/docs/powerx-persistence-recovery.md
+++ b/docs/powerx-persistence-recovery.md
@@ -82,7 +82,10 @@ Blob cache. The revision includes linked series, ingest time, CSV hash, sidecars
 point links/audits. The payload stays in Blob; the revision query reads only metadata.
 Same-input ingest leaves the revision unchanged. A sidecar correction, series replacement,
 new point link or linked audit correction selects a new cache entry, including for every
-point sharing the series. Missing points are not negatively cached.
+point sharing the series. Missing points are not negatively cached. A re-ingest that
+commits while the reader is between its statements changes the series version key
+(`csv_sha256`, `sample_count`, `ingested_at`), which the reader re-checks after loading
+and retries, so a payload never mixes statistics and samples from two versions.
 
 Point and Timeline responses use `Cache-Control: no-store`, so CDN/browser response caches
 cannot skip the database check. Client queries revalidate on mount and window focus.
diff --git a/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts b/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
new file mode 100644
index 000000000..8a7a430ca
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
@@ -0,0 +1,299 @@
+/**
+ * Re-ingest consistency of the PowerX telemetry read path.
+ *
+ * Property under test: a reader of one benchmark point never observes samples
+ * and per-GPU statistics that come from different versions of the same series.
+ *
+ * `upsertGpuMetricSeries` replaces samples and stats inside one `sql.begin`
+ * transaction, so the write side is atomic. `getGpuMetricsForPoint` ->
+ * `loadSeriesDetails`, however, issues separate autocommit statements (series
+ * rows, then `gpu_metric_gpu_stats`, then `gpu_metric_samples`). In production
+ * the DbClient is either neon() HTTP (one implicit transaction per call) or a
+ * postgres.js pool used without a transaction, so a re-ingest can commit between
+ * the stats and the samples statement. The reader re-checks the series version
+ * key afterwards and restarts the read when it moved.
+ *
+ * PGlite is single-connection, so the interleaving is simulated at statement
+ * granularity: after the stats statement returns, a full re-ingest transaction
+ * runs and commits before the samples statement executes. Under READ COMMITTED
+ * this is observationally identical to a second connection committing between
+ * the two autocommit statements.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import type { DbClient } from '../connection';
+import { ingestGpuMetricsArtifact } from '../etl/gpu-metrics-ingest';
+import {
+  getGpuMetricsForPoint,
+  type GpuMetricSeries,
+  TelemetrySnapshotChangedError,
+} from './gpu-metrics';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+/** Writer handle: the ingest code calls `sql.begin`, `sql.array`, `sql.json`. */
+let sql: Sql;
+/** Reader handle: plain autocommit statements, as the app's DbClient issues them. */
+let reader: DbClient;
+const roots: string[] = [];
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query<Record<string, unknown>>(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, {
+    json: JSON.stringify,
+    array: (value: unknown) => value,
+  });
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  // The point reader aggregates benchmark_results.power_audit (migration 015).
+  await db.exec('ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb');
+  sql = Object.assign(queryClient(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(queryClient(tx) as unknown as Sql)),
+  }) as unknown as Sql;
+  reader = queryClient(db) as DbClient;
+}, 20_000);
+
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+    VALUES (1, 34557177019, 1, 'Run Sweep', 'completed', 'success', '2026-09-11', '2026-09-11');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 4, 4, 4, 4);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+           (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}');`);
+});
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+afterAll(async () => {
+  await db?.close();
+});
+
+/** Version 1: 2 GPUs x 2 distinct timestamps (+ duplicate flush row) = 4 unique samples. */
+const NVIDIA_CSV_V1 = [
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+  '2026/09/11 04:19:41.982, 0, 187.80 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:41.986, 1, 190.96 W, 39, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:42.990, 0, 912.10 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+  // Duplicate flush of the last sample, as emitted when the monitor stops.
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+].join('\n');
+
+/**
+ * Version 1 + `extraScrapes` further scrapes per GPU, each at a distinct
+ * timestamp, so every version has a distinct CSV digest and sample count.
+ */
+function csvVersion(extraScrapes: number): string {
+  const lines = [NVIDIA_CSV_V1];
+  for (let i = 0; i < extraScrapes; i += 1) {
+    const second = String(43 + i).padStart(2, '0');
+    lines.push(
+      `2026/09/11 04:19:${second}.990, 0, 700.00 W, 60, 1900 MHz, 3996 MHz, 90 %, 70 %`,
+      `2026/09/11 04:19:${second}.994, 1, 702.50 W, 61, 1900 MHz, 3996 MHz, 91 %, 71 %`,
+    );
+  }
+  return lines.join('\n');
+}
+
+/** Version 2: the same artifact re-uploaded with one more scrape per GPU = 6 unique samples. */
+const NVIDIA_CSV_V2 = csvVersion(1);
+/** Version 3: one more scrape per GPU again = 8 unique samples. */
+const NVIDIA_CSV_V3 = csvVersion(2);
+
+const V1_UNIQUE_SAMPLES = 4;
+const V2_UNIQUE_SAMPLES = 6;
+const V3_UNIQUE_SAMPLES = 8;
+
+function writeArtifact(csv: string, contextZone = 'UTC') {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-reingest-'));
+  roots.push(root);
+  const artifactName = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+  const artifactDir = path.join(root, artifactName);
+  fs.mkdirSync(artifactDir);
+  fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_context.json'),
+    JSON.stringify({ timestamp_timezone: contextZone }),
+  );
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_identity.csv'),
+    'index, uuid, name\n0, GPU-a, NVIDIA B200\n1, GPU-b, NVIDIA B200\n',
+  );
+  return { artifactName, artifactDir };
+}
+
+function ingest(csv: string) {
+  return ingestGpuMetricsArtifact(sql, {
+    workflowRunId: 1,
+    artifact: writeArtifact(csv),
+    benchmarkResultIds: [10],
+  });
+}
+
+interface InterleavedReader {
+  client: DbClient;
+  /** How many times the reader issued its first statement (the point's series rows). */
+  seriesReads: () => number;
+}
+
+/**
+ * A DbClient that forwards every statement to `base`, but after each
+ * `gpu_metric_gpu_stats` statement has returned (and before the caller gets
+ * the rows back), runs `between(statsReadIndex)` to completion. With a
+ * committed re-ingest in `between`, this is the schedule: reader(series),
+ * reader(stats), WRITER COMMITS, reader(samples), reader(version check).
+ */
+function interleaveAfterStats(
+  base: DbClient,
+  between: (statsReadIndex: number) => Promise<unknown>,
+): InterleavedReader {
+  let statsReads = 0;
+  let seriesReads = 0;
+  const client: DbClient = async (strings, ...values) => {
+    const text = strings.join('');
+    if (/from benchmark_result_gpu_metrics link/.test(text)) seriesReads += 1;
+    const rows = await base(strings, ...values);
+    if (/from gpu_metric_gpu_stats/.test(text)) {
+      statsReads += 1;
+      await between(statsReads);
+    }
+    return rows;
+  };
+  return { client, seriesReads: () => seriesReads };
+}
+
+/**
+ * The consistency property: every statistic row was computed over exactly the
+ * sample rows returned in the same payload, and the series header agrees.
+ */
+function expectCoherent(series: GpuMetricSeries) {
+  for (const stat of series.stats) {
+    const rowsForGpu = series.data.filter((row) => row.index === stat.gpuIndex).length;
+    expect(stat.count, `stats.count for gpu ${stat.gpuIndex}/${stat.metric}`).toBe(rowsForGpu);
+  }
+  expect(series.sampleCount, 'series.sampleCount vs data.length').toBe(series.data.length);
+}
+
+describe('getGpuMetricsForPoint under telemetry re-ingest', () => {
+  it('serial read after re-ingest is coherent', async () => {
+    const first = await ingest(NVIDIA_CSV_V1);
+    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
+    const second = await ingest(NVIDIA_CSV_V2);
+    expect(second.samplesInserted).toBe(V2_UNIQUE_SAMPLES);
+    expect(second.seriesIds).toEqual(first.seriesIds);
+
+    const payload = await getGpuMetricsForPoint(reader, 10);
+    expect(payload?.series).toHaveLength(1);
+    for (const series of payload!.series) {
+      expect(series.sampleCount).toBe(V2_UNIQUE_SAMPLES);
+      expectCoherent(series);
+    }
+  });
+
+  it('a re-ingest committed between the stats and samples statements yields one version', async () => {
+    const first = await ingest(NVIDIA_CSV_V1);
+    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
+
+    let reingest: Awaited<ReturnType<typeof ingest>> | undefined;
+    const interleaved = interleaveAfterStats(reader, async (statsReadIndex) => {
+      if (statsReadIndex === 1) reingest = await ingest(NVIDIA_CSV_V2);
+    });
+
+    const payload = await getGpuMetricsForPoint(interleaved.client, 10);
+
+    // The writer really did replace the series inside its own transaction.
+    expect(reingest?.samplesInserted).toBe(V2_UNIQUE_SAMPLES);
+    expect(reingest?.seriesIds).toEqual(first.seriesIds);
+    expect(payload?.series).toHaveLength(1);
+    // The version key moved, so the reader restarted from the series statement.
+    expect(interleaved.seriesReads()).toBe(2);
+
+    for (const series of payload!.series) {
+      expect(series.sampleCount).toBe(V2_UNIQUE_SAMPLES);
+      expect(series.data).toHaveLength(V2_UNIQUE_SAMPLES);
+      for (const stat of series.stats) expect(stat.count).toBe(V2_UNIQUE_SAMPLES / 2);
+      expectCoherent(series);
+    }
+  });
+
+  it('an identical re-ingest committed between the stats and samples statements is coherent', async () => {
+    const first = await ingest(NVIDIA_CSV_V1);
+    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
+
+    let reingest: Awaited<ReturnType<typeof ingest>> | undefined;
+    const interleaved = interleaveAfterStats(reader, async (statsReadIndex) => {
+      if (statsReadIndex === 1) reingest = await ingest(NVIDIA_CSV_V1);
+    });
+
+    const payload = await getGpuMetricsForPoint(interleaved.client, 10);
+
+    // Unchanged digest, sidecars and sample count: the no-op path wrote nothing.
+    expect(reingest?.samplesInserted).toBe(0);
+    expect(reingest?.seriesSkipped).toBe(1);
+    expect(payload?.series).toHaveLength(1);
+    // Same version key, so no retry.
+    expect(interleaved.seriesReads()).toBe(1);
+
+    for (const series of payload!.series) {
+      expect(series.sampleCount).toBe(V1_UNIQUE_SAMPLES);
+      expectCoherent(series);
+    }
+  });
+
+  it('converges when a second re-ingest lands during the retry', async () => {
+    const first = await ingest(NVIDIA_CSV_V1);
+    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
+
+    const interleaved = interleaveAfterStats(reader, async (statsReadIndex) => {
+      if (statsReadIndex === 1) await ingest(NVIDIA_CSV_V2);
+      if (statsReadIndex === 2) await ingest(NVIDIA_CSV_V3);
+    });
+
+    const payload = await getGpuMetricsForPoint(interleaved.client, 10);
+
+    expect(payload?.series).toHaveLength(1);
+    expect(interleaved.seriesReads()).toBe(3);
+    for (const series of payload!.series) {
+      expect(series.sampleCount).toBe(V3_UNIQUE_SAMPLES);
+      expect(series.data).toHaveLength(V3_UNIQUE_SAMPLES);
+      expectCoherent(series);
+    }
+  });
+
+  it('gives up after three attempts when the series keeps changing', async () => {
+    const first = await ingest(NVIDIA_CSV_V1);
+    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
+
+    const interleaved = interleaveAfterStats(reader, async (statsReadIndex) => {
+      // Every attempt sees a fresh, distinct version committed under it.
+      await ingest(csvVersion(statsReadIndex));
+    });
+
+    await expect(getGpuMetricsForPoint(interleaved.client, 10)).rejects.toBeInstanceOf(
+      TelemetrySnapshotChangedError,
+    );
+    expect(interleaved.seriesReads()).toBe(3);
+  });
+});
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
index 37d0a141b..2597b2f6c 100644
--- a/packages/db/src/queries/gpu-metrics.ts
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -97,6 +97,16 @@ interface RawSeriesRow {
   sidecars: Record<string, unknown> | string;
   benchmark_result_ids: (number | string)[] | null;
   power_audits: Record<string, unknown>[] | null;
+  csv_sha256: string;
+  ingested_at: string | Date;
+}
+
+/** The columns `upsertGpuMetricSeries` rewrites whenever it replaces a series. */
+interface RawSeriesVersionRow {
+  id: number | string;
+  csv_sha256: string;
+  sample_count: number;
+  ingested_at: string | Date;
 }
 
 interface RawStatRow {
@@ -138,6 +148,34 @@ const isoString = (value: string | Date): string =>
 
 const optional = (value: number | null): number | undefined => (value === null ? undefined : value);
 
+/**
+ * Thrown by the point/run readers when a series was replaced while its parts
+ * were being read; the caller restarts the whole read (links may have changed).
+ */
+export class TelemetrySnapshotChangedError extends Error {
+  constructor(seriesIds: readonly number[]) {
+    super(`gpu_metric_series ${seriesIds.join(', ')} changed while being read`);
+    this.name = 'TelemetrySnapshotChangedError';
+  }
+}
+
+const MAX_SNAPSHOT_ATTEMPTS = 3;
+
+const seriesVersionKey = (row: RawSeriesVersionRow): string =>
+  `${Number(row.id)}:${row.csv_sha256}:${Number(row.sample_count)}:${isoString(row.ingested_at)}`;
+
+async function withConsistentSnapshot<T>(read: () => Promise<T>): Promise<T> {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return await read();
+    } catch (error) {
+      if (!(error instanceof TelemetrySnapshotChangedError) || attempt >= MAX_SNAPSHOT_ATTEMPTS) {
+        throw error;
+      }
+    }
+  }
+}
+
 function toSampleRow(raw: RawSampleRow): GpuMetricSampleRow {
   return {
     timestamp: isoString(raw.sampled_at),
@@ -198,6 +236,24 @@ async function loadSeriesDetails(
     order by series_id, sampled_at, gpu_index
   `) as unknown as RawSampleRow[];
 
+  // The three statements above run as separate autocommit queries (the DbClient
+  // has no transaction), so a re-ingest can commit between them. The writer
+  // replaces samples, stats and the series row in one transaction and stamps
+  // `ingested_at`, so a version key that is unchanged after the samples were
+  // read proves stats and samples belong to the same series version.
+  const versionRows = (await sql`
+    select id, csv_sha256, sample_count, ingested_at
+    from gpu_metric_series
+    where id = any(${ids}::bigint[])
+  `) as unknown as RawSeriesVersionRow[];
+  const versionKeys = new Set(versionRows.map(seriesVersionKey));
+  if (
+    versionRows.length !== seriesRows.length ||
+    !seriesRows.every((row) => versionKeys.has(seriesVersionKey(row)))
+  ) {
+    throw new TelemetrySnapshotChangedError(ids);
+  }
+
   const statsBySeries = new Map<number, GpuMetricStatRow[]>();
   for (const raw of statRows) {
     const key = Number(raw.series_id);
@@ -243,7 +299,14 @@ async function loadSeriesDetails(
  * Returns null when the run is unknown or has no stored series, so callers can
  * fall back to the live GitHub artifacts for in-flight runs.
  */
-export async function getGpuMetricsForRun(
+export function getGpuMetricsForRun(
+  sql: DbClient,
+  githubRunId: number,
+): Promise<GpuMetricsRunPayload | null> {
+  return withConsistentSnapshot(() => readGpuMetricsForRun(sql, githubRunId));
+}
+
+async function readGpuMetricsForRun(
   sql: DbClient,
   githubRunId: number,
 ): Promise<GpuMetricsRunPayload | null> {
@@ -273,6 +336,7 @@ export async function getGpuMetricsForRun(
   const seriesRows = (await sql`
     select s.id, s.workflow_run_id, s.artifact_name, s.config_key, s.file_name, s.vendor,
       s.sample_interval_s, s.sample_count, s.gpu_count, s.started_at, s.ended_at, s.sidecars,
+      s.csv_sha256, s.ingested_at,
       (
         select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
         from benchmark_result_gpu_metrics l where l.series_id = s.id
@@ -313,13 +377,21 @@ export interface GpuMetricsPointPayload {
 }
 
 /** Series linked to one benchmark point, with samples. Null when none is linked. */
-export async function getGpuMetricsForPoint(
+export function getGpuMetricsForPoint(
+  sql: DbClient,
+  benchmarkResultId: number,
+): Promise<GpuMetricsPointPayload | null> {
+  return withConsistentSnapshot(() => readGpuMetricsForPoint(sql, benchmarkResultId));
+}
+
+async function readGpuMetricsForPoint(
   sql: DbClient,
   benchmarkResultId: number,
 ): Promise<GpuMetricsPointPayload | null> {
   const seriesRows = (await sql`
     select s.id, s.workflow_run_id, s.artifact_name, s.config_key, s.file_name, s.vendor,
       s.sample_interval_s, s.sample_count, s.gpu_count, s.started_at, s.ended_at, s.sidecars,
+      s.csv_sha256, s.ingested_at,
       (
         select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
         from benchmark_result_gpu_metrics l where l.series_id = s.id

From 3895ce65e53cb468cc562b0d76c9dfa09ea26251 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Thu, 24 Sep 2026 15:58:51 -0700
Subject: [PATCH 035/103] feat: add PowerX same-load, role and fit panels
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Same-concurrency table pairs two exact sources at identical load, with no
interpolation. Role group plots prefill/decode power, energy and share with
explicit denominators. Power fit gives per-source least squares: intercept,
marginal J/token, R², fitted range and TDP. i_powerfit toggles the fit.

中文：新增 PowerX 同负载、角色与拟合面板。同并发表按完全相同的负载配对两个来源，
不做插值；角色组展示 prefill/decode 功耗、能耗与占比，并标明分母；功耗拟合按来源
给出最小二乘截距、边际 J/token、R²、拟合范围与 TDP。i_powerfit 控制拟合面板。
---
 .../component/power-service-comparison.cy.tsx | 227 ++++++++++-
 .../components/inference/ui/ChartDisplay.tsx  |   9 +
 .../inference/ui/MatchedConcurrencyTable.tsx  | 218 +++++++++++
 .../components/inference/ui/PowerFitPanel.tsx | 234 ++++++++++++
 .../inference/ui/PowerPanelPlot.tsx           | 196 ++++++++++
 .../inference/ui/PowerRoleGroup.tsx           | 326 ++++++++++++++++
 .../inference/ui/PowerServiceComparison.tsx   | 355 ++++++++----------
 .../utils/equal-service-comparison.test.ts    |  54 +++
 .../utils/equal-service-comparison.ts         |  75 +++-
 .../utils/matched-concurrency.test.ts         | 149 ++++++++
 .../inference/utils/matched-concurrency.ts    | 128 +++++++
 .../inference/utils/power-fit.test.ts         | 163 ++++++++
 .../components/inference/utils/power-fit.ts   | 122 ++++++
 .../inference/utils/resolveXAxisField.ts      |  26 +-
 packages/app/src/lib/api-route-catalog.ts     |   8 +-
 packages/app/src/lib/url-state.ts             |   2 +
 16 files changed, 2065 insertions(+), 227 deletions(-)
 create mode 100644 packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerFitPanel.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerPanelPlot.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerRoleGroup.tsx
 create mode 100644 packages/app/src/components/inference/utils/matched-concurrency.test.ts
 create mode 100644 packages/app/src/components/inference/utils/matched-concurrency.ts
 create mode 100644 packages/app/src/components/inference/utils/power-fit.test.ts
 create mode 100644 packages/app/src/components/inference/utils/power-fit.ts

diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
index 3ca436d2e..d35f695ae 100644
--- a/packages/app/cypress/component/power-service-comparison.cy.tsx
+++ b/packages/app/cypress/component/power-service-comparison.cy.tsx
@@ -59,6 +59,7 @@ const comparator = [
   }),
 ];
 const data = [...baseline, ...comparator];
+const OVERLAY_RUN_URL = 'https://example.invalid/runs/900000002';
 const baseKey = equalServiceSourceKey(baseline[0]);
 const peerKey = equalServiceSourceKey(comparator[0]);
 const roles = [40, 50, 60].map((share, index) =>
@@ -80,21 +81,84 @@ const roles = [40, 50, 60].map((share, index) =>
   }),
 );
 
-function mountComparison(points = data, xField: keyof AggDataEntry = 'mean_tpot_intvty') {
+// Validated role telemetry on the same three disaggregated observations.
+const measuredRoles = roles.map((entry, index) => ({
+  ...entry,
+  measuredPrefillAvgPower: metric(800 + 10 * index),
+  measuredDecodeAvgPower: metric(600 + 10 * index),
+  measuredPrefillJPerInputToken: metric(entry.prefill_joules_per_input_token!),
+  measuredDecodeJPerOutputToken: metric(entry.decode_joules_per_output_token!),
+}));
+// W/GPU = 250 + 0.5 × output tok/s/GPU on four loads of one source.
+const fitLadder = [20, 60, 120, 260].map((rate, index) =>
+  point({
+    id: 20 + index,
+    conc: 2 ** index,
+    mean_tpot_intvty: 100 - 20 * index,
+    output_tput_per_gpu: rate,
+    measuredAvgPower: metric(250 + 0.5 * rate),
+    measuredJPerOutputToken: metric((250 + 0.5 * rate) / rate),
+  }),
+);
+
+function mountComparison(
+  points = data,
+  xField: keyof AggDataEntry = 'mean_tpot_intvty',
+  overlay: InferenceData[] = [],
+) {
   mountWithProviders(
     <PathnameContext.Provider value="/inference">
       <div style={{ width: '100%', maxWidth: 1120, padding: 12, boxSizing: 'border-box' }}>
         <PowerServiceComparison
-          data={points}
+          data={[...points, ...overlay]}
+          overlayData={overlay}
           xField={xField}
           xLabel={xField === 'conc' ? 'Concurrency' : 'Mean interactivity (output tok/s/user)'}
+          interactivityField="mean_tpot_intvty"
           chartId="power-service-test"
         />
       </div>
     </PathnameContext.Provider>,
-    { inference: {}, unofficial: {} },
+    {
+      inference: {},
+      unofficial: overlay.length > 0 ? { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } } : {},
+    },
   );
 }
+type CsvWindow = Cypress.AUTWindow & { __csv?: Blob };
+/** Keep the next CSV download in memory instead of saving it. */
+function captureCsv() {
+  cy.window().then((win) => {
+    cy.stub(win.URL, 'createObjectURL').callsFake((blob: Blob) => {
+      (win as CsvWindow).__csv = blob;
+      return 'blob:csv-test';
+    });
+    cy.stub(win.HTMLAnchorElement.prototype, 'click');
+  });
+}
+function exportCsv(sectionId: string): Cypress.Chainable<string[][]> {
+  cy.get(`#${sectionId} [data-testid="export-button"]`).click();
+  cy.get('[data-testid="export-csv-button"]').click();
+  return cy
+    .window()
+    .then((win) => (win as CsvWindow).__csv!.text())
+    .then((text) =>
+      text
+        .split('\n')
+        .filter((line) => !line.startsWith('#'))
+        .map((line) => line.split(',')),
+    );
+}
+const plotValues = (plot: string) =>
+  cy
+    .get<SVGCircleElement & { __data__: { y: number } }>(
+      `[data-testid="power-service-test-${plot}-plot"] circle.point`,
+    )
+    .then(($points) => [...$points].map((element) => element.__data__.y).toSorted((a, b) => a - b));
+const closeTo = (actual: number[], expected: number[]) => {
+  expect(actual).to.have.length(expected.length);
+  actual.forEach((value, index) => expect(value).to.be.closeTo(expected[index], 1e-9));
+};
 const normalizedText = (element: JQuery<HTMLElement>) => element.text().replaceAll('−', '-');
 const target = () => cy.get('[data-testid="equal-service-target"]');
 const row = (metricName: string) => cy.get(`[data-testid="equal-service-${metricName}"]`);
@@ -116,6 +180,7 @@ describe('PowerServiceComparison', () => {
     writeUrlParams({
       i_servicecompare: '0',
       i_roleshare: '0',
+      i_powerfit: '0',
       i_servicebase: '',
       i_servicepeer: '',
       i_servicetarget: '',
@@ -248,4 +313,160 @@ describe('PowerServiceComparison', () => {
       overwrite: true,
     });
   });
+  it('pairs sources at each observed concurrency and marks loads measured once or twice', () => {
+    captureCsv();
+    mountComparison([
+      ...data,
+      point({
+        id: 5,
+        conc: 64,
+        mean_tpot_intvty: 10,
+        measuredAvgPower: metric(300),
+        measuredJPerOutputToken: metric(5),
+      }),
+      // A second baseline observation at c8 that disagrees with the first.
+      point({ id: 6, measuredAvgPower: metric(420), measuredJPerOutputToken: metric(11) }),
+    ]);
+    cy.get('[data-testid="equal-service-toggle"]').check();
+    cy.get('[data-testid="matched-concurrency-table"] tbody tr').should('have.length', 3);
+    cy.get('[data-testid="matched-concurrency-row-1"]').should(($row) => {
+      const text = normalizedText($row);
+      expect(text).to.include('30.000').and.include('16.000').and.include('-46.7%');
+      expect(text).to.include('W/GPU +25.0%').and.include('tok/s/user +0.0%');
+    });
+    cy.get('[data-testid="matched-concurrency-row-8"] td')
+      .eq(0)
+      .should('contain.text', '2 conflicting observations; none selected');
+    cy.get('[data-testid="matched-concurrency-row-64"] td')
+      .eq(1)
+      .should('have.text', 'Not measured');
+    exportCsv('power-service-test-matched-concurrency').then((rows) => {
+      const [header, ...body] = rows;
+      expect(header.slice(0, 3)).to.deep.equal([
+        'concurrency',
+        'baseline_status',
+        'baseline_j_per_output_token',
+      ]);
+      expect(body.map((cells) => [cells[0], cells[1], cells[7]])).to.deep.equal([
+        ['1', 'observed', 'observed'],
+        ['8', 'ambiguous', 'observed'],
+        ['64', 'observed', 'missing'],
+      ]);
+    });
+  });
+
+  it('keeps load-matched rows in concurrency mode and follows the chosen direction on mobile', () => {
+    cy.viewport(390, 1000);
+    mountComparison(data, 'conc');
+    cy.get('[data-testid="equal-service-toggle"]').check();
+    cy.get('[data-testid="equal-service-concurrency-note"]').should('be.visible');
+    cy.get('[data-testid="equal-service-panel"]').should('not.exist');
+    cy.get('[data-testid="equal-service-baseline"]').select(peerKey);
+    cy.get('[data-testid="equal-service-comparator"]').select(baseKey);
+    // B300 c8 is 8 J and 800 W; B200 c8 is 10 J and 400 W.
+    cy.get('[data-testid="matched-concurrency-row-8"]').should(($row) => {
+      const text = normalizedText($row);
+      expect(text).to.include('+25.0%').and.include('W/GPU -50.0%');
+    });
+    checkNoHorizontalOverflow();
+    cy.get('[data-testid="matched-concurrency-panel"]').screenshot('matched-concurrency-mobile', {
+      overwrite: true,
+    });
+  });
+
+  it('draws role power, both energy denominators and the share from the same observations', () => {
+    cy.viewport(1280, 1400);
+    captureCsv();
+    mountComparison(measuredRoles);
+    cy.get('[data-testid="role-share-toggle"]').check();
+    plotValues('role-power').should((values) => closeTo(values, [600, 610, 620, 800, 810, 820]));
+    // Role-local: prefill J/input token beside decode J/output token.
+    plotValues('role-local-energy').should((values) => closeTo(values, [0.8, 1, 1.2, 4, 5, 6]));
+    // Output-token basis: prefill 0.8 J/in × (10 J/out ÷ 2 J/in) = 4, decode 6, total 10.
+    plotValues('role-output-energy').should((values) =>
+      closeTo(values, [4, 4, 5, 5, 6, 6, 10, 10, 10]),
+    );
+    plotValues('role-share').should((values) => closeTo(values, [40, 50, 60]));
+    cy.get('[data-testid="power-service-test-role-power-plot"] path.line-path')
+      .should('have.length', 2)
+      .then(($paths) =>
+        expect([...$paths].map((path) => path.getAttribute('stroke-dasharray'))).to.have.members([
+          '7 3',
+          '2 3',
+        ]),
+      );
+    exportCsv('power-service-test-roles').then((rows) => {
+      const [header, ...body] = rows;
+      const column = (name: string) => body.map((cells) => Number(cells[header.indexOf(name)]));
+      expect(body).to.have.length(3);
+      closeTo(column('prefill_j_per_output_token'), [4, 5, 6]);
+      closeTo(column('total_j_per_output_token'), [10, 10, 10]);
+      closeTo(column('prefill_energy_share_pct'), [40, 50, 60]);
+    });
+    checkNoHorizontalOverflow();
+    cy.get('[data-testid="prefill-share-panel"]').screenshot('power-roles-desktop', {
+      overwrite: true,
+    });
+  });
+
+  it('fits power against output rate per source and states the fitted range', () => {
+    cy.viewport(1280, 1200);
+    captureCsv();
+    mountComparison([...fitLadder, ...comparator]);
+    cy.get('[data-testid="power-fit-toggle"]').check();
+    cy.get('[data-testid="power-fit-row"]').should('have.length', 2);
+    cy.get('[data-testid="power-fit-row"]')
+      .eq(0)
+      .find('td')
+      .then(($cells) =>
+        expect([...$cells].map((cell) => cell.textContent)).to.deep.equal([
+          '250',
+          '25% · 1,000 W',
+          '0.500',
+          '1.000',
+          '4',
+          '20.0–260.0',
+        ]),
+      );
+    cy.get('[data-testid="power-fit-row"]')
+      .eq(1)
+      .should('contain.text', 'Not fitted: needs 3 distinct output rates, has 2.');
+    // One solid fitted segment plus the dashed extension to zero output.
+    cy.get('[data-testid="power-service-test-power-fit-plot"] path.line-path')
+      .should('have.length', 2)
+      .then(($paths) =>
+        expect([...$paths].map((path) => path.getAttribute('stroke-dasharray'))).to.have.members([
+          'none',
+          '4 4',
+        ]),
+      );
+    cy.get('[data-testid="power-service-test-power-fit-plot"] circle.point').should(
+      'have.length',
+      6,
+    );
+    cy.then(() => expect(new URL(buildShareUrl()).searchParams.get('i_powerfit')).to.equal('1'));
+    exportCsv('power-service-test-power-fit').then(([header, first, second]) => {
+      expect(header).to.include('p0_over_tdp');
+      expect(Number(first[header.indexOf('m_j_per_output_token')])).to.be.closeTo(0.5, 1e-9);
+      expect(second[header.indexOf('status')]).to.equal('too-few-points');
+    });
+    cy.get('[data-testid="power-fit-panel"]').screenshot('power-fit-desktop', { overwrite: true });
+  });
+
+  it('colours ?unofficialrun= sources with their run colour in every panel', () => {
+    mountComparison([...fitLadder], 'mean_tpot_intvty', comparator);
+    cy.get('[data-testid="power-fit-toggle"]').check();
+    cy.get(
+      '[data-testid="power-service-test-power-fit-plot"] circle.point[fill="var(--overlay-run-0)"]',
+    ).should('have.length', 2);
+    cy.get('[data-testid="power-service-test-power-fit-plot"] circle.point')
+      .not('[fill="var(--overlay-run-0)"]')
+      .should('have.length', 4);
+    cy.get('[data-testid="equal-service-toggle"]').check();
+    cy.get('[data-testid="equal-service-comparator"] option:selected').should(
+      'contain.text',
+      '900000002',
+    );
+    cy.get('[data-testid="matched-concurrency-row-8"]').should('exist');
+  });
 });
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index eb1575b82..5577c1138 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -46,6 +46,7 @@ import {
   makeRunComparisonEntry,
 } from '@/components/inference/utils/comparisonEntry';
 import { dataRunsForDate } from '@/components/inference/utils/runEnumeration';
+import { resolveServiceField } from '@/components/inference/utils/resolveXAxisField';
 import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
 import { bestSeriesPerSku } from '@/components/inference/utils/best-series-per-sku';
 import InferenceTable from '@/components/inference/ui/InferenceTable';
@@ -737,6 +738,12 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
   }, [effectiveGraphs, selectedXAxisMode]);
 
   const isAgenticSequence = sequenceKind(selectedSequence) === 'agentic';
+  // Streaming speed at the selected statistic, read by the load-matched PowerX rows.
+  const serviceInteractivityField = resolveServiceField('median_intvty', {
+    isAgentic: isAgenticSequence,
+    percentile: selectedPercentile,
+    fixedSequenceStatistic,
+  });
   const residentPointIds = useMemo(() => {
     if (!isAgenticSequence) return [] as number[];
     const ids = new Set<number>();
@@ -1346,8 +1353,10 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                             chartId={`chart-${graphIndex}`}
                             contextLabel={`${getModelLabel(selectedModel)} · ${getSequenceLabel(selectedSequence)}`}
                             data={[...officialRows, ...overlayRows]}
+                            overlayData={overlayRows}
                             xField={graph.chartDefinition.x_scale_field as keyof AggDataEntry}
                             xLabel={resolvedXLabel}
+                            interactivityField={serviceInteractivityField}
                           />
                         );
                       })()}
diff --git a/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx b/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
new file mode 100644
index 000000000..a3ad3c7ca
--- /dev/null
+++ b/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
@@ -0,0 +1,218 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { Heading } from '@/components/ui/heading';
+import { exportToCsv } from '@/lib/csv-export';
+import { useLocale } from '@/lib/use-locale';
+import type { AggDataEntry, InferenceData } from '../types';
+import {
+  buildMatchedConcurrencyTable,
+  type MatchedConcurrencySide,
+} from '../utils/matched-concurrency';
+
+const STRINGS = {
+  en: {
+    title: 'Matched concurrency (load diagnostic)',
+    method:
+      'Observations of the two sources at the same concurrency. Matched load is not matched service: at one concurrency the sources usually serve different speeds, so use the comparison above for equal service. Change = (comparator ÷ baseline − 1) × 100%.',
+    scope:
+      'Each cell is one observation of the selected source; repeated dispatches are separate sources and are not averaged. Measured GPU energy excludes host-system and facility power.',
+    concurrency: 'Concurrency',
+    baseline: 'Baseline',
+    comparator: 'Comparator',
+    change: 'Change',
+    energy: 'J/output token',
+    speed: 'tok/s/user',
+    power: 'W/GPU',
+    missing: 'Not measured',
+    ambiguous: (count: number) => `${count} conflicting observations; none selected`,
+    metricMissing: 'Energy not reported',
+    energyChange: 'GPU energy',
+    empty: 'Neither source has an observation with a positive concurrency.',
+    unavailable: 'Choose two different available sources.',
+  },
+  zh: {
+    title: '相同并发下的对照（负载诊断）',
+    method:
+      '在相同并发数下对比两个数据源的观测值。相同负载不等于相同服务水平：同一并发数下两者的生成速度通常不同，如需在相同服务水平下比较，请使用上方的对比。变化 =（对比对象 ÷ 基准 − 1）× 100%。',
+    scope:
+      '每个单元格是所选数据源的一次观测；重复运行计为不同的数据源，不做平均。实测 GPU 能耗不含主机系统和数据中心设施功耗。',
+    concurrency: '并发数',
+    baseline: '基准',
+    comparator: '对比对象',
+    change: '变化',
+    energy: 'J/输出 token',
+    speed: 'tok/s/user',
+    power: 'W/GPU',
+    missing: '未测量',
+    ambiguous: (count: number) => `${count} 个观测值相互冲突，均未采用`,
+    metricMissing: '未报告能耗',
+    energyChange: 'GPU 能耗',
+    empty: '两个数据源都没有并发数为正的观测值。',
+    unavailable: '请选择两个不同且可用的数据源。',
+  },
+};
+
+const joules = d3.format(',.3f');
+const watts = d3.format(',.0f');
+const speed = d3.format(',.1f');
+const signed = d3.format('+.1f');
+const percent = (value: number | null) => (value === null ? '—' : `${signed(value)}%`);
+const sideColumns = (side: MatchedConcurrencySide) =>
+  side.status === 'observed'
+    ? [
+        side.status,
+        side.values.joulesPerOutputToken,
+        side.values.meanWattsPerGpu,
+        side.values.interactivity,
+        side.point.id ?? null,
+        side.point.run_url ?? null,
+      ]
+    : [side.status, null, null, null, null, null];
+
+export default function MatchedConcurrencyTable({
+  chartId,
+  data,
+  baseline,
+  comparator,
+  interactivityField,
+  sourceLabel,
+}: {
+  chartId: string;
+  data: InferenceData[];
+  baseline: string;
+  comparator: string;
+  interactivityField: keyof AggDataEntry;
+  sourceLabel: (key: string) => string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const table = useMemo(
+    () => buildMatchedConcurrencyTable(data, { baseline, comparator, interactivityField }),
+    [data, baseline, comparator, interactivityField],
+  );
+  const cell = (side: MatchedConcurrencySide) => {
+    if (side.status === 'missing')
+      return <span className="text-muted-foreground">{t.missing}</span>;
+    if (side.status === 'ambiguous')
+      return <span className="text-muted-foreground">{t.ambiguous(side.points.length)}</span>;
+    const { joulesPerOutputToken, meanWattsPerGpu, interactivity } = side.values;
+    return (
+      <>
+        <strong>
+          {joulesPerOutputToken === null ? t.metricMissing : joules(joulesPerOutputToken)}
+        </strong>
+        <span className="block text-xs text-muted-foreground">
+          {meanWattsPerGpu === null ? '—' : watts(meanWattsPerGpu)} {t.power} ·{' '}
+          {interactivity === null ? '—' : speed(interactivity)} {t.speed}
+        </span>
+      </>
+    );
+  };
+  const sectionId = `${chartId}-matched-concurrency`;
+  const exportCsv = () => {
+    exportToCsv(
+      `InferenceX_matched_concurrency`,
+      [
+        'concurrency',
+        ...['baseline', 'comparator'].flatMap((prefix) => [
+          `${prefix}_status`,
+          `${prefix}_j_per_output_token`,
+          `${prefix}_w_per_gpu`,
+          `${prefix}_${String(interactivityField)}`,
+          `${prefix}_point_id`,
+          `${prefix}_run_url`,
+        ]),
+        'change_j_per_output_token_pct',
+        'change_w_per_gpu_pct',
+        'change_interactivity_pct',
+      ],
+      table.rows.map((row) => [
+        row.concurrency,
+        ...sideColumns(row.baseline),
+        ...sideColumns(row.comparator),
+        row.changePercent.joulesPerOutputToken,
+        row.changePercent.meanWattsPerGpu,
+        row.changePercent.interactivity,
+      ]),
+      [`baseline: ${sourceLabel(baseline)}`, `comparator: ${sourceLabel(comparator)}`],
+    );
+  };
+  return (
+    <section id={sectionId} className="min-w-0 space-y-3" data-testid="matched-concurrency-panel">
+      <Heading as="h3" level="card">
+        {t.title}
+      </Heading>
+      <p className="text-sm text-muted-foreground">{t.method}</p>
+      {table.reason ? (
+        <p className="text-sm text-muted-foreground">{t.unavailable}</p>
+      ) : table.rows.length === 0 ? (
+        <p className="text-sm text-muted-foreground">{t.empty}</p>
+      ) : (
+        <div className="min-w-0 overflow-x-auto">
+          <table
+            className="w-full min-w-[34rem] table-fixed break-words text-left text-sm"
+            data-testid="matched-concurrency-table"
+          >
+            <thead>
+              <tr>
+                <th className="w-28 whitespace-nowrap p-2">{t.concurrency}</th>
+                <th className="p-2">
+                  {t.baseline}
+                  <span className="block text-xs font-normal text-muted-foreground">
+                    {t.energy}
+                  </span>
+                </th>
+                <th className="p-2">
+                  {t.comparator}
+                  <span className="block text-xs font-normal text-muted-foreground">
+                    {t.energy}
+                  </span>
+                </th>
+                <th className="p-2">
+                  {t.change}
+                  <span className="block text-xs font-normal text-muted-foreground">
+                    {t.energyChange}
+                  </span>
+                </th>
+              </tr>
+            </thead>
+            <tbody>
+              {table.rows.map((row) => (
+                <tr
+                  key={row.concurrency}
+                  className="border-t"
+                  data-testid={`matched-concurrency-row-${row.concurrency}`}
+                >
+                  <th className="p-2 font-medium">{row.concurrency}</th>
+                  <td className="p-2 align-top">{cell(row.baseline)}</td>
+                  <td className="p-2 align-top">{cell(row.comparator)}</td>
+                  <td className="p-2 align-top">
+                    <strong>{percent(row.changePercent.joulesPerOutputToken)}</strong>
+                    <span className="block text-xs text-muted-foreground">
+                      {t.power} {percent(row.changePercent.meanWattsPerGpu)} · {t.speed}{' '}
+                      {percent(row.changePercent.interactivity)}
+                    </span>
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      )}
+      <p className="text-xs text-muted-foreground">{t.scope}</p>
+      <div className="max-h-0 overflow-hidden">
+        <div id={`${sectionId}-export`} className="p-4" />
+      </div>
+      <ChartButtons
+        chartId={sectionId}
+        analyticsPrefix="matched_concurrency"
+        hideZoomReset
+        onExportCsv={table.rows.length > 0 ? exportCsv : undefined}
+      />
+    </section>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/PowerFitPanel.tsx b/packages/app/src/components/inference/ui/PowerFitPanel.tsx
new file mode 100644
index 000000000..92071faa5
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerFitPanel.tsx
@@ -0,0 +1,234 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { Heading } from '@/components/ui/heading';
+import { exportToCsv } from '@/lib/csv-export';
+import { useLocale } from '@/lib/use-locale';
+import { escapeHtml } from '@/lib/utils';
+import type { InferenceData } from '../types';
+import { buildPowerFits, MIN_FIT_POINTS } from '../utils/power-fit';
+import { PowerPanelPlot, type PanelLine, type PanelMarker } from './PowerPanelPlot';
+
+const STRINGS = {
+  en: {
+    title: 'Power versus output rate (least-squares fit)',
+    method:
+      'Each source is fitted on its own observations: mean GPU power (W/GPU over all allocated GPUs) = P₀ + m × output rate (output tok/s per allocated GPU). Disaggregated output is spread over the prefill and decode GPUs. Solid lines span the observed range; the dashed segment only extends the line to zero output to read P₀.',
+    reading:
+      'P₀ is a fitted intercept, not measured idle power. m is the marginal GPU energy per output token (W per tok/s = J/token). R² describes this line only.',
+    xAxis: 'Output rate (tok/s per allocated GPU)',
+    yAxis: 'Mean GPU power (W/GPU)',
+    source: 'Source',
+    intercept: 'P₀ (W/GPU)',
+    tdpShare: 'P₀ ÷ TDP',
+    slope: 'm (J/output token)',
+    rSquared: 'R²',
+    points: 'Points',
+    range: 'Fitted range (tok/s/GPU)',
+    tooFew: (count: number) =>
+      `Not fitted: needs ${MIN_FIT_POINTS} distinct output rates, has ${count}.`,
+    flat: 'Undefined: power did not vary',
+    empty: 'No validated measured power with a known output rate is available for these filters.',
+  },
+  zh: {
+    title: '功耗与输出速率（最小二乘拟合）',
+    method:
+      '每个数据源只用自己的观测值拟合：平均 GPU 功耗（按全部已分配 GPU 计的 W/GPU）= P₀ + m × 输出速率（每个已分配 GPU 的输出 tok/s）。分离式部署的输出量均摊到预填充和解码 GPU 上。实线覆盖观测范围；虚线仅将直线延伸到零输出处，用于读取 P₀。',
+    reading:
+      'P₀ 是拟合截距，不是实测空载功耗。m 是每个输出 token 的边际 GPU 能耗（W/(tok/s) = J/token）。R² 仅描述这条拟合直线。',
+    xAxis: '输出速率（每个已分配 GPU 的 tok/s）',
+    yAxis: '平均 GPU 功耗（W/GPU）',
+    source: '数据源',
+    intercept: 'P₀（W/GPU）',
+    tdpShare: 'P₀ ÷ TDP',
+    slope: 'm（J/输出 token）',
+    rSquared: 'R²',
+    points: '点数',
+    range: '拟合范围（tok/s/GPU）',
+    tooFew: (count: number) =>
+      `未拟合：需要 ${MIN_FIT_POINTS} 个不同的输出速率，当前只有 ${count} 个。`,
+    flat: '无定义：功耗没有变化',
+    empty: '当前筛选条件下没有同时具备有效实测功耗和已知输出速率的数据。',
+  },
+};
+
+const watts = d3.format(',.0f');
+const joules = d3.format(',.3f');
+const rate = d3.format(',.1f');
+const share = d3.format('.0%');
+const rSquared = d3.format('.3f');
+const EXTENSION_DASH = '4 4';
+
+export default function PowerFitPanel({
+  chartId,
+  data,
+  contextLabel,
+  colorOf,
+}: {
+  chartId: string;
+  data: InferenceData[];
+  contextLabel?: string;
+  colorOf: (sourceKey: string) => string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const fits = useMemo(() => buildPowerFits(data), [data]);
+  const sectionId = `${chartId}-power-fit`;
+
+  const markers: PanelMarker[] = fits.flatMap(({ source, observations }) =>
+    observations.map((observation) => ({
+      x: observation.x,
+      y: observation.y,
+      key: source.key,
+      tooltip: [
+        `<strong>${escapeHtml(source.label)}</strong>`,
+        `c${observation.point.conc} · ${rate(observation.x)} tok/s/GPU`,
+        `${watts(observation.y)} W/GPU`,
+      ].join('<br/>'),
+    })),
+  );
+  // Line keys become SVG class names, so they index the source rather than embed its key.
+  const lines: PanelLine[] = fits.flatMap(({ source, fit }, index) => {
+    if (!fit) return [];
+    const at = (x: number) => ({ x, y: fit.intercept + fit.slope * x });
+    const color = colorOf(source.key);
+    return [
+      { key: `source${index}-fit`, color, points: [at(fit.xMin), at(fit.xMax)] },
+      ...(fit.xMin > 0
+        ? [
+            {
+              key: `source${index}-extension`,
+              color,
+              dash: EXTENSION_DASH,
+              points: [at(0), at(fit.xMin)],
+            },
+          ]
+        : []),
+    ];
+  });
+
+  const exportCsv = () => {
+    exportToCsv(
+      'InferenceX_power_fit',
+      [
+        'source',
+        'p0_w_per_gpu',
+        'tdp_w',
+        'p0_over_tdp',
+        'm_j_per_output_token',
+        'r_squared',
+        'n',
+        'x_min_tok_s_per_gpu',
+        'x_max_tok_s_per_gpu',
+        'status',
+      ],
+      fits.map((entry) => {
+        const { fit, tdpWatts } = entry;
+        return [
+          entry.source.label,
+          fit?.intercept ?? null,
+          tdpWatts,
+          fit && tdpWatts ? fit.intercept / tdpWatts : null,
+          fit?.slope ?? null,
+          fit?.rSquared ?? null,
+          entry.observations.length,
+          fit?.xMin ?? null,
+          fit?.xMax ?? null,
+          entry.reason ?? 'fitted',
+        ];
+      }),
+      contextLabel ? [contextLabel] : [],
+    );
+  };
+
+  return (
+    <section id={sectionId} className="min-w-0 space-y-3" data-testid="power-fit-panel">
+      <Heading as="h3" level="card">
+        {t.title}
+      </Heading>
+      <p className="text-sm text-muted-foreground">{contextLabel}</p>
+      <p className="text-xs text-muted-foreground">{t.method}</p>
+      {fits.length === 0 ? (
+        <p className="py-6 text-sm text-muted-foreground">{t.empty}</p>
+      ) : (
+        <>
+          <PowerPanelPlot
+            chartId={sectionId}
+            markers={markers}
+            lines={lines}
+            markerColor={colorOf}
+            xLabel={t.xAxis}
+            yLabel={t.yAxis}
+            height={360}
+          />
+          <div className="min-w-0 overflow-x-auto">
+            <table
+              className="w-full min-w-[40rem] table-fixed break-words text-left text-sm"
+              data-testid="power-fit-table"
+            >
+              <thead>
+                <tr>
+                  <th className="w-2/5 p-2">{t.source}</th>
+                  <th className="p-2">{t.intercept}</th>
+                  <th className="p-2">{t.tdpShare}</th>
+                  <th className="p-2">{t.slope}</th>
+                  <th className="p-2">{t.rSquared}</th>
+                  <th className="p-2">{t.points}</th>
+                  <th className="p-2">{t.range}</th>
+                </tr>
+              </thead>
+              <tbody>
+                {fits.map((entry) => {
+                  const { fit, source, tdpWatts } = entry;
+                  return (
+                    <tr key={source.key} className="border-t" data-testid="power-fit-row">
+                      <th className="p-2 align-top font-normal">
+                        <span style={{ color: colorOf(source.key) }}>● </span>
+                        <span className="break-all">{source.label}</span>
+                      </th>
+                      {fit ? (
+                        <>
+                          <td className="p-2 align-top">{watts(fit.intercept)}</td>
+                          <td className="p-2 align-top">
+                            {tdpWatts
+                              ? `${share(fit.intercept / tdpWatts)} · ${watts(tdpWatts)} W`
+                              : '—'}
+                          </td>
+                          <td className="p-2 align-top">{joules(fit.slope)}</td>
+                          <td className="p-2 align-top">
+                            {fit.rSquared === null ? t.flat : rSquared(fit.rSquared)}
+                          </td>
+                          <td className="p-2 align-top">{fit.n}</td>
+                          <td className="p-2 align-top">
+                            {rate(fit.xMin)}–{rate(fit.xMax)}
+                          </td>
+                        </>
+                      ) : (
+                        <td className="p-2 align-top text-muted-foreground" colSpan={6}>
+                          {t.tooFew(new Set(entry.observations.map((o) => o.x)).size)}
+                        </td>
+                      )}
+                    </tr>
+                  );
+                })}
+              </tbody>
+            </table>
+          </div>
+          <p className="text-xs text-muted-foreground">{t.reading}</p>
+          <div className="max-h-0 overflow-hidden">
+            <div id={`${sectionId}-export`} className="p-4" />
+          </div>
+          <ChartButtons
+            chartId={sectionId}
+            analyticsPrefix="power_fit"
+            hideZoomReset
+            onExportCsv={exportCsv}
+          />
+        </>
+      )}
+    </section>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/PowerPanelPlot.tsx b/packages/app/src/components/inference/ui/PowerPanelPlot.tsx
new file mode 100644
index 000000000..595200cd3
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerPanelPlot.tsx
@@ -0,0 +1,196 @@
+'use client';
+
+import * as d3 from 'd3';
+
+import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import type { CustomLayerConfig, LayerConfig } from '@/lib/d3-chart/D3Chart/types';
+import type { ContinuousScale } from '@/lib/d3-chart/types';
+
+/** One observed or derived value drawn as a marker. */
+export interface PanelMarker {
+  x: number;
+  y: number;
+  /** Series identity; the colour comes from `markerColor(key)`. */
+  key: string;
+  selected?: boolean;
+  /** Tooltip HTML; callers escape any source text. */
+  tooltip?: string;
+}
+
+/**
+ * A polyline drawn beneath the markers (series connections, fit lines). A
+ * non-finite y breaks the line; it never bridges a missing value.
+ */
+export interface PanelLine {
+  key: string;
+  points: { x: number; y: number }[];
+  color: string;
+  dash?: string;
+}
+
+const MARGIN = { top: 20, right: 18, bottom: 64, left: 65 };
+const compactNumber = d3.format('~g');
+const compact = (value: d3.AxisDomain) => compactNumber(Number(value));
+
+/** d3's log labelling: the 1× and 2× steps of each decade get labels, other ticks stay bare. */
+function logTickFormat(domain: [number, number]) {
+  const format = d3.scaleLog().domain(domain).tickFormat(5, '~g');
+  return (value: d3.AxisDomain) => format(Number(value));
+}
+
+function logDomain(values: number[]): [number, number] {
+  const positive = values.filter((value) => value > 0 && Number.isFinite(value));
+  if (positive.length === 0) return [1, 10];
+  const min = Math.min(...positive);
+  const max = Math.max(...positive);
+  return min === max ? [min / 2, max * 2] : [min / 1.25, max * 1.25];
+}
+
+/** Observed x range; a single value widens from zero so the marker is not on an edge. */
+function linearXDomain(values: number[]): [number, number] {
+  const finite = values.filter(Number.isFinite);
+  if (finite.length === 0) return [0, 1];
+  const min = Math.min(...finite);
+  const max = Math.max(...finite);
+  return min === max ? [0, max * 1.05 || 1] : [min, max];
+}
+
+/** Values plus zero and the reference, padded by a tenth of the span; never below zero for non-negative data. */
+function linearYDomain(values: number[], include: number[]): [number, number] {
+  const finite = [...values, ...include].filter(Number.isFinite);
+  const min = Math.min(...finite);
+  const max = Math.max(...finite);
+  const pad = (max - min || 1) * 0.1;
+  return [min >= 0 ? 0 : min - pad, max + pad];
+}
+
+/**
+ * Small D3 plot shared by the PowerX comparison panels: markers, optional
+ * connecting or fitted lines, and one dashed reference value (0 %, 50 %…).
+ * Log axes drop non-positive values instead of clamping them.
+ */
+export function PowerPanelPlot({
+  chartId,
+  markers,
+  lines = [],
+  markerColor,
+  xLabel,
+  yLabel,
+  reference = null,
+  xLog = false,
+  yLog = false,
+  xDomain,
+  yDomain,
+  xTickValues,
+  height = 320,
+}: {
+  chartId: string;
+  markers: PanelMarker[];
+  lines?: PanelLine[];
+  markerColor: (key: string) => string;
+  xLabel: string;
+  yLabel: string;
+  reference?: number | null;
+  xLog?: boolean;
+  yLog?: boolean;
+  xDomain?: [number, number];
+  yDomain?: [number, number];
+  /** Explicit x ticks, e.g. the observed concurrencies of a load sweep. */
+  xTickValues?: number[];
+  height?: number;
+}) {
+  const visible = (point: { x: number; y: number }) =>
+    Number.isFinite(point.x) &&
+    Number.isFinite(point.y) &&
+    (!xLog || point.x > 0) &&
+    (!yLog || point.y > 0);
+  const drawn = markers.filter(visible);
+  const drawnLines = lines.filter((line) => line.points.filter(visible).length > 1);
+  const everything = [...drawn, ...drawnLines.flatMap((line) => line.points.filter(visible))];
+  const xs = everything.map((point) => point.x);
+  const ys = everything.map((point) => point.y);
+  const x = xDomain ?? (xLog ? logDomain(xs) : linearXDomain(xs));
+  const y =
+    yDomain ??
+    (yLog ? logDomain(ys) : linearYDomain(ys, reference === null ? [0] : [0, reference]));
+  const colors = Object.fromEntries(drawnLines.map((line) => [line.key, line.color]));
+  const dashes = Object.fromEntries(drawnLines.map((line) => [line.key, line.dash ?? '']));
+  const drawReference: NonNullable<CustomLayerConfig['render']> = (group, ctx) => {
+    const scale = (ctx.renderedYScale ?? ctx.yScale) as ContinuousScale;
+    group
+      .selectAll('line')
+      .data(reference === null ? [] : [reference])
+      .join('line')
+      .attr('x1', 0)
+      .attr('x2', ctx.width)
+      .attr('y1', (value) => scale(value))
+      .attr('y2', (value) => scale(value))
+      .attr('stroke', 'currentColor')
+      .attr('stroke-dasharray', '5,4')
+      .attr('opacity', 0.6);
+  };
+  const layers: LayerConfig<PanelMarker>[] = [
+    { type: 'custom', key: 'reference', render: drawReference },
+    {
+      type: 'line',
+      key: 'lines',
+      lines: Object.fromEntries(drawnLines.map((line) => [line.key, line.points])),
+      config: {
+        curve: d3.curveLinear,
+        getColor: (key) => colors[key],
+        getStrokeDasharray: (key) => dashes[key] || 'none',
+        isDefined: visible,
+      },
+    },
+    {
+      type: 'point',
+      key: 'markers',
+      data: drawn,
+      config: {
+        getCx: () => 0,
+        getCy: () => 0,
+        getX: (point) => point.x,
+        getY: (point) => point.y,
+        getRadius: (point) => (point.selected ? 6 : 3),
+        getColor: (point) => markerColor(point.key),
+      },
+    },
+  ];
+  const hasTooltips = drawn.some((point) => point.tooltip);
+  return (
+    <D3Chart<PanelMarker>
+      chartId={`${chartId}-plot`}
+      data={drawn}
+      height={height}
+      testId={`${chartId}-plot`}
+      watermark="logo"
+      zoom={{ enabled: false }}
+      grabCursor={false}
+      instructions=""
+      margin={MARGIN}
+      xScale={{ type: xLog ? 'log' : 'linear', domain: x, nice: !xLog }}
+      yScale={{ type: yLog ? 'log' : 'linear', domain: y, nice: !yLog }}
+      xAxis={{
+        label: xLabel,
+        tickCount: 4,
+        ...(xTickValues ? { tickValues: xTickValues, tickFormat: compact } : {}),
+      }}
+      yAxis={{
+        label: yLabel,
+        tickCount: 5,
+        ...(yLog ? { tickFormat: logTickFormat(y) } : {}),
+      }}
+      layers={layers}
+      {...(hasTooltips
+        ? {
+            tooltip: {
+              rulerType: 'none' as const,
+              content: (point: PanelMarker) =>
+                `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md">${point.tooltip ?? ''}</div>`,
+              attachToLayer: 2,
+            },
+          }
+        : {})}
+    />
+  );
+}
diff --git a/packages/app/src/components/inference/ui/PowerRoleGroup.tsx b/packages/app/src/components/inference/ui/PowerRoleGroup.tsx
new file mode 100644
index 000000000..7fedb94a1
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerRoleGroup.tsx
@@ -0,0 +1,326 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { Heading } from '@/components/ui/heading';
+import { exportToCsv } from '@/lib/csv-export';
+import { useLocale } from '@/lib/use-locale';
+import { escapeHtml } from '@/lib/utils';
+import type { AggDataEntry, InferenceData } from '../types';
+import {
+  getRolePoints,
+  type EqualServiceSource,
+  type RolePoint,
+} from '../utils/equal-service-comparison';
+import { powerVariantDash } from '../utils/power-compare';
+import { PowerPanelPlot, type PanelLine, type PanelMarker } from './PowerPanelPlot';
+
+type RoleSeriesKey = 'prefill' | 'decode' | 'total';
+type RolePanelId = 'power' | 'local-energy' | 'output-energy' | 'share';
+
+const STRINGS = {
+  en: {
+    title: 'Prefill and decode roles',
+    method:
+      'Validated disaggregated observations only. Each panel names its denominator. Missing role telemetry is omitted, never drawn as zero.',
+    empty: 'No validated prefill/decode telemetry is available for these filters.',
+    panelEmpty: 'These observations do not report this role figure.',
+    roles: { prefill: 'Prefill', decode: 'Decode', total: 'Prefill + decode' },
+    panels: {
+      power: {
+        title: 'Mean GPU power by role',
+        axis: 'Mean GPU power (W/GPU)',
+        note: 'Mean board power per GPU inside each pool over the validated window.',
+        units: { prefill: 'W/GPU', decode: 'W/GPU', total: 'W/GPU' },
+      },
+      'local-energy': {
+        title: 'Role-local GPU energy',
+        axis: 'GPU energy (J/token, log)',
+        note: 'Prefill: prefill-pool joules ÷ input tokens. Decode: decode-pool joules ÷ output tokens. The denominators differ, so these two are not added.',
+        units: { prefill: 'J/input token', decode: 'J/output token', total: 'J/output token' },
+      },
+      'output-energy': {
+        title: 'GPU energy per output token by role',
+        axis: 'GPU energy (J/output token, log)',
+        note: 'Prefill energy restated per output token with the same window’s input:output token ratio, so prefill + decode is the request total.',
+        units: { prefill: 'J/output token', decode: 'J/output token', total: 'J/output token' },
+      },
+      share: {
+        title: 'Prefill energy share',
+        axis: 'Prefill energy share (%)',
+        note: 'Share = prefill ÷ (prefill + decode), both per output token. The dashed line marks 50%.',
+        units: { prefill: '%', decode: '%', total: '%' },
+      },
+    } satisfies Record<
+      RolePanelId,
+      { title: string; axis: string; note: string; units: Record<RoleSeriesKey, string> }
+    >,
+  },
+  zh: {
+    title: '预填充与解码角色',
+    method:
+      '仅包含经过验证的分离式部署观测值。每个面板都注明了分母。缺少角色遥测数据的点不绘制，不会按 0 处理。',
+    empty: '当前筛选条件下没有经过验证的预填充 / 解码遥测数据。',
+    panelEmpty: '这些观测值没有报告该角色指标。',
+    roles: { prefill: '预填充', decode: '解码', total: '预填充 + 解码' },
+    panels: {
+      power: {
+        title: '各角色的平均 GPU 功耗',
+        axis: '平均 GPU 功耗（W/GPU）',
+        note: '有效测量窗口内各 GPU 池中每个 GPU 的平均板卡功耗。',
+        units: { prefill: 'W/GPU', decode: 'W/GPU', total: 'W/GPU' },
+      },
+      'local-energy': {
+        title: '各角色按本池 token 计的 GPU 能耗',
+        axis: 'GPU 能耗（J/token，对数）',
+        note: '预填充：预填充池焦耳数 ÷ 输入 token 数。解码：解码池焦耳数 ÷ 输出 token 数。两者分母不同，因此不相加。',
+        units: { prefill: 'J/输入 token', decode: 'J/输出 token', total: 'J/输出 token' },
+      },
+      'output-energy': {
+        title: '各角色每输出 token 的 GPU 能耗',
+        axis: 'GPU 能耗（J/输出 token，对数）',
+        note: '用同一窗口的输入:输出 token 比，把预填充能耗换算为每输出 token，因此预填充 + 解码等于整个请求的能耗。',
+        units: { prefill: 'J/输出 token', decode: 'J/输出 token', total: 'J/输出 token' },
+      },
+      share: {
+        title: '预填充能耗占比',
+        axis: '预填充能耗占比（%）',
+        note: '占比 = 预填充 ÷（预填充 + 解码），两者都按输出 token 计。虚线标记 50%。',
+        units: { prefill: '%', decode: '%', total: '%' },
+      },
+    } satisfies Record<
+      RolePanelId,
+      { title: string; axis: string; note: string; units: Record<RoleSeriesKey, string> }
+    >,
+  },
+};
+
+const PANELS: {
+  id: RolePanelId;
+  series: { role: RoleSeriesKey; value: (point: RolePoint) => number | null }[];
+  yLog?: boolean;
+  reference?: number;
+  yDomain?: [number, number];
+  /** Share points stay unconnected: each is one observed configuration. */
+  connect: boolean;
+}[] = [
+  {
+    id: 'power',
+    series: [
+      { role: 'prefill', value: (point) => point.prefillWattsPerGpu },
+      { role: 'decode', value: (point) => point.decodeWattsPerGpu },
+    ],
+    connect: true,
+  },
+  {
+    id: 'local-energy',
+    series: [
+      { role: 'prefill', value: (point) => point.prefillJoulesPerInputToken },
+      { role: 'decode', value: (point) => point.decodeJoulesPerOutputToken },
+    ],
+    yLog: true,
+    connect: true,
+  },
+  {
+    id: 'output-energy',
+    series: [
+      { role: 'prefill', value: (point) => point.energy?.prefill ?? null },
+      { role: 'decode', value: (point) => point.energy?.decode ?? null },
+      { role: 'total', value: (point) => point.energy?.total ?? null },
+    ],
+    yLog: true,
+    connect: true,
+  },
+  {
+    id: 'share',
+    series: [{ role: 'prefill', value: (point) => point.energy?.prefillShare ?? null }],
+    reference: 50,
+    yDomain: [0, 100],
+    connect: false,
+  },
+];
+const ROLE_DASH: Record<RoleSeriesKey, string> = {
+  prefill: powerVariantDash({ kind: 'role', id: 'prefill' }),
+  decode: powerVariantDash({ kind: 'role', id: 'decode' }),
+  total: '',
+};
+const value = d3.format(',.4~g');
+
+export default function PowerRoleGroup({
+  chartId,
+  data,
+  xField,
+  xLabel,
+  contextLabel,
+  sources,
+  colorOf,
+}: {
+  chartId: string;
+  data: InferenceData[];
+  xField: keyof AggDataEntry;
+  xLabel: string;
+  contextLabel?: string;
+  sources: EqualServiceSource[];
+  colorOf: (sourceKey: string) => string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const points = useMemo(() => getRolePoints(data, xField), [data, xField]);
+  const label = (key: string) => sources.find((source) => source.key === key)?.label ?? key;
+  const isConcurrency = xField === 'conc';
+  const concurrencies = isConcurrency ? [...new Set(points.map((point) => point.x))] : undefined;
+  const sectionId = `${chartId}-roles`;
+
+  const panel = (definition: (typeof PANELS)[number]) => {
+    const copy = t.panels[definition.id];
+    const plotId = `${chartId}-role-${definition.id}`;
+    const markers: PanelMarker[] = definition.series.flatMap(({ role, value: read }) =>
+      points.flatMap((point) => {
+        const y = read(point);
+        return y === null
+          ? []
+          : [
+              {
+                x: point.x,
+                y,
+                key: point.sourceKey,
+                tooltip: [
+                  `<strong>${escapeHtml(label(point.sourceKey))}</strong>`,
+                  `${escapeHtml(xLabel)}: ${value(point.x)} · c${point.point.conc}`,
+                  `${t.roles[role]}: ${value(y)} ${copy.units[role]}`,
+                ].join('<br/>'),
+              },
+            ];
+      }),
+    );
+    // Line keys become SVG class names, so they index the source rather than embed its key.
+    const lines: PanelLine[] = definition.connect
+      ? definition.series.flatMap(({ role, value: read }) =>
+          [...new Set(points.map((point) => point.sourceKey))].map((sourceKey, index) => ({
+            key: `source${index}-${role}`,
+            color: colorOf(sourceKey),
+            dash: ROLE_DASH[role],
+            points: points
+              .filter((point) => point.sourceKey === sourceKey)
+              .map((point) => ({ x: point.x, y: read(point) ?? Number.NaN })),
+          })),
+        )
+      : [];
+    return (
+      <figure key={definition.id} className="min-w-0 space-y-1">
+        <figcaption className="text-sm font-medium">{copy.title}</figcaption>
+        {markers.length > 0 ? (
+          <PowerPanelPlot
+            chartId={plotId}
+            markers={markers}
+            lines={lines}
+            markerColor={colorOf}
+            xLabel={xLabel}
+            yLabel={copy.axis}
+            reference={definition.reference ?? null}
+            xLog={isConcurrency}
+            yLog={definition.yLog}
+            yDomain={definition.yDomain}
+            xTickValues={concurrencies}
+            height={300}
+          />
+        ) : (
+          <p className="py-6 text-sm text-muted-foreground" data-testid={`${plotId}-empty`}>
+            {t.panelEmpty}
+          </p>
+        )}
+        <p className="text-xs text-muted-foreground">{copy.note}</p>
+      </figure>
+    );
+  };
+
+  const exportCsv = () => {
+    exportToCsv(
+      'InferenceX_prefill_decode_roles',
+      [
+        'source',
+        String(xField),
+        'concurrency',
+        'point_id',
+        'run_url',
+        'prefill_w_per_gpu',
+        'decode_w_per_gpu',
+        'prefill_j_per_input_token',
+        'decode_j_per_output_token',
+        'prefill_j_per_output_token',
+        'total_j_per_output_token',
+        'prefill_energy_share_pct',
+      ],
+      points.map((point) => [
+        label(point.sourceKey),
+        point.x,
+        point.point.conc,
+        point.point.id ?? null,
+        point.point.run_url ?? null,
+        point.prefillWattsPerGpu,
+        point.decodeWattsPerGpu,
+        point.prefillJoulesPerInputToken,
+        point.decodeJoulesPerOutputToken,
+        point.energy?.prefill ?? null,
+        point.energy?.total ?? null,
+        point.energy?.prefillShare ?? null,
+      ]),
+      contextLabel ? [contextLabel] : [],
+    );
+  };
+
+  const shownSources = sources.filter((source) =>
+    points.some((point) => point.sourceKey === source.key),
+  );
+  return (
+    <section id={sectionId} className="min-w-0 space-y-3" data-testid="prefill-share-panel">
+      <Heading as="h3" level="card">
+        {t.title}
+      </Heading>
+      <p className="text-sm text-muted-foreground">{contextLabel}</p>
+      <p className="text-xs text-muted-foreground">{t.method}</p>
+      {points.length > 0 ? (
+        <>
+          <div className="flex flex-wrap gap-x-5 gap-y-2 text-sm">
+            {shownSources.map((source) => (
+              <span key={source.key} className="min-w-0 break-all">
+                <span style={{ color: colorOf(source.key) }}>● </span>
+                {source.label}
+              </span>
+            ))}
+            {(['prefill', 'decode', 'total'] as const).map((role) => (
+              <span key={role} className="inline-flex items-center gap-2">
+                <svg width="28" height="10" aria-hidden="true">
+                  <line
+                    x1="0"
+                    x2="28"
+                    y1="5"
+                    y2="5"
+                    stroke="currentColor"
+                    strokeWidth="2"
+                    strokeDasharray={ROLE_DASH[role] || undefined}
+                  />
+                </svg>
+                {t.roles[role]}
+              </span>
+            ))}
+          </div>
+          <div className="grid min-w-0 gap-6 lg:grid-cols-2">{PANELS.map(panel)}</div>
+          <div className="max-h-0 overflow-hidden">
+            <div id={`${sectionId}-export`} className="p-4" />
+          </div>
+          <ChartButtons
+            chartId={sectionId}
+            analyticsPrefix="power_roles"
+            hideZoomReset
+            onExportCsv={exportCsv}
+          />
+        </>
+      ) : (
+        <p className="py-6 text-sm text-muted-foreground">{t.empty}</p>
+      )}
+    </section>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
index 53b4c7277..1363ef643 100644
--- a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
+++ b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
@@ -1,30 +1,36 @@
 'use client';
 
 import * as d3 from 'd3';
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
 import { ChartButtons } from '@/components/ui/chart-buttons';
 import { Heading } from '@/components/ui/heading';
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
 import { useThemeColors } from '@/hooks/useThemeColors';
 import { useUrlState } from '@/hooks/useUrlState';
-import { D3Chart } from '@/lib/d3-chart/D3Chart';
-import type { CustomLayerConfig } from '@/lib/d3-chart/D3Chart/types';
-import type { ContinuousScale } from '@/lib/d3-chart/types';
+import { track } from '@/lib/analytics';
+import { overlayRunColor, overlayRunIndex } from '@/lib/overlay-run-style';
 import { useLocale } from '@/lib/use-locale';
 import type { AggDataEntry, InferenceData } from '../types';
 import {
   buildEqualServiceComparison,
+  equalServiceSourceKey,
   getEqualServiceComparisonCurve,
   getEqualServiceSources,
-  getPrefillSharePoints,
+  observedPoints,
   type EqualServiceEstimate,
   type EqualServiceReason,
 } from '../utils/equal-service-comparison';
+import MatchedConcurrencyTable from './MatchedConcurrencyTable';
+import PowerFitPanel from './PowerFitPanel';
+import { PowerPanelPlot } from './PowerPanelPlot';
+import PowerRoleGroup from './PowerRoleGroup';
 
 const STRINGS = {
   en: {
     compare: 'Compare at the same speed / latency',
-    share: 'Prefill energy share',
+    roles: 'Prefill / decode roles',
+    fit: 'Power vs output-rate fit',
     baseline: 'Baseline',
     comparator: 'Comparator',
     target: 'Target',
@@ -34,15 +40,12 @@ const STRINGS = {
       'Change = (comparator ÷ baseline − 1) × 100%. A negative energy change means lower energy use. Matches the selected axis only; other latencies may differ.',
     interpolation:
       'Within each source, raw quantities are linearly interpolated between neighboring observations, then compared. No extrapolation. Larger markers show the selected target. Lines connect the derived comparisons; they are not additional measurements.',
-    roleMethod:
-      'Prefill and decode energy use the same output-token denominator. Share = prefill ÷ (prefill + decode). Points are observed configurations; the dashed line marks 50%.',
     targetHelp:
       'Enter a target within both source ranges to inspect values and bracketing observations.',
     concurrency:
-      'Concurrency is a load diagnostic, not equal service. Select interactivity, TTFT or end-to-end latency for this comparison.',
+      'Concurrency is a load diagnostic, not equal service. Select interactivity, TTFT or end-to-end latency for the equal-service comparison; the table below pairs observations at each concurrency.',
     metric: 'Metric',
     empty: 'No comparable points in the selected sources’ overlapping range.',
-    roleEmpty: 'No validated prefill/decode energy is available for these filters.',
     measured: 'Observed',
     interpolated: 'Interpolated',
     observation: 'Observation',
@@ -50,12 +53,12 @@ const STRINGS = {
     outputTokensPerSecond: 'Deployment output (tok/s)',
     joulesPerOutputToken: 'GPU energy (J/output token)',
     percent: 'Comparator change (%)',
-    shareAxis: 'Prefill energy share (%)',
     unavailable: 'Unavailable',
   },
   zh: {
     compare: '在相同速度 / 延迟下比较',
-    share: '预填充能耗占比',
+    roles: '预填充 / 解码角色',
+    fit: '功耗与输出速率拟合',
     baseline: '基准',
     comparator: '对比对象',
     target: '目标值',
@@ -65,14 +68,11 @@ const STRINGS = {
       '变化 =（对比对象 ÷ 基准 − 1）× 100%。能耗变化率为负表示能耗更低。只匹配所选横轴，其他延迟可能不同。',
     interpolation:
       '各数据源在相邻观测点间对原始数值进行线性插值，再计算变化率；不做外推。大圆点标记所选目标值。连线连接推导出的比较结果，不代表额外实测。',
-    roleMethod:
-      '预填充与解码能耗均按输出 token 归一化。占比 = 预填充 ÷（预填充 + 解码）。各点为实测配置，虚线标记 50%。',
     targetHelp: '输入两个数据源范围内的目标值，查看数值及插值两端的观测点。',
     concurrency:
-      '并发数用于分析负载，并不代表相同服务水平。请选交互性、首 token 延迟或端到端延迟进行比较。',
+      '并发数用于分析负载，并不代表相同服务水平。相同服务水平的比较请选择交互性、首 token 延迟或端到端延迟；下表按各并发数配对观测值。',
     metric: '指标',
     empty: '所选数据源的重叠范围内没有可比较的数据。',
-    roleEmpty: '当前筛选条件下没有经过验证的预填充 / 解码能耗数据。',
     measured: '实测',
     interpolated: '插值',
     observation: '观测点',
@@ -80,7 +80,6 @@ const STRINGS = {
     outputTokensPerSecond: '部署输出吞吐量（tok/s）',
     joulesPerOutputToken: 'GPU 能耗（J/输出 token）',
     percent: '对比对象变化（%）',
-    shareAxis: '预填充能耗占比（%）',
     unavailable: '不可用',
   },
 };
@@ -103,129 +102,68 @@ const METRICS = ['meanWattsPerGpu', 'outputTokensPerSecond', 'joulesPerOutputTok
 const DASHES = ['', '6,4', '2,3'];
 const number = d3.format(',.4~g');
 const percent = d3.format('+.2f');
-interface PlotPoint {
-  x: number;
-  y: number;
-  key: string;
-  selected?: boolean;
-}
 
-function ComparisonPlot({
-  chartId,
-  points,
-  xLabel,
-  yLabel,
-  reference,
-  colors,
-  lines = true,
+function PanelToggle({
+  checked,
+  onChange,
+  label,
+  testId,
+  event,
 }: {
-  chartId: string;
-  points: PlotPoint[];
-  xLabel: string;
-  yLabel: string;
-  reference: number;
-  colors: Record<string, string>;
-  lines?: boolean;
+  checked: boolean;
+  onChange: (checked: boolean) => void;
+  label: string;
+  testId: string;
+  event: string;
 }) {
-  const xs = points.map((p) => p.x).filter(Number.isFinite);
-  const ys = points.map((p) => p.y).filter(Number.isFinite);
-  const xMin = Math.min(...xs),
-    xMax = Math.max(...xs);
-  const yMin = Math.min(0, ...ys),
-    yMax = Math.max(reference, ...ys);
-  const grouped = Object.fromEntries(d3.groups(points, (p) => p.key));
-  const finitePoints = points.filter((p) => Number.isFinite(p.y));
-  const drawReference: NonNullable<CustomLayerConfig['render']> = (group, ctx) => {
-    const scale = (ctx.renderedYScale ?? ctx.yScale) as ContinuousScale;
-    group
-      .selectAll('line')
-      .data([reference])
-      .join('line')
-      .attr('x1', 0)
-      .attr('x2', ctx.width)
-      .attr('y1', (v) => scale(v))
-      .attr('y2', (v) => scale(v))
-      .attr('stroke', 'currentColor')
-      .attr('stroke-dasharray', '5,4')
-      .attr('opacity', 0.6);
-  };
   return (
-    <D3Chart<PlotPoint>
-      chartId={`${chartId}-plot`}
-      data={finitePoints}
-      height={360}
-      testId={`${chartId}-plot`}
-      watermark="logo"
-      zoom={{ enabled: false }}
-      grabCursor={false}
-      instructions=""
-      margin={{ top: 20, right: 18, bottom: 64, left: 65 }}
-      xScale={{
-        type: 'linear',
-        domain: xMin === xMax ? [0, xMax * 1.05] : [xMin, xMax],
-        nice: true,
-      }}
-      yScale={{
-        type: 'linear',
-        domain: lines
-          ? [yMin - (yMax - yMin || 1) * 0.1, yMax + (yMax - yMin || 1) * 0.1]
-          : [0, 100],
-        nice: true,
-      }}
-      xAxis={{ label: xLabel, tickCount: 4 }}
-      yAxis={{ label: yLabel, tickCount: 5 }}
-      layers={[
-        { type: 'custom', key: 'reference', render: drawReference },
-        ...(lines
-          ? [
-              {
-                type: 'line' as const,
-                lines: grouped,
-                config: {
-                  curve: d3.curveLinear,
-                  isDefined: (p: { x: number; y: number }) => Number.isFinite(p.y),
-                  getColor: (key: string) => colors[key],
-                  getStrokeDasharray: (key: string) =>
-                    DASHES[METRICS.indexOf(key as (typeof METRICS)[number])],
-                },
-              },
-            ]
-          : []),
-        {
-          type: 'point',
-          data: finitePoints,
-          config: {
-            getCx: () => 0,
-            getCy: () => 0,
-            getX: (p) => p.x,
-            getY: (p) => p.y,
-            getRadius: (p) => (p.selected ? 6 : 3),
-            getColor: (p) => colors[p.key],
-          },
-        },
-      ]}
-    />
+    <label className="flex items-center gap-2">
+      <input
+        type="checkbox"
+        checked={checked}
+        onChange={(e) => {
+          onChange(e.target.checked);
+          track(event, { enabled: e.target.checked });
+        }}
+        data-testid={testId}
+      />
+      {label}
+    </label>
   );
 }
 
+/**
+ * PowerX analysis panels under a measured-power chart: equal-service and
+ * matched-concurrency comparisons, the prefill/decode role group and the
+ * power-vs-output-rate fit. Every panel reads the chart's visible official and
+ * `?unofficialrun=` rows; overlay sources take their run's legend colour.
+ */
 export default function PowerServiceComparison({
   data,
+  overlayData = [],
   xField,
   xLabel,
+  interactivityField,
   chartId,
   contextLabel,
 }: {
   data: InferenceData[];
+  /** The subset of `data` loaded from unofficial runs. */
+  overlayData?: readonly InferenceData[];
   xField: keyof AggDataEntry;
   xLabel: string;
+  /** Streaming-speed field at the selected statistic, for load-matched rows. */
+  interactivityField: keyof AggDataEntry;
   chartId: string;
   contextLabel?: string;
 }) {
   const locale = useLocale();
   const t = STRINGS[locale];
   const { getUrlParam, setUrlParams } = useUrlState();
+  const { runIndexByUrl } = useUnofficialRun();
   const [enabled, setEnabled] = useState(() => getUrlParam('i_servicecompare') === '1');
   const [roleShare, setRoleShare] = useState(() => getUrlParam('i_roleshare') === '1');
+  const [powerFit, setPowerFit] = useState(() => getUrlParam('i_powerfit') === '1');
   const [baseline, setBaseline] = useState(() => getUrlParam('i_servicebase') ?? '');
   const [comparator, setComparator] = useState(() => getUrlParam('i_servicepeer') ?? '');
   const [target, setTarget] = useState(() => getUrlParam('i_servicetarget') ?? '');
@@ -244,11 +182,12 @@ export default function PowerServiceComparison({
     setUrlParams({
       i_servicecompare: enabled ? '1' : '0',
       i_roleshare: roleShare ? '1' : '0',
+      i_powerfit: powerFit ? '1' : '0',
       i_servicebase: enabled ? base : baseline,
       i_servicepeer: enabled ? peer : comparator,
       i_servicetarget: target,
     });
-  }, [enabled, roleShare, base, peer, baseline, comparator, target, setUrlParams]);
+  }, [enabled, roleShare, powerFit, base, peer, baseline, comparator, target, setUrlParams]);
   const curve = useMemo(
     () =>
       enabled
@@ -272,16 +211,24 @@ export default function PowerServiceComparison({
         : null,
     [enabled, data, base, peer, xField, target],
   );
-  const shares = useMemo(
-    () => (roleShare ? getPrefillSharePoints(data, xField) : []),
-    [roleShare, data, xField],
-  );
   const { resolveColor } = useThemeColors({
     highContrast: true,
     identifiers: [...METRICS, ...sources.map((s) => s.key)],
   });
   const metricColors = Object.fromEntries(METRICS.map((key) => [key, resolveColor(key)]));
-  const sourceColors = Object.fromEntries(sources.map((s) => [s.key, resolveColor(s.key)]));
+  const overlaySourceKeys = useMemo(
+    () => new Map(observedPoints(overlayData).map((p) => [equalServiceSourceKey(p), p.run_url])),
+    [overlayData],
+  );
+  const colorOf = useCallback(
+    (key: string) =>
+      overlaySourceKeys.has(key)
+        ? overlayRunColor(overlayRunIndex(overlaySourceKeys.get(key), runIndexByUrl))
+        : resolveColor(key),
+    [overlaySourceKeys, runIndexByUrl, resolveColor],
+  );
+  const sourceLabel = (key: string) =>
+    sources.find((source) => source.key === key)?.label ?? t.unavailable;
   // The percentage of interpolated raw values is not linear in X. Include the
   // exact selected target as a knot so its plotted marker agrees with the table.
   const plottedCurve =
@@ -325,6 +272,7 @@ export default function PowerServiceComparison({
     onChange: (value: string) => void,
     label: string,
     testId: string,
+    role: 'baseline' | 'comparator',
   ) => (
     <label className="min-w-0 space-y-1 text-sm">
       <span>{label}</span>
@@ -333,7 +281,10 @@ export default function PowerServiceComparison({
         aria-label={label}
         data-testid={testId}
         value={value}
-        onChange={(event) => onChange(event.target.value)}
+        onChange={(event) => {
+          onChange(event.target.value);
+          track('inference_equal_service_source_changed', { role });
+        }}
       >
         {!sources.some((source) => source.key === value) && (
           <option value={value}>{t.unavailable}</option>
@@ -349,36 +300,48 @@ export default function PowerServiceComparison({
   return (
     <div className="mt-6 min-w-0 space-y-4 border-t pt-4" data-testid="power-service-comparison">
       <div className="no-export flex flex-wrap gap-4 text-sm">
-        <label className="flex items-center gap-2">
-          <input
-            type="checkbox"
-            checked={enabled}
-            onChange={(e) => setEnabled(e.target.checked)}
-            data-testid="equal-service-toggle"
-          />
-          {t.compare}
-        </label>
-        <label className="flex items-center gap-2">
-          <input
-            type="checkbox"
-            checked={roleShare}
-            onChange={(e) => setRoleShare(e.target.checked)}
-            data-testid="role-share-toggle"
-          />
-          {t.share}
-        </label>
+        <PanelToggle
+          checked={enabled}
+          onChange={setEnabled}
+          label={t.compare}
+          testId="equal-service-toggle"
+          event="inference_equal_service_toggled"
+        />
+        <PanelToggle
+          checked={roleShare}
+          onChange={setRoleShare}
+          label={t.roles}
+          testId="role-share-toggle"
+          event="inference_power_roles_toggled"
+        />
+        <PanelToggle
+          checked={powerFit}
+          onChange={setPowerFit}
+          label={t.fit}
+          testId="power-fit-toggle"
+          event="inference_power_fit_toggled"
+        />
       </div>
-      {enabled &&
-        (xField === 'conc' ? (
-          <p className="text-sm text-muted-foreground" data-testid="equal-service-concurrency-note">
-            {t.concurrency}
-          </p>
-        ) : (
-          <>
-            <div className="no-export grid min-w-0 gap-3 md:grid-cols-2">
-              {sourceSelect(base, setBaseline, t.baseline, 'equal-service-baseline')}
-              {sourceSelect(peer, setComparator, t.comparator, 'equal-service-comparator')}
-            </div>
+      {enabled && (
+        <>
+          <div className="no-export grid min-w-0 gap-3 md:grid-cols-2">
+            {sourceSelect(base, setBaseline, t.baseline, 'equal-service-baseline', 'baseline')}
+            {sourceSelect(
+              peer,
+              setComparator,
+              t.comparator,
+              'equal-service-comparator',
+              'comparator',
+            )}
+          </div>
+          {xField === 'conc' ? (
+            <p
+              className="text-sm text-muted-foreground"
+              data-testid="equal-service-concurrency-note"
+            >
+              {t.concurrency}
+            </p>
+          ) : (
             <section
               id={`${chartId}-service`}
               className="min-w-0 space-y-3"
@@ -390,8 +353,7 @@ export default function PowerServiceComparison({
               <p className="text-sm text-muted-foreground">{contextLabel}</p>
               <p className="text-sm text-muted-foreground">{t.method}</p>
               <p className="break-words text-sm">
-                {t.baseline}: {sources.find((s) => s.key === base)?.label ?? t.unavailable} →{' '}
-                {t.comparator}: {sources.find((s) => s.key === peer)?.label ?? t.unavailable}
+                {t.baseline}: {sourceLabel(base)} → {t.comparator}: {sourceLabel(peer)}
               </p>
 
               <div className="flex flex-wrap gap-x-5 gap-y-2 text-sm">
@@ -413,13 +375,20 @@ export default function PowerServiceComparison({
                 ))}
               </div>
               {plotPoints.some((p) => Number.isFinite(p.y)) ? (
-                <ComparisonPlot
+                <PowerPanelPlot
                   chartId={`${chartId}-service`}
-                  points={plotPoints}
+                  markers={plotPoints.filter((p) => Number.isFinite(p.y))}
+                  lines={METRICS.map((key, index) => ({
+                    key,
+                    color: metricColors[key],
+                    dash: DASHES[index],
+                    points: plotPoints.filter((p) => p.key === key),
+                  }))}
+                  markerColor={(key) => metricColors[key]}
                   xLabel={xLabel}
                   yLabel={t.percent}
                   reference={0}
-                  colors={metricColors}
+                  height={360}
                 />
               ) : (
                 <p className="py-6 text-sm text-muted-foreground">{t.empty}</p>
@@ -486,53 +455,35 @@ export default function PowerServiceComparison({
                 <p className="text-xs text-muted-foreground">{t.targetHelp}</p>
               )}
             </section>
-          </>
-        ))}
-      {roleShare && (
-        <section
-          id={`${chartId}-role-share`}
-          className="min-w-0 space-y-3"
-          data-testid="prefill-share-panel"
-        >
-          <Heading as="h3" level="card">
-            {t.share}
-          </Heading>
-          <p className="text-sm text-muted-foreground">{contextLabel}</p>
-          <p className="text-xs text-muted-foreground">{t.roleMethod}</p>
-          {shares.length > 0 ? (
-            <>
-              <div className="flex flex-wrap gap-3 text-sm">
-                {sources
-                  .filter((s) => shares.some((p) => p.sourceKey === s.key))
-                  .map((s) => (
-                    <span key={s.key} className="min-w-0 break-all">
-                      <span style={{ color: sourceColors[s.key] }}>● </span>
-                      {s.label}
-                    </span>
-                  ))}
-              </div>
-              <ComparisonPlot
-                chartId={`${chartId}-role-share`}
-                points={shares.map((p) => ({ key: p.sourceKey, x: p.x, y: p.prefillShare }))}
-                xLabel={xLabel}
-                yLabel={t.shareAxis}
-                reference={50}
-                colors={sourceColors}
-                lines={false}
-              />
-              <div className="max-h-0 overflow-hidden">
-                <div id={`${chartId}-role-share-export`} className="p-4" />
-              </div>
-              <ChartButtons
-                chartId={`${chartId}-role-share`}
-                analyticsPrefix="prefill_share"
-                hideZoomReset
-              />
-            </>
-          ) : (
-            <p className="py-6 text-sm text-muted-foreground">{t.roleEmpty}</p>
           )}
-        </section>
+          <MatchedConcurrencyTable
+            chartId={chartId}
+            data={data}
+            baseline={base}
+            comparator={peer}
+            interactivityField={interactivityField}
+            sourceLabel={sourceLabel}
+          />
+        </>
+      )}
+      {roleShare && (
+        <PowerRoleGroup
+          chartId={chartId}
+          data={data}
+          xField={xField}
+          xLabel={xLabel}
+          contextLabel={contextLabel}
+          sources={sources}
+          colorOf={colorOf}
+        />
+      )}
+      {powerFit && (
+        <PowerFitPanel
+          chartId={chartId}
+          data={data}
+          contextLabel={contextLabel}
+          colorOf={colorOf}
+        />
       )}
     </div>
   );
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
index f202b7b30..c3273782b 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
@@ -6,6 +6,7 @@ import {
   getEqualServiceComparisonCurve,
   getEqualServiceSources,
   getPrefillSharePoints,
+  getRolePoints,
 } from './equal-service-comparison';
 
 const metric = (y: number) => ({ y, roof: false });
@@ -292,4 +293,57 @@ describe('equal-service comparison', () => {
     });
     expect(getPrefillSharePoints([pd], 'conc')[0]).toMatchObject({ x: pd.conc, prefillShare: 50 });
   });
+
+  it('keeps role-local denominators apart from the additive output-token reconstruction', () => {
+    // GB200 1P1D at c4 (PowerX Figure 12): prefill 272 W/GPU, decode 421 W/GPU.
+    const pd = point({
+      hwKey: 'gb200_dynamo-sglang',
+      disagg: true,
+      conc: 4,
+      num_prefill_gpu: 4,
+      num_decode_gpu: 4,
+      power_valid: 1,
+      power_metric_schema_version: 2,
+      joules_per_input_token: 0.65,
+      joules_per_output_token: 5.2,
+      prefill_joules_per_input_token: 0.25,
+      decode_joules_per_output_token: 3.2,
+      measuredPrefillAvgPower: metric(272),
+      measuredDecodeAvgPower: metric(421),
+      measuredPrefillJPerInputToken: metric(0.25),
+      measuredDecodeJPerOutputToken: metric(3.2),
+    });
+    const [role] = getRolePoints([pd], 'conc');
+    expect(role).toMatchObject({
+      x: 4,
+      prefillWattsPerGpu: 272,
+      decodeWattsPerGpu: 421,
+      prefillJoulesPerInputToken: 0.25,
+      decodeJoulesPerOutputToken: 3.2,
+    });
+    // Prefill J/input × served J/out ÷ J/in = 0.25 × 8 = 2 J per output token.
+    expect(role.energy!.prefill).toBeCloseTo(2, 12);
+    expect(role.energy!.total).toBeCloseTo(5.2, 12);
+    expect(role.energy!.prefillShare).toBeCloseTo((100 * 2) / 5.2, 12);
+  });
+
+  it('keeps role watts without reconstructable energy and drops rows with no role figure', () => {
+    const wattsOnly = point({
+      disagg: true,
+      measuredPrefillAvgPower: metric(240),
+      measuredDecodeAvgPower: metric(330),
+    });
+    const [role] = getRolePoints(
+      [wattsOnly, point({ disagg: true }), point({ measuredPrefillAvgPower: metric(1) })],
+      'mean_intvty',
+    );
+    expect(role).toMatchObject({
+      prefillWattsPerGpu: 240,
+      decodeWattsPerGpu: 330,
+      prefillJoulesPerInputToken: null,
+      energy: null,
+    });
+    expect(getRolePoints([wattsOnly, point({ disagg: true })], 'mean_intvty')).toHaveLength(1);
+    expect(getRolePoints([wattsOnly], 'tpPerGpu' as never)).toEqual([]);
+  });
 });
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.ts b/packages/app/src/components/inference/utils/equal-service-comparison.ts
index fff7c3e78..3bcadea34 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.ts
@@ -1,7 +1,7 @@
 import type { AggDataEntry, InferenceData } from '../types';
 import { chipCounts } from '@/lib/chip-counts';
 import { isPositive, powerBasisNormalization } from '@/lib/power-basis';
-import { reconstructedRoleEnergy } from './role-energy';
+import { reconstructedRoleEnergy, type ReconstructedRoleEnergy } from './role-energy';
 import { pointTopologyKey, topologyLabel } from './topology-filter';
 
 export interface EqualServiceSource {
@@ -48,7 +48,10 @@ export interface EqualServiceComparison {
 const serviceAxis = (field: string) =>
   field === 'mean_tpot_intvty' ||
   /^(?:mean|median|p\d+(?:\.\d+)?)_(?:intvty|tpot|ttft|e2el|itl)$/u.test(field);
-const observed = (points: readonly InferenceData[]) =>
+/** A positive finite reading, or null: a missing value is never zero. */
+export const positiveOrNull = (value: unknown): number | null => (isPositive(value) ? value : null);
+/** Measured rows only: hidden rows and power-comparison clones are never sources. */
+export const observedPoints = (points: readonly InferenceData[]) =>
   points.filter((point) => !point.hidden && !point.powerVariant);
 
 /** Concurrency is excluded; unknown run identity must never join distinct rows. */
@@ -82,7 +85,9 @@ export function equalServiceSourceKey(point: InferenceData): string {
 }
 
 export function getEqualServiceSources(points: readonly InferenceData[]): EqualServiceSource[] {
-  const sources = new Map(observed(points).map((point) => [equalServiceSourceKey(point), point]));
+  const sources = new Map(
+    observedPoints(points).map((point) => [equalServiceSourceKey(point), point]),
+  );
   const topologies = [...sources.values()].map(pointTopologyKey);
   return [...sources]
     .sort(([a], [b]) => a.localeCompare(b))
@@ -121,7 +126,8 @@ function deploymentOutput(point: InferenceData): number | undefined {
     ? point.output_tput_per_gpu * count
     : undefined;
 }
-const metrics = {
+/** The measured quantities every service panel compares, read from one point. */
+export const serviceMetricValue = {
   meanWattsPerGpu: (point: InferenceData) => point.measuredAvgPower?.y,
   outputTokensPerSecond: deploymentOutput,
   joulesPerOutputToken: (point: InferenceData) => point.measuredJPerOutputToken?.y,
@@ -179,7 +185,7 @@ export function buildEqualServiceComparison(
   else if (!isPositive(target)) reason = 'invalid-target';
   else if (baseline === comparator) reason = 'same-source';
   else if (!sourceA || !sourceB) reason = 'unknown-source';
-  const rows = observed(points);
+  const rows = observedPoints(points);
   const a = rows.filter((point) => equalServiceSourceKey(point) === baseline);
   const b = rows.filter((point) => equalServiceSourceKey(point) === comparator);
   const compare = (quantity: (point: InferenceData) => number | undefined): EqualServiceMetric => {
@@ -204,9 +210,9 @@ export function buildEqualServiceComparison(
     comparator: sourceB,
     ...(reason ? { reason } : {}),
     metrics: {
-      meanWattsPerGpu: compare(metrics.meanWattsPerGpu),
-      outputTokensPerSecond: compare(metrics.outputTokensPerSecond),
-      joulesPerOutputToken: compare(metrics.joulesPerOutputToken),
+      meanWattsPerGpu: compare(serviceMetricValue.meanWattsPerGpu),
+      outputTokensPerSecond: compare(serviceMetricValue.outputTokensPerSecond),
+      joulesPerOutputToken: compare(serviceMetricValue.joulesPerOutputToken),
     },
   };
 }
@@ -218,7 +224,7 @@ export function getEqualServiceComparisonCurve(
 ): EqualServiceComparison[] {
   if (!serviceAxis(options.xField) || options.baseline === options.comparator) return [];
   const xs = (key: string) =>
-    observed(points)
+    observedPoints(points)
       .filter((point) => equalServiceSourceKey(point) === key)
       .map((point) => point[options.xField])
       .filter(isPositive);
@@ -238,7 +244,7 @@ export function getPrefillSharePoints(
   xField: keyof AggDataEntry,
 ) {
   if (!serviceAxis(xField) && xField !== 'conc') return [];
-  return observed(points)
+  return observedPoints(points)
     .flatMap((point) => {
       const x = point[xField];
       const energy = reconstructedRoleEnergy(point);
@@ -248,3 +254,52 @@ export function getPrefillSharePoints(
     })
     .sort((a, b) => a.sourceKey.localeCompare(b.sourceKey) || a.x - b.x);
 }
+
+export interface RolePoint {
+  x: number;
+  sourceKey: string;
+  point: InferenceData;
+  /** Mean board W/GPU inside each pool (role-local). */
+  prefillWattsPerGpu: number | null;
+  decodeWattsPerGpu: number | null;
+  /** Role-local energy: each pool's joules over its own token count. */
+  prefillJoulesPerInputToken: number | null;
+  decodeJoulesPerOutputToken: number | null;
+  /** Both pools on the output-token denominator, when reconstructable. */
+  energy: ReconstructedRoleEnergy | null;
+}
+
+/**
+ * Validated disaggregated rows with any role measurement (PowerX Figures
+ * 12–14). Pool-local denominators stay separate from the additive
+ * output-token reconstruction; a missing figure is null, never zero.
+ */
+export function getRolePoints(
+  points: readonly InferenceData[],
+  xField: keyof AggDataEntry,
+): RolePoint[] {
+  if (!serviceAxis(xField) && xField !== 'conc') return [];
+  return observedPoints(points)
+    .flatMap((point): RolePoint[] => {
+      const x = point[xField];
+      if (!point.disagg || !isPositive(x)) return [];
+      const role: RolePoint = {
+        x,
+        sourceKey: equalServiceSourceKey(point),
+        point,
+        prefillWattsPerGpu: positiveOrNull(point.measuredPrefillAvgPower?.y),
+        decodeWattsPerGpu: positiveOrNull(point.measuredDecodeAvgPower?.y),
+        prefillJoulesPerInputToken: positiveOrNull(point.measuredPrefillJPerInputToken?.y),
+        decodeJoulesPerOutputToken: positiveOrNull(point.measuredDecodeJPerOutputToken?.y),
+        energy: reconstructedRoleEnergy(point) ?? null,
+      };
+      const measured =
+        role.prefillWattsPerGpu !== null ||
+        role.decodeWattsPerGpu !== null ||
+        role.prefillJoulesPerInputToken !== null ||
+        role.decodeJoulesPerOutputToken !== null ||
+        role.energy !== null;
+      return measured ? [role] : [];
+    })
+    .sort((a, b) => a.sourceKey.localeCompare(b.sourceKey) || a.x - b.x);
+}
diff --git a/packages/app/src/components/inference/utils/matched-concurrency.test.ts b/packages/app/src/components/inference/utils/matched-concurrency.test.ts
new file mode 100644
index 000000000..f227d368b
--- /dev/null
+++ b/packages/app/src/components/inference/utils/matched-concurrency.test.ts
@@ -0,0 +1,149 @@
+import { describe, expect, it } from 'vitest';
+import type { InferenceData } from '../types';
+import { equalServiceSourceKey } from './equal-service-comparison';
+import { buildMatchedConcurrencyTable } from './matched-concurrency';
+
+const metric = (y: number) => ({ y, roof: false });
+function point(overrides: Partial<InferenceData> = {}): InferenceData {
+  return {
+    x: 100,
+    y: 1,
+    hwKey: 'b200_sglang',
+    date: '2026-09-18',
+    tp: 4,
+    physicalChips: 4,
+    precision: 'fp8',
+    conc: 1,
+    run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/35317697106/attempts/1',
+    model: 'Qwen-3.5-397B-A17B',
+    benchmark_type: 'single_turn',
+    isl: 8192,
+    osl: 1024,
+    decode_tp: 4,
+    output_tput_per_gpu: 50,
+    tpPerGpu: metric(50),
+    tpPerMw: metric(50),
+    costh: metric(1),
+    costr: metric(1),
+    costhi: metric(1),
+    costri: metric(1),
+    ...overrides,
+  };
+}
+// PowerX Figure 6 values (B200 / MI355X, TP4, three-dispatch means).
+const b200 = (conc: number, joules: number, watts: number, speed: number, id: number) =>
+  point({
+    id,
+    conc,
+    mean_tpot_intvty: speed,
+    measuredJPerOutputToken: metric(joules),
+    measuredAvgPower: metric(watts),
+  });
+const mi355x = (conc: number, joules: number, watts: number, speed: number, id: number) =>
+  point({
+    id,
+    conc,
+    hwKey: 'mi355x_sglang',
+    run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/33348766792/attempts/2',
+    mean_tpot_intvty: speed,
+    measuredJPerOutputToken: metric(joules),
+    measuredAvgPower: metric(watts),
+  });
+const baseline = [b200(1, 9.065, 402, 186.9, 1), b200(4, 3.87, 507, 141.2, 2)];
+const comparator = [mi355x(1, 13.271, 412, 128.1, 11), mi355x(128, 1.311, 869, 22.1, 12)];
+const options = {
+  baseline: equalServiceSourceKey(baseline[0]),
+  comparator: equalServiceSourceKey(comparator[0]),
+  interactivityField: 'mean_tpot_intvty' as const,
+};
+
+describe('matched-concurrency table', () => {
+  it('pairs observed rows by concurrency with one signed change convention', () => {
+    const table = buildMatchedConcurrencyTable([...baseline, ...comparator], options);
+    expect(table.reason).toBeUndefined();
+    expect(table.rows.map((row) => row.concurrency)).toEqual([1, 4, 128]);
+    const [first] = table.rows;
+    expect(first.baseline).toMatchObject({
+      status: 'observed',
+      values: { joulesPerOutputToken: 9.065, meanWattsPerGpu: 402, interactivity: 186.9 },
+    });
+    expect(first.changePercent.joulesPerOutputToken).toBeCloseTo(46.4, 1);
+    expect(first.changePercent.meanWattsPerGpu).toBeCloseTo(2.49, 2);
+    expect(first.changePercent.interactivity).toBeCloseTo(-31.46, 2);
+  });
+
+  it('marks a load one source did not measure instead of borrowing a neighbour', () => {
+    const table = buildMatchedConcurrencyTable([...baseline, ...comparator], options);
+    const c4 = table.rows.find((row) => row.concurrency === 4)!;
+    expect(c4.baseline.status).toBe('observed');
+    expect(c4.comparator.status).toBe('missing');
+    expect(c4.changePercent).toEqual({
+      joulesPerOutputToken: null,
+      meanWattsPerGpu: null,
+      interactivity: null,
+    });
+    const c128 = table.rows.find((row) => row.concurrency === 128)!;
+    expect(c128.baseline.status).toBe('missing');
+  });
+
+  it('keeps a missing metric null while still comparing the metrics both sides measured', () => {
+    const noEnergy = mi355x(1, 13.271, 412, 128.1, 11);
+    delete noEnergy.measuredJPerOutputToken;
+    const table = buildMatchedConcurrencyTable([baseline[0], noEnergy], options);
+    expect(table.rows[0].comparator).toMatchObject({
+      status: 'observed',
+      values: { joulesPerOutputToken: null },
+    });
+    expect(table.rows[0].changePercent.joulesPerOutputToken).toBeNull();
+    expect(table.rows[0].changePercent.meanWattsPerGpu).toBeCloseTo(2.49, 2);
+  });
+
+  it('refuses to pick between conflicting observations of one source at one load', () => {
+    const repeat = b200(1, 9.5, 410, 180, 3);
+    const table = buildMatchedConcurrencyTable([...baseline, repeat, ...comparator], options);
+    const c1 = table.rows[0];
+    expect(c1.baseline.status).toBe('ambiguous');
+    expect(c1.baseline.status === 'ambiguous' && c1.baseline.points.map((p) => p.id)).toEqual([
+      1, 3,
+    ]);
+    expect(c1.changePercent.joulesPerOutputToken).toBeNull();
+    const duplicate = { ...baseline[0], id: 4 };
+    const agreed = buildMatchedConcurrencyTable([...baseline, duplicate, ...comparator], options);
+    expect(agreed.rows[0].baseline.status).toBe('observed');
+  });
+
+  it('ignores power-comparison clones, hidden rows and non-positive loads', () => {
+    const clone = {
+      ...b200(8, 1, 1000, 100, 5),
+      powerVariant: { kind: 'basis', id: 'gpu-provisioned' },
+    } as InferenceData;
+    const hidden = { ...b200(16, 2, 600, 80, 6), hidden: true };
+    const zero = b200(0, 2, 600, 80, 7);
+    const table = buildMatchedConcurrencyTable(
+      [...baseline, clone, hidden, zero, ...comparator],
+      options,
+    );
+    expect(table.rows.map((row) => row.concurrency)).toEqual([1, 4, 128]);
+  });
+
+  it('reports why no table exists for one or unknown sources', () => {
+    expect(
+      buildMatchedConcurrencyTable(baseline, { ...options, comparator: options.baseline }),
+    ).toMatchObject({ reason: 'same-source', rows: [] });
+    expect(
+      buildMatchedConcurrencyTable(baseline, { ...options, comparator: 'missing' }),
+    ).toMatchObject({ reason: 'unknown-source', rows: [] });
+  });
+
+  it('reads streaming speed from the selected statistic field', () => {
+    const median = buildMatchedConcurrencyTable(
+      [
+        { ...baseline[0], median_intvty: 190 },
+        { ...comparator[0], median_intvty: 133 },
+      ],
+      { ...options, interactivityField: 'median_intvty' },
+    );
+    expect(median.rows[0].baseline).toMatchObject({ values: { interactivity: 190 } });
+    expect(median.rows[0].changePercent.interactivity).toBeCloseTo(-30, 1);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/matched-concurrency.ts b/packages/app/src/components/inference/utils/matched-concurrency.ts
new file mode 100644
index 000000000..41d97e868
--- /dev/null
+++ b/packages/app/src/components/inference/utils/matched-concurrency.ts
@@ -0,0 +1,128 @@
+import type { AggDataEntry, InferenceData } from '../types';
+import {
+  equalServiceSourceKey,
+  getEqualServiceSources,
+  observedPoints,
+  positiveOrNull,
+  serviceMetricValue,
+  type EqualServiceSource,
+} from './equal-service-comparison';
+
+/**
+ * Pairs two sources' observations at the same concurrency (PowerX Figures 6,
+ * 7 and 9). Matched load is a diagnostic next to the equal-service comparison,
+ * not a replacement: the two sources usually serve different speeds at one
+ * concurrency. Nothing is interpolated, averaged or carried between rows.
+ */
+export const MATCHED_CONCURRENCY_METRICS = [
+  'joulesPerOutputToken',
+  'meanWattsPerGpu',
+  'interactivity',
+] as const;
+export type MatchedConcurrencyMetric = (typeof MATCHED_CONCURRENCY_METRICS)[number];
+export type MatchedConcurrencyValues = Record<MatchedConcurrencyMetric, number | null>;
+
+export type MatchedConcurrencySide =
+  | { status: 'observed'; point: InferenceData; values: MatchedConcurrencyValues }
+  | { status: 'missing' }
+  /** Several observations of one source at one load disagree; none is chosen. */
+  | { status: 'ambiguous'; points: InferenceData[] };
+
+export interface MatchedConcurrencyRow {
+  concurrency: number;
+  baseline: MatchedConcurrencySide;
+  comparator: MatchedConcurrencySide;
+  /** `100 × (comparator ÷ baseline − 1)`; null unless both values were observed. */
+  changePercent: MatchedConcurrencyValues;
+}
+
+export type MatchedConcurrencyReason = 'same-source' | 'unknown-source';
+
+export interface MatchedConcurrencyTable {
+  baseline: EqualServiceSource | null;
+  comparator: EqualServiceSource | null;
+  /** Streaming-speed field read for the `interactivity` column (selected statistic). */
+  interactivityField: keyof AggDataEntry;
+  reason?: MatchedConcurrencyReason;
+  rows: MatchedConcurrencyRow[];
+}
+
+const NO_CHANGE: MatchedConcurrencyValues = {
+  joulesPerOutputToken: null,
+  meanWattsPerGpu: null,
+  interactivity: null,
+};
+
+function values(point: InferenceData, field: keyof AggDataEntry): MatchedConcurrencyValues {
+  return {
+    joulesPerOutputToken: positiveOrNull(serviceMetricValue.joulesPerOutputToken(point)),
+    meanWattsPerGpu: positiveOrNull(serviceMetricValue.meanWattsPerGpu(point)),
+    interactivity: positiveOrNull(point[field]),
+  };
+}
+
+function side(points: readonly InferenceData[], field: keyof AggDataEntry): MatchedConcurrencySide {
+  if (points.length === 0) return { status: 'missing' };
+  const first = values(points[0], field);
+  const agree = points.every((point) => {
+    const other = values(point, field);
+    return MATCHED_CONCURRENCY_METRICS.every((key) => Object.is(other[key], first[key]));
+  });
+  return agree
+    ? { status: 'observed', point: points[0], values: first }
+    : { status: 'ambiguous', points: [...points] };
+}
+
+export function buildMatchedConcurrencyTable(
+  points: readonly InferenceData[],
+  options: { baseline: string; comparator: string; interactivityField: keyof AggDataEntry },
+): MatchedConcurrencyTable {
+  const { baseline, comparator, interactivityField } = options;
+  const sources = getEqualServiceSources(points);
+  const sourceA = sources.find((source) => source.key === baseline) ?? null;
+  const sourceB = sources.find((source) => source.key === comparator) ?? null;
+  const table = { baseline: sourceA, comparator: sourceB, interactivityField };
+  if (baseline === comparator) return { ...table, reason: 'same-source', rows: [] };
+  if (!sourceA || !sourceB) return { ...table, reason: 'unknown-source', rows: [] };
+
+  const byConcurrency = (key: string) => {
+    const groups = new Map<number, InferenceData[]>();
+    for (const point of observedPoints(points)) {
+      if (equalServiceSourceKey(point) !== key || !Number.isSafeInteger(point.conc)) continue;
+      if (point.conc <= 0) continue;
+      const group = groups.get(point.conc);
+      if (group) group.push(point);
+      else groups.set(point.conc, [point]);
+    }
+    return groups;
+  };
+  const a = byConcurrency(baseline);
+  const b = byConcurrency(comparator);
+  const rows = [...new Set([...a.keys(), ...b.keys()])]
+    .toSorted((x, y) => x - y)
+    .map((concurrency): MatchedConcurrencyRow => {
+      const left = side(a.get(concurrency) ?? [], interactivityField);
+      const right = side(b.get(concurrency) ?? [], interactivityField);
+      if (left.status !== 'observed' || right.status !== 'observed') {
+        return { concurrency, baseline: left, comparator: right, changePercent: NO_CHANGE };
+      }
+      const change = (key: MatchedConcurrencyMetric) => {
+        const before = left.values[key];
+        const after = right.values[key];
+        if (before === null || after === null) return null;
+        const percent = 100 * (after / before - 1);
+        return Number.isFinite(percent) ? percent : null;
+      };
+      return {
+        concurrency,
+        baseline: left,
+        comparator: right,
+        changePercent: {
+          joulesPerOutputToken: change('joulesPerOutputToken'),
+          meanWattsPerGpu: change('meanWattsPerGpu'),
+          interactivity: change('interactivity'),
+        },
+      };
+    });
+  return { ...table, rows };
+}
diff --git a/packages/app/src/components/inference/utils/power-fit.test.ts b/packages/app/src/components/inference/utils/power-fit.test.ts
new file mode 100644
index 000000000..f3e438249
--- /dev/null
+++ b/packages/app/src/components/inference/utils/power-fit.test.ts
@@ -0,0 +1,163 @@
+import { describe, expect, it } from 'vitest';
+import type { InferenceData } from '../types';
+import {
+  buildPowerFits,
+  MIN_FIT_POINTS,
+  ordinaryLeastSquares,
+  outputRatePerAllocatedGpu,
+} from './power-fit';
+
+const metric = (y: number) => ({ y, roof: false });
+function point(overrides: Partial<InferenceData> = {}): InferenceData {
+  return {
+    x: 100,
+    y: 1,
+    hwKey: 'h200_sglang',
+    date: '2026-09-18',
+    tp: 8,
+    physicalChips: 8,
+    precision: 'fp8',
+    conc: 1,
+    run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28719990565/attempts/1',
+    model: 'Qwen-3.5-397B-A17B',
+    benchmark_type: 'single_turn',
+    isl: 8192,
+    osl: 1024,
+    decode_tp: 8,
+    output_tput_per_gpu: 50,
+    tpPerGpu: metric(50),
+    tpPerMw: metric(50),
+    costh: metric(1),
+    costr: metric(1),
+    costhi: metric(1),
+    costri: metric(1),
+    ...overrides,
+  };
+}
+const ladder = (throughputs: number[], watts: (x: number) => number, base = {}) =>
+  throughputs.map((x, index) =>
+    point({
+      id: index + 1,
+      conc: 2 ** index,
+      output_tput_per_gpu: x,
+      measuredAvgPower: metric(watts(x)),
+      ...base,
+    }),
+  );
+
+describe('ordinaryLeastSquares', () => {
+  it('recovers an exact line and its observed range', () => {
+    const fit = ordinaryLeastSquares([20, 50, 100, 260].map((x) => ({ x, y: 235 + 0.97 * x })));
+    expect(fit!.intercept).toBeCloseTo(235, 9);
+    expect(fit!.slope).toBeCloseTo(0.97, 9);
+    expect(fit!.rSquared).toBeCloseTo(1, 12);
+    expect(fit).toMatchObject({ n: 4, xMin: 20, xMax: 260 });
+  });
+
+  it('reports R² below one for scattered observations', () => {
+    const fit = ordinaryLeastSquares([
+      { x: 1, y: 2 },
+      { x: 2, y: 3 },
+      { x: 3, y: 7 },
+    ]);
+    // Least squares: slope 2.5, intercept -1, residuals (0.5, -1, 0.5) → SSres 1.5, SStot 14.
+    expect(fit!.slope).toBeCloseTo(2.5, 12);
+    expect(fit!.intercept).toBeCloseTo(-1, 12);
+    expect(fit!.rSquared).toBeCloseTo(1 - 1.5 / 14, 12);
+  });
+
+  it('has no line without throughput variance and no R² without power variance', () => {
+    expect(
+      ordinaryLeastSquares([
+        { x: 5, y: 1 },
+        { x: 5, y: 2 },
+      ]),
+    ).toBeNull();
+    expect(ordinaryLeastSquares([])).toBeNull();
+    const flat = ordinaryLeastSquares([1, 2, 3].map((x) => ({ x, y: 400 })));
+    expect(flat).toMatchObject({ slope: 0, intercept: 400, rSquared: null });
+  });
+});
+
+describe('outputRatePerAllocatedGpu', () => {
+  it('keeps aggregated per-GPU output and spreads disaggregated output over every GPU', () => {
+    expect(outputRatePerAllocatedGpu(point({ output_tput_per_gpu: 42 }))).toBe(42);
+    // Fixed-sequence disagg rows report output per decode GPU: 4 × 100 ÷ (4 + 4).
+    expect(
+      outputRatePerAllocatedGpu(
+        point({ disagg: true, num_prefill_gpu: 4, num_decode_gpu: 4, output_tput_per_gpu: 100 }),
+      ),
+    ).toBe(50);
+    expect(
+      outputRatePerAllocatedGpu(
+        point({ disagg: true, num_prefill_gpu: 4, num_decode_gpu: 16, output_tput_per_gpu: 25 }),
+      ),
+    ).toBe(20);
+    // AgentX disagg throughput semantics are not verifiable in-app.
+    expect(
+      outputRatePerAllocatedGpu(
+        point({
+          disagg: true,
+          benchmark_type: 'agentic_traces',
+          num_prefill_gpu: 4,
+          num_decode_gpu: 4,
+        }),
+      ),
+    ).toBeUndefined();
+    expect(outputRatePerAllocatedGpu(point({ output_tput_per_gpu: 0 }))).toBeUndefined();
+  });
+});
+
+describe('buildPowerFits', () => {
+  it('fits each source on its own observations', () => {
+    const h200 = ladder([20, 60, 120, 260], (x) => 235 + 0.97 * x);
+    const b200 = ladder([40, 200, 600, 930], (x) => 454 + 0.44 * x, {
+      hwKey: 'b200_sglang',
+      run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/35317697106/attempts/1',
+    });
+    const fits = buildPowerFits([...b200, ...h200]);
+    expect(fits).toHaveLength(2);
+    const byHw = Object.fromEntries(fits.map((fit) => [fit.observations[0].point.hwKey, fit]));
+    expect(byHw.h200_sglang.fit!.intercept).toBeCloseTo(235, 9);
+    expect(byHw.h200_sglang.fit!.slope).toBeCloseTo(0.97, 9);
+    expect(byHw.b200_sglang.fit!.intercept).toBeCloseTo(454, 9);
+    expect(byHw.b200_sglang.fit).toMatchObject({ n: 4, xMin: 40, xMax: 930 });
+    // Rated TDP from the hardware registry, for reading P0 ÷ TDP.
+    expect(byHw.h200_sglang.tdpWatts).toBe(700);
+    expect(byHw.b200_sglang.tdpWatts).toBe(1000);
+  });
+
+  it(`requires ${MIN_FIT_POINTS} distinct throughputs and keeps the observations it could not fit`, () => {
+    const two = ladder([20, 60], (x) => 235 + x);
+    const [fit] = buildPowerFits(two);
+    expect(fit).toMatchObject({ fit: null, reason: 'too-few-points' });
+    expect(fit.observations.map((observation) => observation.x)).toEqual([20, 60]);
+  });
+
+  it('skips rows without measured power and sources with nothing measured', () => {
+    const measured = ladder([20, 60, 120], (x) => 300 + x);
+    const unmeasured = ladder([30, 90, 150], () => 0, {
+      hwKey: 'b300_sglang',
+      run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/31756025413/attempts/1',
+    }).map(({ measuredAvgPower: _measured, ...rest }) => rest as InferenceData);
+    const fits = buildPowerFits([...measured, ...unmeasured]);
+    expect(fits).toHaveLength(1);
+    expect(fits[0].observations).toHaveLength(3);
+  });
+
+  it('fits disaggregated sources on output per allocated GPU', () => {
+    const gb200 = ladder([100, 300, 500], () => 0, {
+      hwKey: 'gb200_dynamo-sglang',
+      disagg: true,
+      num_prefill_gpu: 4,
+      num_decode_gpu: 4,
+    }).map((entry) => ({
+      ...entry,
+      measuredAvgPower: metric(307 + 0.7 * (entry.output_tput_per_gpu! / 2)),
+    }));
+    const [fit] = buildPowerFits(gb200);
+    expect(fit.observations.map((observation) => observation.x)).toEqual([50, 150, 250]);
+    expect(fit.fit!.intercept).toBeCloseTo(307, 9);
+    expect(fit.fit!.slope).toBeCloseTo(0.7, 9);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/power-fit.ts b/packages/app/src/components/inference/utils/power-fit.ts
new file mode 100644
index 000000000..09fb2f262
--- /dev/null
+++ b/packages/app/src/components/inference/utils/power-fit.ts
@@ -0,0 +1,122 @@
+import type { InferenceData } from '../types';
+import { getGpuSpecs } from '@/lib/constants';
+import { isPositive, powerBasisNormalization } from '@/lib/power-basis';
+import {
+  equalServiceSourceKey,
+  getEqualServiceSources,
+  observedPoints,
+  type EqualServiceSource,
+} from './equal-service-comparison';
+
+/**
+ * Serving-regime power model per source (PowerX Figure 15): an ordinary
+ * least-squares line `W/GPU = P0 + m × output tok/s per GPU` through one
+ * source's measured load points. `P0` is the fit's zero-throughput intercept,
+ * not measured idle power; `m` is marginal GPU energy per output token in
+ * joules. The fit describes only the observed throughput range.
+ */
+
+/** Distinct throughputs a line needs before its intercept and R² mean anything. */
+export const MIN_FIT_POINTS = 3;
+
+export interface LinearFit {
+  /** `P0`, W/GPU at zero output rate (extrapolated). */
+  intercept: number;
+  /** `m`, J per output token (W per output tok/s/GPU). */
+  slope: number;
+  /** Null when every observation draws the same power (no variance to explain). */
+  rSquared: number | null;
+  n: number;
+  xMin: number;
+  xMax: number;
+}
+
+export function ordinaryLeastSquares(pairs: readonly { x: number; y: number }[]): LinearFit | null {
+  const n = pairs.length;
+  if (n === 0) return null;
+  const xMean = pairs.reduce((sum, pair) => sum + pair.x, 0) / n;
+  const yMean = pairs.reduce((sum, pair) => sum + pair.y, 0) / n;
+  let sxx = 0;
+  let sxy = 0;
+  let syy = 0;
+  for (const { x, y } of pairs) {
+    sxx += (x - xMean) ** 2;
+    sxy += (x - xMean) * (y - yMean);
+    syy += (y - yMean) ** 2;
+  }
+  if (!(sxx > 0)) return null;
+  const slope = sxy / sxx;
+  const intercept = yMean - slope * xMean;
+  const residual = pairs.reduce((sum, { x, y }) => sum + (y - (intercept + slope * x)) ** 2, 0);
+  return {
+    intercept,
+    slope,
+    rSquared: syy > 0 ? 1 - residual / syy : null,
+    n,
+    xMin: Math.min(...pairs.map((pair) => pair.x)),
+    xMax: Math.max(...pairs.map((pair) => pair.x)),
+  };
+}
+
+/**
+ * Whole-deployment output tokens/s divided by every allocated GPU, so a
+ * disaggregated deployment's prefill GPUs share the output they enable and its
+ * mean W/GPU (averaged over all GPUs) sits on the same basis.
+ */
+export function outputRatePerAllocatedGpu(point: InferenceData): number | undefined {
+  if (!isPositive(point.output_tput_per_gpu)) return undefined;
+  const { allocatedGpus, totalOutputTokPerSec } = powerBasisNormalization({
+    output_tput_per_gpu: point.output_tput_per_gpu,
+    disagg: Boolean(point.disagg),
+    benchmark_type: point.benchmark_type,
+    num_prefill_gpu: point.num_prefill_gpu ?? 0,
+    num_decode_gpu: point.num_decode_gpu ?? 0,
+  });
+  return isPositive(allocatedGpus) && isPositive(totalOutputTokPerSec)
+    ? totalOutputTokPerSec / allocatedGpus
+    : undefined;
+}
+
+export interface PowerFitObservation {
+  /** Output tok/s per allocated GPU. */
+  x: number;
+  /** Measured mean GPU-board W/GPU. */
+  y: number;
+  point: InferenceData;
+}
+
+export interface PowerFit {
+  source: EqualServiceSource;
+  /** Rated board TDP per GPU from the hardware registry, to read `P0 ÷ TDP`; null when unknown. */
+  tdpWatts: number | null;
+  observations: PowerFitObservation[];
+  fit: LinearFit | null;
+  reason?: 'too-few-points';
+}
+
+/** One fit per equal-service source that has any measured observation. */
+export function buildPowerFits(points: readonly InferenceData[]): PowerFit[] {
+  const rows = observedPoints(points);
+  return getEqualServiceSources(points).flatMap((source): PowerFit[] => {
+    const observations = rows
+      .filter((point) => equalServiceSourceKey(point) === source.key)
+      .flatMap((point) => {
+        const x = outputRatePerAllocatedGpu(point);
+        const y = point.measuredAvgPower?.y;
+        return isPositive(x) && isPositive(y) ? [{ x, y, point }] : [];
+      })
+      .toSorted((a, b) => a.x - b.x || (a.point.id ?? 0) - (b.point.id ?? 0));
+    if (observations.length === 0) return [];
+    const tdp = getGpuSpecs(observations[0].point.hwKey).tdp;
+    const tdpWatts = isPositive(tdp) ? tdp : null;
+    const fit =
+      new Set(observations.map((observation) => observation.x)).size >= MIN_FIT_POINTS
+        ? ordinaryLeastSquares(observations)
+        : null;
+    return [
+      fit
+        ? { source, tdpWatts, observations, fit }
+        : { source, tdpWatts, observations, fit: null, reason: 'too-few-points' },
+    ];
+  });
+}
diff --git a/packages/app/src/components/inference/utils/resolveXAxisField.ts b/packages/app/src/components/inference/utils/resolveXAxisField.ts
index 834befae2..06b48aa10 100644
--- a/packages/app/src/components/inference/utils/resolveXAxisField.ts
+++ b/packages/app/src/components/inference/utils/resolveXAxisField.ts
@@ -37,6 +37,22 @@ export interface ResolvedXAxis {
   branch: XAxisBranch;
 }
 
+/**
+ * A service-metric field at the selected statistic: the percentile for agentic
+ * rows, mean or median for fixed sequences. Fixed-sequence mean interactivity
+ * is reciprocal mean TPOT, never the raw arithmetic-mean interactivity field.
+ */
+export function resolveServiceField(
+  field: string,
+  opts: { isAgentic: boolean; percentile: string; fixedSequenceStatistic?: FixedSequenceStatistic },
+): keyof AggDataEntry {
+  const { isAgentic, percentile, fixedSequenceStatistic = 'median' } = opts;
+  const resolved = withPercentile(field, isAgentic ? percentile : fixedSequenceStatistic);
+  return (
+    !isAgentic && resolved === 'mean_intvty' ? 'mean_tpot_intvty' : resolved
+  ) as keyof AggDataEntry;
+}
+
 /**
  * Resolve the x-axis data field for a chart definition + metric selection.
  *
@@ -68,14 +84,8 @@ export function resolveXAxisField(
     fixedSequenceStatistic?: FixedSequenceStatistic;
   },
 ): ResolvedXAxis {
-  const { isAgentic, percentile, xAxisMode, fixedSequenceStatistic = 'median' } = opts;
-  const statistic = isAgentic ? percentile : fixedSequenceStatistic;
-  const serviceField = (field: string): keyof AggDataEntry => {
-    const resolved = withPercentile(field, statistic);
-    return (
-      !isAgentic && resolved === 'mean_intvty' ? 'mean_tpot_intvty' : resolved
-    ) as keyof AggDataEntry;
-  };
+  const { isAgentic, percentile, xAxisMode } = opts;
+  const serviceField = (field: string) => resolveServiceField(field, opts);
   const naturalX = serviceField(chartDef.x);
 
   const metricTitle =
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 68cfd9d97..884fd4e9c 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -806,7 +806,7 @@ export interface ApiContractSourceDigest {
 export const apiContractSourceDigests = [
   {
     source: 'src/components/inference/utils/resolveXAxisField.ts',
-    sourceSha256: 'd59ad021fbe8e8547a811fc83ce63adb2373c3005d2668844f2dcbcb61448e1f',
+    sourceSha256: '4783579c7b3c1a21b91968cb03e9c35a57a85251f4992cb5667a855ba7c77497',
     reviewArea: {
       en: 'Shared service-axis resolution: fixed-sequence mean/median, reciprocal mean TPOT, and AgentX percentile isolation.',
       zh: '共用服务轴解析：固定长度工作负载 mean/median、mean TPOT 的倒数，以及 AgentX 独立的分位数选择。',
@@ -814,10 +814,10 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/inference/utils/equal-service-comparison.ts',
-    sourceSha256: 'e6e1e07a3dfaa4cfa0ea1bd9b6e8f7cc9a6fc43f043b9f07ef1651d4422c01db',
+    sourceSha256: 'adbc79b5fe8d14d8e16cc6edd757324447f12cf0656631ec9b16415e5e0795e2',
     reviewArea: {
-      en: 'Source-scoped equal-service interpolation, comparator-relative changes, endpoint provenance, and prefill share projection.',
-      zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源，以及 prefill 占比视图。',
+      en: 'Source-scoped equal-service interpolation, comparator-relative changes, endpoint provenance, prefill share projection and role points.',
+      zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源、prefill 占比视图以及各角色数据点。',
     },
   },
   {
diff --git a/packages/app/src/lib/url-state.ts b/packages/app/src/lib/url-state.ts
index 187d315da..648d0676f 100644
--- a/packages/app/src/lib/url-state.ts
+++ b/packages/app/src/lib/url-state.ts
@@ -36,6 +36,7 @@ const URL_STATE_KEYS = [
   'i_servicepeer',
   'i_servicetarget',
   'i_roleshare',
+  'i_powerfit',
   'i_xmetric',
   'i_e2e_xmetric',
   'i_xmode',
@@ -174,6 +175,7 @@ export const PARAM_DEFAULTS: Record<UrlStateKey, string> = {
   i_servicepeer: '',
   i_servicetarget: '',
   i_roleshare: '0',
+  i_powerfit: '0',
   i_xmetric: 'p90_ttft',
   i_e2e_xmetric: 'p90_ttft',
   i_xmode: '',

From 8476487d069db7e766865e601acba97f149273a6 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Thu, 24 Sep 2026 15:59:17 -0700
Subject: [PATCH 036/103] feat: compare PowerX timelines at one load
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

i_ptconc limits the Timeline to one concurrency so GB200 and GB300 pools
align on validated windows. Summary lists validated W/GPU, peak 1-s pool
power, pool TDP and telemetry source. Run cap prefers runs the legend
shows; trace labels stack instead of overlapping.

中文：PowerX Timeline 支持单一负载对比。i_ptconc 将 Timeline 限定为一个并发，
使 GB200 与 GB300 各池按有效窗口对齐；汇总表列出有效窗口 W/GPU、池功耗 1 秒峰值、
池 TDP 与遥测来源。运行数上限优先加载图例中显示的运行，曲线标签错行排列，不再重叠。
---
 .../cypress/component/power-timeline.cy.tsx   | 174 +++++++++++++++-
 .../src/components/gpu-power/power-series.ts  |   2 +
 .../components/inference/ui/PowerTimeline.tsx | 192 ++++++++++++-----
 .../inference/ui/PowerTimelineSummary.tsx     | 197 ++++++++++++++++++
 .../inference/utils/powerTimeline.test.ts     |  97 ++++++++-
 .../inference/utils/powerTimeline.ts          |  89 ++++++++
 packages/app/src/lib/url-state.ts             |   3 +
 7 files changed, 694 insertions(+), 60 deletions(-)
 create mode 100644 packages/app/src/components/inference/ui/PowerTimelineSummary.tsx

diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index e23349b77..9a69b113e 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -218,6 +218,7 @@ function mountTimeline(
     width?: number;
     overlay?: Parameters<typeof PowerTimeline>[0]['overlayData'];
     unofficial?: Parameters<typeof createMockUnofficialRunContext>[0];
+    activeHwTypes?: readonly string[];
   } = {},
 ) {
   mountWithProviders(
@@ -241,7 +242,7 @@ function mountTimeline(
         selectedSequence: Sequence.EightK_OneK,
         selectedYAxisMetric: 'y_measuredPowerTimeline',
         hardwareConfig: hwConfig,
-        activeHwTypes: new Set(HW_TYPES),
+        activeHwTypes: new Set(options.activeHwTypes ?? HW_TYPES),
         hwTypesWithData: new Set(HW_TYPES),
       },
       unofficial: options.unofficial ?? {},
@@ -253,7 +254,14 @@ const svg = () => cy.get('[data-testid="power-timeline-chart-svg"]');
 
 describe('PowerTimeline', () => {
   beforeEach(() => {
-    writeUrlParams({ i_ptaxis: '', i_ptlines: '', i_ptwindow: '', i_ptfocus: '', i_ptutility: '' });
+    writeUrlParams({
+      i_ptaxis: '',
+      i_ptlines: '',
+      i_ptwindow: '',
+      i_ptfocus: '',
+      i_ptutility: '',
+      i_ptconc: '',
+    });
     readUrlParams();
     cy.on('uncaught:exception', (error) => {
       if (error.message.includes('ResizeObserver loop')) return false;
@@ -618,6 +626,41 @@ describe('PowerTimeline', () => {
     });
   });
 
+  it('gives the run cap to runs the legend shows before runs it hides', () => {
+    // Four H100 runs sort first and would fill the cap, but the legend hides
+    // H100, so the B200 run behind them is fetched and drawn instead.
+    const hiddenRuns = ['30000000001', '30000000002', '30000000003', '30000000004'];
+    const hiddenPoints = hiddenRuns.map((runId, index) =>
+      measuredPoint('h100', 8 * 2 ** index, 600, { run_url: runUrlFor(runId) }),
+    );
+    hiddenRuns.forEach((runId, index) => {
+      cy.intercept('POST', `/api/gpu-metrics?runId=${runId}*`, {
+        body: {
+          runInfo: { ...response.runInfo, id: Number(runId), url: runUrlFor(runId) },
+          series: [series('h100', 8 * 2 ** index, 600)],
+        } satisfies GpuPowerSeriesResponse,
+      }).as(`hidden${index}`);
+    });
+    const shownRun = '30000000005';
+    cy.intercept('POST', `/api/gpu-metrics?runId=${shownRun}*`, {
+      body: {
+        runInfo: { ...response.runInfo, id: Number(shownRun), url: runUrlFor(shownRun) },
+        series: [series('b200', 16, 700)],
+      } satisfies GpuPowerSeriesResponse,
+    }).as('shown');
+    mountTimeline(
+      [...hiddenPoints, measuredPoint('b200', 16, 700, { run_url: runUrlFor(shownRun) })],
+      { activeHwTypes: ['b200', 'gb200'] },
+    );
+    cy.wait(['@shown', '@hidden0', '@hidden1', '@hidden2']);
+    cy.get('@hidden3.all').should('have.length', 0);
+    cy.get('[data-testid="power-timeline-status"]').should(
+      'contain.text',
+      'Telemetry from 1 more run was not loaded',
+    );
+    svg().find('path.power-trace[data-hw="b200"][data-segment="window"]').should('have.length', 1);
+  });
+
   it('reports a failed run and hides traces the legend has switched off', () => {
     cy.intercept('POST', '/api/gpu-metrics*', {
       statusCode: 500,
@@ -861,4 +904,131 @@ describe('PowerTimeline', () => {
       .and('contain.text', '池功耗： 1,200 W')
       .and('contain.text', '池 TDP');
   });
+  describe('same-load comparison across platforms', () => {
+    // B200 and a disaggregated GB200 deployment both measured at c8, plus a
+    // B200 c64 row that the concurrency filter removes.
+    const rolePoint = () =>
+      disaggPoint(8, 800, {
+        measuredPrefillAvgPower: { y: 900, roof: false },
+        measuredDecodeAvgPower: { y: 700, roof: false },
+      });
+    const points = () => [
+      measuredPoint('b200', 8, 650),
+      measuredPoint('b200', 64, 900),
+      rolePoint(),
+    ];
+    const sameLoadResponse: GpuPowerSeriesResponse = {
+      source: 'database',
+      runInfo: response.runInfo,
+      series: [series('b200', 8, 650), series('b200', 64, 900), poolSeries(8)],
+    };
+    const labels = () =>
+      svg()
+        .find('text.power-trace-label')
+        .then(($labels) => [...$labels].map((label) => label.textContent).toSorted());
+
+    it('filters every platform to one concurrency and names the hardware on each line', () => {
+      cy.intercept('POST', '/api/gpu-metrics*', { body: sameLoadResponse }).as('series');
+      mountTimeline(points());
+      cy.wait('@series');
+      labels().should('deep.equal', ['B200 c64', 'B200 c8', 'GB200 NVL72 c8']);
+      cy.get('[data-testid="power-timeline-concurrency"]').select('c8');
+      labels().should('deep.equal', ['B200 c8', 'GB200 NVL72 c8']);
+      svg().find('path.power-trace[data-segment="window"]').should('have.length', 2);
+      cy.get('[data-testid="power-timeline-summary-trace"]').should('have.length', 2);
+      cy.then(() => expect(new URL(buildShareUrl()).searchParams.get('i_ptconc')).to.eq('8'));
+      cy.get('[data-testid="power-timeline-concurrency"]').select('All');
+      svg().find('path.power-trace[data-segment="window"]').should('have.length', 3);
+      cy.then(() => expect(new URL(buildShareUrl()).searchParams.has('i_ptconc')).to.eq(false));
+    });
+
+    it('restores a shared concurrency and requests only the sources at that load', () => {
+      writeUrlParams({ i_ptconc: '8' });
+      cy.intercept('POST', '/api/gpu-metrics*', { body: sameLoadResponse }).as('series');
+      mountTimeline(points());
+      cy.wait('@series').then(({ request }) => {
+        expect(request.body.sources).to.deep.equal(
+          [`power_validation_${resultName('b200', 8)}.json`, disaggSource(8)].toSorted(),
+        );
+      });
+      cy.get('[data-testid="power-timeline-concurrency"]').should('have.value', '8');
+    });
+
+    it('summarises each pool beside its validated average, drawn peak and pool TDP', () => {
+      writeUrlParams({ i_ptconc: '8' });
+      cy.intercept('POST', '/api/gpu-metrics*', { body: sameLoadResponse }).as('series');
+      mountTimeline(points());
+      cy.wait('@series');
+      const trace = () =>
+        cy.get(
+          `[data-testid="power-timeline-summary-trace"][data-trace="${traceKeyForPoint(rolePoint())}"]`,
+        );
+      const cells = (role: string) =>
+        trace()
+          .find(`[data-testid="power-timeline-summary-${role}"] td`)
+          .then(($cells) => [...$cells].map((cell) => cell.textContent));
+      trace()
+        .should('contain.text', 'GB200 NVL72')
+        .and('contain.text', `run ${RUN_ID}`)
+        .and('contain.text', `${disaggSource(8)} · database`);
+      // Window 40–60 s: prefill 900–903 W on four GPUs, decode 704–707 W on four,
+      // beside the rows' validated averages and pool size × rated TDP.
+      // The first pool row also carries the run cell (checked above).
+      const poolTdp = (gpus: number) => (gpus * GB200_TDP).toLocaleString('en-US');
+      cells('all')
+        .then((values) => values.slice(1))
+        .should('deep.equal', ['20', 'All GPUs · 8', '800', '6,428', poolTdp(8)]);
+      cells('prefill').should('deep.equal', ['Prefill · 4', '900', '3,606', poolTdp(4)]);
+      cells('decode').should('deep.equal', ['Decode · 4', '700', '2,822', poolTdp(4)]);
+      cy.get('[data-testid="power-timeline-summary"]').should('contain.text', 'not recomputed');
+    });
+
+    it('marks overlay traces in the summary with their run colour', () => {
+      const overlayPoint = measuredPoint('h200', 16, 500, { run_url: OVERLAY_RUN_URL });
+      cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
+      cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+        body: overlayResponse([series('h200', 16, 500)]),
+      }).as('overlay');
+      mountTimeline([measuredPoint('b200', 16, 700)], {
+        overlay: overlayData([overlayPoint]),
+        unofficial: createMockUnofficialRunContext(overlayRun('h200')),
+      });
+      cy.wait(['@official', '@overlay']);
+      cy.get(
+        `[data-testid="power-timeline-summary-trace"][data-trace="${traceKeyForPoint(overlayPoint)}"]`,
+      )
+        .should('contain.text', 'unofficial')
+        .find('th > span')
+        .first()
+        .should('have.attr', 'style')
+        .and('contain', overlayRunColor(0));
+    });
+
+    it('translates the concurrency filter and summary on /zh', () => {
+      writeUrlParams({ i_ptconc: '8' });
+      cy.intercept('POST', '/api/gpu-metrics*', { body: sameLoadResponse }).as('series');
+      mountTimeline(points(), { pathname: '/zh/inference' });
+      cy.wait('@series');
+      cy.get('[data-testid="power-timeline-toolbar"]').should('contain.text', '并发数');
+      cy.get('[data-testid="power-timeline-summary"]')
+        .should('contain.text', '有效测量窗口汇总')
+        .and('contain.text', '预填充 · 4')
+        .and('contain.text', '数据库');
+    });
+
+    it('keeps the summary table inside its scroller on mobile', () => {
+      cy.viewport(390, 844);
+      writeUrlParams({ i_ptconc: '8' });
+      cy.intercept('POST', '/api/gpu-metrics*', { body: sameLoadResponse }).as('series');
+      mountTimeline(points(), { width: 324 });
+      cy.wait('@series');
+      cy.get('[data-testid="power-timeline-summary"]').should('be.visible');
+      cy.document().should((doc) => {
+        expect(doc.documentElement.scrollWidth).to.be.at.most(doc.documentElement.clientWidth + 1);
+      });
+      cy.get('[data-testid="power-timeline"]').screenshot('power-timeline-same-load-mobile', {
+        overwrite: true,
+      });
+    });
+  });
 });
diff --git a/packages/app/src/components/gpu-power/power-series.ts b/packages/app/src/components/gpu-power/power-series.ts
index 8ff75fabb..0f98d1e80 100644
--- a/packages/app/src/components/gpu-power/power-series.ts
+++ b/packages/app/src/components/gpu-power/power-series.ts
@@ -51,6 +51,8 @@ export interface GpuPowerSeries {
 }
 
 export interface GpuPowerSeriesResponse {
+  /** Where the route read the series: the ingested digest or the run's GitHub artifacts. */
+  source?: 'database' | 'github';
   runInfo: GpuPowerRunInfo;
   series: GpuPowerSeries[];
   /** Coverage of requested validation identities only, never the full run/sweep. */
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index 51d8f7102..6bb77e5a8 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -60,6 +60,7 @@ import {
 } from '../InferenceContext';
 import type { InferenceData, OverlayData } from '../types';
 import { powerVariantDash } from '../utils/power-compare';
+import PowerTimelineSummary from './PowerTimelineSummary';
 import {
   allGpuPool,
   consumePowerTraceFocus,
@@ -72,6 +73,7 @@ import {
   prioritizeRun,
   prioritizeRuns,
   referenceLabelSlots,
+  stackTraceLabels,
   runIdFromUrl,
   traceConfigLabel,
   traceKeyRunId,
@@ -103,6 +105,8 @@ const MARGIN = { top: 24, right: 84, bottom: 60, left: 64 };
 const STRINGS = {
   en: {
     timeAxis: 'Time axis',
+    concurrency: 'Concurrency',
+    allConcurrencies: 'All',
     wall: 'Wall clock (UTC)',
     elapsed: 'Since telemetry start',
     serving: 'Since serving start',
@@ -184,6 +188,8 @@ const STRINGS = {
   },
   zh: {
     timeAxis: '时间轴',
+    concurrency: '并发数',
+    allConcurrencies: '全部',
     wall: '实际时刻（UTC）',
     elapsed: '距遥测起点',
     serving: '距服务窗口起点',
@@ -371,10 +377,21 @@ const formatUtcDate = d3.utcFormat('%Y-%m-%d');
 /** Pool sums run to thousands of watts; group the digits. */
 const formatWatts = d3.format(',.0f');
 
+/** Rough advance of one label character at the data-label size. */
+const LABEL_CHAR_WIDTH = 6.5;
+
 function baseHardware(hwKey: string): string {
   return hwKey.split('_')[0];
 }
 
+function runIdsOf(points: readonly InferenceData[]): Set<string> {
+  return new Set(
+    points
+      .map((point) => runIdFromUrl(point.run_url))
+      .filter((runId): runId is string => runId !== null),
+  );
+}
+
 /**
  * The pools a trace draws in pool mode: its worker-role pools, or every GPU as
  * one pool when the collector assigned no roles (a single-node trace then shows
@@ -621,17 +638,25 @@ function drawLabels(
     .attr('data-pool', (label) => label.pool ?? null)
     .attr('fill', (label) => label.color)
     .attr('opacity', (label) => labelOpacity(label, highlight))
-    .text((label) => label.text)
-    .each(function (label) {
-      const x = xScale(label.x);
-      const y = yScale(label.y);
-      // Sit just past the last sample; flip inside the plot near the right edge.
-      const overflow = x + 6 + label.text.length * 6.5 > plotWidth;
-      d3.select(this)
-        .attr('text-anchor', overflow ? 'end' : 'start')
-        .attr('x', overflow ? x - 6 : x + 6)
-        .attr('y', y);
-    });
+    .text((label) => label.text);
+  // Sit just past the last sample; flip inside the plot near the right edge.
+  const boxes = model.labels.map((label) => {
+    const x = xScale(label.x);
+    const width = label.text.length * LABEL_CHAR_WIDTH;
+    const flip = x + 6 + width > plotWidth;
+    const left = flip ? x - 6 - width : x + 6;
+    return { flip, left, right: left + width, y: yScale(label.y) };
+  });
+  const rows = stackTraceLabels(boxes, CHART_TYPE.dataLabel + 2);
+  const byId = new Map(model.labels.map((label, index) => [label.id, index]));
+  group.selectAll<SVGTextElement, TraceLabel>('text.power-trace-label').each(function (label) {
+    const index = byId.get(label.id)!;
+    const box = boxes[index];
+    d3.select(this)
+      .attr('text-anchor', box.flip ? 'end' : 'start')
+      .attr('x', box.flip ? box.right : box.left)
+      .attr('y', rows[index]);
+  });
 }
 
 function drawReferenceLines(
@@ -727,6 +752,7 @@ export default function PowerTimeline({
       i_ptwindow: getUrlParam('i_ptwindow'),
       i_ptfocus: getUrlParam('i_ptfocus'),
       i_ptutility: getUrlParam('i_ptutility'),
+      i_ptconc: getUrlParam('i_ptconc'),
     }),
   );
   const [xModeChoice, setXModeChoice] = useState<XMode | null>(initialView.axis);
@@ -738,6 +764,15 @@ export default function PowerTimeline({
   const [focusKey, setFocusKey] = useState<string | null>(initialView.focus);
   /** The deep-link request, read once on mount; `undefined` until read, `null` once honoured. */
   const requestedFocusRef = useRef<string | null | undefined>(undefined);
+  // The deep-link request is read once, before planning, so its run is fetched
+  // even when the chart spans more runs than the cap.
+  if (requestedFocusRef.current === undefined) {
+    requestedFocusRef.current = consumePowerTraceFocus();
+  }
+  /** One load across hardware (e.g. GB200 and GB300 at c4); a deep link names its own trace. */
+  const [concurrency, setConcurrency] = useState<number | null>(() =>
+    requestedFocusRef.current ? null : initialView.concurrency,
+  );
 
   // The chart's point list still carries every precision, quick-filtered rows
   // and rows without a validated average (ScatterGraph applies those gates at
@@ -756,10 +791,21 @@ export default function PowerTimeline({
     [overlayData, plotsHere],
   );
   const overlayPointSet = useMemo(() => new Set<InferenceData>(overlayPoints), [overlayPoints]);
-  const allPoints = useMemo(
-    () => [...measuredData, ...overlayPoints],
+  const concurrencyOptions = useMemo(
+    () =>
+      [...new Set([...measuredData, ...overlayPoints].map((point) => point.conc))]
+        .filter((conc) => Number.isSafeInteger(conc) && conc > 0)
+        .toSorted((a, b) => a - b),
     [measuredData, overlayPoints],
   );
+  // Filtering before planning keeps the run cap for the runs that hold this load.
+  const allPoints = useMemo(
+    () =>
+      [...measuredData, ...overlayPoints].filter(
+        (point) => concurrency === null || point.conc === concurrency,
+      ),
+    [measuredData, overlayPoints, concurrency],
+  );
 
   const hwKeysInData = useMemo(
     () =>
@@ -778,30 +824,30 @@ export default function PowerTimeline({
   });
 
   const requests = useMemo(() => planPowerTimelineRequests(allPoints), [allPoints]);
-  // The deep-link request is read once, before planning, so its run is fetched
-  // even when the chart spans more runs than the cap.
-  if (requestedFocusRef.current === undefined) {
-    requestedFocusRef.current = consumePowerTraceFocus();
-  }
   const focusRun = traceKeyRunId(requestedFocusRef.current ?? focusKey);
-  // Overlay runs were requested explicitly (`?unofficialrun=`), so they take
-  // the cap's slots before official runs; the deep-linked run still goes first.
-  const overlayRunIds = useMemo(
-    () =>
-      new Set(
-        overlayPoints
-          .map((point) => runIdFromUrl(point.run_url))
-          .filter((runId): runId is string => runId !== null),
-      ),
-    [overlayPoints],
+  // Same visibility source as ScatterGraph: an overlay session may hold a
+  // local official selection that has not been written back to the filters.
+  const officialHwTypes = localOfficialOverride ?? activeHwTypes;
+  const isShown = useCallback(
+    (point: InferenceData) =>
+      overlayPointSet.has(point)
+        ? activeOverlayHwTypes.has(point.hwKey)
+        : officialHwTypes.has(point.hwKey),
+    [overlayPointSet, activeOverlayHwTypes, officialHwTypes],
   );
+  // Overlay runs were requested explicitly (`?unofficialrun=`), so they take
+  // the cap's slots before official runs; runs the legend shows go before runs
+  // it hides entirely, so hiding hardware makes room for the pair compared.
+  // The deep-linked run still goes first.
+  const overlayRunIds = useMemo(() => runIdsOf(overlayPoints), [overlayPoints]);
+  const shownRunIds = useMemo(() => runIdsOf(allPoints.filter(isShown)), [allPoints, isShown]);
   const fetchedRequests = useMemo(
     () =>
-      prioritizeRun(prioritizeRuns(requests, overlayRunIds), focusRun).slice(
-        0,
-        POWER_TIMELINE_MAX_RUNS,
-      ),
-    [requests, overlayRunIds, focusRun],
+      prioritizeRun(
+        prioritizeRuns(prioritizeRuns(requests, overlayRunIds), shownRunIds),
+        focusRun,
+      ).slice(0, POWER_TIMELINE_MAX_RUNS),
+    [requests, overlayRunIds, shownRunIds, focusRun],
   );
   const droppedRuns = requests.length - fetchedRequests.length;
   const queries = useQueries({
@@ -868,9 +914,6 @@ export default function PowerTimeline({
     },
     [overlayPointSet, runIndexByUrl, getCssColor, resolveColor],
   );
-  // Same visibility source as ScatterGraph: an overlay session may hold a
-  // local official selection that has not been written back to the filters.
-  const officialHwTypes = localOfficialOverride ?? activeHwTypes;
   // With an overlay loaded the chart reads localOfficialOverride, so a legend
   // click must write the unified selection the way ScatterGraph does; the
   // context's toggleHwType would change activeHwTypes with no visible effect.
@@ -898,13 +941,8 @@ export default function PowerTimeline({
     ],
   );
   const visibleTraces = useMemo(
-    () =>
-      traces.filter((trace) =>
-        overlayPointSet.has(trace.point)
-          ? activeOverlayHwTypes.has(trace.point.hwKey)
-          : officialHwTypes.has(trace.point.hwKey),
-      ),
-    [traces, overlayPointSet, activeOverlayHwTypes, officialHwTypes],
+    () => traces.filter((trace) => isShown(trace.point)),
+    [traces, isShown],
   );
   // Focus follows visibility: hiding the focused hardware in the legend lifts
   // the dimming and the chip instead of dimming everything with nothing lit.
@@ -933,17 +971,35 @@ export default function PowerTimeline({
       i_ptwindow: windowOnly ? 'window' : '',
       i_ptfocus: focusKey ?? '',
       i_ptutility: showUtility ? '1' : '',
+      i_ptconc: concurrency === null ? '' : String(concurrency),
     });
-  }, [xModeChoice, lineMode, windowOnly, focusKey, showUtility, setUrlParams]);
+  }, [xModeChoice, lineMode, windowOnly, focusKey, showUtility, concurrency, setUrlParams]);
 
   const missingWindows =
     windowOnly || xMode === 'serving'
       ? visibleTraces.filter((trace) => !hasPowerTimelineWindow(trace)).length
       : 0;
 
+  const hardwareLabel = useCallback(
+    (point: InferenceData): string => {
+      const config = overlayPointSet.has(point)
+        ? overlayData?.hardwareConfig[point.hwKey]
+        : hardwareConfig[point.hwKey];
+      return config ? getDisplayLabel(config) : point.hwKey;
+    },
+    [overlayPointSet, overlayData, hardwareConfig],
+  );
+
   const model = useMemo<DrawModel>(() => {
     const paths: TracePath[] = [];
     const labels: TraceLabel[] = [];
+    // Two platforms at one load share `c4`; name the hardware so the end labels differ.
+    const bases = new Set(visibleTraces.map((trace) => baseHardware(trace.point.hwKey)));
+    const hardwarePrefix = (trace: PowerTimelineTrace) => {
+      if (bases.size < 2) return '';
+      const base = baseHardware(trace.point.hwKey);
+      return `${HW_REGISTRY[base]?.label ?? base.toUpperCase()} `;
+    };
     for (const trace of visibleTraces) {
       const { color, overlayIndex } = colorForTrace(trace);
       const tracePathSet = tracePaths(trace, color, overlayIndex, xMode, lineMode, windowOnly);
@@ -969,9 +1025,11 @@ export default function PowerTimeline({
           hwKey: trace.point.hwKey,
           pool: group.pool,
           color,
-          text: group.pool
-            ? `c${trace.point.conc} · ${t.poolShort[group.pool]}`
-            : `c${trace.point.conc}`,
+          text: `${hardwarePrefix(trace)}${
+            group.pool
+              ? `c${trace.point.conc} · ${t.poolShort[group.pool]}`
+              : `c${trace.point.conc}`
+          }`,
           x: last.x,
           y: last.y,
         });
@@ -1172,16 +1230,6 @@ export default function PowerTimeline({
     [activeHighlight],
   );
 
-  const hardwareLabel = useCallback(
-    (point: InferenceData): string => {
-      const config = overlayPointSet.has(point)
-        ? overlayData?.hardwareConfig[point.hwKey]
-        : hardwareConfig[point.hwKey];
-      return config ? getDisplayLabel(config) : point.hwKey;
-    },
-    [overlayPointSet, overlayData, hardwareConfig],
-  );
-
   const tooltipContent = useCallback(
     (sample: TimelineSample, isPinned: boolean) => {
       const { trace } = sample;
@@ -1383,6 +1431,27 @@ export default function PowerTimeline({
       className="flex flex-wrap items-center justify-end gap-2 pb-1"
       data-testid="power-timeline-toolbar"
     >
+      <label className="flex items-center gap-2 text-xs text-muted-foreground">
+        {t.concurrency}
+        <select
+          className="rounded-md border bg-background px-2 py-1 text-xs text-foreground"
+          data-testid="power-timeline-concurrency"
+          value={concurrency ?? ''}
+          onChange={(event) => {
+            const value = event.target.value === '' ? null : Number(event.target.value);
+            setConcurrency(value);
+            track('inference_power_timeline_concurrency_changed', { concurrency: value });
+          }}
+        >
+          <option value="">{t.allConcurrencies}</option>
+          {concurrency !== null && !concurrencyOptions.includes(concurrency) && (
+            <option value={concurrency}>{`c${concurrency}`}</option>
+          )}
+          {concurrencyOptions.map((conc) => (
+            <option key={conc} value={conc}>{`c${conc}`}</option>
+          ))}
+        </select>
+      </label>
       <span className="text-xs text-muted-foreground">{t.timeAxis}</span>
       <SegmentedToggle<XMode>
         value={xMode}
@@ -1545,6 +1614,15 @@ export default function PowerTimeline({
         <p>{windowOnly ? t.methodWindow : t.method}</p>
         {hasPools && <p>{t.methodPools}</p>}
       </div>
+      {loadingRuns === 0 && visibleTraces.length > 0 && (
+        <PowerTimelineSummary
+          traces={visibleTraces}
+          responses={responses}
+          colorOf={(trace) => colorForTrace(trace).color}
+          hardwareLabel={hardwareLabel}
+          isOverlay={(point) => overlayPointSet.has(point)}
+        />
+      )}
     </div>
   );
 }
diff --git a/packages/app/src/components/inference/ui/PowerTimelineSummary.tsx b/packages/app/src/components/inference/ui/PowerTimelineSummary.tsx
new file mode 100644
index 000000000..968bc43ba
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerTimelineSummary.tsx
@@ -0,0 +1,197 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
+
+import type { GpuPowerSeriesResponse } from '@/components/gpu-power/power-series';
+import { useLocale } from '@/lib/use-locale';
+import type { InferenceData } from '../types';
+import {
+  allGpuPool,
+  runAttemptFromUrl,
+  summarizeTraceWindow,
+  telemetryNameForPoint,
+  traceConfigLabel,
+  tracePools,
+  type PowerPoolRole,
+  type PowerTimelineTrace,
+} from '../utils/powerTimeline';
+
+const STRINGS = {
+  en: {
+    title: 'Validated-window summary',
+    trace: 'Hardware · config',
+    run: 'Run · telemetry source',
+    window: 'Window (s)',
+    pool: 'Pool · GPUs',
+    validated: 'Validated average (W/GPU)',
+    peak: 'Peak 1-s pool power (W)',
+    poolTdp: 'Pool TDP (W)',
+    pools: { all: 'All GPUs', prefill: 'Prefill', decode: 'Decode' } satisfies Record<
+      PowerPoolRole,
+      string
+    >,
+    source: { database: 'database', github: 'GitHub artifact fallback' },
+    attempt: (attempt: number) => `attempt ${attempt}`,
+    unofficial: 'unofficial',
+    noWindow: 'Not recorded',
+    method: (bucket: number | null) =>
+      `Validated averages are the benchmark row’s figures, not recomputed here. Peak is the highest ${bucket === null ? '' : `${bucket}-s `}sum of the pool’s GPUs inside the recorded validated window, as drawn; buckets missing a pool GPU are skipped. Pool TDP = GPUs × rated TDP from the hardware registry. The telemetry source is per run: database when every requested series was stored, GitHub artifact fallback when any had to be read live.`,
+  },
+  zh: {
+    title: '有效测量窗口汇总',
+    trace: '硬件 · 配置',
+    run: '运行 · 遥测来源',
+    window: '窗口（秒）',
+    pool: 'GPU 池 · GPU 数',
+    validated: '有效窗口平均值（W/GPU）',
+    peak: '池功耗 1 秒峰值（W）',
+    poolTdp: '池 TDP（W）',
+    pools: { all: '全部 GPU', prefill: '预填充', decode: '解码' } satisfies Record<
+      PowerPoolRole,
+      string
+    >,
+    source: { database: '数据库', github: 'GitHub 产物回退' },
+    attempt: (attempt: number) => `第 ${attempt} 次尝试`,
+    unofficial: '非官方',
+    noWindow: '未记录',
+    method: (bucket: number | null) =>
+      `有效窗口平均值取自基准测试记录，此处不重新计算。峰值是在已记录的有效测量窗口内，${bucket === null ? '' : `按 ${bucket} 秒区间`}对该池各 GPU 功耗求和后的最大值，与图中曲线一致；缺少任一 GPU 采样的区间不计入。池 TDP = GPU 数 × 硬件注册表中的额定 TDP。遥测来源按运行标注：所有请求的序列都已入库时为数据库；只要有序列需要实时读取，就标为 GitHub 产物回退。`,
+  },
+};
+
+const watts = d3.format(',.0f');
+const seconds = d3.format(',.0f');
+
+const validatedWatts = (point: InferenceData, role: PowerPoolRole) =>
+  (role === 'prefill'
+    ? point.measuredPrefillAvgPower
+    : role === 'decode'
+      ? point.measuredDecodeAvgPower
+      : point.measuredAvgPower
+  )?.y ?? null;
+
+/**
+ * Per-trace provenance behind the Timeline curves: which run and telemetry file
+ * each trace came from, the validated window length, and per pool its GPU
+ * count, the row's validated average, the drawn peak and the rated pool TDP.
+ */
+export default function PowerTimelineSummary({
+  traces,
+  responses,
+  colorOf,
+  hardwareLabel,
+  isOverlay,
+}: {
+  traces: readonly PowerTimelineTrace[];
+  responses: ReadonlyMap<string, GpuPowerSeriesResponse>;
+  colorOf: (trace: PowerTimelineTrace) => string;
+  hardwareLabel: (point: InferenceData) => string;
+  isOverlay: (point: InferenceData) => boolean;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const rows = useMemo(
+    () =>
+      traces.map((trace) => ({
+        trace,
+        summary: summarizeTraceWindow(trace, [
+          allGpuPool(trace.series),
+          ...tracePools(trace.series),
+        ]),
+      })),
+    [traces],
+  );
+  const buckets = [...new Set(rows.map((row) => row.summary.bucketSeconds))];
+  return (
+    <section className="min-w-0 space-y-2 px-1" data-testid="power-timeline-summary">
+      <h3 className="text-sm font-medium">{t.title}</h3>
+      <div className="max-h-96 min-w-0 overflow-auto">
+        <table className="w-full min-w-[48rem] table-fixed break-words text-left text-xs">
+          <thead className="sticky top-0 bg-background">
+            <tr>
+              <th className="w-1/5 p-2">{t.trace}</th>
+              <th className="w-1/4 p-2">{t.run}</th>
+              <th className="p-2">{t.window}</th>
+              <th className="p-2">{t.pool}</th>
+              <th className="p-2">{t.validated}</th>
+              <th className="p-2">{t.peak}</th>
+              <th className="p-2">{t.poolTdp}</th>
+            </tr>
+          </thead>
+          {rows.map(({ trace, summary }) => {
+            const { point } = trace;
+            const attempt = runAttemptFromUrl(point.run_url);
+            const name = telemetryNameForPoint(point);
+            const source = responses.get(trace.runId)?.source;
+            const tdp = HW_REGISTRY[point.hwKey.split('_')[0]]?.tdp ?? 0;
+            return (
+              <tbody
+                key={trace.key}
+                className="border-t"
+                data-testid="power-timeline-summary-trace"
+                data-trace={trace.key}
+              >
+                {summary.pools.map((pool, index) => {
+                  const validated = validatedWatts(point, pool.role);
+                  return (
+                    <tr key={pool.role} data-testid={`power-timeline-summary-${pool.role}`}>
+                      {index === 0 && (
+                        <>
+                          <th className="p-2 align-top font-normal" rowSpan={summary.pools.length}>
+                            <span style={{ color: colorOf(trace) }}>● </span>
+                            {hardwareLabel(point)}
+                            <span className="block text-muted-foreground">
+                              {traceConfigLabel(point)}
+                              {isOverlay(point) ? ` · ${t.unofficial}` : ''}
+                            </span>
+                          </th>
+                          <td className="p-2 align-top" rowSpan={summary.pools.length}>
+                            <a
+                              href={point.run_url}
+                              target="_blank"
+                              rel="noopener noreferrer"
+                              className="underline decoration-dotted"
+                            >
+                              {`run ${trace.runId}`}
+                            </a>
+                            {attempt === null ? '' : ` · ${t.attempt(attempt)}`}
+                            <span className="block break-all text-muted-foreground">
+                              {name ? `power_validation_${name}.json` : '—'}
+                              {source ? ` · ${t.source[source]}` : ''}
+                            </span>
+                          </td>
+                          <td className="p-2 align-top" rowSpan={summary.pools.length}>
+                            {summary.windowSeconds === null
+                              ? t.noWindow
+                              : seconds(summary.windowSeconds)}
+                          </td>
+                        </>
+                      )}
+                      <td className="p-2 align-top">
+                        {t.pools[pool.role]} · {pool.gpuCount}
+                      </td>
+                      <td className="p-2 align-top">
+                        {validated === null ? '—' : watts(validated)}
+                      </td>
+                      <td className="p-2 align-top">
+                        {pool.peakWatts === null ? '—' : watts(pool.peakWatts)}
+                      </td>
+                      <td className="p-2 align-top">
+                        {tdp > 0 ? watts(tdp * pool.gpuCount) : '—'}
+                      </td>
+                    </tr>
+                  );
+                })}
+              </tbody>
+            );
+          })}
+        </table>
+      </div>
+      <p className="text-xs text-muted-foreground">
+        {t.method(buckets.length === 1 ? buckets[0] : null)}
+      </p>
+    </section>
+  );
+}
diff --git a/packages/app/src/components/inference/utils/powerTimeline.test.ts b/packages/app/src/components/inference/utils/powerTimeline.test.ts
index a407a8bb6..b00f86b69 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.test.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.test.ts
@@ -17,7 +17,10 @@ import {
   prioritizeRuns,
   referenceLabelSlots,
   requestPowerTraceFocus,
+  runAttemptFromUrl,
   runIdFromUrl,
+  stackTraceLabels,
+  summarizeTraceWindow,
   telemetryArtifactForPoint,
   traceConfigLabel,
   traceKeyForPoint,
@@ -83,6 +86,7 @@ describe('shared timeline view', () => {
         i_ptwindow: 'window',
         i_ptfocus: trace.key,
         i_ptutility: '1',
+        i_ptconc: '4',
       }),
     ).toEqual({
       axis: 'serving',
@@ -90,6 +94,7 @@ describe('shared timeline view', () => {
       windowOnly: true,
       focus: trace.key,
       utility: true,
+      concurrency: 4,
     });
     expect(parsePowerTimelineParams({ i_ptlines: 'gpu', i_ptfocus: trace.key }).lines).toBe('gpu');
   });
@@ -102,8 +107,19 @@ describe('shared timeline view', () => {
         i_ptwindow: 'all',
         i_ptfocus: 'not-a-run:../../../secret',
         i_ptutility: 'true',
+        i_ptconc: '0',
       }),
-    ).toEqual({ axis: null, lines: 'mean', windowOnly: false, focus: null, utility: false });
+    ).toEqual({
+      axis: null,
+      lines: 'mean',
+      windowOnly: false,
+      focus: null,
+      utility: false,
+      concurrency: null,
+    });
+    for (const i_ptconc of ['-4', '4.5', 'c4', '1e3', '01']) {
+      expect(parsePowerTimelineParams({ i_ptconc }).concurrency).toBeNull();
+    }
   });
 
   it('uses the retained serving origin, distinct from telemetry origin', () => {
@@ -134,6 +150,68 @@ describe('shared timeline view', () => {
   });
 });
 
+describe('summarizeTraceWindow', () => {
+  // Two prefill and two decode GPUs; the window holds buckets 1–3 (t = 11..13 s).
+  const pooled: PowerTimelineTrace = {
+    key: `34716669498:${NAME_B}`,
+    point: point({ disagg: true, conc: 4 }),
+    runId: '34716669498',
+    series: {
+      artifact: `power_audit_${NAME_B}`,
+      startMs: 1_000_000,
+      bucketSeconds: 1,
+      gpus: [0, 1, 2, 3],
+      t: [10, 11, 12, 13, 14],
+      power: [
+        [900, 250, 260, 270, 900],
+        [900, 250, null, 270, 900],
+        [900, 400, 410, 420, 900],
+        [900, 400, 410, 420, 900],
+      ],
+      devices: [
+        { id: 'a/0', role: 'prefill' },
+        { id: 'a/1', role: 'prefill' },
+        { id: 'b/0', role: 'decode' },
+        { id: 'b/1', role: 'decode' },
+      ],
+    },
+    windowStartMs: 1_011_000,
+    windowEndMs: 1_013_500,
+  };
+
+  it('reports window length and each pool’s peak summed bucket inside the window', () => {
+    const summary = summarizeTraceWindow(pooled, tracePools(pooled.series));
+    expect(summary.windowSeconds).toBe(2.5);
+    expect(summary.bucketSeconds).toBe(1);
+    // The 900 W buckets sit outside the window; bucket 2 lacks one prefill GPU,
+    // so it is a gap, not a 260 W dip.
+    expect(summary.pools).toEqual([
+      { role: 'prefill', gpuCount: 2, peakWatts: 540 },
+      { role: 'decode', gpuCount: 2, peakWatts: 840 },
+    ]);
+  });
+
+  it('summarizes every GPU as one pool and reports nothing without window bounds', () => {
+    const all = summarizeTraceWindow(pooled, [allGpuPool(pooled.series)]);
+    expect(all.pools).toEqual([{ role: 'all', gpuCount: 4, peakWatts: 1380 }]);
+    const unbounded = summarizeTraceWindow(
+      { ...pooled, windowStartMs: null, windowEndMs: null },
+      tracePools(pooled.series),
+    );
+    expect(unbounded.windowSeconds).toBeNull();
+    expect(unbounded.pools.map((pool) => pool.peakWatts)).toEqual([null, null]);
+  });
+});
+
+describe('runAttemptFromUrl', () => {
+  it('reads the attempt only from an explicit attempts segment', () => {
+    expect(runAttemptFromUrl(`${RUN_URL}/attempts/2`)).toBe(2);
+    expect(runAttemptFromUrl(RUN_URL)).toBeNull();
+    expect(runAttemptFromUrl(undefined)).toBeNull();
+    expect(runIdFromUrl(`${RUN_URL}/attempts/2`)).toBe('34716669498');
+  });
+});
+
 describe('telemetryArtifactForPoint', () => {
   it('maps the power-audit source to the gpu_metrics artifact of the same RESULT_FILENAME', () => {
     expect(
@@ -471,6 +549,23 @@ describe('groupPoolsBySize', () => {
   });
 });
 
+describe('stackTraceLabels', () => {
+  it('moves overlapping labels one row below the label above and leaves clear ones', () => {
+    expect(
+      stackTraceLabels(
+        [
+          { left: 100, right: 200, y: 600 },
+          { left: 150, right: 260, y: 604 },
+          { left: 120, right: 220, y: 598 },
+          { left: 300, right: 380, y: 600 },
+          { left: 100, right: 200, y: 300 },
+        ],
+        12,
+      ),
+    ).toEqual([610, 622, 598, 600, 300]);
+  });
+});
+
 describe('referenceLabelSlots', () => {
   it('stacks labels of lines that share a watts value and leaves others on the line', () => {
     expect(
diff --git a/packages/app/src/components/inference/utils/powerTimeline.ts b/packages/app/src/components/inference/utils/powerTimeline.ts
index 129756ce9..0a7a22254 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.ts
@@ -15,6 +15,7 @@
  */
 import {
   bucketTimeMs,
+  sumPowerAt,
   type GpuPowerRole,
   type GpuPowerSeries,
   type GpuPowerSeriesResponse,
@@ -57,6 +58,12 @@ export function runIdFromUrl(url: string | null | undefined): string | null {
   return url?.match(/\/runs\/(?<runId>\d+)/u)?.groups?.runId ?? null;
 }
 
+/** Attempt number from a `/runs/<id>/attempts/<n>` URL; null when the URL names none. */
+export function runAttemptFromUrl(url: string | null | undefined): number | null {
+  const attempt = url?.match(/\/runs\/\d+\/attempts\/(?<attempt>\d+)/u)?.groups?.attempt;
+  return attempt ? Number(attempt) : null;
+}
+
 export function longestCommonPrefix(values: readonly string[]): string {
   if (values.length === 0) return '';
   let prefix = values[0];
@@ -165,6 +172,7 @@ export function parsePowerTimelineParams(params: {
   i_ptwindow?: string;
   i_ptfocus?: string;
   i_ptutility?: string;
+  i_ptconc?: string;
 }) {
   return {
     axis: (['wall', 'elapsed', 'serving'].includes(params.i_ptaxis ?? '')
@@ -177,6 +185,7 @@ export function parsePowerTimelineParams(params: {
     focus:
       params.i_ptfocus && /^[1-9]\d*:[\w.-]+$/u.test(params.i_ptfocus) ? params.i_ptfocus : null,
     utility: params.i_ptutility === '1',
+    concurrency: /^[1-9]\d{0,5}$/u.test(params.i_ptconc ?? '') ? Number(params.i_ptconc) : null,
   };
 }
 
@@ -367,11 +376,91 @@ export function referenceLabelSlots(lines: readonly { watts: number }[]): number
   });
 }
 
+/**
+ * Rows for end-of-line trace labels in pixel space: a label whose box overlaps
+ * one already placed (both ranges intersect) moves one `rowHeight` below it,
+ * top anchors first, so pools ending at the same watts do not overprint.
+ * Returns each label's y in input order.
+ */
+export function stackTraceLabels(
+  labels: readonly { left: number; right: number; y: number }[],
+  rowHeight: number,
+): number[] {
+  const ys = labels.map((label) => label.y);
+  const placed: { left: number; right: number; y: number }[] = [];
+  const order = labels.map((_, index) => index).toSorted((a, b) => labels[a].y - labels[b].y);
+  for (const index of order) {
+    const { left, right } = labels[index];
+    let y = ys[index];
+    // Each move strictly lowers the label, so this ends within `placed.length` passes.
+    let moved = true;
+    while (moved) {
+      moved = false;
+      for (const other of placed) {
+        if (left < other.right && other.left < right && Math.abs(y - other.y) < rowHeight) {
+          y = other.y + rowHeight;
+          moved = true;
+        }
+      }
+    }
+    ys[index] = y;
+    placed.push({ left, right, y });
+  }
+  return ys;
+}
+
 /** Every GPU of the series as one pool. */
 export function allGpuPool(series: Pick<GpuPowerSeries, 'power'>): PowerPool {
   return { role: 'all', rows: series.power.map((_, row) => row) };
 }
 
+export interface TracePoolSummary {
+  role: PowerPoolRole;
+  gpuCount: number;
+  /** Highest drawn one-second pool sum inside the window; null when none was complete. */
+  peakWatts: number | null;
+}
+
+export interface TraceWindowSummary {
+  /** Recorded validated serving-window length, or null when bounds are missing. */
+  windowSeconds: number | null;
+  bucketSeconds: number;
+  pools: TracePoolSummary[];
+}
+
+/**
+ * What a Timeline reader needs next to the curves: the validated window's
+ * length and, per pool, its GPU count and the peak of the drawn pool line
+ * inside the window. A bucket missing a pool device is a gap in the line, so
+ * it is skipped. Averages are not recomputed: the benchmark row's validated
+ * figures stay the only means.
+ */
+export function summarizeTraceWindow(
+  trace: PowerTimelineTrace,
+  pools: readonly PowerPool[],
+): TraceWindowSummary {
+  const hasWindow = hasPowerTimelineWindow(trace);
+  const columns = hasWindow
+    ? trace.series.t
+        .map((_, column) => column)
+        .filter((column) => windowPhase(trace, bucketTimeMs(trace.series, column)) === 'window')
+    : [];
+  return {
+    windowSeconds: hasWindow ? (trace.windowEndMs! - trace.windowStartMs!) / 1000 : null,
+    bucketSeconds: trace.series.bucketSeconds,
+    pools: pools.map((pool) => {
+      const sums = columns
+        .map((column) => sumPowerAt(trace.series, pool.rows, column))
+        .filter((value): value is number => value !== null);
+      return {
+        role: pool.role,
+        gpuCount: pool.rows.length,
+        peakWatts: sums.length > 0 ? Math.max(...sums) : null,
+      };
+    }),
+  };
+}
+
 // ── Deep link from a pinned scatter tooltip ─────────────────────────────────
 //
 // "View power trace" on a pinned tooltip switches the metric to the Timeline
diff --git a/packages/app/src/lib/url-state.ts b/packages/app/src/lib/url-state.ts
index 648d0676f..d75f4e736 100644
--- a/packages/app/src/lib/url-state.ts
+++ b/packages/app/src/lib/url-state.ts
@@ -76,6 +76,8 @@ const URL_STATE_KEYS = [
   'i_ptwindow',
   'i_ptfocus',
   'i_ptutility',
+  // Power Timeline concurrency filter: one positive integer, empty = every load.
+  'i_ptconc',
   // Completed Perf Rulers on the primary inference chart: `isoX|curveA|curveB`
   // entries joined by `;` (see serializePerfRulers in d3-chart/layers/perf-ruler).
   'i_rulers',
@@ -209,6 +211,7 @@ export const PARAM_DEFAULTS: Record<UrlStateKey, string> = {
   i_ptwindow: '',
   i_ptfocus: '',
   i_ptutility: '',
+  i_ptconc: '',
   i_rulers: '',
   i_pcompare: '',
   i_overview_current: '',

From 41f2e1cb1bf146ff55f164eaa370fb59a17d02bc Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Thu, 24 Sep 2026 15:59:32 -0700
Subject: [PATCH 037/103] feat: list PowerX frontier points under the scatter
 chart
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Measured-power scatter charts list the drawn Pareto frontier with each
point's hardware, run, topology and official/unofficial source, plus CSV
export. Overlay points keep their run colour.

中文：在 PowerX 散点图下方列出前沿点。实测功耗散点图列出当前绘制的 Pareto 前沿，
逐点标明硬件、运行、拓扑以及官方或非官方来源，并支持 CSV 导出；非官方运行的点
沿用其运行颜色。
---
 .../component/frontier-points-panel.cy.tsx    | 158 ++++++++++++
 packages/app/cypress/e2e/powerx-compare.cy.ts | 133 +++++++++-
 .../inference/ui/FrontierPointsPanel.tsx      | 229 ++++++++++++++++++
 .../components/inference/ui/ScatterGraph.tsx  |  34 +++
 .../inference/utils/frontier-points.test.ts   | 138 +++++++++++
 .../inference/utils/frontier-points.ts        |  79 ++++++
 6 files changed, 768 insertions(+), 3 deletions(-)
 create mode 100644 packages/app/cypress/component/frontier-points-panel.cy.tsx
 create mode 100644 packages/app/src/components/inference/ui/FrontierPointsPanel.tsx
 create mode 100644 packages/app/src/components/inference/utils/frontier-points.test.ts
 create mode 100644 packages/app/src/components/inference/utils/frontier-points.ts

diff --git a/packages/app/cypress/component/frontier-points-panel.cy.tsx b/packages/app/cypress/component/frontier-points-panel.cy.tsx
new file mode 100644
index 000000000..182371f3b
--- /dev/null
+++ b/packages/app/cypress/component/frontier-points-panel.cy.tsx
@@ -0,0 +1,158 @@
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+
+import type { InferenceData } from '@/components/inference/types';
+import FrontierPointsPanel from '@/components/inference/ui/FrontierPointsPanel';
+import { FRONTIER_EXPORT_HEADERS } from '@/components/inference/utils/frontier-points';
+import { globalParetoFrontier } from '@/components/inference/utils/global-pareto';
+import { createMockInferenceData } from '../support/mock-data';
+import { mountWithProviders } from '../support/test-utils';
+
+const RUN = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs';
+const OVERLAY_RUN_URL = `${RUN}/33348766792/attempts/2`;
+const point = (overrides: Partial<InferenceData>) =>
+  createMockInferenceData({
+    hwKey: 'b200_sglang',
+    framework: 'sglang',
+    precision: 'fp8',
+    physicalChips: 4,
+    tp: 4,
+    decode_tp: 4,
+    date: '2026-09-18',
+    run_url: `${RUN}/35317697106/attempts/1`,
+    image: 'lmsysorg/sglang:nightly-dev-cu13-20260918-20518d85',
+    ...overrides,
+  });
+const gb300 = (overrides: Partial<InferenceData>) =>
+  point({
+    hwKey: 'gb300_dynamo-sglang',
+    framework: 'dynamo-sglang',
+    disagg: true,
+    physicalChips: 8,
+    num_prefill_gpu: 4,
+    num_decode_gpu: 4,
+    run_url: `${RUN}/35319969159/attempts/1`,
+    ...overrides,
+  });
+// Interactivity (higher is better) against J/output token (lower is better).
+const official = [
+  point({ id: 1, conc: 128, x: 31.6, y: 0.824 }),
+  point({ id: 2, conc: 1, x: 186.9, y: 9.065 }),
+  gb300({ id: 3, conc: 1, x: 206.3, y: 12.275 }),
+  gb300({ id: 4, conc: 4, x: 172.2, y: 4.634 }),
+  gb300({ id: 5, conc: 64, x: 72.2, y: 1.311 }),
+];
+// Faster and cheaper than GB300 c1, so the overlay point displaces it.
+const overlay = [
+  point({
+    id: 0,
+    hwKey: 'mi355x_sglang',
+    conc: 1,
+    x: 215,
+    y: 11,
+    run_url: OVERLAY_RUN_URL,
+    image: 'lmsysorg/sglang-rocm:v0.5.18-rocm720-mi35x-20260828',
+  }),
+];
+const eligible = [...official, ...overlay];
+const frontier = globalParetoFrontier(eligible, true, false);
+
+type CsvWindow = Cypress.AUTWindow & { __csv?: Blob };
+
+function mountPanel(width: number) {
+  cy.viewport(width, 1000);
+  mountWithProviders(
+    <PathnameContext.Provider value="/inference">
+      <div style={{ width: '100%', maxWidth: 1120, padding: 12, boxSizing: 'border-box' }}>
+        <FrontierPointsPanel
+          chartId="frontier-test"
+          eligible={eligible}
+          frontier={frontier}
+          xLabel="Interactivity (tok/s/user)"
+          yLabel="J/output token"
+          maximizeX
+          maximizeY={false}
+          overlayPoints={overlay}
+          hardwareLabel={(entry) => entry.hwKey.split('_')[0].toUpperCase()}
+          hardwareColor={() => 'rgb(200, 0, 0)'}
+        />
+      </div>
+    </PathnameContext.Provider>,
+    { unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } } },
+  );
+}
+
+describe('FrontierPointsPanel', () => {
+  it('states the competing scope and lists each frontier point with its run', () => {
+    mountPanel(1280);
+    cy.get('[data-testid="frontier-points-scope"]')
+      .should(
+        'contain.text',
+        '5 of 6 visible observations are on the frontier; they competed across 3 sources from 3 runs.',
+      )
+      .and('contain.text', 'Better: higher Interactivity (tok/s/user) and lower J/output token.');
+    cy.get('[data-testid="frontier-points-mixed"]').should(
+      'contain.text',
+      'span 2 topologies and 2 images',
+    );
+    cy.get('[data-testid="frontier-points-owner"]').then(($owners) =>
+      expect([...$owners].map((owner) => owner.textContent)).to.deep.equal([
+        'B200 ×2',
+        'GB300 ×2',
+        'MI355X ×1',
+      ]),
+    );
+    cy.get('[data-testid="frontier-points-row"]').should('have.length', 5);
+    cy.get('[data-testid="frontier-points-row"]')
+      .filter(':contains("MI355X")')
+      .should('contain.text', 'unofficial')
+      .and('contain.text', 'attempt 2')
+      .find('a')
+      .should('have.attr', 'href', OVERLAY_RUN_URL)
+      .and('have.text', 'run 33348766792');
+    cy.get('[data-testid="frontier-points-row"]')
+      .filter(':contains("MI355X")')
+      .find('th > span')
+      .first()
+      .should('have.attr', 'style')
+      .and('contain', 'var(--overlay-run-0)');
+    cy.get('[data-testid="frontier-points-table"]').should('not.contain.text', '206.3');
+  });
+
+  it('exports the frontier with run, attempt and unofficial provenance', () => {
+    mountPanel(1280);
+    cy.window().then((win) => {
+      cy.stub(win.URL, 'createObjectURL').callsFake((blob: Blob) => {
+        (win as CsvWindow).__csv = blob;
+        return 'blob:csv-test';
+      });
+      cy.stub(win.HTMLAnchorElement.prototype, 'click');
+    });
+    cy.get('#frontier-test-frontier-points [data-testid="export-button"]').click();
+    cy.get('[data-testid="export-csv-button"]').click();
+    cy.window()
+      .then((win) => (win as CsvWindow).__csv!.text())
+      .then((text) => {
+        expect(text).to.include('# x: Interactivity (tok/s/user)');
+        const [header, ...rows] = text
+          .split('\n')
+          .filter((line) => !line.startsWith('#'))
+          .map((line) => line.split(','));
+        expect(header).to.deep.equal([...FRONTIER_EXPORT_HEADERS, 'unofficial']);
+        const column = (name: string) => rows.map((row) => row[header.indexOf(name)]);
+        expect(rows).to.have.length(5);
+        expect(column('point_id').toSorted()).to.deep.equal(['0', '1', '2', '4', '5']);
+        expect(column('unofficial').filter((value) => value === 'true')).to.have.length(1);
+        expect(column('run_attempt')).to.include('2');
+      });
+  });
+
+  it('keeps the table inside its own scroller on mobile', () => {
+    mountPanel(390);
+    cy.document().should((doc) => {
+      expect(doc.documentElement.scrollWidth).to.be.at.most(doc.documentElement.clientWidth + 1);
+    });
+    cy.get('[data-testid="frontier-points-panel"]').screenshot('frontier-points-mobile', {
+      overwrite: true,
+    });
+  });
+});
diff --git a/packages/app/cypress/e2e/powerx-compare.cy.ts b/packages/app/cypress/e2e/powerx-compare.cy.ts
index af2594200..78de66d09 100644
--- a/packages/app/cypress/e2e/powerx-compare.cy.ts
+++ b/packages/app/cypress/e2e/powerx-compare.cy.ts
@@ -88,9 +88,11 @@ const availability = [
   },
 ];
 
-function interceptRows() {
+/** Official rows; with a run URL they form one source, as ingested runs do. */
+function interceptRows(officialRunUrl: string | null = null) {
+  const official = rows(null, 'b200').map((row) => ({ ...row, run_url: officialRunUrl }));
   cy.intercept('GET', '/api/v1/availability', { body: availability }).as('availability');
-  cy.intercept('GET', '/api/v1/benchmarks*', { body: rows(null, 'b200') }).as('benchmarks');
+  cy.intercept('GET', '/api/v1/benchmarks*', { body: official }).as('benchmarks');
   cy.intercept('GET', '/api/v1/workflow-info*', {
     body: { runs: [], changelogs: [], configs: [] },
   });
@@ -118,14 +120,47 @@ function interceptOverlayRows() {
   }).as('unofficialRun');
 }
 
+/** Overlay rows 10% cheaper per token than the official rows, so they own the frontier. */
+function interceptCheaperOverlayRows() {
+  const cheaper = rows(OVERLAY_RUN_URL, 'h200').map((row) => ({
+    ...row,
+    metrics: {
+      ...row.metrics,
+      joules_per_output_token: row.metrics.joules_per_output_token * 0.9,
+      joules_per_input_token: row.metrics.joules_per_input_token * 0.9,
+    },
+  }));
+  cy.intercept('GET', '/api/unofficial-run*', {
+    body: {
+      runInfos: [
+        {
+          id: OVERLAY_RUN_ID,
+          name: 'powerx-panels',
+          branch: 'powerx-panels',
+          sha: 'abc000',
+          createdAt: `${DATE}T00:00:00Z`,
+          url: OVERLAY_RUN_URL,
+          conclusion: 'success',
+          status: 'completed',
+          isNonMainBranch: true,
+        },
+      ],
+      benchmarks: cheaper,
+      evaluations: [],
+    },
+  }).as('unofficialRun');
+}
+
 function visitChart({
   path = '/inference',
   extraParams = '',
+  officialRunUrl = null,
 }: {
   path?: string;
   extraParams?: string;
+  officialRunUrl?: string | null;
 }) {
-  interceptRows();
+  interceptRows(officialRunUrl);
   cy.visit(`${path}?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4${extraParams}`, {
     onBeforeLoad(win) {
       win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
@@ -299,3 +334,95 @@ describe('PowerX comparison series (i_pcompare)', () => {
       .and('contain.text', '解码 GPU');
   });
 });
+
+// The article panels under a measured chart: load-matched rows, the role group,
+// the power-vs-output fit and the frontier's provenance, each for official rows
+// and a `?unofficialrun=` overlay together.
+describe('PowerX article panels', () => {
+  const PANELS = '&i_servicecompare=1&i_roleshare=1&i_powerfit=1&i_frontier=1';
+  const OFFICIAL_RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27182818284';
+  const OVERLAY_COLOR = 'var(--overlay-run-0)';
+
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message === 'ResizeObserver loop completed with undelivered notifications.') {
+        return false;
+      }
+    });
+  });
+
+  it('reproduces matched-load, role, fit and frontier panels for official and overlay rows', () => {
+    interceptCheaperOverlayRows();
+    visitChart({
+      extraParams: `&unofficialrun=${OVERLAY_RUN_ID}&i_metric=y_measuredJPerOutputToken${PANELS}`,
+      officialRunUrl: OFFICIAL_RUN_URL,
+    });
+    cy.wait('@unofficialRun');
+
+    // Official B200 against the overlay H200 at each observed concurrency.
+    for (const [conc] of CONFIGS) {
+      cy.get(`[data-testid="matched-concurrency-row-${conc}"]`).should(($row) => {
+        const text = $row.text().replaceAll('−', '-');
+        expect(text).to.include('-10.0%').and.include('W/GPU +0.0%');
+      });
+    }
+
+    // Role power: prefill and decode W/GPU for both sources; the overlay in its run colour.
+    cy.get('[data-testid="chart-0-role-power-plot"] circle.point').should(
+      'have.length',
+      CONFIGS.length * 4,
+    );
+    cy.get(`[data-testid="chart-0-role-power-plot"] circle.point[fill="${OVERLAY_COLOR}"]`).should(
+      'have.length',
+      CONFIGS.length * 2,
+    );
+    cy.get('[data-testid="chart-0-role-share-plot"] circle.point').should(
+      'have.length',
+      CONFIGS.length * 2,
+    );
+
+    // Output per allocated GPU is output per decode GPU × 4 ÷ 8: 100, 200 and 400 tok/s.
+    // W/GPU 500, 600, 700 → P0 450 W, m 0.643 J/token, R² 0.964.
+    cy.get('[data-testid="power-fit-row"]').should('have.length', 2);
+    cy.get('[data-testid="power-fit-row"]')
+      .filter(':contains("b200")')
+      .should('contain.text', '450')
+      .and('contain.text', '45% · 1,000 W')
+      .and('contain.text', '0.643')
+      .and('contain.text', '0.964')
+      .and('contain.text', '100.0–400.0');
+    cy.get('[data-testid="power-fit-row"]')
+      .filter(':contains("h200")')
+      .should('contain.text', '64% · 700 W');
+
+    // The cheaper overlay rows own the frontier; each lists its run.
+    cy.get('[data-testid="frontier-points-row"]')
+      .should('have.length', CONFIGS.length)
+      .each(($row) => {
+        expect($row.text()).to.include('unofficial');
+        expect($row.find('a').attr('href')).to.eq(OVERLAY_RUN_URL);
+      });
+    cy.get('[data-testid="frontier-points-scope"]').should(
+      'contain.text',
+      `${CONFIGS.length} of ${CONFIGS.length * 2} visible observations`,
+    );
+    assertShareLinkParams({
+      i_servicecompare: '1',
+      i_roleshare: '1',
+      i_powerfit: '1',
+      i_frontier: '1',
+    });
+  });
+
+  it('translates the article panels on /zh/inference', () => {
+    visitChart({
+      path: '/zh/inference',
+      extraParams: `&i_metric=y_measuredJPerOutputToken${PANELS}`,
+      officialRunUrl: OFFICIAL_RUN_URL,
+    });
+    cy.get('[data-testid="matched-concurrency-panel"]').should('contain.text', '相同并发下的对照');
+    cy.get('[data-testid="prefill-share-panel"]').should('contain.text', '预填充与解码角色');
+    cy.get('[data-testid="power-fit-panel"]').should('contain.text', '功耗与输出速率');
+    cy.get('[data-testid="frontier-points-panel"]').should('contain.text', '前沿点');
+  });
+});
diff --git a/packages/app/src/components/inference/ui/FrontierPointsPanel.tsx b/packages/app/src/components/inference/ui/FrontierPointsPanel.tsx
new file mode 100644
index 000000000..a8dcd84a6
--- /dev/null
+++ b/packages/app/src/components/inference/ui/FrontierPointsPanel.tsx
@@ -0,0 +1,229 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { Heading } from '@/components/ui/heading';
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
+import { exportToCsv } from '@/lib/csv-export';
+import { overlayRunColor, overlayRunIndex } from '@/lib/overlay-run-style';
+import { useLocale } from '@/lib/use-locale';
+import type { InferenceData } from '../types';
+import {
+  FRONTIER_EXPORT_HEADERS,
+  frontierExportRow,
+  frontierHardwareCounts,
+  frontierScope,
+} from '../utils/frontier-points';
+import { runAttemptFromUrl, runIdFromUrl } from '../utils/powerTimeline';
+import { pointTopologyKey, topologyLabel } from '../utils/topology-filter';
+
+const STRINGS = {
+  en: {
+    title: 'Frontier points',
+    scope: (frontier: number, eligible: number, sources: number, runs: number) =>
+      `${frontier} of ${eligible} visible observations are on the frontier; they competed across ${sources} sources from ${runs} runs.`,
+    direction: (x: string, y: string) => `Better: ${x} and ${y}.`,
+    higher: (label: string) => `higher ${label}`,
+    lower: (label: string) => `lower ${label}`,
+    method:
+      'One non-dominated set over every series visible on the chart, with the chart’s filters. Each point keeps its own run and recipe; nothing is interpolated or averaged.',
+    mixed: (topologies: number, images: number) =>
+      `The competing observations span ${topologies} topologies and ${images} images, so the frontier compares deployments as served, not one recipe.`,
+    owners: 'Frontier points by hardware',
+    hardware: 'Hardware',
+    config: 'Configuration',
+    concurrency: 'Conc.',
+    run: 'Run',
+    date: 'Date',
+    attempt: (attempt: number) => `attempt ${attempt}`,
+    unofficial: 'unofficial',
+    noRun: 'No run recorded',
+  },
+  zh: {
+    title: '前沿点',
+    scope: (frontier: number, eligible: number, sources: number, runs: number) =>
+      `${eligible} 个可见观测值中有 ${frontier} 个位于前沿上；这些观测值来自 ${runs} 次运行中的 ${sources} 个数据源。`,
+    direction: (x: string, y: string) => `更优方向：${x}、${y}。`,
+    higher: (label: string) => `${label}更高`,
+    lower: (label: string) => `${label}更低`,
+    method:
+      '在图表当前的筛选条件下，对图上全部可见系列统一计算一个非支配集合。每个点保留各自的运行和配置方案，不做插值或平均。',
+    mixed: (topologies: number, images: number) =>
+      `参与比较的观测值涉及 ${topologies} 种拓扑和 ${images} 个镜像，因此前沿比较的是各自的实际部署，而非同一配置方案。`,
+    owners: '各硬件的前沿点数',
+    hardware: '硬件',
+    config: '配置',
+    concurrency: '并发',
+    run: '运行',
+    date: '日期',
+    attempt: (attempt: number) => `第 ${attempt} 次尝试`,
+    unofficial: '非官方',
+    noRun: '未记录运行',
+  },
+};
+
+const number = d3.format(',.4~g');
+
+export default function FrontierPointsPanel({
+  chartId,
+  eligible,
+  frontier,
+  xLabel,
+  yLabel,
+  maximizeX,
+  maximizeY,
+  overlayPoints,
+  hardwareLabel,
+  hardwareColor,
+}: {
+  chartId: string;
+  /** Observations that competed: the chart's visible, frontier-eligible points. */
+  eligible: readonly InferenceData[];
+  frontier: readonly InferenceData[];
+  xLabel: string;
+  yLabel: string;
+  maximizeX: boolean;
+  maximizeY: boolean;
+  overlayPoints: readonly InferenceData[];
+  hardwareLabel: (point: InferenceData) => string;
+  hardwareColor: (point: InferenceData) => string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const { runIndexByUrl } = useUnofficialRun();
+  const overlaySet = useMemo(() => new Set(overlayPoints), [overlayPoints]);
+  const scope = useMemo(() => frontierScope(eligible), [eligible]);
+  const owners = useMemo(() => frontierHardwareCounts(frontier), [frontier]);
+  const topologies = useMemo(() => [...new Set(eligible.map(pointTopologyKey))], [eligible]);
+  const sectionId = `${chartId}-frontier-points`;
+  const colorOf = (point: InferenceData) =>
+    overlaySet.has(point)
+      ? overlayRunColor(overlayRunIndex(point.run_url, runIndexByUrl))
+      : hardwareColor(point);
+  const labelFor = (hwKey: string) => {
+    const point = frontier.find((entry) => entry.hwKey === hwKey);
+    return point ? hardwareLabel(point) : hwKey;
+  };
+
+  const exportCsv = () => {
+    exportToCsv(
+      'InferenceX_frontier_points',
+      [...FRONTIER_EXPORT_HEADERS, 'unofficial'],
+      frontier.map((point) => [...frontierExportRow(point), overlaySet.has(point)]),
+      [`x: ${xLabel}`, `y: ${yLabel}`],
+    );
+  };
+
+  return (
+    <section
+      id={sectionId}
+      className="mt-4 min-w-0 space-y-3 border-t pt-4"
+      data-testid="frontier-points-panel"
+    >
+      <Heading as="h3" level="card">
+        {t.title}
+      </Heading>
+      <p className="text-sm" data-testid="frontier-points-scope">
+        {t.scope(frontier.length, scope.eligible, scope.sources, scope.runs)}{' '}
+        {t.direction(
+          maximizeX ? t.higher(xLabel) : t.lower(xLabel),
+          maximizeY ? t.higher(yLabel) : t.lower(yLabel),
+        )}
+      </p>
+      <p className="text-xs text-muted-foreground">{t.method}</p>
+      {(scope.topologies > 1 || scope.images > 1) && (
+        <p className="text-xs text-muted-foreground" data-testid="frontier-points-mixed">
+          {t.mixed(scope.topologies, scope.images)}
+        </p>
+      )}
+      <p className="flex flex-wrap items-center gap-x-4 gap-y-1 text-sm">
+        <span className="text-muted-foreground">{t.owners}:</span>
+        {owners.map(({ hwKey, count }) => (
+          <span key={hwKey} data-testid="frontier-points-owner">
+            {labelFor(hwKey)} ×{count}
+          </span>
+        ))}
+      </p>
+      <div className="max-h-96 min-w-0 overflow-auto">
+        <table
+          className="w-full min-w-[48rem] table-fixed break-words text-left text-sm"
+          data-testid="frontier-points-table"
+        >
+          <thead className="sticky top-0 bg-background align-bottom">
+            <tr>
+              <th className="w-1/5 p-2">{t.hardware}</th>
+              <th className="w-1/4 p-2">{t.config}</th>
+              <th className="w-16 p-2">{t.concurrency}</th>
+              <th className="p-2">{xLabel}</th>
+              <th className="p-2">{yLabel}</th>
+              <th className="p-2">{t.run}</th>
+              <th className="w-24 p-2">{t.date}</th>
+            </tr>
+          </thead>
+          <tbody>
+            {frontier.map((point, index) => {
+              const runId = runIdFromUrl(point.run_url);
+              const attempt = runAttemptFromUrl(point.run_url);
+              return (
+                <tr
+                  key={`${point.id ?? index}:${point.run_url ?? ''}`}
+                  className="border-t"
+                  data-testid="frontier-points-row"
+                >
+                  <th className="p-2 align-top font-normal">
+                    <span style={{ color: colorOf(point) }}>● </span>
+                    {hardwareLabel(point)}
+                    {overlaySet.has(point) && (
+                      <span className="block text-xs text-muted-foreground">{t.unofficial}</span>
+                    )}
+                  </th>
+                  <td className="p-2 align-top">
+                    {[
+                      point.framework,
+                      point.precision.toUpperCase(),
+                      topologyLabel(pointTopologyKey(point), locale, topologies),
+                    ]
+                      .filter(Boolean)
+                      .join(' · ')}
+                  </td>
+                  <td className="p-2 align-top">{point.conc}</td>
+                  <td className="p-2 align-top">{number(point.x)}</td>
+                  <td className="p-2 align-top">{number(point.y)}</td>
+                  <td className="p-2 align-top">
+                    {point.run_url && runId ? (
+                      <a
+                        href={point.run_url}
+                        target="_blank"
+                        rel="noopener noreferrer"
+                        className="underline decoration-dotted"
+                      >
+                        {`run ${runId}`}
+                      </a>
+                    ) : (
+                      <span className="text-muted-foreground">{t.noRun}</span>
+                    )}
+                    {attempt !== null && (
+                      <span className="block text-xs text-muted-foreground">
+                        {t.attempt(attempt)}
+                      </span>
+                    )}
+                  </td>
+                  <td className="p-2 align-top">{point.actualDate ?? point.date}</td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </table>
+      </div>
+      <ChartButtons
+        chartId={sectionId}
+        analyticsPrefix="frontier_points"
+        hideZoomReset
+        hideImageExport
+        onExportCsv={exportCsv}
+      />
+    </section>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 57dfc074f..8873cddd0 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -161,6 +161,7 @@ import {
   powerVariantLabel,
   powerVariantsInData,
 } from '@/components/inference/utils/power-compare';
+import FrontierPointsPanel from '@/components/inference/ui/FrontierPointsPanel';
 import LegendPointsDialog from '@/components/inference/ui/LegendPointsDialog';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
 import { renderLegacyPowerRing } from '@/components/inference/utils/legacy-power-marker';
@@ -1694,6 +1695,25 @@ const ScatterGraph = React.memo(
       () => frontierHardwareKeys(globalParetoPoints, globalFrontier),
       [globalParetoPoints, globalFrontier],
     );
+    // PowerX provenance of the drawn frontier: the same points, listed with their runs.
+    const showFrontierPoints =
+      showParetoFrontier &&
+      globalFrontier.length > 0 &&
+      !minimalChrome &&
+      getMeasuredMetricConfig(selectedYAxisMetric) !== undefined;
+    const frontierHardwareLabel = useCallback(
+      (point: InferenceData) => {
+        const config = processedOverlayData.includes(point)
+          ? overlayData?.hardwareConfig[point.hwKey]
+          : hardwareConfig[point.hwKey];
+        return config ? getDisplayLabel(config) : point.hwKey;
+      },
+      [processedOverlayData, overlayData, hardwareConfig],
+    );
+    const frontierHardwareColor = useCallback(
+      (point: InferenceData) => getCssColor(resolveColor(point.hwKey)),
+      [getCssColor, resolveColor],
+    );
     const applyParetoFadeRef = useRef<(group: RenderContext['layout']['zoomGroup']) => void>(
       () => {},
     );
@@ -4732,6 +4752,20 @@ const ScatterGraph = React.memo(
             }
           />
         )}
+        {showFrontierPoints && (
+          <FrontierPointsPanel
+            chartId={chartId}
+            eligible={globalParetoPoints}
+            frontier={globalFrontier}
+            xLabel={xLabel}
+            yLabel={yLabel}
+            maximizeX={maximizeParetoX}
+            maximizeY={maximizeParetoY}
+            overlayPoints={processedOverlayData}
+            hardwareLabel={frontierHardwareLabel}
+            hardwareColor={frontierHardwareColor}
+          />
+        )}
         {powerTelemetryPoint === null ? null : (
           <PowerTelemetryDialog
             key={powerTelemetryPoint.id}
diff --git a/packages/app/src/components/inference/utils/frontier-points.test.ts b/packages/app/src/components/inference/utils/frontier-points.test.ts
new file mode 100644
index 000000000..5bcdb83dc
--- /dev/null
+++ b/packages/app/src/components/inference/utils/frontier-points.test.ts
@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest';
+import type { InferenceData } from '../types';
+import {
+  FRONTIER_EXPORT_HEADERS,
+  frontierExportRow,
+  frontierHardwareCounts,
+  frontierScope,
+} from './frontier-points';
+import { globalParetoFrontier } from './global-pareto';
+
+const metric = (y: number) => ({ y, roof: false });
+const RUN = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs';
+function point(overrides: Partial<InferenceData> = {}): InferenceData {
+  return {
+    x: 100,
+    y: 1,
+    hwKey: 'b200_sglang',
+    framework: 'sglang',
+    date: '2026-09-18',
+    tp: 4,
+    physicalChips: 4,
+    decode_tp: 4,
+    precision: 'fp8',
+    conc: 1,
+    run_url: `${RUN}/35317697106/attempts/1`,
+    image: 'lmsysorg/sglang:nightly-dev-cu13-20260918-20518d85',
+    tpPerGpu: metric(50),
+    tpPerMw: metric(50),
+    costh: metric(1),
+    costr: metric(1),
+    costhi: metric(1),
+    costri: metric(1),
+    ...overrides,
+  };
+}
+
+// Interactivity (x, higher is better) vs J/output token (y, lower is better).
+const b200 = [
+  point({ id: 1, conc: 128, x: 31.6, y: 0.824 }),
+  point({ id: 2, conc: 1, x: 186.9, y: 9.065 }),
+];
+const gb300 = [
+  point({
+    id: 3,
+    hwKey: 'gb300_dynamo-sglang',
+    framework: 'dynamo-sglang',
+    disagg: true,
+    num_prefill_gpu: 4,
+    num_decode_gpu: 4,
+    conc: 1,
+    x: 206.3,
+    y: 12.275,
+    run_url: `${RUN}/35319969159/attempts/1`,
+  }),
+  point({
+    id: 6,
+    hwKey: 'gb300_dynamo-sglang',
+    framework: 'dynamo-sglang',
+    disagg: true,
+    num_prefill_gpu: 4,
+    num_decode_gpu: 4,
+    conc: 4,
+    x: 172.2,
+    y: 4.634,
+    run_url: `${RUN}/35319969159/attempts/1`,
+  }),
+  point({
+    id: 4,
+    hwKey: 'gb300_dynamo-sglang',
+    framework: 'dynamo-sglang',
+    disagg: true,
+    num_prefill_gpu: 4,
+    num_decode_gpu: 4,
+    conc: 64,
+    x: 72.2,
+    y: 1.311,
+    run_url: `${RUN}/35319969159/attempts/1`,
+  }),
+];
+const mi355x = [
+  point({
+    id: 5,
+    hwKey: 'mi355x_sglang',
+    conc: 4,
+    x: 110.1,
+    y: 4.937,
+    run_url: `${RUN}/33348766792/attempts/2`,
+    image: 'lmsysorg/sglang-rocm:v0.5.18-rocm720-mi35x-20260828',
+  }),
+];
+const eligible = [...b200, ...gb300, ...mi355x];
+
+describe('frontier provenance', () => {
+  it('describes the competing scope and which hardware owns the frontier', () => {
+    const frontier = globalParetoFrontier(eligible, true, false);
+    // MI355X c4 is dominated by GB300 c4 (faster and cheaper).
+    expect(frontier.map((entry) => entry.id)).toEqual([1, 4, 6, 2, 3]);
+    expect(frontierHardwareCounts(frontier)).toEqual([
+      { hwKey: 'gb300_dynamo-sglang', count: 3 },
+      { hwKey: 'b200_sglang', count: 2 },
+    ]);
+    expect(frontierScope(eligible)).toEqual({
+      eligible: 6,
+      sources: 3,
+      runs: 3,
+      topologies: 2,
+      images: 2,
+    });
+    expect(frontierScope([])).toEqual({
+      eligible: 0,
+      sources: 0,
+      runs: 0,
+      topologies: 0,
+      images: 0,
+    });
+  });
+
+  it('exports one row per frontier point with its run, attempt and recipe identity', () => {
+    const row = frontierExportRow(gb300[2]);
+    expect(row).toHaveLength(FRONTIER_EXPORT_HEADERS.length);
+    const record = Object.fromEntries(
+      FRONTIER_EXPORT_HEADERS.map((key, index) => [key, row[index]]),
+    );
+    expect(record).toMatchObject({
+      hardware: 'gb300_dynamo-sglang',
+      framework: 'dynamo-sglang',
+      concurrency: 64,
+      x: 72.2,
+      y: 1.311,
+      run_id: '35319969159',
+      run_attempt: 1,
+      recipe_fingerprint: null,
+      point_id: 4,
+    });
+    expect(String(record.topology)).toMatch(/^PD\|/u);
+    expect(frontierExportRow(point({ run_url: undefined }))).toContain(null);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/frontier-points.ts b/packages/app/src/components/inference/utils/frontier-points.ts
new file mode 100644
index 000000000..4b0a4c01e
--- /dev/null
+++ b/packages/app/src/components/inference/utils/frontier-points.ts
@@ -0,0 +1,79 @@
+import type { InferenceData } from '../types';
+import { equalServiceSourceKey } from './equal-service-comparison';
+import { runAttemptFromUrl, runIdFromUrl } from './powerTimeline';
+import { pointTopologyKey } from './topology-filter';
+
+/**
+ * Provenance of a cross-platform frontier (PowerX Figure 16). The frontier is
+ * the chart's own global non-dominated set; this only makes the comparison
+ * scope explicit: how many observations, sources, runs, topologies and images
+ * competed, and which hardware owns the frontier.
+ */
+export interface FrontierScope {
+  /** Observations that competed for the frontier. */
+  eligible: number;
+  sources: number;
+  runs: number;
+  topologies: number;
+  images: number;
+}
+
+export function frontierScope(eligible: readonly InferenceData[]): FrontierScope {
+  const distinct = (key: (point: InferenceData) => string | null | undefined) =>
+    new Set(eligible.map(key).filter((value) => value !== null && value !== undefined)).size;
+  return {
+    eligible: eligible.length,
+    sources: distinct(equalServiceSourceKey),
+    runs: distinct((point) => point.run_url),
+    topologies: distinct(pointTopologyKey),
+    images: distinct((point) => point.image),
+  };
+}
+
+/** Frontier points per hardware key, most first; ties keep hardware order. */
+export function frontierHardwareCounts(
+  frontier: readonly InferenceData[],
+): { hwKey: string; count: number }[] {
+  const counts = new Map<string, number>();
+  for (const point of frontier) counts.set(point.hwKey, (counts.get(point.hwKey) ?? 0) + 1);
+  return [...counts]
+    .map(([hwKey, count]) => ({ hwKey, count }))
+    .toSorted((a, b) => b.count - a.count || a.hwKey.localeCompare(b.hwKey));
+}
+
+/** Stable export columns: identity first, then plotted coordinates and provenance. */
+export const FRONTIER_EXPORT_HEADERS = [
+  'hardware',
+  'framework',
+  'precision',
+  'topology',
+  'concurrency',
+  'x',
+  'y',
+  'date',
+  'run_url',
+  'run_id',
+  'run_attempt',
+  'recipe_fingerprint',
+  'image',
+  'point_id',
+] as const;
+
+export function frontierExportRow(point: InferenceData): (string | number | null)[] {
+  return [
+    point.hwKey,
+    point.framework ?? null,
+    point.precision,
+    pointTopologyKey(point),
+    point.conc,
+    point.x,
+    point.y,
+    point.actualDate ?? point.date,
+    point.run_url ?? null,
+    runIdFromUrl(point.run_url),
+    runAttemptFromUrl(point.run_url),
+    point.recipe_fingerprint ?? null,
+    point.image ?? null,
+    point.id ?? null,
+  ];
+}

From b7a88b6c8067c83528f58e18d8cf2fe8aefc0921 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Thu, 24 Sep 2026 15:59:47 -0700
Subject: [PATCH 038/103] feat: expose PowerX panel data in the views API
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

/api/v1/views/inference returns matchedConcurrency with serviceCompare,
rolePoints with roleShare, and powerFits with the new powerFit flag, so
agents read the same rows the panels draw. Docs, catalog digests and the
skill reference follow.

中文：视图 API 返回 PowerX 面板数据。/api/v1/views/inference 在 serviceCompare
下返回 matchedConcurrency，在 roleShare 下返回 rolePoints，并新增 powerFit 参数
返回 powerFits，使 agent 读取的数据与面板绘制的一致；文档、目录摘要和 skill 参考
同步更新。
---
 .../app/api/v1/views/inference/route.test.ts  | 107 +++++++++++++++++
 .../src/app/api/v1/views/inference/route.ts   |  60 +++++++++-
 .../app/api/v1/views/options/route.test.ts    |   1 +
 .../app/src/app/api/v1/views/options/route.ts |   1 +
 packages/app/src/lib/api-route-catalog.ts     |  22 +++-
 .../app/src/lib/views-api/docs/inference.ts   | 113 +++++++++++++++++-
 .../app/src/lib/views-api/docs/options.ts     |   1 +
 packages/app/src/lib/views-api/registry.ts    |   1 +
 .../skills/inferencex-api/integrity.json      |   2 +-
 .../references/dashboard-views.md             |  66 ++++++----
 10 files changed, 337 insertions(+), 37 deletions(-)

diff --git a/packages/app/src/app/api/v1/views/inference/route.test.ts b/packages/app/src/app/api/v1/views/inference/route.test.ts
index 3bfb6ea21..167cb9544 100644
--- a/packages/app/src/app/api/v1/views/inference/route.test.ts
+++ b/packages/app/src/app/api/v1/views/inference/route.test.ts
@@ -5,6 +5,8 @@ import {
   buildEqualServiceComparison,
   getEqualServiceSources,
 } from '@/components/inference/utils/equal-service-comparison';
+import { buildMatchedConcurrencyTable } from '@/components/inference/utils/matched-concurrency';
+import { buildPowerFits } from '@/components/inference/utils/power-fit';
 import { buildInferenceSeries } from '@/lib/views-api/series';
 import { Sequence } from '@/lib/data-mappings';
 import type { BenchmarkRow } from '@/lib/api';
@@ -197,6 +199,7 @@ describe('GET /api/v1/views/inference', () => {
     for (const extra of [
       'format=csv&serviceCompare=true',
       'format=csv&roleShare=true',
+      'format=csv&powerFit=true',
       'serviceTarget=0',
       'serviceTarget=',
       'serviceTarget=NaN',
@@ -224,6 +227,8 @@ describe('GET /api/v1/views/inference', () => {
         joules_per_output_token: 8,
         prefill_joules_per_input_token: 0.4,
         decode_joules_per_output_token: 4.8,
+        prefill_avg_power_w: 520,
+        decode_avg_power_w: 410,
       },
     });
     mockGetLatestBenchmarks.mockResolvedValue([row]);
@@ -256,9 +261,111 @@ describe('GET /api/v1/views/inference', () => {
         decodeShare: 60,
       });
     }
+    expect(body.rolePoints).toHaveLength(2);
+    for (const role of body.rolePoints) {
+      expect(role).toMatchObject({
+        prefillWattsPerGpu: 520,
+        decodeWattsPerGpu: 410,
+        prefillJoulesPerInputToken: 0.4,
+        decodeJoulesPerOutputToken: 4.8,
+        energy: { prefill: 3.2, decode: 4.8, total: 8, prefillShare: 40 },
+      });
+      expect(Object.keys(role.point)).not.toContain('tpPerGpu');
+    }
     expect(body.overlays[0]).not.toHaveProperty('observedPoints');
   });
 
+  it('returns the same-concurrency table and per-source power fits the dashboard draws', async () => {
+    const ladder = (hardware: string, loads: [number, number][], base: number) =>
+      loads.map(([conc, output]) =>
+        makeRow({
+          hardware,
+          conc,
+          metrics: {
+            ...makeRow().metrics,
+            median_intvty: 100 / conc,
+            output_tput_per_gpu: output,
+            avg_power_w: base + 0.5 * output,
+            joules_per_output_token: (base + 0.5 * output) / output,
+            power_valid: 1,
+            power_metric_schema_version: 2,
+          },
+        }),
+      );
+    const rows = [
+      ...ladder(
+        'h200',
+        [
+          [1, 20],
+          [4, 60],
+          [16, 120],
+        ],
+        250,
+      ),
+      ...ladder(
+        'mi300x',
+        [
+          [1, 30],
+          [16, 150],
+        ],
+        400,
+      ),
+    ];
+    mockGetLatestBenchmarks.mockResolvedValue(rows);
+    const projected = buildInferenceSeries(rows, {
+      sequence: Sequence.EightK_OneK,
+      percentile: 'p90',
+      precisions: ['fp8'],
+      metricConfigKey: 'y_measuredAvgPower',
+      xmode: 'interactivity',
+      xmetric: 'p90_ttft',
+      gpus: [],
+      quickFilters: { vendors: [], frameworks: [], deployment: [], spec: [], power: [] },
+      optimal: true,
+      best: true,
+    });
+    const sources = getEqualServiceSources(projected.observedPoints);
+    const expected = buildMatchedConcurrencyTable(projected.observedPoints, {
+      baseline: sources[0].key,
+      comparator: sources[1].key,
+      interactivityField: 'median_intvty',
+    });
+    const response = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=measuredAvgPower&serviceCompare=true&powerFit=true',
+      ),
+    );
+    const body = await response.json();
+    expect(response.status).toBe(200);
+    expect(body.params.powerFit).toBe(true);
+    expect(body.matchedConcurrency.interactivityField).toBe('median_intvty');
+    expect(
+      body.matchedConcurrency.rows.map((row: { concurrency: number }) => row.concurrency),
+    ).toEqual([1, 4, 16]);
+    expect(
+      body.matchedConcurrency.rows.map((row: { changePercent: unknown }) => row.changePercent),
+    ).toEqual(expected.rows.map((row) => row.changePercent));
+    // c4 exists only for H200: the MI300X side stays missing, never borrowed.
+    expect(body.matchedConcurrency.rows[1].comparator).toEqual({ status: 'missing' });
+    expect(body.matchedConcurrency.rows[0].baseline.point.id).toBe(rows[0].id);
+
+    const fits = buildPowerFits(projected.observedPoints);
+    expect(body.powerFits).toHaveLength(2);
+    const h200 = body.powerFits.find(
+      (entry: { source: { key: string } }) => entry.source.key === fits[0].source.key,
+    );
+    expect(h200.fit.intercept).toBeCloseTo(250, 9);
+    expect(h200.fit.slope).toBeCloseTo(0.5, 9);
+    expect(h200.tdpWatts).toBe(700);
+    expect(h200.observations.map((entry: { point: { id: number } }) => entry.point.id)).toEqual(
+      rows.slice(0, 3).map((row) => row.id),
+    );
+    const mi300x = body.powerFits.find(
+      (entry: { source: { key: string } }) => entry.source.key === fits[1].source.key,
+    );
+    expect(mi300x).toMatchObject({ fit: null, reason: 'too-few-points' });
+  });
+
   it('resolves the fixed-sequence statistic and rejects unknown values', async () => {
     mockGetLatestBenchmarks.mockResolvedValue([
       makeRow({ metrics: { ...makeRow().metrics, mean_tpot: 0.025, mean_intvty: 99 } }),
diff --git a/packages/app/src/app/api/v1/views/inference/route.ts b/packages/app/src/app/api/v1/views/inference/route.ts
index 7398a4f5d..8ae6f0d7d 100644
--- a/packages/app/src/app/api/v1/views/inference/route.ts
+++ b/packages/app/src/app/api/v1/views/inference/route.ts
@@ -7,9 +7,17 @@ import {
   getEqualServiceComparisonCurve,
   getEqualServiceSources,
   getPrefillSharePoints,
+  getRolePoints,
   type EqualServiceComparison,
   type EqualServiceEstimate,
 } from '@/components/inference/utils/equal-service-comparison';
+import {
+  buildMatchedConcurrencyTable,
+  type MatchedConcurrencySide,
+  type MatchedConcurrencyTable,
+} from '@/components/inference/utils/matched-concurrency';
+import { buildPowerFits } from '@/components/inference/utils/power-fit';
+import { resolveServiceField } from '@/components/inference/utils/resolveXAxisField';
 import { pointTopologyKey } from '@/components/inference/utils/topology-filter';
 import type {
   InferenceData,
@@ -254,6 +262,25 @@ function publicServiceComparison(comparison: EqualServiceComparison) {
   };
 }
 
+function publicMatchedSide(side: MatchedConcurrencySide) {
+  if (side.status === 'observed')
+    return { status: side.status, values: side.values, point: observedPointIdentity(side.point) };
+  if (side.status === 'ambiguous')
+    return { status: side.status, points: side.points.map(observedPointIdentity) };
+  return side;
+}
+
+function publicMatchedConcurrency(table: MatchedConcurrencyTable) {
+  return {
+    ...table,
+    rows: table.rows.map((row) => ({
+      ...row,
+      baseline: publicMatchedSide(row.baseline),
+      comparator: publicMatchedSide(row.comparator),
+    })),
+  };
+}
+
 export function GET(request: NextRequest) {
   return runViewsRoute('inference', async () => {
     validateViewParams(request.nextUrl.searchParams, VIEW_QUERY_PARAMS['inference']);
@@ -299,6 +326,7 @@ export function GET(request: NextRequest) {
     const format = parseFormatParam(search.get('format'));
     const serviceCompare = parseBoolParam(search.get('serviceCompare'), 'serviceCompare', false);
     const roleShare = parseBoolParam(search.get('roleShare'), 'roleShare', false);
+    const powerFit = parseBoolParam(search.get('powerFit'), 'powerFit', false);
     const requestedServiceBaseline = search.get('serviceBaseline');
     const requestedServiceComparator = search.get('serviceComparator');
     const serviceTarget = search.has('serviceTarget')
@@ -306,10 +334,10 @@ export function GET(request: NextRequest) {
       : null;
     if (serviceTarget !== null && serviceTarget <= 0)
       throw new ViewsApiParamError('serviceTarget', 'serviceTarget must be positive');
-    if (format === 'csv' && (serviceCompare || roleShare))
+    if (format === 'csv' && (serviceCompare || roleShare || powerFit))
       throw new ViewsApiParamError(
         'format',
-        'Equal-service and role-share panels require format=json',
+        'Equal-service, role-share and power-fit panels require format=json',
       );
     const tcoBasis = parseTcoBasisParam(search.get('tcoBasis'));
     const power = parseListParam(search.get('power'), 'power', POWER_TIER_ORDER);
@@ -458,6 +486,18 @@ export function GET(request: NextRequest) {
           equalServiceCurve: getEqualServiceComparisonCurve(observedPoints, serviceOptions).map(
             publicServiceComparison,
           ),
+          matchedConcurrency: publicMatchedConcurrency(
+            buildMatchedConcurrencyTable(observedPoints, {
+              baseline: serviceBaseline,
+              comparator: serviceComparator,
+              // The dashboard reads streaming speed at the selected statistic.
+              interactivityField: resolveServiceField('median_intvty', {
+                isAgentic: sequence === Sequence.AgenticTraces,
+                percentile,
+                fixedSequenceStatistic: xstat,
+              }),
+            }),
+          ),
         }
       : {};
     const rolePanel = roleShare
@@ -469,6 +509,20 @@ export function GET(request: NextRequest) {
               decodeShare: 100 - energy.prefillShare,
             }),
           ),
+          rolePoints: getRolePoints(observedPoints, serviceOptions.xField).map(
+            ({ point, ...role }) => ({ ...role, point: observedPointIdentity(point) }),
+          ),
+        }
+      : {};
+    const fitPanel = powerFit
+      ? {
+          powerFits: buildPowerFits(observedPoints).map(({ observations, ...fit }) => ({
+            ...fit,
+            observations: observations.map(({ point, ...observation }) => ({
+              ...observation,
+              point: observedPointIdentity(point),
+            })),
+          })),
         }
       : {};
 
@@ -505,6 +559,7 @@ export function GET(request: NextRequest) {
       serviceComparator: serviceCompare ? serviceComparator : null,
       serviceTarget: serviceCompare ? serviceTarget : null,
       roleShare,
+      powerFit,
     };
 
     if (format === 'csv') {
@@ -534,6 +589,7 @@ export function GET(request: NextRequest) {
       pricing,
       ...servicePanels,
       ...rolePanel,
+      ...fitPanel,
     });
   });
 }
diff --git a/packages/app/src/app/api/v1/views/options/route.test.ts b/packages/app/src/app/api/v1/views/options/route.test.ts
index 612016adc..d38d7508a 100644
--- a/packages/app/src/app/api/v1/views/options/route.test.ts
+++ b/packages/app/src/app/api/v1/views/options/route.test.ts
@@ -96,6 +96,7 @@ describe('GET /api/v1/views/options', () => {
       xstat: 'median',
       serviceCompare: false,
       roleShare: false,
+      powerFit: false,
     });
     // Same vendors, in the dashboard's quick-filter pill order.
     expect(body.quickFilters.vendors).toEqual(VENDOR_ORDER);
diff --git a/packages/app/src/app/api/v1/views/options/route.ts b/packages/app/src/app/api/v1/views/options/route.ts
index 6af689edb..a1e766c22 100644
--- a/packages/app/src/app/api/v1/views/options/route.ts
+++ b/packages/app/src/app/api/v1/views/options/route.ts
@@ -194,6 +194,7 @@ function buildOptionsPayload() {
       xstat: 'median',
       serviceCompare: false,
       roleShare: false,
+      powerFit: false,
       xmetric: 'p90_ttft',
       scale: 'auto',
       precisions: 'auto',
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 884fd4e9c..051c4324b 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -139,7 +139,7 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'published-read',
     operationId: 'get-inference-view',
-    sourceSha256: '5f2d5997fdab9e1e94510bdbefe6e0dba394d65680fec37c5bcdeeb004eefcfd',
+    sourceSha256: 'bafac08dbe6e6e4b75dd15987e79f84b514f3e93351149ad44b296f6dd2a9662',
   },
   {
     source: 'src/app/api/v1/views/operatorx/route.ts',
@@ -155,7 +155,7 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'published-read',
     operationId: 'get-view-options',
-    sourceSha256: '1f441c8726e6adb69d68660e80e854582bbacaba842cea5ec6f3ad2512ff1b5c',
+    sourceSha256: 'ceba9504cfc50cb37748c9455f22dca9813789eb0148da740b24678bb540fb27',
   },
   {
     source: 'src/app/api/v1/views/overview/route.ts',
@@ -820,6 +820,22 @@ export const apiContractSourceDigests = [
       zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源、prefill 占比视图以及各角色数据点。',
     },
   },
+  {
+    source: 'src/components/inference/utils/matched-concurrency.ts',
+    sourceSha256: 'db81deeff9e6ff64f607b71751d18acc59626f43fecbe037145e3a55c4fe959f',
+    reviewArea: {
+      en: 'Same-concurrency pairing of two exact sources: missing and conflicting observations, signed comparator-relative changes, no interpolation.',
+      zh: '两个完整来源在相同并发下的配对：缺失与冲突观测、相对基准的带符号变化，不做插值。',
+    },
+  },
+  {
+    source: 'src/components/inference/utils/power-fit.ts',
+    sourceSha256: '6c39a91e0745cd6432730f7d9094638fe1365c1e6d38a99c696c21359409bafb',
+    reviewArea: {
+      en: 'Per-source least-squares power fit on output per allocated GPU: intercept, marginal J/token, R², fitted range and registry TDP.',
+      zh: '按来源对每个已分配 GPU 的输出做最小二乘功耗拟合：截距、边际 J/token、R²、拟合范围与注册表 TDP。',
+    },
+  },
   {
     source: 'src/components/inference/utils/role-energy.ts',
     sourceSha256: '36b1ceda97af99731482ed815167a660f1619ab94c2956afe11cf72d58fa5380',
@@ -996,7 +1012,7 @@ export const apiContractSourceDigests = [
 
   {
     source: 'src/lib/views-api/registry.ts',
-    sourceSha256: '266305115106c86b18d1131e3a8916a756b847f569e7de02c82ec74dad1bcf17',
+    sourceSha256: '5770b2b60883003f4203b9db915aee24e39e14ca5dd787b67281520fd11f940c',
     reviewArea: {
       en: 'Dashboard read-only selector and calculation parity.',
       zh: '仪表板只读接口的选择项与计算一致性。',
diff --git a/packages/app/src/lib/views-api/docs/inference.ts b/packages/app/src/lib/views-api/docs/inference.ts
index e8ea04b6f..7dc330dde 100644
--- a/packages/app/src/lib/views-api/docs/inference.ts
+++ b/packages/app/src/lib/views-api/docs/inference.ts
@@ -221,8 +221,8 @@ const parameters: readonly ApiParameter[] = [
     required: false,
     type: 'boolean',
     description: text(
-      'Include source options, equal-service percentage curves and an optional target comparison, using the same helper as the dashboard. Uses scoped observed points before frontier/best pruning. JSON only.',
-      '返回来源选项、同等服务条件下的百分比对比曲线，以及可选目标值对比；复用仪表板计算逻辑，使用筛选后、前沿和 best 筛选前的实测点。仅支持 JSON。',
+      'Include source options, equal-service percentage curves, an optional target comparison and the same-concurrency diagnostic table (matchedConcurrency), using the same helpers as the dashboard. Uses scoped observed points before frontier/best pruning. JSON only.',
+      '返回来源选项、同等服务条件下的百分比对比曲线、可选目标值对比，以及相同并发下的诊断表（matchedConcurrency）；复用仪表板计算逻辑，使用筛选后、前沿和 best 筛选前的实测点。仅支持 JSON。',
     ),
     schema: { type: 'boolean', default: false },
     example: 'true',
@@ -269,8 +269,20 @@ const parameters: readonly ApiParameter[] = [
     required: false,
     type: 'boolean',
     description: text(
-      'Include validated disaggregated prefill/decode energy shares on one output-token denominator. Uses same-window aggregate J/output ÷ J/input to convert prefill J/input; share denominator is reconstructed prefill + decode energy, not pool-local token counts. Missing/invalid data is omitted. JSON only.',
-      '返回通过验证的分离式 prefill/decode 能耗占比，统一使用 output token 分母。用同窗口总 J/output ÷ J/input 将 prefill J/input 转换为 J/output；占比分母为重建的 prefill + decode 能耗，不使用各池独立的 token 数。缺失或无效数据不返回，仅支持 JSON。',
+      'Include validated disaggregated prefill/decode energy shares on one output-token denominator, plus rolePoints with each pool’s W/GPU and role-local energy. Uses same-window aggregate J/output ÷ J/input to convert prefill J/input; share denominator is reconstructed prefill + decode energy, not pool-local token counts. Missing/invalid data is omitted or null. JSON only.',
+      '返回通过验证的分离式 prefill/decode 能耗占比，统一使用 output token 分母；rolePoints 另含各池的 W/GPU 和按本池 token 计的能耗。用同窗口总 J/output ÷ J/input 将 prefill J/input 转换为 J/output；占比分母为重建的 prefill + decode 能耗，不使用各池独立的 token 数。缺失或无效的数据会被省略或返回 null，仅支持 JSON。',
+    ),
+    schema: { type: 'boolean', default: false },
+    example: 'true',
+  },
+  {
+    name: 'powerFit',
+    location: 'query',
+    required: false,
+    type: 'boolean',
+    description: text(
+      'Include one ordinary least-squares line per source: measured mean W/GPU = P0 + m × output tok/s per allocated GPU (disaggregated output spread over prefill and decode GPUs). P0 is the zero-output intercept, not measured idle power; m is marginal J/output token. Sources with fewer than 3 distinct output rates return observations with fit null. JSON only.',
+      '按数据源分别返回普通最小二乘拟合：实测平均 W/GPU = P0 + m × 每个已分配 GPU 的输出 tok/s（分离式部署的输出量均摊到 prefill 和 decode GPU）。P0 是零输出截距，不是实测空载功耗；m 是每个输出 token 的边际能耗（J）。不同输出速率少于 3 个的数据源返回观测点，fit 为 null。仅支持 JSON。',
     ),
     schema: { type: 'boolean', default: false },
     example: 'true',
@@ -281,8 +293,8 @@ const parameters: readonly ApiParameter[] = [
     required: false,
     type: 'enum',
     description: text(
-      'Response encoding. csv returns one flat row per plotted point; serviceCompare and roleShare panels require JSON and return 400 with CSV.',
-      '响应编码。csv 为每个图表点返回一行平面数据；serviceCompare 和 roleShare 面板仅支持 JSON，与 CSV 同用时返回 400。',
+      'Response encoding. csv returns one flat row per plotted point; serviceCompare, roleShare and powerFit panels require JSON and return 400 with CSV.',
+      '响应编码。csv 为每个图表点返回一行平面数据；serviceCompare、roleShare 和 powerFit 面板仅支持 JSON，与 CSV 同用时返回 400。',
     ),
     schema: { type: 'string', enum: ['json', 'csv'], default: 'json' },
     example: 'csv',
@@ -382,6 +394,30 @@ const comparisonSchema = objectSchema({
   }),
 });
 
+const nullableNumber = (description: string) => ({
+  type: ['number', 'null'] as const,
+  description,
+});
+const matchedValuesSchema = objectSchema({
+  joulesPerOutputToken: { type: ['number', 'null'] },
+  meanWattsPerGpu: { type: ['number', 'null'] },
+  interactivity: { type: ['number', 'null'] },
+});
+const matchedSideSchema = objectSchema(
+  {
+    status: {
+      type: 'string',
+      enum: ['observed', 'missing', 'ambiguous'],
+      description:
+        'observed: one agreeing observation; missing: none at this concurrency; ambiguous: conflicting observations, none chosen.',
+    },
+    values: matchedValuesSchema,
+    point: identitySchema,
+    points: arraySchema(identitySchema),
+  },
+  ['status'],
+);
+
 const responseSchema = objectSchema(
   {
     view: { type: 'string', enum: ['inference'] },
@@ -445,6 +481,70 @@ const responseSchema = objectSchema(
         decodeShare: { ...numberSchema, description: 'Decode percentage of reconstructed total.' },
       }),
     ),
+    matchedConcurrency: objectSchema({
+      baseline: { ...sourceSchema, type: ['object', 'null'] },
+      comparator: { ...sourceSchema, type: ['object', 'null'] },
+      interactivityField: stringSchema,
+      reason: { type: 'string', enum: ['same-source', 'unknown-source'] },
+      rows: arraySchema(
+        objectSchema({
+          concurrency: integerSchema,
+          baseline: matchedSideSchema,
+          comparator: matchedSideSchema,
+          changePercent: {
+            ...matchedValuesSchema,
+            description:
+              '100 × (comparator / baseline − 1); null unless both values were observed.',
+          },
+        }),
+      ),
+    }),
+    rolePoints: arraySchema(
+      objectSchema({
+        x: numberSchema,
+        sourceKey: stringSchema,
+        point: identitySchema,
+        prefillWattsPerGpu: nullableNumber('Mean W/GPU inside the prefill pool.'),
+        decodeWattsPerGpu: nullableNumber('Mean W/GPU inside the decode pool.'),
+        prefillJoulesPerInputToken: nullableNumber('Prefill-pool joules per input token.'),
+        decodeJoulesPerOutputToken: nullableNumber('Decode-pool joules per output token.'),
+        energy: {
+          ...objectSchema({
+            prefill: numberSchema,
+            decode: numberSchema,
+            total: numberSchema,
+            prefillShare: numberSchema,
+          }),
+          type: ['object', 'null'],
+          description: 'Both pools on the output-token denominator (J/output token, share %).',
+        },
+      }),
+    ),
+    powerFits: arraySchema(
+      objectSchema({
+        source: sourceSchema,
+        tdpWatts: nullableNumber('Rated board TDP per GPU; P0 ÷ TDP = fit.intercept / tdpWatts.'),
+        fit: {
+          ...objectSchema({
+            intercept: { ...numberSchema, description: 'P0, W/GPU at zero output (extrapolated).' },
+            slope: { ...numberSchema, description: 'm, J per output token.' },
+            rSquared: { type: ['number', 'null'] },
+            n: integerSchema,
+            xMin: numberSchema,
+            xMax: numberSchema,
+          }),
+          type: ['object', 'null'],
+        },
+        reason: { type: 'string', enum: ['too-few-points'] },
+        observations: arraySchema(
+          objectSchema({
+            x: { ...numberSchema, description: 'Output tok/s per allocated GPU.' },
+            y: { ...numberSchema, description: 'Measured mean W/GPU.' },
+            point: identitySchema,
+          }),
+        ),
+      }),
+    ),
     pricing: { type: ['object', 'null'], additionalProperties: true },
     comparisons: arraySchema({ type: 'object', additionalProperties: true }),
     overlays: arraySchema({ type: 'object', additionalProperties: true }),
@@ -480,6 +580,7 @@ const responseExample = {
     serviceComparator: null,
     serviceTarget: null,
     roleShare: false,
+    powerFit: false,
   },
   metric: {
     key: 'tpPerGpu',
diff --git a/packages/app/src/lib/views-api/docs/options.ts b/packages/app/src/lib/views-api/docs/options.ts
index 86721ff40..6d7b24ec3 100644
--- a/packages/app/src/lib/views-api/docs/options.ts
+++ b/packages/app/src/lib/views-api/docs/options.ts
@@ -188,6 +188,7 @@ const responseExample = {
     xstat: 'median',
     serviceCompare: false,
     roleShare: false,
+    powerFit: false,
   },
 };
 
diff --git a/packages/app/src/lib/views-api/registry.ts b/packages/app/src/lib/views-api/registry.ts
index 4e5d0952b..ef0780fd5 100644
--- a/packages/app/src/lib/views-api/registry.ts
+++ b/packages/app/src/lib/views-api/registry.ts
@@ -173,6 +173,7 @@ export const VIEW_QUERY_PARAMS = {
     'serviceComparator',
     'serviceTarget',
     'roleShare',
+    'powerFit',
   ],
   operatorx: [
     'backend',
diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index cee8532c2..490b5c22c 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -7,7 +7,7 @@
     "references/cli-contract.md": "82e0016e42bc1d06c3ac53b33473a0a56d0df422c6006fc74b5f3a75ac21b8d9",
     "references/cli.md": "580ea3492c3835ccc45298b339fa2a8c6fc457079a547cb04be3432a263752b0",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "8703d877157ecd63fdda4b4596a2b7dd9b089850b4a13748f40589a9d29e0108",
+    "references/dashboard-views.md": "80c375246c6e841f4dbfb1bfe18d8742ba0e515ede6559555c8ee082a25198a1",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/powerx.md": "f04f89ce77590d6898a776f892749722f4f4303e40e7daeeb576cbcff5d098cf",
     "references/provenance.md": "da4e9d078b31f234727706593f77ca9d5fdac611921783aaa09b5741de58b69a",
diff --git a/packages/skills/skills/inferencex-api/references/dashboard-views.md b/packages/skills/skills/inferencex-api/references/dashboard-views.md
index 7dcd10b5c..457407b13 100644
--- a/packages/skills/skills/inferencex-api/references/dashboard-views.md
+++ b/packages/skills/skills/inferencex-api/references/dashboard-views.md
@@ -39,29 +39,29 @@ All paths below are relative to `/api/v1/views/`. The maintained exhaustive
 query-key list is in the app's OpenAPI contract. The following groups explain
 which controls belong together.
 
-| View                            | Selection and calculation                                                                                                                                                                                                                                                                                    |
-| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `options`                       | Static registries and defaults, JSON only. Data-dependent run/config choices come from their own views.                                                                                                                                                                                                      |
-| `inference`                     | Model, sequence, precisions, date/exact run, GPU/vendor/framework/deployment/spec/power filters; metric, xmode, xstat, xmetric, percentile, optimal/best/allPoints; equal-service sources/target and roleShare; TCO, custom costs/powers, pricing, unofficial runs, comparison dates/endpoints. JSON or CSV. |
-| `historical`                    | Model, sequence, target, metric, precisions, GPUs/vendors/frameworks/deployment, start/end, TCO and pricing. `extendToDate` labels synthetic extension, defaults to current UTC date. JSON or CSV.                                                                                                           |
-| `calculator`                    | Model/sequence/run/date, precisions/GPUs, percentile, target/mode, token type, owning/renting cost, TCO, power budget, cost cap, hide-above-limit and public unofficial runs. JSON or CSV.                                                                                                                   |
-| `first-token`                   | Benchmark selection plus 1–8 positive TTFT caps in seconds, minimum interactivity, cost provider and token type. Shared dashboard winner selection.                                                                                                                                                          |
-| `cache-reuse`                   | AgentX selection plus exact `config` from returned configurations. Cache-reuse curves retain official versus unofficial evidence.                                                                                                                                                                            |
-| `profit-estimator`              | AgentX selection, comparison dates/runs, target, utilization, lab revenue share, list/OpenRouter/custom token prices, own/rent/custom chip costs, TCO and provisioned/modeled/compare power. USD/chip-hour.                                                                                                  |
-| `profit-estimator-per-gigawatt` | Same selectors; USD/GW-year basis and owning-cost default.                                                                                                                                                                                                                                                   |
-| `fleet`                         | Model/sequence/precision/GPUs, target/percentile, TCO/token type/cost provider, MW, input/output prices, ramp, cache discount, MTBI, recovery, horizon and metric. JSON or CSV.                                                                                                                              |
-| `evaluation`                    | Model, task, date, precision and GPU selection; public unofficial runs remain separately labeled and independent of the official date cutoff. JSON or CSV.                                                                                                                                                   |
-| `reliability`                   | Rolling range, GPU selection and optional `asOf` date for reproducibility. JSON or CSV.                                                                                                                                                                                                                      |
-| `gpu-specs`                     | Full hardware properties or selected metric ranking; table/radar/bar are renderings of these values. JSON or CSV.                                                                                                                                                                                            |
-| `overview`                      | Models, model/hardware row limits, hardware tier, engine, comparison mode and reference. JSON or CSV.                                                                                                                                                                                                        |
-| `rankings`                      | Ranking kind (model or chip), selected model/scenario and format. Use the exact values in OpenAPI.                                                                                                                                                                                                           |
-| `compare`                       | GPU pairs, model/slug, scenario, tier selection and variant. JSON or CSV.                                                                                                                                                                                                                                    |
-| `operatorx`                     | Exact/default measured run, operator, precision, shape, backend, cluster, status, throughput/latency and zero-based table page.                                                                                                                                                                              |
-| `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                                                                                  |
-| `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                                                                       |
-| `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                                                                    |
-| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first raw-explorer projection; full-record statistics use stored digests. Not a serving-window/role-pool projection. Responses are no-store.           |
-| `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                                                                       |
+| View                            | Selection and calculation                                                                                                                                                                                                                                                                                              |
+| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `options`                       | Static registries and defaults, JSON only. Data-dependent run/config choices come from their own views.                                                                                                                                                                                                                |
+| `inference`                     | Model, sequence, precisions, date/exact run, GPU/vendor/framework/deployment/spec/power filters; metric, xmode, xstat, xmetric, percentile, optimal/best/allPoints; equal-service sources/target, roleShare and powerFit; TCO, custom costs/powers, pricing, unofficial runs, comparison dates/endpoints. JSON or CSV. |
+| `historical`                    | Model, sequence, target, metric, precisions, GPUs/vendors/frameworks/deployment, start/end, TCO and pricing. `extendToDate` labels synthetic extension, defaults to current UTC date. JSON or CSV.                                                                                                                     |
+| `calculator`                    | Model/sequence/run/date, precisions/GPUs, percentile, target/mode, token type, owning/renting cost, TCO, power budget, cost cap, hide-above-limit and public unofficial runs. JSON or CSV.                                                                                                                             |
+| `first-token`                   | Benchmark selection plus 1–8 positive TTFT caps in seconds, minimum interactivity, cost provider and token type. Shared dashboard winner selection.                                                                                                                                                                    |
+| `cache-reuse`                   | AgentX selection plus exact `config` from returned configurations. Cache-reuse curves retain official versus unofficial evidence.                                                                                                                                                                                      |
+| `profit-estimator`              | AgentX selection, comparison dates/runs, target, utilization, lab revenue share, list/OpenRouter/custom token prices, own/rent/custom chip costs, TCO and provisioned/modeled/compare power. USD/chip-hour.                                                                                                            |
+| `profit-estimator-per-gigawatt` | Same selectors; USD/GW-year basis and owning-cost default.                                                                                                                                                                                                                                                             |
+| `fleet`                         | Model/sequence/precision/GPUs, target/percentile, TCO/token type/cost provider, MW, input/output prices, ramp, cache discount, MTBI, recovery, horizon and metric. JSON or CSV.                                                                                                                                        |
+| `evaluation`                    | Model, task, date, precision and GPU selection; public unofficial runs remain separately labeled and independent of the official date cutoff. JSON or CSV.                                                                                                                                                             |
+| `reliability`                   | Rolling range, GPU selection and optional `asOf` date for reproducibility. JSON or CSV.                                                                                                                                                                                                                                |
+| `gpu-specs`                     | Full hardware properties or selected metric ranking; table/radar/bar are renderings of these values. JSON or CSV.                                                                                                                                                                                                      |
+| `overview`                      | Models, model/hardware row limits, hardware tier, engine, comparison mode and reference. JSON or CSV.                                                                                                                                                                                                                  |
+| `rankings`                      | Ranking kind (model or chip), selected model/scenario and format. Use the exact values in OpenAPI.                                                                                                                                                                                                                     |
+| `compare`                       | GPU pairs, model/slug, scenario, tier selection and variant. JSON or CSV.                                                                                                                                                                                                                                              |
+| `operatorx`                     | Exact/default measured run, operator, precision, shape, backend, cluster, status, throughput/latency and zero-based table page.                                                                                                                                                                                        |
+| `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                                                                                            |
+| `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                                                                                 |
+| `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                                                                              |
+| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first raw-explorer projection; full-record statistics use stored digests. Not a serving-window/role-pool projection. Responses are no-store.                     |
+| `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                                                                                 |
 
 ## Interpretation and maintenance
 
@@ -106,11 +106,27 @@ change means lower comparator energy. Preserve bracket endpoint identities,
 `interpolated`, missing reasons and nulls. Never call interpolated points new
 measurements or bridge different runs, recipes, topologies or missing endpoints.
 
+`serviceCompare=true` also returns `matchedConcurrency`: the two selected sources
+paired at each concurrency either observed. Sides are `observed`, `missing`, or
+`ambiguous` (disagreeing duplicates, none chosen); `changePercent` needs both
+observed. It is a same-load diagnostic: speeds usually differ, so never present it
+as an equal-service result.
+
 `roleShare=true` returns validated disaggregated prefill/decode J/output and their
 shares of reconstructed total energy. It converts prefill J/input using the
 same-window aggregate J/output-to-J/input ratio; it does not compare unlike token
-denominators. Missing roles are omitted. Both panels require JSON; enabling
-either with CSV returns 400. Existing CSV remains a plotted-point export.
+denominators. Missing roles are omitted. `rolePoints` adds per-observation role
+W/GPU, role-local J/input and J/output (different denominators, never add them)
+and the output-token reconstruction, with nulls for missing figures.
+
+`powerFit=true` returns `powerFits`: per source, an OLS line of measured mean W/GPU
+against output tok/s per allocated GPU, with `P₀`, slope `m` (J/output token), R²,
+n, x-range, registry `tdpWatts` and point identities. Fewer than three distinct
+rates return `fit: null`, `reason: "too-few-points"`. Call `P₀` an extrapolated
+intercept, not idle power, and do not read the line outside its x-range.
+
+These panels require JSON; enabling any with CSV returns 400. Existing CSV remains
+a plotted-point export.
 
 For exact-load comparisons, use `xmode=concurrency`. The response resolves
 `optimal=false` and `best=false`, retains every eligible observed load, and sets

From d8b3675484b036a6356566c465753650fa68bb0e Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Thu, 24 Sep 2026 15:59:58 -0700
Subject: [PATCH 039/103] docs: document PowerX article panels and timeline
 load filter
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Maps article figures 6–16 to their panels, documents the Timeline load
filter and validated-window summary, and adds powerFit to the views API
key table. State ownership lists i_ptconc.

中文：记录 PowerX 文章面板与 Timeline 负载筛选。将文章图 6–16 对应到各面板，说明
Timeline 负载筛选与有效窗口汇总，在视图 API 参数表中加入 powerFit，并在状态归属
文档中列出 i_ptconc。
---
 docs/dashboard-readonly-views.md | 117 +++++++++++++++++++++----------
 docs/powerx-permanent-view.md    |  71 +++++++++++++++++--
 docs/state-ownership.md          |   2 +-
 3 files changed, 148 insertions(+), 42 deletions(-)

diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index e8fb77f49..fac4e62e2 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -11,29 +11,29 @@ All endpoints are GET under /api/v1/views. Unsupported and repeated keys return
 This table records accepted query names; behavioral tests exercise representative
 combinations, not the full Cartesian product of all possible filter values.
 
-| View                            | Accepted query keys                                                                                                                                                                                                                                                                                                                                                                                                     |
-| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `cache-reuse`                   | `config`, `date`, `gpus`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                                                                                                                         |
-| `calculator`                    | `costProvider`, `costType`, `costcap`, `date`, `format`, `gpus`, `hideSkuAboveConfigLimit`, `mode`, `model`, `mw`, `percentile`, `precisions`, `runId`, `sequence`, `target`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                               |
-| `collectivex`                   | `activeSeries`, `kvSeries`, `swapSeries`, `backend`, `epSize`, `kvOp`, `kvX`, `kvY`, `modes`, `operation`, `overlapIsl`, `pageTokens`, `percentile`, `phase`, `precision`, `runs`, `sku`, `suite`, `swapDirection`, `swapLayout`, `swapMetric`, `swapPercentile`, `version`, `yAxis`                                                                                                                                    |
-| `compare`                       | `format`, `gpus`, `model`, `scenario`, `slug`, `tiers`, `variant`                                                                                                                                                                                                                                                                                                                                                       |
-| `current-inferencex-image`      | `asOf`, `frameworks`, `hardware`, `model`, `nodeType`, `precision`, `sequence`, `spec`                                                                                                                                                                                                                                                                                                                                  |
-| `evaluation`                    | `unofficialrun`, `benchmark`, `date`, `format`, `gpus`, `model`, `precisions`                                                                                                                                                                                                                                                                                                                                           |
-| `first-token`                   | `caps`, `costProvider`, `costType`, `date`, `gpus`, `minInteractivity`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                                                                           |
-| `fleet`                         | `cache`, `costProvider`, `costType`, `format`, `gpus`, `horizon`, `metric`, `model`, `mtbi`, `mw`, `oprice`, `percentile`, `precisions`, `price`, `ramp`, `recovery`, `sequence`, `target`, `tcoBasis`                                                                                                                                                                                                                  |
-| `gpu-metrics`                   | `artifact`, `chartView`, `corrXMetric`, `corrYMetric`, `direction`, `downsample`, `gpus`, `metric`, `runId`, `sort`                                                                                                                                                                                                                                                                                                     |
-| `gpu-specs`                     | `format`, `metric`                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `historical`                    | `deployment`, `end`, `extendToDate`, `format`, `frameworks`, `gpus`, `metric`, `model`, `precisions`, `priceSource`, `sequence`, `start`, `target`, `tcoBasis`, `vendors`                                                                                                                                                                                                                                               |
-| `inference`                     | `allPoints`, `best`, `date`, `dates`, `deployment`, `end`, `format`, `frameworks`, `gpus`, `metric`, `model`, `optimal`, `percentile`, `power`, `precisions`, `priceSource`, `runId`, `sequence`, `spec`, `start`, `tcoBasis`, `topologies`, `unofficialrun`, `userCosts`, `userPowers`, `vendors`, `xmetric`, `xmode`, `xstat`, `serviceCompare`, `serviceBaseline`, `serviceComparator`, `serviceTarget`, `roleShare` |
-| `operatorx`                     | `backend`, `cluster`, `metric`, `operator`, `page`, `precision`, `runId`, `shape`, `status`                                                                                                                                                                                                                                                                                                                             |
-| `options`                       | `format`                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `overview`                      | `compare`, `engine`, `format`, `hwrows`, `models`, `ref`, `rows`, `tier`                                                                                                                                                                                                                                                                                                                                                |
-| `profit-estimator`              | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                                                                                                                                          |
-| `profit-estimator-per-gigawatt` | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                                                                                                                                          |
-| `rankings`                      | `format`, `kind`, `model`, `scenario`                                                                                                                                                                                                                                                                                                                                                                                   |
-| `reliability`                   | `asOf`, `format`, `gpus`, `range`                                                                                                                                                                                                                                                                                                                                                                                       |
-| `submissions`                   | `direction`, `limit`, `lines`, `mode`, `offset`, `onChangeOnly`, `search`, `sort`                                                                                                                                                                                                                                                                                                                                       |
-| `video`                         | `artifact`, `cell`, `compare`, `costs`, `gpuBasis`, `page`, `phase`, `run`, `selected`, `slot`, `source`, `view`, `workload`, `xAxis`, `yAxis`                                                                                                                                                                                                                                                                          |
+| View                            | Accepted query keys                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `cache-reuse`                   | `config`, `date`, `gpus`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                                                                                                                                     |
+| `calculator`                    | `costProvider`, `costType`, `costcap`, `date`, `format`, `gpus`, `hideSkuAboveConfigLimit`, `mode`, `model`, `mw`, `percentile`, `precisions`, `runId`, `sequence`, `target`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                                           |
+| `collectivex`                   | `activeSeries`, `kvSeries`, `swapSeries`, `backend`, `epSize`, `kvOp`, `kvX`, `kvY`, `modes`, `operation`, `overlapIsl`, `pageTokens`, `percentile`, `phase`, `precision`, `runs`, `sku`, `suite`, `swapDirection`, `swapLayout`, `swapMetric`, `swapPercentile`, `version`, `yAxis`                                                                                                                                                |
+| `compare`                       | `format`, `gpus`, `model`, `scenario`, `slug`, `tiers`, `variant`                                                                                                                                                                                                                                                                                                                                                                   |
+| `current-inferencex-image`      | `asOf`, `frameworks`, `hardware`, `model`, `nodeType`, `precision`, `sequence`, `spec`                                                                                                                                                                                                                                                                                                                                              |
+| `evaluation`                    | `unofficialrun`, `benchmark`, `date`, `format`, `gpus`, `model`, `precisions`                                                                                                                                                                                                                                                                                                                                                       |
+| `first-token`                   | `caps`, `costProvider`, `costType`, `date`, `gpus`, `minInteractivity`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                                                                                       |
+| `fleet`                         | `cache`, `costProvider`, `costType`, `format`, `gpus`, `horizon`, `metric`, `model`, `mtbi`, `mw`, `oprice`, `percentile`, `precisions`, `price`, `ramp`, `recovery`, `sequence`, `target`, `tcoBasis`                                                                                                                                                                                                                              |
+| `gpu-metrics`                   | `artifact`, `chartView`, `corrXMetric`, `corrYMetric`, `direction`, `downsample`, `gpus`, `metric`, `runId`, `sort`                                                                                                                                                                                                                                                                                                                 |
+| `gpu-specs`                     | `format`, `metric`                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `historical`                    | `deployment`, `end`, `extendToDate`, `format`, `frameworks`, `gpus`, `metric`, `model`, `precisions`, `priceSource`, `sequence`, `start`, `target`, `tcoBasis`, `vendors`                                                                                                                                                                                                                                                           |
+| `inference`                     | `allPoints`, `best`, `date`, `dates`, `deployment`, `end`, `format`, `frameworks`, `gpus`, `metric`, `model`, `optimal`, `percentile`, `power`, `precisions`, `priceSource`, `runId`, `sequence`, `spec`, `start`, `tcoBasis`, `topologies`, `unofficialrun`, `userCosts`, `userPowers`, `vendors`, `xmetric`, `xmode`, `xstat`, `serviceCompare`, `serviceBaseline`, `serviceComparator`, `serviceTarget`, `roleShare`, `powerFit` |
+| `operatorx`                     | `backend`, `cluster`, `metric`, `operator`, `page`, `precision`, `runId`, `shape`, `status`                                                                                                                                                                                                                                                                                                                                         |
+| `options`                       | `format`                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `overview`                      | `compare`, `engine`, `format`, `hwrows`, `models`, `ref`, `rows`, `tier`                                                                                                                                                                                                                                                                                                                                                            |
+| `profit-estimator`              | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                                                                                                                                                      |
+| `profit-estimator-per-gigawatt` | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                                                                                                                                                      |
+| `rankings`                      | `format`, `kind`, `model`, `scenario`                                                                                                                                                                                                                                                                                                                                                                                               |
+| `reliability`                   | `asOf`, `format`, `gpus`, `range`                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `submissions`                   | `direction`, `limit`, `lines`, `mode`, `offset`, `onChangeOnly`, `search`, `sort`                                                                                                                                                                                                                                                                                                                                                   |
+| `video`                         | `artifact`, `cell`, `compare`, `costs`, `gpuBasis`, `page`, `phase`, `run`, `selected`, `slot`, `source`, `view`, `workload`, `xAxis`, `yAxis`                                                                                                                                                                                                                                                                                      |
 
 ## Source audit and shared computations
 
@@ -74,16 +74,21 @@ benchmark `power_audit` supplies the exact serving-window bounds. The public
 `/api/v1/views/gpu-metrics` projection alone does not return that combined evidence
 and must not be described as a serving-window or role-pool projection.
 
-Timeline share fields `i_ptaxis`, `i_ptlines`, `i_ptwindow`, `i_ptfocus` and
-`i_ptutility` are renderer state, not parameters of the raw explorer API. Window-only
+Timeline share fields `i_ptaxis`, `i_ptlines`, `i_ptwindow`, `i_ptfocus`, `i_ptutility`
+and `i_ptconc` are renderer state, not parameters of the raw explorer API. `i_ptconc`
+keeps the chart's rows at one concurrency, so platforms can be read at one load. Window-only
 display selects retained bucket timestamps within the recorded inclusive bounds;
 serving-relative display uses `(bucket UTC ms - window start UTC ms) / 1000`.
 Missing, nonfinite or non-increasing bounds omit that trace in either mode.
-No boundary samples are interpolated, and no window statistics or energy values
-are recomputed. Per-GPU/mean/role-pool modes reuse the existing device identity and
-pool-sum calculations. Focus only dims other traces and the utility toggle only
-adds registry references. Raw telemetry, full-record statistics and API responses
-are unchanged by all five display settings. The reusable client helpers are
+No boundary samples are interpolated, and no stored window statistics or energy
+values are recomputed. Per-GPU/mean/role-pool modes reuse the existing device identity
+and pool-sum calculations. Focus only dims other traces and the utility toggle only
+adds registry references. The validated-window summary below the chart lists each
+trace's run, attempt, validation file and per-run telemetry source (database, or
+GitHub artifact fallback when any requested series was read live), then per pool the
+row's validated average as stored, the largest drawn pool bucket inside the window,
+and GPUs × registry TDP. Raw telemetry, full-record statistics and API responses
+are unchanged by all six display settings. The reusable client helpers are
 `parsePowerTimelineParams`, `powerTimelineSampleX` and `tracePools` in
 `components/inference/utils/powerTimeline.ts`, and `sumPowerAt` in
 `components/gpu-power/power-series.ts`.
@@ -107,6 +112,15 @@ invented operating point. Streaming-speed targets are tok/s/user; TTFT/E2E targe
 are seconds. Concurrency remains a separate observed-load diagnostic, not an
 equal-service comparison axis.
 
+That diagnostic is `matchedConcurrency`, also returned by `serviceCompare=true`: the
+two selected sources paired at every concurrency either one observed. Each side is
+`observed` (J/output token, mean W/GPU and streaming speed at the selected statistic,
+named by `interactivityField`, plus its point identity), `missing`, or `ambiguous`
+when one source's observations at that load disagree; all are listed and none is
+chosen. `changePercent` is `100 × (comparator / baseline − 1)` only when both sides
+were observed. Same-load pairs usually serve different speeds, so the table sits
+beside the equal-service comparison rather than replacing it.
+
 The dashboard and API share `equal-service-comparison.ts`: both consume scoped
 observed points after chart coverage/limits, before frontier and best-per-SKU
 pruning, with power-comparison clones excluded. `allPoints=true` restores clipped
@@ -126,19 +140,35 @@ not zero. This is an operating-point comparison, not proof of a hardware-only
 causal effect. Official, historical and unofficial source identities remain
 visible.
 
-`roleShare=true` returns `roleEnergyShares` through the same shared role helper.
+`roleShare=true` returns `roleEnergyShares` and `rolePoints` through the same shared
+role helper. Each role point carries prefill and decode mean W/GPU, role-local
+prefill J/input and decode J/output, and the output-token reconstruction below;
+any missing figure is null.
 Validated disaggregated prefill J/input is multiplied by same-window aggregate
 J/output ÷ J/input, then compared with decode J/output. The percentage denominator
 is reconstructed prefill + decode energy on one output-token basis. Missing or
 invalid role measurements are omitted. This view does not mix pool-local token
 denominators or claim the reconstructed sum was independently measured.
 
-These panel results are JSON-only: `format=csv` with either panel enabled returns
+`powerFit=true` returns `powerFits`: per source, an ordinary least-squares line of
+measured mean W/GPU (over all allocated GPUs) against whole-deployment output tok/s
+per allocated GPU. Each fit reports intercept `P₀`, slope `m` (J/output token), R²,
+n and the fitted x-range, plus registry `tdpWatts` and every observation with its
+point identity. Fewer than three distinct output rates return `fit: null` with
+`reason: "too-few-points"`. `P₀` is an extrapolated intercept, not measured idle
+power, and R² is null when power did not vary.
+
+These panel results are JSON-only: `format=csv` with any panel enabled returns
 400, rather than silently exporting only the primary chart. Ordinary CSV retains
 its existing plotted-point contract. Share controls map directly:
 `i_mstat` → `xstat`, `i_servicecompare` → `serviceCompare`, `i_servicebase` →
 `serviceBaseline`, `i_servicepeer` → `serviceComparator`, `i_servicetarget` →
-`serviceTarget`, and `i_roleshare` → `roleShare`.
+`serviceTarget`, `i_roleshare` → `roleShare`, and `i_powerfit` → `powerFit`.
+
+The scatter chart's Frontier points table (shown with `i_frontier` on a measured
+power metric) lists the drawn cross-platform frontier with each point's run and
+attempt, and exports it as CSV. The views API has no global-frontier parameter, so
+that table remains dashboard-only.
 
 ## Verification scope
 
@@ -166,12 +196,27 @@ GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全
 时间线通过现有只读 `/api/gpu-metrics?series=power` 获取逐秒采样、设备角色和验证来源，
 再结合基准测试 `power_audit` 中的服务窗口边界；公开的 `/api/v1/views/gpu-metrics`
 本身不返回这组完整证据，不能称为服务窗口或 GPU 池投影视图。
-五个 `i_pt*` 分享字段只控制显示，不是原始浏览器 API 的参数。窗口模式仅显示已记录
+六个 `i_pt*` 分享字段只控制显示，不是原始浏览器 API 的参数；`i_ptconc` 只保留同一并发数的
+行，便于在同一负载下对照多个平台。窗口模式仅显示已记录
 边界内的采样点（含边界），服务起点模式将 UTC 时间减去窗口起点后换算为秒。
-边界缺失、非有限值或结束不晚于开始时，不绘制对应曲线；不插值补点，也不重算窗口
-统计或能耗。GPU 池模式复用已有设备角色和求和函数；聚焦仅调暗其他曲线，参考线
+边界缺失、非有限值或结束不晚于开始时，不绘制对应曲线；不插值补点，也不重算已存储的
+窗口统计或能耗。图下的有效测量窗口汇总列出每条曲线的运行、尝试次数、验证文件和
+遥测来源（数据库，或有序列需实时读取时的 GitHub 产物回退），并按 GPU 池列出基准测试行
+存储的有效平均值、窗口内所绘曲线的最大值，以及 GPU 数 × 注册表 TDP。GPU 池模式复用已有设备角色和求和函数；聚焦仅调暗其他曲线，参考线
 使用硬件注册表。原始遥测、全记录统计和 API 响应均不因这些显示设置而改变。
 响应使用 private, no-store，上游 503 保留为错误响应。
 
+`serviceCompare=true` 还返回 `matchedConcurrency`：按并发数逐行配对两个所选数据源，任一方在
+该并发数下有观测即列出一行；每侧为 `observed`、`missing`，或同一负载下观测值不一致时的
+`ambiguous`（全部列出、不选其一）；仅当两侧都有观测时才计算变化百分比。同一并发下两者
+的服务速度通常不同，因此该表只作诊断，不替代同等服务对比。`roleShare=true` 另返回
+`rolePoints`（各角色 W/GPU、按本池 token 计的能耗及按输出 token 重建的能耗）。
+`powerFit=true` 返回 `powerFits`：每个数据源以最小二乘法拟合平均 W/GPU 与每个已分配
+GPU 的输出 tok/s，给出 `P₀`、`m`（J/输出 token）、R²、点数、拟合范围和注册表 TDP；
+不同输出速率少于 3 个时不拟合。`P₀` 是外推截距，不是实测空载功耗。这些面板只支持
+JSON；`i_powerfit` 对应 `powerFit`。散点图的前沿点表（`i_frontier` 开启且为实测功耗
+指标时显示）列出跨平台前沿各点的运行和尝试次数，并可导出 CSV；只读 API 没有全局前沿
+参数。
+
 测试覆盖契约同步及代表性的筛选行为，并未穷举所有参数组合。生产数据库上的
 完整 UI/API 对照仍需集成审查，不能仅凭单元测试宣称已完成。
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index bfd24f917..93a6d868c 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -211,8 +211,10 @@ config is `display: 'timeline'`.
 
 - **Fetch.** One request per workflow run in the visible points
   (`planPowerTimelineRequests`, at most `POWER_TIMELINE_MAX_RUNS`; a deep-linked trace's run
-  goes first, then `?unofficialrun=` overlay runs, then official runs — `prioritizeRun` /
-  `prioritizeRuns` — so an overlay the user asked for is never the run that gets dropped),
+  goes first, then runs holding a point the legend shows (`?unofficialrun=` overlay runs before
+  official ones), then runs whose points are all hidden — `prioritizeRun` / `prioritizeRuns` — so
+  an overlay the user asked for, or a pair left visible for comparison, is never the run that gets
+  dropped),
   narrowed with
   `prefix=` to the common RESULT_FILENAME prefix so a nightly sweep's other models are not
   downloaded. `/api/gpu-metrics?series=power` first uses persisted telemetry and returns one-second per-GPU buckets
@@ -240,7 +242,8 @@ config is `display: 'timeline'`.
   the all-in provisioned line is an opt-in legend switch because it halves the traces'
   vertical resolution. X axis: wall clock (UTC) when the visible traces come from one run,
   otherwise seconds since each trace's start; both are a toolbar toggle. `c<conc>` labels sit
-  at the end of the emphasized segment.
+  at the end of the emphasized segment; labels that would overprint stack one row apart
+  (`stackTraceLabels`).
 - **Pools (Figure 1).** The legend switch _Prefill / decode pools_ (shown when a visible
   trace carries worker roles) sums the board power of each role's GPUs
   (`tracePools` / `sumPowerAt`) and draws one line per pool — prefill dashed `7 3`, decode
@@ -263,9 +266,20 @@ config is `display: 'timeline'`.
   the current page with `i_metric=y_measuredPowerTimeline` only, so open-in-new-tab lands on
   the unfocused timeline; once the focus is applied it is written to `i_ptfocus` like the other
   timeline settings.
+- **Same load across platforms.** The toolbar _Concurrency_ select (`i_ptconc`, default all)
+  keeps the chart's rows at one load, so, for example, GB200 and GB300 prefill/decode pools draw
+  side by side; `i_ptaxis=serving` aligns them at each validated window's start. With two or
+  more hardware types visible, every line label leads with the hardware label. A deep link
+  resets the filter so the focused trace is never filtered out.
+- **Validated-window summary.** `ui/PowerTimelineSummary.tsx` lists each drawn trace's
+  hardware and config, run link, attempt, validation file, per-run telemetry source
+  (`database`, or `GitHub artifact fallback` when `/api/gpu-metrics` read any requested series
+  live) and window length. Per pool (all GPUs, prefill, decode) it shows the GPU count, the
+  row's validated average W/GPU as stored, the largest drawn 1-s pool sum inside the window
+  (`summarizeTraceWindow`) and pool TDP = GPUs × `HW_REGISTRY.tdp`. No average is recomputed.
 - **State.** Axis mode (`i_ptaxis`), line mode (`i_ptlines`: mean / `gpu` / `pool`), window-only
-  display (`i_ptwindow`), the focused trace (`i_ptfocus`) and the all-in switch (`i_ptutility`)
-  are `PowerTimeline` component state mirrored into the URL by the component itself
+  display (`i_ptwindow`), the focused trace (`i_ptfocus`), the all-in switch (`i_ptutility`) and
+  the concurrency filter (`i_ptconc`) are `PowerTimeline` component state mirrored into the URL by the component itself
   (`parsePowerTimelineParams` on mount, `setUrlParams` on change); defaults serialize as `''`.
   Hover highlight is never shared. See
   [Dashboard read-only views](./dashboard-readonly-views.md) for the renderer-only status of
@@ -274,9 +288,47 @@ config is `display: 'timeline'`.
   `inference_power_timeline_axis_changed { mode }`,
   `inference_power_timeline_lines_changed { lines: 'mean' | 'gpu' | 'pool' }`,
   `inference_power_timeline_utility_toggled { enabled }`,
+  `inference_power_timeline_concurrency_changed { concurrency }`,
   `inference_power_trace_opened { hwKey, conc, overlay }` (scatter tooltip action),
   `inference_power_timeline_focus_cleared`.
 
+## Analysis panels (article figures 6–16)
+
+Figure numbers here follow the current article draft; the share-link table above predates its
+renumbering. Below the measured chart, `ui/PowerServiceComparison.tsx` offers three opt-in
+panels, and the scatter chart adds a fourth. All read the chart's scoped observed points
+(`observedPoints`: official and `?unofficialrun=` rows, comparison clones excluded), keep one
+source per exact run and recipe (`equalServiceSourceKey`), and colour overlay sources with
+`overlayRunColor`.
+
+| Figures      | Panel                                                                                                                                         | Switch (share param)                                                                                    | Helper                                                 |
+| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
+| 6 / 7 / 9    | Same-concurrency table: baseline and comparator J/output token, W/GPU and streaming speed, with % change                                      | _Compare at the same speed / latency_ (`i_servicecompare=1`, sources `i_servicebase` / `i_servicepeer`) | `utils/matched-concurrency.ts`                         |
+| 12 / 13 / 14 | Role group: W/GPU by role, role-local J/input and J/output (not added), J/output token by role with the total, prefill share                  | _Prefill / decode roles_ (`i_roleshare=1`)                                                              | `getRolePoints` in `utils/equal-service-comparison.ts` |
+| 15           | Least-squares fit of mean W/GPU against output tok/s per allocated GPU: points, line, dashed extension to zero, P₀, P₀ ÷ TDP, m, R², n, range | _Power vs output-rate fit_ (`i_powerfit=1`)                                                             | `utils/power-fit.ts`                                   |
+| 16           | Frontier points: the drawn cross-platform frontier, its competing scope, points per hardware, and each point's run and attempt                | Legend _Pareto frontier_ (`i_frontier`) on a measured metric                                            | `utils/frontier-points.ts`                             |
+
+- **Same concurrency** pairs only observations; nothing is interpolated. A side missing at a
+  load reads _Not measured_. Disagreeing duplicates of one source read as ambiguous, with none
+  chosen. % change needs both sides. Same load usually means different speed, so the table
+  sits beside the equal-service comparison, not in place of it.
+- **Roles** use validated disaggregated rows. Each panel names its denominator. Missing role
+  telemetry is omitted, never drawn as zero, and share points stay unconnected.
+- **Fit** needs three distinct output rates per source. Output is whole-deployment tok/s over
+  all allocated GPUs, on the same basis as the mean W/GPU. P₀ is an extrapolated intercept,
+  not measured idle power, and R² describes only that line.
+- **Frontier** lists `globalParetoFrontier`'s own output, so the table is exactly what is
+  drawn. Ties keep the first point, official before overlay. It notes when the competing
+  points span several topologies or images.
+- Plots export PNG and CSV; the frontier table exports CSV only. The views API returns
+  `matchedConcurrency`, `rolePoints` and `powerFits`
+  ([Dashboard read-only views](./dashboard-readonly-views.md#fixed-sequence-service-comparisons));
+  it has no global-frontier parameter.
+- Analytics: `inference_equal_service_toggled`, `inference_power_roles_toggled` and
+  `inference_power_fit_toggled` (`{ enabled }`), `inference_equal_service_source_changed
+{ role }`, and chart-button events under `matched_concurrency`, `power_roles`, `power_fit`
+  and `frontier_points`.
+
 ## Tests
 
 - `metric-registry.test.ts` — the six keys are in the gated group, resolve as themselves, are
@@ -303,6 +355,15 @@ config is `display: 'timeline'`.
 - `cypress/component/power-timeline.cy.tsx` — traces, emphasized window, TDP / all-in
   references, per-GPU lines, pool lines with per-pool TDP, the focus chip, axis toggle,
   overlay-run colour and filter, failed run, `/zh`.
+- `utils/matched-concurrency.test.ts`, `utils/power-fit.test.ts`, `utils/frontier-points.test.ts`,
+  `utils/equal-service-comparison.test.ts` — same-load pairing (missing, ambiguous, change),
+  least-squares fits and too-few-point sources, frontier scope and export rows, role points.
+- `cypress/component/power-service-comparison.cy.tsx`, `frontier-points-panel.cy.tsx` — the four
+  analysis panels, CSV exports, overlay colours, `/zh`, mobile width.
+- `cypress/component/power-timeline.cy.tsx` (same-load block) — concurrency filter, hardware
+  labels, the validated-window summary, overlay rows, `/zh`, mobile width.
+- `cypress/e2e/powerx-compare.cy.ts` (article panels) — share params, overlay rows, `/zh`.
+- `api/v1/views/inference/route.test.ts` — `matchedConcurrency`, `rolePoints`, `powerFits`, CSV 400.
 - `cypress/e2e/powerx-timeline.cy.ts` — Display → Timeline round trip through the share link,
   shared-link entry, Table view on the alias, `?unofficialrun=` overlay traces, _View power
   trace_ from a pinned tooltip (official and overlay), `/zh`.
diff --git a/docs/state-ownership.md b/docs/state-ownership.md
index c5fac4f21..d6b1d39c5 100644
--- a/docs/state-ownership.md
+++ b/docs/state-ownership.md
@@ -114,7 +114,7 @@ Axis and presentation state:
 
 - selected x-axis and y-axis metrics, percentile, and effective x-axis mode
 - the Measured controls (Boundary / Per / Scope / Statistic / Display / Unit) own no state: `measured-metric-config.ts` resolves each selection to the nearest registered metric key and writes it back to `selectedYAxisMetric`, so the power boundary rides on `i_metric` (there is deliberately no `i_pbasis`; see [PowerX Permanent View](./powerx-permanent-view.md))
-- the Measured Power Display value `timeline` (`y_measuredPowerTimeline`) swaps the chart body for `PowerTimeline`; its axis mode, line mode, window-only display, focused trace and all-in reference switch are component state that `PowerTimeline` itself reads and writes through `useUrlState` as `i_ptaxis` / `i_ptlines` / `i_ptwindow` / `i_ptfocus` / `i_ptutility`, so they never pass through the display domain
+- the Measured Power Display value `timeline` (`y_measuredPowerTimeline`) swaps the chart body for `PowerTimeline`; its axis mode, line mode, window-only display, focused trace, all-in reference switch and concurrency filter are component state that `PowerTimeline` itself reads and writes through `useUrlState` as `i_ptaxis` / `i_ptlines` / `i_ptwindow` / `i_ptfocus` / `i_ptutility` / `i_ptconc`, so they never pass through the display domain
 - token-revenue price source (`i_revenue`): normalized uncached/cached/output pricing or the selected model's live OpenRouter catalog prices
 - scale, optimal-point, label, contrast, legend, and overlay controls
 

From 1672075506e8926c84f56668c11384f7d0187c1e Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Thu, 24 Sep 2026 16:21:06 -0700
Subject: [PATCH 040/103] fix: localize PowerX comparison source labels
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Source labels in the baseline/comparator selects, role group and power
fit used English topology, attempt and recipe words on /zh. They now
follow the page locale; the read-only API keeps English.

中文：修复 PowerX 对比面板来源标签未本地化的问题。基准/对比来源下拉框、角色组和
功耗拟合中的拓扑、尝试次数与配方字样在 /zh 页面仍为英文，现在随页面语言显示；
只读 API 仍保持英文。
---
 .../component/power-service-comparison.cy.tsx | 19 +++++++++++++++++-
 .../components/inference/ui/PowerFitPanel.tsx |  2 +-
 .../inference/ui/PowerServiceComparison.tsx   |  2 +-
 .../utils/equal-service-comparison.test.ts    | 15 ++++++++++++++
 .../utils/equal-service-comparison.ts         | 20 ++++++++++++++-----
 .../components/inference/utils/power-fit.ts   |  7 +++++--
 packages/app/src/lib/api-route-catalog.ts     |  4 ++--
 7 files changed, 57 insertions(+), 12 deletions(-)

diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
index d35f695ae..e2c85fa31 100644
--- a/packages/app/cypress/component/power-service-comparison.cy.tsx
+++ b/packages/app/cypress/component/power-service-comparison.cy.tsx
@@ -105,9 +105,10 @@ function mountComparison(
   points = data,
   xField: keyof AggDataEntry = 'mean_tpot_intvty',
   overlay: InferenceData[] = [],
+  pathname = '/inference',
 ) {
   mountWithProviders(
-    <PathnameContext.Provider value="/inference">
+    <PathnameContext.Provider value={pathname}>
       <div style={{ width: '100%', maxWidth: 1120, padding: 12, boxSizing: 'border-box' }}>
         <PowerServiceComparison
           data={[...points, ...overlay]}
@@ -453,6 +454,22 @@ describe('PowerServiceComparison', () => {
     cy.get('[data-testid="power-fit-panel"]').screenshot('power-fit-desktop', { overwrite: true });
   });
 
+  it('labels sources in Chinese on /zh pages', () => {
+    cy.viewport(1280, 1000);
+    mountComparison([...fitLadder, ...comparator], 'mean_tpot_intvty', [], '/zh/inference');
+    cy.get('[data-testid="equal-service-toggle"]').check();
+    cy.get('[data-testid="power-fit-toggle"]').check();
+    cy.get('[data-testid="equal-service-baseline"] option')
+      .should('have.length', 2)
+      .each(($option) => {
+        expect($option.text()).to.include('单节点');
+        expect($option.text()).not.to.include('Single-node');
+      });
+    cy.get('[data-testid="power-fit-row"] th').each(($cell) =>
+      expect($cell.text()).to.include('单节点'),
+    );
+  });
+
   it('colours ?unofficialrun= sources with their run colour in every panel', () => {
     mountComparison([...fitLadder], 'mean_tpot_intvty', comparator);
     cy.get('[data-testid="power-fit-toggle"]').check();
diff --git a/packages/app/src/components/inference/ui/PowerFitPanel.tsx b/packages/app/src/components/inference/ui/PowerFitPanel.tsx
index 92071faa5..470265074 100644
--- a/packages/app/src/components/inference/ui/PowerFitPanel.tsx
+++ b/packages/app/src/components/inference/ui/PowerFitPanel.tsx
@@ -75,7 +75,7 @@ export default function PowerFitPanel({
 }) {
   const locale = useLocale();
   const t = STRINGS[locale];
-  const fits = useMemo(() => buildPowerFits(data), [data]);
+  const fits = useMemo(() => buildPowerFits(data, locale), [data, locale]);
   const sectionId = `${chartId}-power-fit`;
 
   const markers: PanelMarker[] = fits.flatMap(({ source, observations }) =>
diff --git a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
index 1363ef643..15ba274cc 100644
--- a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
+++ b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
@@ -167,7 +167,7 @@ export default function PowerServiceComparison({
   const [baseline, setBaseline] = useState(() => getUrlParam('i_servicebase') ?? '');
   const [comparator, setComparator] = useState(() => getUrlParam('i_servicepeer') ?? '');
   const [target, setTarget] = useState(() => getUrlParam('i_servicetarget') ?? '');
-  const sources = useMemo(() => getEqualServiceSources(data), [data]);
+  const sources = useMemo(() => getEqualServiceSources(data, locale), [data, locale]);
   const base = baseline || sources[0]?.key || '';
   const peer = comparator || sources[1]?.key || '';
   const previousAxis = useRef(xField);
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
index c3273782b..376b09e2d 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
@@ -194,6 +194,21 @@ describe('equal-service comparison', () => {
     expect(getEqualServiceSources([...b, ...a])).toEqual(getEqualServiceSources([...a, ...b]));
   });
 
+  it('labels sources in the page locale and keeps English for the API default', () => {
+    const labelled = {
+      ...point({ id: 1, recipe_fingerprint: 'r1', run_url: undefined }),
+      run_attempt: 2,
+    };
+    const [zh] = getEqualServiceSources([labelled], 'zh');
+    for (const part of ['单节点', '数据点 1', '第 2 次尝试', '配方 r1'])
+      expect(zh.label).toContain(part);
+    expect(zh.label).not.toMatch(/Single-node|Point|Attempt|Recipe/u);
+    const [en] = getEqualServiceSources([labelled]);
+    for (const part of ['Single-node', 'Point 1', 'Attempt 2', 'Recipe r1'])
+      expect(en.label).toContain(part);
+    expect(en.key).toBe(zh.key);
+  });
+
   it('keeps source keys stable across UI display-date overrides and uses the requested mean basis', () => {
     expect(equalServiceSourceKey({ ...a[0], date: '2026-09-24', actualDate: a[0].date })).toBe(
       equalServiceSourceKey(a[0]),
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.ts b/packages/app/src/components/inference/utils/equal-service-comparison.ts
index 3bcadea34..0ef533672 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.ts
@@ -84,7 +84,17 @@ export function equalServiceSourceKey(point: InferenceData): string {
   ]);
 }
 
-export function getEqualServiceSources(points: readonly InferenceData[]): EqualServiceSource[] {
+const SOURCE_LABEL_WORDS = {
+  en: { point: 'Point', attempt: (attempt: unknown) => `Attempt ${attempt}`, recipe: 'Recipe' },
+  zh: { point: '数据点', attempt: (attempt: unknown) => `第 ${attempt} 次尝试`, recipe: '配方' },
+};
+
+/** Labels are English by default: the read-only API has no locale. */
+export function getEqualServiceSources(
+  points: readonly InferenceData[],
+  locale: 'en' | 'zh' = 'en',
+): EqualServiceSource[] {
+  const words = SOURCE_LABEL_WORDS[locale];
   const sources = new Map(
     observedPoints(points).map((point) => [equalServiceSourceKey(point), point]),
   );
@@ -96,11 +106,11 @@ export function getEqualServiceSources(points: readonly InferenceData[]): EqualS
       label: [
         point.hwKey,
         point.precision.toUpperCase(),
-        topologyLabel(pointTopologyKey(point), 'en', topologies),
+        topologyLabel(pointTopologyKey(point), locale, topologies),
         point.actualDate ?? point.date,
-        point.run_url ?? `Point ${point.id ?? '?'}`,
-        'run_attempt' in point ? `Attempt ${point.run_attempt}` : null,
-        point.recipe_fingerprint ? `Recipe ${point.recipe_fingerprint}` : null,
+        point.run_url ?? `${words.point} ${point.id ?? '?'}`,
+        'run_attempt' in point ? words.attempt(point.run_attempt) : null,
+        point.recipe_fingerprint ? `${words.recipe} ${point.recipe_fingerprint}` : null,
         point.image ?? null,
       ]
         .filter(Boolean)
diff --git a/packages/app/src/components/inference/utils/power-fit.ts b/packages/app/src/components/inference/utils/power-fit.ts
index 09fb2f262..80877c0ba 100644
--- a/packages/app/src/components/inference/utils/power-fit.ts
+++ b/packages/app/src/components/inference/utils/power-fit.ts
@@ -95,9 +95,12 @@ export interface PowerFit {
 }
 
 /** One fit per equal-service source that has any measured observation. */
-export function buildPowerFits(points: readonly InferenceData[]): PowerFit[] {
+export function buildPowerFits(
+  points: readonly InferenceData[],
+  locale: 'en' | 'zh' = 'en',
+): PowerFit[] {
   const rows = observedPoints(points);
-  return getEqualServiceSources(points).flatMap((source): PowerFit[] => {
+  return getEqualServiceSources(points, locale).flatMap((source): PowerFit[] => {
     const observations = rows
       .filter((point) => equalServiceSourceKey(point) === source.key)
       .flatMap((point) => {
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 051c4324b..4c17db4bf 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -814,7 +814,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/inference/utils/equal-service-comparison.ts',
-    sourceSha256: 'adbc79b5fe8d14d8e16cc6edd757324447f12cf0656631ec9b16415e5e0795e2',
+    sourceSha256: '8611179bb7230362e9aebd79b71d1f8240d8f8e69669ac9fd83c6f2a3e35caf0',
     reviewArea: {
       en: 'Source-scoped equal-service interpolation, comparator-relative changes, endpoint provenance, prefill share projection and role points.',
       zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源、prefill 占比视图以及各角色数据点。',
@@ -830,7 +830,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/inference/utils/power-fit.ts',
-    sourceSha256: '6c39a91e0745cd6432730f7d9094638fe1365c1e6d38a99c696c21359409bafb',
+    sourceSha256: 'a1e30d09648b74897e283b67a4e63e2591a485ed0f92e00acbe606b75967444a',
     reviewArea: {
       en: 'Per-source least-squares power fit on output per allocated GPU: intercept, marginal J/token, R², fitted range and registry TDP.',
       zh: '按来源对每个已分配 GPU 的输出做最小二乘功耗拟合：截距、边际 J/token、R²、拟合范围与注册表 TDP。',

From 10dcb1b718a17633a86a3992399de6bc396680a7 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Thu, 24 Sep 2026 16:21:55 -0700
Subject: [PATCH 041/103] test: pin concurrency view loads outside latency and
 cost limits
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

xmode=concurrency keeps loads without end-to-end latency and loads above
the chart cost limit, which e2e mode clips.

中文：新增测试，确认 xmode=concurrency 保留缺少端到端延迟的负载以及超出图表成本
上限的负载，而 e2e 模式会裁剪后者。
---
 packages/app/src/lib/views-api/series.test.ts | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/packages/app/src/lib/views-api/series.test.ts b/packages/app/src/lib/views-api/series.test.ts
index 4df0c2b2f..ba8eb43c7 100644
--- a/packages/app/src/lib/views-api/series.test.ts
+++ b/packages/app/src/lib/views-api/series.test.ts
@@ -115,6 +115,11 @@ function powerSweepRows(): BenchmarkRow[] {
   );
 }
 
+/** Concurrency of every returned point, in series order. */
+function seriesLoads(result: ReturnType<typeof buildInferenceSeries>): number[] {
+  return result.series.flatMap((series) => series.points).map((point) => point.concurrency);
+}
+
 describe('buildInferenceSeries', () => {
   it.each([
     ['interactivity', 'mean_tpot_intvty', 20],
@@ -339,6 +344,23 @@ describe('buildInferenceSeries', () => {
     },
   );
 
+  it('keeps concurrency loads that lack end-to-end latency or exceed the cost limit', () => {
+    const withoutE2e = Object.fromEntries(
+      Object.entries(metrics()).filter(([key]) => !key.endsWith('_e2el')),
+    );
+    const rows = [
+      makeRow({ conc: 1, metrics: metrics({ tput_per_gpu: 0.5, output_tput_per_gpu: 0.4 }) }),
+      makeRow({ conc: 4, metrics: withoutE2e }),
+      makeRow({ conc: 16 }),
+    ];
+    const options = { ...BASE_OPTIONS, metricConfigKey: 'y_costh' } as const;
+
+    expect(seriesLoads(buildInferenceSeries(rows, { ...options, xmode: 'e2e' }))).not.toContain(1);
+    expect(seriesLoads(buildInferenceSeries(rows, { ...options, xmode: 'concurrency' }))).toEqual([
+      1, 4, 16,
+    ]);
+  });
+
   it('exports reusable topology keys and preserves every load within the chosen topology', () => {
     const rows = [
       makeRow({ conc: 1 }),

From 2ee539e728bd687c45b05de2645f69b83b684a9f Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 03:34:20 -0700
Subject: [PATCH 042/103] test: remove redundant PowerX tests and local DB
 harness
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Keep 76 cases that pin published numbers, ingest/DB consistency, API
status contracts, or the required ?unofficialrun= overlay path. Drop the
other 499 audited cases, the local PostgreSQL acceptance harness, its
fixtures and the test:e2e:powerx script.

中文：删除冗余的 PowerX 测试和本地数据库验收框架。保留 76 个用例，覆盖发布数值、ingest/DB 一致性、API 状态契约以及必需的 ?unofficialrun= overlay 路径；删除其余 499 个审计用例、本地 PostgreSQL 验收框架及其 fixture，以及 test:e2e:powerx 脚本。
---
 docs/fixtures/powerx-reingest/README.md       |   41 +-
 docs/fixtures/powerx-reingest/provenance.json |   31 -
 docs/powerx-permanent-view.md                 |   41 +-
 docs/powerx-persistence-recovery.md           |   12 -
 packages/app/cypress.powerx-db.config.ts      |   57 -
 .../cypress/component/gpu-metrics-axis.cy.tsx |  158 ---
 .../cypress/component/gpu-stats-table.cy.tsx  |  156 ---
 .../inference-table-power-compare.cy.tsx      |   68 -
 .../component/measured-metric-controls.cy.tsx |   38 -
 .../cypress/component/power-compare.cy.tsx    |  720 +---------
 .../power-metric-availability.cy.tsx          |  154 ---
 .../cypress/component/power-timeline.cy.tsx   |  724 +---------
 .../cypress/component/scatter-graph.cy.tsx    |  327 -----
 .../e2e/gpu-compare-agentic-detail.cy.ts      |   35 -
 packages/app/cypress/e2e/gpu-power.cy.ts      |   52 -
 .../cypress/e2e/measured-power-overlay.cy.ts  |   30 -
 packages/app/cypress/e2e/powerx-basis.cy.ts   |  342 -----
 packages/app/cypress/e2e/powerx-compare.cy.ts |  301 -----
 .../app/cypress/e2e/powerx-timeline.cy.ts     |  462 -------
 packages/app/cypress/e2e/url-params.cy.ts     |  124 --
 .../app/cypress/powerx-db/telemetry.cy.ts     |  300 -----
 packages/app/cypress/support/share-link.ts    |   27 -
 packages/app/package.json                     |    1 -
 packages/app/scripts/powerx-db-acceptance.ts  |  184 ---
 packages/app/scripts/powerx-db-fixture.ts     |  256 ----
 .../app/api/gpu-metrics/route.context.test.ts |  255 +---
 .../app/api/gpu-metrics/route.sources.test.ts |  242 +---
 .../app/src/app/api/gpu-metrics/route.test.ts |  744 +---------
 .../api/v1/gpu-metrics-point/route.test.ts    |   50 -
 .../api/v1/views/gpu-metrics/route.test.ts    |   62 -
 .../calculator/profit-power.test.ts           |   41 -
 .../gpu-power/power-audit-bundle.test.ts      |  102 --
 .../components/gpu-power/power-series.test.ts |   69 -
 .../gpu-power/stored-gpu-stats.test.ts        |   69 -
 .../gpu-power/telemetry-smoothing.test.ts     |  171 +--
 .../src/components/gpu-power/types.test.ts    |   90 --
 .../agentic-point/overlay-sources.test.ts     |   61 -
 .../power-telemetry-view.test.ts              |   26 -
 .../agentic-point/use-detail-view.test.tsx    |   22 -
 .../inference/measured-metric-config.test.ts  |  128 --
 .../measured-power-direction.test.ts          |   63 -
 .../inference/metric-registry.test.ts         |   43 -
 .../inference/perf-ruler-store.test.ts        |  246 ----
 .../inference/ui/line-label-layer.test.ts     |  111 --
 .../ui/line-label-visibility.test.ts          |   38 -
 .../inference/utils/point-identity.test.ts    |   30 +-
 .../inference/utils/power-compare.test.ts     |  293 ----
 .../inference/utils/powerCurves.test.ts       |   56 +-
 .../inference/utils/powerTimeline.test.ts     |  397 +-----
 .../inference/utils/role-energy.test.ts       |   15 -
 .../utils/tooltip-utils.power-trace.test.ts   |  141 --
 packages/app/src/lib/chart-utils.test.ts      |   93 --
 .../app/src/lib/csv-export-helpers.test.ts    |   31 -
 .../app/src/lib/d3-chart/layers/lines.test.ts |   23 -
 .../lib/d3-chart/layers/perf-ruler.test.ts    |   98 --
 packages/app/src/lib/github-artifacts.test.ts |   23 -
 packages/app/src/lib/inference-labels.test.ts |   35 -
 packages/app/src/lib/power-basis.test.ts      |  373 +----
 packages/app/src/lib/url-state.test.ts        |   88 --
 packages/app/timings.json                     |   12 -
 packages/db/src/backfill-gpu-metrics.test.ts  | 1200 -----------------
 .../required-power-agentic-matrix.json        |   50 -
 .../db/src/etl/gpu-metrics-artifacts.test.ts  |  177 ---
 packages/db/src/etl/gpu-metrics-csv.test.ts   |   61 +-
 .../db/src/etl/gpu-metrics-ingest.test.ts     |  385 +-----
 .../src/etl/multinode-power-samples.test.ts   |   85 --
 .../db/src/etl/power-audit-recovery.test.ts   |   73 +-
 .../src/etl/power-audit-validations.test.ts   |  186 +--
 packages/db/src/etl/power-publication.test.ts |   28 -
 .../src/etl/required-power-curve-db.test.ts   |   44 -
 .../db/src/etl/required-power-curve.test.ts   |   22 +-
 .../etl/required-power-publication.test.ts    |  140 +-
 packages/db/src/etl/skip-tracker.test.ts      |   20 -
 packages/db/src/etl/telemetry-receipt.test.ts |  820 +----------
 packages/db/src/ingest-ci-run.test.ts         |   17 +-
 packages/db/src/ingest-ci-telemetry.test.ts   |  219 ---
 packages/db/src/lib/artifact-retry.test.ts    |   20 +-
 .../lib/backfill-benchmark-refresh.test.ts    |  306 -----
 .../src/lib/benchmark-result-lookup.test.ts   |  130 +-
 packages/db/src/lib/github-artifacts.test.ts  |   50 +-
 .../db/src/lib/gpu-metrics-backfill.test.ts   |  179 +--
 packages/db/src/lib/telemetry-purge.test.ts   |  160 ---
 packages/db/src/prepare-ci-artifacts.test.ts  |  107 --
 .../src/queries/gpu-metrics-timeline.test.ts  |  112 --
 .../gpu-metrics.reingest-consistency.test.ts  |   83 +-
 packages/db/src/queries/gpu-metrics.test.ts   |   43 +-
 86 files changed, 175 insertions(+), 13524 deletions(-)
 delete mode 100644 docs/fixtures/powerx-reingest/provenance.json
 delete mode 100644 packages/app/cypress.powerx-db.config.ts
 delete mode 100644 packages/app/cypress/component/gpu-metrics-axis.cy.tsx
 delete mode 100644 packages/app/cypress/component/gpu-stats-table.cy.tsx
 delete mode 100644 packages/app/cypress/component/inference-table-power-compare.cy.tsx
 delete mode 100644 packages/app/cypress/component/measured-metric-controls.cy.tsx
 delete mode 100644 packages/app/cypress/e2e/powerx-basis.cy.ts
 delete mode 100644 packages/app/cypress/e2e/powerx-compare.cy.ts
 delete mode 100644 packages/app/cypress/e2e/powerx-timeline.cy.ts
 delete mode 100644 packages/app/cypress/powerx-db/telemetry.cy.ts
 delete mode 100644 packages/app/cypress/support/share-link.ts
 delete mode 100644 packages/app/scripts/powerx-db-acceptance.ts
 delete mode 100644 packages/app/scripts/powerx-db-fixture.ts
 delete mode 100644 packages/app/src/components/inference/agentic-point/overlay-sources.test.ts
 delete mode 100644 packages/app/src/components/inference/agentic-point/power-telemetry-view.test.ts
 delete mode 100644 packages/app/src/components/inference/perf-ruler-store.test.ts
 delete mode 100644 packages/app/src/components/inference/utils/power-compare.test.ts
 delete mode 100644 packages/db/src/backfill-gpu-metrics.test.ts
 delete mode 100644 packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json
 delete mode 100644 packages/db/src/etl/gpu-metrics-artifacts.test.ts
 delete mode 100644 packages/db/src/etl/multinode-power-samples.test.ts
 delete mode 100644 packages/db/src/ingest-ci-telemetry.test.ts
 delete mode 100644 packages/db/src/lib/backfill-benchmark-refresh.test.ts
 delete mode 100644 packages/db/src/lib/telemetry-purge.test.ts
 delete mode 100644 packages/db/src/prepare-ci-artifacts.test.ts

diff --git a/docs/fixtures/powerx-reingest/README.md b/docs/fixtures/powerx-reingest/README.md
index f22777fe1..6df4caba2 100644
--- a/docs/fixtures/powerx-reingest/README.md
+++ b/docs/fixtures/powerx-reingest/README.md
@@ -2,16 +2,13 @@
 
 `nvidia.csv` contains unchanged readings from the public InferenceX B200/Qwen3.5
 run [34175132645, attempt 1](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645/attempts/1).
-`provenance.json` records the original artifact name, full-file SHA-256, physical
-line ranges and derived-file SHA-256. Tests read these committed bytes; no artifact
-download is required.
+Tests read these committed bytes; no artifact download is required.
 
 Retain original line 1 and lines 2898–2921, joined with LF and a final LF: three
 consecutive samples of all eight GPUs, 24 rows / 1,901 bytes. Headers, units,
 timestamps and values are unchanged. The CSV contains no hostnames or UUIDs, so
 no identity anonymization was needed. The original collector version and timezone
-are unknown. The file hash identifies the source bytes independently of those
-unknowns.
+are unknown.
 
 The UTC context, collector labels, identity sidecars, local benchmark rows and
 repair offsets used by tests are **constructed test inputs**. They do not describe
@@ -25,35 +22,13 @@ Fixed checks come directly from the retained rows: GPU 0 has
 `351.4033333333333 W`. Production parsers/statistics functions must not generate
 test expectations.
 
-Run the recovery checks from the repository root after the lockfile dependencies,
-Cypress binary and PostgreSQL 17 tools are installed:
+Run the recovery check from `packages/app`:
 
 ```sh
-bun run --cwd packages/db test:unit src/etl/gpu-metrics-ingest.test.ts --maxWorkers=2
-(cd packages/app && bun node_modules/vitest/vitest.mjs run src/app/api/v1/gpu-metrics-point/route.test.ts --maxWorkers=2)
-POWERX_ACCEPTANCE_APP_PORT=3157 POWERX_ACCEPTANCE_PG_PORT=3158 \
-  bun run --cwd packages/app test:e2e:powerx /absolute/fresh/output-directory
+bun node_modules/vitest/vitest.mjs run src/app/api/v1/gpu-metrics-point/route.test.ts
 ```
 
-The API test uses PGlite, the production parser/ingest/query/cache/point handler,
-and the real Blob SDK with a local HTTP transport. Its four cases retain
-missing→present, shared links, timezone/identity repair, no-op, cache-write failure
-and retry, and DB failure. The ingest tests separately check actual late FK
-rollback and second-series failure followed by repair; they do not claim whole
-artifact atomicity.
-
-The browser driver creates a disposable loopback PostgreSQL database, runs real
-migrations and ETL, then starts Next.js and Cypress. The two retained-source cases
-populate old cache entries for both shared points, repair constructed sidecars,
-and check API values plus EN desktop / ZH mobile focus, reopen and no-op behavior.
-The original eight synthetic browser cases remain. Successful telemetry responses
-are never substituted. The seed verifies the excerpt hash before database writes
-and records it in `seed-receipt.json`; `blob-receipt.json` records both revisions.
-
-`POWERX_PG_BIN` selects the PostgreSQL bin directory; app/PG ports default to
-3137/3138 and must be unused. Use a fresh output directory each time. The driver
-stops its owned Next, PostgreSQL and Blob fixture and records cleanup errors.
-This local check needs no artifact download or production credentials. Ancillary
-site stars/font traffic is not blocked by this driver, so it does not establish
-strict network-isolated execution. Hosted Neon, Blob/CDN and deployment are not
-covered. No collector or telemetry-validity policy changes are included.
+The test uses PGlite, the production parser/ingest/query/cache/point handler, and
+the real Blob SDK with a local HTTP transport. It checks live revisions for
+successful and missing responses, then refreshes a missing point, shared links and
+timezone/identity repairs without purging.
diff --git a/docs/fixtures/powerx-reingest/provenance.json b/docs/fixtures/powerx-reingest/provenance.json
deleted file mode 100644
index e6a332ee1..000000000
--- a/docs/fixtures/powerx-reingest/provenance.json
+++ /dev/null
@@ -1,31 +0,0 @@
-{
-  "source": {
-    "repository": "SemiAnalysisAI/InferenceX",
-    "run_id": 34175132645,
-    "run_attempt": 1,
-    "run_url": "https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645/attempts/1",
-    "artifact_name": "power_audit_qwen3.5_8k1k_fp8_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc1_b200-nscale-slurm_00_recipe-4a9cbfa6f11448e8",
-    "file": "gpu_metrics.csv",
-    "sha256": "0c04d4c47ce4ebdd71aa2a56e179cbf481733bb9517021bb9c6e91b261897c0d",
-    "collector_version": null,
-    "timestamp_timezone": null,
-    "head_sha": "931838616543914232d4bab6724bae79742ba371"
-  },
-  "fixture": {
-    "file": "nvidia.csv",
-    "sha256": "833cf864da4618579deeeda89b3ddde6dbf8b7b32b7877fda643f18411ee3481",
-    "physical_lines_inclusive": [
-      [1, 1],
-      [2898, 2921]
-    ],
-    "transformations": [
-      "Retain header and three complete consecutive 8-GPU samples; join unchanged lines with LF and final LF."
-    ],
-    "bytes": 1901,
-    "sample_count": 24,
-    "gpu_count": 8,
-    "utc_start_with_test_context": "2026-09-08T07:20:19.279Z",
-    "utc_end_with_test_context": "2026-09-08T07:20:21.279Z",
-    "gpu0_power_w": [380.42, 336.61, 337.18]
-  }
-}
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 7ded29c2c..8e3725ca2 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -19,8 +19,7 @@ The Measured Energy group is `gated: true` in `metric-registry.ts`. `ChartContro
 gated group while the gate is locked unless the selected `i_metric` belongs to it, so a
 shared link to any boundary renders for a reader who never unlocked the gate, while the
 group stays out of the selector otherwise. The boundary metrics are members of that group
-(`POWER_BASIS_METRIC_CONFIG_KEYS` is spread into it) so they inherit exactly this behaviour;
-Cypress `powerx-basis.cy.ts` covers the locked, unlocked and shared-link cases.
+(`POWER_BASIS_METRIC_CONFIG_KEYS` is spread into it) so they inherit exactly this behaviour.
 
 ## Boundaries
 
@@ -274,30 +273,14 @@ config is `display: 'timeline'`.
 
 ## Tests
 
-- `metric-registry.test.ts` — the six keys are in the gated group, resolve as themselves, are
-  bilingual, are not `measured*` keys, and map 1:1 onto `POWER_BASIS_FIELDS`.
-- `measured-metric-config.test.ts` — basis round-trips, snapping, return-to-measured, family
-  switch.
-- `measured-power-direction.test.ts` — watt keys share the measured corners and ascending
-  table sort, are power-curve metrics (upper envelope keeps the dominated peak) but not
-  measured-power-curve metrics; energy keys use the Pareto frontier and stay off the envelope.
-- `cypress/component/power-metric-availability.cy.tsx` — per-point explanations (en/zh)
-  including `noSpec`, `noNormalization`, `modelWorkload`, the overlay-aware count, and the
-  measured dictionary staying separate from the boundary dictionary.
-- `cypress/e2e/powerx-basis.cy.ts`, `measured-power-overlay.cy.ts` — control, URL, table,
-  `/zh`, overlay run.
-- `power-series.test.ts` — UTC timestamp parsing, one-second bucketing with `null` gaps, pool
-  sums.
-- `power-audit-bundle.test.ts` — cutting a DCGM bundle into per-validation series: window
-  clipping, device order and roles (validation file, manifest fallback), malformed entries.
-- `utils/powerTimeline.test.ts` — artifact-name and `source` joins, trace keys, per-run request
-  planning with the common prefix, missing rows, window phases, role pools, the focus store.
-- `api/gpu-metrics/route.test.ts` — `series=power` shape, `prefix=` narrowing the downloads
-  (both ways for bundles), the bundle size cap, the raw shape ignoring bundles, 400s for
-  malformed params.
-- `cypress/component/power-timeline.cy.tsx` — traces, emphasized window, TDP / all-in
-  references, per-GPU lines, pool lines with per-pool TDP, the focus chip, axis toggle,
-  overlay-run colour and filter, failed run, `/zh`.
-- `cypress/e2e/powerx-timeline.cy.ts` — Display → Timeline round trip through the share link,
-  shared-link entry, Table view on the alias, `?unofficialrun=` overlay traces, _View power
-  trace_ from a pinned tooltip (official and overlay), `/zh`.
+- `lib/power-basis.test.ts` and `lib/chart-utils.test.ts` — the six boundary values through
+  the real builder, and the same fields on `?unofficialrun=` overlay rows.
+- `gpu-power/power-series.test.ts`, `power-audit-bundle.test.ts` — one-second buckets with
+  `null` gaps, a partial pool is a gap rather than a lower sum, and bundle rows stay on their
+  host/device and role inside the padded window.
+- `utils/powerTimeline.test.ts` — overlay runs are fetched ahead of official runs.
+- `api/gpu-metrics/route*.test.ts` — the stored digest shape, DB-first serving, database
+  failure as 503, known missing hosts, and the retained-inventory recount before a CSV
+  fallback.
+- `cypress/component/power-timeline.cy.tsx`, `power-compare.cy.tsx` — overlay-run colour and
+  the overlay hardware filter.
diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
index e195008ff..84134453a 100644
--- a/docs/powerx-persistence-recovery.md
+++ b/docs/powerx-persistence-recovery.md
@@ -213,18 +213,6 @@ bun run check:typography
 bun run --cwd packages/app test:unit src/app/api/v1/gpu-metrics-point/route.test.ts
 bun run --cwd packages/app test:unit src/app/api/v1/views/gpu-metrics/route.test.ts
 bun run --cwd packages/db test:unit src/queries/gpu-metrics-timeline.test.ts src/etl/telemetry-receipt.test.ts
-bun run --cwd packages/app test:e2e:component --spec cypress/component/gpu-stats-table.cy.tsx
-```
-
-The focused browser driver creates a disposable localhost PostgreSQL database, ingests
-NVIDIA/AMD/multinode artifacts, starts Next without a GitHub token, and enables the real
-Blob SDK against a local HTTP fixture. It writes logs, screenshots and receipts, then stops
-its owned processes. It uses ports 3137/3138 and requires PostgreSQL 17 tools. Run with a
-fresh output directory while no other dev server is using this checkout's `.next` directory:
-
-```sh
-cd packages/app
-POWERX_PG_BIN=/path/to/postgresql/bin bun scripts/powerx-db-acceptance.ts /absolute/fresh/output
 ```
 
 The ordinary fixture-backed smoke command remains `bun run test:e2e` with an
diff --git a/packages/app/cypress.powerx-db.config.ts b/packages/app/cypress.powerx-db.config.ts
deleted file mode 100644
index 61bcb2e07..000000000
--- a/packages/app/cypress.powerx-db.config.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import createBundler from '@bahmutov/cypress-esbuild-preprocessor';
-import { execFileSync } from 'node:child_process';
-import path from 'node:path';
-import { defineConfig } from 'cypress';
-
-export default defineConfig({
-  allowCypressEnv: false,
-  video: false,
-  retries: 0,
-  defaultCommandTimeout: 10000,
-  screenshotsFolder: path.join(process.env.POWERX_ACCEPTANCE_OUTPUT!, 'screenshots'),
-  e2e: {
-    baseUrl: process.env.POWERX_ACCEPTANCE_BASE_URL ?? 'http://127.0.0.1:3137',
-    specPattern: 'cypress/powerx-db/*.cy.ts',
-    supportFile: 'cypress/support/e2e.ts',
-    setupNodeEvents(on) {
-      on(
-        'file:preprocessor',
-        createBundler({
-          define: { 'process.env.NODE_ENV': '"test"' },
-          alias: { '@': path.resolve(__dirname, 'src') },
-        }),
-      );
-      on('task', {
-        unlinkRetainedPoint() {
-          execFileSync('bun', ['scripts/powerx-db-fixture.ts', 'unlink-retained-point'], {
-            env: process.env,
-          });
-          return null;
-        },
-        retainedTelemetry(repaired: boolean) {
-          return JSON.parse(
-            execFileSync(
-              'bun',
-              ['scripts/powerx-db-fixture.ts', repaired ? 'retained-repair' : 'retained-reset'],
-              { encoding: 'utf8', env: process.env },
-            ),
-          );
-        },
-        repairTelemetry() {
-          return execFileSync('bun', ['scripts/powerx-db-fixture.ts', 'repair'], {
-            encoding: 'utf8',
-            env: process.env,
-          });
-        },
-        setTelemetryAvailable(available: boolean) {
-          execFileSync(
-            'bun',
-            ['scripts/powerx-db-fixture.ts', available ? 'restore' : 'unavailable'],
-            { env: process.env },
-          );
-          return null;
-        },
-      });
-    },
-  },
-});
diff --git a/packages/app/cypress/component/gpu-metrics-axis.cy.tsx b/packages/app/cypress/component/gpu-metrics-axis.cy.tsx
deleted file mode 100644
index 3513fa5bb..000000000
--- a/packages/app/cypress/component/gpu-metrics-axis.cy.tsx
+++ /dev/null
@@ -1,158 +0,0 @@
-import GpuMetricsChart from '@/components/gpu-power/GpuPowerChart';
-import type { GpuMetricRow } from '@/components/gpu-power/types';
-import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
-import { useState } from 'react';
-
-const svg = () => cy.get('[data-testid="gpu-metrics-chart-svg"]');
-
-function samples(clock: (sample: number) => number): GpuMetricRow[] {
-  return Array.from({ length: 8 }, (_chip, index) =>
-    Array.from({ length: 21 }, (_, sample) => ({
-      timestamp: new Date(Date.UTC(2026, 8, 20) + sample * 30_000).toISOString(),
-      index,
-      power: 300 + sample * 30,
-      memClock: clock(sample),
-    })),
-  ).flat();
-}
-
-function mountClock(data: GpuMetricRow[]) {
-  cy.mount(
-    <GpuMetricsChart
-      data={data}
-      visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
-      metricKey="memClock"
-      artifactName="gpu_metrics_b200"
-      display={{ mode: 'rolling', windowS: 300, series: 'chips' }}
-    />,
-  );
-}
-
-function assertReadableAxis(value: number) {
-  svg().should(($svg) => {
-    const labels = $svg.find('.y-axis .tick text').toArray();
-    expect(labels.length, 'multiple useful ticks').to.be.greaterThan(1);
-    const values = labels.map((label) => Number(label.textContent?.replaceAll(',', '')));
-    expect(values.every(Number.isFinite), 'numeric ticks').to.eq(true);
-    expect(new Set(values).size, 'distinct ticks').to.eq(values.length);
-    expect(Math.min(...values)).to.be.at.most(value);
-    expect(Math.max(...values)).to.be.greaterThan(value);
-    const title = $svg.find('.y-axis-label')[0]!.getBoundingClientRect();
-    for (const label of labels) {
-      expect(label.getBoundingClientRect().left, 'tick clears axis title').to.be.greaterThan(
-        title.right,
-      );
-    }
-  });
-  svg().find('path.line-path').should('have.length', 8);
-}
-
-describe('PowerX telemetry axis', () => {
-  for (const width of [1280, 375]) {
-    it(`keeps constant memory clocks readable at ${width}px`, () => {
-      cy.viewport(width, 800);
-      mountClock(samples(() => 390));
-      assertReadableAxis(390);
-    });
-  }
-
-  for (const width of [1440, 390]) {
-    it(`keeps long telemetry time ticks separated at ${width}px with a right axis`, () => {
-      cy.viewport(width, 844);
-      const data = samples(() => 390).map((row, i) => ({
-        ...row,
-        timestamp: new Date(Date.UTC(2026, 8, 20) + (i % 21) * 340_000).toISOString(),
-      }));
-      cy.mount(
-        <div style={{ width: '100%', padding: 33 }}>
-          <GpuMetricsChart
-            data={data}
-            visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
-            metricKey="power"
-            artifactName="gpu_metrics_h200"
-            overlay={{
-              label: 'Decode throughput',
-              unit: 'tok/s',
-              color: '#a78bfa',
-              points: [
-                { ms: Date.UTC(2026, 8, 20), value: 500 },
-                { ms: Date.UTC(2026, 8, 20) + 6800_000, value: 2000 },
-              ],
-            }}
-          />
-        </div>,
-      );
-      svg()
-        .find('.x-axis .tick text')
-        .should(($ticks) => {
-          expect($ticks.length).to.be.greaterThan(1);
-          const boxes = [...$ticks].map((tick) => tick.getBoundingClientRect());
-          for (let i = 1; i < boxes.length; i++) {
-            expect(boxes[i].left, 'seconds labels do not overlap').to.be.greaterThan(
-              boxes[i - 1].right,
-            );
-          }
-        });
-      svg().screenshot(`gpu-telemetry-time-${width}`);
-    });
-  }
-
-  it('does not magnify floating-point noise after rolling averages', () => {
-    mountClock(samples((sample) => 390 - (sample % 2) * Number.EPSILON * 256));
-    assertReadableAxis(390);
-  });
-
-  it('gives all-zero telemetry a nonzero, nonnegative range', () => {
-    mountClock(samples(() => 0));
-    assertReadableAxis(0);
-    svg().find('.y-axis .tick text').first().should('have.text', '0.0');
-  });
-
-  it('preserves varying power measurements and the hardware TDP reference', () => {
-    cy.mount(
-      <GpuMetricsChart
-        data={samples(() => 390)}
-        visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
-        metricKey="power"
-        artifactName="gpu_metrics_b200"
-        display={{ mode: 'points', windowS: 300, series: 'chips' }}
-      />,
-    );
-    svg().find('.tdp-line text').should('contain.text', `${HW_REGISTRY.b200.tdp}W`);
-    svg().should(($svg) => {
-      const values = $svg
-        .find('.y-axis .tick text')
-        .toArray()
-        .map((label) => Number(label.textContent?.replaceAll(',', '')));
-      expect(Math.min(...values)).to.be.at.most(300);
-      expect(Math.max(...values)).to.be.at.least(HW_REGISTRY.b200.tdp);
-    });
-  });
-
-  it('removes the power reference when switching to memory clock and restores it once', () => {
-    function SwitchMetric() {
-      const [metric, setMetric] = useState<'power' | 'memClock'>('power');
-      return (
-        <>
-          <button onClick={() => setMetric(metric === 'power' ? 'memClock' : 'power')}>
-            Switch metric
-          </button>
-          <GpuMetricsChart
-            data={samples(() => 3996)}
-            visibleGpus={new Set([0, 1, 2, 3, 4, 5, 6, 7])}
-            metricKey={metric}
-            artifactName="gpu_metrics_b200"
-            display={{ mode: 'rolling', windowS: 300, series: 'chips' }}
-          />
-        </>
-      );
-    }
-    cy.mount(<SwitchMetric />);
-    svg().find('.tdp-line').should('have.length', 1);
-    cy.contains('button', 'Switch metric').click();
-    svg().find('.tdp-line').should('not.exist');
-    assertReadableAxis(3996);
-    cy.contains('button', 'Switch metric').click();
-    svg().find('.tdp-line').should('have.length', 1);
-  });
-});
diff --git a/packages/app/cypress/component/gpu-stats-table.cy.tsx b/packages/app/cypress/component/gpu-stats-table.cy.tsx
deleted file mode 100644
index b2e20052a..000000000
--- a/packages/app/cypress/component/gpu-stats-table.cy.tsx
+++ /dev/null
@@ -1,156 +0,0 @@
-import { useState } from 'react';
-import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
-import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
-
-import GpuStatsTable from '@/components/gpu-power/GpuStatsTable';
-import { parseCsvData, type GpuMetricKey } from '@/components/gpu-power/types';
-
-const storedStats: GpuMetricStatRow[] = [
-  {
-    gpuIndex: 0,
-    metric: 'power_w',
-    count: 3,
-    min: 0,
-    max: 100,
-    mean: 50,
-    median: 50,
-    p95: 95,
-    p99: 99,
-    stddev: Math.sqrt(5000 / 3),
-  },
-  {
-    gpuIndex: 1,
-    metric: 'power_w',
-    count: 2,
-    min: 0,
-    max: 0,
-    mean: 0,
-    median: 0,
-    p95: 0,
-    p99: 0,
-    stddev: 0,
-  },
-  {
-    gpuIndex: 0,
-    metric: 'gfx_voltage_mv',
-    count: 1,
-    min: 850,
-    max: 850,
-    mean: 850,
-    median: 850,
-    p95: 850,
-    p99: 850,
-    stddev: 0,
-  },
-];
-
-function StoredTable() {
-  const [metricKey, setMetricKey] = useState<GpuMetricKey>('power');
-  return (
-    <>
-      <button onClick={() => setMetricKey('gfxVoltage')}>Voltage</button>
-      <button onClick={() => setMetricKey('temperature')}>Uncollected</button>
-      <GpuStatsTable data={[]} metricKey={metricKey} storedStats={storedStats} />
-    </>
-  );
-}
-
-function EmptyDigest() {
-  const [digest, setDigest] = useState<GpuMetricStatRow[] | undefined>();
-  return (
-    <>
-      <button onClick={() => setDigest([])}>Read empty digest</button>
-      <GpuStatsTable
-        metricKey="power"
-        storedStats={digest}
-        data={[{ timestamp: '2026-09-21T00:00:00Z', index: 0, power: 100 }]}
-      />
-    </>
-  );
-}
-
-describe('PowerX full-record statistics', () => {
-  for (const width of [1280, 390]) {
-    it(`reads stored values, sorts, and switches metrics at ${width}px`, () => {
-      cy.viewport(width, 720);
-      cy.mount(<StoredTable />);
-      cy.get('[data-testid="gpu-stats-scope"]')
-        .should('contain.text', 'Full-record statistics include startup and warmup')
-        .then(($scope) => {
-          expect($scope[0].getBoundingClientRect().right).to.be.at.most(width);
-        });
-      // The full-record digest is authoritative; rendering never needs to scan raw samples.
-      cy.get('tbody tr').should('have.length', 2);
-      cy.get('tbody tr')
-        .first()
-        .find('td')
-        .then(($cells) => {
-          expect([...$cells].map((cell) => cell.textContent)).to.deep.equal([
-            '0',
-            '3',
-            '0.0',
-            '100.0',
-            '50.0',
-            '50.0',
-            '95.0',
-            '99.0',
-            '40.8',
-          ]);
-        });
-      cy.contains('button', 'Mean (W)').click();
-      cy.get('tbody tr').first().find('td').first().should('have.text', '1');
-      cy.contains('button', 'Voltage').click();
-      cy.contains('th', 'Mean (mV)').should('exist');
-      cy.get('tbody tr').should('have.length', 1).find('td').eq(4).should('have.text', '850.0');
-      cy.get('[data-testid="gpu-stats-scope"]').parent().screenshot(`powerx-stored-stats-${width}`);
-      cy.contains('button', 'Uncollected').click();
-      cy.get('table').should('not.exist');
-    });
-  }
-
-  it('keeps Chinese labels and measured zeros in the stored digest', () => {
-    cy.viewport(390, 720);
-    cy.mount(
-      <PathnameContext.Provider value="/zh/gpu-metrics">
-        <StoredTable />
-      </PathnameContext.Provider>,
-    );
-    cy.contains('th', '平均值 (W)').should('exist');
-    cy.get('[data-testid="gpu-stats-scope"]').should(
-      'contain.text',
-      '全记录统计，包含服务启动与 warmup',
-    );
-    cy.get('tbody tr').last().find('td').eq(4).should('have.text', '0.0');
-    cy.get('[data-testid="gpu-stats-scope"]').parent().screenshot('powerx-stored-stats-zh-390');
-  });
-
-  it('computes a live artifact without a stored digest', () => {
-    cy.mount(
-      <GpuStatsTable
-        metricKey="power"
-        data={[
-          { timestamp: '2026-09-21T00:00:00Z', index: 0, power: 0 },
-          { timestamp: '2026-09-21T00:00:01Z', index: 0, power: 100 },
-        ]}
-      />,
-    );
-    cy.get('tbody tr').find('td').eq(4).should('have.text', '50.0');
-  });
-
-  it('does not synthesize stats when the stored digest is empty', () => {
-    cy.mount(<EmptyDigest />);
-    cy.get('table').should('exist');
-    cy.contains('button', 'Read empty digest').click();
-    cy.get('table').should('not.exist');
-  });
-
-  it('keeps a live CSV missing temperature separate from zero and duplicate readings', () => {
-    const data = parseCsvData(
-      'timestamp,gpu,socket_power,hotspot\n1789948800,0,0,N/A\n1789948801.0009,0,100,0\n1789948801.0011,0,900,90',
-    );
-    cy.mount(<GpuStatsTable metricKey="temperature" data={data} />);
-    cy.contains('th', 'Mean (°C)').should('exist');
-    cy.get('tbody tr').find('td').eq(1).should('have.text', '1');
-    cy.get('tbody tr').find('td').eq(4).should('have.text', '0.0');
-  });
-});
diff --git a/packages/app/cypress/component/inference-table-power-compare.cy.tsx b/packages/app/cypress/component/inference-table-power-compare.cy.tsx
deleted file mode 100644
index d8405a969..000000000
--- a/packages/app/cypress/component/inference-table-power-compare.cy.tsx
+++ /dev/null
@@ -1,68 +0,0 @@
-import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
-
-import { chartDefinitions } from '@/components/inference/metric-registry';
-import InferenceTable from '@/components/inference/ui/InferenceTable';
-import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
-
-import { createMockInferenceData } from '../support/mock-data';
-import { mountWithProviders } from '../support/test-utils';
-
-const metric = (y: number) => ({ y, roof: false });
-const points = expandPowerCompareSeries(
-  [
-    [708.1, 760.442, 690.652],
-    [281.614, 250.622, 291.945],
-  ].map(([all, prefill, decode], index) =>
-    createMockInferenceData({
-      hwKey: 'gb300_dynamo-trt',
-      conc: (index + 1) * 64,
-      y: all,
-      measuredAvgPower: metric(all),
-      measuredPrefillAvgPower: metric(prefill),
-      measuredDecodeAvgPower: metric(decode),
-    }),
-  ),
-  'y_measuredAvgPower',
-  'roles',
-);
-
-describe('Power comparison table values', () => {
-  for (const width of [1280, 390]) {
-    it(`keeps role values, sorting and search consistent at ${width}px`, () => {
-      cy.viewport(width, 720);
-      mountWithProviders(
-        <PathnameContext.Provider value="/inference">
-          <InferenceTable
-            data={points}
-            chartDefinition={chartDefinitions[0]}
-            selectedYAxisMetric="y_measuredAvgPower"
-          />
-        </PathnameContext.Provider>,
-      );
-      const table = '[data-testid="inference-results-table"]';
-      const assertRows = (expected: [string, string][]) => {
-        cy.get<HTMLTableRowElement>(`${table} tbody tr`).should(($rows) => {
-          expect(
-            [...$rows].map((row) => [row.cells[2].textContent, row.cells[3].textContent]),
-          ).to.deep.equal(expected);
-        });
-      };
-      const ascending: [string, string][] = [
-        ['Prefill GPUs', '251'],
-        ['All GPUs', '282'],
-        ['Decode GPUs', '292'],
-        ['Decode GPUs', '691'],
-        ['All GPUs', '708'],
-        ['Prefill GPUs', '760'],
-      ];
-      assertRows(ascending);
-      cy.get(`${table} thead th`).eq(3).scrollIntoView().click();
-      assertRows(ascending.toReversed());
-      cy.get(`${table} thead th`).eq(3).click();
-      assertRows(ascending);
-      cy.get(table).screenshot(`power-role-table-${width}`);
-      cy.get(`${table} input`).type('760');
-      assertRows([['Prefill GPUs', '760']]);
-    });
-  }
-});
diff --git a/packages/app/cypress/component/measured-metric-controls.cy.tsx b/packages/app/cypress/component/measured-metric-controls.cy.tsx
deleted file mode 100644
index bd34d29b4..000000000
--- a/packages/app/cypress/component/measured-metric-controls.cy.tsx
+++ /dev/null
@@ -1,38 +0,0 @@
-import { MeasuredMetricControls } from '@/components/inference/ui/MeasuredMetricControls';
-import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
-
-describe('MeasuredMetricControls statistic layout', () => {
-  for (const pathname of ['/inference', '/zh/inference']) {
-    for (const width of [375, 1280]) {
-      it(`contains statistic labels at ${width}px on ${pathname}`, () => {
-        cy.viewport(width, 800);
-        cy.mount(
-          <PathnameContext.Provider value={pathname}>
-            <div style={{ width: '100%', maxWidth: 570 }}>
-              <MeasuredMetricControls
-                metric="y_measuredAvgPower"
-                onChange={cy.stub().as('change')}
-              />
-            </div>
-          </PathnameContext.Provider>,
-        );
-        cy.get('[data-testid^="measured-power-statistic-"]')
-          .should('have.length', 3)
-          .each(($button) => {
-            const button = $button[0];
-            const bounds = button.getBoundingClientRect();
-            const group = button.parentElement!.getBoundingClientRect();
-            const range = button.ownerDocument.createRange();
-            range.selectNodeContents(button);
-            const label = range.getBoundingClientRect();
-            expect(label.left, 'label stays inside its button').to.be.at.least(bounds.left);
-            expect(label.right, 'label stays inside its button').to.be.at.most(bounds.right);
-            expect(bounds.left, 'button stays inside the group').to.be.at.least(group.left);
-            expect(bounds.right, 'button stays inside the group').to.be.at.most(group.right);
-          });
-        cy.get('[data-testid="measured-power-statistic-p75"]').click();
-        cy.get('@change').should('have.been.calledOnceWith', 'y_measuredP75Power');
-      });
-    }
-  }
-});
diff --git a/packages/app/cypress/component/power-compare.cy.tsx b/packages/app/cypress/component/power-compare.cy.tsx
index 825d6c56b..e1d3917a0 100644
--- a/packages/app/cypress/component/power-compare.cy.tsx
+++ b/packages/app/cypress/component/power-compare.cy.tsx
@@ -13,11 +13,9 @@ import {
 } from '../support/mock-data';
 import { mountWithProviders } from '../support/test-utils';
 
-// Power comparison series (`i_pcompare`): useChartData / the overlay processor
-// append one clone per boundary or role to every base point. ScatterGraph must
-// draw the clones as their own series — hardware colour, per-variant dash, its
-// own frontier — with legend rows that toggle and highlight them, and one line
-// label per series that names the boundary or role it plots.
+// Power comparison series (`i_pcompare`) on `?unofficialrun=` overlays: role
+// clones draw in the overlay run colour with the role dash, and their legend
+// rows toggle them.
 
 const OVERLAY_RUN_ID = 31415926535;
 const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
@@ -26,224 +24,90 @@ const chartDefinition = createMockChartDefinition({
   chartType: 'interactivity',
   y_measuredAvgPower: 'measuredAvgPower.y',
   y_measuredAvgPower_roofline: 'lower_left',
-  y_measuredJPerOutputToken: 'measuredJPerOutputToken.y',
-  // Interactivity chart, lower-is-better metric (metric-registry `rooflineDirection`).
-  y_measuredJPerOutputToken_roofline: 'lower_right',
 });
 
-type CompareMetric = 'y_measuredAvgPower' | 'y_measuredJPerOutputToken';
-
-const Y_LABELS: Record<CompareMetric, string> = {
-  y_measuredAvgPower: 'Measured Power per Chip (W)',
-  y_measuredJPerOutputToken: 'Energy per Output Token (J)',
-};
-
 const metric = (y: number) => ({ y, roof: false });
 
-interface CurveOptions {
-  run_url?: string;
-  precision?: Precision;
-  /** Measured W per chip at x = 8, 16, 32. Falls as x rises so every point sits on the envelope. */
-  measured?: readonly [number, number, number];
-  /** Per-chip provisioned boundaries; the defaults are the B200 registry figures. */
-  tdpWatts?: number;
-  allInWatts?: number;
-}
-
-/**
- * H100 registry boundaries (700 W TDP, 1.37 kW all-in) with measured watts far
- * enough below the TDP line that a label anchored on the wrong series is
- * unambiguous in pixels.
- */
-const H100_CURVE: CurveOptions = { measured: [400, 360, 320], tdpWatts: 700, allInWatts: 1370 };
-
 /**
- * Three measured points with every boundary and both roles available. Power
- * falls as x rises so every point sits on the upper power envelope the chart
- * draws for watt axes (maximise x, keep the running maximum y).
+ * Three measured points with both roles available. Power falls as x rises so
+ * every point sits on the upper power envelope the chart draws for watt axes.
  */
-function measuredCurve(hwKey: string, options: CurveOptions = {}): InferenceData[] {
-  const {
-    run_url,
-    precision = Precision.FP4,
-    measured = [700, 600, 500],
-    tdpWatts = 1000,
-    allInWatts = 1710,
-  } = options;
+function measuredCurve(hwKey: string, run_url?: string): InferenceData[] {
   return [
-    [8, 840, 500],
-    [16, 820, 450],
-    [32, 800, 400],
-  ].map(([x, prefill, decode], index) =>
+    [8, 700, 840, 500],
+    [16, 600, 820, 450],
+    [32, 500, 800, 400],
+  ].map(([x, measured, prefill, decode]) =>
     createMockInferenceData({
       hwKey,
       x,
       conc: x,
-      y: measured[index],
-      precision,
+      y: measured,
+      precision: Precision.FP4,
       run_url,
       disagg: true,
-      measuredAvgPower: metric(measured[index]),
+      measuredAvgPower: metric(measured),
       measuredPrefillAvgPower: metric(prefill),
       measuredDecodeAvgPower: metric(decode),
-      gpuProvisionedWatts: metric(tdpWatts),
-      utilityProvisionedWatts: metric(allInWatts),
-    }),
-  );
-}
-
-/**
- * J per output token for the measured and provisioned boundaries. Energy rises
- * with interactivity, so the lower-right Pareto frontier keeps all three points
- * of every series.
- */
-function energyCurve(hwKey: string): InferenceData[] {
-  return [
-    [8, 0.5, 0.9, 1.7],
-    [16, 0.6, 1, 1.9],
-    [32, 0.7, 1.1, 2.1],
-  ].map(([x, measured, tdp, allIn]) =>
-    createMockInferenceData({
-      hwKey,
-      x,
-      conc: x,
-      y: measured,
-      precision: Precision.FP4,
-      disagg: true,
-      measuredJPerOutputToken: metric(measured),
-      gpuProvisionedJPerOutputToken: metric(tdp),
-      utilityProvisionedJPerOutputToken: metric(allIn),
     }),
   );
 }
 
-function mountCompare(
-  data: InferenceData[],
-  options: {
-    pathname?: string;
-    width?: number;
-    overlay?: InferenceData[];
-    hiddenNonOptimal?: boolean;
-    metric?: CompareMetric;
-    lineLabels?: boolean;
-    precisions?: Precision[];
-    /** Extra `?unofficialrun=` runs beyond the default one, for multi-run tests. */
-    extraRuns?: { id: number; url: string; hwKeys: string[] }[];
-  } = {},
-) {
-  const metricKey = options.metric ?? 'y_measuredAvgPower';
+function mountCompare(data: InferenceData[], overlay: InferenceData[]) {
   mountWithProviders(
-    <PathnameContext.Provider value={options.pathname ?? '/inference'}>
-      <div style={{ width: options.width ?? 1000, height: 640 }}>
+    <PathnameContext.Provider value="/inference">
+      <div style={{ width: 1000, height: 640 }}>
         <ScatterGraph
           chartId="power-compare-test"
           modelLabel="DeepSeek V4 Pro"
           data={data}
           xLabel="Interactivity (tok/s/user)"
-          yLabel={Y_LABELS[metricKey]}
+          yLabel="Measured Power per Chip (W)"
           chartDefinition={chartDefinition}
-          overlayData={
-            options.overlay
-              ? {
-                  data: options.overlay,
-                  hardwareConfig: hwConfig,
-                  label: 'powerx-compare',
-                  runUrl: OVERLAY_RUN_URL,
-                }
-              : undefined
-          }
+          overlayData={{
+            data: overlay,
+            hardwareConfig: hwConfig,
+            label: 'powerx-compare',
+            runUrl: OVERLAY_RUN_URL,
+          }}
         />
       </div>
     </PathnameContext.Provider>,
     {
       inference: {
-        selectedYAxisMetric: metricKey,
+        selectedYAxisMetric: 'y_measuredAvgPower',
         hardwareConfig: hwConfig,
         activeHwTypes: new Set(['b200', 'h100']),
         hwTypesWithData: new Set(['b200', 'h100']),
-        selectedPrecisions: options.precisions ?? [Precision.FP4],
-        hideNonOptimal: options.hiddenNonOptimal ?? false,
-        showLineLabels: options.lineLabels ?? false,
+        selectedPrecisions: [Precision.FP4],
+        hideNonOptimal: false,
+        showLineLabels: false,
+      },
+      unofficial: {
+        isUnofficialRun: true,
+        activeOverlayHwTypes: new Set(['h100']),
+        allOverlayHwTypes: new Set(['h100']),
+        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [String(OVERLAY_RUN_ID)]: 0 },
+        unofficialRunInfos: [
+          {
+            id: OVERLAY_RUN_ID,
+            name: 'powerx-compare',
+            branch: 'powerx-compare',
+            sha: 'abc000',
+            createdAt: '2026-09-01T00:00:00Z',
+            url: OVERLAY_RUN_URL,
+            conclusion: 'success',
+            status: 'completed',
+            isNonMainBranch: true,
+          },
+        ],
       },
-      unofficial: options.overlay
-        ? {
-            isUnofficialRun: true,
-            activeOverlayHwTypes: new Set([
-              'h100',
-              ...(options.extraRuns ?? []).flatMap((run) => run.hwKeys),
-            ]),
-            allOverlayHwTypes: new Set([
-              'h100',
-              ...(options.extraRuns ?? []).flatMap((run) => run.hwKeys),
-            ]),
-            runIndexByUrl: {
-              [OVERLAY_RUN_URL]: 0,
-              [String(OVERLAY_RUN_ID)]: 0,
-              ...Object.fromEntries(
-                (options.extraRuns ?? []).flatMap((run, index) => [
-                  [run.url, index + 1],
-                  [String(run.id), index + 1],
-                ]),
-              ),
-            },
-            unofficialRunInfos: [
-              {
-                id: OVERLAY_RUN_ID,
-                name: 'powerx-compare',
-                branch: 'powerx-compare',
-                sha: 'abc000',
-                createdAt: '2026-09-01T00:00:00Z',
-                url: OVERLAY_RUN_URL,
-                conclusion: 'success',
-                status: 'completed',
-                isNonMainBranch: true,
-              },
-              ...(options.extraRuns ?? []).map((run) => ({
-                id: run.id,
-                name: `powerx-compare-${run.id}`,
-                branch: `powerx-compare-${run.id}`,
-                sha: 'abc001',
-                createdAt: '2026-09-02T00:00:00Z',
-                url: run.url,
-                conclusion: 'success' as const,
-                status: 'completed' as const,
-                isNonMainBranch: true,
-              })),
-            ],
-          }
-        : {},
     },
   );
 }
 
 const svg = '#power-compare-test svg';
 const legend = '#power-compare-test [data-testid="chart-legend"]';
-const lineLabels = `${svg} .line-label`;
-/** Selector for the pill of one comparison series, relative to the chart svg. */
-const labelSelector = (variant: string) => `.line-label[data-power-variant="${variant}"]`;
-const lineLabel = (variant: string) => `${svg} ${labelSelector(variant)}`;
-
-/** A pill's rendered text, whitespace-normalised across its tspans. */
-const pillText = (node: Element): string =>
-  (node.querySelector('.ll-text')?.textContent ?? '').replaceAll(/\s+/gu, ' ').trim();
-
-/** Rendered pill text keyed by the comparison variant the pill labels. */
-const pillTextByVariant = ($labels: JQuery<HTMLElement>): Record<string, string> =>
-  Object.fromEntries([...$labels].map((node) => [node.dataset.powerVariant, pillText(node)]));
-
-/** Vertical translate of a `.line-label` or `.dot-group`, in zoom-group pixels. */
-const translateY = (node: Element): number => {
-  const match = /translate\([^,]+,(?<y>[^)]+)\)/u.exec(node.getAttribute('transform') ?? '');
-  return match?.groups?.y === undefined ? Number.NaN : Number.parseFloat(match.groups.y);
-};
-
-/** Pixel distance from `y` to the nearest marker of one comparison series. */
-const distanceToSeries = (root: Element, variant: string, y: number): number =>
-  Math.min(
-    ...[...root.querySelectorAll(`.dot-group[data-power-variant="${variant}"]`)].map((marker) =>
-      Math.abs(translateY(marker) - y),
-    ),
-  );
 
 describe('ScatterGraph power comparison series', () => {
   beforeEach(() => {
@@ -252,168 +116,14 @@ describe('ScatterGraph power comparison series', () => {
     });
   });
 
-  it('wraps long role labels without losing the framework or role on mobile', () => {
-    cy.viewport(390, 844);
-    const data = expandPowerCompareSeries(
-      measuredCurve('gb200_dynamo-sglang'),
-      'y_measuredAvgPower',
-      'roles',
-    );
-    mountWithProviders(
-      <div style={{ width: '100%', maxWidth: 1000, padding: 33 }}>
-        <ScatterGraph
-          chartId="power-compare-test"
-          modelLabel="Qwen3.5 397B"
-          data={data}
-          xLabel="Interactivity"
-          yLabel={Y_LABELS.y_measuredAvgPower}
-          chartDefinition={chartDefinition}
-        />
-      </div>,
-      {
-        inference: {
-          selectedYAxisMetric: 'y_measuredAvgPower',
-          hardwareConfig: {
-            ...hwConfig,
-            'gb200_dynamo-sglang': {
-              name: 'gb200',
-              label: 'GB200 NVL72',
-              suffix: '(Dynamo SGLang)',
-              gpu: 'GB200',
-            },
-          },
-          activeHwTypes: new Set(['gb200_dynamo-sglang']),
-          hwTypesWithData: new Set(['gb200_dynamo-sglang']),
-          selectedPrecisions: [Precision.FP4],
-          hideNonOptimal: false,
-          showLineLabels: true,
-        },
-        unofficial: {},
-      },
-    );
-    cy.get(lineLabel('prefill'))
-      .should('contain.text', 'Dynamo SGLang')
-      .and('contain.text', 'Prefill');
-    cy.get(lineLabel('decode')).should('contain.text', 'Decode');
-    cy.get(svg).should(($svg) => {
-      const clipWidth = Number($svg.find('clipPath rect')[0].getAttribute('width'));
-      const labels = $svg
-        .find('.line-label')
-        .toArray()
-        .filter((el) => el.style.opacity !== '0');
-      expect(labels).to.have.length(3);
-      for (const label of labels) {
-        const box = label.querySelector('.ll-bg')!.getBoundingClientRect();
-        expect(box.width, label.textContent ?? '').to.be.at.most(clipWidth + 1);
-      }
-    });
-    cy.get(svg).first().screenshot('power-roles-mobile-wrapped');
-    cy.viewport(1440, 900);
-    cy.get(lineLabel('prefill'))
-      .find('.ll-bg')
-      .should(($rect) => {
-        expect(
-          $rect[0].getBoundingClientRect().height,
-          'desktop uses a single line',
-        ).to.be.lessThan(30);
-      });
-    cy.get(svg).first().screenshot('power-roles-desktop-unwrapped');
-  });
-
-  it('updates a performance ruler at mobile width when dragged', () => {
-    cy.viewport(390, 844);
-    mountCompare(expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles'), {
-      width: 324,
-    });
-    cy.contains('button', 'Advanced').click();
-    cy.get('#scatter-perf-ruler').click();
-    cy.get(`${svg} .perf-ruler-hit`).eq(0).click({ force: true });
-    cy.get(`${svg} .perf-ruler-hit`).eq(1).click({ force: true });
-    cy.get(`${svg} .pr-drag`)
-      .should('have.length', 1)
-      .then(($line) => {
-        const line = $line[0];
-        const before = line.getAttribute('x1');
-        const box = line.getBoundingClientRect();
-        const view = line.ownerDocument.defaultView!;
-        const start = { clientX: box.x, clientY: box.y + box.height / 2, view, bubbles: true };
-        line.dispatchEvent(new MouseEvent('mousedown', { ...start, button: 0, buttons: 1 }));
-        view.dispatchEvent(
-          new MouseEvent('mousemove', { ...start, clientX: box.x + 20, buttons: 1 }),
-        );
-        view.dispatchEvent(new MouseEvent('mouseup', { ...start, clientX: box.x + 20 }));
-        cy.get(`${svg} .pr-drag`).invoke('attr', 'x1').should('not.equal', before);
-      });
-  });
-
-  it('draws each boundary as a dashed sibling series in the hardware colour with a toggling legend row', () => {
-    const data = expandPowerCompareSeries(
-      measuredCurve('b200'),
-      'y_measuredAvgPower',
-      'boundaries',
-    );
-    // Three base points plus TDP and all-in clones; no modeled watts on these rows.
-    expect(data).to.have.length(9);
-    mountCompare(data);
-
-    cy.get(`${svg} .dot-group[data-power-variant=""]`).should('have.length', 3);
-    cy.get(`${svg} .dot-group[data-power-variant="gpu-provisioned"]`)
-      .should('have.length', 3)
-      .each(($point) => {
-        // Clones sit behind the base series they annotate.
-        expect(Number(getComputedStyle($point[0]).opacity)).to.be.closeTo(0.6, 0.01);
-      });
-    cy.get(`${svg} .roofline-path[data-hw-key="b200"]`).should('have.length', 3);
-    cy.get(`${svg} .roofline-path:not([data-power-variant])`)
-      .should('have.length', 1)
-      .and('not.have.attr', 'stroke-dasharray');
-    cy.get(`${svg} .roofline-path[data-power-variant="gpu-provisioned"]`)
-      .should('have.length', 1)
-      .and('have.attr', 'stroke-dasharray', '8 4');
-    cy.get(`${svg} .roofline-path[data-power-variant="utility-provisioned"]`)
-      .should('have.attr', 'stroke-dasharray', '3 3')
-      .then(($sibling) => {
-        cy.get(`${svg} .roofline-path:not([data-power-variant])`).should(($base) => {
-          // Same hardware, same colour: only the dash tells the series apart.
-          expect($sibling.attr('stroke')).to.eq($base.attr('stroke'));
-        });
-      });
-
-    // Legend: the base series first, then its siblings, each with a line swatch.
-    cy.get(legend).within(() => {
-      cy.contains('GPU measured').should('exist');
-      cy.contains('GPU provisioned (TDP)').should('exist');
-      cy.contains('Utility provisioned (all-in)').should('exist');
-      cy.contains('Utility modeled (PUE)').should('not.exist');
-      cy.contains('GPU provisioned (TDP)').click();
-    });
-    cy.get(`${svg} .roofline-path[data-power-variant="gpu-provisioned"]`).should(
-      'have.css',
-      'opacity',
-      '0',
-    );
-    cy.get(`${svg} .dot-group[data-power-variant="gpu-provisioned"]`).each(($point) => {
-      expect(getComputedStyle($point[0]).opacity).to.eq('0');
-    });
-    // The base series and the other sibling stay.
-    cy.get(`${svg} .roofline-path[data-power-variant="utility-provisioned"]`).should(
-      'have.css',
-      'opacity',
-      '1',
-    );
-    cy.get(`${svg} .dot-group[data-power-variant=""]`).each(($point) => {
-      expect(getComputedStyle($point[0]).opacity).to.eq('1');
-    });
-  });
-
   it('draws role siblings for ?unofficialrun= overlays in the run colour with the role dash', () => {
     const official = expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles');
     const overlay = expandPowerCompareSeries(
-      measuredCurve('h100', { run_url: OVERLAY_RUN_URL }),
+      measuredCurve('h100', OVERLAY_RUN_URL),
       'y_measuredAvgPower',
       'roles',
     );
-    mountCompare(official, { overlay });
+    mountCompare(official, overlay);
 
     cy.get(`${svg} .roofline-path[data-power-variant="prefill"]`).should(
       'have.attr',
@@ -441,338 +151,4 @@ describe('ScatterGraph power comparison series', () => {
       expect(hidden).to.have.length(3);
     });
   });
-
-  it('keys legend rows by the comparison base when only an overlay carries the series', () => {
-    // No official measured points at all: the base row must still be the
-    // selected metric, and each sibling must keep its own toggle.
-    const overlay = expandPowerCompareSeries(
-      measuredCurve('h100', { run_url: OVERLAY_RUN_URL }),
-      'y_measuredAvgPower',
-      'roles',
-    );
-    mountCompare([], { overlay });
-
-    cy.get(`${svg} .unofficial-overlay-pt`).should('have.length', 9);
-    cy.get(legend).within(() => {
-      cy.contains('All GPUs').should('exist');
-      cy.contains('Decode GPUs').click();
-    });
-    cy.get(`${svg} .overlay-roofline-path[data-power-variant="decode"]`).should(
-      'have.css',
-      'opacity',
-      '0',
-    );
-    cy.get(`${svg} .overlay-roofline-path:not([data-power-variant])`).should(
-      'have.css',
-      'opacity',
-      '1',
-    );
-    cy.get(`${svg} .unofficial-overlay-pt`).then(($points) => {
-      const hidden = [...$points].filter((point) => getComputedStyle(point).opacity === '0');
-      expect(hidden).to.have.length(3);
-    });
-  });
-
-  it('translates the comparison legend rows on /zh', () => {
-    mountCompare(expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles'), {
-      pathname: '/zh/inference',
-    });
-    cy.get(legend)
-      .should('contain.text', '全部 GPU')
-      .and('contain.text', '预填充 GPU')
-      .and('contain.text', '解码 GPU');
-  });
-
-  // Line labels: one pill per drawn series. The base series keeps its ordinary
-  // hardware label; a sibling appends the boundary or role it plots, and on a
-  // watts axis a flat boundary also carries its per-chip watts.
-
-  it('labels every boundary series once, with the boundary watts, each on its own line', () => {
-    const data = expandPowerCompareSeries(
-      measuredCurve('h100', H100_CURVE),
-      'y_measuredAvgPower',
-      'boundaries',
-    );
-    mountCompare(data, { lineLabels: true });
-
-    cy.get(lineLabels).should('have.length', 3);
-    cy.get(lineLabel(''))
-      .should('have.length', 1)
-      .and('have.attr', 'data-series-id', 'h100')
-      .and('have.attr', 'data-visible', '1');
-    cy.get(lineLabel('gpu-provisioned'))
-      .should('have.length', 1)
-      .and('have.attr', 'data-series-id', 'h100::gpu-provisioned')
-      .and('have.attr', 'data-visible', '1');
-    cy.get(lineLabel('utility-provisioned'))
-      .should('have.length', 1)
-      .and('have.attr', 'data-series-id', 'h100::utility-provisioned')
-      .and('have.attr', 'data-visible', '1');
-    cy.get(lineLabels).then(($labels) => {
-      expect(pillTextByVariant($labels)).to.deep.equal({
-        '': 'H100',
-        'gpu-provisioned': 'H100 · TDP 700 W',
-        'utility-provisioned': 'H100 · All-in 1.37 kW',
-      });
-      // Same hardware, same pill colour: the text tells the series apart.
-      const fills = new Set(
-        [...$labels].map((node) => node.querySelector('.ll-bg')?.getAttribute('fill')),
-      );
-      expect([...fills]).to.have.length(1);
-    });
-
-    // Each pill hugs the series it names: the base label sits on the measured
-    // curve, not on the flat TDP line above it, and the TDP label vice versa.
-    cy.get(svg).then(($svg) => {
-      const root = $svg[0];
-      const pillY = (variant: string) => translateY(root.querySelector(labelSelector(variant))!);
-      const baseY = pillY('');
-      expect(distanceToSeries(root, '', baseY)).to.be.lessThan(
-        distanceToSeries(root, 'gpu-provisioned', baseY),
-      );
-      const tdpY = pillY('gpu-provisioned');
-      expect(distanceToSeries(root, 'gpu-provisioned', tdpY)).to.be.lessThan(
-        distanceToSeries(root, '', tdpY),
-      );
-    });
-  });
-
-  it('labels role siblings with the worker pool and never with watts', () => {
-    mountCompare(expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles'), {
-      lineLabels: true,
-    });
-
-    cy.get(lineLabels)
-      .should('have.length', 3)
-      .then(($labels) => {
-        expect(pillTextByVariant($labels)).to.deep.equal({
-          '': 'B200',
-          prefill: 'B200 · Prefill GPUs',
-          decode: 'B200 · Decode GPUs',
-        });
-      });
-    cy.get(lineLabel('prefill')).should('have.attr', 'data-series-id', 'b200::prefill');
-    cy.get(lineLabel('decode')).should('have.attr', 'data-series-id', 'b200::decode');
-
-    // Hiding a sibling from the legend hides its label with it.
-    cy.get(legend).within(() => {
-      cy.contains('Decode GPUs').click();
-    });
-    cy.get(`${svg} .roofline-path[data-power-variant="decode"]`).should('have.css', 'opacity', '0');
-    cy.get(svg).should(($svg) => {
-      const label = $svg[0].querySelector<SVGGElement>(labelSelector('decode'));
-      expect(label === null || getComputedStyle(label).opacity === '0').to.eq(true);
-    });
-    cy.get(lineLabel('prefill')).should('have.css', 'opacity', '1');
-  });
-
-  it('keeps the boundary suffix but drops the watts on a J per token axis', () => {
-    const data = expandPowerCompareSeries(
-      energyCurve('h100'),
-      'y_measuredJPerOutputToken',
-      'boundaries',
-    );
-    expect(data).to.have.length(9);
-    mountCompare(data, { lineLabels: true, metric: 'y_measuredJPerOutputToken' });
-
-    cy.get(`${svg} .roofline-path`).should('have.length', 3);
-    cy.get(lineLabels)
-      .should('have.length', 3)
-      .then(($labels) => {
-        expect(pillTextByVariant($labels)).to.deep.equal({
-          '': 'H100',
-          'gpu-provisioned': 'H100 · TDP',
-          'utility-provisioned': 'H100 · All-in',
-        });
-      });
-  });
-
-  it('translates boundary line labels on /zh', () => {
-    const data = expandPowerCompareSeries(
-      measuredCurve('h100', H100_CURVE),
-      'y_measuredAvgPower',
-      'boundaries',
-    );
-    mountCompare(data, { lineLabels: true, pathname: '/zh/inference' });
-
-    cy.get(lineLabels)
-      .should('have.length', 3)
-      .then(($labels) => {
-        expect(pillTextByVariant($labels)).to.deep.equal({
-          '': 'H100',
-          'gpu-provisioned': 'H100 · TDP 700 W',
-          'utility-provisioned': 'H100 · 全站 1.37 kW',
-        });
-      });
-  });
-
-  it('translates role line labels on /zh', () => {
-    mountCompare(expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles'), {
-      lineLabels: true,
-      pathname: '/zh/inference',
-    });
-
-    cy.get(lineLabels)
-      .should('have.length', 3)
-      .then(($labels) => {
-        expect(pillTextByVariant($labels)).to.deep.equal({
-          '': 'B200',
-          prefill: 'B200 · 预填充 GPU',
-          decode: 'B200 · 解码 GPU',
-        });
-      });
-  });
-
-  /**
-   * Regression for the PowerX article's Fig 6. Two `?unofficialrun=` overlays in
-   * roles mode draw six lines, and the anchor pass used to hide whichever series
-   * ran out of anchor slots — in the exported figure that was the GB300 overall
-   * line, leaving a drawn curve the reader could only identify by elimination.
-   *
-   * `crowdedCurve` reproduces the shape that causes it, which a gently spread
-   * curve does not: power falls steeply with interactivity, so every series'
-   * anchors land in the top slice of a tall y domain and compete for the same
-   * few x positions. Pills stay in the DOM at opacity 0 when hidden, so counting
-   * nodes cannot see this bug; the assertions below are on `data-visible`.
-   */
-  const crowdedCurve = (hwKey: string, runUrl: string, offset: number): InferenceData[] =>
-    [
-      [8, 840, 848, 832],
-      [16, 700, 712, 690],
-      [32, 470, 486, 458],
-      [64, 330, 344, 318],
-      [128, 250, 262, 240],
-    ].map(([x, measured, prefill, decode]) =>
-      createMockInferenceData({
-        hwKey,
-        x,
-        conc: x,
-        y: measured + offset,
-        precision: Precision.FP4,
-        run_url: runUrl,
-        disagg: true,
-        measuredAvgPower: metric(measured + offset),
-        measuredPrefillAvgPower: metric(prefill + offset),
-        measuredDecodeAvgPower: metric(decode + offset),
-        gpuProvisionedWatts: metric(1000),
-        utilityProvisionedWatts: metric(1710),
-      }),
-    );
-
-  it('keeps a visible pill on all three role series of every ?unofficialrun= overlay', () => {
-    const secondRunId = 27182818284;
-    const secondRunUrl = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${secondRunId}`;
-    const overlay = [
-      ...expandPowerCompareSeries(
-        crowdedCurve('h100', OVERLAY_RUN_URL, 0),
-        'y_measuredAvgPower',
-        'roles',
-      ),
-      ...expandPowerCompareSeries(
-        crowdedCurve('b200', secondRunUrl, 6),
-        'y_measuredAvgPower',
-        'roles',
-      ),
-    ];
-    mountCompare([], {
-      overlay,
-      lineLabels: true,
-      extraRuns: [{ id: secondRunId, url: secondRunUrl, hwKeys: ['b200'] }],
-    });
-
-    cy.get(lineLabels).should('have.length', 6);
-    cy.get(`${lineLabels}[data-visible="1"]`).should('have.length', 6);
-    // The two "overall" pills are the ones the old anchor pass dropped.
-    cy.get(`${svg} ${labelSelector('')}[data-visible="1"]`).should('have.length', 2);
-    // A kept pill is only worth keeping if it is on the chart. (layoutPills'
-    // clamp is unit-tested against the exact clip rect in
-    // line-label-pill-bounds.test.ts; this is the coarse check that nothing was
-    // pushed off the chart entirely.)
-    cy.get(svg).then(($svg) => {
-      const chart = $svg[0].getBoundingClientRect();
-      cy.get(`${lineLabels}[data-visible="1"] .ll-bg`).each(($bg) => {
-        const box = $bg[0].getBoundingClientRect();
-        expect(box.left, 'pill left inside chart').to.be.at.least(chart.left - 1);
-        expect(box.right, 'pill right inside chart').to.be.at.most(chart.right + 1);
-        expect(box.top, 'pill top inside chart').to.be.at.least(chart.top - 1);
-        expect(box.bottom, 'pill bottom inside chart').to.be.at.most(chart.bottom + 1);
-      });
-    });
-    // Both runs contribute all three roles, keyed by line so the runs stay apart.
-    cy.get(`${lineLabels}[data-visible="1"]`).then(($labels) => {
-      const byLine = [...$labels].map((node) => ({
-        line: (node as HTMLElement).dataset.lineKey ?? '',
-        text: pillText(node),
-      }));
-      expect(new Set(byLine.map((entry) => entry.line)).size, 'distinct line keys').to.eq(6);
-      expect(byLine.filter((entry) => /H100/u.test(entry.text)).length).to.eq(3);
-      expect(byLine.filter((entry) => /B200/u.test(entry.text)).length).to.eq(3);
-    });
-  });
-
-  it('labels ?unofficialrun= comparison siblings with the marked hardware and the variant', () => {
-    const overlay = expandPowerCompareSeries(
-      measuredCurve('h100', { run_url: OVERLAY_RUN_URL }),
-      'y_measuredAvgPower',
-      'roles',
-    );
-    mountCompare([], { overlay, lineLabels: true });
-
-    cy.get(lineLabels)
-      .should('have.length', 3)
-      .each(($label) => {
-        expect($label.attr('data-line-key')).to.match(/^overlay-/u);
-        // Overlay pills take the run colour, like the overlay rooflines.
-        expect($label.find('.ll-bg').attr('fill')).to.eq(overlayRunColor(0));
-      })
-      .then(($labels) => {
-        // The branch stays in the legend; pills name the hardware behind the marker.
-        expect(pillTextByVariant($labels)).to.deep.equal({
-          '': '✕ H100',
-          prefill: '✕ H100 · Prefill GPUs',
-          decode: '✕ H100 · Decode GPUs',
-        });
-      });
-    cy.get(lineLabel('')).should('have.attr', 'data-series-id', 'h100');
-    cy.get(lineLabel('decode')).should('have.attr', 'data-series-id', 'h100::decode');
-  });
-
-  it('labels each precision of every boundary series when several precisions are shown', () => {
-    const fp4 = measuredCurve('h100', H100_CURVE);
-    const fp8 = measuredCurve('h100', {
-      ...H100_CURVE,
-      measured: [200, 180, 160],
-      precision: Precision.FP8,
-    });
-    const data = expandPowerCompareSeries([...fp4, ...fp8], 'y_measuredAvgPower', 'boundaries');
-    mountCompare(data, { lineLabels: true, precisions: [Precision.FP4, Precision.FP8] });
-
-    cy.get(lineLabels)
-      .should('have.length', 6)
-      .then(($labels) => {
-        expect([...$labels].map(pillText)).to.have.members([
-          'H100 FP4',
-          'H100 FP4 · TDP 700 W',
-          'H100 FP4 · All-in 1.37 kW',
-          'H100 FP8',
-          'H100 FP8 · TDP 700 W',
-          'H100 FP8 · All-in 1.37 kW',
-        ]);
-      });
-    cy.get(lineLabel('')).should('have.length', 2);
-    cy.get(lineLabel('gpu-provisioned')).should('have.length', 2);
-    cy.get(lineLabel('utility-provisioned')).should('have.length', 2);
-  });
-
-  it('leaves line labels untouched without a comparison', () => {
-    mountCompare([...measuredCurve('b200'), ...measuredCurve('h100', H100_CURVE)], {
-      lineLabels: true,
-    });
-
-    cy.get(lineLabels)
-      .should('have.length', 2)
-      .then(($labels) => {
-        expect([...$labels].map(pillText)).to.have.members(['B200', 'H100']);
-      });
-  });
 });
diff --git a/packages/app/cypress/component/power-metric-availability.cy.tsx b/packages/app/cypress/component/power-metric-availability.cy.tsx
index fa2a9f3a8..6a6c7b1a6 100644
--- a/packages/app/cypress/component/power-metric-availability.cy.tsx
+++ b/packages/app/cypress/component/power-metric-availability.cy.tsx
@@ -24,71 +24,6 @@ const measured = createMockInferenceData({
   power_metric_schema_version: 2,
   measuredAvgPower: { y: 640, roof: false },
 });
-
-// Derived power boundaries (lib/power-basis.ts). The registered B200 carries
-// every boundary; the GB200 NVL72 has spec watts but sits outside the chassis
-// power model; the AMD row failed validation, so its modeled boundary is
-// withheld even though its spec constants exist; the disaggregated AgentX row
-// reports throughput but no whole-deployment GPU count, so its provisioned
-// energy is withheld and the chassis model rejects its workload; the
-// unregistered hardware has no spec constants at all.
-const boundaries = createMockInferenceData({
-  ...base,
-  hwKey: 'b200',
-  power_valid: 1,
-  power_metric_schema_version: 2,
-  measuredAvgPower: { y: 640, roof: false },
-  gpuProvisionedWatts: { y: 1000, roof: false },
-  gpuProvisionedJPerOutputToken: { y: 3.6, roof: false },
-  utilityProvisionedWatts: { y: 1710, roof: false },
-  utilityProvisionedJPerOutputToken: { y: 6.1, roof: false },
-  utilityModeledWatts: { y: 1105, roof: false },
-  utilityModeledJPerOutputToken: { y: 3.9, roof: false },
-});
-const outsideModel = createMockInferenceData({
-  ...base,
-  hwKey: 'gb200',
-  output_tput_per_gpu: undefined,
-  gpuProvisionedWatts: { y: 1200, roof: false },
-  utilityProvisionedWatts: { y: 1870, roof: false },
-  modeledSystemPower: { status: 'unsupported', reason: 'hardware', modelRevision: 'abc1234' },
-});
-const failedValidation = createMockInferenceData({
-  ...base,
-  hwKey: 'mi355x',
-  power_valid: 0,
-  power_invalid_reasons: ['sampling_gap_exceeded'],
-  gpuProvisionedWatts: { y: 1400, roof: false },
-  gpuProvisionedJPerOutputToken: { y: 5, roof: false },
-  utilityProvisionedWatts: { y: 2200, roof: false },
-  utilityProvisionedJPerOutputToken: { y: 7.9, roof: false },
-});
-const agenticDisagg = createMockInferenceData({
-  ...base,
-  hwKey: 'b200_disagg',
-  disagg: true,
-  benchmark_type: 'agentic_traces',
-  output_tput_per_gpu: 300,
-  num_prefill_gpu: 4,
-  num_decode_gpu: 4,
-  power_valid: 1,
-  power_metric_schema_version: 2,
-  measuredAvgPower: { y: 700, roof: false },
-  gpuProvisionedWatts: { y: 1000, roof: false },
-  utilityProvisionedWatts: { y: 1710, roof: false },
-  modeledSystemPower: { status: 'unsupported', reason: 'workload', modelRevision: 'abc1234' },
-});
-const unregistered = createMockInferenceData({ ...base, hwKey: 'unknown_hw' });
-function BoundaryPanel({ metric: initial }: { metric: string }) {
-  const [metric, select] = useState(initial);
-  return (
-    <PowerMetricAvailabilityPanel
-      points={[boundaries, outsideModel, failedValidation, agenticDisagg, unregistered]}
-      metric={metric}
-      onSelect={select}
-    />
-  );
-}
 function Panel() {
   const [metric, select] = useState('y_measuredAvgPower');
   return (
@@ -125,95 +60,6 @@ describe('PowerX metric availability', () => {
     cy.contains('summary', '所有实测指标的可用性').click();
     cy.contains('缺失值不会被替换为零或 TDP 估算值');
   });
-  it('explains why derived power boundaries are missing per point', () => {
-    cy.mount(<BoundaryPanel metric="y_utilityModeledWatts" />);
-    // B4 follows the chassis model and the telemetry verdict.
-    cy.contains('1 of 5 points have this metric');
-    cy.contains('Value available: 1');
-    cy.contains('Hardware not in the chassis power model: 1');
-    cy.contains('Chassis model covers 8K / 1K only: 1');
-    cy.contains('No validated GPU telemetry: 1');
-    cy.contains('Validation failed: 1');
-    cy.contains('summary', 'source details').click();
-    cy.contains('gb200: Hardware not in the chassis power model (1)');
-    cy.contains('b200_disagg: Chassis model covers 8K / 1K only (1)');
-    cy.contains('unknown_hw: No validated GPU telemetry (1)');
-    cy.contains('mi355x: Validation failed (1) · sampling_gap_exceeded');
-    // Spec-constant watts exist for every registered hardware, validated or not.
-    cy.contains('summary', 'all measured metrics').click();
-    cy.contains('button', 'GPU Provisioned Power per Chip (TDP)').should('contain', '4/5').click();
-    cy.contains('4 of 5 points have this metric');
-    cy.contains('No published spec for this hardware: 1');
-    cy.get('[data-testid="power-metric-availability"]').should('not.contain', 'Validation failed');
-    // Provisioned energy additionally needs output throughput and, for
-    // disaggregated rows, the whole-deployment GPU count (the list stays open).
-    cy.contains('button', 'Utility Provisioned Joules per Output Token, all GPUs (all-in)')
-      .should('contain', '2/5')
-      .click();
-    cy.contains('2 of 5 points have this metric');
-    cy.contains('No output throughput reported: 1');
-    cy.contains('Whole-deployment GPU count unavailable for this disaggregated row: 1');
-    cy.contains('No published spec for this hardware: 1');
-    cy.contains('gb200: No output throughput reported (1)');
-    cy.contains(
-      'b200_disagg: Whole-deployment GPU count unavailable for this disaggregated row (1)',
-    );
-  });
-  it('uses Chinese copy for the derived boundary states', () => {
-    cy.mount(
-      <PathnameContext.Provider value="/zh/inference/qwen-3-5">
-        <BoundaryPanel metric="y_utilityModeledJPerOutputToken" />
-      </PathnameContext.Provider>,
-    );
-    cy.contains('5 个数据点中有 1 个提供此指标');
-    cy.contains('有数值: 1');
-    cy.contains('硬件不在机箱功耗模型范围内: 1');
-    cy.contains('机箱功耗模型仅覆盖 8K / 1K: 1');
-    cy.contains('没有已验证的 GPU 遥测: 1');
-    cy.contains('验证失败: 1');
-    cy.contains('summary', '所有实测指标的可用性').click();
-    cy.contains('button', '每芯片 GPU 额定功耗（TDP）').should('contain', '4/5');
-    cy.contains('button', '每输出 token 全电源配置焦耳能耗，按全部 GPU 归一（all-in）')
-      .should('contain', '2/5')
-      .click();
-    cy.contains('无法确定该分离式部署的 GPU 总数: 1');
-    cy.contains('该硬件没有公开的规格参数: 1');
-  });
-  it('keeps the measured validation copy on the measured dictionary', () => {
-    // `invalid` exists in both dictionaries; the measured metric must read
-    // its own so a future basis-copy edit cannot rewrite the measured string.
-    // Only the registered B200 and the disaggregated AgentX row carry
-    // validated telemetry; the GB200 and the unregistered hardware report
-    // nothing and the AMD row failed validation.
-    cy.mount(<BoundaryPanel metric="y_measuredAvgPower" />);
-    cy.contains('2 of 5 points have this metric');
-    cy.contains('Validation failed: 1');
-    cy.contains('Metric not reported: 2');
-    cy.get('[data-testid="power-metric-availability"]').should('not.contain', 'Value available');
-  });
-  it('counts derived boundaries on visible unofficial overlay rows only', () => {
-    mountWithProviders(
-      <PowerMetricAvailability metric="y_gpuProvisionedJPerOutputToken" onSelect={cy.stub()} />,
-      {
-        inference: {
-          selectionPoints: [outsideModel],
-          activeHwTypes: new Set(['gb200']),
-          selectedModel: Model.Qwen3_5,
-          selectedSequence: Sequence.EightK_OneK,
-          selectedPrecisions: [Precision.FP8],
-        },
-        unofficial: {
-          isUnofficialRun: true,
-          activeOverlayHwTypes: new Set(['b200']),
-          getOverlayData: () => ({ data: [boundaries, failedValidation], hardwareConfig: {} }),
-        },
-      },
-    );
-    // Official GB200 (no throughput) + visible overlay B200; hidden overlay mi355x excluded.
-    cy.contains('1 of 2 points have this metric');
-    cy.contains('No output throughput reported: 1');
-    cy.get('[data-testid="power-metric-availability"]').should('not.contain', 'Validation failed');
-  });
   it('counts filtered unofficial rows before the metric filter and respects hidden overlay hardware', () => {
     mountWithProviders(
       <PowerMetricAvailability metric="y_measuredAvgPower" onSelect={cy.stub()} />,
diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index adab6f6ac..01fc78f13 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -1,18 +1,8 @@
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
-import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
-import { useState, type ReactElement } from 'react';
 
-import type {
-  GpuPowerDevice,
-  GpuPowerSeries,
-  GpuPowerSeriesResponse,
-} from '@/components/gpu-power/power-series';
+import type { GpuPowerSeries, GpuPowerSeriesResponse } from '@/components/gpu-power/power-series';
 import PowerTimeline from '@/components/inference/ui/PowerTimeline';
 import type { InferenceData } from '@/components/inference/types';
-import {
-  requestPowerTraceFocus,
-  traceKeyForPoint,
-} from '@/components/inference/utils/powerTimeline';
 import { Model, Precision, Sequence } from '@/lib/data-mappings';
 import { overlayRunColor } from '@/lib/overlay-run-style';
 
@@ -24,39 +14,19 @@ import {
 import { mountWithProviders } from '../support/test-utils';
 
 // PowerTimeline joins chart points to `gpu_metrics_<RESULT_FILENAME>` artifacts
-// (or to the series the API cuts out of a `power_audit_*` bundle) by the
-// `power_audit.source` file name and draws one trace per config: the whole job
-// faint, the validated window emphasized, TDP dashed per hardware. Bundle
-// series carry worker roles, which unlock the prefill / decode pool mode.
+// by the `power_audit.source` file name and draws one trace per config. Overlay
+// runs keep their run colour and follow the overlay hardware filter.
 
 const RUN_ID = '34716669498';
 const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
 const OVERLAY_RUN_ID = '31415926535';
 const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
-const runUrlFor = (runId: string) =>
-  `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${runId}`;
 const START_MS = Date.UTC(2026, 8, 12, 20, 20, 0);
-const hwConfig = {
-  ...createMockHardwareConfig(),
-  gb200: {
-    name: 'gb200',
-    label: 'GB200 NVL72',
-    suffix: '',
-    gpu: "NVIDIA 'Blackwell' GB200 NVL72",
-  },
-};
-const HW_TYPES = new Set(['b200', 'h100', 'gb200']);
+const hwConfig = createMockHardwareConfig();
+const HW_TYPES = new Set(['b200', 'h100']);
 
 const resultName = (hardware: string, conc: number) =>
   `dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc${conc}_${hardware}-host-0123456789abcdef0123`;
-
-// A Slurm / Dynamo disaggregated sweep: one bundle per sweep, one validation
-// file per concurrency inside it, DCGM device ids as `<hostname>/<GPU-uuid>`.
-const DISAGG_RESULT =
-  'qwen3.5_8k1k_fp8_dynamo-sglang_prefill-tp4-pp1-dcp1-pcp1-ep1-dpfalse-nw1_decode-tp4-pp1-dcp1-pcp1-e-5b35252b29d80b104d11';
-const disaggSource = (conc: number) =>
-  `power_validation_${DISAGG_RESULT}_sa-bench_isl_8192_osl_1024_conc${conc}_gpus_8_ctx_4_gen_4.json`;
-const HOST = 'watchtower-navy-cn01';
 const WINDOW = {
   // Window covers the last 20 s of a 60 s job.
   window_start_unix: (START_MS + 40_000) / 1000,
@@ -87,19 +57,6 @@ function measuredPoint(
   });
 }
 
-function disaggPoint(
-  conc: number,
-  watts: number,
-  overrides: Partial<InferenceData> = {},
-): InferenceData {
-  return measuredPoint('gb200', conc, watts, {
-    tp: 4,
-    disagg: true,
-    power_audit: { source: disaggSource(conc), ...WINDOW },
-    ...overrides,
-  });
-}
-
 /** 61 one-second buckets: idle 200 W, ramps to `peak` inside the window. */
 function series(hwKey: string, conc: number, peak: number, gpus = [0, 1]): GpuPowerSeries {
   const t = Array.from({ length: 61 }, (_, i) => i);
@@ -113,34 +70,6 @@ function series(hwKey: string, conc: number, peak: number, gpus = [0, 1]): GpuPo
   };
 }
 
-/**
- * Bundle-cut series: 4 prefill + 4 decode devices. Prefill idles at 300 W and
- * works at 900 W (+row), decode at 250 W and 700 W (+row), so the pool sums in
- * the window are 3606 W and 2822 W.
- */
-function poolSeries(conc: number, prefillCount = 4): GpuPowerSeries {
-  const t = Array.from({ length: 61 }, (_, i) => i);
-  const devices: GpuPowerDevice[] = Array.from({ length: 8 }, (_, i) => ({
-    id: `${HOST}/GPU-${String(i).padStart(8, '0')}-d62f-0ff2-b4e5-e36f6fac8f1b`,
-    role: i < prefillCount ? 'prefill' : 'decode',
-  }));
-  return {
-    artifact: `power_audit_${DISAGG_RESULT}`,
-    source: disaggSource(conc),
-    startMs: START_MS,
-    bucketSeconds: 1,
-    gpus: devices.map((_, i) => i),
-    t,
-    power: devices.map((device, i) =>
-      t.map((second) => {
-        const prefill = device.role === 'prefill';
-        return second >= 40 ? (prefill ? 900 : 700) + i : prefill ? 300 : 250;
-      }),
-    ),
-    devices,
-  };
-}
-
 const response: GpuPowerSeriesResponse = {
   runInfo: {
     id: Number(RUN_ID),
@@ -155,36 +84,22 @@ const response: GpuPowerSeriesResponse = {
   series: [series('b200', 16, 700), series('b200', 64, 900)],
 };
 
-/** A single-node B200 config and a disaggregated GB200 config from the same run. */
-const poolResponse: GpuPowerSeriesResponse = {
-  runInfo: response.runInfo,
-  series: [series('b200', 16, 700), poolSeries(8)],
-};
-
-const GB200_TDP = HW_REGISTRY.gb200?.tdp || HW_REGISTRY.b200.tdp;
-
 function mountTimeline(
-  data: InferenceData[] | ReactElement,
+  data: InferenceData[],
   options: {
-    pathname?: string;
-    width?: number;
     overlay?: Parameters<typeof PowerTimeline>[0]['overlayData'];
     unofficial?: Parameters<typeof createMockUnofficialRunContext>[0];
   } = {},
 ) {
   mountWithProviders(
-    <PathnameContext.Provider value={options.pathname ?? '/inference'}>
-      <div style={{ width: options.width ?? 1100, height: 700 }}>
-        {Array.isArray(data) ? (
-          <PowerTimeline
-            chartId="power-timeline-test"
-            data={data}
-            overlayData={options.overlay}
-            yLabel="Measured Average Power per Chip over Time (W)"
-          />
-        ) : (
-          data
-        )}
+    <PathnameContext.Provider value="/inference">
+      <div style={{ width: 1100, height: 700 }}>
+        <PowerTimeline
+          chartId="power-timeline-test"
+          data={data}
+          overlayData={options.overlay}
+          yLabel="Measured Average Power per Chip over Time (W)"
+        />
       </div>
     </PathnameContext.Provider>,
     {
@@ -210,223 +125,6 @@ describe('PowerTimeline', () => {
     });
   });
 
-  it('distinguishes dates when wall-clock traces span multiple days', () => {
-    cy.intercept('POST', '/api/gpu-metrics*', {
-      body: {
-        ...response,
-        series: response.series.map((trace, index) => ({
-          ...trace,
-          startMs: trace.startMs + index * 2 * 24 * 60 * 60_000,
-        })),
-      },
-    }).as('series');
-    mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('b200', 64, 900)]);
-    cy.wait('@series');
-    cy.get('[data-testid="power-timeline-axis-wall"]').click();
-    svg()
-      .find('.x-axis .tick text')
-      .should(($ticks) => {
-        const labels = [...$ticks].map((tick) => tick.textContent);
-        expect(labels.some((label) => label?.includes('09/13'))).to.equal(true);
-        expect(labels.some((label) => label?.includes('09/14'))).to.equal(true);
-        expect(new Set(labels).size).to.equal(labels.length);
-      });
-    svg().screenshot('power-timeline-multiday');
-  });
-
-  it('keeps mobile wall-clock dates separated', () => {
-    cy.viewport(390, 844);
-    cy.intercept('POST', '/api/gpu-metrics*', {
-      body: {
-        ...response,
-        series: response.series.map((trace, index) => ({
-          ...trace,
-          startMs: trace.startMs + index * 2 * 24 * 60 * 60_000,
-        })),
-      },
-    }).as('series');
-    mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('b200', 64, 900)], {
-      width: 324,
-    });
-    cy.wait('@series');
-    cy.get('[data-testid="power-timeline-axis-wall"]').click();
-    svg()
-      .find('.x-axis .tick text')
-      .should(($ticks) => {
-        expect($ticks.length).to.be.greaterThan(1);
-        const boxes = [...$ticks].map((tick) => tick.getBoundingClientRect());
-        for (let i = 1; i < boxes.length; i++) {
-          expect(boxes[i].left, 'date labels do not overlap').to.be.greaterThan(boxes[i - 1].right);
-        }
-      });
-    svg().screenshot('power-timeline-mobile-dates');
-  });
-
-  it('fetches one prefixed series request per run and draws the job with its window emphasized', () => {
-    cy.intercept('POST', '/api/gpu-metrics*', { body: response }).as('series');
-    mountTimeline([
-      measuredPoint('b200', 16, 700, {
-        power_audit: {
-          source: `results/power_validation_${resultName('b200', 16)}.json`,
-          ...WINDOW,
-        },
-      }),
-      measuredPoint('b200', 64, 900),
-      // Same run, no artifact uploaded (e.g. a disaggregated Dynamo row).
-      measuredPoint('b200', 256, 950, {
-        disagg: true,
-        power_audit: { source: 'power_validation_dsv4_8k1k_fp4_dynamo-sglang_conc256.json' },
-      }),
-    ]);
-
-    cy.wait('@series').then(({ request }) => {
-      const url = new URL(request.url);
-      expect(url.searchParams.get('runId')).to.eq(RUN_ID);
-      expect(url.searchParams.get('series')).to.eq('power');
-      expect(url.searchParams.get('prefix')).to.eq('dsv4_8k1k_fp4_');
-      expect(request.body).to.deep.equal({
-        sources: [
-          `power_validation_${resultName('b200', 16)}.json`,
-          `power_validation_${resultName('b200', 64)}.json`,
-          'power_validation_dsv4_8k1k_fp4_dynamo-sglang_conc256.json',
-        ].toSorted(),
-      });
-      expect(request.body.sources).to.deep.equal([...new Set(request.body.sources)].toSorted());
-    });
-
-    svg().within(() => {
-      cy.get('path.power-trace[data-segment="full"]').should('have.length', 2);
-      cy.get('path.power-trace[data-segment="window"]')
-        .should('have.length', 2)
-        .each(($path) => {
-          // The window segment is the emphasized one.
-          expect(Number($path.attr('stroke-width'))).to.be.greaterThan(2);
-          expect(Number($path.attr('opacity'))).to.eq(1);
-        });
-      cy.get('path.power-trace[data-hw="b200"]').should('have.length', 4);
-      // Mean mode carries no pool attributes or dashes.
-      cy.get('path.power-trace[data-pool]').should('not.exist');
-      cy.get('path.power-trace[stroke-dasharray]').should('not.exist');
-      cy.get('.power-reference[data-reference="tdp"][data-watts="1000"]').should('exist');
-      cy.get('.power-reference[data-reference="tdp"] text').should('contain.text', 'TDP 1000 W');
-      cy.get('.power-reference[data-reference="utility"]').should('not.exist');
-      cy.get('text.power-trace-label').should('have.length', 2);
-      cy.get('text.power-trace-label').first().should('contain.text', 'c');
-      cy.get('.x-axis-label, text').contains('Time (UTC)').should('exist');
-    });
-    cy.get('[data-testid="power-timeline-missing"]')
-      .should('contain.text', '1 of 3 measured configs have no telemetry trace')
-      .and('contain.text', '1 have no gpu_metrics artifact or power-audit bundle in their run')
-      .and('contain.text', 'Not drawn: B200 PD · TP8 · c256');
-    cy.get('[data-testid="power-timeline-source"] a')
-      .should('have.attr', 'href', RUN_URL)
-      .and('contain.text', `run ${RUN_ID}`);
-    cy.get('[data-testid="power-timeline-empty"]').should('not.exist');
-    // No trace carries worker roles, so the pools switch is not offered.
-    cy.get('[data-testid="power-timeline-pools"]').should('not.exist');
-    cy.get('[data-testid="power-timeline-focus"]').should('not.exist');
-
-    // One line per GPU doubles the polylines; the all-in switch adds its reference.
-    cy.get('[data-testid="power-timeline-per-gpu"]').click();
-    cy.get('[data-testid="power-timeline-chart-svg"] path.power-trace[data-segment="full"]').should(
-      'have.length',
-      4,
-    );
-    cy.get('[data-testid="power-timeline-utility"]').click();
-    cy.get(
-      '[data-testid="power-timeline-chart-svg"] .power-reference[data-reference="utility"]',
-    ).should('exist');
-
-    // Elapsed axis relabels the x-axis and keeps every trace.
-    cy.get('[data-testid="power-timeline-axis-elapsed"]').click();
-    svg().within(() => {
-      cy.get('text').contains('Time since telemetry start').should('exist');
-      cy.get('path.power-trace[data-segment="full"]').should('have.length', 4);
-    });
-  });
-
-  it('fetches again when wanted sources change within the same run and prefix', () => {
-    const source16 = `power_validation_${resultName('b200', 16)}.json`;
-    const source32 = `power_validation_${resultName('b200', 32)}.json`;
-    const source64 = `power_validation_${resultName('b200', 64)}.json`;
-    cy.intercept('POST', '/api/gpu-metrics*', (request) => {
-      request.reply({
-        body: {
-          ...response,
-          series: request.body.sources.includes(source32)
-            ? [series('b200', 16, 700), series('b200', 32, 800)]
-            : response.series,
-        },
-      });
-    }).as('series');
-
-    function ChangingSelection() {
-      const [changed, setChanged] = useState(false);
-      return (
-        <>
-          <button onClick={() => setChanged(true)}>Select concurrency 32</button>
-          <PowerTimeline
-            chartId="power-timeline-test"
-            data={[
-              measuredPoint('b200', 16, 700),
-              measuredPoint('b200', changed ? 32 : 64, changed ? 800 : 900),
-            ]}
-            yLabel="Measured Average Power per Chip over Time (W)"
-          />
-        </>
-      );
-    }
-
-    mountTimeline(<ChangingSelection />);
-    cy.wait('@series').then(({ request: first }) => {
-      expect(first.body).to.deep.equal({ sources: [source16, source64] });
-      svg().find('text.power-trace-label').should('contain.text', 'c64');
-      cy.contains('button', 'Select concurrency 32').click();
-      cy.wait('@series').then(({ request: second }) => {
-        expect(second.url).to.eq(first.url);
-        expect(second.body).to.deep.equal({ sources: [source16, source32] });
-      });
-    });
-    svg()
-      .find('text.power-trace-label')
-      .should('contain.text', 'c32')
-      .and('not.contain.text', 'c64');
-    cy.get('[data-testid="power-timeline-missing"]').should('not.exist');
-    cy.get('@series.all').should('have.length', 2);
-  });
-
-  for (const [locale, pathname, width] of [
-    ['EN desktop', '/inference', 1280],
-    ['ZH mobile', '/zh/inference', 390],
-  ] as const) {
-    it(`draws the stored and recovered sibling from a hybrid API fixture on ${locale}`, () => {
-      cy.viewport(width, 844);
-      // Transport fixture: the API already retained c16 from DB and recovered c64 from GitHub.
-      // Real database recovery is verified separately by the route integration checks.
-      cy.intercept('POST', '/api/gpu-metrics*', {
-        body: { ...response, source: 'github' },
-      }).as('series');
-      mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('b200', 64, 900)], {
-        pathname,
-        width: width === 390 ? 324 : 1100,
-      });
-      cy.wait('@series').then(({ request }) => {
-        expect(request.body.sources).to.deep.equal([
-          `power_validation_${resultName('b200', 16)}.json`,
-          `power_validation_${resultName('b200', 64)}.json`,
-        ]);
-      });
-      svg().find('path.power-trace[data-segment="window"]').should('have.length', 2);
-      svg().find('text.power-trace-label').should('contain.text', 'c16').and('contain.text', 'c64');
-      cy.get('[data-testid="power-timeline-missing"]').should('not.exist');
-      cy.get('[data-testid="power-timeline-empty"]').should('not.exist');
-      if (pathname.startsWith('/zh')) {
-        cy.get('[data-testid="power-timeline-toolbar"]').should('contain.text', '时间轴');
-      }
-      svg().screenshot(`power-timeline-hybrid-${width === 390 ? 'zh-mobile' : 'en-desktop'}`);
-    });
-  }
-
   it('colours overlay-run traces by run and honours the overlay hardware filter', () => {
     const overlayPoint = measuredPoint('h200', 16, 500, {
       run_url: OVERLAY_RUN_URL,
@@ -483,398 +181,4 @@ describe('PowerTimeline', () => {
     });
     cy.get('[data-testid="chart-legend"]').should('contain.text', '✕ powerx-timeline');
   });
-
-  it('solos an official row through the unified overlay selection while an overlay is loaded', () => {
-    // localOfficialOverride shadows activeHwTypes once an overlay is in, so the
-    // context toggle would be invisible: the legend must write both selections.
-    const overlayPoint = measuredPoint('h200', 16, 500, {
-      run_url: OVERLAY_RUN_URL,
-      power_audit: {
-        source: `power_validation_${resultName('h200', 16)}.json`,
-        ...WINDOW,
-      },
-    });
-    cy.intercept('POST', '/api/gpu-metrics*', { body: response }).as('series');
-    mountTimeline([measuredPoint('b200', 16, 700), measuredPoint('h100', 16, 600)], {
-      overlay: {
-        data: [overlayPoint],
-        hardwareConfig: hwConfig,
-        label: 'powerx-timeline',
-        runUrl: OVERLAY_RUN_URL,
-      },
-      // Plain overrides: mountWithProviders builds the context itself, so the
-      // aliased stubs below are the ones the component receives.
-      unofficial: {
-        isUnofficialRun: true,
-        unofficialRunInfos: [
-          {
-            id: Number(OVERLAY_RUN_ID),
-            name: 'powerx-timeline',
-            branch: 'powerx-timeline',
-            sha: 'abc000',
-            createdAt: '2026-09-12T00:00:00Z',
-            url: OVERLAY_RUN_URL,
-            conclusion: 'success',
-            status: 'completed',
-            isNonMainBranch: true,
-          },
-        ],
-        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
-        activeOverlayHwTypes: new Set(['h200']),
-      },
-    });
-    cy.wait('@series');
-
-    cy.get('[data-testid="chart-legend"] label[for="checkbox-b200"]').click();
-    cy.get('@setUnifiedOverlaySelection')
-      .should('have.been.calledOnce')
-      .then((stub) => {
-        const [official, overlay] = (stub as unknown as sinon.SinonStub).firstCall.args as [
-          Set<string>,
-          Set<string>,
-        ];
-        expect([...official]).to.deep.equal(['b200']);
-        expect([...overlay]).to.deep.equal(['h200']);
-      });
-  });
-
-  it('keeps ?unofficialrun= overlay telemetry inside the per-chart run cap', () => {
-    // Four official runs already fill the cap and all sort before the overlay run
-    // id: the overlay the user asked for is fetched anyway and the last official
-    // run (by id) is the one left out.
-    const officialRuns = ['30000000001', '30000000002', '30000000003', '30000000004'];
-    const officialPoints = officialRuns.map((runId, index) =>
-      measuredPoint('b200', 8 * 2 ** index, 700, { run_url: runUrlFor(runId) }),
-    );
-    officialRuns.forEach((runId, index) => {
-      cy.intercept('POST', `/api/gpu-metrics?runId=${runId}*`, {
-        body: {
-          runInfo: { ...response.runInfo, id: Number(runId), url: runUrlFor(runId) },
-          series: [series('b200', 8 * 2 ** index, 700)],
-        } satisfies GpuPowerSeriesResponse,
-      }).as(`official${index}`);
-    });
-    const overlayPoint = measuredPoint('h200', 16, 500, {
-      run_url: OVERLAY_RUN_URL,
-      power_audit: {
-        source: `power_validation_${resultName('h200', 16)}.json`,
-        ...WINDOW,
-      },
-    });
-    cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
-      body: {
-        runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
-        series: [series('h200', 16, 500)],
-      } satisfies GpuPowerSeriesResponse,
-    }).as('overlay');
-    mountTimeline(officialPoints, {
-      overlay: {
-        data: [overlayPoint],
-        hardwareConfig: hwConfig,
-        label: 'powerx-timeline',
-        runUrl: OVERLAY_RUN_URL,
-      },
-      unofficial: createMockUnofficialRunContext({
-        isUnofficialRun: true,
-        unofficialRunInfos: [
-          {
-            id: Number(OVERLAY_RUN_ID),
-            name: 'powerx-timeline',
-            branch: 'powerx-timeline',
-            sha: 'abc000',
-            createdAt: '2026-09-12T00:00:00Z',
-            url: OVERLAY_RUN_URL,
-            conclusion: 'success',
-            status: 'completed',
-            isNonMainBranch: true,
-          },
-        ],
-        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
-        activeOverlayHwTypes: new Set(['h200']),
-      }),
-    });
-    cy.wait(['@overlay', '@official0', '@official1', '@official2']);
-
-    cy.get('[data-testid="power-timeline-status"]').should(
-      'contain.text',
-      'Telemetry from 1 more run was not loaded',
-    );
-    cy.get('@official3.all').should('have.length', 0);
-    svg().within(() => {
-      cy.get('path.power-trace[data-run-index="0"][data-segment="window"]')
-        .should('have.length', 1)
-        .and('have.attr', 'stroke', overlayRunColor(0));
-      cy.get('path.power-trace[data-hw="b200"][data-segment="window"]').should('have.length', 3);
-    });
-  });
-
-  it('reports a failed run and hides traces the legend has switched off', () => {
-    cy.intercept('POST', '/api/gpu-metrics*', {
-      statusCode: 500,
-      body: { error: 'No gpu_metrics artifacts found for this run' },
-    }).as('failed');
-    mountTimeline([measuredPoint('b200', 16, 700)]);
-    cy.wait('@failed');
-    cy.get('[data-testid="power-timeline-status"] [role="alert"]').should(
-      'contain.text',
-      `Run ${RUN_ID}: No gpu_metrics artifacts found for this run`,
-    );
-    cy.get('[data-testid="power-timeline-chart-svg"] path.power-trace').should('not.exist');
-    cy.get('[data-testid="power-timeline-empty"]').should('contain.text', 'No telemetry traces');
-  });
-
-  it('translates the toolbar, legend switches and status on /zh', () => {
-    cy.intercept('POST', '/api/gpu-metrics*', { body: response }).as('series');
-    mountTimeline([measuredPoint('b200', 16, 700)], { pathname: '/zh/inference' });
-    cy.wait('@series');
-    cy.get('[data-testid="power-timeline-toolbar"]').should('contain.text', '时间轴');
-    cy.get('[data-testid="power-timeline-axis-wall"]').should('contain.text', '实际时刻');
-    cy.get('[data-testid="chart-legend"]').should('contain.text', '每个 GPU 一条线');
-    cy.get('[data-testid="power-timeline-status"]').should('contain.text', '遥测来源');
-    cy.get('[data-testid="power-timeline-chart-svg"] text').contains('时间（UTC）').should('exist');
-  });
-
-  it('sums prefill and decode pools against pool-sized TDP references in pool mode', () => {
-    cy.intercept('POST', '/api/gpu-metrics*', { body: poolResponse }).as('series');
-    mountTimeline([measuredPoint('b200', 16, 700), disaggPoint(8, 800)]);
-    cy.wait('@series');
-
-    // Mean mode treats the bundle-cut trace like any other: one line, per-GPU TDP.
-    svg().within(() => {
-      cy.get('path.power-trace[data-hw="gb200"][data-segment="full"]').should('have.length', 1);
-      cy.get('path.power-trace[data-pool]').should('not.exist');
-      cy.get(`.power-reference[data-reference="tdp"][data-watts="${GB200_TDP}"]`).should('exist');
-      cy.get('.power-reference[data-pool]').should('not.exist');
-    });
-    cy.get('[data-testid="power-timeline-missing"]').should('not.exist');
-
-    cy.get('[data-testid="power-timeline-pools"]').should('exist').click();
-    cy.get('[data-testid="power-timeline-per-gpu"]').should('have.attr', 'data-state', 'unchecked');
-    svg().within(() => {
-      // One dashed line per pool, full job plus window emphasis.
-      cy.get('path.power-trace[data-pool="prefill"]')
-        .should('have.length', 2)
-        .each(($path) => expect($path.attr('stroke-dasharray')).to.eq('7 3'));
-      cy.get('path.power-trace[data-pool="decode"]')
-        .should('have.length', 2)
-        .each(($path) => expect($path.attr('stroke-dasharray')).to.eq('2 3'));
-      // The single-node trace falls back to its whole deployment as one solid pool.
-      cy.get('path.power-trace[data-hw="b200"][data-pool="all"]')
-        .should('have.length', 2)
-        .and('not.have.attr', 'stroke-dasharray');
-      cy.get('path.power-trace[data-hw="gb200"][data-segment="window"]').should('have.length', 2);
-
-      // References scale to the pool: both GB200 pools hold 4 GPUs, so they
-      // share one ceiling and one label instead of two printed over each other;
-      // 2 × rated TDP for the B200 pair.
-      cy.get('.power-reference[data-reference="tdp"][data-pool="prefill decode"]')
-        .should('have.attr', 'data-watts', String(4 * GB200_TDP))
-        .find('text')
-        .should('contain.text', `GB200 NVL72 prefill / decode ×4 TDP ${4 * GB200_TDP} W`);
-      cy.get('.power-reference[data-reference="tdp"][data-pool="all"]')
-        .should('have.attr', 'data-watts', String(2 * HW_REGISTRY.b200.tdp))
-        .find('text')
-        .should('contain.text', 'B200 all GPUs ×2 TDP');
-      cy.get('.power-reference[data-reference="tdp"]').should('have.length', 2);
-
-      // End labels name the pool; the axis reads pool watts.
-      cy.get('text.power-trace-label[data-pool="prefill"]').should('contain.text', 'c8 · prefill');
-      cy.get('text.power-trace-label[data-pool="decode"]').should('contain.text', 'c8 · decode');
-      cy.get('text.power-trace-label[data-hw="b200"]').should('contain.text', 'c16 · all GPUs');
-      cy.get('text').contains('GPU pool power (W)').should('exist');
-    });
-
-    // Hover a prefill hit point: the B200 pool stream comes first (61 buckets), then prefill.
-    cy.get('[data-testid="power-timeline-chart-svg"] circle.point').eq(61).trigger('mouseenter');
-    cy.get('[data-chart-tooltip]')
-      .should('contain.text', 'GB200 NVL72 · PD · TP4 · c8')
-      .and('contain.text', 'Pool: prefill · 4 GPUs')
-      .and(
-        'contain.text',
-        `Pool power: 1,200 W (${Math.round((1200 / (4 * GB200_TDP)) * 100)}% pool TDP)`,
-      )
-      .and('contain.text', 'Mean per GPU: 300.0 W · min 300.0 W · max 300.0 W')
-      .and('contain.text', 'Before window');
-
-    // The all-in switch also scales to the pool.
-    cy.get('[data-testid="power-timeline-utility"]').click();
-    svg()
-      .find('.power-reference[data-reference="utility"][data-pool~="prefill"]')
-      .should('have.attr', 'data-watts', String(4 * Math.round(HW_REGISTRY.gb200.power * 1000)));
-
-    // Per-GPU and pools are mutually exclusive; per-GPU restores the per-GPU TDP line.
-    cy.get('[data-testid="power-timeline-per-gpu"]').click();
-    cy.get('[data-testid="power-timeline-pools"]').should('have.attr', 'data-state', 'unchecked');
-    svg().within(() => {
-      cy.get('path.power-trace[data-pool]').should('not.exist');
-      cy.get('path.power-trace[data-hw="gb200"][data-segment="full"]').should('have.length', 8);
-      cy.get(`.power-reference[data-reference="tdp"][data-watts="${GB200_TDP}"]`).should('exist');
-      cy.get('text').contains('Measured Average Power per Chip over Time (W)').should('exist');
-    });
-  });
-
-  it('keeps separate pool references when prefill and decode pools differ in size', () => {
-    cy.intercept('POST', '/api/gpu-metrics*', {
-      body: {
-        runInfo: response.runInfo,
-        series: [poolSeries(8, 6)],
-      } satisfies GpuPowerSeriesResponse,
-    }).as('series');
-    mountTimeline([disaggPoint(8, 800)]);
-    cy.wait('@series');
-    cy.get('[data-testid="power-timeline-pools"]').click();
-
-    svg().within(() => {
-      cy.get('.power-reference[data-reference="tdp"][data-pool="prefill"]')
-        .should('have.attr', 'data-watts', String(6 * GB200_TDP))
-        .find('text')
-        .should('contain.text', `GB200 NVL72 prefill ×6 TDP ${6 * GB200_TDP} W`);
-      cy.get('.power-reference[data-reference="tdp"][data-pool="decode"]')
-        .should('have.attr', 'data-watts', String(2 * GB200_TDP))
-        .find('text')
-        .should('contain.text', `GB200 NVL72 decode ×2 TDP ${2 * GB200_TDP} W`);
-      cy.get('.power-reference[data-reference="tdp"]').should('have.length', 2);
-    });
-  });
-
-  it('draws an overlay-run pool trace in the run colour', () => {
-    const overlayPoint = disaggPoint(8, 800, { run_url: OVERLAY_RUN_URL });
-    const overlayResponse: GpuPowerSeriesResponse = {
-      runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
-      series: [poolSeries(8)],
-    };
-    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
-    cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
-      body: overlayResponse,
-    }).as('overlay');
-    mountTimeline([measuredPoint('b200', 16, 700)], {
-      overlay: {
-        data: [overlayPoint],
-        hardwareConfig: hwConfig,
-        label: 'powerx-pools',
-        runUrl: OVERLAY_RUN_URL,
-      },
-      unofficial: createMockUnofficialRunContext({
-        isUnofficialRun: true,
-        unofficialRunInfos: [
-          {
-            id: Number(OVERLAY_RUN_ID),
-            name: 'powerx-pools',
-            branch: 'powerx-pools',
-            sha: 'abc000',
-            createdAt: '2026-09-12T00:00:00Z',
-            url: OVERLAY_RUN_URL,
-            conclusion: 'success',
-            status: 'completed',
-            isNonMainBranch: true,
-          },
-        ],
-        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
-        activeOverlayHwTypes: new Set(['gb200']),
-      }),
-    });
-    cy.wait(['@official', '@overlay']);
-
-    cy.get('[data-testid="power-timeline-pools"]').click();
-    svg().within(() => {
-      cy.get('path.power-trace[data-run-index="0"][data-pool="prefill"][data-segment="window"]')
-        .should('have.length', 1)
-        .and('have.attr', 'stroke', overlayRunColor(0))
-        .and('have.attr', 'stroke-dasharray', '7 3');
-      cy.get('path.power-trace[data-run-index="0"][data-pool="decode"]').should('have.length', 2);
-      cy.get('.power-reference[data-reference="tdp"][data-pool~="prefill"] line').should(
-        'have.attr',
-        'stroke',
-        overlayRunColor(0),
-      );
-      // The official trace keeps its hardware colour and solid all-GPU pool.
-      cy.get('path.power-trace[data-hw="b200"][data-pool="all"][data-segment="window"]')
-        .should('have.length', 1)
-        .and('not.have.attr', 'stroke', overlayRunColor(0));
-      cy.get('path.power-trace[data-hw="b200"][data-pool="all"][stroke-dasharray]').should(
-        'not.exist',
-      );
-      cy.get('.power-reference[data-reference="tdp"][data-pool="all"] line').should(
-        'not.have.attr',
-        'stroke',
-        overlayRunColor(0),
-      );
-    });
-    cy.get('[data-testid="chart-legend"]').should('contain.text', '✕ powerx-pools');
-  });
-
-  it('focuses the deep-linked trace, opens pool mode for it and clears on request', () => {
-    const disagg = disaggPoint(8, 800);
-    requestPowerTraceFocus(traceKeyForPoint(disagg)!);
-    cy.intercept('POST', '/api/gpu-metrics*', { body: poolResponse }).as('series');
-    mountTimeline([measuredPoint('b200', 16, 700), disagg]);
-    cy.wait('@series');
-
-    cy.get('[data-testid="power-timeline-focus"]').should(
-      'contain.text',
-      'Focused on GB200 NVL72 · PD · TP4 · c8',
-    );
-    // A pooled trace opens in pool mode without touching the switch.
-    cy.get('[data-testid="power-timeline-pools"]').should('have.attr', 'data-state', 'checked');
-    svg().within(() => {
-      cy.get('path.power-trace[data-pool="prefill"]').should('exist');
-      cy.get('path.power-trace[data-hw="gb200"][data-segment="window"]').each(($path) =>
-        expect($path.attr('opacity')).to.eq('1'),
-      );
-      cy.get('text.power-trace-label[data-hw="gb200"]').each(($label) =>
-        expect($label.attr('opacity')).to.eq('1'),
-      );
-      // Every other trace dims: labels to 0.2, lines to 15 % of their weight.
-      cy.get('text.power-trace-label[data-hw="b200"]').should('have.attr', 'opacity', '0.2');
-      cy.get('path.power-trace[data-hw="b200"][data-segment="window"]').should(
-        'have.attr',
-        'opacity',
-        '0.15',
-      );
-    });
-
-    cy.get('[data-testid="power-timeline-focus-clear"]').should('contain.text', 'Show all').click();
-    cy.get('[data-testid="power-timeline-focus"]').should('not.exist');
-    svg().within(() => {
-      cy.get('text.power-trace-label[data-hw="b200"]').should('have.attr', 'opacity', '1');
-      cy.get('path.power-trace[data-hw="b200"][data-segment="window"]').should(
-        'have.attr',
-        'opacity',
-        '1',
-      );
-      // Pool mode stays: clearing the focus only restores the other traces.
-      cy.get('path.power-trace[data-pool="prefill"]').should('exist');
-    });
-  });
-
-  it('translates the pool switch, pool labels and focus chip on /zh', () => {
-    const disagg = disaggPoint(8, 800);
-    requestPowerTraceFocus(traceKeyForPoint(disagg)!);
-    cy.intercept('POST', '/api/gpu-metrics*', { body: poolResponse }).as('series');
-    mountTimeline([disagg], { pathname: '/zh/inference' });
-    cy.wait('@series');
-
-    cy.get('[data-testid="chart-legend"]').should('contain.text', '预填充 / 解码 GPU 池');
-    cy.get('[data-testid="power-timeline-pools"]').should('have.attr', 'data-state', 'checked');
-    svg().within(() => {
-      cy.get('text').contains('GPU 池功耗（W）').should('exist');
-      cy.get('text.power-trace-label[data-pool="prefill"]').should('contain.text', 'c8 · 预填充');
-      cy.get('text.power-trace-label[data-pool="decode"]').should('contain.text', 'c8 · 解码');
-      cy.get('.power-reference[data-reference="tdp"][data-pool~="decode"] text').should(
-        'contain.text',
-        `GB200 NVL72 预填充 / 解码 ×4 TDP ${4 * GB200_TDP} W`,
-      );
-    });
-    cy.get('[data-testid="power-timeline-focus"]')
-      .should('contain.text', '聚焦：GB200 NVL72 · PD · TP4 · c8')
-      .find('[data-testid="power-timeline-focus-clear"]')
-      .should('contain.text', '显示全部');
-    cy.get('[data-testid="power-timeline-status"]').should('contain.text', 'GPU 池模式');
-
-    cy.get('[data-testid="power-timeline-chart-svg"] circle.point').first().trigger('mouseenter');
-    cy.get('[data-chart-tooltip]')
-      .should('contain.text', 'GPU 池： 预填充 · 4 个 GPU')
-      .and('contain.text', '池功耗： 1,200 W')
-      .and('contain.text', '池 TDP');
-  });
 });
diff --git a/packages/app/cypress/component/scatter-graph.cy.tsx b/packages/app/cypress/component/scatter-graph.cy.tsx
index 71dbdfca2..fac02fad5 100644
--- a/packages/app/cypress/component/scatter-graph.cy.tsx
+++ b/packages/app/cypress/component/scatter-graph.cy.tsx
@@ -1,12 +1,6 @@
 import { useReducer, useState } from 'react';
 import { GlobalFilterSelectionContext } from '@/components/GlobalFilterContext';
 import { InferenceContextsProvider } from '@/components/inference/InferenceContext';
-import {
-  PerfRulerStoreContext,
-  usePerfRulerStoreValue,
-} from '@/components/inference/perf-ruler-store';
-import { perfRulerAxisMetricKey } from '@/hooks/usePerfRulerAxisReset';
-import { serializePerfRulers } from '@/lib/d3-chart/layers/perf-ruler';
 import {
   overlaySelectionReducer,
   UnofficialRunContext,
@@ -31,19 +25,6 @@ import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.share
 const defaultChartDef = createMockChartDefinition();
 const hwConfig = createMockHardwareConfig();
 
-/** FP4 curve through x = 8, 16, 32 with distinct `conc` join keys. */
-const threePointCurve = (hwKey: string, ys: number[], extra: Partial<{ run_url: string }> = {}) =>
-  ys.map((y, index) =>
-    createMockInferenceData({
-      hwKey,
-      x: [8, 16, 32][index],
-      y,
-      conc: [8, 16, 32][index],
-      precision: Precision.FP4,
-      ...extra,
-    }),
-  );
-
 describe('ScatterGraph', () => {
   it('keeps the frontier modes and overlay winners without exposing the retired hinterland', () => {
     const official = [
@@ -1140,107 +1121,6 @@ describe('ScatterGraph', () => {
     ).should('have.css', 'opacity', '1');
   });
 
-  it('tags overlay line labels with the run only when several runs draw the same hardware', () => {
-    const interactivityChartDef = createMockChartDefinition({
-      chartType: 'interactivity',
-      y_tpPerGpu_roofline: 'upper_left',
-    });
-    const runs = [
-      { id: 31756025413, branch: 'main' },
-      {
-        id: 35319956855,
-        branch: 'klaud/qwen3.5-fp8-gb200-dynamo-sglang-nightly-dev-cu13-20260918-20518d85',
-      },
-    ].map((run) => ({
-      ...run,
-      url: `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${run.id}`,
-    }));
-    const overlayData = {
-      data: runs.flatMap((run, index) =>
-        [8, 16, 32].map((x, i) =>
-          createMockInferenceData({
-            hwKey: 'b200_trt',
-            x,
-            y: [320, 280, 220][i] - index * 60,
-            precision: Precision.FP4,
-            run_url: run.url,
-          }),
-        ),
-      ),
-      hardwareConfig: hwConfig,
-      label: runs[0].branch,
-      runUrl: runs[0].url,
-    };
-
-    mountWithProviders(
-      <div style={{ width: 800, height: 600 }}>
-        <ScatterGraph
-          chartId="test-scatter-overlay-run-tags"
-          modelLabel="DeepSeek R1"
-          data={[]}
-          xLabel="Concurrency"
-          yLabel="Throughput / Chip (tok/s)"
-          chartDefinition={interactivityChartDef}
-          overlayData={overlayData}
-        />
-      </div>,
-      {
-        inference: {
-          hardwareConfig: hwConfig,
-          activeHwTypes: new Set<string>(),
-          hwTypesWithData: new Set<string>(),
-          selectedPrecisions: [Precision.FP4],
-          showLineLabels: true,
-        },
-        unofficial: {
-          activeOverlayHwTypes: new Set(['b200_trt']),
-          allOverlayHwTypes: new Set(['b200_trt']),
-          runIndexByUrl: Object.fromEntries(
-            runs.flatMap((run, index) => [
-              [run.url, index],
-              [String(run.id), index],
-            ]),
-          ),
-          unofficialRunInfos: runs.map((run) => ({
-            id: run.id,
-            name: 'CI run',
-            branch: run.branch,
-            sha: '7a4a06b',
-            createdAt: '2026-09-18T19:40:51Z',
-            url: run.url,
-            conclusion: 'success',
-            status: 'completed',
-            isNonMainBranch: run.branch !== 'main',
-          })),
-        },
-      },
-    );
-
-    // No official hardware is active, yet both overlay pills stay visible: they
-    // follow the overlay legend rows, not the official ones.
-    cy.get('#test-scatter-overlay-run-tags svg .line-label[data-line-key^="overlay-"]')
-      .should('have.length', 2)
-      .each(($label) => {
-        expect($label.attr('data-visible')).to.eq('1');
-        expect($label.css('opacity')).to.eq('1');
-      });
-    // Same hardware from two runs: each pill carries a short run tag, the
-    // long klaud branch shortened to its date-sha tail.
-    cy.get('#test-scatter-overlay-run-tags svg .line-label[data-line-key^="overlay-"] .ll-text')
-      .should('have.length', 2)
-      .then(($labels) => {
-        expect($labels.toArray().map((label) => label.textContent)).to.have.members([
-          '✕ B200 (TRTLLM) · main',
-          '✕ B200 (TRTLLM) · …20260918-20518d85',
-        ]);
-        for (const label of $labels) {
-          expect(
-            [...label.querySelectorAll('tspan')].map((segment) => segment.className.baseVal),
-          ).to.deep.equal(['ll-marker', 'll-gpu', 'll-engine', 'll-run']);
-        }
-      });
-  });
-
   it('renders a line label for a singleton ingested hardware series', () => {
     const interactivityChartDef = createMockChartDefinition({
       chartType: 'interactivity',
@@ -1846,213 +1726,6 @@ describe('ScatterGraph', () => {
     expectCurvesIntact();
     placeRuler();
   });
-
-  it('restores share-link perf rulers from the provider store once their curves render', () => {
-    const chartId = 'chart-0';
-    const runUrl = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/777';
-    // Three-point curves with a 2x (official pair) and 4x (official vs
-    // overlay) ratio at every knot, so the restored ruler at x=16 reads
-    // exactly on both.
-    const b200 = threePointCurve('b200_sglang', [400, 300, 200]);
-    const h100 = threePointCurve('h100_vllm', [200, 150, 100]);
-    const overlay = threePointCurve('b200_vllm', [100, 75, 50], { run_url: runUrl });
-    const chartDefinition = createMockChartDefinition({
-      chartType: 'interactivity',
-      y_tpPerGpu_roofline: 'upper_left',
-    });
-    const OFFICIAL_RULER = '16|roofline-b200_sglang_fp4|roofline-h100_vllm_fp4';
-    const OVERLAY_RULER = '16|roofline-b200_sglang_fp4|overlay-roofline-b200_vllm_fp4_run0';
-    // The overlay run carries its own hardware config; a roofline is only
-    // drawn for hardware that config knows, so the run's vLLM B200 needs an
-    // entry of its own.
-    const overlayHwConfig = { ...hwConfig, b200_vllm: hwConfig.b200_sglang };
-    const baseInference = createMockInferenceContextValues();
-
-    function StoreHarness() {
-      // The h100 curve arrives after the first draw, like `i_gpus` or a
-      // comparison date resolving on a real share-link load.
-      const [h100Loaded, setH100Loaded] = useState(false);
-      const [overlayDismissed, setOverlayDismissed] = useState(false);
-      const store = usePerfRulerStoreValue(
-        chartId,
-        `${OFFICIAL_RULER};${OVERLAY_RULER}`,
-        perfRulerAxisMetricKey(chartDefinition.x_scale_field, 'y_tpPerGpu'),
-      );
-      const inference = {
-        ...baseInference,
-        hardwareConfig: hwConfig,
-        activeHwTypes: new Set(['b200_sglang', 'h100_vllm']),
-        hwTypesWithData: new Set(h100Loaded ? ['b200_sglang', 'h100_vllm'] : ['b200_sglang']),
-        selectedModel: Model.DeepSeek_V4_Pro,
-        selectedSequence: Sequence.AgenticTraces,
-        selectedPrecisions: [Precision.FP4],
-        selectedYAxisMetric: 'y_tpPerGpu',
-      };
-      const unofficial = createMockUnofficialRunContext({
-        isUnofficialRun: true,
-        activeOverlayHwTypes: new Set(['b200_vllm']),
-        allOverlayHwTypes: new Set(['b200_vllm']),
-        runIndexByUrl: { [runUrl]: 0, '777': 0 },
-      });
-      const overlayData = overlayDismissed
-        ? undefined
-        : { data: overlay, hardwareConfig: overlayHwConfig, label: 'Overlay', runUrl };
-      return (
-        <InferenceContextsProvider
-          data={inference}
-          filters={inference}
-          display={inference}
-          actions={inference}
-        >
-          <UnofficialRunContext.Provider value={unofficial}>
-            <PerfRulerStoreContext.Provider value={store}>
-              <button data-testid="load-h100" onClick={() => setH100Loaded(true)}>
-                Load h100
-              </button>
-              <button data-testid="dismiss-overlay" onClick={() => setOverlayDismissed(true)}>
-                Dismiss overlay
-              </button>
-              <output data-testid="i-rulers">{serializePerfRulers(store.state)}</output>
-              <output data-testid="pending-count">{store.pending?.length ?? 0}</output>
-              <div style={{ width: 800, height: 600 }}>
-                <ScatterGraph
-                  chartId={chartId}
-                  modelLabel={Model.DeepSeek_V4_Pro}
-                  data={h100Loaded ? [...b200, ...h100] : b200}
-                  xLabel="Interactivity"
-                  yLabel="Throughput / Chip (tok/s)"
-                  chartDefinition={chartDefinition}
-                  overlayData={overlayData}
-                  transitionDuration={0}
-                />
-              </div>
-              {/* The replay chart draws the same curve classes under the same
-                  provider and must not pick the persisted rulers up. */}
-              <div style={{ width: 800, height: 600 }}>
-                <ScatterGraph
-                  chartId={`replay-${chartId}`}
-                  modelLabel={Model.DeepSeek_V4_Pro}
-                  data={[...b200, ...h100]}
-                  xLabel="Interactivity"
-                  yLabel="Throughput / Chip (tok/s)"
-                  chartDefinition={chartDefinition}
-                  transitionDuration={0}
-                />
-              </div>
-            </PerfRulerStoreContext.Provider>
-          </UnofficialRunContext.Provider>
-        </InferenceContextsProvider>
-      );
-    }
-
-    mountWithProviders(<StoreHarness />);
-
-    // Nobody clicked anything: the mode is on for the persisted chart only,
-    // the overlay pair renders (both curves exist), and the official pair
-    // waits for its second curve instead of being pruned. Advanced switches
-    // only mount once each legend's drawer is open.
-    cy.get(`#${chartId} svg .roofline-path`).should('have.length', 1);
-    cy.get('[data-testid="legend-advanced-toggle"]')
-      .should('have.length', 2)
-      .click({ multiple: true });
-    // Two charts render the switch under one id; jQuery's `#id` fast path
-    // returns only the first match, so select by attribute.
-    cy.get('[id="scatter-perf-ruler"]').should('have.length', 2);
-    cy.get('[id="scatter-perf-ruler"]').first().should('have.attr', 'aria-checked', 'true');
-    cy.get(`#${chartId} svg .perf-ruler`).should('have.length', 1);
-    cy.get(`#${chartId} svg .perf-ruler .pr-text-ratio`).should('have.text', '4.00x');
-    cy.get('[data-testid="i-rulers"]').should('have.text', OVERLAY_RULER);
-    cy.get('[data-testid="pending-count"]').should('have.text', '1');
-    cy.get(`#replay-${chartId} svg .roofline-path`).should('have.length', 2);
-    cy.get(`#replay-${chartId} svg .perf-ruler`).should('not.exist');
-    cy.get('[id="scatter-perf-ruler"]').eq(1).should('have.attr', 'aria-checked', 'false');
-
-    // The late curve arrives: the pending ruler commits and both render.
-    cy.get('[data-testid="load-h100"]').click();
-    cy.get(`#${chartId} svg .roofline-path`).should('have.length', 2);
-    cy.get(`#${chartId} svg .perf-ruler`).should('have.length', 2);
-    cy.get(`#${chartId} svg .perf-ruler .pr-text-ratio`).then(($labels) => {
-      expect([...$labels].map((label) => label.textContent).sort()).to.deep.equal([
-        '2.00x',
-        '4.00x',
-      ]);
-    });
-    cy.get('[data-testid="pending-count"]').should('have.text', '0');
-    cy.get('[data-testid="i-rulers"]').should('have.text', `${OVERLAY_RULER};${OFFICIAL_RULER}`);
-    cy.get(`#replay-${chartId} svg .perf-ruler`).should('not.exist');
-
-    // Dismissing the overlay run prunes only the ruler that referenced it.
-    cy.get('[data-testid="dismiss-overlay"]').click();
-    cy.get(`#${chartId} svg .overlay-roofline-path`).should('not.exist');
-    cy.get(`#${chartId} svg .perf-ruler`).should('have.length', 1);
-    cy.get(`#${chartId} svg .perf-ruler .pr-text-ratio`).should('have.text', '2.00x');
-    cy.get('[data-testid="i-rulers"]').should('have.text', OFFICIAL_RULER);
-
-    // Toggling the tool off clears the persisted rulers, so the share link
-    // drops the param.
-    cy.get('[id="scatter-perf-ruler"]').first().click({ force: true });
-    cy.get(`#${chartId} svg .perf-ruler`).should('not.exist');
-    cy.get('[data-testid="i-rulers"]').should('have.text', '');
-  });
-
-  it('discards pending share-link rulers when the tool is switched off before their curves load', () => {
-    const chartId = 'chart-0';
-    const chartDefinition = createMockChartDefinition({
-      chartType: 'interactivity',
-      y_tpPerGpu_roofline: 'upper_left',
-    });
-    const b200 = [8, 16, 32].map((x, index) =>
-      createMockInferenceData({ hwKey: 'b200_sglang', x, y: 400 - index * 100, conc: x }),
-    );
-    const baseInference = createMockInferenceContextValues();
-
-    function PendingHarness() {
-      const store = usePerfRulerStoreValue(
-        chartId,
-        '16|roofline-b200_sglang_fp4|roofline-h100_vllm_fp4',
-        perfRulerAxisMetricKey(chartDefinition.x_scale_field, 'y_tpPerGpu'),
-      );
-      const inference = {
-        ...baseInference,
-        hardwareConfig: hwConfig,
-        activeHwTypes: new Set(['b200_sglang']),
-        hwTypesWithData: new Set(['b200_sglang']),
-        selectedYAxisMetric: 'y_tpPerGpu',
-      };
-      return (
-        <InferenceContextsProvider
-          data={inference}
-          filters={inference}
-          display={inference}
-          actions={inference}
-        >
-          <PerfRulerStoreContext.Provider value={store}>
-            <output data-testid="pending-count">{store.pending?.length ?? 0}</output>
-            <div style={{ width: 800, height: 600 }}>
-              <ScatterGraph
-                chartId={chartId}
-                modelLabel={Model.DeepSeek_V4_Pro}
-                data={b200}
-                xLabel="Interactivity"
-                yLabel="Throughput / Chip (tok/s)"
-                chartDefinition={chartDefinition}
-                transitionDuration={0}
-              />
-            </div>
-          </PerfRulerStoreContext.Provider>
-        </InferenceContextsProvider>
-      );
-    }
-
-    mountWithProviders(<PendingHarness />, { unofficial: {} });
-    cy.get(`#${chartId} svg .roofline-path`).should('have.length', 1);
-    expandLegendAdvanced();
-    cy.get('#scatter-perf-ruler').should('have.attr', 'aria-checked', 'true');
-    cy.get('[data-testid="pending-count"]').should('have.text', '1');
-    cy.get('#scatter-perf-ruler').click({ force: true });
-    cy.get('#scatter-perf-ruler').should('have.attr', 'aria-checked', 'false');
-    cy.get('[data-testid="pending-count"]').should('have.text', '0');
-  });
 });
 
 describe('ChartDisplay responsive status notes', () => {
diff --git a/packages/app/cypress/e2e/gpu-compare-agentic-detail.cy.ts b/packages/app/cypress/e2e/gpu-compare-agentic-detail.cy.ts
index fae2d640a..d643a2d44 100644
--- a/packages/app/cypress/e2e/gpu-compare-agentic-detail.cy.ts
+++ b/packages/app/cypress/e2e/gpu-compare-agentic-detail.cy.ts
@@ -234,39 +234,4 @@ describe('GPU comparison agentic point detail', () => {
       .and('not.contain.text', 'SGLang');
     cy.contains('button', 'Jun 12, 2026').should('be.visible');
   });
-
-  it('opens PowerX from a comparison point while the chart legend is collapsed', () => {
-    cy.intercept('GET', '/api/v1/availability', { body: agenticAvailability });
-    cy.intercept('GET', '/api/v1/benchmarks*', { body: agenticBenchmarks });
-    cy.intercept('GET', '/api/v1/gpu-metrics-point*', { statusCode: 404 }).as('pointTelemetry');
-    cy.intercept('GET', '/api/v1/trace-server-metrics*', { statusCode: 404 });
-    interceptDerivedAgenticMetrics();
-    cy.visit(
-      '/inference?g_model=DeepSeek-V4-Pro&i_seq=agentic-traces&i_prec=fp4&i_gpus=b200_vllm&i_dates=2026-06-12&i_dstart=2026-06-12&i_dend=2026-06-12',
-      {
-        onBeforeLoad(win) {
-          win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
-          unlockAgenticGate(win);
-        },
-      },
-    );
-    cy.get('[data-testid="gpu-graph"]')
-      .first()
-      .within(() => {
-        cy.get('[data-testid="legend-close-button"]').click();
-        cy.get('[data-testid="legend-open-button"]').should('be.visible');
-        cy.get('svg .dot-group').first().find('.visible-shape').click({ force: true });
-      });
-    cy.get('[data-chart-tooltip]:visible [data-action="view-power-telemetry"]').click();
-    cy.wait('@pointTelemetry').then(({ request }) => {
-      const id = Number(new URL(request.url).searchParams.get('id'));
-      expect(agenticIds.has(id)).to.eq(true);
-      cy.get('[data-testid="power-telemetry-dialog"]').should('contain.text', `#${id}`);
-    });
-    cy.get('[data-testid="power-telemetry-missing"]').should('be.visible');
-    cy.get('[data-testid="power-telemetry-dialog"]').contains('button', 'Close').click();
-    cy.get('[data-testid="power-telemetry-dialog"]').should('not.exist');
-    cy.get('[data-testid="gpu-graph"] [data-testid="legend-open-button"]').should('be.visible');
-    cy.location('pathname').should('eq', '/inference');
-  });
 });
diff --git a/packages/app/cypress/e2e/gpu-power.cy.ts b/packages/app/cypress/e2e/gpu-power.cy.ts
index 3449ecd82..eb769267b 100644
--- a/packages/app/cypress/e2e/gpu-power.cy.ts
+++ b/packages/app/cypress/e2e/gpu-power.cy.ts
@@ -167,58 +167,6 @@ const gpuMetricsResponse = {
   ],
 };
 
-describe('PowerX legend view switching', () => {
-  for (const { locale, width, correlation, line } of [
-    { locale: '', width: 1280, correlation: 'Correlation scatter', line: 'Line chart' },
-    { locale: '/zh', width: 390, correlation: '相关性散点图', line: '折线图' },
-  ]) {
-    it(`preserves filtering and downsampling across views at ${width}px`, () => {
-      cy.viewport(width, 844);
-      cy.intercept('GET', '**/api/gpu-metrics?runId=12345', {
-        ...gpuMetricsResponse,
-        artifacts: gpuMetricsResponse.artifacts.map((artifact) => ({
-          ...artifact,
-          data: artifact.data.flatMap((row) => [row, { ...row, index: 1, power: row.power + 20 }]),
-        })),
-      }).as('gpuMetrics');
-      cy.visit(`${locale}/gpu-metrics?gm_runId=12345`, {
-        onBeforeLoad(win) {
-          win.localStorage.setItem('inferencex-feature-gate', '1');
-          win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
-        },
-      });
-      cy.wait('@gpuMetrics');
-      cy.get('[data-testid="chart-legend"] label[for="checkbox-1"]').click();
-      cy.get('#checkbox-1').should('not.be.checked');
-      cy.get('[data-testid="gpu-metrics-reset-filter"]').should('be.visible');
-      cy.get('[data-testid="gpu-metrics-downsample"]')
-        .click()
-        .should('have.attr', 'aria-checked', 'false');
-
-      cy.get(`button[title="${correlation}"]`).click();
-      cy.get('#checkbox-1').should('not.be.checked');
-      cy.get('[data-testid="gpu-metrics-downsample-corr"]').should(
-        'have.attr',
-        'aria-checked',
-        'false',
-      );
-      cy.get('[data-testid="gpu-metrics-reset-filter-2"]').click();
-      cy.get('#checkbox-1').should('be.checked');
-      cy.get('[data-testid="gpu-metrics-reset-filter-2"]').should('not.exist');
-
-      cy.get('[data-testid="chart-legend"] label[for="checkbox-1"]').click();
-      cy.get(`button[title="${line}"]`).click();
-      cy.get('[data-testid="gpu-metrics-reset-filter"]').click();
-      cy.get('#checkbox-1').should('be.checked');
-      cy.get('[data-testid="gpu-metrics-downsample"]').should('have.attr', 'aria-checked', 'false');
-      cy.document().then((doc) => {
-        expect(doc.documentElement.scrollWidth).to.be.at.most(doc.documentElement.clientWidth);
-      });
-      cy.screenshot(`powerx-legend-${width}`);
-    });
-  }
-});
-
 describe('PowerX Chinese route', () => {
   beforeEach(() => {
     cy.viewport(390, 844);
diff --git a/packages/app/cypress/e2e/measured-power-overlay.cy.ts b/packages/app/cypress/e2e/measured-power-overlay.cy.ts
index 2f6d05ba7..13ea47a29 100644
--- a/packages/app/cypress/e2e/measured-power-overlay.cy.ts
+++ b/packages/app/cypress/e2e/measured-power-overlay.cy.ts
@@ -1,5 +1,3 @@
-import { assertShareLinkMetric } from '../support/share-link';
-
 // Verifies the new measured-power Y-axis options render on the unofficial-run
 // overlay path against a real GitHub Actions artifact (run 26312107787 — the
 // on-PR sweep for PR #1558 / qwen3.5-fp8-h200-sglang). This is the canonical
@@ -72,32 +70,4 @@ describe('Measured power on unofficial-run overlay', () => {
     cy.screenshot('measured-joules-selected', { capture: 'viewport' });
     cy.get('[data-testid="inference-chart-display"] svg').should('exist');
   });
-
-  it('switches the power boundary on the overlay view and keeps the derived key in the URL', () => {
-    cy.get('[data-testid="yaxis-metric-selector"]').click('right');
-    cy.contains('[data-slot="select-item"]', /^Measured Power$/u)
-      .scrollIntoView()
-      .click();
-    cy.get('[data-testid="measured-power-basis"]').should('contain.text', 'GPU measured');
-    // The boundary control and its derived key ride the overlay view like any
-    // other Measured setting. Overlay rows plotted on a derived boundary are
-    // covered with intercepted rows in powerx-basis.cy.ts.
-    cy.get('[data-testid="measured-power-basis"]').click();
-    cy.get('[data-slot="select-item"][data-value="utility-provisioned"]').click();
-    assertShareLinkMetric('y_utilityProvisionedWatts');
-    cy.get('[data-testid="chart-figure"] h2').should(
-      'contain.text',
-      'Utility Provisioned Power per Chip (all-in)',
-    );
-    cy.get('[data-testid="measured-basis-hint"]').should('be.visible');
-    cy.get('[data-testid="power-basis-assumptions"]')
-      .should('have.attr', 'data-power-basis', 'utility-provisioned')
-      .and('contain.text', 'all-in provisioned utility power per GPU');
-    cy.get('[data-testid="inference-chart-display"] svg').should('exist');
-    // Any telemetry-only setting returns to the GPU measured boundary.
-    cy.get('[data-testid="measured-power-statistic-p90"]').click();
-    assertShareLinkMetric('y_measuredP90Power');
-    cy.get('[data-testid="measured-power-basis"]').should('contain.text', 'GPU measured');
-    cy.get('[data-testid="measured-basis-hint"]').should('not.exist');
-  });
 });
diff --git a/packages/app/cypress/e2e/powerx-basis.cy.ts b/packages/app/cypress/e2e/powerx-basis.cy.ts
deleted file mode 100644
index 41fc06b9e..000000000
--- a/packages/app/cypress/e2e/powerx-basis.cy.ts
+++ /dev/null
@@ -1,342 +0,0 @@
-import { assertShareLinkMetric } from '../support/share-link';
-
-// Power boundaries inside the gated Measured Energy group. Deterministic
-// intercepted rows carry validated telemetry and throughput, so every boundary
-// (GPU measured, GPU provisioned, utility provisioned, utility modeled) has a
-// value on the official B200 rows; the overlay run adds H200 rows. The metric
-// key carries the boundary — there is no separate URL parameter to round-trip.
-
-const BASIS_MODEL = 'dsv4';
-const BASIS_DATE = '2026-09-01';
-const BASIS_OVERLAY_RUN_ID = '31415926535';
-const BASIS_OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${BASIS_OVERLAY_RUN_ID}`;
-
-/** conc, interactivity (tok/s/user), output tok/s per GPU, measured W per GPU, measured J/out */
-const BASIS_CONFIGS: [number, number, number, number, number][] = [
-  [16, 90, 200, 500, 2.5],
-  [64, 60, 400, 600, 1.5],
-  [256, 30, 800, 700, 0.875],
-];
-
-// HW_REGISTRY: b200 tdp 1000 W / all-in 1.71 kW; h200 tdp 700 W / all-in 1.37 kW.
-const B200_ALL_IN_WATTS = 1710;
-const H200_ALL_IN_WATTS = 1370;
-const B200_TDP_WATTS = 1000;
-
-const basisMetrics = (
-  intvty: number,
-  outputTput: number,
-  watts: number,
-  joulesPerOutput: number,
-): Record<string, number> => ({
-  median_intvty: intvty,
-  median_itl: 1 / intvty,
-  median_e2el: 20,
-  median_ttft: 0.5,
-  tput_per_gpu: outputTput * 9,
-  output_tput_per_gpu: outputTput,
-  input_tput_per_gpu: outputTput * 8,
-  power_valid: 1,
-  power_metric_schema_version: 2,
-  avg_power_w: watts,
-  // Eight validated GPUs on one host: the chassis model recovers the count
-  // from total ÷ per-GPU watts, so the utility modeled boundary is supported.
-  avg_total_gpu_power_w: watts * 8,
-  joules_per_output_token: joulesPerOutput,
-});
-
-let basisId = 970000;
-const basisRows = (runUrl: string | null, hardware: 'b200' | 'h200') =>
-  BASIS_CONFIGS.map(([conc, intvty, outputTput, watts, joules]) => ({
-    id: runUrl ? 0 : basisId++,
-    hardware,
-    framework: 'sglang',
-    model: BASIS_MODEL,
-    precision: 'fp4',
-    spec_method: 'none',
-    disagg: false,
-    is_multinode: false,
-    prefill_tp: 8,
-    decode_tp: 8,
-    num_prefill_gpu: 8,
-    num_decode_gpu: 8,
-    isl: 8192,
-    osl: 1024,
-    conc,
-    offload_mode: 'off',
-    benchmark_type: 'single_turn',
-    image: 'sglang:test',
-    metrics: basisMetrics(intvty, outputTput, watts, joules),
-    workers: null,
-    date: BASIS_DATE,
-    run_url: runUrl,
-  }));
-
-const basisAvailability = [
-  {
-    model: BASIS_MODEL,
-    isl: 8192,
-    osl: 1024,
-    precision: 'fp4',
-    hardware: 'b200',
-    framework: 'sglang',
-    spec_method: 'none',
-    disagg: false,
-    benchmark_type: 'single_turn',
-    date: BASIS_DATE,
-  },
-];
-
-function interceptBasisRows() {
-  cy.intercept('GET', '/api/v1/availability', { body: basisAvailability }).as('availability');
-  cy.intercept('GET', '/api/v1/benchmarks*', { body: basisRows(null, 'b200') }).as('benchmarks');
-  cy.intercept('GET', '/api/v1/workflow-info*', {
-    body: { runs: [], changelogs: [], configs: [] },
-  });
-}
-
-function interceptOverlayRows() {
-  cy.intercept('GET', '/api/unofficial-run*', {
-    body: {
-      runInfos: [
-        {
-          id: BASIS_OVERLAY_RUN_ID,
-          name: 'powerx-basis',
-          branch: 'powerx-basis',
-          sha: 'abc000',
-          createdAt: `${BASIS_DATE}T00:00:00Z`,
-          url: BASIS_OVERLAY_RUN_URL,
-          conclusion: 'success',
-          status: 'completed',
-          isNonMainBranch: true,
-        },
-      ],
-      benchmarks: basisRows(BASIS_OVERLAY_RUN_URL, 'h200'),
-      evaluations: [],
-    },
-  }).as('unofficialRun');
-}
-
-function visitBasisChart({
-  path = '/inference',
-  extraParams = '',
-  gateUnlocked,
-}: {
-  path?: string;
-  extraParams?: string;
-  gateUnlocked: boolean;
-}) {
-  interceptBasisRows();
-  cy.visit(`${path}?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4${extraParams}`, {
-    onBeforeLoad(win) {
-      win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
-      if (gateUnlocked) win.localStorage.setItem('inferencex-feature-gate', '1');
-      else win.localStorage.removeItem('inferencex-feature-gate');
-    },
-  });
-  cy.wait(['@availability', '@benchmarks']);
-  cy.get('[data-testid="inference-chart-display"]').should('exist');
-  cy.get('[data-testid="chart-figure"]').should('have.length.at.least', 1);
-}
-
-/** Plotted y values (sorted) of every point matching `selector`, visible or not. */
-function assertPlottedValues(selector: string, expected: number[]) {
-  cy.get<SVGElement & { __data__: { y: number } }>(
-    `[data-testid="inference-chart-display"] svg ${selector}`,
-  ).should(($points) => {
-    const values = Array.from($points, (point) => point.__data__.y).sort((a, b) => a - b);
-    expect(values).to.have.length(expected.length);
-    for (const [index, value] of values.entries()) {
-      expect(value).to.be.closeTo(expected[index], 1e-6);
-    }
-  });
-}
-
-const sortedAsc = (values: number[]) => [...values].sort((a, b) => a - b);
-
-describe('PowerX power boundaries in the Measured Energy group', () => {
-  beforeEach(() => {
-    cy.on('uncaught:exception', (error) => {
-      if (error.message === 'ResizeObserver loop completed with undelivered notifications.') {
-        return false;
-      }
-    });
-  });
-
-  it('switches the boundary from the Measured controls and carries it in i_metric', () => {
-    visitBasisChart({ gateUnlocked: true, extraParams: '&i_metric=y_measuredJPerOutputToken' });
-    cy.get('[data-testid="measured-metric-controls"]').should('be.visible');
-    cy.get('[data-testid="measured-energy-basis"]')
-      .should('be.visible')
-      .and('contain.text', 'GPU measured');
-    cy.get('[data-testid="power-basis-assumptions"]').should('not.exist');
-
-    cy.get('[data-testid="measured-energy-basis"]').click();
-    cy.get('[data-slot="select-item"][data-value="utility-provisioned"]')
-      .should('contain.text', 'Utility provisioned (all-in)')
-      .click();
-
-    assertShareLinkMetric('y_utilityProvisionedJPerOutputToken');
-    cy.get('[data-testid="chart-figure"] h2').should(
-      'contain.text',
-      'Utility Provisioned Joules per Output Token, all GPUs (all-in)',
-    );
-    // Aggregate rows: all-in W ÷ output tok/s per GPU (N_alloc cancels).
-    assertPlottedValues(
-      '.dot-group',
-      sortedAsc(BASIS_CONFIGS.map((config) => B200_ALL_IN_WATTS / config[2])),
-    );
-    cy.get('[data-testid="power-basis-assumptions"]')
-      .should('have.attr', 'data-power-basis', 'utility-provisioned')
-      .and('contain.text', 'all-in provisioned utility power per GPU')
-      .and('contain.text', 'prefill and decode GPUs together');
-    cy.get('[data-testid="power-metric-availability"]').should(
-      'contain.text',
-      '3 of 3 points have this metric',
-    );
-    // The collapsed Y-axis option carries the boundary metric's own
-    // explanation, so its help popover must resolve for a boundary key.
-    cy.get('[data-testid="selected-option-help-y_utilityProvisionedJPerOutputToken"]').trigger(
-      'pointerover',
-      { pointerType: 'mouse' },
-    );
-    cy.get('[data-testid="selected-option-help-content-y_utilityProvisionedJPerOutputToken"]')
-      .should('be.visible')
-      .and('contain.text', 'J/tok')
-      .and('contain.text', 'allocated GPUs');
-    cy.get('[data-testid="selected-option-help-y_utilityProvisionedJPerOutputToken"]').trigger(
-      'pointerout',
-      { pointerType: 'mouse' },
-    );
-    // The other energy settings stay usable and return to GPU measured.
-    cy.get('[data-testid="measured-energy-denominator"]').click();
-    cy.get('[data-slot="select-item"][data-value="query"]').click();
-    assertShareLinkMetric('y_measuredJPerSuccessfulQuery');
-    cy.get('[data-testid="measured-energy-basis"]').should('contain.text', 'GPU measured');
-  });
-
-  it('renders a shared utility-modeled link while the gate is locked and hides the group otherwise', () => {
-    visitBasisChart({ gateUnlocked: false, extraParams: '&i_metric=y_utilityModeledWatts' });
-    cy.get('[data-testid="chart-figure"] h2').should(
-      'contain.text',
-      'Utility Modeled Power per Chip (PUE)',
-    );
-    // B200 8k/1k with eight validated GPUs is inside the chassis model, so
-    // every row has a modeled utility value above its measured watts.
-    cy.get<SVGElement & { __data__: { y: number } }>(
-      '[data-testid="inference-chart-display"] svg .dot-group',
-    ).should(($points) => {
-      expect($points).to.have.length(BASIS_CONFIGS.length);
-      const measured = sortedAsc(BASIS_CONFIGS.map((config) => config[3]));
-      const plotted = sortedAsc(Array.from($points, (point) => point.__data__.y));
-      for (const [index, value] of plotted.entries()) {
-        // Chassis AC × PUE 1.3 per GPU exceeds the GPU-board watts but stays
-        // below the 1.71 kW all-in provisioning.
-        expect(value).to.be.greaterThan(measured[index]);
-        expect(value).to.be.lessThan(B200_ALL_IN_WATTS);
-      }
-    });
-    cy.get('[data-testid="power-basis-assumptions"]')
-      .should('have.attr', 'data-power-basis', 'utility-modeled')
-      .and('contain.text', 'PUE 1.3')
-      .and('contain.text', 'revision');
-    // Watt boundaries draw the upper power envelope like measured watts, so
-    // Optimal Only (default on) keeps every load point instead of a Pareto corner.
-    cy.get('[data-testid="power-curve-description"]').should('exist');
-    cy.get('[data-testid="inference-chart-display"] svg .roofline-path')
-      .should('have.length.at.least', 1)
-      .and('have.attr', 'data-curve-kind', 'power-envelope');
-    cy.get<SVGElement>('[data-testid="inference-chart-display"] svg .dot-group').should(
-      ($points) => {
-        const shown = [...$points].filter((point) => getComputedStyle(point).opacity === '1');
-        expect(shown).to.have.length(BASIS_CONFIGS.length);
-      },
-    );
-    // Like its Measured siblings, the selected gated metric keeps its own
-    // controls reachable from a shared link.
-    cy.get('[data-testid="measured-power-basis"]').should('contain.text', 'Utility modeled (PUE)');
-    cy.get('[data-testid="measured-basis-hint"]').should('be.visible');
-
-    // Without the shared metric the locked gate hides the whole group.
-    visitBasisChart({ gateUnlocked: false });
-    cy.get('[data-testid="measured-metric-controls"]').should('not.exist');
-    cy.get('[data-testid="yaxis-metric-selector"]').click('right');
-    cy.get('[data-slot="select-content"]').should('exist');
-    cy.get('[data-slot="select-item"]').should('not.contain.text', 'Measured Power');
-    cy.get('[data-slot="select-item"]').should('not.contain.text', 'Measured Energy');
-  });
-
-  it('shows the boundary column in the Table view', () => {
-    visitBasisChart({ gateUnlocked: true, extraParams: '&i_metric=y_gpuProvisionedWatts' });
-    cy.get('[data-testid="inference-table-view-btn"]').click();
-    cy.get('[data-testid="inference-chart-display"] table').within(() => {
-      cy.contains('th', 'GPU Provisioned Power per Chip (TDP, W)').should('be.visible');
-      // formatInferenceTableNumber renders the 1000 W spec constant as "1,000".
-      cy.contains('td', B200_TDP_WATTS.toLocaleString('en-US')).should('exist');
-    });
-  });
-
-  it('translates the boundary control and metric on /zh/inference', () => {
-    visitBasisChart({
-      path: '/zh/inference',
-      gateUnlocked: true,
-      extraParams: '&i_metric=y_gpuProvisionedJPerOutputToken',
-    });
-    cy.get('[data-testid="chart-figure"] h2').should(
-      'contain.text',
-      '每输出 token GPU 额定焦耳能耗（TDP）',
-    );
-    cy.get('[data-testid="measured-metric-controls"]').should('contain.text', '功耗边界');
-    cy.get('[data-testid="measured-energy-basis"]').should('contain.text', 'GPU 额定（TDP）');
-    cy.get('[data-testid="measured-basis-hint"]').should('contain.text', '返回 GPU 实测');
-    cy.get('[data-testid="power-basis-assumptions"]').should('contain.text', 'GPU 额定边界');
-    cy.get('[data-testid="power-metric-availability"]').should(
-      'contain.text',
-      '3 个数据点中有 3 个提供此指标',
-    );
-    assertPlottedValues(
-      '.dot-group',
-      sortedAsc(BASIS_CONFIGS.map((config) => B200_TDP_WATTS / config[2])),
-    );
-  });
-
-  it('plots the boundary for ?unofficialrun= overlay rows with the overlay hardware specs', () => {
-    interceptOverlayRows();
-    visitBasisChart({
-      gateUnlocked: true,
-      extraParams: `&unofficialrun=${BASIS_OVERLAY_RUN_ID}&i_metric=y_utilityProvisionedJPerOutputToken`,
-    });
-    cy.wait('@unofficialRun');
-    cy.get('[data-testid="chart-figure"] h2').should(
-      'contain.text',
-      'Utility Provisioned Joules per Output Token, all GPUs (all-in)',
-    );
-    assertPlottedValues(
-      '.dot-group',
-      sortedAsc(BASIS_CONFIGS.map((config) => B200_ALL_IN_WATTS / config[2])),
-    );
-    // Overlay H200 rows derive from their own registry specs, not the official B200's.
-    assertPlottedValues(
-      '.unofficial-overlay-pt',
-      sortedAsc(BASIS_CONFIGS.map((config) => H200_ALL_IN_WATTS / config[2])),
-    );
-    // Official (3) + visible overlay (3) rows feed the availability count.
-    cy.get('[data-testid="power-metric-availability"]').should(
-      'contain.text',
-      '6 of 6 points have this metric',
-    );
-    // The modeled boundary rides the same overlay path: validated H200 8k/1k
-    // telemetry is inside the chassis model too.
-    cy.get('[data-testid="measured-energy-basis"]').click();
-    cy.get('[data-slot="select-item"][data-value="utility-modeled"]').click();
-    assertShareLinkMetric('y_utilityModeledJPerOutputToken');
-    cy.get('[data-testid="inference-chart-display"] svg .unofficial-overlay-pt').should(
-      'have.length',
-      BASIS_CONFIGS.length,
-    );
-    cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
-      'have.length',
-      BASIS_CONFIGS.length,
-    );
-  });
-});
diff --git a/packages/app/cypress/e2e/powerx-compare.cy.ts b/packages/app/cypress/e2e/powerx-compare.cy.ts
deleted file mode 100644
index af2594200..000000000
--- a/packages/app/cypress/e2e/powerx-compare.cy.ts
+++ /dev/null
@@ -1,301 +0,0 @@
-import { assertShareLinkParams } from '../support/share-link';
-
-// Power comparison series (`i_pcompare`) inside the gated Measured Energy
-// group: `boundaries` overlays every power boundary, `roles` the prefill and
-// decode pools, on the same points as the selected metric. Deterministic
-// disaggregated rows carry validated whole-deployment and per-role telemetry,
-// so every sibling series has a value; the overlay run adds H200 rows.
-
-const MODEL = 'dsv4';
-const DATE = '2026-09-01';
-const OVERLAY_RUN_ID = '31415926535';
-const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
-
-/**
- * conc, interactivity (tok/s/user), output tok/s per GPU, measured W per GPU,
- * prefill W per GPU, decode W per GPU, J per output token, decode J per output token.
- * Input tokens outnumber output tokens 8:1, so J/in = J/out ÷ 8 and the prefill
- * pool's J/in reconstructs to J/out − decode J/out on the output-token axis.
- */
-const CONFIGS: [number, number, number, number, number, number, number, number][] = [
-  [16, 90, 200, 500, 800, 400, 2.4, 1.6],
-  [64, 60, 400, 600, 820, 450, 1.6, 1],
-  [256, 30, 800, 700, 840, 500, 1, 0.6],
-];
-const TOKEN_RATIO = 8;
-
-// HW_REGISTRY: b200 tdp 1000 W / all-in 1.71 kW; h200 tdp 700 W / all-in 1.37 kW.
-const B200_TDP_WATTS = 1000;
-const B200_ALL_IN_WATTS = 1710;
-
-let rowId = 990000;
-const rows = (runUrl: string | null, hardware: 'b200' | 'h200') =>
-  CONFIGS.map(([conc, intvty, outputTput, watts, prefillWatts, decodeWatts, jOut, decodeJOut]) => ({
-    id: runUrl ? 0 : rowId++,
-    hardware,
-    framework: 'dynamo-sglang',
-    model: MODEL,
-    precision: 'fp4',
-    spec_method: 'none',
-    disagg: true,
-    is_multinode: true,
-    prefill_tp: 4,
-    decode_tp: 4,
-    num_prefill_gpu: 4,
-    num_decode_gpu: 4,
-    isl: 8192,
-    osl: 1024,
-    conc,
-    offload_mode: 'off',
-    benchmark_type: 'single_turn',
-    image: 'dynamo:test',
-    metrics: {
-      median_intvty: intvty,
-      median_itl: 1 / intvty,
-      median_e2el: 20,
-      median_ttft: 0.5,
-      tput_per_gpu: outputTput * 9,
-      output_tput_per_gpu: outputTput,
-      input_tput_per_gpu: outputTput * 8,
-      power_valid: 1,
-      power_metric_schema_version: 2,
-      avg_power_w: watts,
-      avg_total_gpu_power_w: watts * 8,
-      prefill_avg_power_w: prefillWatts,
-      decode_avg_power_w: decodeWatts,
-      joules_per_output_token: jOut,
-      joules_per_input_token: jOut / TOKEN_RATIO,
-      prefill_joules_per_input_token: (jOut - decodeJOut) / TOKEN_RATIO,
-      decode_joules_per_output_token: decodeJOut,
-    },
-    workers: null,
-    date: DATE,
-    run_url: runUrl,
-  }));
-
-const availability = [
-  {
-    model: MODEL,
-    isl: 8192,
-    osl: 1024,
-    precision: 'fp4',
-    hardware: 'b200',
-    framework: 'dynamo-sglang',
-    spec_method: 'none',
-    disagg: true,
-    benchmark_type: 'single_turn',
-    date: DATE,
-  },
-];
-
-function interceptRows() {
-  cy.intercept('GET', '/api/v1/availability', { body: availability }).as('availability');
-  cy.intercept('GET', '/api/v1/benchmarks*', { body: rows(null, 'b200') }).as('benchmarks');
-  cy.intercept('GET', '/api/v1/workflow-info*', {
-    body: { runs: [], changelogs: [], configs: [] },
-  });
-}
-
-function interceptOverlayRows() {
-  cy.intercept('GET', '/api/unofficial-run*', {
-    body: {
-      runInfos: [
-        {
-          id: OVERLAY_RUN_ID,
-          name: 'powerx-compare',
-          branch: 'powerx-compare',
-          sha: 'abc000',
-          createdAt: `${DATE}T00:00:00Z`,
-          url: OVERLAY_RUN_URL,
-          conclusion: 'success',
-          status: 'completed',
-          isNonMainBranch: true,
-        },
-      ],
-      benchmarks: rows(OVERLAY_RUN_URL, 'h200'),
-      evaluations: [],
-    },
-  }).as('unofficialRun');
-}
-
-function visitChart({
-  path = '/inference',
-  extraParams = '',
-}: {
-  path?: string;
-  extraParams?: string;
-}) {
-  interceptRows();
-  cy.visit(`${path}?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4${extraParams}`, {
-    onBeforeLoad(win) {
-      win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
-      win.localStorage.setItem('inferencex-feature-gate', '1');
-    },
-  });
-  cy.wait(['@availability', '@benchmarks']);
-  cy.get('[data-testid="inference-chart-display"]').should('exist');
-  cy.get('[data-testid="chart-figure"]').should('have.length.at.least', 1);
-}
-
-const sortedAsc = (values: number[]) => [...values].sort((a, b) => a - b);
-
-/** Plotted y values (sorted) of every point matching `selector`, visible or not. */
-function assertPlottedValues(selector: string, expected: number[]) {
-  cy.get<SVGElement & { __data__: { y: number } }>(
-    `[data-testid="inference-chart-display"] svg ${selector}`,
-  ).should(($points) => {
-    const values = sortedAsc(Array.from($points, (point) => point.__data__.y));
-    expect(values).to.have.length(expected.length);
-    for (const [index, value] of values.entries()) {
-      expect(value).to.be.closeTo(expected[index], 1e-6);
-    }
-  });
-}
-
-function chooseCompare(mode: 'none' | 'boundaries' | 'roles') {
-  cy.get('[data-testid="measured-power-compare"]').click();
-  cy.get(`[data-slot="select-item"][data-value="${mode}"]`).click();
-}
-
-describe('PowerX comparison series (i_pcompare)', () => {
-  beforeEach(() => {
-    cy.on('uncaught:exception', (error) => {
-      if (error.message === 'ResizeObserver loop completed with undelivered notifications.') {
-        return false;
-      }
-    });
-  });
-
-  it('overlays every boundary from a shared link and switches to roles from the Compare control', () => {
-    visitChart({ extraParams: '&i_metric=y_measuredAvgPower&i_pcompare=boundaries' });
-    cy.get('[data-testid="measured-power-compare"]').should('contain.text', 'All boundaries');
-
-    const measured = CONFIGS.map((config) => config[3]);
-    assertPlottedValues('.dot-group[data-power-variant=""]', sortedAsc(measured));
-    assertPlottedValues(
-      '.dot-group[data-power-variant="gpu-provisioned"]',
-      CONFIGS.map(() => B200_TDP_WATTS),
-    );
-    assertPlottedValues(
-      '.dot-group[data-power-variant="utility-provisioned"]',
-      CONFIGS.map(() => B200_ALL_IN_WATTS),
-    );
-    // Siblings share the hardware colour and differ by dash; every series
-    // draws its own power envelope.
-    cy.get('[data-testid="inference-chart-display"] svg .roofline-path:not([data-power-variant])')
-      .should('have.length', 1)
-      .and('have.attr', 'data-hw-key', 'b200_dynamo-sglang');
-    cy.get(
-      '[data-testid="inference-chart-display"] svg .roofline-path[data-power-variant="gpu-provisioned"]',
-    )
-      .should('have.attr', 'stroke-dasharray', '8 4')
-      .and('have.attr', 'data-hw-key', 'b200_dynamo-sglang');
-    cy.get('[data-testid="chart-legend"]')
-      .should('contain.text', 'GPU measured')
-      .and('contain.text', 'GPU provisioned (TDP)')
-      .and('contain.text', 'Utility provisioned (all-in)');
-    assertShareLinkParams({ i_metric: 'y_measuredAvgPower', i_pcompare: 'boundaries' });
-
-    chooseCompare('roles');
-    assertPlottedValues(
-      '.dot-group[data-power-variant="prefill"]',
-      sortedAsc(CONFIGS.map((config) => config[4])),
-    );
-    assertPlottedValues(
-      '.dot-group[data-power-variant="decode"]',
-      sortedAsc(CONFIGS.map((config) => config[5])),
-    );
-    cy.get(
-      '[data-testid="inference-chart-display"] svg .dot-group[data-power-variant^="gpu-"]',
-    ).should('not.exist');
-    assertShareLinkParams({ i_pcompare: 'roles' });
-
-    // The Table names each row's series.
-    cy.get('[data-testid="inference-table-view-btn"]').click();
-    cy.get('[data-testid="inference-chart-display"] table').within(() => {
-      cy.contains('th', 'Series').should('be.visible');
-      cy.contains('td', 'Prefill GPUs').should('exist');
-      cy.contains('td', 'All GPUs').should('exist');
-    });
-    cy.get('[data-testid="inference-chart-view-btn"]').click();
-
-    chooseCompare('none');
-    cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
-      'have.length',
-      CONFIGS.length,
-    );
-    assertShareLinkParams({ i_pcompare: null });
-  });
-
-  it('reconstructs the prefill pool on the output-token energy axis and pauses off it', () => {
-    visitChart({ extraParams: '&i_metric=y_measuredJPerOutputToken&i_pcompare=roles' });
-    assertPlottedValues(
-      '.dot-group[data-power-variant=""]',
-      sortedAsc(CONFIGS.map((config) => config[6])),
-    );
-    // Prefill J/in × (J/out ÷ J/in) = the prefill pool's J per output token.
-    assertPlottedValues(
-      '.dot-group[data-power-variant="prefill"]',
-      sortedAsc(CONFIGS.map((config) => config[6] - config[7])),
-    );
-    assertPlottedValues(
-      '.dot-group[data-power-variant="decode"]',
-      sortedAsc(CONFIGS.map((config) => config[7])),
-    );
-    cy.get('[data-testid="measured-compare-hint"]').should('not.exist');
-
-    // A prefill J per input token axis has no decode counterpart: the
-    // comparison pauses and says so instead of drawing a mismatched series.
-    cy.get('[data-testid="measured-energy-denominator"]').click();
-    cy.get('[data-slot="select-item"][data-value="input"]').click();
-    cy.get('[data-testid="measured-compare-hint"]').should('be.visible');
-    cy.get(
-      '[data-testid="inference-chart-display"] svg .dot-group[data-power-variant="prefill"]',
-    ).should('not.exist');
-    cy.get('[data-testid="measured-power-compare"]').should('contain.text', 'Prefill vs decode');
-    assertShareLinkParams({ i_metric: 'y_measuredJPerInputToken', i_pcompare: 'roles' });
-  });
-
-  it('draws comparison siblings for ?unofficialrun= overlay rows in the run colour', () => {
-    interceptOverlayRows();
-    visitChart({
-      extraParams: `&unofficialrun=${OVERLAY_RUN_ID}&i_metric=y_measuredAvgPower&i_pcompare=boundaries`,
-    });
-    cy.wait('@unofficialRun');
-    // Three overlay rows × (measured + TDP + all-in).
-    cy.get('[data-testid="inference-chart-display"] svg .unofficial-overlay-pt').should(
-      'have.length',
-      CONFIGS.length * 3,
-    );
-    cy.get(
-      '[data-testid="inference-chart-display"] svg .overlay-roofline-path[data-power-variant="gpu-provisioned"]',
-    )
-      .should('have.length', 1)
-      .and('have.attr', 'stroke-dasharray', '8 4')
-      .then(($sibling) => {
-        cy.get(
-          '[data-testid="inference-chart-display"] svg .overlay-roofline-path:not([data-power-variant])',
-        ).should(($base) => {
-          expect($sibling.attr('stroke')).to.eq($base.attr('stroke'));
-        });
-      });
-    // Comparison clones do not inflate the availability count.
-    cy.get('[data-testid="power-metric-availability"]').should(
-      'contain.text',
-      '6 of 6 points have this metric',
-    );
-  });
-
-  it('translates the Compare control and legend rows on /zh/inference', () => {
-    visitChart({
-      path: '/zh/inference',
-      extraParams: '&i_metric=y_measuredAvgPower&i_pcompare=roles',
-    });
-    cy.get('[data-testid="measured-metric-controls"]').should('contain.text', '对比');
-    cy.get('[data-testid="measured-power-compare"]').should('contain.text', '预填充 vs 解码');
-    cy.get('[data-testid="chart-legend"]')
-      .should('contain.text', '全部 GPU')
-      .and('contain.text', '预填充 GPU')
-      .and('contain.text', '解码 GPU');
-  });
-});
diff --git a/packages/app/cypress/e2e/powerx-timeline.cy.ts b/packages/app/cypress/e2e/powerx-timeline.cy.ts
deleted file mode 100644
index 5e2267dec..000000000
--- a/packages/app/cypress/e2e/powerx-timeline.cy.ts
+++ /dev/null
@@ -1,462 +0,0 @@
-import { assertShareLinkMetric } from '../support/share-link';
-
-// The Measured Power "Timeline" display (`y_measuredPowerTimeline`) inside the
-// gated Measured Energy group. Deterministic intercepted rows carry validated
-// telemetry plus the `power_audit.source` / `run_url` provenance that names each
-// point's `gpu_metrics_*` artifact; `/api/gpu-metrics?series=power` is
-// intercepted with matching one-second series.
-
-const MODEL = 'dsv4';
-const DATE = '2026-09-01';
-const RUN_ID = '34716669498';
-const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
-const OVERLAY_RUN_ID = '31415926535';
-const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
-const START_MS = Date.UTC(2026, 8, 1, 20, 0, 0);
-
-/** conc, interactivity (tok/s/user), output tok/s per GPU, measured W per GPU */
-const CONFIGS: [number, number, number, number][] = [
-  [16, 90, 200, 500],
-  [64, 60, 400, 600],
-  [256, 30, 800, 700],
-];
-
-const resultName = (hardware: string, conc: number) =>
-  `dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc${conc}_${hardware}-host-0123456789abcdef0123`;
-
-let rowId = 980000;
-const rows = (runUrl: string, hardware: 'b200' | 'h200') =>
-  CONFIGS.map(([conc, intvty, outputTput, watts]) => ({
-    id: hardware === 'b200' ? rowId++ : 0,
-    hardware,
-    framework: 'sglang',
-    model: MODEL,
-    precision: 'fp4',
-    spec_method: 'none',
-    disagg: false,
-    is_multinode: false,
-    prefill_tp: 8,
-    decode_tp: 8,
-    num_prefill_gpu: 8,
-    num_decode_gpu: 8,
-    isl: 8192,
-    osl: 1024,
-    conc,
-    offload_mode: 'off',
-    benchmark_type: 'single_turn',
-    image: 'sglang:test',
-    metrics: {
-      median_intvty: intvty,
-      median_itl: 1 / intvty,
-      median_e2el: 20,
-      median_ttft: 0.5,
-      tput_per_gpu: outputTput * 9,
-      output_tput_per_gpu: outputTput,
-      input_tput_per_gpu: outputTput * 8,
-      power_valid: 1,
-      power_metric_schema_version: 2,
-      avg_power_w: watts,
-      avg_total_gpu_power_w: watts * 8,
-      joules_per_output_token: watts / outputTput,
-    },
-    workers: null,
-    power_audit: {
-      source: `power_validation_${resultName(hardware, conc)}.json`,
-      sample_count: 160,
-      window_start_unix: (START_MS + 40_000) / 1000,
-      window_end_unix: (START_MS + 60_000) / 1000,
-      observed_gpu_ids: ['0', '1', '2', '3', '4', '5', '6', '7'],
-    },
-    date: DATE,
-    run_url: runUrl,
-  }));
-
-const seriesFor = (hardware: string, runUrl: string, runId: string) => ({
-  runInfo: {
-    id: Number(runId),
-    name: 'Run Sweep',
-    branch: hardware === 'b200' ? 'main' : 'powerx-timeline',
-    sha: 'abc123',
-    createdAt: `${DATE}T20:00:00Z`,
-    url: runUrl,
-    conclusion: 'success',
-    status: 'completed',
-  },
-  series: CONFIGS.map((config) => {
-    const [conc] = config;
-    const watts = config[3];
-    const t = Array.from({ length: 61 }, (_, i) => i);
-    return {
-      artifact: `gpu_metrics_${resultName(hardware, conc)}`,
-      startMs: START_MS,
-      bucketSeconds: 1,
-      gpus: [0, 1],
-      t,
-      power: [0, 1].map((gpu) => t.map((second) => (second >= 40 ? watts + gpu : 150 + gpu))),
-    };
-  }),
-});
-
-function pointTelemetry(id: number) {
-  const trace = seriesFor('b200', RUN_URL, RUN_ID).series[1];
-  const data = trace.gpus.flatMap((index, gpu) =>
-    trace.t.map((second, sample) => ({
-      timestamp: new Date(START_MS + second * 1000).toISOString(),
-      index,
-      power: trace.power[gpu][sample],
-    })),
-  );
-  return {
-    benchmarkResultId: id,
-    series: [
-      {
-        id: 1,
-        artifactName: trace.artifact,
-        configKey: resultName('b200', 64),
-        fileName: 'gpu_metrics.csv',
-        vendor: 'nvidia',
-        sampleIntervalS: 1,
-        sampleCount: data.length,
-        gpuCount: trace.gpus.length,
-        startedAt: data[0].timestamp,
-        endedAt: data.at(-1)!.timestamp,
-        sidecars: {},
-        benchmarkResultIds: [id],
-        stats: [],
-        data,
-      },
-    ],
-  };
-}
-
-const availability = [
-  {
-    model: MODEL,
-    isl: 8192,
-    osl: 1024,
-    precision: 'fp4',
-    hardware: 'b200',
-    framework: 'sglang',
-    spec_method: 'none',
-    disagg: false,
-    benchmark_type: 'single_turn',
-    date: DATE,
-  },
-];
-
-function interceptRows() {
-  const benchmarks = rows(RUN_URL, 'b200');
-  cy.intercept('GET', '/api/v1/availability', { body: availability }).as('availability');
-  cy.intercept('GET', '/api/v1/benchmarks*', { body: benchmarks }).as('benchmarks');
-  cy.intercept('GET', '/api/v1/workflow-info*', {
-    body: { runs: [], changelogs: [], configs: [] },
-  });
-  cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, {
-    body: seriesFor('b200', RUN_URL, RUN_ID),
-  }).as('series');
-  return benchmarks;
-}
-
-function interceptOverlay() {
-  cy.intercept('GET', '/api/unofficial-run*', {
-    body: {
-      runInfos: [
-        {
-          id: OVERLAY_RUN_ID,
-          name: 'powerx-timeline',
-          branch: 'powerx-timeline',
-          sha: 'abc000',
-          createdAt: `${DATE}T00:00:00Z`,
-          url: OVERLAY_RUN_URL,
-          conclusion: 'success',
-          status: 'completed',
-          isNonMainBranch: true,
-        },
-      ],
-      benchmarks: rows(OVERLAY_RUN_URL, 'h200'),
-      evaluations: [],
-    },
-  }).as('unofficialRun');
-  cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
-    body: seriesFor('h200', OVERLAY_RUN_URL, OVERLAY_RUN_ID),
-  }).as('overlaySeries');
-}
-
-function visitChart({
-  path = '/inference',
-  extraParams = '',
-  unlocked = true,
-}: {
-  path?: string;
-  extraParams?: string;
-  unlocked?: boolean;
-}) {
-  const benchmarks = interceptRows();
-  cy.visit(`${path}?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4${extraParams}`, {
-    onBeforeLoad(win) {
-      win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
-      if (unlocked) win.localStorage.setItem('inferencex-feature-gate', '1');
-      else win.localStorage.removeItem('inferencex-feature-gate');
-    },
-  });
-  cy.wait(['@availability', '@benchmarks']);
-  cy.get('[data-testid="inference-chart-display"]').should('exist');
-  return benchmarks;
-}
-
-describe('PowerX measured power timeline', () => {
-  beforeEach(() => {
-    cy.on('uncaught:exception', (error) => {
-      if (error.message === 'ResizeObserver loop completed with undelivered notifications.') {
-        return false;
-      }
-    });
-  });
-
-  it('switches the Display control to Timeline and renders the per-second traces', () => {
-    visitChart({ extraParams: '&i_metric=y_measuredAvgPower' });
-    cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
-      'have.length',
-      CONFIGS.length,
-    );
-
-    cy.get('[data-testid="measured-power-display"]').click();
-    cy.get('[data-slot="select-item"][data-value="timeline"]')
-      .should('contain.text', 'Timeline')
-      .click();
-
-    assertShareLinkMetric('y_measuredPowerTimeline');
-    cy.get('[data-testid="chart-figure"] h2').should(
-      'contain.text',
-      'Measured Average Power per Chip over Time',
-    );
-    cy.wait('@series').then(({ request }) => {
-      const url = new URL(request.url);
-      expect(url.searchParams.get('series')).to.eq('power');
-      expect(url.searchParams.get('prefix')).to.eq(
-        'dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc',
-      );
-    });
-    cy.get('[data-testid="power-timeline-chart-svg"]').within(() => {
-      cy.get('path.power-trace[data-segment="full"]').should('have.length', CONFIGS.length);
-      cy.get('path.power-trace[data-segment="window"]').should('have.length', CONFIGS.length);
-      cy.get('.power-reference[data-reference="tdp"][data-watts="1000"]').should('exist');
-      cy.get('text.power-trace-label').should('have.length', CONFIGS.length);
-    });
-    cy.get('[data-testid="power-timeline-source"] a').should('have.attr', 'href', RUN_URL);
-    cy.get('[data-testid="power-metric-availability"]').should(
-      'contain.text',
-      '3 of 3 points have this metric',
-    );
-
-    // Back to watts returns the scatter body on the same points.
-    cy.get('[data-testid="measured-power-display"]').click();
-    cy.get('[data-slot="select-item"][data-value="watts"]').click();
-    assertShareLinkMetric('y_measuredAvgPower');
-    cy.get('[data-testid="power-timeline"]').should('not.exist');
-    cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
-      'have.length',
-      CONFIGS.length,
-    );
-  });
-
-  it('opens the timeline from a shared link and keeps the Table view on the measured average', () => {
-    visitChart({ extraParams: '&i_metric=y_measuredPowerTimeline' });
-    cy.wait('@series');
-    cy.get('[data-testid="measured-power-display"]').should('contain.text', 'Timeline');
-    cy.get('[data-testid="power-timeline-chart-svg"] path.power-trace').should(
-      'have.length.at.least',
-      CONFIGS.length,
-    );
-    cy.get('[data-testid="inference-table-view-btn"]').click();
-    cy.get('[data-testid="inference-chart-display"] table').within(() => {
-      cy.contains('th', 'Measured Average Power per Chip over Time (W)').should('be.visible');
-      cy.contains('td', '700').should('exist');
-    });
-  });
-
-  it('draws ?unofficialrun= overlay traces in the run colour', () => {
-    interceptOverlay();
-    visitChart({
-      extraParams: `&unofficialrun=${OVERLAY_RUN_ID}&i_metric=y_measuredPowerTimeline`,
-    });
-    cy.wait(['@unofficialRun', '@series', '@overlaySeries']);
-    cy.get('[data-testid="power-timeline-chart-svg"]').within(() => {
-      cy.get('path.power-trace[data-run-index="0"][data-segment="window"]').should(
-        'have.length',
-        CONFIGS.length,
-      );
-      // Official hardware keys carry the framework suffix (`b200_sglang`).
-      cy.get('path.power-trace[data-hw^="b200"][data-segment="window"]').should(
-        'have.length',
-        CONFIGS.length,
-      );
-      // B200 and H200 references.
-      cy.get('.power-reference[data-reference="tdp"]').should('have.length', 2);
-    });
-    cy.get('[data-testid="chart-legend"]').should('contain.text', '✕ powerx-timeline');
-  });
-
-  it('translates the display option and chart on /zh/inference', () => {
-    visitChart({ path: '/zh/inference', extraParams: '&i_metric=y_measuredPowerTimeline' });
-    cy.wait('@series');
-    cy.get('[data-testid="chart-figure"] h2').should('contain.text', '每芯片实测平均功耗时间线');
-    cy.get('[data-testid="measured-power-display"]').should('contain.text', '时间线');
-    cy.get('[data-testid="power-timeline-toolbar"]').should('contain.text', '时间轴');
-  });
-
-  // ── "View power trace" on pinned scatter tooltips ─────────────────────────
-
-  const POWER_TRACE_ACTION = '[data-chart-tooltip]:visible [data-action="view-power-trace"]';
-  const TELEMETRY_ACTION = '[data-chart-tooltip]:visible [data-action="view-power-telemetry"]';
-  const TELEMETRY_DIALOG = '[data-testid="power-telemetry-dialog"]';
-
-  /** Pin the tooltip of the marker plotted for `conc` (official `.dot-group` or overlay X). */
-  function pinPointTooltip(selector: string, conc: number): void {
-    cy.get(`[data-testid="inference-chart-display"] svg ${selector}`)
-      .should('have.length', CONFIGS.length)
-      .then(($points) => {
-        const target = [...$points].find(
-          (node) => (node as unknown as { __data__?: { conc?: number } }).__data__?.conc === conc,
-        );
-        expect(target, `a ${selector} marker at concurrency ${conc}`).to.not.equal(undefined);
-        cy.wrap(target).find('.visible-shape').click({ force: true });
-      });
-  }
-
-  for (const [path, width, closeLabel] of [
-    ['/inference', 1280, 'Close'],
-    ['/zh/inference', 390, '关闭'],
-  ] as const) {
-    it(`loads the selected point's PowerX telemetry in place at ${path} ${width}px`, () => {
-      cy.viewport(width, 900);
-      cy.intercept('GET', '/api/v1/gpu-metrics-point*', (request) => {
-        const id = Number(new URL(request.url).searchParams.get('id'));
-        request.reply({ body: pointTelemetry(id) });
-      }).as('pointTelemetry');
-      cy.intercept('GET', '/api/v1/trace-server-metrics*', { statusCode: 404 }).as('serverMetrics');
-      const benchmarks = visitChart({ path, extraParams: '&i_metric=y_measuredAvgPower' });
-      const selectedPointId = benchmarks.find((point) => point.conc === 64)!.id;
-      cy.get('@pointTelemetry.all').should('have.length', 0);
-      pinPointTooltip('.dot-group', 64);
-      cy.get(TELEMETRY_ACTION).should('have.prop', 'tagName', 'BUTTON').click();
-      cy.wait('@pointTelemetry').then(({ request }) => {
-        const id = Number(new URL(request.url).searchParams.get('id'));
-        expect(id).to.eq(selectedPointId);
-      });
-      cy.location('pathname').should('eq', path);
-      cy.get(TELEMETRY_DIALOG)
-        .should('contain.text', 'PowerX')
-        .within(() => {
-          cy.get('[data-testid="gpu-metrics-run-input"]').should('not.exist');
-          cy.get('[data-testid="power-telemetry-sample-count"]').should('have.text', '122');
-          cy.get('[data-testid="gpu-metrics-chart-svg"] path.line-path').should('have.length', 2);
-        });
-      cy.get(TELEMETRY_DIALOG)
-        .should(($dialog) => {
-          const dialog = $dialog[0];
-          expect(dialog.scrollWidth, 'no horizontal dialog overflow').to.be.at.most(
-            dialog.clientWidth + 1,
-          );
-          const bounds = dialog.getBoundingClientRect();
-          expect(bounds.left).to.be.at.least(0);
-          expect(bounds.right).to.be.at.most(width);
-        })
-        .screenshot(`powerx-point-dialog-${width}`);
-      cy.get(TELEMETRY_DIALOG)
-        .scrollTo('bottom')
-        .screenshot(`powerx-point-dialog-${width}-bottom`)
-        .scrollTo('top');
-      cy.get(TELEMETRY_DIALOG).contains('button', closeLabel).click();
-      cy.get(TELEMETRY_DIALOG).should('not.exist');
-      assertShareLinkMetric('y_measuredAvgPower');
-      cy.get('@serverMetrics.all').should('have.length', 0);
-      pinPointTooltip('.dot-group', 64);
-      cy.get(TELEMETRY_ACTION).click();
-      cy.get(TELEMETRY_DIALOG).should('be.visible');
-      cy.get('body').type('{esc}');
-      cy.get(TELEMETRY_DIALOG).should('not.exist');
-    });
-  }
-
-  it('keeps the normal-metric entry gated and reveals it after unlocking PowerX', () => {
-    cy.intercept('GET', '/api/v1/gpu-metrics-point*', { statusCode: 404 }).as('pointTelemetry');
-    visitChart({ extraParams: '&i_metric=y_tpPerGpu', unlocked: false });
-    pinPointTooltip('.dot-group', 64);
-    cy.get(TELEMETRY_ACTION).should('not.exist');
-    cy.get('body').type('{uparrow}{uparrow}{downarrow}{downarrow}');
-    cy.get('[data-testid="tab-trigger-hidden"]').should('be.visible');
-    pinPointTooltip('.dot-group', 16);
-    cy.get(TELEMETRY_ACTION).should('be.visible').click();
-    cy.wait('@pointTelemetry');
-    cy.get(TELEMETRY_DIALOG).should('contain.text', 'PowerX');
-    cy.location('pathname').should('eq', '/inference');
-  });
-
-  it('shows unavailable telemetry instead of a run-ID form when the selected point has no series', () => {
-    cy.intercept('GET', '/api/v1/gpu-metrics-point*', { statusCode: 404 }).as('missingTelemetry');
-    visitChart({ extraParams: '&i_metric=y_measuredAvgPower' });
-    pinPointTooltip('.dot-group', 64);
-    cy.get(TELEMETRY_ACTION).click();
-    cy.wait('@missingTelemetry');
-    cy.get(TELEMETRY_DIALOG).within(() => {
-      cy.get('[data-testid="power-telemetry-missing"]').should(
-        'contain.text',
-        'No PowerX telemetry is stored',
-      );
-      cy.get('[data-testid="power-telemetry-query-error"]').should('not.exist');
-      cy.get('[data-testid="gpu-metrics-run-input"]').should('not.exist');
-    });
-  });
-
-  it('jumps from a pinned point to the timeline focused on that config', () => {
-    visitChart({ extraParams: '&i_metric=y_measuredAvgPower' });
-    // Only a pinned tooltip offers the action (the hover gate is unit-tested).
-    pinPointTooltip('.dot-group', 64);
-    cy.get(POWER_TRACE_ACTION)
-      .should('be.visible')
-      .should('contain.text', 'View power trace')
-      .invoke('attr', 'href')
-      .should('contain', 'i_metric=y_measuredPowerTimeline');
-    cy.get(POWER_TRACE_ACTION).click();
-
-    // Same-tab click switches the metric in place instead of navigating.
-    cy.location('pathname').should('eq', '/inference');
-    cy.get('[data-testid="power-timeline"]').should('exist');
-    cy.wait('@series');
-    cy.get(
-      '[data-testid="power-timeline-chart-svg"] path.power-trace[data-segment="window"]',
-    ).should('have.length', CONFIGS.length);
-    assertShareLinkMetric('y_measuredPowerTimeline');
-    cy.get('[data-testid="power-timeline-focus"]').should('contain.text', 'c64');
-  });
-
-  it('offers the action on pinned ?unofficialrun= overlay tooltips and opens the overlay trace', () => {
-    interceptOverlay();
-    visitChart({
-      extraParams: `&unofficialrun=${OVERLAY_RUN_ID}&i_metric=y_measuredAvgPower`,
-    });
-    cy.wait('@unofficialRun');
-    pinPointTooltip('.unofficial-overlay-pt', 64);
-    cy.get(TELEMETRY_ACTION).should('not.exist');
-    cy.get(POWER_TRACE_ACTION).should('be.visible').should('contain.text', 'View power trace');
-    cy.get(POWER_TRACE_ACTION).click();
-
-    cy.get('[data-testid="power-timeline"]').should('exist');
-    cy.wait(['@series', '@overlaySeries']);
-    cy.get('[data-testid="power-timeline-chart-svg"]').within(() => {
-      cy.get('path.power-trace[data-run-index="0"][data-segment="window"]').should(
-        'have.length',
-        CONFIGS.length,
-      );
-    });
-    assertShareLinkMetric('y_measuredPowerTimeline');
-    cy.get('[data-testid="power-timeline-focus"]').should('contain.text', 'c64');
-  });
-
-  it('translates the tooltip action on /zh/inference', () => {
-    visitChart({ path: '/zh/inference', extraParams: '&i_metric=y_measuredAvgPower' });
-    pinPointTooltip('.dot-group', 64);
-    cy.get(POWER_TRACE_ACTION).should('be.visible').should('contain.text', '查看功耗曲线');
-  });
-});
diff --git a/packages/app/cypress/e2e/url-params.cy.ts b/packages/app/cypress/e2e/url-params.cy.ts
index 428b9833e..93f7ebda2 100644
--- a/packages/app/cypress/e2e/url-params.cy.ts
+++ b/packages/app/cypress/e2e/url-params.cy.ts
@@ -137,130 +137,6 @@ describe('URL Parameter Persistence', () => {
     });
   });
 
-  describe('Perf ruler share state', () => {
-    const chart = '#chart-0 svg';
-
-    // The second click completes a ruler only when the two curves share an
-    // x range; real fixture curves do not all overlap, so walk the hit
-    // strokes until one pairs with the first.
-    const completeRuler = (index: number) => {
-      cy.get(`${chart} .perf-ruler-hit`)
-        .its('length')
-        .then((count) => {
-          expect(index, 'a curve overlapping the first one').to.be.lessThan(count);
-          cy.get(`${chart} .perf-ruler-hit`).eq(index).click({ force: true });
-          cy.get(chart).then(($svg) => {
-            if ($svg.find('.perf-ruler').length === 0) completeRuler(index + 1);
-          });
-        });
-    };
-
-    it('round-trips a placed ruler through the share link and restores it on load', () => {
-      visitWithDismissedModal('/inference?g_model=DeepSeek-R1-0528&i_best=0');
-      cy.get(`${chart} .roofline-path`).should('have.length.greaterThan', 1);
-      expandLegendAdvanced();
-      cy.get('#scatter-perf-ruler').should('have.attr', 'aria-checked', 'false');
-      cy.get('#scatter-perf-ruler').click({ force: true });
-      cy.get(`${chart} .perf-ruler-hit`).should('have.length.greaterThan', 1);
-      cy.get(`${chart} .perf-ruler-hit`).eq(0).click({ force: true });
-      completeRuler(1);
-      cy.get(`${chart} .perf-ruler`).should('have.length', 1);
-
-      cy.get(`${chart} .perf-ruler .pr-text-ratio`)
-        .invoke('text')
-        .then((ratio) => {
-          expect(ratio).to.match(/^\d+\.\d{2}x$/u);
-          // The address bar stays clean after load, so the share link is
-          // where the placed ruler must show up.
-          cy.get('[data-testid="share-button"]').first().click();
-          cy.get('[data-testid="share-url-input"]')
-            .invoke('val')
-            .then((value) => {
-              const shareUrl = new URL(String(value));
-              const rulers = shareUrl.searchParams.get('i_rulers');
-              expect(rulers, 'i_rulers in the share link').to.match(
-                /^[\d.e+-]+\|roofline-[\w%.-]+\|roofline-[\w%.-]+$/u,
-              );
-
-              // Opening the link reproduces the ruler without a click and
-              // switches the tool on so it is visible.
-              visitWithDismissedModal(`${shareUrl.pathname}${shareUrl.search}`);
-              cy.get(`${chart} .perf-ruler`).should('have.length', 1);
-              // The link stores the iso-x to four significant digits, so the
-              // restored ratio may differ from the placed one in the last
-              // displayed decimal.
-              cy.get(`${chart} .perf-ruler .pr-text-ratio`)
-                .invoke('text')
-                .then((restoredRatio) => {
-                  expect(Number.parseFloat(restoredRatio)).to.be.closeTo(
-                    Number.parseFloat(ratio),
-                    0.011,
-                  );
-                });
-              expandLegendAdvanced();
-              cy.get('#scatter-perf-ruler').should('have.attr', 'aria-checked', 'true');
-              cy.get('[data-testid="share-button"]').first().click();
-              cy.get('[data-testid="share-url-input"]')
-                .invoke('val')
-                .then((restoredValue) => {
-                  expect(new URL(String(restoredValue)).searchParams.get('i_rulers')).to.equal(
-                    rulers,
-                  );
-                });
-              cy.get('body').type('{esc}');
-
-              // Clearing the rulers drops the param from the next share link.
-              cy.get('[data-testid="scatter-clear-perf-rulers"]').click();
-              cy.get(`${chart} .perf-ruler`).should('not.exist');
-              cy.get('[data-testid="share-button"]').first().click();
-              cy.get('[data-testid="share-url-input"]')
-                .invoke('val')
-                .should('not.include', 'i_rulers');
-            });
-        });
-    });
-
-    it('clears a restored ruler when the x-axis mode changes the rendered chart', () => {
-      // Build the link through the UI so it references curves the fixture
-      // really renders, then reopen it and swap the x axis: chart-0 now
-      // draws the e2e graph in seconds, so the ruler placed in tok/s/user
-      // must go, on screen and in the next share link.
-      visitWithDismissedModal('/inference?g_model=DeepSeek-R1-0528&i_best=0');
-      cy.get(`${chart} .roofline-path`).should('have.length.greaterThan', 1);
-      expandLegendAdvanced();
-      cy.get('#scatter-perf-ruler').click({ force: true });
-      cy.get(`${chart} .perf-ruler-hit`).should('have.length.greaterThan', 1);
-      cy.get(`${chart} .perf-ruler-hit`).eq(0).click({ force: true });
-      completeRuler(1);
-      cy.get(`${chart} .perf-ruler`).should('have.length', 1);
-      cy.get('[data-testid="share-button"]').first().click();
-      cy.get('[data-testid="share-url-input"]')
-        .invoke('val')
-        .then((value) => {
-          const shareUrl = new URL(String(value));
-          expect(shareUrl.searchParams.get('i_rulers')).to.include('|roofline-');
-          visitWithDismissedModal(`${shareUrl.pathname}${shareUrl.search}`);
-          cy.get(`${chart} .perf-ruler`).should('have.length', 1);
-
-          selectXAxisMode('e2e');
-          cy.get(`${chart} .perf-ruler`).should('not.exist');
-          cy.get('[data-testid="share-button"]').first().click();
-          cy.get('[data-testid="share-url-input"]')
-            .invoke('val')
-            .should('include', 'i_xmode=e2e')
-            .and('not.include', 'i_rulers');
-        });
-    });
-
-    it('ignores a malformed i_rulers value and leaves the tool off', () => {
-      visitWithDismissedModal('/inference?g_model=DeepSeek-R1-0528&i_rulers=not-a-ruler');
-      cy.get(`${chart} .roofline-path`).should('have.length.greaterThan', 1);
-      cy.get(`${chart} .perf-ruler`).should('not.exist');
-      expandLegendAdvanced();
-      cy.get('#scatter-perf-ruler').should('have.attr', 'aria-checked', 'false');
-    });
-  });
-
   describe('Provider remount state', () => {
     it('preserves filters across a standalone dashboard route', () => {
       visitWithDismissedModal('/inference');
diff --git a/packages/app/cypress/powerx-db/telemetry.cy.ts b/packages/app/cypress/powerx-db/telemetry.cy.ts
deleted file mode 100644
index 1e1e3dc7f..000000000
--- a/packages/app/cypress/powerx-db/telemetry.cy.ts
+++ /dev/null
@@ -1,300 +0,0 @@
-const POINT = '/api/v1/gpu-metrics-point?id=206885';
-const RUN = '34716669498';
-const telemetry = '[data-testid="power-telemetry-view"]';
-const statsCard = `${telemetry} > [data-slot="card"]:last-child`;
-
-function visit(url: string, delayTelemetry = false) {
-  cy.visit(url, {
-    onBeforeLoad(win) {
-      win.localStorage.setItem('inferencex-feature-gate', '1');
-      win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
-      if (delayTelemetry) {
-        const nativeFetch = win.fetch.bind(win);
-        win.fetch = async (...args) => {
-          const response = await nativeFetch(...args);
-          if (String(args[0]).includes('gpu-metrics-point')) {
-            await new Promise((resolve) => {
-              win.setTimeout(resolve, 700);
-            });
-          }
-          return response;
-        };
-      }
-    },
-  });
-}
-
-function captureViewport(selector: string, name: string, fromBottom = false) {
-  // Wait for Radix exit animations before scrolling or capturing the page.
-  cy.get('[data-slot="select-content"]').should('not.exist');
-  cy.get(selector).then(($target) => {
-    cy.window().then((win) => {
-      const rect = $target[0].getBoundingClientRect();
-      win.scrollTo({
-        top: win.scrollY + (fromBottom ? rect.bottom - 600 : rect.top - 112),
-        left: 0,
-        behavior: 'instant',
-      });
-    });
-  });
-  cy.screenshot(name, { capture: 'viewport' });
-}
-
-function refocus() {
-  cy.window().then((win) => {
-    Object.defineProperty(win.document, 'visibilityState', { configurable: true, value: 'hidden' });
-    win.dispatchEvent(new win.Event('visibilitychange'));
-    Object.defineProperty(win.document, 'visibilityState', {
-      configurable: true,
-      value: 'visible',
-    });
-    win.dispatchEvent(new win.Event('visibilitychange'));
-  });
-}
-
-describe('PowerX artifact → PostgreSQL → real API → browser', () => {
-  beforeEach(() => {
-    cy.on('uncaught:exception', (error) => {
-      if (error.message === 'ResizeObserver loop completed with undelivered notifications.')
-        return false;
-    });
-  });
-  afterEach(() => {
-    cy.task('setTelemetryAvailable', true);
-  });
-
-  it('loads NVIDIA point telemetry and the stored full-record digest without GitHub', () => {
-    cy.viewport(1280, 900);
-    // Delay the real fetch result; Cypress response intercepts race dev StrictMode aborts.
-    visit('/inference/agentic/206885?view=power', true);
-    cy.get('[data-testid="power-telemetry-loading"]').should('be.visible');
-    cy.get(telemetry).should('contain.text', 'collector-before-repair');
-    cy.request(POINT).then((response) => {
-      expect(response.status).to.eq(200);
-      expect(response.headers['cache-control']).to.eq('no-store');
-      const series = response.body.series[0];
-      expect(series.sampleCount).to.eq(16); // 17 CSV rows, one duplicate flush.
-      expect(
-        series.stats.find(
-          (row: { gpuIndex: number; metric: string }) =>
-            row.gpuIndex === 0 && row.metric === 'power_w',
-        ).mean,
-      ).to.eq(135);
-    });
-    cy.get(telemetry).should('contain.text', 'collector-before-repair');
-    cy.get('[data-testid="power-telemetry-sample-count"]').should('have.text', '16');
-    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '135.0');
-    cy.get('[data-testid="gpu-metrics-chart-svg"] path.line-path').should('have.length', 2);
-    captureViewport('[data-testid="power-telemetry-chart"]', 'point-nvidia-desktop-chart');
-    captureViewport(statsCard, 'point-nvidia-desktop-stats');
-  });
-
-  it('keeps AMD missing samples and metric units correct in Chinese on mobile', () => {
-    cy.viewport(390, 844);
-    visit('/zh/inference/agentic/206886?view=power');
-    cy.get(telemetry).should('contain.text', 'amd-smi');
-    cy.get('[data-testid="power-telemetry-metric-select"]').click();
-    cy.get('[data-slot="select-item"]').contains('GFX 电压 (mV)').click();
-    cy.get(`${telemetry} table`).should('contain.text', '平均值 (mV)');
-    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(1).should('have.text', '6');
-    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '850.0');
-    captureViewport(
-      '[data-testid="power-telemetry-metric-select"]',
-      'point-amd-mobile-zh-controls',
-    );
-    captureViewport('[data-testid="power-telemetry-chart"]', 'point-amd-mobile-zh-chart');
-    captureViewport(
-      '[data-testid="power-telemetry-chart"]',
-      'point-amd-mobile-zh-chart-bottom',
-      true,
-    );
-    captureViewport(statsCard, 'point-amd-mobile-zh-stats');
-  });
-
-  it('switches multinode series without merging host-local GPU zero', () => {
-    cy.viewport(1280, 900);
-    visit('/inference/agentic/206887?view=power');
-    cy.get(telemetry).should('contain.text', 'srt-slurm.dcgm-power');
-    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '535.0');
-    cy.get('#power-telemetry-series-select').click();
-    cy.get('[data-slot="select-item"]').contains('host-b').click();
-    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '635.0');
-    cy.get('[data-testid="power-telemetry-sample-count"]').should('have.text', '16');
-    cy.get('[data-testid="power-telemetry-metric-select"]').click();
-    cy.get('[data-slot="select-item"]').should('have.length', 1).and('contain.text', 'Power Draw');
-    cy.get('body').type('{esc}');
-    captureViewport('[data-testid="power-telemetry-chart"]', 'point-multinode-series-chart');
-    captureViewport(statsCard, 'point-multinode-series-stats');
-  });
-
-  for (const [prefix, width] of [
-    ['', 1280],
-    ['/zh', 390],
-  ] as const) {
-    it(`renders database Timeline with GitHub unavailable at ${prefix || 'en'} ${width}px`, () => {
-      cy.viewport(width, 900);
-      cy.request({ url: '/api/gpu-metrics?runId=999999', failOnStatusCode: false }).then(
-        (response) => {
-          expect(response.status).to.eq(500);
-          expect(response.body.error).to.eq('GitHub token not configured');
-        },
-      );
-      cy.intercept('POST', `/api/gpu-metrics?runId=${RUN}*`).as('timeline');
-      visit(
-        `${prefix}/inference?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4&i_metric=y_measuredPowerTimeline`,
-      );
-      cy.wait('@timeline').then(({ request, response }) => {
-        expect(request.body.sources).to.have.length(3);
-        expect(response!.statusCode).to.eq(200);
-        expect(response!.body.source).to.eq('database');
-        expect(response!.body.series).to.have.length(3);
-      });
-      cy.get(
-        '[data-testid="power-timeline-chart-svg"] path.power-trace[data-segment="full"]',
-      ).should('have.length', 3);
-      cy.get('[data-testid="power-timeline-missing"]').should('not.exist');
-      captureViewport(
-        '[data-testid="power-timeline"]',
-        `timeline-db-${prefix ? 'zh-mobile' : 'en-desktop'}`,
-      );
-      captureViewport(
-        '[data-testid="power-timeline-chart-svg"]',
-        `timeline-db-${prefix ? 'zh-mobile' : 'en-desktop'}-chart-bottom`,
-        true,
-      );
-    });
-  }
-
-  it('distinguishes a real database read error from missing data and retries successfully', () => {
-    cy.task('setTelemetryAvailable', false);
-    cy.request({
-      url: `/api/v1/views/gpu-metrics?runId=${RUN}`,
-      failOnStatusCode: false,
-    }).then(({ status, body, headers }) => {
-      expect(status).to.eq(503);
-      expect(body.error).to.eq('Source data unavailable');
-      expect(headers['cache-control']).to.eq('private, no-store');
-    });
-    visit('/zh/inference/agentic/206885?view=power');
-    cy.get('[data-testid="power-telemetry-query-error"]').should('be.visible');
-    cy.get('[data-testid="power-telemetry-missing"]').should('not.exist');
-    cy.task('setTelemetryAvailable', true);
-    cy.get('[data-testid="power-telemetry-query-error"]').contains('button', '重试').click();
-    cy.get(telemetry).should('contain.text', 'collector-before-repair');
-    cy.get('[data-testid="power-telemetry-query-error"]').should('not.exist');
-  });
-
-  it('shows a genuine missing point as missing', () => {
-    visit('/inference/agentic/999999?view=power');
-    cy.get('[data-testid="power-telemetry-missing"]').should('contain.text', '#999999');
-    cy.get('[data-testid="power-telemetry-query-error"]').should('not.exist');
-  });
-
-  it('returns retained full-record digests through the public view while filtering chart GPUs', () => {
-    cy.request('/api/v1/gpu-metrics-point?id=206888').then(({ body }) => {
-      const digest = body.series[0].stats
-        .filter((row: { metric: string }) => row.metric === 'power_w')
-        .sort((a: { mean: number }, b: { mean: number }) => b.mean - a.mean);
-      cy.request(
-        '/api/v1/views/gpu-metrics?runId=34175132645&metric=power&gpus=0&sort=mean&direction=desc',
-      ).then((response) => {
-        expect(response.status).to.eq(200);
-        expect(response.headers['cache-control']).to.eq('private, no-store');
-        expect(response.body.stats).to.deep.eq(digest);
-        expect(response.body.stats).to.have.length(8);
-        const gpu0 = response.body.stats.find((row: { gpuIndex: number }) => row.gpuIndex === 0);
-        expect(gpu0.count).to.eq(3);
-        expect(gpu0.mean).to.be.closeTo(351.4033333333333, 0.0001);
-        expect(response.body.rows).to.have.length(3);
-        expect(response.body.rows.every((row: { index: number }) => row.index === 0)).to.eq(true);
-        expect(Object.keys(response.body.chart)).to.deep.eq(['0']);
-      });
-    });
-  });
-
-  it('recovers a missing point link through unchanged-input ingest and browser refocus', () => {
-    cy.task('retainedTelemetry', false);
-    cy.task('unlinkRetainedPoint');
-    visit('/inference/agentic/206889?view=power');
-    cy.get('[data-testid="power-telemetry-missing"]').should('be.visible');
-    cy.request({ url: '/api/v1/gpu-metrics-point?id=206889', failOnStatusCode: false })
-      .its('status')
-      .should('eq', 404);
-    cy.task('retainedTelemetry', false).should('include', { samplesInserted: 0 });
-    refocus();
-    cy.get(telemetry).should('contain.text', 'retained-before-repair');
-    cy.get(`${telemetry} table tbody tr`).should('have.length', 8);
-    cy.request('/api/v1/gpu-metrics-point?id=206889').then(({ body }) => {
-      expect(body.series[0].sampleCount).to.eq(24);
-      expect(body.series[0].benchmarkResultIds).to.deep.eq([206888, 206889]);
-    });
-  });
-
-  it('refreshes corrected sidecars and timestamps on focus and reopening the tab', () => {
-    visit('/inference/agentic/206885?view=power');
-    cy.get(telemetry).should('contain.text', 'collector-before-repair');
-    cy.request(POINT).its('body.series.0.startedAt').should('eq', '2026-09-01T20:00:00.000Z');
-    cy.task('repairTelemetry');
-    refocus();
-    cy.get(telemetry).should('contain.text', 'collector-after-repair');
-    cy.request(POINT).then((response) => {
-      expect(response.body.series[0].startedAt).to.eq('2026-09-01T18:00:00.000Z');
-      expect(response.body.series[0].sampleCount).to.eq(16);
-    });
-    cy.get('[data-testid="detail-view-point"]').click();
-    cy.get('[data-testid="detail-view-power"]').click();
-    cy.get(telemetry).should('contain.text', 'collector-after-repair');
-    cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '135.0');
-    captureViewport(telemetry, 'point-after-reingest');
-  });
-
-  for (const [prefix, width] of [
-    ['', 1280],
-    ['/zh', 390],
-  ] as const) {
-    it(`repairs retained B200 telemetry through cache, shared points and ${prefix || 'en'} browser`, () => {
-      cy.task('retainedTelemetry', false);
-      cy.viewport(width, 900);
-      for (const id of [206888, 206889]) {
-        cy.request(`/api/v1/gpu-metrics-point?id=${id}`).then(({ body }) => {
-          expect(body.series[0].startedAt).to.eq('2026-09-08T07:20:19.279Z');
-          expect(body.series[0].sampleCount).to.eq(24);
-          expect(body.series[0].gpuCount).to.eq(8);
-          expect(body.series[0].benchmarkResultIds).to.deep.eq([206888, 206889]);
-          expect(body.series[0].data[0].power).to.be.closeTo(380.42, 0.0001);
-        });
-      }
-      visit(`${prefix}/inference/agentic/206888?view=power`);
-      cy.get(telemetry).should('contain.text', 'retained-before-repair');
-      cy.get('[data-testid="power-telemetry-sample-count"]').should('have.text', '24');
-      cy.get(`${telemetry} table tbody tr`).should('have.length', 8);
-      cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '351.4');
-      cy.task('retainedTelemetry', true).its('samplesInserted').should('eq', 24);
-      refocus();
-      cy.get(telemetry).should('contain.text', 'retained-after-repair');
-      cy.window().then((win) => {
-        const expected = new win.Date('2026-09-08T05:20:19.279Z').toLocaleTimeString(
-          prefix ? 'zh-CN' : undefined,
-        );
-        cy.get(telemetry).should('contain.text', expected);
-      });
-      for (const id of [206888, 206889]) {
-        cy.request(`/api/v1/gpu-metrics-point?id=${id}`).then(({ body }) => {
-          expect(body.series[0].startedAt).to.eq('2026-09-08T05:20:19.279Z');
-          expect(body.series[0].sampleCount).to.eq(24);
-          expect(JSON.stringify(body.series[0].sidecars)).to.contain('GPU-fixture-corrected-0');
-        });
-      }
-      cy.task('retainedTelemetry', true).should('include', {
-        samplesInserted: 0,
-        seriesSkipped: 1,
-      });
-      cy.get('[data-testid="detail-view-point"]').click();
-      cy.get('[data-testid="detail-view-power"]').click();
-      cy.get(telemetry).should('contain.text', 'retained-after-repair');
-      cy.get(`${telemetry} table tbody tr`).first().find('td').eq(4).should('have.text', '351.4');
-      captureViewport(telemetry, `retained-repair-${prefix ? 'zh-mobile' : 'en-desktop'}`);
-      captureViewport(statsCard, `retained-stats-${prefix ? 'zh-mobile' : 'en-desktop'}`);
-    });
-  }
-});
diff --git a/packages/app/cypress/support/share-link.ts b/packages/app/cypress/support/share-link.ts
deleted file mode 100644
index 0ff42a514..000000000
--- a/packages/app/cypress/support/share-link.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-/**
- * The address bar is stripped clean after load (share-link state lives in the
- * in-memory store), so the Share popover is where a metric change must land.
- * Closes the popover again so the controls stay clickable.
- */
-export function assertShareLinkMetric(metric: string): void {
-  assertShareLinkParams({ i_metric: metric });
-}
-
-/**
- * Asserts several share-link parameters in one popover round trip. A `null`
- * expectation means the parameter must be absent (stripped as a default).
- */
-export function assertShareLinkParams(expected: Record<string, string | null>): void {
-  cy.get('[data-testid="share-button"]').first().click();
-  cy.get('[data-testid="share-url-input"]')
-    .invoke('val')
-    .should((value) => {
-      const params = new URL(String(value)).searchParams;
-      for (const [key, param] of Object.entries(expected)) {
-        expect(params.get(key), `${key} in the share link`).to.eq(param);
-      }
-    });
-  // The link field is read-only, so dismiss the popover from the document.
-  cy.get('body').type('{esc}');
-  cy.get('[data-testid="share-url-input"]').should('not.exist');
-}
diff --git a/packages/app/package.json b/packages/app/package.json
index 8aefd19d3..dbc291ffe 100644
--- a/packages/app/package.json
+++ b/packages/app/package.json
@@ -24,7 +24,6 @@
     "test:e2e:full": "cypress run --component && cypress run",
     "test:e2e:component": "cypress run --component",
     "test:e2e:integration": "cypress run",
-    "test:e2e:powerx": "bun scripts/powerx-db-acceptance.ts",
     "test:unit": "bun --env-file=../../.env vitest run",
     "test:unit:coverage": "bun --env-file=../../.env vitest run --coverage",
     "clean": "rimraf .next out",
diff --git a/packages/app/scripts/powerx-db-acceptance.ts b/packages/app/scripts/powerx-db-acceptance.ts
deleted file mode 100644
index 6566c1eef..000000000
--- a/packages/app/scripts/powerx-db-acceptance.ts
+++ /dev/null
@@ -1,184 +0,0 @@
-/** bun scripts/powerx-db-acceptance.ts /absolute/output/directory; requires PostgreSQL 17 tools. */
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { execFileSync, spawn } from 'node:child_process';
-import { startPowerxBlobFixture } from './powerx-blob-fixture';
-
-const output = path.resolve(
-  process.argv[2] ?? fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-db-')),
-);
-const pgBin = process.env.POWERX_PG_BIN ?? '/opt/homebrew/opt/postgresql@17/bin';
-const appRoot = path.resolve(import.meta.dirname, '..');
-const pgData = path.join(output, 'postgres');
-const appPort = Number(process.env.POWERX_ACCEPTANCE_APP_PORT ?? 3137);
-const pgPort = Number(process.env.POWERX_ACCEPTANCE_PG_PORT ?? 3138);
-const baseUrl = `http://127.0.0.1:${appPort}`;
-const dbUrl = `postgres://powerx_acceptance@127.0.0.1:${pgPort}/powerx_acceptance`;
-fs.mkdirSync(output, { recursive: true });
-const blob = await startPowerxBlobFixture();
-const env = {
-  ...process.env,
-  POWERX_ACCEPTANCE_OUTPUT: output,
-  POWERX_ACCEPTANCE_DATABASE_URL: dbUrl,
-  POWERX_ACCEPTANCE_BASE_URL: baseUrl,
-  DATABASE_READONLY_URL: dbUrl,
-  DATABASE_WRITE_URL: '',
-  DATABASE_DRIVER: 'postgres',
-  DATABASE_SSL: 'false',
-  E2E_FIXTURES: '0',
-  GITHUB_TOKEN: '',
-  ...blob.env,
-  NEXT_PUBLIC_POSTHOG_KEY: '',
-};
-let server: ReturnType<typeof spawn> | undefined;
-let dbStarted = false;
-const cleanupErrors: string[] = [];
-const receipt = {
-  output,
-  database: 'disposable localhost PostgreSQL',
-  githubToken: false,
-  blobCache: 'real SDK, local HTTP transport',
-  retainedFixture: JSON.parse(
-    fs.readFileSync(
-      path.resolve(appRoot, '../../docs/fixtures/powerx-reingest/provenance.json'),
-      'utf8',
-    ),
-  ),
-  exitCode: 1,
-  cleanupErrors,
-};
-try {
-  execFileSync(
-    path.join(pgBin, 'initdb'),
-    ['-D', pgData, '-A', 'trust', '-U', 'powerx_acceptance', '--no-locale', '--encoding=UTF8'],
-    { stdio: 'pipe' },
-  );
-  execFileSync(
-    path.join(pgBin, 'pg_ctl'),
-    [
-      '-D',
-      pgData,
-      '-l',
-      path.join(output, 'postgres.log'),
-      '-o',
-      `-h 127.0.0.1 -p ${pgPort} -k /tmp`,
-      'start',
-    ],
-    { stdio: 'pipe' },
-  );
-  dbStarted = true;
-  execFileSync(path.join(pgBin, 'createdb'), [
-    '-h',
-    '127.0.0.1',
-    '-p',
-    String(pgPort),
-    '-U',
-    'powerx_acceptance',
-    'powerx_acceptance',
-  ]);
-  const seedLog = fs.openSync(path.join(output, 'seed.log'), 'w');
-  execFileSync('bun', ['scripts/powerx-db-fixture.ts', 'seed'], {
-    cwd: appRoot,
-    env,
-    stdio: ['ignore', seedLog, seedLog],
-  });
-  fs.closeSync(seedLog);
-  const serverLog = fs.openSync(path.join(output, 'next.log'), 'w');
-  server = spawn(
-    'node',
-    [
-      'node_modules/next/dist/bin/next',
-      'dev',
-      '--hostname',
-      '127.0.0.1',
-      '--port',
-      String(appPort),
-    ],
-    {
-      cwd: appRoot,
-      env,
-      detached: true,
-      stdio: ['ignore', serverLog, serverLog],
-    },
-  );
-  let ready = false;
-  for (let i = 0; i < 60; i++) {
-    try {
-      const response = await fetch(`${baseUrl}/api/v1/gpu-metrics-point?id=206885`, {
-        signal: AbortSignal.timeout(5000),
-      });
-      if (response.ok) {
-        ready = true;
-        break;
-      }
-    } catch {
-      /* Connection refusal is expected while Next starts. */
-    }
-    await new Promise((resolve) => {
-      setTimeout(resolve, 500);
-    });
-  }
-  if (!ready) throw new Error(`Local server did not become ready; inspect ${output}/next.log`);
-  await fetch(`${baseUrl}/inference/agentic/206885?view=power`);
-  await fetch(`${baseUrl}/zh/inference/agentic/206885?view=power`);
-  await fetch(`${baseUrl}/inference`);
-  const browserLog = fs.openSync(path.join(output, 'browser.log'), 'w');
-  const browser = spawn(
-    'node',
-    ['node_modules/cypress/bin/cypress', 'run', '--config-file', 'cypress.powerx-db.config.ts'],
-    {
-      cwd: appRoot,
-      env,
-      stdio: ['ignore', browserLog, browserLog],
-    },
-  );
-  receipt.exitCode = await new Promise<number>((resolve) => {
-    browser.on('exit', (code) => resolve(code ?? 1));
-  });
-  const revisions = [...blob.objects.values()]
-    .map((value) => JSON.parse(value))
-    .filter((payload) => payload?.benchmarkResultId === 206885);
-  const producers = revisions.map((payload) => payload.series[0].sidecars.context.producer);
-  const retainedProducers = [...blob.objects.values()]
-    .map((value) => JSON.parse(value))
-    .filter((payload) => [206888, 206889].includes(payload?.benchmarkResultId))
-    .map((payload) => payload.series[0].sidecars.context.producer);
-  const cacheVerified =
-    blob.counts.reads > 0 &&
-    producers.includes('collector-before-repair') &&
-    producers.includes('collector-after-repair') &&
-    retainedProducers.includes('retained-before-repair') &&
-    retainedProducers.includes('retained-after-repair');
-  fs.writeFileSync(
-    path.join(output, 'blob-receipt.json'),
-    JSON.stringify({ counts: blob.counts, producers, retainedProducers, cacheVerified }, null, 2),
-  );
-  if (!cacheVerified) receipt.exitCode = 1;
-  fs.closeSync(browserLog);
-  fs.closeSync(serverLog);
-} finally {
-  try {
-    if (server?.pid) process.kill(-server.pid, 'SIGTERM');
-  } catch (error) {
-    if (!(error instanceof Error && 'code' in error && error.code === 'ESRCH'))
-      cleanupErrors.push(`Next: ${String(error)}`);
-  }
-  try {
-    if (dbStarted)
-      execFileSync(path.join(pgBin, 'pg_ctl'), ['-D', pgData, '-m', 'fast', 'stop'], {
-        stdio: 'pipe',
-      });
-  } catch (error) {
-    cleanupErrors.push(`PostgreSQL: ${String(error)}`);
-  }
-  try {
-    await blob.close();
-  } catch (error) {
-    cleanupErrors.push(`Blob fixture: ${String(error)}`);
-  }
-  if (cleanupErrors.length > 0) receipt.exitCode = 1;
-  fs.writeFileSync(path.join(output, 'receipt.json'), JSON.stringify(receipt, null, 2));
-}
-console.log(JSON.stringify(receipt));
-process.exitCode = receipt.exitCode;
diff --git a/packages/app/scripts/powerx-db-fixture.ts b/packages/app/scripts/powerx-db-fixture.ts
deleted file mode 100644
index 5ce4d65b1..000000000
--- a/packages/app/scripts/powerx-db-fixture.ts
+++ /dev/null
@@ -1,256 +0,0 @@
-/** Disposable localhost-only browser fixture. Telemetry always goes through production ingest. */
-import fs from 'node:fs';
-import path from 'node:path';
-import { createHash } from 'node:crypto';
-import { createAdminSql } from '@semianalysisai/inferencex-db/etl/db-utils';
-
-import { ingestGpuMetricsArtifact } from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
-import { runMigrations } from '@semianalysisai/inferencex-db/lib/migration-runner';
-
-const url = new URL(process.env.POWERX_ACCEPTANCE_DATABASE_URL ?? '');
-if (url.hostname !== '127.0.0.1' || url.pathname !== '/powerx_acceptance') {
-  throw new Error('This fixture only writes the disposable loopback powerx_acceptance database');
-}
-const sql = createAdminSql({ url: url.toString(), noSsl: true, max: 1, onnotice: () => {} });
-const output = process.env.POWERX_ACCEPTANCE_OUTPUT!;
-const artifactsDir = path.join(output, 'artifacts');
-const runId = 34716669498;
-const start = Date.UTC(2026, 8, 1, 20) / 1000;
-const suffixes = [
-  'dsv4_8k1k_fp4_sglang_tp2_conc16_b200-local_0',
-  'dsv4_8k1k_fp4_sglang_tp1_conc32_mi355x-local_0',
-  'dsv4_8k1k_fp4_sglang_tp4_conc64_b200-multinode_0',
-];
-const retainedName = 'gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc1_b200-retained_0';
-
-function write(name: string, file: string, contents: string) {
-  const target = path.join(artifactsDir, name, file);
-  fs.mkdirSync(path.dirname(target), { recursive: true });
-  fs.writeFileSync(target, contents);
-}
-
-function ingest(index: number) {
-  const artifactName = `${index === 2 ? 'power_audit_' : 'gpu_metrics_'}${suffixes[index]}`;
-  return ingestGpuMetricsArtifact(sql, {
-    workflowRunId: 1,
-    artifact: { artifactName, artifactDir: path.join(artifactsDir, artifactName) },
-    benchmarkResultIds: [206885 + index],
-  });
-}
-
-async function ingestRetained(repaired: boolean) {
-  // CSV bytes are retained; sidecars deliberately inject a repair scenario.
-  write(
-    retainedName,
-    'gpu_metrics_context.json',
-    JSON.stringify({
-      timestamp_timezone: repaired ? '+02:00' : 'UTC',
-      producer: repaired ? 'retained-after-repair' : 'retained-before-repair',
-    }),
-  );
-  write(
-    retainedName,
-    'gpu_metrics_identity.csv',
-    [
-      'index,uuid,name',
-      ...Array.from(
-        { length: 8 },
-        (_, gpu) => `${gpu},GPU-fixture-${repaired ? 'corrected' : 'original'}-${gpu},NVIDIA B200`,
-      ),
-    ].join('\n'),
-  );
-  const result = await ingestGpuMetricsArtifact(sql, {
-    workflowRunId: 2,
-    artifact: { artifactName: retainedName, artifactDir: path.join(artifactsDir, retainedName) },
-    benchmarkResultIds: [206888, 206889],
-  });
-  return result;
-}
-
-async function seed() {
-  const fixtureDir = path.resolve(import.meta.dirname, '../../../docs/fixtures/powerx-reingest');
-  const retainedCsv = fs.readFileSync(path.join(fixtureDir, 'nvidia.csv'));
-  const retainedSha256 = createHash('sha256').update(retainedCsv).digest('hex');
-  const provenance = JSON.parse(fs.readFileSync(path.join(fixtureDir, 'provenance.json'), 'utf8'));
-  if (retainedSha256 !== provenance.fixture.sha256) throw new Error('Retained CSV hash mismatch');
-  await runMigrations(sql, path.resolve(import.meta.dirname, '../../db/migrations'));
-  await sql`INSERT INTO workflow_runs
-    (id, github_run_id, run_attempt, name, status, conclusion, head_branch, head_sha, html_url, created_at, run_started_at, date)
-    VALUES (1, ${runId}, 1, 'PowerX local acceptance', 'completed', 'success', 'main', 'local-fixture',
-      ${`https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${runId}`},
-      '2026-09-01T20:00:00Z', '2026-09-01T20:00:00Z', '2026-09-01')`;
-  for (let i = 0; i < 3; i++) {
-    const gpuCount = [2, 1, 4][i];
-    await sql`INSERT INTO configs
-      (id, model, hardware, framework, precision, spec_method, disagg, is_multinode,
-       prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
-      VALUES (${i + 1}, 'dsv4', ${i === 1 ? 'mi355x' : 'b200'}, 'sglang', 'fp4', 'none', false,
-        ${i === 2}, ${gpuCount}, ${gpuCount}, ${gpuCount}, ${gpuCount})`;
-    await sql`INSERT INTO benchmark_results
-      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, image, metrics, power_audit)
-      VALUES (${206885 + i}, 1, ${i + 1}, 'single_turn', '2026-09-01', 8192, 1024, ${16 * 2 ** i},
-        'sglang:local-fixture', ${sql.json({
-          median_intvty: 90 - i * 20,
-          median_itl: 1 / (90 - i * 20),
-          median_e2el: 20,
-          median_ttft: 0.5,
-          tput_per_gpu: 1800,
-          output_tput_per_gpu: 200,
-          input_tput_per_gpu: 1600,
-          power_valid: 1,
-          power_metric_schema_version: 2,
-          avg_power_w: [185, 470, 595][i],
-          avg_total_gpu_power_w: [370, 470, 2380][i],
-          joules_per_output_token: [0.925, 2.35, 2.975][i],
-        })}, ${sql.json({
-          source: `power_validation_${suffixes[i]}.json`,
-          sample_count: gpuCount * 4,
-          window_start_unix: start + 2,
-          window_end_unix: start + 5,
-          observed_gpu_ids: Array.from({ length: gpuCount }, (_, gpu) => String(gpu)),
-        })})`;
-  }
-  const nvidia = `gpu_metrics_${suffixes[0]}`;
-  const nvidiaRows = Array.from({ length: 8 }, (_, sample) =>
-    [0, 1].map(
-      (gpu) =>
-        `2026/09/01 20:00:0${sample}, ${gpu}, ${100 + gpu * 100 + sample * 10} W, ${40 + sample}, 1500 MHz, 3996 MHz, ${sample * 10} %, 0 %`,
-    ),
-  ).flat();
-  write(
-    nvidia,
-    'gpu_metrics.csv',
-    [
-      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
-      ...nvidiaRows,
-      nvidiaRows.at(-1),
-    ].join('\n'),
-  );
-  write(
-    nvidia,
-    'gpu_metrics_context.json',
-    JSON.stringify({ timestamp_timezone: 'UTC', producer: 'collector-before-repair' }),
-  );
-  write(
-    nvidia,
-    'gpu_metrics_identity.csv',
-    'index,uuid,name\n0,GPU-n0,NVIDIA B200\n1,GPU-n1,NVIDIA B200\n',
-  );
-  const amd = `gpu_metrics_${suffixes[1]}`;
-  write(
-    amd,
-    'gpu_metrics.csv',
-    [
-      'timestamp,gpu,gfx_activity,umc_activity,mm_activity,socket_power,gfx_voltage,soc_voltage,mem_voltage,gfx_0_clk,mem_0_clk,fclk_0_clk,socclk_0_clk,edge,hotspot,mem',
-      ...Array.from(
-        { length: 8 },
-        (_, sample) =>
-          `${start + sample},0,90,80,N/A,${400 + sample * 20},${sample < 2 ? 'N/A' : 850},900,1250,2402,2000,1250,39,55,78,60`,
-      ),
-    ].join('\n'),
-  );
-  const multi = `power_audit_${suffixes[2]}`;
-  write(
-    multi,
-    'LOGS/power/samples.csv',
-    [
-      'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
-      ...Array.from({ length: 8 }, (_, sample) =>
-        ['host-a', 'host-b'].flatMap((host, h) =>
-          [0, 1].map(
-            (gpu) =>
-              `1,${start + sample},${sample},${host},${gpu},GPU-${host}-${gpu},${500 + h * 100 + gpu * 20 + sample * 10}`,
-          ),
-        ),
-      ).flat(),
-    ].join('\n'),
-  );
-  write(
-    multi,
-    'LOGS/power/manifest.json',
-    JSON.stringify({
-      producer: 'srt-slurm.dcgm-power',
-      expected_devices: ['host-a', 'host-b'].flatMap((hostname) =>
-        [0, 1].map((gpu_index) => ({ hostname, gpu_index })),
-      ),
-    }),
-  );
-  write(
-    multi,
-    `power_validation_${suffixes[2]}.json`,
-    JSON.stringify({
-      selected_window: { start_time_unix: start + 2, end_time_unix: start + 5 },
-    }),
-  );
-  const results = [];
-  for (let i = 0; i < 3; i++) results.push(await ingest(i));
-  // Benchmark rows are local linkage fixtures, not republished benchmark measurements.
-  await sql`INSERT INTO workflow_runs
-    (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
-    VALUES (2, 34175132645, 1, 'Retained telemetry recovery fixture', 'completed', 'success',
-      '2026-09-08T07:20:19Z', '2026-09-08')`;
-  await sql`INSERT INTO configs
-    (id, model, hardware, framework, precision, spec_method, disagg,
-     prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
-    VALUES (4, 'qwen3.5', 'b200', 'sglang', 'fp8', 'none', false, 8, 8, 8, 8)`;
-  await sql`INSERT INTO benchmark_results
-    (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
-    VALUES (206888, 2, 4, 'single_turn', '2026-09-08', 8192, 1024, 1, '{}'),
-           (206889, 2, 4, 'single_turn', '2026-09-08', 8192, 1024, 2, '{}')`;
-  write(retainedName, 'gpu_metrics.csv', retainedCsv.toString());
-  const retained = await ingestRetained(false);
-  await sql`REFRESH MATERIALIZED VIEW latest_benchmarks`;
-  fs.writeFileSync(
-    path.join(output, 'seed-receipt.json'),
-    JSON.stringify(
-      {
-        runId,
-        pointIds: [206885, 206886, 206887],
-        results,
-        retained: {
-          runId: 34175132645,
-          pointIds: [206888, 206889],
-          sha256: retainedSha256,
-          result: retained,
-        },
-      },
-      null,
-      2,
-    ),
-  );
-}
-
-try {
-  if (process.argv[2] === 'seed') await seed();
-  else if (process.argv[2] === 'repair') {
-    write(
-      `gpu_metrics_${suffixes[0]}`,
-      'gpu_metrics_context.json',
-      JSON.stringify({
-        timestamp_timezone: '+02:00',
-        producer: 'collector-after-repair',
-      }),
-    );
-    const result = await ingest(0);
-    fs.writeFileSync(path.join(output, 'repair-receipt.json'), JSON.stringify(result, null, 2));
-    console.log(JSON.stringify(result));
-  } else if (process.argv[2] === 'retained-repair' || process.argv[2] === 'retained-reset') {
-    const result = await ingestRetained(process.argv[2] === 'retained-repair');
-    fs.writeFileSync(
-      path.join(output, `${process.argv[2]}-receipt.json`),
-      JSON.stringify(result, null, 2),
-    );
-    console.log(JSON.stringify(result));
-  } else if (process.argv[2] === 'unlink-retained-point') {
-    await sql`DELETE FROM benchmark_result_gpu_metrics WHERE benchmark_result_id = 206889`;
-  } else if (process.argv[2] === 'unavailable') {
-    await sql`ALTER TABLE gpu_metric_series RENAME TO gpu_metric_series_unavailable`;
-  } else if (process.argv[2] === 'restore') {
-    await sql`ALTER TABLE IF EXISTS gpu_metric_series_unavailable RENAME TO gpu_metric_series`;
-  } else
-    throw new Error(
-      'Expected seed, repair, retained-repair, retained-reset, unlink-retained-point, unavailable, or restore',
-    );
-} finally {
-  await sql.end();
-}
diff --git a/packages/app/src/app/api/gpu-metrics/route.context.test.ts b/packages/app/src/app/api/gpu-metrics/route.context.test.ts
index 02a12b63e..1e2b58eeb 100644
--- a/packages/app/src/app/api/gpu-metrics/route.context.test.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.context.test.ts
@@ -1,16 +1,7 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import AdmZip from 'adm-zip';
 import { NextRequest } from 'next/server';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { prepareGpuMetricsArtifact } from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
-import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
-
-import { cutPowerAuditBundle } from '@/components/gpu-power/power-audit-bundle';
-import { parseCsvData } from '@/components/gpu-power/types';
-
 const { readStored } = vi.hoisted(() => ({ readStored: vi.fn() }));
 vi.mock('@semianalysisai/inferencex-db/connection', () => ({ getDb: () => ({}) }));
 vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
@@ -22,7 +13,6 @@ import { GET } from './route';
 const HEADER =
   'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
 const CSV = `${HEADER}\n2026/09/21 00:00:00.000, 0, 100 W, 40, 1500, 2000, 90, 80\n2026/09/21 00:00:01.000, 0, 200 W, 41, 1500, 2000, 90, 80\n`;
-const directories: string[] = [];
 
 beforeEach(() => {
   readStored.mockReset().mockResolvedValue(null);
@@ -33,15 +23,10 @@ beforeEach(() => {
 afterEach(() => {
   vi.unstubAllGlobals();
   vi.unstubAllEnvs();
-  for (const directory of directories.splice(0)) fs.rmSync(directory, { recursive: true });
 });
 
-function liveArtifact(
-  files: Record<string, string>,
-  name = 'gpu_metrics_probe_live',
-  options: Partial<AdmZip.InitOptions> = {},
-) {
-  const zip = new AdmZip(undefined, options);
+function liveArtifact(files: Record<string, string>) {
+  const zip = new AdmZip();
   for (const [entry, contents] of Object.entries(files)) zip.addFile(entry, Buffer.from(contents));
   const bytes = zip.toBuffer();
   vi.stubGlobal(
@@ -51,7 +36,13 @@ function liveArtifact(
       if (url.includes('/artifacts?')) {
         return Promise.resolve(
           Response.json({
-            artifacts: [{ id: 2, name, archive_download_url: 'https://example.test/dl/live' }],
+            artifacts: [
+              {
+                id: 2,
+                name: 'gpu_metrics_probe_live',
+                archive_download_url: 'https://example.test/dl/live',
+              },
+            ],
           }),
         );
       }
@@ -79,146 +70,15 @@ function liveArtifact(
       throw new Error(`Unexpected network request: ${url}`);
     }),
   );
-  return bytes;
 }
 
-async function readRoute(params = '') {
-  const response = await GET(
-    new NextRequest(`http://localhost/api/gpu-metrics?runId=12345${params}`),
-  );
+async function readRoute() {
+  const response = await GET(new NextRequest('http://localhost/api/gpu-metrics?runId=12345'));
   expect(response.status).toBe(200);
   return response.json();
 }
 
-function prepareSeries(files: Record<string, string>, artifactName: string): GpuMetricSeries[] {
-  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-context-'));
-  directories.push(directory);
-  for (const [name, contents] of Object.entries(files)) {
-    const file = path.join(directory, name);
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, contents);
-  }
-  return prepareGpuMetricsArtifact({ artifactName, artifactDir: directory }).map(
-    (entry, index) => ({
-      id: index + 1,
-      artifactName,
-      configKey: artifactName.slice('gpu_metrics_'.length),
-      fileName: entry.fileName,
-      vendor: entry.vendor,
-      sampleIntervalS: entry.sampleIntervalS,
-      sampleCount: entry.samples.length,
-      gpuCount: entry.gpuCount,
-      startedAt: new Date(entry.startedAtMs).toISOString(),
-      endedAt: new Date(entry.endedAtMs).toISOString(),
-      sidecars: { ...entry.sidecars },
-      benchmarkResultIds: [index + 1],
-      stats: [],
-      data: entry.samples.map((sample) => ({
-        timestamp: new Date(sample.timestampMs).toISOString(),
-        index: sample.gpuIndex,
-        power: sample.powerW!,
-      })),
-    }),
-  );
-}
-
 describe('GET /api/gpu-metrics collector context', () => {
-  it.each([
-    {
-      label: 'reversed lowercase names',
-      contexts: [
-        ['z_gpu_metrics_context.json', '+02:00'],
-        ['a_gpu_metrics_context.json', '-07:00'],
-      ],
-      expected: '2026-09-21T07:00:00.000Z',
-      expectedZone: '-07:00',
-    },
-    {
-      label: 'code-unit ordering of uppercase and lowercase names',
-      contexts: [
-        ['a_gpu_metrics_context.json', '-07:00'],
-        ['Z_gpu_metrics_context.json', '+02:00'],
-      ],
-      expected: '2026-09-20T22:00:00.000Z',
-      expectedZone: '+02:00',
-    },
-  ])('ignores ZIP context order: $label', async ({ contexts, expected, expectedZone }) => {
-    const files: Record<string, string> = {
-      ...Object.fromEntries(
-        contexts.map(([name, zone]) => [name, JSON.stringify({ timestamp_timezone: zone })]),
-      ),
-      '0_gpu_metrics_context.json': '{bad json',
-      'gpu_metrics.csv': CSV,
-      'power_validation_probe.json': JSON.stringify({
-        selected_window: {
-          start_time_unix: Date.parse('2026-09-20T22:00:00Z') / 1000,
-          end_time_unix: Date.parse('2026-09-21T07:00:01Z') / 1000,
-        },
-      }),
-    };
-    const bytes = liveArtifact(files, 'gpu_metrics_probe_live', { noSort: true });
-    const archive = new AdmZip(bytes);
-    expect(archive.getEntries().map((entry) => entry.entryName)).toEqual(Object.keys(files));
-    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-context-order-'));
-    directories.push(directory);
-    archive.extractAllTo(directory);
-    const [stored] = prepareGpuMetricsArtifact({
-      artifactName: 'gpu_metrics_probe_live',
-      artifactDir: directory,
-    });
-    expect(stored.sidecars.context).toEqual({ timestamp_timezone: expectedZone });
-    expect(new Date(stored.startedAtMs).toISOString()).toBe(expected);
-
-    const raw = await readRoute();
-    expect.soft(raw.artifacts[0].data[0].timestamp).toBe(expected);
-    const power = await readRoute('&series=power');
-    expect.soft(power.series[0].startMs).toBe(Date.parse(expected));
-
-    liveArtifact(files, 'power_audit_probe', { noSort: true });
-    const bundle = await readRoute('&series=power');
-    expect.soft(bundle.series[0].startMs).toBe(Date.parse(expected));
-    expect(bundle.series[0].power).toEqual([[100, 200]]);
-  });
-
-  it.each([
-    ['gpu_metrics_context.json', '-07:00', '2026-09-21T07:00:00.000Z'],
-    ['gpu_metrics_context.json', '+05:30', '2026-09-20T18:30:00.000Z'],
-    ['gpu_metrics_context.json', ' +0530 ', '2026-09-20T18:30:00.000Z'],
-    ['gpu_metrics_context.JSON', '-07:00', '2026-09-21T07:00:00.000Z'],
-    ['gpu_metrics_CONTEXT.JSON', '+05:30', '2026-09-20T18:30:00.000Z'],
-  ])('aligns live CSV, ingest and bundle timestamps for %s (%s)', async (name, zone, expected) => {
-    const files: Record<string, string> = {
-      'gpu_metrics.csv': CSV,
-    };
-    if (name === 'gpu_metrics_context.JSON') files['gpu_metrics_bad_context.json'] = '{bad json';
-    files[name] = JSON.stringify({ timestamp_timezone: zone });
-    const stored = prepareSeries(files, 'gpu_metrics_probe_live');
-    expect(stored[0].startedAt).toBe(expected);
-    liveArtifact(files);
-
-    const raw = await readRoute();
-    expect(raw.artifacts[0].data[0].timestamp).toBe(expected);
-    const power = await readRoute('&series=power');
-    expect(power.series[0].startMs).toBe(Date.parse(expected));
-    expect(power.series[0].power).toEqual([[100, 200]]);
-
-    const bundleFiles = {
-      ...files,
-      'power_validation_probe.json': JSON.stringify({
-        selected_window: {
-          start_time_unix: Date.parse(expected) / 1000,
-          end_time_unix: Date.parse(expected) / 1000 + 1,
-        },
-      }),
-    };
-    const bundle = cutPowerAuditBundle('power_audit_probe', new Map(Object.entries(bundleFiles)));
-    expect(bundle[0]?.startMs).toBe(Date.parse(expected));
-    expect(bundle[0]?.power).toEqual([[100, 200]]);
-    liveArtifact(bundleFiles, 'power_audit_probe');
-    const bundleRoute = await readRoute('&series=power');
-    expect(bundleRoute.series).toEqual(bundle);
-  });
-
   it('uses each host directory context and skips malformed neighboring context files', async () => {
     liveArtifact({
       'gpu_metrics_context.json': '{"timestamp_timezone":"+12:00"}',
@@ -246,97 +106,4 @@ describe('GET /api/gpu-metrics collector context', () => {
       },
     ]);
   });
-
-  it.each([
-    ['absent', undefined],
-    ['malformed', '{bad json'],
-    ['non-object', '[]'],
-    ['unknown zone', '{"timestamp_timezone":"America/Los_Angeles"}'],
-    ['UTC', '{"timestamp_timezone":"UTC"}'],
-  ])(
-    'keeps UTC behavior with %s context and ignores other directories',
-    async (_label, context) => {
-      const files: Record<string, string> = {
-        'gpu_metrics_host/gpu_metrics.csv': CSV,
-        'gpu_metrics_context.json': '{"timestamp_timezone":"-07:00"}',
-        'gpu_metrics_host/unrelated_context.json': '{"timestamp_timezone":"+05:30"}',
-        'gpu_metrics_host/GPU_METRICS_context.JSON': '{"timestamp_timezone":"+05:30"}',
-      };
-      if (context !== undefined) files['gpu_metrics_host/gpu_metrics_context.json'] = context;
-      liveArtifact(files);
-      const raw = await readRoute();
-      expect(raw.artifacts[0].data[0].timestamp).toBe('2026/09/21 00:00:00.000');
-      const power = await readRoute('&series=power');
-      expect(power.series[0].startMs).toBe(Date.parse('2026-09-21T00:00:00Z'));
-    },
-  );
-
-  it.each([
-    ['ISO', `${HEADER}\n2026-09-21T07:00:00Z, 0, 100 W, 40, 1500, 2000, 90, 80\n`],
-    [
-      'AMD seconds',
-      `timestamp,gpu,socket_power\n${Date.parse('2026-09-21T07:00:00Z') / 1000},0,100\n`,
-    ],
-    [
-      'AMD milliseconds',
-      `timestamp,gpu,socket_power\n${Date.parse('2026-09-21T07:00:00Z')},0,100\n`,
-    ],
-  ])('does not apply the collector offset twice to %s timestamps', async (_label, csv) => {
-    liveArtifact({
-      'gpu_metrics.csv': csv,
-      'gpu_metrics_context.json': '{"timestamp_timezone":"-07:00"}',
-    });
-    const raw = await readRoute();
-    expect(raw.artifacts[0].data[0].timestamp).toBe(parseCsvData(csv)[0].timestamp);
-    const power = await readRoute('&series=power');
-    expect(power.series[0].startMs).toBe(Date.parse('2026-09-21T07:00:00Z'));
-  });
-
-  it('keeps recovered live power aligned with durable history and raw responses', async () => {
-    const files = {
-      'gpu_metrics.csv': CSV,
-      'gpu_metrics_context.json': '{"timestamp_timezone":"-07:00"}',
-    };
-    const healthy = prepareSeries(files, 'gpu_metrics_probe_stored');
-    const partial = prepareSeries(files, 'gpu_metrics_probe_live');
-    partial[0].data = partial[0].data.slice(0, 1);
-    readStored.mockResolvedValue({
-      workflowRun: {
-        id: 7,
-        githubRunId: 12345,
-        runAttempt: 1,
-        name: 'Controlled context fixture',
-        date: '2026-09-21',
-        htmlUrl: 'https://example.test/runs/12345',
-        headBranch: 'test',
-        headSha: 'fixture',
-        conclusion: 'success',
-        status: 'completed',
-        createdAt: '2026-09-21T00:00:00Z',
-      },
-      series: [...healthy, ...partial],
-    });
-    liveArtifact(files);
-    const power = await readRoute('&series=power&prefix=probe_');
-    expect(power.source).toBe('github');
-    expect(power.series).toMatchObject([
-      {
-        artifact: 'gpu_metrics_probe_stored',
-        startMs: Date.parse('2026-09-21T07:00:00Z'),
-        power: [[100, 200]],
-      },
-      {
-        artifact: 'gpu_metrics_probe_live',
-        startMs: Date.parse('2026-09-21T07:00:00Z'),
-        power: [[100, 200]],
-      },
-    ]);
-
-    const storedRaw = await readRoute('&prefix=probe_stored');
-    expect(storedRaw.source).toBe('database');
-    readStored.mockResolvedValue(null);
-    const liveRaw = await readRoute('&prefix=probe_live');
-    expect(liveRaw.source).toBe('github');
-    expect(liveRaw.artifacts[0].data).toMatchObject(storedRaw.artifacts[0].data);
-  });
 });
diff --git a/packages/app/src/app/api/gpu-metrics/route.sources.test.ts b/packages/app/src/app/api/gpu-metrics/route.sources.test.ts
index f8d59998b..6b2a98f82 100644
--- a/packages/app/src/app/api/gpu-metrics/route.sources.test.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.sources.test.ts
@@ -1,14 +1,8 @@
-import AdmZip from 'adm-zip';
 import { NextRequest } from 'next/server';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
 import { parseCsvData } from '@/components/gpu-power/types';
-import type { InferenceData } from '@/components/inference/types';
-import {
-  joinPowerTimeline,
-  planPowerTimelineRequests,
-} from '@/components/inference/utils/powerTimeline';
 
 const { readRun } = vi.hoisted(() => ({ readRun: vi.fn() }));
 vi.mock('@semianalysisai/inferencex-db/connection', () => ({
@@ -18,7 +12,7 @@ vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
   getGpuMetricsForRun: readRun,
 }));
 
-import { GET, POST } from './route';
+import { POST } from './route';
 
 const RUN_ID = '12345';
 const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
@@ -75,51 +69,6 @@ function stored(name: string, power = 100): GpuMetricSeries {
   };
 }
 
-function zip(entries: Record<string, string>): Uint8Array<ArrayBuffer> {
-  const archive = new AdmZip();
-  for (const [name, text] of Object.entries(entries)) archive.addFile(name, Buffer.from(text));
-  return new Uint8Array(archive.toBuffer());
-}
-
-function github(archives: Record<string, Uint8Array<ArrayBuffer>>) {
-  const downloads: string[] = [];
-  vi.stubGlobal(
-    'fetch',
-    vi.fn((input: string | URL | Request) => {
-      const url = String(input);
-      if (url.includes('/artifacts?')) {
-        return Promise.resolve(
-          Response.json({
-            artifacts: Object.keys(archives).map((name, id) => ({
-              id,
-              name,
-              archive_download_url: `https://artifacts.test/${name}`,
-            })),
-          }),
-        );
-      }
-      if (url.startsWith('https://artifacts.test/')) {
-        const name = url.slice('https://artifacts.test/'.length);
-        downloads.push(name);
-        return Promise.resolve(new Response(archives[name]));
-      }
-      return Promise.resolve(
-        Response.json({
-          id: Number(RUN_ID),
-          name: workflowRun.name,
-          head_branch: 'main',
-          head_sha: 'abc123',
-          created_at: workflowRun.createdAt,
-          html_url: RUN_URL,
-          conclusion: 'success',
-          status: 'completed',
-        }),
-      );
-    }),
-  );
-  return downloads;
-}
-
 function request(body: unknown, prefix = 'dsr1_', raw = false): NextRequest {
   const params = new URLSearchParams({
     runId: RUN_ID,
@@ -146,88 +95,6 @@ afterEach(() => {
 });
 
 describe('Timeline requested-source coverage', () => {
-  it('keeps the planned stored c32 and downloads only missing c64 under their common prefix', async () => {
-    const points = [NAME_A, NAME_B].map(
-      (name, index) =>
-        ({
-          x: 1,
-          y: 1,
-          hwKey: 'b200_sglang',
-          tp: 4,
-          conc: index === 0 ? 32 : 64,
-          precision: 'fp8',
-          date: '2026-03-01',
-          run_url: RUN_URL,
-          power_audit: { source: source(name) },
-        }) as InferenceData,
-    );
-    const [planned] = planPowerTimelineRequests(points);
-    expect(planned.sources).toEqual([SOURCE_A, SOURCE_B]);
-    const downloads = github({
-      [csvName(NAME_A)]: zip({ 'gpu_metrics.csv': csv(900) }),
-      [csvName(NAME_B)]: zip({ 'gpu_metrics.csv': csv(300) }),
-      gpu_metrics_dsr1_conc128_b200: zip({ 'gpu_metrics.csv': csv(500) }),
-    });
-    const response = await POST(request({ sources: planned.sources }, planned.prefix));
-    expect(response.status).toBe(200);
-    expect(response.headers.get('Cache-Control')).toBe('no-store');
-    const body = await response.json();
-    expect(body.sourceCoverage).toEqual({
-      status: 'complete',
-      missingSources: [],
-    });
-    expect(downloads).toEqual([csvName(NAME_B)]);
-    const joined = joinPowerTimeline(points, new Map([[RUN_ID, body]]));
-    expect(joined.missing).toEqual([]);
-    expect(joined.traces.map((trace) => trace.series.power)).toEqual([[[100, 110]], [[300, 310]]]);
-  });
-
-  it('serves the complete requested set from DB without GitHub and canonicalizes duplicates', async () => {
-    readRun.mockResolvedValue({
-      workflowRun,
-      series: [stored(NAME_A), stored(NAME_B, 300)],
-    });
-    const response = await POST(request({ sources: [SOURCE_B, SOURCE_A, SOURCE_B] }));
-    expect(response.status).toBe(200);
-    const body = await response.json();
-    expect(body.sourceCoverage).toEqual({
-      status: 'complete',
-      missingSources: [],
-    });
-    expect(body.series).toHaveLength(2);
-    expect(globalThis.fetch).not.toHaveBeenCalled();
-  });
-
-  it.each(['no token', 'GitHub 404'])(
-    'preserves healthy DB data with incomplete coverage when %s',
-    async (failure) => {
-      if (failure === 'no token') vi.stubEnv('GITHUB_TOKEN', '');
-      else vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(null, { status: 404 })));
-      const response = await POST(request({ sources: [SOURCE_B, SOURCE_A] }));
-      expect(response.status).toBe(200);
-      const body = await response.json();
-      expect(body.sourceCoverage).toEqual({
-        status: 'incomplete',
-        missingSources: [SOURCE_B],
-      });
-      expect(body.series).toMatchObject([{ artifact: csvName(NAME_A), power: [[100, 110]] }]);
-      if (failure === 'no token') expect(globalThis.fetch).not.toHaveBeenCalled();
-    },
-  );
-
-  it('does not call an identity-free GET complete', async () => {
-    const response = await GET(
-      new NextRequest(`http://localhost/api/gpu-metrics?runId=${RUN_ID}&series=power`),
-    );
-    expect(response.status).toBe(200);
-    const body = await response.json();
-    expect(body.sourceCoverage).toEqual({
-      status: 'unknown',
-      missingSources: [],
-    });
-    expect(globalThis.fetch).not.toHaveBeenCalled();
-  });
-
   it('keeps known missing hosts as 503 even when another requested series is healthy', async () => {
     const partial = stored(NAME_B, 300);
     partial.sidecars.seriesInventory = [
@@ -246,111 +113,4 @@ describe('Timeline requested-source coverage', () => {
       artifact: csvName(NAME_B),
     });
   });
-
-  it('ignores an unrelated partial artifact under the same common prefix', async () => {
-    const partial = stored('dsr1_conc128_b200');
-    partial.sidecars.seriesInventory = [{ fileName: 'missing.csv', sampleCount: 2 }];
-    readRun.mockResolvedValue({
-      workflowRun,
-      series: [stored(NAME_A), partial],
-    });
-    const response = await POST(request({ sources: [SOURCE_A] }));
-    expect(response.status).toBe(200);
-    const body = await response.json();
-    expect(body.sourceCoverage).toEqual({
-      status: 'complete',
-      missingSources: [],
-    });
-    expect(globalThis.fetch).not.toHaveBeenCalled();
-  });
-
-  it('supplements a missing validation window from the same bundle without replacing its stored window', async () => {
-    const artifact = 'power_audit_dsr1';
-    const validation = {
-      selected_window: { start_time_unix: START, end_time_unix: START + 1 },
-    };
-    const bundle = stored(NAME_A);
-    bundle.artifactName = artifact;
-    bundle.fileName = 'LOGS/power/samples.csv#host-a';
-    bundle.sidecars = {
-      identity: [{ hostname: 'host-a', gpu_index: 0, gpu_uuid: 'GPU-a' }],
-      validations: { [SOURCE_A]: validation },
-      seriesInventory: [{ fileName: bundle.fileName, sampleCount: 2 }],
-    };
-    readRun.mockResolvedValue({ workflowRun, series: [bundle] });
-    const downloads = github({
-      [artifact]: zip({
-        'LOGS/power/samples.csv': [
-          'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
-          `1,${START},1,host-a,0,GPU-a,900`,
-          `1,${START + 1},2,host-a,0,GPU-a,910`,
-        ].join('\n'),
-        'LOGS/power/manifest.json': '{}',
-        [SOURCE_A]: JSON.stringify(validation),
-        [SOURCE_B]: JSON.stringify(validation),
-      }),
-    });
-    const response = await POST(request({ sources: [SOURCE_A, SOURCE_B] }));
-    expect(response.status).toBe(200);
-    const body = await response.json();
-    expect(body.sourceCoverage).toEqual({
-      status: 'complete',
-      missingSources: [],
-    });
-    expect(body.series).toHaveLength(2);
-    expect(
-      body.series.find((entry: { source: string }) => entry.source === SOURCE_A).power,
-    ).toEqual([[100, 110]]);
-    expect(
-      body.series.find((entry: { source: string }) => entry.source === SOURCE_B).power,
-    ).toEqual([[900, 910]]);
-    expect(downloads).toEqual([artifact]);
-  });
-});
-
-describe('Timeline source request validation', () => {
-  it.each([
-    ['malformed JSON', '{', true],
-    ['null', null, false],
-    ['missing sources', {}, false],
-    ['string sources', { sources: SOURCE_A }, false],
-    ['empty sources', { sources: [] }, false],
-    ['non-string source', { sources: [42] }, false],
-    ['source path', { sources: [`dir/${SOURCE_A}`] }, false],
-    ['wrong source name', { sources: [csvName(NAME_A)] }, false],
-    ['overlong suffix', { sources: [source(`dsr1_${'a'.repeat(196)}`)] }, false],
-    ['too many sources', { sources: Array.from({ length: 1001 }, () => SOURCE_A) }, false],
-    ['prefix mismatch', { sources: [source('other_conc32')] }, false],
-  ])('rejects %s before DB or GitHub access', async (_label, body, raw) => {
-    const response = await POST(request(body, 'dsr1_', Boolean(raw)));
-    expect(response.status).toBe(400);
-    expect(readRun).not.toHaveBeenCalled();
-    expect(globalThis.fetch).not.toHaveBeenCalled();
-  });
-
-  it('rejects bodies beyond 256 KiB before attempting telemetry reads', async () => {
-    const response = await POST(request(' '.repeat(256 * 1024 + 1), 'dsr1_', true));
-    expect(response.status).toBe(413);
-    expect(readRun).not.toHaveBeenCalled();
-    expect(globalThis.fetch).not.toHaveBeenCalled();
-  });
-
-  it('accepts 1000 bounded sources through the body without a long query string', async () => {
-    const names = Array.from(
-      { length: 1000 },
-      (_, index) => `dsr1_${String(index).padStart(4, '0')}_${'a'.repeat(190)}`,
-    );
-    const sources = names.map(source);
-    readRun.mockResolvedValue({ workflowRun, series: [stored(names[0])] });
-    vi.stubEnv('GITHUB_TOKEN', '');
-    const input = request({ sources });
-    expect(input.url.length).toBeLessThan(200);
-    const response = await POST(input);
-    expect(response.status).toBe(200);
-    const body = await response.json();
-    expect(body.sourceCoverage).toEqual({
-      status: 'incomplete',
-      missingSources: sources.slice(1),
-    });
-  });
 });
diff --git a/packages/app/src/app/api/gpu-metrics/route.test.ts b/packages/app/src/app/api/gpu-metrics/route.test.ts
index 89aa6d990..1241df995 100644
--- a/packages/app/src/app/api/gpu-metrics/route.test.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.test.ts
@@ -62,9 +62,6 @@ vi.mock('adm-zip', () => {
       this.key = buffer.toString('utf8');
     }
     getEntries() {
-      if (this.key === 'corrupt') {
-        throw new Error('ADM-ZIP: Invalid or unsupported zip format. No END header found');
-      }
       const entries = zipArchives.byKey.get(this.key) ?? zipArchives.csvArchive;
       return entries.map((entry) => ({
         entryName: entry.entryName,
@@ -226,26 +223,6 @@ describe('databasePayloadToResponse', () => {
     expect(response.artifacts[0]!.series?.benchmarkResultIds).toEqual([10]);
     expect(response.artifacts[0]!.series).not.toHaveProperty('data');
   });
-
-  it('fills missing run metadata with the run date and canonical run URL', () => {
-    const response = databasePayloadToResponse({
-      ...storedRunPayload,
-      workflowRun: {
-        ...storedRunPayload.workflowRun,
-        htmlUrl: null,
-        headBranch: null,
-        headSha: null,
-        conclusion: null,
-        status: null,
-        createdAt: null,
-      },
-    });
-    expect(response.runInfo.createdAt).toBe('2026-09-11T00:00:00Z');
-    expect(response.runInfo.url).toBe(
-      'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34557177019',
-    );
-    expect(response.runInfo.branch).toBe('');
-  });
 });
 
 describe('GET /api/gpu-metrics — database first', () => {
@@ -263,47 +240,6 @@ describe('GET /api/gpu-metrics — database first', () => {
     expect(globalThis.fetch).not.toHaveBeenCalled();
   });
 
-  it('falls back to GitHub when the database has no series for the run', async () => {
-    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
-    mockGetGpuMetricsForRun.mockResolvedValueOnce(null);
-    globalThis.fetch = vi
-      .fn()
-      .mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            id: 99,
-            name: 'In progress',
-            head_branch: 'main',
-            head_sha: 'abc',
-            created_at: '2026-09-17T00:00:00Z',
-            html_url: 'https://github.com/TestOwner/TestRepo/actions/runs/99',
-            conclusion: null,
-            status: 'in_progress',
-          }),
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            artifacts: [
-              { id: 1, name: 'gpu_metrics_live', archive_download_url: 'https://example.com/dl/1' },
-            ],
-          }),
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers({ 'Content-Length': '1024' }),
-        arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-      });
-
-    const res = await GET(req('/api/gpu-metrics?runId=99'));
-    expect(res.status).toBe(200);
-    const body = await res.json();
-    expect(body.source).toBe('github');
-    expect(body.artifacts[0].name).toBe('gpu_metrics_live');
-  });
-
   it('reports a database failure separately instead of treating it as missing data', async () => {
     process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
     mockGetGpuMetricsForRun.mockRejectedValueOnce(new Error('relation does not exist'));
@@ -315,108 +251,7 @@ describe('GET /api/gpu-metrics — database first', () => {
     expect(globalThis.fetch).not.toHaveBeenCalled();
   });
 
-  it('renders persisted Timeline series with GitHub unavailable and preserves prefix filtering', async () => {
-    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
-    mockGetGpuMetricsForRun.mockResolvedValueOnce(storedRunPayload);
-    globalThis.fetch = vi.fn().mockRejectedValue(new Error('GitHub artifacts expired'));
-    const res = await GET(req('/api/gpu-metrics?runId=34557177019&series=power&prefix=dsr1_'));
-    expect(res.status).toBe(200);
-    expect(res.headers.get('Cache-Control')).toBe('no-store');
-    expect(await res.json()).toMatchObject({
-      source: 'database',
-      series: [
-        {
-          artifact: 'gpu_metrics_dsr1_conc32_b200-x_0',
-          startMs: Date.parse('2026-09-11T04:19:41Z'),
-          bucketSeconds: 1,
-          gpus: [0],
-          t: [0, 1],
-          power: [[187.8, 912.1]],
-        },
-      ],
-    });
-    expect(globalThis.fetch).not.toHaveBeenCalled();
-  });
-
-  it('uses stored bundle windows when a point prefix extends past the artifact name', async () => {
-    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
-    const source = 'power_validation_qwen3.5_8k1k_fp8_slurm_conc32.json';
-    const base = storedRunPayload.series[0];
-    const start = Date.parse(base.data[0].timestamp) / 1000;
-    const bundle = (host: string, power: number) => ({
-      ...base,
-      artifactName: 'power_audit_qwen3.5_8k1k_fp8_slurm',
-      fileName: `LOGS/power/samples.csv#${host}`,
-      sidecars: {
-        identity: [{ hostname: host, gpu_index: 0, gpu_uuid: `GPU-${host}` }],
-        validations: {
-          [source]: { selected_window: { start_time_unix: start, end_time_unix: start + 1 } },
-        },
-      },
-      data: [{ ...base.data[0], power }],
-    });
-    mockGetGpuMetricsForRun.mockResolvedValueOnce({
-      ...storedRunPayload,
-      series: [bundle('a', 100), bundle('b', 500)],
-    });
-    globalThis.fetch = vi.fn().mockRejectedValue(new Error('GitHub unavailable'));
-    const res = await GET(
-      req('/api/gpu-metrics?runId=34557177019&series=power&prefix=qwen3.5_8k1k_fp8_slurm_conc32'),
-    );
-    expect(res.status).toBe(200);
-    const body = await res.json();
-    expect(body.series).toMatchObject([
-      {
-        artifact: 'power_audit_qwen3.5_8k1k_fp8_slurm',
-        source,
-        gpus: [0, 1],
-        power: [[100], [500]],
-        devices: [{ id: 'a/GPU-a' }, { id: 'b/GPU-b' }],
-      },
-    ]);
-    expect(globalThis.fetch).not.toHaveBeenCalled();
-  });
-
-  it('reports the incomplete artifact and recovery action when partial storage cannot fall back to GitHub', async () => {
-    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
-    const entry = storedRunPayload.series[0];
-    const artifactName = 'power_audit_qwen3.5_multinode';
-    mockGetGpuMetricsForRun.mockResolvedValueOnce({
-      ...storedRunPayload,
-      series: [
-        {
-          ...entry,
-          artifactName,
-          fileName: 'LOGS/power/samples.csv#host-a',
-          sidecars: {
-            seriesInventory: [
-              { fileName: 'LOGS/power/samples.csv#host-a', sampleCount: 2 },
-              { fileName: 'LOGS/power/samples.csv#host-b', sampleCount: 2 },
-            ],
-          },
-        },
-      ],
-    });
-    globalThis.fetch = vi.fn().mockResolvedValue({ ok: false, status: 404 });
-    const res = await GET(req('/api/gpu-metrics?runId=34557177019&series=power'));
-    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
-    expect(res.status).toBe(503);
-    const body = await res.json();
-    expect(body).toMatchObject({ code: 'STORED_TELEMETRY_INCOMPLETE', artifact: artifactName });
-    expect(body.error).toContain('host-b');
-    expect(body.error).toContain('Re-ingest');
-    expect(body.series).toBeUndefined();
-  });
-
-  it.each([
-    'complete',
-    'missing host',
-    'empty host',
-    'truncated host',
-    'second missing artifact',
-    'healthy stored artifact',
-    'healthy stored artifact also live',
-  ])('checks retained file/sample coverage before using a %s CSV fallback', async (coverage) => {
+  it('checks retained file/sample coverage before using a truncated host CSV fallback', async () => {
     process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
     const { parseCsvData } = await vi.importActual<typeof GpuPowerTypes>(
       '@/components/gpu-power/types',
@@ -424,29 +259,18 @@ describe('GET /api/gpu-metrics — database first', () => {
     const header =
       'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
     const hostA = [header, nvidiaRow(0, 300), nvidiaRow(0, 999), nvidiaRow(1, 310)].join('\n');
-    const hostB =
-      coverage === 'empty host'
-        ? header
-        : [
-            header,
-            nvidiaRow(0, 500),
-            ...(coverage === 'truncated host' ? [] : [nvidiaRow(1, 510)]),
-          ].join('\n');
+    // host-b lost its GPU 1 row: one of the two retained samples.
+    const hostB = [header, nvidiaRow(0, 500)].join('\n');
     zipArchives.byKey.set('coverage', [
       { entryName: 'host-a/gpu_metrics.csv', data: hostA },
-      ...(coverage === 'missing host'
-        ? []
-        : [{ entryName: 'host-b/gpu_metrics.csv', data: hostB }]),
+      { entryName: 'host-b/gpu_metrics.csv', data: hostB },
     ]);
-    mockParseCsvData.mockImplementationOnce(parseCsvData);
-    if (coverage !== 'missing host') mockParseCsvData.mockImplementationOnce(parseCsvData);
-    const entry = storedRunPayload.series[0];
-    const healthyStoredArtifact = coverage.startsWith('healthy stored artifact');
+    mockParseCsvData.mockImplementationOnce(parseCsvData).mockImplementationOnce(parseCsvData);
     mockGetGpuMetricsForRun.mockResolvedValueOnce({
       ...storedRunPayload,
       series: [
         {
-          ...entry,
+          ...storedRunPayload.series[0],
           artifactName: 'gpu_metrics_live',
           fileName: 'host-a/gpu_metrics.csv',
           sidecars: {
@@ -456,22 +280,6 @@ describe('GET /api/gpu-metrics — database first', () => {
             ],
           },
         },
-        ...(healthyStoredArtifact ? [entry] : []),
-        ...(coverage === 'second missing artifact'
-          ? [
-              {
-                ...entry,
-                artifactName: 'gpu_metrics_second',
-                fileName: 'host-a/gpu_metrics.csv',
-                sidecars: {
-                  seriesInventory: [
-                    { fileName: 'host-a/gpu_metrics.csv', sampleCount: 2 },
-                    { fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
-                  ],
-                },
-              },
-            ]
-          : []),
       ],
     });
     globalThis.fetch = vi
@@ -495,20 +303,7 @@ describe('GET /api/gpu-metrics — database first', () => {
         json: () =>
           Promise.resolve({
             artifacts: [
-              {
-                id: 1,
-                name: 'gpu_metrics_live',
-                archive_download_url: 'https://example.test/zip',
-              },
-              ...(coverage === 'healthy stored artifact also live'
-                ? [
-                    {
-                      id: 2,
-                      name: entry.artifactName,
-                      archive_download_url: 'https://example.test/healthy-zip',
-                    },
-                  ]
-                : []),
+              { id: 1, name: 'gpu_metrics_live', archive_download_url: 'https://example.test/zip' },
             ],
           }),
       })
@@ -516,88 +311,18 @@ describe('GET /api/gpu-metrics — database first', () => {
         ok: true,
         headers: new Headers(),
         arrayBuffer: () => Promise.resolve(new TextEncoder().encode('coverage').buffer),
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers(),
-        arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
       });
     const res = await GET(req('/api/gpu-metrics?runId=34557177019&series=power'));
-    if (coverage === 'complete' || healthyStoredArtifact) {
-      expect(res.status).toBe(200);
-      const body = await res.json();
-      expect(body.source).toBe('github');
-      expect(body.series).toHaveLength(healthyStoredArtifact ? 2 : 1);
-      expect(body.series).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            artifact: 'gpu_metrics_live',
-            power: [
-              [300, 310],
-              [500, 510],
-            ],
-          }),
-          ...(healthyStoredArtifact
-            ? [
-                expect.objectContaining({
-                  artifact: entry.artifactName,
-                  power: [[187.8, 912.1]],
-                }),
-              ]
-            : []),
-        ]),
-      );
-    } else {
-      expect(res.status).toBe(503);
-      expect(await res.json()).toMatchObject({
-        code: 'STORED_TELEMETRY_INCOMPLETE',
-        artifact:
-          coverage === 'second missing artifact' ? 'gpu_metrics_second' : 'gpu_metrics_live',
-      });
-    }
-    expect(globalThis.fetch).toHaveBeenCalledTimes(
-      coverage === 'healthy stored artifact also live' ? 4 : 3,
-    );
-  });
-
-  it('reports Timeline database failure even when the GitHub token is absent', async () => {
-    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
-    delete process.env.GITHUB_TOKEN;
-    mockGetGpuMetricsForRun.mockRejectedValueOnce(new Error('connection unavailable'));
-    globalThis.fetch = vi.fn();
-    const res = await GET(req('/api/gpu-metrics?runId=34557177019&series=power'));
     expect(res.status).toBe(503);
-    expect(await res.json()).toMatchObject({ code: 'DATABASE_UNAVAILABLE' });
-    expect(globalThis.fetch).not.toHaveBeenCalled();
-  });
-});
-
-describe('GET /api/gpu-metrics', () => {
-  it('keeps host-local GPU zero separate in the default live multi-file response', async () => {
-    const { parseCsvData } = await vi.importActual<typeof GpuPowerTypes>(
-      '@/components/gpu-power/types',
-    );
-    const header =
-      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
-    zipArchives.byKey.set('multinode-csv', [
-      { entryName: 'host-a/gpu_metrics.csv', data: [header, nvidiaRow(0, 300)].join('\n') },
-      { entryName: 'host-b/gpu_metrics.csv', data: [header, nvidiaRow(0, 500)].join('\n') },
-    ]);
-    mockParseCsvData.mockImplementationOnce(parseCsvData).mockImplementationOnce(parseCsvData);
-    mockGithub([{ name: 'gpu_metrics_live', url: 'https://example.test/dl/multinode' }], {
-      'https://example.test/dl/multinode': { archive: 'multinode-csv' },
-    });
-    const res = await GET(req('/api/gpu-metrics?runId=12345'));
-    expect(res.status).toBe(200);
     expect(await res.json()).toMatchObject({
-      source: 'github',
-      artifacts: [
-        { name: 'gpu_metrics_live/host-a/gpu_metrics.csv', data: [{ index: 0, power: 300 }] },
-        { name: 'gpu_metrics_live/host-b/gpu_metrics.csv', data: [{ index: 0, power: 500 }] },
-      ],
+      code: 'STORED_TELEMETRY_INCOMPLETE',
+      artifact: 'gpu_metrics_live',
     });
+    expect(globalThis.fetch).toHaveBeenCalledTimes(3);
   });
+});
 
+describe('GET /api/gpu-metrics', () => {
   it('returns 400 when runId is missing', async () => {
     const res = await GET(req('/api/gpu-metrics'));
     expect(res.status).toBe(400);
@@ -675,119 +400,6 @@ describe('GET /api/gpu-metrics', () => {
     expect(body.artifacts[0].data).toHaveLength(1);
   });
 
-  it('returns 400 for a malformed prefix or an unknown series shape', async () => {
-    const badPrefix = await GET(req('/api/gpu-metrics?runId=12345&prefix=a%20b'));
-    expect(badPrefix.status).toBe(400);
-    const badPrefixBody = await badPrefix.json();
-    expect(badPrefixBody.error).toContain('prefix');
-    const badSeries = await GET(req('/api/gpu-metrics?runId=12345&series=temperature'));
-    expect(badSeries.status).toBe(400);
-    const badSeriesBody = await badSeries.json();
-    expect(badSeriesBody.error).toContain('series');
-  });
-
-  it('narrows downloads to the prefix and returns bucketed power series on demand', async () => {
-    const mockRunData = {
-      id: 12345,
-      name: 'Run Sweep',
-      head_branch: 'main',
-      head_sha: 'abc123',
-      created_at: '2026-03-01T00:00:00Z',
-      html_url: 'https://github.com/TestOwner/TestRepo/actions/runs/12345',
-      conclusion: 'success',
-      status: 'completed',
-    };
-    mockParseCsvData.mockImplementationOnce(() => [
-      {
-        timestamp: '2026/03/01 00:00:00.100',
-        index: 0,
-        power: 300,
-        temperature: 1,
-        smClock: 1,
-        memClock: 1,
-        gpuUtil: 0,
-        memUtil: 0,
-      },
-      {
-        timestamp: '2026/03/01 00:00:00.104',
-        index: 1,
-        power: 310,
-        temperature: 1,
-        smClock: 1,
-        memClock: 1,
-        gpuUtil: 0,
-        memUtil: 0,
-      },
-      {
-        timestamp: '2026/03/01 00:00:01.100',
-        index: 0,
-        power: 500,
-        temperature: 1,
-        smClock: 1,
-        memClock: 1,
-        gpuUtil: 0,
-        memUtil: 0,
-      },
-    ]);
-    const fetchMock = vi
-      .fn()
-      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRunData) })
-      .mockResolvedValueOnce({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            artifacts: [
-              // Another model in the same sweep: filtered out before download.
-              {
-                id: 1,
-                name: 'gpu_metrics_dsr1_1k1k_fp8_x',
-                archive_download_url: 'https://example.com/dl/1',
-              },
-              {
-                id: 2,
-                name: 'gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc16',
-                archive_download_url: 'https://example.com/dl/2',
-              },
-              {
-                id: 3,
-                name: 'eval_gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc16',
-                archive_download_url: 'https://example.com/dl/3',
-              },
-            ],
-          }),
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        headers: new Headers({ 'Content-Length': '1024' }),
-        arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-      });
-    globalThis.fetch = fetchMock;
-
-    const res = await GET(
-      req('/api/gpu-metrics?runId=12345&series=power&prefix=qwen3.5_8k1k_fp8_'),
-    );
-    expect(res.status).toBe(200);
-    // Run info, artifact list, and exactly one artifact download.
-    expect(fetchMock).toHaveBeenCalledTimes(3);
-    expect(fetchMock.mock.calls[2][0]).toBe('https://example.com/dl/2');
-    const body = await res.json();
-    expect(body.runInfo.id).toBe(12345);
-    expect(body.artifacts).toBeUndefined();
-    expect(body.series).toEqual([
-      {
-        artifact: 'gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc16',
-        startMs: Date.UTC(2026, 2, 1, 0, 0, 0),
-        bucketSeconds: 1,
-        gpus: [0, 1],
-        t: [0, 1],
-        power: [
-          [300, 500],
-          [310, null],
-        ],
-      },
-    ]);
-  });
-
   it('returns 500 when workflow run fetch fails', async () => {
     globalThis.fetch = vi.fn().mockResolvedValueOnce({
       ok: false,
@@ -956,335 +568,3 @@ describe('GET /api/gpu-metrics', () => {
     expect(body.artifacts[0].name).toBe('gpu_metrics_dsr1_b200');
   });
 });
-
-/**
- * Bundle fixtures: one `power_audit_*` sweep with two devices and one
- * validated window, plus a GitHub mock that answers by URL so download order
- * does not matter.
- */
-const BUNDLE_RESULT = 'qwen3.5_8k1k_fp8_dynamo-sglang_prefill-tp4-pp1_decode-tp4-pp1-e-5b35252b';
-const BUNDLE_NAME = `power_audit_${BUNDLE_RESULT}`;
-const BUNDLE_VALIDATION = `power_validation_${BUNDLE_RESULT}_sa-bench_isl_8192_osl_1024_conc8_gpus_8_ctx_4_gen_4.json`;
-const OTHER_BUNDLE_NAME = 'power_audit_dsr1_1k1k_fp8_dynamo-sglang_prefill-tp4-abc';
-const CSV_NAME = 'gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc16';
-const RUN = {
-  id: 12345,
-  name: 'Run Sweep',
-  head_branch: 'main',
-  head_sha: 'abc123',
-  created_at: '2026-03-01T00:00:00Z',
-  html_url: 'https://github.com/TestOwner/TestRepo/actions/runs/12345',
-  conclusion: 'success',
-  status: 'completed',
-};
-
-const BUNDLE_ARCHIVE = [
-  {
-    entryName: 'LOGS/power/samples.csv',
-    data: [
-      'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
-      '1,1000.2,1,cn02,0,GPU-d,500',
-      '1,1000.2,1,cn01,0,GPU-p,300',
-      '1,1001.2,2,cn02,0,GPU-d,510',
-      '1,1001.2,2,cn01,0,GPU-p,310',
-    ].join('\n'),
-  },
-  {
-    entryName: 'LOGS/power/manifest.json',
-    data: JSON.stringify({
-      expected_devices: [
-        { hostname: 'cn02', gpu_index: 0, assignments: [{ worker_role: 'decode' }] },
-      ],
-    }),
-  },
-  {
-    entryName: BUNDLE_VALIDATION,
-    data: JSON.stringify({
-      selected_window: { concurrency: 8, start_time_unix: 1000, end_time_unix: 1001 },
-      per_gpu_role: { 'cn01/GPU-p': 'prefill' },
-    }),
-  },
-  {
-    entryName: `LOGS/sa-bench_isl_8192_osl_1024/results_concurrency_8.json`,
-    data: '{"huge": true}',
-  },
-  { entryName: `agg_${BUNDLE_RESULT}_conc8.json`, data: '{}' },
-];
-
-const EXPECTED_BUNDLE_SERIES = {
-  artifact: BUNDLE_NAME,
-  source: BUNDLE_VALIDATION,
-  startMs: 1000 * 1000,
-  bucketSeconds: 1,
-  gpus: [0, 1],
-  t: [0, 1],
-  power: [
-    [300, 310],
-    [500, 510],
-  ],
-  devices: [
-    { id: 'cn01/GPU-p', role: 'prefill' },
-    { id: 'cn02/GPU-d', role: 'decode' },
-  ],
-};
-
-interface MockDownload {
-  /** Key of the zip archive the adm-zip mock serves for this download. */
-  archive: string;
-  contentLength?: number;
-}
-
-/** Answers run info, the artifact listing, and downloads by URL; returns the fetch spy. */
-function mockGithub(
-  artifacts: { name: string; url: string }[],
-  downloads: Record<string, MockDownload>,
-) {
-  const fetchMock = vi.fn((input: string) => {
-    if (input.endsWith('/actions/runs/12345')) {
-      return Promise.resolve({ ok: true, json: () => Promise.resolve(RUN) });
-    }
-    if (input.includes('/actions/runs/12345/artifacts')) {
-      return Promise.resolve({
-        ok: true,
-        json: () =>
-          Promise.resolve({
-            artifacts: artifacts.map((artifact, index) => ({
-              id: index + 1,
-              name: artifact.name,
-              archive_download_url: artifact.url,
-            })),
-          }),
-      });
-    }
-    const download = downloads[input];
-    if (!download) return Promise.resolve({ ok: false, statusText: `Unexpected ${input}` });
-    const bytes = new TextEncoder().encode(download.archive);
-    return Promise.resolve({
-      ok: true,
-      headers: new Headers({ 'Content-Length': String(download.contentLength ?? 1024) }),
-      arrayBuffer: () => Promise.resolve(bytes.buffer),
-    });
-  });
-  globalThis.fetch = fetchMock as unknown as typeof fetch;
-  return fetchMock;
-}
-
-function downloadedUrls(fetchMock: ReturnType<typeof mockGithub>): string[] {
-  return fetchMock.mock.calls.map(([url]) => url).filter((url) => url.includes('/dl/'));
-}
-
-describe('GET /api/gpu-metrics?series=power with power_audit bundles', () => {
-  beforeEach(() => {
-    zipArchives.byKey.set('bundle', BUNDLE_ARCHIVE);
-    vi.spyOn(console, 'warn').mockImplementation(() => {});
-  });
-
-  it('does not accept a same-name partial bundle as recovery for known missing stored hosts', async () => {
-    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
-    mockGetGpuMetricsForRun.mockResolvedValueOnce({
-      ...storedRunPayload,
-      series: [
-        {
-          ...storedRunPayload.series[0],
-          artifactName: BUNDLE_NAME,
-          fileName: 'LOGS/power/samples.csv#cn01',
-          sidecars: {
-            seriesInventory: [
-              { fileName: 'LOGS/power/samples.csv#cn01', sampleCount: 2 },
-              { fileName: 'LOGS/power/samples.csv#cn02', sampleCount: 2 },
-            ],
-          },
-        },
-      ],
-    });
-    zipArchives.byKey.set(
-      'partial-bundle',
-      BUNDLE_ARCHIVE.map((entry) =>
-        entry.entryName === 'LOGS/power/samples.csv'
-          ? {
-              ...entry,
-              data: entry.data
-                .split('\n')
-                .filter((line) => !line.includes(',cn02,'))
-                .join('\n'),
-            }
-          : entry,
-      ),
-    );
-    mockGithub([{ name: BUNDLE_NAME, url: 'https://example.test/dl/bundle' }], {
-      'https://example.test/dl/bundle': { archive: 'partial-bundle' },
-    });
-    const res = await GET(req('/api/gpu-metrics?runId=12345&series=power'));
-    expect(res.status).toBe(503);
-    expect(await res.json()).toMatchObject({
-      code: 'STORED_TELEMETRY_INCOMPLETE',
-      artifact: BUNDLE_NAME,
-    });
-  });
-
-  it('cuts a bundle into per-window series alongside gpu_metrics series', async () => {
-    const fetchMock = mockGithub(
-      [
-        { name: CSV_NAME, url: 'https://example.com/dl/csv' },
-        { name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' },
-      ],
-      {
-        'https://example.com/dl/csv': { archive: '' },
-        'https://example.com/dl/bundle': { archive: 'bundle' },
-      },
-    );
-
-    const res = await GET(
-      req('/api/gpu-metrics?runId=12345&series=power&prefix=qwen3.5_8k1k_fp8_'),
-    );
-    expect(res.status).toBe(200);
-    expect(downloadedUrls(fetchMock)).toEqual([
-      'https://example.com/dl/csv',
-      'https://example.com/dl/bundle',
-    ]);
-    const body = await res.json();
-    expect(body.runInfo.id).toBe(12345);
-    expect(body.artifacts).toBeUndefined();
-    expect(body.series).toHaveLength(2);
-    expect(body.series[0]).toMatchObject({ artifact: CSV_NAME, gpus: [0] });
-    expect(body.series[0].source).toBeUndefined();
-    expect(body.series[1]).toEqual(EXPECTED_BUNDLE_SERIES);
-  });
-
-  it('skips a bundle whose archive cannot be read and keeps the other series', async () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    mockGithub(
-      [
-        { name: CSV_NAME, url: 'https://example.com/dl/csv' },
-        { name: BUNDLE_NAME, url: 'https://example.com/dl/corrupt' },
-      ],
-      {
-        'https://example.com/dl/csv': { archive: '' },
-        'https://example.com/dl/corrupt': { archive: 'corrupt' },
-      },
-    );
-
-    const res = await GET(
-      req('/api/gpu-metrics?runId=12345&series=power&prefix=qwen3.5_8k1k_fp8_'),
-    );
-    expect(res.status).toBe(200);
-    const body = await res.json();
-    expect(body.series).toHaveLength(1);
-    expect(body.series[0]).toMatchObject({ artifact: CSV_NAME });
-    expect(warn).toHaveBeenCalledWith(
-      `Failed to read artifact ${BUNDLE_NAME}:`,
-      expect.objectContaining({ message: expect.stringContaining('ADM-ZIP') }),
-    );
-  });
-
-  it('selects a bundle whether the prefix stops short of or runs past its name', async () => {
-    const artifacts = [
-      { name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' },
-      { name: OTHER_BUNDLE_NAME, url: 'https://example.com/dl/other' },
-    ];
-    const downloads = {
-      'https://example.com/dl/bundle': { archive: 'bundle' },
-      'https://example.com/dl/other': { archive: 'bundle' },
-    };
-
-    const longPrefix = `${BUNDLE_RESULT}_sa-bench_isl_8192_osl_1024_conc`;
-    let fetchMock = mockGithub(artifacts, downloads);
-    let res = await GET(req(`/api/gpu-metrics?runId=12345&series=power&prefix=${longPrefix}`));
-    expect(res.status).toBe(200);
-    expect(downloadedUrls(fetchMock)).toEqual(['https://example.com/dl/bundle']);
-    let body = await res.json();
-    expect(body.series).toEqual([EXPECTED_BUNDLE_SERIES]);
-
-    fetchMock = mockGithub(artifacts, downloads);
-    res = await GET(req('/api/gpu-metrics?runId=12345&series=power&prefix=qwen3.5_8k1k_'));
-    expect(res.status).toBe(200);
-    expect(downloadedUrls(fetchMock)).toEqual(['https://example.com/dl/bundle']);
-    body = await res.json();
-    expect(body.series.map((entry: { artifact: string }) => entry.artifact)).toEqual([BUNDLE_NAME]);
-
-    // No prefix: every bundle of the run.
-    fetchMock = mockGithub(artifacts, downloads);
-    res = await GET(req('/api/gpu-metrics?runId=12345&series=power'));
-    expect(res.status).toBe(200);
-    expect(downloadedUrls(fetchMock)).toEqual([
-      'https://example.com/dl/bundle',
-      'https://example.com/dl/other',
-    ]);
-    body = await res.json();
-    expect(body.series.map((entry: { artifact: string }) => entry.artifact)).toEqual([
-      BUNDLE_NAME,
-      OTHER_BUNDLE_NAME,
-    ]);
-  });
-
-  it('skips bundles above 256 MiB with a warning', async () => {
-    mockGithub(
-      [
-        { name: OTHER_BUNDLE_NAME, url: 'https://example.com/dl/other' },
-        { name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' },
-      ],
-      {
-        'https://example.com/dl/other': { archive: 'bundle', contentLength: 300 * 1024 * 1024 },
-        // Above the 50 MB CSV cap, below the bundle cap.
-        'https://example.com/dl/bundle': { archive: 'bundle', contentLength: 200 * 1024 * 1024 },
-      },
-    );
-
-    const res = await GET(req('/api/gpu-metrics?runId=12345&series=power'));
-    expect(res.status).toBe(200);
-    const body = await res.json();
-    expect(body.series).toEqual([EXPECTED_BUNDLE_SERIES]);
-    expect(console.warn).toHaveBeenCalledWith(
-      `Artifact ${OTHER_BUNDLE_NAME} exceeds 256 MB, skipping`,
-    );
-  });
-
-  it('keeps the raw-rows shape blind to bundles', async () => {
-    let fetchMock = mockGithub(
-      [
-        { name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' },
-        { name: CSV_NAME, url: 'https://example.com/dl/csv' },
-      ],
-      {
-        'https://example.com/dl/csv': { archive: '' },
-        'https://example.com/dl/bundle': { archive: 'bundle' },
-      },
-    );
-    let res = await GET(req('/api/gpu-metrics?runId=12345'));
-    expect(res.status).toBe(200);
-    expect(downloadedUrls(fetchMock)).toEqual(['https://example.com/dl/csv']);
-    const body = await res.json();
-    expect(body.series).toBeUndefined();
-    expect(body.artifacts.map((artifact: { name: string }) => artifact.name)).toEqual([CSV_NAME]);
-
-    fetchMock = mockGithub([{ name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' }], {
-      'https://example.com/dl/bundle': { archive: 'bundle' },
-    });
-    res = await GET(req('/api/gpu-metrics?runId=12345'));
-    expect(res.status).toBe(500);
-    expect(downloadedUrls(fetchMock)).toEqual([]);
-    const bundleOnly = await res.json();
-    expect(bundleOnly.error).toBe('No gpu_metrics artifacts found for this run');
-  });
-
-  it('names both collectors when a power request finds no telemetry', async () => {
-    mockGithub([{ name: 'benchmark_results', url: 'https://example.com/dl/results' }], {});
-    const res = await GET(req('/api/gpu-metrics?runId=12345&series=power'));
-    expect(res.status).toBe(500);
-    const body = await res.json();
-    expect(body.error).toBe(
-      'No telemetry artifacts (gpu_metrics or power_audit) found for this run',
-    );
-  });
-
-  it('reports no data when the only bundle has no power entries', async () => {
-    zipArchives.byKey.set('empty', [{ entryName: `agg_${BUNDLE_RESULT}_conc8.json`, data: '{}' }]);
-    mockGithub([{ name: BUNDLE_NAME, url: 'https://example.com/dl/bundle' }], {
-      'https://example.com/dl/bundle': { archive: 'empty' },
-    });
-    const res = await GET(req('/api/gpu-metrics?runId=12345&series=power'));
-    expect(res.status).toBe(500);
-    const body = await res.json();
-    expect(body.error).toBe('No Chip metrics data found in artifacts');
-  });
-});
diff --git a/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts b/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
index 1fa3042da..ec75a4b89 100644
--- a/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
+++ b/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
@@ -193,54 +193,4 @@ describe('artifact → local DB → real Blob cache → point API recovery', ()
     const samples = await db.query('select count(*)::int as n from gpu_metric_samples');
     expect(samples.rows).toEqual([{ n: 24 }]);
   });
-
-  it('logs failed cache writes, serves repaired data, and retries on the next request', async () => {
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: artifact(),
-      benchmarkResultIds: [10],
-    });
-    await request(10);
-    await db.exec(
-      `UPDATE benchmark_results SET power_audit = '{"source":"repaired"}' WHERE id = 10`,
-    );
-    blob.rejectWrites(true);
-    const warning = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    try {
-      const fresh = await request(10);
-      expect(fresh.response.status).toBe(200);
-      expect(fresh.body.series[0].powerAudits).toEqual([{ source: 'repaired' }]);
-      expect(blob.counts.failedWrites).toBeGreaterThan(0);
-      expect(warning).toHaveBeenCalledWith(expect.stringContaining('serving uncached result'));
-      blob.rejectWrites(false);
-      const writes = blob.counts.writes;
-      const recovered = await request(10);
-      expect(recovered.body).toEqual(fresh.body);
-      expect(blob.counts.writes).toBe(writes + 1);
-      await request(10);
-      expect(blob.counts.writes).toBe(writes + 1);
-    } finally {
-      warning.mockRestore();
-      blob.rejectWrites(false);
-    }
-  });
-
-  it('does not serve a cached success when the revision DB read fails', async () => {
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: artifact(),
-      benchmarkResultIds: [10],
-    });
-    await request(10);
-    connection.getDb.mockImplementationOnce(() => {
-      throw new Error('local DB unavailable');
-    });
-    const log = vi.spyOn(console, 'error').mockImplementation(() => {});
-    try {
-      const failed = await request(10);
-      expect(failed.response.status).toBe(500);
-    } finally {
-      log.mockRestore();
-    }
-  });
 });
diff --git a/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts b/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
index b9e708afe..5b5316396 100644
--- a/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
+++ b/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
@@ -95,66 +95,4 @@ describe('GET /api/v1/views/gpu-metrics full-record statistics', () => {
     expect(body.rows).toEqual(rows);
     expect(metrics.mock.calls[0][0].nextUrl.searchParams.get('runId')).toBe(String(runInfo.id));
   });
-
-  it.each(['empty digest', 'uncollected metric'])(
-    'keeps an authoritative %s empty',
-    async (kind) => {
-      if (kind === 'empty digest') source([artifact([])]);
-      const response = await GET(
-        request(kind === 'uncollected metric' ? '&metric=temperature' : ''),
-      );
-      expect(response.status).toBe(200);
-      const body = await response.json();
-      expect(body.stats).toEqual([]);
-    },
-  );
-
-  it('sorts all stored chips while visibility filters only raw rows and the real chart', async () => {
-    const response = await GET(request('&gpus=0&sort=mean&direction=desc'));
-    const body = await response.json();
-    expect(body.stats).toEqual([digest[1], digest[0]]);
-    expect(body.rows).toEqual(rows.slice(0, 2));
-    expect(Object.keys(body.chart)).toEqual(['0']);
-    expect(body.chart['0'].map((point: { value: number }) => point.value)).toEqual([100, 300]);
-    expect(body.params).toMatchObject({ gpus: [0], sort: 'mean', direction: 'desc' });
-  });
-
-  it('computes full-record sample statistics for a live artifact without a stored digest', async () => {
-    source([{ name: 'gpu_metrics_live', data: rows }]);
-    const response = await GET(request('&gpus=1'));
-    const body = await response.json();
-    expect(body.stats).toEqual([
-      {
-        gpuIndex: 0,
-        count: 2,
-        min: 100,
-        max: 300,
-        mean: 200,
-        median: 200,
-        p95: 290,
-        p99: 298,
-        stddev: 100,
-      },
-      {
-        gpuIndex: 1,
-        count: 1,
-        min: 50,
-        max: 50,
-        mean: 50,
-        median: 50,
-        p95: 50,
-        p99: 50,
-        stddev: 0,
-      },
-    ]);
-    expect(body.rows).toEqual([rows[2]]);
-  });
-
-  it('preserves a source database failure as an uncached 503 through the real error wrapper', async () => {
-    metrics.mockResolvedValue(Response.json({ code: 'DATABASE_UNAVAILABLE' }, { status: 503 }));
-    const response = await GET(request());
-    expect(response.status).toBe(503);
-    expect(response.headers.get('cache-control')).toBe('private, no-store');
-    expect(await response.json()).toEqual({ error: 'Source data unavailable' });
-  });
 });
diff --git a/packages/app/src/components/calculator/profit-power.test.ts b/packages/app/src/components/calculator/profit-power.test.ts
index 750dc5c9c..69ca900ae 100644
--- a/packages/app/src/components/calculator/profit-power.test.ts
+++ b/packages/app/src/components/calculator/profit-power.test.ts
@@ -2,7 +2,6 @@ import { describe, expect, it } from 'vitest';
 
 import type { BenchmarkRow } from '@/lib/api';
 import { modelSystemPower } from '@/lib/modeled-system-power';
-import { estimateChassisPower } from '@/lib/system-power-model';
 import { Percentile, Sequence } from '@/lib/data-mappings';
 import { buildGpuGroups, interpolateForGPU } from './useThroughputData';
 import { estimateProfitRows } from './profit-estimator';
@@ -158,46 +157,6 @@ describe('profit power basis preview', () => {
     ).toMatchObject({ extrapolated: true });
   });
 
-  it('plans fully measured multi-chassis deployments at the same facility watts per GPU', () => {
-    // Kimi K3 B200 dynamo-vLLM TP8/PP2: sixteen GPUs on two hosts, aggregate
-    // producer without a per-worker array → uniform-hosts basis.
-    const multinode: BenchmarkRow = {
-      ...source,
-      hardware: 'b200',
-      framework: 'dynamo-vllm',
-      is_multinode: true,
-      num_prefill_gpu: 16,
-      num_decode_gpu: 16,
-      decode_num_workers: 1,
-      metrics: {
-        power_valid: 1,
-        power_metric_schema_version: 2,
-        avg_power_w: 715.095,
-        avg_total_gpu_power_w: 11441.513,
-        decode_pp: 2,
-      },
-    };
-    expect(modelSystemPower(multinode, undefined, true)).toMatchObject({
-      status: 'supported',
-      topologyBasis: 'uniform-hosts',
-      chassisBasis: 'full',
-    });
-    const perChassis = estimateChassisPower('b200', 11441.513 / 2, 1.3)!;
-    expect(
-      modeledPowerAtTarget({ ...result, nearestPoints: [{ ...point, sourceRow: multinode }] }, 45),
-    ).toMatchObject({
-      kwPerGpu: expect.closeTo(((perChassis.facilityWatts * 2) / 16 / 1000) * 1.1, 8),
-      extrapolated: false,
-    });
-    // Disaggregated multinode rows still need per-worker telemetry.
-    expect(
-      modeledPowerAtTarget(
-        { ...result, nearestPoints: [{ ...point, sourceRow: { ...multinode, disagg: true } }] },
-        45,
-      ),
-    ).toEqual({ reason: 'unsupported-power-topology' });
-  });
-
   it('leaves the default estimator and default AgentX model gate unchanged', () => {
     expect(
       estimateProfitByPower([result], specs, pricing, assumptions, 'provisioned', 45, labels),
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.test.ts b/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
index 7c3c7ab1c..7f2aee466 100644
--- a/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
@@ -5,7 +5,6 @@ import {
   BUNDLE_SAMPLES_ENTRY,
   BUNDLE_WINDOW_PAD_SECONDS,
   cutPowerAuditBundle,
-  isPowerAuditBundleEntry,
 } from './power-audit-bundle';
 
 const ARTIFACT = 'power_audit_qwen3.5_8k1k_fp8_dynamo-sglang_x';
@@ -108,33 +107,7 @@ function bundle(overrides: Record<string, string | undefined> = {}): Map<string,
   return present;
 }
 
-describe('isPowerAuditBundleEntry', () => {
-  it('selects samples, manifest and retained validation/result/window documents', () => {
-    expect(isPowerAuditBundleEntry(BUNDLE_SAMPLES_ENTRY)).toBe(true);
-    expect(isPowerAuditBundleEntry(BUNDLE_MANIFEST_ENTRY)).toBe(true);
-    expect(isPowerAuditBundleEntry(validationName(8))).toBe(true);
-    expect(isPowerAuditBundleEntry('LOGS/power/windows/results_concurrency_8.json')).toBe(false);
-    expect(isPowerAuditBundleEntry(`LOGS/sa-bench_isl_8192_osl_1024/results.json`)).toBe(false);
-    // Root result candidates are matched to the exact artifact by normalization.
-    expect(isPowerAuditBundleEntry(`agg_${RESULT}_conc8.json`)).toBe(true);
-    expect(isPowerAuditBundleEntry(`${RESULT}_conc8.json`)).toBe(true);
-    expect(isPowerAuditBundleEntry('LOGS/agentic/conc_8/power_validation.json')).toBe(true);
-    expect(isPowerAuditBundleEntry('LOGS/power/windows/agentic_power_concurrency_8.json')).toBe(
-      true,
-    );
-    expect(isPowerAuditBundleEntry(`nested/${validationName(8)}`)).toBe(false);
-    expect(isPowerAuditBundleEntry('power_validation_x.json.bak')).toBe(false);
-  });
-});
-
 describe('cutPowerAuditBundle', () => {
-  it('emits one series per validation window with samples, in window order', () => {
-    const series = cutPowerAuditBundle(ARTIFACT, bundle());
-    expect(series.map((entry) => entry.source)).toEqual([validationName(1), validationName(2)]);
-    expect(series.every((entry) => entry.artifact === ARTIFACT)).toBe(true);
-    expect(series.every((entry) => entry.bucketSeconds === 1)).toBe(true);
-  });
-
   it('orders rows prefill, decode, unassigned, then by hostname and gpu_index', () => {
     const [first] = cutPowerAuditBundle(ARTIFACT, bundle());
     expect(first.devices).toEqual([
@@ -151,38 +124,6 @@ describe('cutPowerAuditBundle', () => {
     expect(first.power[3][2]).toBe(60);
   });
 
-  it('falls back to manifest roles and to benchmark_window', () => {
-    const [, second] = cutPowerAuditBundle(ARTIFACT, bundle());
-    expect(second.source).toBe(validationName(2));
-    expect(second.devices).toEqual([
-      { id: A0, role: 'prefill' },
-      { id: A1, role: 'prefill' },
-      { id: B0, role: 'decode' },
-    ]);
-    expect(second.startMs).toBe(2000 * 1000);
-    expect(second.t).toEqual([0, 1]);
-    expect(second.power).toEqual([
-      [130, 131],
-      [120, 121],
-      [220, 221],
-    ]);
-  });
-
-  it('leaves roles undefined without a manifest or per_gpu_role', () => {
-    const [, second] = cutPowerAuditBundle(
-      ARTIFACT,
-      bundle({ [BUNDLE_MANIFEST_ENTRY]: undefined }),
-    );
-    expect(second.devices).toEqual([{ id: A0 }, { id: A1 }, { id: B0 }]);
-    const [first] = cutPowerAuditBundle(ARTIFACT, bundle({ [BUNDLE_MANIFEST_ENTRY]: '{oops' }));
-    expect(first.devices!.map((device) => device.role)).toEqual([
-      'prefill',
-      'prefill',
-      'decode',
-      undefined,
-    ]);
-  });
-
   it('clips samples to the window plus the pad on both sides', () => {
     const [first] = cutPowerAuditBundle(ARTIFACT, bundle());
     expect(first.startMs).toBe((1000 - BUNDLE_WINDOW_PAD_SECONDS) * 1000);
@@ -190,47 +131,4 @@ describe('cutPowerAuditBundle', () => {
     // 1005.4 s lands in the 1005 s bucket; the malformed 2002 s rows never appear.
     expect(first.power[2]).toEqual([100, 100, 300, 100, 100]);
   });
-
-  it('skips the sweep entirely without samples', () => {
-    expect(cutPowerAuditBundle(ARTIFACT, bundle({ [BUNDLE_SAMPLES_ENTRY]: undefined }))).toEqual(
-      [],
-    );
-    expect(cutPowerAuditBundle(ARTIFACT, bundle({ [BUNDLE_SAMPLES_ENTRY]: '' }))).toEqual([]);
-    expect(
-      cutPowerAuditBundle(ARTIFACT, bundle({ [BUNDLE_SAMPLES_ENTRY]: `${HEADER}\n` })),
-    ).toEqual([]);
-    // A header without the required columns is as good as no samples.
-    expect(
-      cutPowerAuditBundle(
-        ARTIFACT,
-        bundle({ [BUNDLE_SAMPLES_ENTRY]: 'timestamp,index,power\n1000,0,100' }),
-      ),
-    ).toEqual([]);
-  });
-
-  it('reads columns by header name, not position', () => {
-    const reordered = [
-      'power_w,gpu_uuid,gpu_index,hostname,timestamp_unix',
-      '123.5,GPU-a0,0,cn01,1000',
-      '124.5,GPU-a0,0,cn01,1001.2',
-    ].join('\r\n');
-    const [first] = cutPowerAuditBundle(ARTIFACT, bundle({ [BUNDLE_SAMPLES_ENTRY]: reordered }));
-    expect(first.devices).toEqual([{ id: A0, role: 'decode' }]);
-    expect(first.power).toEqual([[123.5, 124.5]]);
-  });
-
-  it('skips malformed validation files and files without a window', () => {
-    const series = cutPowerAuditBundle(
-      ARTIFACT,
-      bundle({
-        [validationName(1)]: '{"selected_window": ',
-        [validationName(4)]: JSON.stringify({ power_valid: true }),
-        [validationName(5)]: JSON.stringify([1, 2]),
-        [validationName(6)]: JSON.stringify({
-          selected_window: { start_time_unix: 2010, end_time_unix: 2000 },
-        }),
-      }),
-    );
-    expect(series.map((entry) => entry.source)).toEqual([validationName(2)]);
-  });
 });
diff --git a/packages/app/src/components/gpu-power/power-series.test.ts b/packages/app/src/components/gpu-power/power-series.test.ts
index cfecc4bdd..4b5a0fd91 100644
--- a/packages/app/src/components/gpu-power/power-series.test.ts
+++ b/packages/app/src/components/gpu-power/power-series.test.ts
@@ -5,7 +5,6 @@ import {
   bucketPowerFiles,
   bucketTimeMs,
   meanPowerAt,
-  parseTelemetryTimestampUtc,
   sumPowerAt,
   type GpuPowerSeries,
 } from './power-series';
@@ -24,27 +23,6 @@ function row(timestamp: string, index: number, power: number): GpuMetricRow {
   };
 }
 
-describe('parseTelemetryTimestampUtc', () => {
-  it('reads runner nvidia-smi timestamps as UTC regardless of the browser zone', () => {
-    // 2026-09-12 20:19:57.158Z; a local-time parse would shift by the host offset.
-    expect(parseTelemetryTimestampUtc('2026/09/12 20:19:57.158')).toBe(
-      Date.UTC(2026, 8, 12, 20, 19, 57, 158),
-    );
-    expect(parseTelemetryTimestampUtc('2026-09-12 20:19:57')).toBe(
-      Date.UTC(2026, 8, 12, 20, 19, 57, 0),
-    );
-  });
-
-  it('accepts ISO strings with a zone and numeric epochs', () => {
-    expect(parseTelemetryTimestampUtc('2026-09-12T20:19:57.158Z')).toBe(
-      Date.UTC(2026, 8, 12, 20, 19, 57, 158),
-    );
-    expect(parseTelemetryTimestampUtc('1789244397.158')).toBe(1789244397158);
-    expect(parseTelemetryTimestampUtc('1789244397158')).toBe(1789244397158);
-    expect(parseTelemetryTimestampUtc('N/A')).toBeNull();
-  });
-});
-
 describe('bucketPowerSeries', () => {
   it('aligns every GPU on one-second buckets and marks missing samples null', () => {
     const rows = [
@@ -70,47 +48,6 @@ describe('bucketPowerSeries', () => {
     expect(meanPowerAt(series!, 2)).toBe(400);
     expect(bucketTimeMs(series!, 2)).toBe(Date.UTC(2026, 8, 12, 20, 20, 43));
   });
-
-  it('keeps the first sample at each GPU/timestamp before averaging distinct samples', () => {
-    const rows = [
-      row('2026/09/12 04:00:00.100', 0, 300),
-      row('2026/09/12 04:00:00.100', 0, 300), // repeated monitor flush
-      row('2026-09-12T04:00:00.100Z', 0, 999), // same instant, conflicting value
-      row('2026/09/12 04:00:00.100', 1, 100), // different GPU remains independent
-      row('2026/09/12 04:00:00.800', 0, 500),
-      row('2026/09/12 04:00:01.100', 0, 700),
-    ];
-    expect(bucketPowerSeries('gpu_metrics_duplicate', rows)).toMatchObject({
-      gpus: [0, 1],
-      t: [0, 1],
-      power: [
-        [400, 700],
-        [100, null],
-      ],
-    });
-    expect(bucketPowerSeries('gpu_metrics_duplicate', rows, 2)).toMatchObject({
-      bucketSeconds: 2,
-      t: [0],
-      power: [[500], [100]],
-    });
-  });
-
-  it('omits empty buckets so long gaps do not pad the payload', () => {
-    const series = bucketPowerSeries('gpu_metrics_gap', [
-      row('2026/09/12 20:00:00.000', 0, 100),
-      row('2026/09/12 20:00:10.000', 0, 200),
-    ]);
-    expect(series!.t).toEqual([0, 10]);
-    expect(series!.power).toEqual([[100, 200]]);
-  });
-
-  it('drops unparseable rows and returns null when nothing remains', () => {
-    expect(bucketPowerSeries('gpu_metrics_empty', [row('N/A', 0, 100)])).toBeNull();
-    expect(
-      bucketPowerSeries('gpu_metrics_empty', [row('2026/09/12 20:00:00', 0, Number.NaN)]),
-    ).toBeNull();
-    expect(() => bucketPowerSeries('x', [], 0)).toThrow(RangeError);
-  });
 });
 
 describe('sumPowerAt', () => {
@@ -127,12 +64,6 @@ describe('sumPowerAt', () => {
     ],
   };
 
-  it('sums a pool only when every one of its rows has a sample in the bucket', () => {
-    expect(sumPowerAt(series, [0, 1, 2], 0)).toBe(160);
-    expect(sumPowerAt(series, [1, 2], 0)).toBe(60);
-    expect(sumPowerAt(series, [1], 1)).toBe(60);
-  });
-
   it('returns null for a partial pool, an unsampled bucket, an empty pool or an unknown row', () => {
     // GPU 0 and 2 have no sample in bucket 1: a partial sum would read as a dip.
     expect(sumPowerAt(series, [0, 1, 2], 1)).toBeNull();
diff --git a/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts b/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
index 676f8703b..893b1ae2a 100644
--- a/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
+++ b/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
@@ -11,7 +11,6 @@ import {
   prepareGpuMetricsArtifact,
   statMetricColumn,
 } from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
-import { parseMultinodePowerSamples } from '@semianalysisai/inferencex-db/etl/multinode-power-samples';
 
 import { storedGpuStatsForMetric } from './stored-gpu-stats';
 import { ALL_METRIC_OPTIONS, computeGpuStats, parseCsvData, type GpuMetricRow } from './types';
@@ -93,46 +92,6 @@ describe('storedGpuStatsForMetric', () => {
     },
   );
 
-  it.each([
-    ['fractional seconds sharing a rounded millisecond', '1789948800.0009', '1789948800.0011', 1],
-    [
-      'fractional seconds in distinct rounded milliseconds',
-      '1789948800.0001',
-      '1789948800.0009',
-      2,
-    ],
-    ['fractional milliseconds', '1789948800000.9', '1789948800001.1', 1],
-    ['epoch milliseconds and ISO', '1789948800001', '2026-09-20T17:00:00.001-07:00', 1],
-  ])('matches live AMD and ingest populations for %s', (_, first, second, count) => {
-    const csv = `timestamp,gpu,socket_power\n${first},0,100\n${second},0,900`;
-    const artifactDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-stats-timestamp-'));
-    try {
-      fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
-      // Exercise production ingest normalization/dedup/digest, not a test-owned dedup.
-      const [prepared] = prepareGpuMetricsArtifact({
-        artifactDir,
-        artifactName: 'gpu_metrics_amd_fractional_timestamp',
-      });
-      const digest = storedGpuStatsForMetric(
-        prepared.stats.map((row) => ({ ...row, metric: statMetricColumn(row.metric) })),
-        'power',
-      );
-      expect(digest[0]).toMatchObject({
-        count,
-        mean: count === 1 ? 100 : 500,
-        p95: count === 1 ? 100 : 860,
-      });
-      const live = parseCsvData(csv);
-      expect(live.map((row) => Date.parse(row.timestamp))).toEqual(
-        prepared.samples.map((sample) => sample.timestampMs),
-      );
-      const { metric: _metric, ...expected } = prepared.stats[0];
-      expect(computeGpuStats(live, 'power')).toEqual([expected]);
-    } finally {
-      fs.rmSync(artifactDir, { recursive: true, force: true });
-    }
-  });
-
   it('preserves NVIDIA units, zero readings, and full-record percentiles', () => {
     const csv = [
       'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
@@ -166,32 +125,4 @@ describe('storedGpuStatsForMetric', () => {
       stddev: 0,
     });
   });
-
-  it('keeps multinode host-local GPU indices separate and does not invent non-power stats', () => {
-    const hosts = parseMultinodePowerSamples(
-      [
-        'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
-        '1,1789948800,1,host-a,0,GPU-a0,0',
-        '1,1789948801,2,host-a,0,GPU-a0,500',
-        '1,1789948800,1,host-b,0,GPU-b0,800',
-      ].join('\n'),
-    )!;
-    for (const host of hosts) {
-      assertAllMetricStats(
-        host.samples,
-        host.samples.map((sample) => ({
-          timestamp: '',
-          index: sample.gpuIndex,
-          power: sample.powerW!,
-        })),
-      );
-    }
-    expect(storedGpuStatsForMetric(storedStats(hosts[0].samples), 'power')[0].mean).toBe(250);
-    expect(storedGpuStatsForMetric(storedStats(hosts[1].samples), 'power')[0].mean).toBe(800);
-    expect(storedGpuStatsForMetric(storedStats(hosts[0].samples), 'temperature')).toEqual([]);
-  });
-
-  it('keeps a missing digest metric empty', () => {
-    expect(storedGpuStatsForMetric([], 'power')).toEqual([]);
-  });
 });
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
index 8865fc7fc..c181eac2d 100644
--- a/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
@@ -1,13 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import {
-  estimateSampleIntervalMs,
-  meanAcrossSeries,
-  nearestSample,
-  rollingTimeAverage,
-  toAbsoluteMs,
-  type TimedSample,
-} from './telemetry-smoothing';
+import { meanAcrossSeries, rollingTimeAverage, type TimedSample } from './telemetry-smoothing';
 
 const T0 = Date.parse('2026-09-15T21:36:14.107Z');
 
@@ -17,129 +10,15 @@ function everySecond(values: number[], offsetMs = 0): TimedSample[] {
 }
 
 describe('rollingTimeAverage', () => {
-  it('returns an empty array for empty input', () => {
-    expect(rollingTimeAverage([], 30_000)).toEqual([]);
-  });
-
-  it('returns the sample unchanged for a single sample', () => {
-    expect(rollingTimeAverage([{ ms: T0, value: 812.4 }], 60_000)).toEqual([
-      { ms: T0, value: 812.4 },
-    ]);
-  });
-
-  it('copies the input when the window is zero or negative', () => {
-    const input = everySecond([1, 2, 3]);
-    expect(rollingTimeAverage(input, 0)).toEqual(input);
-    expect(rollingTimeAverage(input, -5)).toEqual(input);
-  });
-
   it('averages a centered window and shrinks it at the series edges', () => {
     // 1 s cadence, 2 s window => each sample sees itself and its immediate neighbours.
     const out = rollingTimeAverage(everySecond([100, 200, 600, 200, 100]), 2000);
     expect(out.map((p) => p.value)).toEqual([150, 300, 1000 / 3, 300, 150]);
     expect(out.map((p) => p.ms)).toEqual(everySecond([0, 0, 0, 0, 0]).map((p) => p.ms));
   });
-
-  it('treats both window edges as inclusive', () => {
-    // 4 s window => samples exactly 2 s away are included, 3 s away are not.
-    const out = rollingTimeAverage(everySecond([0, 0, 90, 0, 0, 0]), 4000);
-    // index 2 sees indices 0..4 (five samples) => 18; index 5 sees 3..5 => 0.
-    expect(out[2]!.value).toBeCloseTo(18);
-    expect(out[5]!.value).toBe(0);
-    // index 0 sees 0..2 => 30.
-    expect(out[0]!.value).toBeCloseTo(30);
-  });
-
-  it('uses elapsed time, not sample count, for irregular timestamps', () => {
-    const input: TimedSample[] = [
-      { ms: T0, value: 100 },
-      { ms: T0 + 500, value: 300 }, // burst of close samples
-      { ms: T0 + 700, value: 300 },
-      { ms: T0 + 60_000, value: 900 }, // one minute gap: outside any 10 s window
-    ];
-    const out = rollingTimeAverage(input, 10_000);
-    expect(out[0]!.value).toBeCloseTo((100 + 300 + 300) / 3);
-    expect(out[3]!.value).toBe(900);
-  });
-
-  it('smooths a step change into a ramp whose plateaus keep the original level', () => {
-    const values = [
-      ...Array.from({ length: 30 }, () => 250),
-      ...Array.from({ length: 30 }, () => 950),
-    ];
-    const out = rollingTimeAverage(everySecond(values), 10_000);
-    expect(out[5]!.value).toBe(250);
-    expect(out[54]!.value).toBe(950);
-    const ramp = out.slice(25, 35).map((p) => p.value);
-    for (let i = 1; i < ramp.length; i += 1) expect(ramp[i]!).toBeGreaterThanOrEqual(ramp[i - 1]!);
-    expect(ramp.at(-1)!).toBeGreaterThan(ramp[0]!);
-  });
-});
-
-describe('estimateSampleIntervalMs', () => {
-  it('falls back when there are fewer than two distinct timestamps', () => {
-    expect(estimateSampleIntervalMs([], 1000)).toBe(1000);
-    expect(estimateSampleIntervalMs([{ ms: T0, value: 1 }], 750)).toBe(750);
-    expect(
-      estimateSampleIntervalMs(
-        [
-          { ms: T0, value: 1 },
-          { ms: T0, value: 2 },
-        ],
-        250,
-      ),
-    ).toBe(250);
-  });
-
-  it('returns the median gap so a single dropped sample does not skew it', () => {
-    const samples = [
-      { ms: T0, value: 0 },
-      { ms: T0 + 1000, value: 0 },
-      { ms: T0 + 2000, value: 0 },
-      { ms: T0 + 5000, value: 0 }, // dropped two rows
-      { ms: T0 + 6000, value: 0 },
-    ];
-    expect(estimateSampleIntervalMs(samples)).toBe(1000);
-  });
 });
 
 describe('meanAcrossSeries', () => {
-  it('returns an empty array when there are no series or only empty series', () => {
-    expect(meanAcrossSeries([], 1000)).toEqual([]);
-    expect(meanAcrossSeries([[], []], 1000)).toEqual([]);
-  });
-
-  it('returns a single series as its own mean with count 1', () => {
-    const only = everySecond([10, 20]);
-    expect(meanAcrossSeries([only], 1000)).toEqual([
-      { ms: only[0]!.ms, value: 10, count: 1 },
-      { ms: only[1]!.ms, value: 20, count: 1 },
-    ]);
-  });
-
-  it('aligns chips polled a few ms apart onto the reference timeline', () => {
-    // nvidia-smi writes chip rows ~12 ms apart within one 1 s poll.
-    const chip0 = everySecond([200, 400, 600]);
-    const chip1 = everySecond([300, 500, 700], 12);
-    const chip2 = everySecond([100, 300, 500], 25);
-    const out = meanAcrossSeries([chip0, chip1, chip2], 1000);
-    expect(out.map((p) => p.ms)).toEqual(chip0.map((p) => p.ms));
-    expect(out.map((p) => p.value)).toEqual([200, 400, 600]);
-    expect(out.every((p) => p.count === 3)).toBe(true);
-  });
-
-  it('uses the longest series as the reference and skips chips with no sample in tolerance', () => {
-    const chip0 = everySecond([100, 100]); // shorter: stops early
-    const chip1 = everySecond([300, 300, 300, 300]);
-    const out = meanAcrossSeries([chip0, chip1], 500);
-    expect(out).toHaveLength(4);
-    expect(out[0]).toEqual({ ms: chip1[0]!.ms, value: 200, count: 2 });
-    expect(out[1]).toEqual({ ms: chip1[1]!.ms, value: 200, count: 2 });
-    // chip0 has nothing within 500 ms of t=2 s and t=3 s.
-    expect(out[2]).toEqual({ ms: chip1[2]!.ms, value: 300, count: 1 });
-    expect(out[3]).toEqual({ ms: chip1[3]!.ms, value: 300, count: 1 });
-  });
-
   it('picks the nearest sample when a chip dropped a row', () => {
     const chip0 = everySecond([0, 0, 0, 0]);
     const chip1: TimedSample[] = [
@@ -152,52 +31,4 @@ describe('meanAcrossSeries', () => {
     expect(out.map((p) => p.count)).toEqual([2, 1, 2, 2]);
     expect(out.map((p) => p.value)).toEqual([5, 0, 15, 20]);
   });
-
-  it('treats a negative tolerance as exact-match only', () => {
-    const chip0 = everySecond([0, 0]);
-    const chip1 = everySecond([10, 10], 1);
-    expect(meanAcrossSeries([chip0, chip1], -1).every((p) => p.count === 1)).toBe(true);
-    expect(meanAcrossSeries([chip0, everySecond([10, 10])], -1).every((p) => p.count === 2)).toBe(
-      true,
-    );
-  });
-});
-
-describe('toAbsoluteMs', () => {
-  it('offsets relative seconds from the given origin', () => {
-    // Trace startNs from a real point, as the API returns it.
-    const originMs = 1789508185611923200 / 1e6;
-    expect(
-      toAbsoluteMs(
-        [
-          { t: 0, value: 0 },
-          { t: 1.5, value: 42 },
-        ],
-        originMs,
-      ),
-    ).toEqual([
-      { ms: originMs, value: 0 },
-      { ms: originMs + 1500, value: 42 },
-    ]);
-    expect(toAbsoluteMs([], originMs)).toEqual([]);
-  });
-});
-
-describe('nearestSample', () => {
-  const samples = everySecond([1, 2, 3, 4]);
-
-  it('returns null for an empty series', () => {
-    expect(nearestSample([], T0)).toBeNull();
-  });
-
-  it('returns the closest sample, clamping outside the series range', () => {
-    expect(nearestSample(samples, T0 - 5000)).toEqual(samples[0]);
-    expect(nearestSample(samples, T0 + 99_000)).toEqual(samples[3]);
-    expect(nearestSample(samples, T0 + 1400)).toEqual(samples[1]);
-    expect(nearestSample(samples, T0 + 1600)).toEqual(samples[2]);
-  });
-
-  it('prefers the earlier sample on an exact tie', () => {
-    expect(nearestSample(samples, T0 + 1500)).toEqual(samples[1]);
-  });
 });
diff --git a/packages/app/src/components/gpu-power/types.test.ts b/packages/app/src/components/gpu-power/types.test.ts
index d4847cc8c..d6af71212 100644
--- a/packages/app/src/components/gpu-power/types.test.ts
+++ b/packages/app/src/components/gpu-power/types.test.ts
@@ -5,7 +5,6 @@ import {
   computeGpuStats,
   detectTdpFromArtifactName,
   getAvailableMetrics,
-  tdpForHardware,
   type GpuMetricRow,
   GPU_METRIC_OPTIONS,
   parseCsvData,
@@ -58,20 +57,6 @@ describe('parseCsvData', () => {
     expect(result[1].power).toBe(300.2);
   });
 
-  it('keeps ISO timestamps and deduplicates equivalent offset instants', () => {
-    const csv = `${CSV_HEADER}
-2026-03-08T02:30:00.000Z, 0, 100, 60, 1500, 2000, 95, 80
-2026-03-07T18:30:00.000-08:00, 0, 900, 60, 1500, 2000, 95, 80
-2026-03-08T03:30:00.000Z, 0, 300, 60, 1500, 2000, 95, 80`;
-    const rows = parseCsvData(csv);
-    expect(rows.map((row) => row.timestamp)).toEqual([
-      '2026-03-08T02:30:00.000Z',
-      '2026-03-08T03:30:00.000Z',
-    ]);
-    expect(rows.map((row) => row.power)).toEqual([100, 300]);
-    expect(computeGpuStats(rows, 'power')[0]).toMatchObject({ count: 2, mean: 200, p95: 290 });
-  });
-
   it('returns empty array for header-only CSV', () => {
     expect(parseCsvData(CSV_HEADER)).toEqual([]);
   });
@@ -80,17 +65,6 @@ describe('parseCsvData', () => {
     expect(parseCsvData('')).toEqual([]);
   });
 
-  it('retains valid power when secondary metric columns are missing', () => {
-    const csv = `${CSV_HEADER}
-2026/03/07 00:20:37.071, 0, 76.78 W
-2026/03/07 00:20:37.071, 1, 76.08 W, 29, 345 MHz, 3201 MHz, 0 %, 0 %`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(2);
-    expect(result[0].index).toBe(0);
-    expect(result[0].power).toBe(76.78);
-    expect(result[0].temperature).toBeUndefined();
-  });
-
   it('skips rows with NaN values', () => {
     const csv = `${CSV_HEADER}
 2026/03/07 00:20:37.071, abc, 76.78 W, 30, 345 MHz, 3201 MHz, 0 %, 0 %`;
@@ -264,43 +238,6 @@ describe('parseCsvData', () => {
     expect(result[0].temperature).toBeUndefined();
   });
 
-  it('NVIDIA: retains finite metrics, measured zeros and the first duplicate sample', () => {
-    const csv = `${CSV_HEADER}
-2026/03/07 00:20:37.071, 0, 0 W, N/A, Infinity, 3201 MHz, 0 %, N/A
-2026/03/07 00:20:37.071, 0, 900 W, 70, 1980 MHz, 3201 MHz, 99 %, 80 %
-2026/03/07 00:20:38.071, 0, 100 W, 40, 120 MHz, 3201 MHz, 0 %, 0 %
-2026/03/07 00:20:38.071, 1, Infinity, 40, 120 MHz, 3201 MHz, 0 %, 0 %`;
-    const rows = parseCsvData(csv);
-    expect(rows).toHaveLength(2);
-    expect(rows[0]).toMatchObject({ power: 0, gpuUtil: 0 });
-    expect(rows[0].temperature).toBeUndefined();
-    expect(rows[0].smClock).toBeUndefined();
-    expect(computeGpuStats(rows, 'power')[0]).toMatchObject({ count: 2, min: 0, mean: 50 });
-    expect(computeGpuStats(rows, 'temperature')[0]).toMatchObject({ count: 1, mean: 40 });
-  });
-
-  it('NVIDIA: resolves reordered and omitted optional columns by name', () => {
-    const rows = parseCsvData(
-      'index,power.draw [W],timestamp,utilization.gpu [%]\n0,0 W,2026/03/07 00:20:37.071,0 %',
-    );
-    expect(rows).toHaveLength(1);
-    expect(rows[0]).toMatchObject({ index: 0, power: 0, gpuUtil: 0 });
-    expect(rows[0].temperature).toBeUndefined();
-  });
-
-  it('AMD: leaves absent, N/A and nonfinite metrics missing without losing zeros', () => {
-    const rows = parseCsvData(
-      'timestamp,gpu,socket_power,gfx_activity,gfx_0_clk,gfx_voltage\n1772939616,0,0,0,N/A,Infinity',
-    );
-    expect(rows).toHaveLength(1);
-    expect(rows[0]).toMatchObject({ power: 0, gpuUtil: 0 });
-    for (const key of ['temperature', 'smClock', 'memClock', 'memUtil', 'gfxVoltage'] as const) {
-      expect(rows[0][key], key).toBeUndefined();
-      expect(computeGpuStats(rows, key), key).toEqual([]);
-    }
-    expect(getAvailableMetrics(rows).map((metric) => metric.key)).toEqual(['power', 'gpuUtil']);
-  });
-
   it('AMD: populates all AMD-specific metric fields', () => {
     const amdHeader =
       'timestamp,gpu,gfx_activity,umc_activity,mm_activity,socket_power,gfx_voltage,soc_voltage,mem_voltage,gfx_0_clk,mem_0_clk,fclk_0_clk,socclk_0_clk,edge,hotspot,mem';
@@ -610,30 +547,3 @@ describe('GPU_METRIC_OPTIONS', () => {
     }
   });
 });
-
-describe('tdpForHardware', () => {
-  it('resolves a benchmark point hardware key regardless of artifact naming', () => {
-    expect(tdpForHardware('b200')).toEqual({
-      sku: 'B200',
-      tdp: detectTdpFromArtifactName('gpu_metrics_x_b200-nb_0')!.tdp,
-    });
-    expect(tdpForHardware('GB300')?.sku).toBe('GB300');
-    expect(tdpForHardware(undefined)).toBeNull();
-    expect(tdpForHardware('not-a-sku')).toBeNull();
-  });
-});
-
-/** A multinode DCGM bundle row: power sampled, nothing else collected. */
-const powerOnly = (index: number, power: number) => ({
-  timestamp: '2026-09-12T22:08:20Z',
-  index,
-  power,
-});
-
-describe('power-only rows', () => {
-  it('offers only the metrics the collector sampled', () => {
-    expect(getAvailableMetrics([powerOnly(0, 700), powerOnly(1, 710)]).map((m) => m.key)).toEqual([
-      'power',
-    ]);
-  });
-});
diff --git a/packages/app/src/components/inference/agentic-point/overlay-sources.test.ts b/packages/app/src/components/inference/agentic-point/overlay-sources.test.ts
deleted file mode 100644
index 04bc1d44a..000000000
--- a/packages/app/src/components/inference/agentic-point/overlay-sources.test.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import type { TraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
-
-import { availableOverlaySources, OVERLAY_SOURCES } from './overlay-sources';
-
-const base: TraceServerMetrics = {
-  meta: {} as TraceServerMetrics['meta'],
-  startNs: 1_789_508_185_611_923_200,
-  endNs: 1_789_512_197_546_315_776,
-  durationS: 4011.9,
-  timeslicesCount: 3,
-  kvCacheUsage: [],
-  prefixCacheHitRate: [],
-  queueDepth: [],
-  promptTokensBySource: {},
-  prefillTps: [],
-  decodeTps: [],
-  prefixCacheHitsTps: [],
-  hostKvCacheUsage: [],
-  kvCacheUsageByEngine: [],
-  kvCachePoolTokens: null,
-  metricSources: [],
-};
-
-describe('availableOverlaySources', () => {
-  it('returns nothing without metrics or when every series is empty', () => {
-    expect(availableOverlaySources(null)).toEqual([]);
-    expect(availableOverlaySources(base)).toEqual([]);
-  });
-
-  it('offers only non-empty series, in menu order', () => {
-    const metrics: TraceServerMetrics = {
-      ...base,
-      queueDepth: [{ t: 0, running: 3, waiting: 2, total: 5 }],
-      decodeTps: [{ t: 0, value: 1200 }],
-    };
-    expect(availableOverlaySources(metrics).map((s) => s.key)).toEqual(['decodeTps', 'queueDepth']);
-  });
-
-  it('converts ratios to percent and queue depth to the total', () => {
-    const metrics: TraceServerMetrics = {
-      ...base,
-      kvCacheUsage: [{ t: 1, value: 0.42 }],
-      hostKvCacheUsage: [{ t: 1, value: 0.05 }],
-      prefixCacheHitRate: [{ t: 1, value: 1 }],
-      queueDepth: [{ t: 1, running: 3, waiting: 2, total: 5 }],
-    };
-    const byKey = Object.fromEntries(OVERLAY_SOURCES.map((s) => [s.key, s.points(metrics)]));
-    expect(byKey.kvCacheUsage).toEqual([{ t: 1, value: 42 }]);
-    expect(byKey.hostKvCacheUsage[0]!.value).toBeCloseTo(5, 9);
-    expect(byKey.prefixCacheHitRate).toEqual([{ t: 1, value: 100 }]);
-    expect(byKey.queueDepth).toEqual([{ t: 1, value: 5 }]);
-    expect(byKey.decodeTps).toEqual([]);
-  });
-
-  it('gives every source a distinct key and color', () => {
-    expect(new Set(OVERLAY_SOURCES.map((s) => s.key)).size).toBe(OVERLAY_SOURCES.length);
-    expect(new Set(OVERLAY_SOURCES.map((s) => s.color)).size).toBe(OVERLAY_SOURCES.length);
-  });
-});
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.test.ts b/packages/app/src/components/inference/agentic-point/power-telemetry-view.test.ts
deleted file mode 100644
index 3fb14973f..000000000
--- a/packages/app/src/components/inference/agentic-point/power-telemetry-view.test.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { collectorLabel } from './power-telemetry-view';
-
-describe('collectorLabel', () => {
-  it('names the recorded producer for multinode power bundles', () => {
-    expect(
-      collectorLabel({
-        vendor: 'nvidia',
-        sidecars: {
-          context: { producer: 'srt-slurm.dcgm-power', source_metric: 'DCGM_FI_DEV_POWER_USAGE' },
-        },
-      }),
-    ).toBe('srt-slurm.dcgm-power');
-  });
-
-  it('falls back to the vendor CLI for single-node CSVs', () => {
-    expect(
-      collectorLabel({ vendor: 'nvidia', sidecars: { context: { timestamp_timezone: 'UTC' } } }),
-    ).toBe('nvidia-smi');
-    expect(collectorLabel({ vendor: 'amd', sidecars: {} })).toBe('amd-smi');
-    expect(collectorLabel({ vendor: 'other', sidecars: { context: { producer: '  ' } } })).toBe(
-      'other',
-    );
-  });
-});
diff --git a/packages/app/src/components/inference/agentic-point/use-detail-view.test.tsx b/packages/app/src/components/inference/agentic-point/use-detail-view.test.tsx
index 64874bb74..4fe54b399 100644
--- a/packages/app/src/components/inference/agentic-point/use-detail-view.test.tsx
+++ b/packages/app/src/components/inference/agentic-point/use-detail-view.test.tsx
@@ -21,7 +21,6 @@ function DetailViewProbe() {
     createElement('button', { onClick: () => setView('point') }, 'point'),
     createElement('button', { onClick: () => setView('timeline') }, 'timeline'),
     createElement('button', { onClick: () => setView('aggregates') }, 'aggregates'),
-    createElement('button', { onClick: () => setView('power') }, 'power'),
   );
 }
 
@@ -120,25 +119,4 @@ describe('useDetailView', () => {
     });
     expect(renderedView()).toBe('aggregates');
   });
-
-  it('accepts the PowerX view from the URL and writes it back on selection', () => {
-    nativeReplace('/inference/agentic/42?view=power');
-    renderProbe();
-    expect(renderedView()).toBe('power');
-
-    click('point');
-    expect(new URLSearchParams(window.location.search).has('view')).toBe(false);
-    click('power');
-    expect(renderedView()).toBe('power');
-    expect(new URLSearchParams(window.location.search).get('view')).toBe('power');
-    expect(track).toHaveBeenLastCalledWith('inference_agentic_detail_view_changed', {
-      view: 'power',
-    });
-  });
-
-  it('falls back to the per-point view for unknown view names', () => {
-    nativeReplace('/inference/agentic/42?view=telemetry');
-    renderProbe();
-    expect(renderedView()).toBe('point');
-  });
 });
diff --git a/packages/app/src/components/inference/measured-metric-config.test.ts b/packages/app/src/components/inference/measured-metric-config.test.ts
index f7b4de74c..5ed4ec446 100644
--- a/packages/app/src/components/inference/measured-metric-config.test.ts
+++ b/packages/app/src/components/inference/measured-metric-config.test.ts
@@ -5,7 +5,6 @@ import {
   METRIC_CONFIG_KEYS,
   POWER_BASIS_METRIC_CONFIG_KEYS,
 } from './metric-registry';
-import { POWER_BASES } from '@/lib/power-basis';
 import {
   changeMeasuredMetricConfig,
   getMeasuredMetricConfig,
@@ -23,14 +22,6 @@ describe('measured metric configuration', () => {
     },
   );
 
-  it.each(POWER_BASIS_METRIC_CONFIG_KEYS)('round-trips the power-boundary metric %s', (key) => {
-    const config = getMeasuredMetricConfig(key);
-    expect(config).toBeDefined();
-    expect(config?.basis).not.toBe('gpu-measured');
-    expect(changeMeasuredMetricConfig(key, {})).toBe(key);
-    expect(changeMeasuredMetricConfig('y_tpPerGpu', config!)).toBe(key);
-  });
-
   it('does not group unrelated metrics or unknown persisted values', () => {
     const grouped = METRIC_CONFIG_KEYS.filter((key) => getMeasuredMetricConfig(key));
     expect(grouped).toHaveLength(20);
@@ -88,36 +79,6 @@ describe('measured metric configuration', () => {
     ).toBe('y_measuredDecodeAvgPower');
   });
 
-  it('offers the telemetry timeline only for the whole-deployment average', () => {
-    expect(getMeasuredMetricConfig('y_measuredPowerTimeline')).toEqual({
-      family: 'power',
-      basis: 'gpu-measured',
-      scope: 'all',
-      statistic: 'average',
-      display: 'timeline',
-    });
-    expect(changeMeasuredMetricConfig('y_measuredAvgPower', { display: 'timeline' })).toBe(
-      'y_measuredPowerTimeline',
-    );
-    expect(changeMeasuredMetricConfig('y_measuredPowerPercentTdp', { display: 'timeline' })).toBe(
-      'y_measuredPowerTimeline',
-    );
-    // Percentiles and role scopes have no per-second trace; they fall back to watts.
-    expect(changeMeasuredMetricConfig('y_measuredPowerTimeline', { statistic: 'p90' })).toBe(
-      'y_measuredP90Power',
-    );
-    expect(changeMeasuredMetricConfig('y_measuredPowerTimeline', { scope: 'prefill' })).toBe(
-      'y_measuredPrefillAvgPower',
-    );
-    expect(changeMeasuredMetricConfig('y_measuredP75Power', { display: 'timeline' })).toBe(
-      'y_measuredP75Power',
-    );
-    // Leaving the timeline for energy and coming back lands on the family default.
-    expect(changeMeasuredMetricConfig('y_measuredPowerTimeline', { family: 'energy' })).toBe(
-      'y_measuredJPerOutputToken',
-    );
-  });
-
   it('changes the energy denominator without silently attributing whole-run energy to a role', () => {
     expect(changeMeasuredMetricConfig('y_measuredJPerOutputToken', { denominator: 'input' })).toBe(
       'y_measuredJPerInputToken',
@@ -160,93 +121,4 @@ describe('measured metric configuration', () => {
       changeMeasuredMetricConfig('y_measuredPrefillJPerInputToken', { unit: 'wattHours' }),
     ).toBe('y_measuredPrefillJPerInputToken');
   });
-
-  it('keeps the existing share-link defaults on the GPU-measured boundary', () => {
-    expect(getMeasuredMetricConfig(MEASURED_METRIC_DEFAULTS.power)?.basis).toBe('gpu-measured');
-    expect(getMeasuredMetricConfig(MEASURED_METRIC_DEFAULTS.energy)?.basis).toBe('gpu-measured');
-    expect(POWER_BASES[0]).toBe('gpu-measured');
-  });
-
-  it('snaps a boundary change to that boundary’s canonical combination', () => {
-    // The P90 statistic has no provisioned counterpart: choosing the boundary
-    // moves to its whole-deployment average watts.
-    expect(changeMeasuredMetricConfig('y_measuredP90Power', { basis: 'gpu-provisioned' })).toBe(
-      'y_gpuProvisionedWatts',
-    );
-    expect(
-      changeMeasuredMetricConfig('y_measuredPowerPercentTdp', { basis: 'utility-provisioned' }),
-    ).toBe('y_utilityProvisionedWatts');
-    expect(
-      changeMeasuredMetricConfig('y_measuredDecodeAvgPower', { basis: 'utility-modeled' }),
-    ).toBe('y_utilityModeledWatts');
-    // Role- and query-scoped energy snap to joules per output token.
-    expect(
-      changeMeasuredMetricConfig('y_measuredPrefillJPerInputToken', { basis: 'utility-modeled' }),
-    ).toBe('y_utilityModeledJPerOutputToken');
-    expect(
-      changeMeasuredMetricConfig('y_measuredWhPerSuccessfulQuery', { basis: 'gpu-provisioned' }),
-    ).toBe('y_gpuProvisionedJPerOutputToken');
-    // Boundary-to-boundary moves stay within the family.
-    expect(
-      changeMeasuredMetricConfig('y_gpuProvisionedWatts', { basis: 'utility-provisioned' }),
-    ).toBe('y_utilityProvisionedWatts');
-    expect(
-      changeMeasuredMetricConfig('y_utilityModeledJPerOutputToken', { basis: 'gpu-provisioned' }),
-    ).toBe('y_gpuProvisionedJPerOutputToken');
-    // A boundary requested together with other dimensions wins over them.
-    expect(
-      changeMeasuredMetricConfig('y_measuredAvgPower', {
-        basis: 'utility-modeled',
-        statistic: 'p90',
-      }),
-    ).toBe('y_utilityModeledWatts');
-  });
-
-  it('returns to GPU-measured telemetry from a boundary', () => {
-    expect(changeMeasuredMetricConfig('y_gpuProvisionedWatts', { basis: 'gpu-measured' })).toBe(
-      'y_measuredAvgPower',
-    );
-    expect(
-      changeMeasuredMetricConfig('y_utilityProvisionedJPerOutputToken', { basis: 'gpu-measured' }),
-    ).toBe('y_measuredJPerOutputToken');
-    // Every other dimension exists only for telemetry, so changing one from a
-    // boundary lands on the nearest GPU-measured key rather than a dead end.
-    expect(changeMeasuredMetricConfig('y_utilityModeledWatts', { statistic: 'p75' })).toBe(
-      'y_measuredP75Power',
-    );
-    expect(changeMeasuredMetricConfig('y_gpuProvisionedWatts', { scope: 'decode' })).toBe(
-      'y_measuredDecodeAvgPower',
-    );
-    expect(changeMeasuredMetricConfig('y_utilityProvisionedWatts', { display: 'tdp' })).toBe(
-      'y_measuredPowerPercentTdp',
-    );
-    expect(
-      changeMeasuredMetricConfig('y_utilityModeledJPerOutputToken', { denominator: 'query' }),
-    ).toBe('y_measuredJPerSuccessfulQuery');
-    expect(changeMeasuredMetricConfig('y_gpuProvisionedJPerOutputToken', { scope: 'decode' })).toBe(
-      'y_measuredDecodeJPerOutputToken',
-    );
-    // Re-selecting the canonical value is still a dimension change and leaves the boundary.
-    expect(changeMeasuredMetricConfig('y_utilityModeledWatts', { statistic: 'average' })).toBe(
-      'y_measuredAvgPower',
-    );
-    expect(changeMeasuredMetricConfig('y_gpuProvisionedJPerOutputToken', { unit: 'joules' })).toBe(
-      'y_measuredJPerOutputToken',
-    );
-  });
-
-  it('keeps the boundary across a family switch', () => {
-    expect(changeMeasuredMetricConfig('y_utilityProvisionedWatts', { family: 'energy' })).toBe(
-      'y_utilityProvisionedJPerOutputToken',
-    );
-    expect(changeMeasuredMetricConfig('y_gpuProvisionedJPerOutputToken', { family: 'power' })).toBe(
-      'y_gpuProvisionedWatts',
-    );
-    expect(
-      changeMeasuredMetricConfig('y_tokensPerDollarH', {
-        family: 'energy',
-        basis: 'utility-modeled',
-      }),
-    ).toBe('y_utilityModeledJPerOutputToken');
-  });
 });
diff --git a/packages/app/src/components/inference/measured-power-direction.test.ts b/packages/app/src/components/inference/measured-power-direction.test.ts
index 790df173f..44d2e4ff0 100644
--- a/packages/app/src/components/inference/measured-power-direction.test.ts
+++ b/packages/app/src/components/inference/measured-power-direction.test.ts
@@ -3,11 +3,6 @@ import { describe, it, expect } from 'vitest';
 import chartDefinitions from '@/components/inference/metric-registry';
 import type { ChartDefinition, InferenceData } from '@/components/inference/types';
 import { sortRowsByYMetric } from '@/components/inference/ui/inference-table-sort';
-import {
-  isMeasuredPowerCurveMetric,
-  isPowerCurveMetric,
-  upperPowerEnvelope,
-} from '@/components/inference/utils/powerCurves';
 import {
   isFrontierEligible,
   paretoFrontForDirection,
@@ -34,24 +29,6 @@ const MEASURED_POWER_METRICS = [
   'y_measuredPrefillAvgPower',
   'y_measuredDecodeAvgPower',
   'y_measuredPowerPercentTdp',
-  // Derived power boundaries share the watts semantics: the declared corner
-  // drives the ascending table sort, while the chart itself draws the upper
-  // power envelope (asserted separately below), exactly like measured watts.
-  'y_gpuProvisionedWatts',
-  'y_utilityProvisionedWatts',
-  'y_utilityModeledWatts',
-] as const;
-
-const BASIS_WATT_METRICS = [
-  'y_gpuProvisionedWatts',
-  'y_utilityProvisionedWatts',
-  'y_utilityModeledWatts',
-] as const;
-
-const BASIS_ENERGY_METRICS = [
-  'y_gpuProvisionedJPerOutputToken',
-  'y_utilityProvisionedJPerOutputToken',
-  'y_utilityModeledJPerOutputToken',
 ] as const;
 
 const QUERY_ENERGY_METRICS = [
@@ -188,46 +165,6 @@ describe('measured-power Pareto direction', () => {
     }
   });
 
-  it.each(BASIS_ENERGY_METRICS)('%s is bilingual and lower-is-better', (metric) => {
-    expect(declaredDirection(interactivityDef, metric)).toBe('lower_right');
-    expect(declaredDirection(e2eDef, metric)).toBe('lower_left');
-    for (const chartDef of [interactivityDef, e2eDef]) {
-      expect(chartDef[metric]).toMatch(/\.y$/u);
-      expect(chartDef[`${metric}_label`]).toBeTruthy();
-      expect(chartDef[`${metric}_labelZh`]).toBeTruthy();
-    }
-    // Energy uses the Pareto corner, not the power envelope: the dominated
-    // sweep points drop out just as they do for measured joules.
-    expect(frontierConcs(interactivityDef, metric)).toEqual([1, 32]);
-    expect(frontierConcs(e2eDef, metric)).toEqual([256, 32]);
-  });
-
-  describe.each(BASIS_WATT_METRICS)('%s', (metric) => {
-    it('draws the upper power envelope, not the Pareto corner, like measured watts', () => {
-      // ScatterGraph/GPUGraph pick the curve by `isPowerCurveMetric`; a watt
-      // boundary that misses that set would hide every dominated sweep point
-      // under Optimal Only and, for a flat TDP series, collapse to one marker.
-      expect(isPowerCurveMetric(metric)).toBe(true);
-      expect(isPowerCurveMetric('y_measuredAvgPower')).toBe(true);
-      // Envelope-locked like measured watts: with Optimal Only on, a Pareto
-      // corner would keep one marker and draw no curve for a flat TDP series.
-      expect(isMeasuredPowerCurveMetric(metric)).toBe(true);
-      expect(isMeasuredPowerCurveMetric('y_modeledChassisPowerPerGpu')).toBe(false);
-      expect(isMeasuredPowerCurveMetric('y_measuredAvgPower')).toBe(true);
-
-      const metricField = (interactivityDef[metric] as string).replace(/\.y$/u, '');
-      const envelope = upperPowerEnvelope(sweepPoints(metricField), true).map((p) => p.conc);
-      // The 1400 W conc 8 peak survives on the envelope; the Pareto corner drops it.
-      expect(envelope).toContain(8);
-      expect(frontierConcs(interactivityDef, metric)).not.toContain(8);
-    });
-  });
-
-  it.each(BASIS_ENERGY_METRICS)('%s stays off the power-envelope path', (metric) => {
-    expect(isPowerCurveMetric(metric)).toBe(false);
-    expect(isMeasuredPowerCurveMetric(metric)).toBe(false);
-  });
-
   it('keeps %TDP bilingual while using the same per-hardware frontier as watts', () => {
     // A fixed hardware TDP rescales watts without changing dominance within
     // that hardware series. The shared sweep tests above exercise both axes.
diff --git a/packages/app/src/components/inference/metric-registry.test.ts b/packages/app/src/components/inference/metric-registry.test.ts
index c2944fa84..db4011826 100644
--- a/packages/app/src/components/inference/metric-registry.test.ts
+++ b/packages/app/src/components/inference/metric-registry.test.ts
@@ -10,7 +10,6 @@ import {
   isBenchmarkMetricKey,
   isMeasuredEnergyConfigKey,
   isModeledSystemPowerConfigKey,
-  isPowerBasisConfigKey,
   isRoleLocalMeasuredEnergyConfigKey,
   MEASURED_ENERGY_METRIC_CONFIG_KEYS,
   METRIC_CONFIG_KEYS,
@@ -24,7 +23,6 @@ import {
   resolveMetricConfigKey,
   tokenMetricTypeForConfigKey,
 } from './metric-registry';
-import { POWER_BASIS_FIELDS } from '@/lib/power-basis';
 import type { YAxisMetricKey } from './types';
 
 describe('metric registry', () => {
@@ -224,47 +222,6 @@ describe('metric registry', () => {
     ]);
   });
 
-  it('files the derived power boundaries under the gate without a telemetry tier', () => {
-    // Every derived field lib/power-basis.ts can emit is selectable from the
-    // gated group, and none of them is mistaken for runner telemetry.
-    const basisFields = Object.values(POWER_BASIS_FIELDS).flatMap((fields) =>
-      Object.values(fields).map((field) => `y_${field}`),
-    );
-    expect([...POWER_BASIS_METRIC_CONFIG_KEYS].toSorted()).toEqual(basisFields.toSorted());
-    for (const key of POWER_BASIS_METRIC_CONFIG_KEYS) {
-      expect(key, key).not.toMatch(/^y_measured/u);
-      expect(isPowerBasisConfigKey(key), key).toBe(true);
-      expect(isMeasuredEnergyConfigKey(key), key).toBe(false);
-      expect(isModeledSystemPowerConfigKey(key), key).toBe(false);
-      expect(resolveMetricConfigKey(key), key).toBe(key);
-      const metric = METRIC_REGISTRY[key.slice(2) as keyof typeof METRIC_REGISTRY];
-      expect(chartDefinitions[0][key], key).toBe(metric.field);
-      expect(metric.labelZh, key).toMatch(/\p{Script=Han}/u);
-      expect(metric.titleZh, key).toMatch(/\p{Script=Han}/u);
-    }
-    for (const key of MEASURED_ENERGY_METRIC_CONFIG_KEYS) {
-      expect(isPowerBasisConfigKey(key), key).toBe(false);
-    }
-    expect(isPowerBasisConfigKey('y_modeledChassisPowerPerGpu')).toBe(false);
-    expect(isPowerBasisConfigKey('y_jOutput')).toBe(false);
-    // Watts keys stay token-agnostic; energy keys are output-token metrics, so
-    // the output-capable point filter admits them.
-    expect(tokenMetricTypeForConfigKey('y_utilityProvisionedWatts')).toBe('total');
-    expect(tokenMetricTypeForConfigKey('y_utilityProvisionedJPerOutputToken')).toBe('output');
-    expect(tokenMetricTypeForConfigKey('y_utilityModeledJPerOutputToken')).toBe('output');
-  });
-
-  it('keeps the all-GPU utility energy distinguishable from the per-decode-GPU jOutput', () => {
-    const labels = [
-      METRIC_REGISTRY.jOutput.label,
-      METRIC_REGISTRY.utilityProvisionedJPerOutputToken.label,
-      METRIC_REGISTRY.jOutput.labelZh,
-      METRIC_REGISTRY.utilityProvisionedJPerOutputToken.labelZh,
-    ];
-    expect(new Set(labels).size).toBe(labels.length);
-    expect(METRIC_REGISTRY.utilityProvisionedJPerOutputToken.title).toContain('all GPUs');
-  });
-
   it('classifies measured-energy config keys', () => {
     expect(isMeasuredEnergyConfigKey('y_measuredAvgPower')).toBe(true);
     expect(isMeasuredEnergyConfigKey('y_measuredWhPerSuccessfulQuery')).toBe(true);
diff --git a/packages/app/src/components/inference/perf-ruler-store.test.ts b/packages/app/src/components/inference/perf-ruler-store.test.ts
deleted file mode 100644
index 22e50d0e8..000000000
--- a/packages/app/src/components/inference/perf-ruler-store.test.ts
+++ /dev/null
@@ -1,246 +0,0 @@
-// @vitest-environment jsdom
-import { act, createElement } from 'react';
-import { createRoot, type Root } from 'react-dom/client';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { track } from '@/lib/analytics';
-import { perfRulerAxisMetricKey } from '@/hooks/usePerfRulerAxisReset';
-import {
-  EMPTY_PERF_RULER_STATE,
-  nextPerfRulerState,
-  serializePerfRulers,
-} from '@/lib/d3-chart/layers/perf-ruler';
-
-import {
-  type PerfRulerStore,
-  PerfRulerStoreContext,
-  persistedPerfRulerAxisKey,
-  usePerfRulerStore,
-  usePerfRulerStoreValue,
-} from './perf-ruler-store';
-
-vi.mock('@/lib/analytics', () => ({ track: vi.fn() }));
-
-// `graphs` is always [interactivity, e2e]; ChartDisplay renders the e2e
-// graph as chart-0 for every non-interactivity x mode.
-const graphs = (e2eXField: string) => [
-  { chartDefinition: { chartType: 'interactivity', x_scale_field: 'p90_intvty' } },
-  { chartDefinition: { chartType: 'e2e', x_scale_field: e2eXField } },
-];
-
-describe('persisted perf-ruler store', () => {
-  let container: HTMLDivElement;
-  let root: Root;
-
-  const CURVE_A = 'roofline-b200_trt_fp8';
-  const CURVE_B = 'roofline-mi355x_sglang_fp4';
-  const OVERLAY = 'overlay-roofline-h100_vllm_fp8_run1';
-  const AXIS = perfRulerAxisMetricKey('p90_e2el', 'y_totalTokensPerDollarTco');
-
-  interface Harness {
-    store: () => PerfRulerStore;
-    rerender: (axisMetricKey: string | null) => void;
-  }
-
-  /**
-   * Hosts the store hook the way `InferenceProvider` does and reads it back
-   * through `usePerfRulerStore`, so the test observes what a chart mounted
-   * under the provider observes.
-   */
-  function mountStore(
-    initialSerialized: string | undefined,
-    axisMetricKey: string | null,
-  ): Harness {
-    let latest!: PerfRulerStore;
-    let axisKey = axisMetricKey;
-    const Consumer = () => {
-      latest = usePerfRulerStore()!;
-      return null;
-    };
-    function Host() {
-      const store = usePerfRulerStoreValue('chart-0', initialSerialized, axisKey);
-      return createElement(
-        PerfRulerStoreContext.Provider,
-        { value: store },
-        createElement(Consumer),
-      );
-    }
-    const render = () => act(() => root.render(createElement(Host)));
-    render();
-    return {
-      store: () => latest,
-      rerender: (next) => {
-        axisKey = next;
-        render();
-      },
-    };
-  }
-
-  beforeEach(() => {
-    vi.mocked(track).mockClear();
-    container = document.createElement('div');
-    document.body.append(container);
-    root = createRoot(container);
-  });
-
-  afterEach(() => {
-    act(() => root.unmount());
-    container.remove();
-  });
-
-  it('is absent outside the provider so charts fall back to local state', () => {
-    let seen: PerfRulerStore | undefined | null = null;
-    const Consumer = () => {
-      seen = usePerfRulerStore();
-      return null;
-    };
-    act(() => root.render(createElement(Consumer)));
-    expect(seen).toBeUndefined();
-  });
-
-  it('parses the share link into pending rulers and commits nothing until curves exist', () => {
-    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B};120|${CURVE_A}|${OVERLAY}`, null);
-    expect(h.store().chartId).toBe('chart-0');
-    expect(h.store().state).toBe(EMPTY_PERF_RULER_STATE);
-    expect(h.store().pending).toEqual([
-      { id: 1, curveA: CURVE_A, curveB: CURVE_B, isoX: 41.5 },
-      { id: 2, curveA: CURVE_A, curveB: OVERLAY, isoX: 120 },
-    ]);
-    expect(serializePerfRulers(h.store().state)).toBe('');
-    expect(track).not.toHaveBeenCalled();
-  });
-
-  it('starts with no pending rulers when the link carries none or only garbage', () => {
-    expect(mountStore(undefined, null).store().pending).toBeNull();
-    act(() => root.unmount());
-    root = createRoot(container);
-    expect(mountStore('not-a-ruler', null).store().pending).toBeNull();
-  });
-
-  it('commits resolved rulers with fresh ids, keeps the rest pending, and reports the link once', () => {
-    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B};120|${CURVE_A}|${OVERLAY}`, AXIS);
-    // A ruler placed by hand before the link's curves resolved keeps its id.
-    act(() => {
-      h.store().setState((prev) => nextPerfRulerState(prev, { curve: 'x', isoX: 5 }));
-      h.store().setState((prev) => nextPerfRulerState(prev, { curve: 'y', isoX: 5 }));
-    });
-    expect(h.store().state.rulers.map((ruler) => ruler.id)).toEqual([1]);
-
-    const [official, overlay] = h.store().pending!;
-    act(() => h.store().commitPending([{ ...official, isoX: 42 }], [overlay]));
-    expect(h.store().state.rulers).toEqual([
-      { id: 1, curveA: 'x', curveB: 'y', isoX: 5 },
-      { id: 2, curveA: CURVE_A, curveB: CURVE_B, isoX: 42 },
-    ]);
-    expect(h.store().state.nextId).toBe(3);
-    expect(h.store().pending).toEqual([overlay]);
-    // One opened link is one restore: the event carries the number of
-    // rulers the link held, even though the curves resolve in two passes.
-    expect(track).toHaveBeenCalledTimes(1);
-    expect(track).toHaveBeenCalledWith('interactivity_perf_ruler_shared_load', { count: 2 });
-    expect(serializePerfRulers(h.store().state)).toBe(`5|x|y;42|${CURVE_A}|${CURVE_B}`);
-
-    act(() => h.store().commitPending([overlay], null));
-    expect(h.store().pending).toBeNull();
-    expect(h.store().state.rulers.map((ruler) => ruler.curveB)).toEqual(['y', CURVE_B, OVERLAY]);
-    expect(track).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not report a restore when only unmeasurable rulers were dropped', () => {
-    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B}`, AXIS);
-    act(() => h.store().commitPending([], null));
-    expect(h.store().pending).toBeNull();
-    expect(h.store().state).toBe(EMPTY_PERF_RULER_STATE);
-    expect(track).not.toHaveBeenCalled();
-  });
-
-  it('keeps share-link rulers through the first chart definition but resets on an axis change', () => {
-    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B}`, null);
-    // The first data arriving (null → key) is not an axis change.
-    h.rerender(AXIS);
-    expect(h.store().pending).toHaveLength(1);
-    // Loading a new data set (key → null → same key) is not one either.
-    h.rerender(null);
-    h.rerender(AXIS);
-    expect(h.store().pending).toHaveLength(1);
-
-    act(() => h.store().commitPending(h.store().pending!, null));
-    act(() => h.store().setState((prev) => nextPerfRulerState(prev, { curve: 'x', isoX: 5 })));
-    expect(h.store().state.rulers).toHaveLength(1);
-    expect(h.store().state.draft).not.toBeNull();
-
-    // Placed on the old axes: committed rulers, the draft, and anything still
-    // pending are gone once the y metric changes.
-    h.rerender(perfRulerAxisMetricKey('p90_e2el', 'y_tpPerGpu'));
-    expect(h.store().state.rulers).toEqual([]);
-    expect(h.store().state.draft).toBeNull();
-    expect(h.store().state.nextId).toBe(2);
-    expect(h.store().pending).toBeNull();
-    expect(serializePerfRulers(h.store().state)).toBe('');
-  });
-
-  it('discards pending rulers on an axis change even before any commit', () => {
-    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B}`, AXIS);
-    h.rerender(perfRulerAxisMetricKey('p90_ttft', 'y_totalTokensPerDollarTco'));
-    expect(h.store().pending).toBeNull();
-  });
-
-  it('discardPending drops the link rulers without touching committed ones', () => {
-    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B};9|${CURVE_A}|${OVERLAY}`, AXIS);
-    const [official, overlay] = h.store().pending!;
-    act(() => h.store().commitPending([official], [overlay]));
-    const committed = h.store().state;
-    act(() => h.store().discardPending());
-    expect(h.store().pending).toBeNull();
-    expect(h.store().state).toBe(committed);
-  });
-
-  describe('persistedPerfRulerAxisKey (axis identity of the rendered chart)', () => {
-    const Y = 'y_totalTokensPerDollarTco';
-
-    it('is null until a graph exists', () => {
-      expect(persistedPerfRulerAxisKey([], 'interactivity', Y)).toBeNull();
-    });
-
-    it('follows the graph the x mode renders, not graphs[0]', () => {
-      const interactivity = persistedPerfRulerAxisKey(graphs('p90_e2el'), 'interactivity', Y);
-      const e2e = persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', Y);
-      const ttft = persistedPerfRulerAxisKey(graphs('p90_ttft'), 'ttft', Y);
-      expect(new Set([interactivity, e2e, ttft]).size).toBe(3);
-      // A stable mode and data set keep the identity, so rulers survive
-      // reloads, legend toggles, and date changes.
-      expect(persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', Y)).toBe(e2e);
-    });
-
-    it('changes with the percentile and the y metric', () => {
-      const base = persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', Y);
-      expect(persistedPerfRulerAxisKey(graphs('p99_e2el'), 'e2e', Y)).not.toBe(base);
-      expect(persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', 'y_tpPerGpu')).not.toBe(base);
-    });
-
-    it('treats a derived agentic x mode as its own axis even when the e2e field is unchanged', () => {
-      // ChartDisplay overrides the e2e graph's x field for derived modes
-      // locally; the provider's definition still says p90_e2el.
-      expect(
-        persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e-normalized-interactivity', Y),
-      ).not.toBe(persistedPerfRulerAxisKey(graphs('p90_e2el'), 'e2e', Y));
-    });
-
-    it('falls back to the first graph when no graph matches the mode', () => {
-      // Mirrors ChartDisplay's `visibleGraphs` fallback: with only an
-      // interactivity graph, chart-0 renders it in every mode.
-      const only = [graphs('p90_e2el')[0]];
-      const key = persistedPerfRulerAxisKey(only, 'e2e', Y);
-      expect(key).not.toBeNull();
-      expect(persistedPerfRulerAxisKey(only, 'e2e', 'y_tpPerGpu')).not.toBe(key);
-    });
-  });
-
-  it('keeps the store identity stable across unrelated rerenders', () => {
-    const h = mountStore(`41.5|${CURVE_A}|${CURVE_B}`, AXIS);
-    const before = h.store();
-    h.rerender(AXIS);
-    expect(h.store()).toBe(before);
-    expect(h.store().setState).toBe(before.setState);
-  });
-});
diff --git a/packages/app/src/components/inference/ui/line-label-layer.test.ts b/packages/app/src/components/inference/ui/line-label-layer.test.ts
index 0518b4ea5..e3eda7273 100644
--- a/packages/app/src/components/inference/ui/line-label-layer.test.ts
+++ b/packages/app/src/components/inference/ui/line-label-layer.test.ts
@@ -180,115 +180,4 @@ describe('line-label placement', () => {
 
     expect(labels[0]).toMatchObject({ x: 5, y: 7, visible: true });
   });
-
-  /**
-   * Regression for the PowerX roles-mode figure: with two `?unofficialrun=`
-   * overlays the chart draws nine lines whose first points sit in one narrow
-   * band, every anchor slot is taken, and one series lost its pill entirely —
-   * leaving a drawn line the reader could not identify.
-   *
-   * `band` reproduces that shape: same x sweep for everyone, y values packed
-   * inside one collision height.
-   */
-  describe('crowded series', () => {
-    const band = (key: string, y: number) =>
-      series(
-        key,
-        [0, 25, 50, 75, 100].map((x) => ({ x, y })),
-      );
-    const KEYS = ['a', 'b', 'c', 'd', 'e', 'f'];
-    const crowd = () =>
-      placeLineLabels(
-        KEYS.map((key, index) => band(key, 100 + index * 4)),
-        identity,
-        identity,
-        { collisionWidth: 120 },
-      );
-
-    it('keeps a pill for every series when every anchor slot is taken', () => {
-      const labels = crowd();
-
-      expect(labels).toHaveLength(KEYS.length);
-      expect(labels.every((label) => label.visible)).toBe(true);
-      expect(new Set(labels.map((label) => label.key))).toEqual(new Set(KEYS));
-    });
-
-    it("never anchors a crowded label on the line's first point", () => {
-      // x = 0 is points[0], the axis-hugging index lineCandidates excludes.
-      expect(crowd().every((label) => label.x > 0)).toBe(true);
-    });
-
-    it('puts a crowded label on the least crowded of its slots', () => {
-      // Slots 100px apart so a 40px collision reach cannot bleed between them.
-      // Every slot is occupied, so there is no clear choice; slot 200 carries
-      // one obstacle against three on the first slot tried and two on the rest,
-      // so only a scored fallback lands there.
-      const spread = series(
-        'only',
-        [0, 100, 200, 300, 400].map((x) => ({ x, y: 100 })),
-      );
-      const labels = placeLineLabels([spread], identity, identity, {
-        collisionWidth: 40,
-        collisionHeight: 20,
-        obstacles: [
-          { x: 100, y: 100, halfW: 20 },
-          { x: 100, y: 105, halfW: 20 },
-          { x: 100, y: 110, halfW: 20 },
-          { x: 200, y: 100, halfW: 20 },
-          { x: 300, y: 100, halfW: 20 },
-          { x: 300, y: 105, halfW: 20 },
-          { x: 400, y: 100, halfW: 20 },
-          { x: 400, y: 105, halfW: 20 },
-        ],
-      });
-
-      expect(labels[0]).toMatchObject({ x: 200, visible: true });
-    });
-
-    /**
-     * `clean` starts below the whole band, so the y sort puts it LAST. Both
-     * tests below would pass trivially if it sorted first; placing it last is
-     * what makes them discriminate against the obvious wrong fix, which is to
-     * emit a crowded label in sort order the moment its slots run out.
-     */
-    const clean = () =>
-      series('clean', [
-        { x: 0, y: 900 },
-        { x: 100, y: 1000 },
-      ]);
-
-    it('lets a clean label keep its slot when earlier series have no slot at all', () => {
-      const alone = placeLineLabels([clean()], identity, identity, { collisionWidth: 120 });
-      const withCrowd = placeLineLabels(
-        [...KEYS.map((key, index) => band(key, 100 + index * 4)), clean()],
-        identity,
-        identity,
-        { collisionWidth: 120 },
-      );
-
-      // A crowded series must not consume a slot that a later series could
-      // have had to itself, so `clean` lands exactly where it would alone.
-      expect(withCrowd.find((label) => label.key === 'clean')).toMatchObject({
-        x: alone[0].x,
-        y: alone[0].y,
-        visible: true,
-      });
-    });
-
-    it('emits crowded labels after the clean ones regardless of sort order', () => {
-      // updateRenderedLineLabels lays pills out in this order, so the labels
-      // that will have to move are handed to it last.
-      const labels = placeLineLabels(
-        [...KEYS.map((key, index) => band(key, 100 + index * 4)), clean()],
-        identity,
-        identity,
-        { collisionWidth: 120 },
-      );
-
-      const keys = labels.map((label) => label.key);
-      expect(keys[0]).toBe('a');
-      expect(keys[1]).toBe('clean');
-      expect(keys.slice(2)).toEqual(['b', 'c', 'd', 'e', 'f']);
-    });
-  });
 });
diff --git a/packages/app/src/components/inference/ui/line-label-visibility.test.ts b/packages/app/src/components/inference/ui/line-label-visibility.test.ts
index dab9546f6..3b4a075d8 100644
--- a/packages/app/src/components/inference/ui/line-label-visibility.test.ts
+++ b/packages/app/src/components/inference/ui/line-label-visibility.test.ts
@@ -55,24 +55,8 @@ describe('labelOpacityForActiveState', () => {
 
 describe('labelOpacityForActiveState with ?unofficialrun= overlays', () => {
   const official = new Set(['gb200_dynamo-sglang']);
-  const overlay = new Set(['gb200_dynamo-sglang', 'gb300_dynamo-sglang']);
   const precisions = ['fp8'];
 
-  it('keeps an overlay label whose hardware is active only in the overlay legend', () => {
-    expect(
-      labelOpacityForActiveState(
-        {
-          hwKey: 'gb300_dynamo-sglang',
-          lineKey: 'overlay-gb300_dynamo-sglang_fp8_run0',
-          visible: '1',
-        },
-        official,
-        precisions,
-        overlay,
-      ),
-    ).toBe(1);
-  });
-
   it('hides an overlay label when its overlay hardware row is off, even if the official row is on', () => {
     expect(
       labelOpacityForActiveState(
@@ -87,28 +71,6 @@ describe('labelOpacityForActiveState with ?unofficialrun= overlays', () => {
       ),
     ).toBe(0);
   });
-
-  it('leaves official labels on the official set and falls back to it without an overlay set', () => {
-    expect(
-      labelOpacityForActiveState(
-        { hwKey: 'gb300_dynamo-sglang', lineKey: 'gb300_dynamo-sglang_fp8', visible: '1' },
-        official,
-        precisions,
-        overlay,
-      ),
-    ).toBe(0);
-    expect(
-      labelOpacityForActiveState(
-        {
-          hwKey: 'gb300_dynamo-sglang',
-          lineKey: 'overlay-gb300_dynamo-sglang_fp8_run0',
-          visible: '1',
-        },
-        official,
-        precisions,
-      ),
-    ).toBe(0);
-  });
 });
 
 describe('labelOpacityForHover', () => {
diff --git a/packages/app/src/components/inference/utils/point-identity.test.ts b/packages/app/src/components/inference/utils/point-identity.test.ts
index a53326170..26d71f322 100644
--- a/packages/app/src/components/inference/utils/point-identity.test.ts
+++ b/packages/app/src/components/inference/utils/point-identity.test.ts
@@ -2,12 +2,7 @@ import { describe, expect, it } from 'vitest';
 
 import type { InferenceData } from '@/components/inference/types';
 
-import {
-  parseScatterSeriesKey,
-  scatterPointConfigId,
-  scatterPointJoinId,
-  scatterSeriesKey,
-} from './point-identity';
+import { scatterPointConfigId, scatterPointJoinId } from './point-identity';
 
 const point = (overrides: Partial<InferenceData>): InferenceData =>
   ({
@@ -90,26 +85,3 @@ describe('scatterPointConfigId', () => {
     expect(scatterPointJoinId(undated, true)).toBe(scatterPointConfigId(undated));
   });
 });
-
-describe('scatterSeriesKey', () => {
-  it('keeps comparison clones in their own series and parses the key back', () => {
-    const base = point({});
-    const clone = point({ powerVariant: { kind: 'basis', id: 'gpu-provisioned' } });
-    expect(scatterSeriesKey(base)).toBe('h200_vllm_fp8');
-    expect(scatterSeriesKey(clone)).toBe('h200_vllm_fp8-v-gpu-provisioned');
-    expect(parseScatterSeriesKey('h200_vllm_fp8')).toEqual({
-      hw: 'h200_vllm',
-      precision: 'fp8',
-      variant: null,
-    });
-    expect(parseScatterSeriesKey('b200_sglang_mtp_fp4-v-utility-modeled')).toEqual({
-      hw: 'b200_sglang_mtp',
-      precision: 'fp4',
-      variant: 'utility-modeled',
-    });
-    // The variant is point identity too, so a clone never replaces its base in a D3 join.
-    expect(scatterPointConfigId(clone)).toBe(
-      `${scatterPointConfigId(base)}|variant-gpu-provisioned`,
-    );
-  });
-});
diff --git a/packages/app/src/components/inference/utils/power-compare.test.ts b/packages/app/src/components/inference/utils/power-compare.test.ts
deleted file mode 100644
index 72683486a..000000000
--- a/packages/app/src/components/inference/utils/power-compare.test.ts
+++ /dev/null
@@ -1,293 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import type {
-  InferenceData,
-  PowerBasis,
-  PowerRole,
-  PowerVariant,
-} from '@/components/inference/types';
-
-import {
-  expandPowerCompareSeries,
-  flatSeriesValue,
-  formatWatts,
-  inferPowerCompare,
-  lineLabelHardwareKey,
-  lineLabelSeriesId,
-  metricPlotsWatts,
-  parsePowerCompare,
-  powerCompareAvailable,
-  powerCompareBase,
-  powerCompareVariants,
-  powerLineLabelSuffix,
-  powerSeriesLabel,
-  powerVariantDash,
-  powerVariantLabel,
-  powerVariantShortLabel,
-  powerVariantsInData,
-} from './power-compare';
-
-const metric = (y: number) => ({ y, roof: false });
-
-function point(overrides: Partial<InferenceData> = {}): InferenceData {
-  return {
-    x: 50,
-    y: 600,
-    hwKey: 'b200_sglang',
-    precision: 'fp8',
-    tp: 8,
-    conc: 64,
-    disagg: true,
-    measuredAvgPower: metric(600),
-    measuredPrefillAvgPower: metric(400),
-    measuredDecodeAvgPower: metric(700),
-    gpuProvisionedWatts: metric(1000),
-    utilityProvisionedWatts: metric(1710),
-    measuredJPerOutputToken: metric(7.9),
-    measuredDecodeJPerOutputToken: metric(6),
-    reconstructedPrefillJPerOutputToken: metric(1.975),
-    gpuProvisionedJPerOutputToken: metric(12),
-    ...overrides,
-  } as InferenceData;
-}
-
-describe('powerCompareVariants', () => {
-  it('adds the other three boundaries on the whole-deployment average watts and J per output token', () => {
-    expect(powerCompareVariants('y_measuredAvgPower', 'boundaries')).toEqual([
-      { variant: { kind: 'basis', id: 'gpu-provisioned' }, field: 'gpuProvisionedWatts' },
-      { variant: { kind: 'basis', id: 'utility-provisioned' }, field: 'utilityProvisionedWatts' },
-      { variant: { kind: 'basis', id: 'utility-modeled' }, field: 'utilityModeledWatts' },
-    ]);
-    // Selecting a derived boundary makes GPU measured one of the siblings.
-    expect(
-      powerCompareVariants('y_utilityProvisionedJPerOutputToken', 'boundaries').map(
-        (series) => series.field,
-      ),
-    ).toEqual([
-      'measuredJPerOutputToken',
-      'gpuProvisionedJPerOutputToken',
-      'utilityModeledJPerOutputToken',
-    ]);
-    expect(powerCompareBase('y_gpuProvisionedWatts', 'boundaries')).toEqual({
-      kind: 'basis',
-      id: 'gpu-provisioned',
-    });
-  });
-
-  it('adds the other worker roles, carrying prefill energy onto the output-token axis', () => {
-    expect(powerCompareVariants('y_measuredAvgPower', 'roles')).toEqual([
-      { variant: { kind: 'role', id: 'prefill' }, field: 'measuredPrefillAvgPower' },
-      { variant: { kind: 'role', id: 'decode' }, field: 'measuredDecodeAvgPower' },
-    ]);
-    expect(powerCompareVariants('y_measuredDecodeAvgPower', 'roles')).toEqual([
-      { variant: { kind: 'role', id: 'all' }, field: 'measuredAvgPower' },
-      { variant: { kind: 'role', id: 'prefill' }, field: 'measuredPrefillAvgPower' },
-    ]);
-    expect(powerCompareVariants('y_measuredJPerOutputToken', 'roles')).toEqual([
-      { variant: { kind: 'role', id: 'prefill' }, field: 'reconstructedPrefillJPerOutputToken' },
-      { variant: { kind: 'role', id: 'decode' }, field: 'measuredDecodeJPerOutputToken' },
-    ]);
-    expect(powerCompareBase('y_measuredDecodeJPerOutputToken', 'roles')).toEqual({
-      kind: 'role',
-      id: 'decode',
-    });
-  });
-
-  it('offers nothing where the metric has no common axis for the siblings', () => {
-    for (const [key, mode] of [
-      ['y_measuredP90Power', 'boundaries'],
-      ['y_measuredPowerPercentTdp', 'boundaries'],
-      ['y_measuredPowerTimeline', 'roles'],
-      ['y_measuredJPerInputToken', 'boundaries'],
-      ['y_measuredPrefillJPerInputToken', 'roles'],
-      ['y_measuredJPerSuccessfulQuery', 'roles'],
-      ['y_gpuProvisionedWatts', 'roles'],
-      ['y_tpPerGpu', 'boundaries'],
-    ] as const) {
-      expect(powerCompareVariants(key, mode)).toEqual([]);
-      expect(powerCompareBase(key, mode)).toBeNull();
-      expect(powerCompareAvailable(key, mode)).toBe(false);
-    }
-    expect(powerCompareAvailable('y_measuredP90Power', 'none')).toBe(true);
-    expect(powerCompareVariants('y_measuredAvgPower', 'none')).toEqual([]);
-  });
-});
-
-describe('expandPowerCompareSeries', () => {
-  it('clones each base point once per sibling that has a value and leaves the base untouched', () => {
-    const base = point();
-    const expanded = expandPowerCompareSeries([base], 'y_measuredAvgPower', 'boundaries');
-    expect(expanded[0]).toBe(base);
-    expect(expanded.slice(1).map((p) => [p.powerVariant?.id, p.y])).toEqual([
-      ['gpu-provisioned', 1000],
-      ['utility-provisioned', 1710],
-    ]);
-    // No modeled watts on this point → no utility-modeled clone, never a 0.
-    expect(expanded.some((p) => p.powerVariant?.id === 'utility-modeled')).toBe(false);
-    expect(expanded.slice(1).every((p) => p.hwKey === 'b200_sglang' && p.x === 50)).toBe(true);
-  });
-
-  it('stacks the reconstructed prefill energy against the decode pool on the energy axis', () => {
-    const expanded = expandPowerCompareSeries(
-      [point({ y: 7.9 })],
-      'y_measuredJPerOutputToken',
-      'roles',
-    );
-    expect(expanded.map((p) => [p.powerVariant?.id ?? 'base', p.y])).toEqual([
-      ['base', 7.9],
-      ['prefill', 1.975],
-      ['decode', 6],
-    ]);
-    expect(inferPowerCompare(expanded)).toBe('roles');
-    expect(powerVariantsInData(expanded, 'y_measuredJPerOutputToken')).toEqual([
-      { kind: 'role', id: 'all' },
-      { kind: 'role', id: 'prefill' },
-      { kind: 'role', id: 'decode' },
-    ]);
-  });
-
-  it('returns the points unchanged when the mode is off or inapplicable', () => {
-    const base = point();
-    expect(expandPowerCompareSeries([base], 'y_measuredAvgPower', 'none')).toEqual([base]);
-    expect(expandPowerCompareSeries([base], 'y_measuredP90Power', 'boundaries')).toEqual([base]);
-    expect(inferPowerCompare([base])).toBe('none');
-    expect(powerVariantsInData([base], 'y_measuredAvgPower')).toEqual([]);
-  });
-});
-
-describe('labels, dashes and URL values', () => {
-  it('parses only the two comparison modes from the URL', () => {
-    expect(parsePowerCompare('boundaries')).toBe('boundaries');
-    expect(parsePowerCompare('roles')).toBe('roles');
-    for (const value of ['', 'none', 'basis', null, undefined]) {
-      expect(parsePowerCompare(value)).toBe('none');
-    }
-  });
-
-  it('names series in both locales and keeps the base series solid', () => {
-    expect(powerVariantLabel({ kind: 'basis', id: 'gpu-provisioned' }, 'en')).toBe(
-      'GPU provisioned (TDP)',
-    );
-    expect(powerVariantLabel({ kind: 'role', id: 'prefill' }, 'zh')).toBe('预填充 GPU');
-    expect(powerVariantDash(undefined)).toBe('');
-    expect(powerVariantDash({ kind: 'role', id: 'all' })).toBe('');
-    expect(powerVariantDash({ kind: 'basis', id: 'gpu-provisioned' })).not.toBe('');
-    expect(powerVariantDash({ kind: 'role', id: 'decode' })).not.toBe(
-      powerVariantDash({ kind: 'role', id: 'prefill' }),
-    );
-  });
-
-  it('labels a base row by the selected metric and a clone by its variant', () => {
-    expect(powerSeriesLabel({}, 'y_measuredAvgPower', 'boundaries', 'en')).toBe('GPU measured');
-    expect(
-      powerSeriesLabel(
-        { powerVariant: { kind: 'basis', id: 'utility-modeled' } },
-        'y_measuredAvgPower',
-        'boundaries',
-        'zh',
-      ),
-    ).toBe('数据中心建模（含 PUE）');
-    expect(powerSeriesLabel({}, 'y_measuredAvgPower', 'none', 'en')).toBe('');
-  });
-});
-
-const basis = (id: PowerBasis): PowerVariant => ({ kind: 'basis', id });
-const role = (id: PowerRole): PowerVariant => ({ kind: 'role', id });
-
-describe('line labels', () => {
-  it('names every variant briefly in both locales', () => {
-    const cases: [PowerVariant, string, string][] = [
-      [basis('gpu-measured'), 'Measured', '实测'],
-      [basis('gpu-provisioned'), 'TDP', 'TDP'],
-      [basis('utility-provisioned'), 'All-in', '全站'],
-      [basis('utility-modeled'), 'PUE modeled', 'PUE 建模'],
-      [role('all'), 'All GPUs', '全部 GPU'],
-      [role('prefill'), 'Prefill GPUs', '预填充 GPU'],
-      [role('decode'), 'Decode GPUs', '解码 GPU'],
-    ];
-    for (const [variant, en, zh] of cases) {
-      expect(powerVariantShortLabel(variant, 'en')).toBe(en);
-      expect(powerVariantShortLabel(variant, 'zh')).toBe(zh);
-    }
-  });
-
-  it('formats watts as integer W below 1 kW and trimmed two-decimal kW above', () => {
-    expect(formatWatts(700)).toBe('700 W');
-    expect(formatWatts(999.6)).toBe('1000 W');
-    expect(formatWatts(1000)).toBe('1 kW');
-    expect(formatWatts(1200)).toBe('1.2 kW');
-    expect(formatWatts(1370)).toBe('1.37 kW');
-    expect(formatWatts(1400)).toBe('1.4 kW');
-    expect(formatWatts(1714.5)).toBe('1.71 kW');
-    expect(formatWatts(19200)).toBe('19.2 kW');
-    expect(formatWatts(100000)).toBe('100 kW');
-  });
-
-  it('omits the base suffix and labels a sibling with its variant and flat watts', () => {
-    const tdp = basis('gpu-provisioned');
-    expect(powerLineLabelSuffix(undefined, { isBase: true, locale: 'en' })).toBe('');
-    expect(powerLineLabelSuffix(null, { isBase: false, locale: 'en' })).toBe('');
-    // A variant that is itself the base series keeps the plain label.
-    expect(powerLineLabelSuffix(tdp, { isBase: true, locale: 'en', flatWatts: 1200 })).toBe('');
-    expect(powerLineLabelSuffix(tdp, { isBase: false, locale: 'en' })).toBe(' · TDP');
-    expect(powerLineLabelSuffix(tdp, { isBase: false, locale: 'en', flatWatts: 700 })).toBe(
-      ' · TDP 700 W',
-    );
-    expect(powerLineLabelSuffix(tdp, { isBase: false, locale: 'en', flatWatts: 1370 })).toBe(
-      ' · TDP 1.37 kW',
-    );
-    expect(
-      powerLineLabelSuffix(basis('utility-provisioned'), {
-        isBase: false,
-        locale: 'zh',
-        flatWatts: 19200,
-      }),
-    ).toBe(' · 全站 19.2 kW');
-    // Non-finite or null watts drop the value, never print NaN.
-    expect(powerLineLabelSuffix(tdp, { isBase: false, locale: 'en', flatWatts: null })).toBe(
-      ' · TDP',
-    );
-    expect(powerLineLabelSuffix(tdp, { isBase: false, locale: 'en', flatWatts: NaN })).toBe(
-      ' · TDP',
-    );
-    expect(powerLineLabelSuffix(role('decode'), { isBase: false, locale: 'en' })).toBe(
-      ' · Decode GPUs',
-    );
-    // The suffix alone is what the renderer splits into its own text segment.
-    expect(powerLineLabelSuffix(role('prefill'), { isBase: false, locale: 'zh' })).toBe(
-      ' · 预填充 GPU',
-    );
-    expect(powerLineLabelSuffix(role('prefill'), { isBase: true, locale: 'zh' })).toBe('');
-  });
-
-  it('detects a flat series within the relative tolerance', () => {
-    expect(flatSeriesValue([1200, 1200, 1200])).toBe(1200);
-    expect(flatSeriesValue([1000, 1004, 996])).toBe(1000);
-    expect(flatSeriesValue([1000, 1005])).toBe(1000);
-    expect(flatSeriesValue([1000, 1005.01])).toBeNull();
-    expect(flatSeriesValue([1000, 1005.01], 0.01)).toBe(1000);
-    expect(flatSeriesValue([600, 640, 710])).toBeNull();
-    expect(flatSeriesValue([])).toBeNull();
-    expect(flatSeriesValue([NaN, Infinity])).toBeNull();
-    expect(flatSeriesValue([NaN, 1200, 1200])).toBe(1200);
-    expect(flatSeriesValue([1200])).toBe(1200);
-  });
-
-  it('keeps the hardware key as the base series id and recovers it from a sibling id', () => {
-    const tdp = basis('gpu-provisioned');
-    expect(lineLabelSeriesId('b200_sglang', undefined, true)).toBe('b200_sglang');
-    expect(lineLabelSeriesId('b200_sglang', tdp, true)).toBe('b200_sglang');
-    expect(lineLabelSeriesId('b200_sglang', tdp, false)).toBe('b200_sglang::gpu-provisioned');
-    expect(lineLabelHardwareKey('b200_sglang::gpu-provisioned')).toBe('b200_sglang');
-    expect(lineLabelHardwareKey('b200_sglang')).toBe('b200_sglang');
-  });
-
-  it('only lets a watts axis state a flat boundary value', () => {
-    expect(metricPlotsWatts('y_measuredAvgPower')).toBe(true);
-    expect(metricPlotsWatts('y_gpuProvisionedWatts')).toBe(true);
-    expect(metricPlotsWatts('y_measuredDecodeAvgPower')).toBe(true);
-    expect(metricPlotsWatts('y_measuredPowerPercentTdp')).toBe(false);
-    expect(metricPlotsWatts('y_measuredJPerOutputToken')).toBe(false);
-    expect(metricPlotsWatts('y_tpPerGpu')).toBe(false);
-  });
-});
diff --git a/packages/app/src/components/inference/utils/powerCurves.test.ts b/packages/app/src/components/inference/utils/powerCurves.test.ts
index 21356f6b5..dc0125649 100644
--- a/packages/app/src/components/inference/utils/powerCurves.test.ts
+++ b/packages/app/src/components/inference/utils/powerCurves.test.ts
@@ -4,13 +4,7 @@ import type { InferenceData } from '@/components/inference/types';
 import { chartDefinitions } from '@/components/inference/metric-registry';
 import type { ParetoDirection } from '@/lib/chart-utils';
 
-import {
-  chartFrontier,
-  isMeasuredPowerCurveMetric,
-  isPowerCurveMetric,
-  isPowerGaugeSeries,
-  upperPowerEnvelope,
-} from './powerCurves';
+import { chartFrontier, isPowerCurveMetric, upperPowerEnvelope } from './powerCurves';
 
 function point(conc: number, x: number, y: number, overrides: Partial<InferenceData> = {}) {
   return {
@@ -76,23 +70,6 @@ describe('power chart semantics', () => {
     expect(chartFrontier(points, 'lower_right')).toEqual(points);
   });
 
-  it.each(['y_gpuProvisionedWatts', 'y_utilityProvisionedWatts', 'y_utilityModeledWatts'])(
-    'draws %s as an envelope-locked power gauge like measured watts',
-    (metric) => {
-      expect(isPowerCurveMetric(metric)).toBe(true);
-      expect(isMeasuredPowerCurveMetric(metric)).toBe(true);
-    },
-  );
-
-  it.each([
-    'y_gpuProvisionedJPerOutputToken',
-    'y_utilityProvisionedJPerOutputToken',
-    'y_utilityModeledJPerOutputToken',
-  ])('keeps %s on the energy Pareto frontier', (metric) => {
-    expect(isPowerCurveMetric(metric)).toBe(false);
-    expect(isMeasuredPowerCurveMetric(metric)).toBe(false);
-  });
-
   it('preserves the canonical agentic restriction on Pareto membership', () => {
     const canonical = point(8, 100, 1, { isOnNormalizedInteractivityFrontier: true });
     const nonCanonical = point(1, 200, 4, { isOnNormalizedInteractivityFrontier: false });
@@ -134,37 +111,6 @@ describe('upper power envelope', () => {
     expect(upperPowerEnvelope(samples, false, true)).toEqual([fast, middle, plateau, slow]);
   });
 
-  it('keeps a flat provisioned series across its tested range only when asked to', () => {
-    // A TDP gauge is the same watts at every concurrency: with `keepTies` the
-    // boundary spans the sweep; the strict measured rule would collapse it to
-    // the first-sorted marker.
-    const flat = [point(1, 200, 1000), point(8, 120, 1000), point(64, 40, 1000)];
-    expect(upperPowerEnvelope(flat, true, true)).toEqual(flat.toReversed());
-    expect(upperPowerEnvelope(flat, false, true).map((p) => p.x)).toEqual([40, 120, 200]);
-    expect(upperPowerEnvelope(flat, true)).toEqual([flat[0]]);
-    expect(upperPowerEnvelope(flat, false)).toEqual([flat[2]]);
-  });
-
-  it('keeps ties only for provisioned and modelled gauge series', () => {
-    const measured = point(1, 200, 700);
-    const tdpClone = {
-      ...measured,
-      powerVariant: { kind: 'basis', id: 'gpu-provisioned' } as const,
-    };
-    const measuredClone = {
-      ...measured,
-      powerVariant: { kind: 'basis', id: 'gpu-measured' } as const,
-    };
-    const roleClone = { ...measured, powerVariant: { kind: 'role', id: 'decode' } as const };
-    expect(isPowerGaugeSeries('y_gpuProvisionedWatts', measured)).toBe(true);
-    expect(isPowerGaugeSeries('y_utilityModeledWatts', undefined)).toBe(true);
-    expect(isPowerGaugeSeries('y_measuredAvgPower', measured)).toBe(false);
-    expect(isPowerGaugeSeries('y_measuredAvgPower', tdpClone)).toBe(true);
-    expect(isPowerGaugeSeries('y_measuredAvgPower', measuredClone)).toBe(false);
-    expect(isPowerGaugeSeries('y_measuredAvgPower', roleClone)).toBe(false);
-    expect(isPowerGaugeSeries('y_gpuProvisionedWatts', roleClone)).toBe(false);
-  });
-
   it('uses only finite positive coordinates and preserves singleton boundaries', () => {
     const valid = point(1, 200, 350);
     expect(upperPowerEnvelope([], true)).toEqual([]);
diff --git a/packages/app/src/components/inference/utils/powerTimeline.test.ts b/packages/app/src/components/inference/utils/powerTimeline.test.ts
index def7e63cc..409a74ad1 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.test.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.test.ts
@@ -1,315 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import type { GpuPowerSeriesResponse } from '@/components/gpu-power/power-series';
-import type { InferenceData } from '@/components/inference/types';
-
-import {
-  allGpuPool,
-  consumePowerTraceFocus,
-  joinPowerTimeline,
-  longestCommonPrefix,
-  groupPoolsBySize,
-  planPowerTimelineRequests,
-  prioritizeRun,
-  prioritizeRuns,
-  referenceLabelSlots,
-  requestPowerTraceFocus,
-  runIdFromUrl,
-  telemetryArtifactForPoint,
-  traceConfigLabel,
-  traceKeyForPoint,
-  traceKeyRunId,
-  tracePools,
-  windowPhase,
-} from './powerTimeline';
-
-const RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34716669498';
-const NAME_A =
-  'qwen3.5_8k1k_fp8_sglang_tp4-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc16_b200-nscale-sl-1c68b810a44c3c71a187';
-const NAME_B =
-  'qwen3.5_8k1k_fp8_dynamo-sglang_prefill-tp4-pp1-dcp1-pcp1-ep1-dpfalse-nw1_decode-tp4-5b35252b29d80b104d11_sa-bench_isl_8192_osl_1024_conc1_gpus_8_ctx_4_gen_4';
-
-function point(overrides: Partial<InferenceData>): InferenceData {
-  return {
-    x: 1,
-    y: 1,
-    hwKey: 'b200_sglang',
-    tp: 4,
-    conc: 16,
-    precision: 'fp8',
-    date: '2026-09-12',
-    run_url: RUN_URL,
-    ...overrides,
-  } as InferenceData;
-}
-
-const runInfo: GpuPowerSeriesResponse['runInfo'] = {
-  id: 34716669498,
-  name: 'Run Sweep',
-  branch: 'main',
-  sha: 'abc',
-  createdAt: '2026-09-12T20:00:00Z',
-  url: RUN_URL,
-  conclusion: 'success',
-  status: 'completed',
-};
-
-describe('telemetryArtifactForPoint', () => {
-  it('maps the power-audit source to the gpu_metrics artifact of the same RESULT_FILENAME', () => {
-    expect(
-      telemetryArtifactForPoint({ power_audit: { source: `power_validation_${NAME_A}.json` } }),
-    ).toBe(`gpu_metrics_${NAME_A}`);
-    // A bundled path still resolves to the bare artifact name.
-    expect(
-      telemetryArtifactForPoint({
-        power_audit: { source: `artifacts/power_validation_${NAME_B}.json` },
-      }),
-    ).toBe(`gpu_metrics_${NAME_B}`);
-  });
-
-  it('returns null without an audit source or with a foreign file name', () => {
-    expect(telemetryArtifactForPoint({})).toBeNull();
-    expect(telemetryArtifactForPoint({ power_audit: {} })).toBeNull();
-    expect(telemetryArtifactForPoint({ power_audit: { source: 'agg_results.json' } })).toBeNull();
-  });
-});
-
-describe('planPowerTimelineRequests', () => {
-  it('groups artifacts per workflow run under their common RESULT_FILENAME prefix', () => {
-    const points = [
-      point({ power_audit: { source: `power_validation_${NAME_A}.json` } }),
-      point({ conc: 1, power_audit: { source: `power_validation_${NAME_B}.json` } }),
-      point({ power_audit: { source: `nested/power_validation_${NAME_A}.json` } }),
-      point({
-        run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/1',
-        power_audit: { source: 'power_validation_dsr1_1k1k_fp8_sglang_conc8_h200-x.json' },
-      }),
-      // No run URL: nothing to fetch.
-      point({ run_url: undefined, power_audit: { source: `power_validation_${NAME_A}.json` } }),
-      // No telemetry audit: nothing to fetch.
-      point({ conc: 2 }),
-    ];
-    expect(planPowerTimelineRequests(points)).toEqual([
-      {
-        runId: '1',
-        prefix: 'dsr1_1k1k_fp8_sglang_conc8_h200-x',
-        sources: ['power_validation_dsr1_1k1k_fp8_sglang_conc8_h200-x.json'],
-      },
-      {
-        runId: '34716669498',
-        prefix: 'qwen3.5_8k1k_fp8_',
-        sources: [`power_validation_${NAME_A}.json`, `power_validation_${NAME_B}.json`].sort(),
-      },
-    ]);
-  });
-
-  it('exposes the helpers it is built from', () => {
-    expect(runIdFromUrl(RUN_URL)).toBe('34716669498');
-    expect(runIdFromUrl('https://example.com')).toBeNull();
-    expect(runIdFromUrl(undefined)).toBeNull();
-    expect(longestCommonPrefix(['abc_1', 'abc_2', 'abd'])).toBe('ab');
-    expect(longestCommonPrefix([])).toBe('');
-    expect(longestCommonPrefix(['solo'])).toBe('solo');
-  });
-});
-
-describe('joinPowerTimeline', () => {
-  const response: GpuPowerSeriesResponse = {
-    runInfo,
-    series: [
-      {
-        artifact: `gpu_metrics_${NAME_A}`,
-        startMs: Date.UTC(2026, 8, 12, 20, 19, 57),
-        bucketSeconds: 1,
-        gpus: [0, 1],
-        t: [0, 1, 2],
-        power: [
-          [190, 700, 710],
-          [188, 690, null],
-        ],
-      },
-    ],
-  };
-
-  it('attaches the fetched series and the audit window, and reports the rest as missing', () => {
-    const matched = point({
-      power_audit: {
-        source: `power_validation_${NAME_A}.json`,
-        window_start_unix: 1789244883.149,
-        window_end_unix: 1789244982.413,
-      },
-    });
-    const unmatched = point({
-      conc: 1,
-      disagg: true,
-      power_audit: { source: `power_validation_${NAME_B}.json` },
-    });
-    const noAudit = point({ conc: 2 });
-    const { traces, missing } = joinPowerTimeline(
-      [matched, unmatched, noAudit],
-      new Map([['34716669498', response]]),
-    );
-    expect(traces).toHaveLength(1);
-    expect(traces[0].key).toBe(`34716669498:${NAME_A}`);
-    expect(traces[0].series).toBe(response.series[0]);
-    expect(traces[0].windowStartMs).toBeCloseTo(1789244883149, 0);
-    expect(traces[0].windowEndMs).toBeCloseTo(1789244982413, 0);
-    expect(missing).toEqual([
-      { point: unmatched, reason: 'not-in-run' },
-      { point: noAudit, reason: 'no-source' },
-    ]);
-    // A run that was never loaded is reported as such, not as a missing artifact.
-    expect(joinPowerTimeline([matched], new Map()).missing).toEqual([
-      { point: matched, reason: 'run-not-fetched' },
-    ]);
-    expect(
-      joinPowerTimeline(
-        [point({ run_url: undefined, power_audit: matched.power_audit })],
-        new Map(),
-      ).missing[0].reason,
-    ).toBe('no-run');
-
-    expect(windowPhase(traces[0], 1789244883149 - 1)).toBe('before');
-    expect(windowPhase(traces[0], 1789244883149)).toBe('window');
-    expect(windowPhase(traces[0], 1789244982413 + 1)).toBe('after');
-    expect(traceConfigLabel(matched)).toBe('TP4 · c16');
-    expect(traceConfigLabel(unmatched)).toBe('PD · TP4 · c1');
-  });
-
-  it('treats a trace without a recorded window as unknown rather than emphasised', () => {
-    const noWindow = point({ power_audit: { source: `power_validation_${NAME_A}.json` } });
-    const { traces } = joinPowerTimeline([noWindow], new Map([['34716669498', response]]));
-    expect(traces[0].windowStartMs).toBeNull();
-    expect(windowPhase(traces[0], response.series[0].startMs)).toBe('unknown');
-  });
-});
-
-describe('trace identity helpers', () => {
-  it('names the run-scoped trace key of a point', () => {
-    const audited = point({ power_audit: { source: `power_validation_${NAME_A}.json` } });
-    expect(traceKeyForPoint(audited)).toBe(`34716669498:${NAME_A}`);
-  });
-
-  it('has no key without a run or an audit source', () => {
-    expect(traceKeyForPoint(point({ run_url: undefined, power_audit: { source: 'x.json' } }))).toBe(
-      null,
-    );
-    expect(traceKeyForPoint(point({ power_audit: { source: 'agg_results.json' } }))).toBeNull();
-  });
-});
-
-describe('joinPowerTimeline with bundle-cut series', () => {
-  const bundleSource = `power_validation_${NAME_B}.json`;
-  const artifactSeries: GpuPowerSeriesResponse['series'][number] = {
-    artifact: `gpu_metrics_${NAME_B}`,
-    startMs: 1,
-    bucketSeconds: 1,
-    gpus: [0],
-    t: [0],
-    power: [[1]],
-  };
-  const bundleSeries: GpuPowerSeriesResponse['series'][number] = {
-    artifact: 'power_audit_qwen3.5_8k1k_fp8_dynamo-sglang_prefill-tp4-5b35252b29d80b104d11',
-    source: bundleSource,
-    startMs: 2,
-    bucketSeconds: 1,
-    gpus: [0, 1],
-    t: [0],
-    power: [[2], [3]],
-    devices: [
-      { id: 'watchtower-navy-cn01/GPU-aaa', role: 'prefill' },
-      { id: 'watchtower-navy-cn01/GPU-bbb', role: 'decode' },
-    ],
-  };
-  const disagg = point({ conc: 1, disagg: true, power_audit: { source: bundleSource } });
-
-  it.each(['', 'nested/'])(
-    'matches a series by its validation-file source with prefix %s',
-    (prefix) => {
-      const { traces, missing } = joinPowerTimeline(
-        [{ ...disagg, power_audit: { source: `${prefix}${bundleSource}` } }],
-        new Map([['34716669498', { runInfo, series: [bundleSeries] }]]),
-      );
-      expect(missing).toEqual([]);
-      expect(traces[0].series).toBe(bundleSeries);
-      expect(traces[0].key).toBe(`34716669498:${NAME_B}`);
-    },
-  );
-
-  it('prefers the source match over a gpu_metrics artifact of the same name', () => {
-    const { traces } = joinPowerTimeline(
-      [disagg],
-      new Map([['34716669498', { runInfo, series: [artifactSeries, bundleSeries] }]]),
-    );
-    expect(traces[0].series).toBe(bundleSeries);
-  });
-
-  it('never joins a source-labelled series through its bundle artifact name', () => {
-    const foreign = { ...bundleSeries, source: 'power_validation_other_conc4.json' };
-    const { traces, missing } = joinPowerTimeline(
-      [disagg],
-      new Map([['34716669498', { runInfo, series: [foreign] }]]),
-    );
-    expect(traces).toEqual([]);
-    expect(missing).toEqual([{ point: disagg, reason: 'not-in-run' }]);
-  });
-});
-
-describe('worker-role pools', () => {
-  it('groups rows by role in prefill, decode order regardless of device order', () => {
-    const pools = tracePools({
-      power: [[1], [2], [3], [4], [5]],
-      devices: [
-        { id: 'h/GPU-0', role: 'decode' },
-        { id: 'h/GPU-1', role: 'prefill' },
-        { id: 'h/GPU-2', role: 'decode' },
-        // An unassigned device belongs to no pool.
-        { id: 'h/GPU-3' },
-        { id: 'h/GPU-4', role: 'prefill' },
-      ],
-    });
-    expect(pools).toEqual([
-      { role: 'prefill', rows: [1, 4] },
-      { role: 'decode', rows: [0, 2] },
-    ]);
-  });
-
-  it('yields only the roles present and nothing without roles', () => {
-    expect(
-      tracePools({
-        power: [[1], [2]],
-        devices: [
-          { id: 'a', role: 'decode' },
-          { id: 'b', role: 'decode' },
-        ],
-      }),
-    ).toEqual([{ role: 'decode', rows: [0, 1] }]);
-    expect(tracePools({ power: [[1], [2]], devices: [{ id: '0' }, { id: '1' }] })).toEqual([]);
-    expect(tracePools({ power: [[1], [2]] })).toEqual([]);
-    expect(tracePools({ power: [] })).toEqual([]);
-  });
-
-  it('folds every row into the all-GPU pool', () => {
-    expect(allGpuPool({ power: [[1], [2], [3]] })).toEqual({ role: 'all', rows: [0, 1, 2] });
-    expect(allGpuPool({ power: [] })).toEqual({ role: 'all', rows: [] });
-  });
-});
-
-describe('power trace focus handoff', () => {
-  it('hands the requested key to exactly one consumer', () => {
-    expect(consumePowerTraceFocus()).toBeNull();
-    requestPowerTraceFocus('34716669498:conc16');
-    expect(consumePowerTraceFocus()).toBe('34716669498:conc16');
-    expect(consumePowerTraceFocus()).toBeNull();
-  });
-
-  it('keeps only the latest request', () => {
-    requestPowerTraceFocus('first');
-    requestPowerTraceFocus('second');
-    expect(consumePowerTraceFocus()).toBe('second');
-    expect(consumePowerTraceFocus()).toBeNull();
-  });
-});
+import { prioritizeRuns } from './powerTimeline';
 
 describe('prioritizeRuns', () => {
   const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
@@ -327,90 +18,4 @@ describe('prioritizeRuns', () => {
       '4',
     ]);
   });
-
-  it('lets the deep-linked run lead the overlay runs', () => {
-    const ordered = prioritizeRun(prioritizeRuns(requests, new Set(['4', '5'])), '2');
-    expect(ordered.map((request) => request.runId)).toEqual(['2', '4', '5', '1', '3']);
-  });
-
-  it('returns the same array when nothing moves', () => {
-    expect(prioritizeRuns(requests, new Set())).toBe(requests);
-    expect(prioritizeRuns(requests, new Set(['9']))).toBe(requests);
-    expect(prioritizeRuns(requests, new Set(['1', '2']))).toBe(requests);
-    expect(prioritizeRuns(requests, new Set(['1', '2', '3', '4', '5']))).toBe(requests);
-  });
-});
-
-describe('prioritizeRun', () => {
-  const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
-    runId,
-    prefix: '',
-    sources: [],
-  }));
-
-  it('moves the deep-linked run to the front and keeps the rest in order', () => {
-    expect(prioritizeRun(requests, '5').map((request) => request.runId)).toEqual([
-      '5',
-      '1',
-      '2',
-      '3',
-      '4',
-    ]);
-    expect(prioritizeRun(requests, '3').map((request) => request.runId)).toEqual([
-      '3',
-      '1',
-      '2',
-      '4',
-      '5',
-    ]);
-  });
-
-  it('returns the same array when the run is first, unknown or absent', () => {
-    expect(prioritizeRun(requests, '1')).toBe(requests);
-    expect(prioritizeRun(requests, '9')).toBe(requests);
-    expect(prioritizeRun(requests, null)).toBe(requests);
-    expect(traceKeyRunId('34716669498:qwen_conc8')).toBe('34716669498');
-    expect(traceKeyRunId(null)).toBeNull();
-    expect(traceKeyRunId('')).toBeNull();
-  });
-});
-
-describe('groupPoolsBySize', () => {
-  it('merges pools of one hardware that share a GPU count and keeps pool order', () => {
-    expect(
-      groupPoolsBySize([
-        { role: 'decode', rows: [4, 5, 6, 7] },
-        { role: 'prefill', rows: [0, 1, 2, 3] },
-      ]),
-    ).toEqual([{ size: 4, roles: ['prefill', 'decode'] }]);
-  });
-
-  it('keeps pools of different sizes apart, smallest first, without duplicates', () => {
-    expect(
-      groupPoolsBySize([
-        { role: 'prefill', rows: [0, 1, 2, 3, 4, 5] },
-        { role: 'decode', rows: [6, 7] },
-        { role: 'prefill', rows: [8, 9, 10, 11, 12, 13] },
-        { role: 'all', rows: [0, 1] },
-      ]),
-    ).toEqual([
-      { size: 2, roles: ['all', 'decode'] },
-      { size: 6, roles: ['prefill'] },
-    ]);
-    expect(groupPoolsBySize([])).toEqual([]);
-  });
-});
-
-describe('referenceLabelSlots', () => {
-  it('stacks labels of lines that share a watts value and leaves others on the line', () => {
-    expect(
-      referenceLabelSlots([
-        { watts: 19200 },
-        { watts: 22400 },
-        { watts: 19200 },
-        { watts: 8000 },
-        { watts: 19200 },
-      ]),
-    ).toEqual([0, 0, 1, 0, 2]);
-  });
 });
diff --git a/packages/app/src/components/inference/utils/role-energy.test.ts b/packages/app/src/components/inference/utils/role-energy.test.ts
index 43f0ed13c..102703cc0 100644
--- a/packages/app/src/components/inference/utils/role-energy.test.ts
+++ b/packages/app/src/components/inference/utils/role-energy.test.ts
@@ -23,19 +23,4 @@ describe('reconstructedRoleEnergy', () => {
       prefillShare: (100 * 1.975) / 7.975,
     });
   });
-
-  it('returns nothing unless the row is validated schema-2 disaggregated telemetry with every role figure', () => {
-    for (const overrides of [
-      { disagg: false },
-      { power_valid: 0 },
-      { power_valid: undefined },
-      { power_metric_schema_version: 1 },
-      { joules_per_input_token: 0 },
-      { joules_per_output_token: Number.NaN },
-      { prefill_joules_per_input_token: undefined },
-      { decode_joules_per_output_token: -1 },
-    ]) {
-      expect(reconstructedRoleEnergy({ ...entry, ...overrides })).toBeUndefined();
-    }
-  });
 });
diff --git a/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts b/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
index 93c2af577..45157d317 100644
--- a/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
+++ b/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
@@ -2,10 +2,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import type { HardwareConfig, InferenceData, OverlayData } from '@/components/inference/types';
 import {
-  generateGPUGraphTooltipContent,
   generateOverlayTooltipContent,
-  generateTooltipContent,
-  showsPowerTraceAction,
   type OverlayTooltipConfig,
   type TooltipConfig,
 } from '@/components/inference/utils/tooltipUtils';
@@ -17,7 +14,6 @@ const RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34716
 const AUDIT_NAME =
   'dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc64_b200-host-0123';
 const ACTION = 'data-action="view-power-trace"';
-const TELEMETRY_ACTION = 'data-action="view-power-telemetry"';
 
 const hardwareConfig = {
   b200: {
@@ -80,66 +76,11 @@ function overlayConfig(overrides: Partial<OverlayTooltipConfig> = {}): OverlayTo
   };
 }
 
-describe('showsPowerTraceAction', () => {
-  it('needs a measured metric other than the timeline and a resolvable trace key', () => {
-    const point = measuredPoint();
-    expect(showsPowerTraceAction(point, 'y_measuredAvgPower')).toBe(true);
-    expect(showsPowerTraceAction(point, 'y_measuredJPerOutputToken')).toBe(true);
-    expect(showsPowerTraceAction(point, 'y_measuredPowerTimeline')).toBe(false);
-    expect(showsPowerTraceAction(point, 'y_tpPerGpu')).toBe(false);
-    expect(
-      showsPowerTraceAction(measuredPoint({ power_audit: undefined }), 'y_measuredAvgPower'),
-    ).toBe(false);
-    expect(showsPowerTraceAction(measuredPoint({ run_url: undefined }), 'y_measuredAvgPower')).toBe(
-      false,
-    );
-  });
-});
-
 describe('View power trace tooltip action', () => {
   afterEach(() => {
     vi.unstubAllGlobals();
   });
 
-  it('renders on a pinned measured-power point, after the other point actions', () => {
-    const html = generateTooltipContent(config({ hasLog: true }));
-    expect(html).toContain(`<a ${ACTION}`);
-    expect(html).toContain('View power trace &rarr;');
-    expect(html.indexOf('data-action="view-logs"')).toBeLessThan(html.indexOf(ACTION));
-  });
-
-  it('is absent while hovering (not pinned)', () => {
-    expect(generateTooltipContent(config({ isPinned: false }))).not.toContain(ACTION);
-  });
-
-  it('is absent on non-measured metrics and on the timeline itself', () => {
-    expect(generateTooltipContent(config({ selectedYAxisMetric: 'y_tpPerGpu' }))).not.toContain(
-      ACTION,
-    );
-    expect(
-      generateTooltipContent(config({ selectedYAxisMetric: 'y_measuredPowerTimeline' })),
-    ).not.toContain(ACTION);
-  });
-
-  it('is absent when the point has no telemetry provenance', () => {
-    expect(
-      generateTooltipContent(config({ data: measuredPoint({ power_audit: undefined }) })),
-    ).not.toContain(ACTION);
-    expect(
-      generateTooltipContent(config({ data: measuredPoint({ run_url: undefined }) })),
-    ).not.toContain(ACTION);
-  });
-
-  it('renders alone for a point without persisted id, keeping charts/logs gated on the id', () => {
-    const html = generateTooltipContent(
-      config({ data: measuredPoint({ id: 0 }), hasLog: true, hasTrace: true }),
-    );
-    expect(html).toContain(ACTION);
-    expect(html).not.toContain('data-action="view-logs"');
-    expect(html).not.toContain('data-action="view-charts"');
-    expect(html).toContain('display: grid; gap: 6px; margin-top: 8px;');
-  });
-
   it('renders on pinned overlay tooltips whose points carry id 0', () => {
     const html = generateOverlayTooltipContent(overlayConfig());
     expect(html).toContain(`<a ${ACTION}`);
@@ -150,86 +91,4 @@ describe('View power trace tooltip action', () => {
       generateOverlayTooltipContent(overlayConfig({ selectedYAxisMetric: 'y_tpPerGpu' })),
     ).not.toContain(ACTION);
   });
-
-  it('uses the Chinese label on /zh tooltips', () => {
-    expect(generateTooltipContent(config({ locale: 'zh' }))).toContain('查看功耗曲线 &rarr;');
-    expect(generateOverlayTooltipContent(overlayConfig({ locale: 'zh' }))).toContain(
-      '查看功耗曲线 &rarr;',
-    );
-  });
-
-  it('falls back to "#" without a window and otherwise deep-links the current page to the timeline', () => {
-    expect(generateTooltipContent(config())).toContain(`${ACTION} href="#"`);
-
-    // The address bar is canonicalised by the share-link store: the default
-    // model and the stale metric go, unrelated params stay, the override wins.
-    vi.stubGlobal('window', {
-      location: new URL(
-        'http://localhost:3000/inference?g_model=DeepSeek-V4-Pro&i_metric=y_measuredAvgPower&utm_source=x',
-      ),
-    });
-    const html = generateTooltipContent(config());
-    const href = /data-action="view-power-trace" href="(?<href>[^"]+)"/u.exec(html)?.groups?.href;
-    expect(href).toBeDefined();
-    const url = new URL(href!);
-    expect(url.origin).toBe('http://localhost:3000');
-    expect(url.pathname).toBe('/inference');
-    expect(url.searchParams.get('utm_source')).toBe('x');
-    expect(url.searchParams.has('g_model')).toBe(false);
-    expect(url.searchParams.get('i_metric')).toBe('y_measuredPowerTimeline');
-  });
-
-  it('never renders on the GPU graph tooltip, which has no in-place timeline', () => {
-    expect(generateGPUGraphTooltipContent(config({ hasLog: true }))).not.toContain(ACTION);
-  });
-});
-
-describe('View PowerX point telemetry action', () => {
-  for (const [chart, generate] of [
-    ['scatter', generateTooltipContent],
-    ['GPU comparison', generateGPUGraphTooltipContent],
-  ] as const) {
-    it(`opens from a pinned ordinary ${chart} point without requiring logs or artifact provenance`, () => {
-      const html = generate(
-        config({
-          showPowerTelemetry: true,
-          data: measuredPoint({ power_audit: undefined, run_url: undefined }),
-        }),
-      );
-      expect(html).toMatch(/<button\b[^>]*data-action="view-power-telemetry"/u);
-      expect(html).not.toMatch(/<a\b[^>]*data-action="view-power-telemetry"/u);
-      expect(html).toContain('PowerX');
-    });
-
-    it(`keeps ${chart} telemetry hidden until enabled and pinned`, () => {
-      expect(generate(config())).not.toContain(TELEMETRY_ACTION);
-      expect(generate(config({ showPowerTelemetry: false }))).not.toContain(TELEMETRY_ACTION);
-      expect(generate(config({ showPowerTelemetry: true, isPinned: false }))).not.toContain(
-        TELEMETRY_ACTION,
-      );
-    });
-
-    it.each([undefined, 0, -1, 1.5, Number.NaN])(
-      `does not offer a DB lookup for invalid ${chart} point ID %s`,
-      (id) => {
-        expect(
-          generate(config({ showPowerTelemetry: true, data: measuredPoint({ id }) })),
-        ).not.toContain(TELEMETRY_ACTION);
-      },
-    );
-  }
-
-  it('uses the Chinese action label', () => {
-    expect(generateTooltipContent(config({ showPowerTelemetry: true, locale: 'zh' }))).toMatch(
-      /查看\s*PowerX/u,
-    );
-  });
-
-  it.each([0, 980001])('keeps overlay ID %s on its run-backed trace, never the DB action', (id) => {
-    const html = generateOverlayTooltipContent(
-      overlayConfig({ showPowerTelemetry: true, data: measuredPoint({ id }) }),
-    );
-    expect(html).not.toContain(TELEMETRY_ACTION);
-    expect(html).toContain(ACTION);
-  });
 });
diff --git a/packages/app/src/lib/chart-utils.test.ts b/packages/app/src/lib/chart-utils.test.ts
index 70c43f710..bb8c6d211 100644
--- a/packages/app/src/lib/chart-utils.test.ts
+++ b/packages/app/src/lib/chart-utils.test.ts
@@ -889,19 +889,6 @@ describe('buildDerivedChartFields', () => {
     expect(historicalFields.measuredJPerTotalToken).toBeUndefined();
     expect(Object.keys(historicalFields)).toEqual(['tpPerGpu']);
   });
-
-  it('emits only the requested power-boundary fields and skips unavailable ones', () => {
-    // No output throughput and no telemetry: only the spec watts can be derived.
-    const historicalFields = buildDerivedChartFields(entry(), 'h100', [
-      'tpPerGpu',
-      'gpuProvisionedWatts',
-      'gpuProvisionedJPerOutputToken',
-      'utilityModeledWatts',
-    ]);
-
-    expect(Object.keys(historicalFields)).toEqual(['tpPerGpu', 'gpuProvisionedWatts']);
-    expect(historicalFields.gpuProvisionedWatts).toEqual({ y: 700, roof: false });
-  });
 });
 
 // ===========================================================================
@@ -1051,25 +1038,6 @@ describe('createChartDataPoint power-boundary fields', () => {
     expect(p.measuredJPerOutputToken).toEqual({ y: 10, roof: false });
   });
 
-  // The ?unofficialrun= overlay seam (transformBenchmarkRows(rows, 'median',
-  // 'external') vs the official derivation) is asserted in power-basis.test.ts,
-  // where real BenchmarkRow fixtures and HW_REGISTRY specs are available.
-
-  it('omits provisioned energies when output throughput is missing, keeps spec watts and B1-scaled modeled energy', () => {
-    const p = boundaryPoint(
-      entry({ output_tput_per_gpu: 0, benchmark_type: 'single_turn', ...validated }),
-    );
-    expect(p.gpuProvisionedWatts?.y).toBe(700);
-    expect(p.utilityProvisionedWatts?.y).toBe(700_000);
-    expect(p.utilityModeledWatts?.y).toBe(877.5);
-    expect(p.gpuProvisionedJPerOutputToken).toBeUndefined();
-    expect(p.utilityProvisionedJPerOutputToken).toBeUndefined();
-    expect('gpuProvisionedJPerOutputToken' in p).toBe(false);
-    expect('utilityProvisionedJPerOutputToken' in p).toBe(false);
-    // Modeled energy inherits B1's token denominator, so it survives.
-    expect(p.utilityModeledJPerOutputToken?.y).toBeCloseTo(17.55, 10);
-  });
-
   it('normalizes fixed-sequence disaggregated energy by all GPUs while jOutput stays per decode GPU', () => {
     const p = boundaryPoint(
       entry({
@@ -1098,41 +1066,6 @@ describe('createChartDataPoint power-boundary fields', () => {
     expect(agentic.gpuProvisionedJPerOutputToken).toBeUndefined();
     expect(agentic.utilityProvisionedJPerOutputToken).toBeUndefined();
   });
-
-  it('omits the modeled boundary without a supported model or without B1 watts', () => {
-    const unsupported = boundaryPoint(
-      entry({
-        output_tput_per_gpu: 400,
-        ...validated,
-        modeledSystemPower: { status: 'unsupported', reason: 'hardware', modelRevision: 'test' },
-      }),
-    );
-    expect(unsupported.utilityModeledWatts).toBeUndefined();
-    expect(unsupported.utilityModeledJPerOutputToken).toBeUndefined();
-    expect(unsupported.utilityProvisionedJPerOutputToken).toBeDefined();
-
-    // Admission belongs to the model, not to the schema marker: a validated
-    // unversioned single-node row the model accepted renders B4 alongside B1.
-    const legacy = boundaryPoint(
-      entry({ output_tput_per_gpu: 400, ...validated, power_metric_schema_version: undefined }),
-    );
-    expect(legacy.measuredAvgPower?.y).toBe(500);
-    expect(legacy.modeledChassisPowerPerGpu?.y).toBe(650);
-    expect(legacy.utilityModeledWatts?.y).toBe(877.5);
-    expect(legacy.utilityModeledJPerOutputToken?.y).toBeCloseTo(17.55, 10);
-
-    // B4 is B1 scaled to the meter, so it needs B1's watts even with a model.
-    const noB1 = boundaryPoint(
-      entry({ output_tput_per_gpu: 400, ...validated, avg_power_w: undefined }),
-    );
-    expect(noB1.measuredAvgPower).toBeUndefined();
-    expect(noB1.utilityModeledWatts).toBeUndefined();
-    expect(noB1.utilityModeledJPerOutputToken).toBeUndefined();
-
-    const noTelemetry = boundaryPoint(entry({ output_tput_per_gpu: 400 }));
-    expect(noTelemetry.utilityModeledWatts).toBeUndefined();
-    expect(noTelemetry.gpuProvisionedJPerOutputToken?.y).toBeCloseTo(1.75, 10);
-  });
 });
 
 // ===========================================================================
@@ -1355,32 +1288,6 @@ describe('createChartDataPoint per-stage measured power fields', () => {
     expect(point.measuredDecodeJPerOutputToken).toBeDefined();
     expect(point.measuredDecodeJPerOutputToken!.y).toBe(0);
   });
-
-  it('carries the prefill pool energy onto the output-token axis for validated disaggregated rows', () => {
-    const e = entry({
-      disagg: true,
-      power_valid: 1,
-      power_metric_schema_version: 2,
-      joules_per_input_token: 0.3,
-      joules_per_output_token: 2.4,
-      prefill_joules_per_input_token: 0.1,
-      decode_joules_per_output_token: 1.6,
-    });
-    const point = createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
-    // 0.1 J/in × (2.4 ÷ 0.3 = 8 input tokens per output token) = 0.8 J/out,
-    // which with the decode pool's 1.6 J/out reconstructs the 2.4 J/out total.
-    expect(point.reconstructedPrefillJPerOutputToken!.y).toBeCloseTo(0.8, 12);
-    expect(point.reconstructedPrefillJPerOutputToken!.roof).toBe(false);
-    // Aggregate rows have no pools to split.
-    const aggregate = createChartDataPoint(
-      '2025-01-01',
-      entry({ ...e, disagg: false }),
-      'median_e2el',
-      'tput_per_gpu',
-      'h100',
-    );
-    expect(aggregate.reconstructedPrefillJPerOutputToken).toBeUndefined();
-  });
 });
 
 // ===========================================================================
diff --git a/packages/app/src/lib/csv-export-helpers.test.ts b/packages/app/src/lib/csv-export-helpers.test.ts
index b98449f27..46298dd4e 100644
--- a/packages/app/src/lib/csv-export-helpers.test.ts
+++ b/packages/app/src/lib/csv-export-helpers.test.ts
@@ -752,37 +752,6 @@ describe('historicalTrendToCsv (mirrors HistoricalTrendsDisplay export)', () =>
 });
 
 describe('inferenceChartToCsv power comparison', () => {
-  it('names each row’s boundary or role only while comparison clones are present', () => {
-    const base = makePoint({
-      hwKey: 'b200_sglang',
-      measuredAvgPower: { y: 600, roof: false },
-    });
-    const clone = {
-      ...base,
-      y: 1000,
-      powerVariant: { kind: 'basis', id: 'gpu-provisioned' },
-    } as InferenceData;
-    const plain = inferenceChartToCsv([base], 'dsv4', '8k/1k', [], {
-      yHeader: 'Measured Power per Chip (W)',
-      yPath: 'measuredAvgPower.y',
-      xHeader: 'Interactivity (tok/s/user)',
-    });
-    expect(plain.headers).not.toContain('Power Series');
-
-    const { headers, rows } = inferenceChartToCsv([base, clone], 'dsv4', '8k/1k', [], {
-      yHeader: 'Measured Power per Chip (W)',
-      yPath: 'measuredAvgPower.y',
-      xHeader: 'Interactivity (tok/s/user)',
-    });
-    const column = headers.indexOf('Power Series');
-    expect(column).toBeGreaterThan(-1);
-    expect(rows.map((row) => row[column])).toEqual(['GPU measured', 'GPU provisioned (TDP)']);
-    expect(rows.map((row) => row[headers.indexOf('Measured Power per Chip (W)')])).toEqual([
-      600, 1000,
-    ]);
-    expect(rows.every((row) => row.length === headers.length)).toBe(true);
-  });
-
   it.each([false, true])('exports plotted role values with overlay=%s', (overlay) => {
     const base = makePoint({
       hwKey: 'gb300_dynamo-trt',
diff --git a/packages/app/src/lib/d3-chart/layers/lines.test.ts b/packages/app/src/lib/d3-chart/layers/lines.test.ts
index 81b3a16dc..894e9d5f3 100644
--- a/packages/app/src/lib/d3-chart/layers/lines.test.ts
+++ b/packages/app/src/lib/d3-chart/layers/lines.test.ts
@@ -130,29 +130,6 @@ describe('renderLines', () => {
     }
   });
 
-  it('uses getStrokeWidth per series and falls back to strokeWidth otherwise', () => {
-    const group = createMockGroup();
-    const { xScale, yScale } = makeScales();
-    renderLines(
-      group as any,
-      SAMPLE_LINES,
-      xScale,
-      yScale,
-      makeConfig({
-        strokeWidth: 1.5,
-        getStrokeWidth: (key) => (key === 'seriesB' ? 3 : (undefined as unknown as number)),
-      }),
-    );
-
-    const widthByClass = Object.fromEntries(
-      group
-        .selectAll('.line-path')
-        .elements.map((el) => [el.attrs['class'], el.attrs['stroke-width']]),
-    );
-    expect(widthByClass['line-path line-seriesA']).toBe(1.5);
-    expect(widthByClass['line-path line-seriesB']).toBe(3);
-  });
-
   it('generates valid d attribute from line generator', () => {
     const group = createMockGroup();
     const { xScale, yScale } = makeScales();
diff --git a/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts b/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
index 428fcbf8f..c7cc0ad80 100644
--- a/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
+++ b/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
@@ -917,104 +917,6 @@ describe('serializePerfRulers / parsePerfRulers', () => {
     expect(parsed.draft).toBeNull();
     expect(parsed.nextId).toBe(3);
   });
-
-  it('survives URLSearchParams encoding, which the share link applies', () => {
-    const state = complete(EMPTY_PERF_RULER_STATE, OFFICIAL_A, OVERLAY, 33);
-    const search = new URLSearchParams({ i_rulers: serializePerfRulers(state) });
-    const decoded = new URLSearchParams(search.toString()).get('i_rulers');
-    expect(parsePerfRulers(decoded).rulers).toEqual([
-      { id: 1, curveA: OFFICIAL_A, curveB: OVERLAY, isoX: 33 },
-    ]);
-  });
-
-  it('rounds the iso-x to four significant digits and never emits the draft', () => {
-    let state = complete(EMPTY_PERF_RULER_STATE, OFFICIAL_A, OFFICIAL_B, 123.456789);
-    state = nextPerfRulerState(state, { curve: OFFICIAL_B, isoX: 9 });
-    expect(state.draft).not.toBeNull();
-    expect(serializePerfRulers(state)).toBe(`123.5|${OFFICIAL_A}|${OFFICIAL_B}`);
-    expect(serializePerfRulers(complete(EMPTY_PERF_RULER_STATE, 'a', 'b', 0.00012346))).toBe(
-      '0.0001235|a|b',
-    );
-    expect(serializePerfRulers(complete(EMPTY_PERF_RULER_STATE, 'a', 'b', 98765))).toBe(
-      '98770|a|b',
-    );
-  });
-
-  it('serializes the empty state to the empty string so the param strips as default', () => {
-    expect(serializePerfRulers(EMPTY_PERF_RULER_STATE)).toBe('');
-    const drafted = nextPerfRulerState(EMPTY_PERF_RULER_STATE, { curve: 'a', isoX: 1 });
-    expect(serializePerfRulers(drafted)).toBe('');
-  });
-
-  it('returns the shared empty state for missing or entirely malformed input', () => {
-    expect(parsePerfRulers('')).toBe(EMPTY_PERF_RULER_STATE);
-    expect(parsePerfRulers(null)).toBe(EMPTY_PERF_RULER_STATE);
-    expect(parsePerfRulers(undefined)).toBe(EMPTY_PERF_RULER_STATE);
-    expect(parsePerfRulers('garbage')).toBe(EMPTY_PERF_RULER_STATE);
-    expect(parsePerfRulers(';;|')).toBe(EMPTY_PERF_RULER_STATE);
-  });
-
-  it('drops malformed entries and keeps the valid ones', () => {
-    const encoded = [
-      `NaN|${OFFICIAL_A}|${OFFICIAL_B}`, // non-numeric iso-x
-      `|${OFFICIAL_A}|${OFFICIAL_B}`, // missing iso-x
-      `12|${OFFICIAL_A}`, // missing curve B
-      `12||${OFFICIAL_B}`, // empty curve A
-      `12|${OFFICIAL_A}|${OFFICIAL_A}`, // a curve cannot be measured against itself
-      `12|${OFFICIAL_A}|${OFFICIAL_B}|extra`, // too many fields
-      `Infinity|${OFFICIAL_A}|${OFFICIAL_B}`,
-      `7.5|${OFFICIAL_A}|${OFFICIAL_B}`,
-    ].join(';');
-    expect(parsePerfRulers(encoded).rulers).toEqual([
-      { id: 1, curveA: OFFICIAL_A, curveB: OFFICIAL_B, isoX: 7.5 },
-    ]);
-  });
-
-  it('only accepts roofline identity classes as curve ids', () => {
-    const encoded = [
-      // The shared marker classes sit on EVERY roofline path: a ruler between
-      // them would land on whichever two paths come first in the DOM.
-      `10|roofline-path|overlay-roofline-path`,
-      `10|${OFFICIAL_A}|roofline-path`,
-      // Other nodes inside the zoom group are not curves.
-      `10|perf-ruler-hit|${OFFICIAL_A}`,
-      `10|dot-group|zoom-group`,
-      `10|${OFFICIAL_A}|roofline-`, // identity class needs a series
-      `10|${OFFICIAL_A}|roofline-b200 fp8`, // no whitespace in a class token
-      `10|${OFFICIAL_A}|${OVERLAY}`,
-    ].join(';');
-    expect(parsePerfRulers(encoded).rulers).toEqual([
-      { id: 1, curveA: OFFICIAL_A, curveB: OVERLAY, isoX: 10 },
-    ]);
-  });
-
-  it('caps at MAX_PERF_RULERS keeping the newest entries, like the click reducer', () => {
-    const encoded = Array.from(
-      { length: MAX_PERF_RULERS + 3 },
-      (_, index) => `${index + 1}|roofline-a${index}|roofline-b${index}`,
-    ).join(';');
-    const parsed = parsePerfRulers(encoded);
-    expect(parsed.rulers).toHaveLength(MAX_PERF_RULERS);
-    expect(parsed.rulers[0]).toEqual({
-      id: 1,
-      curveA: 'roofline-a3',
-      curveB: 'roofline-b3',
-      isoX: 4,
-    });
-    expect(parsed.rulers.at(-1)).toEqual({
-      id: MAX_PERF_RULERS,
-      curveA: `roofline-a${MAX_PERF_RULERS + 2}`,
-      curveB: `roofline-b${MAX_PERF_RULERS + 2}`,
-      isoX: MAX_PERF_RULERS + 3,
-    });
-    expect(parsed.nextId).toBe(MAX_PERF_RULERS + 1);
-  });
-
-  it('hands out ids a later click never reuses', () => {
-    const restored = parsePerfRulers(`10|roofline-a|roofline-b;20|roofline-c|roofline-d`);
-    const placed = complete(restored, 'e', 'f', 30);
-    expect(placed.rulers.map((ruler) => ruler.id)).toEqual([1, 2, 3]);
-  });
 });
 
 // ── pathXExtent ─────────────────────────────────────────────
diff --git a/packages/app/src/lib/github-artifacts.test.ts b/packages/app/src/lib/github-artifacts.test.ts
index 948a18462..622f851a6 100644
--- a/packages/app/src/lib/github-artifacts.test.ts
+++ b/packages/app/src/lib/github-artifacts.test.ts
@@ -8,7 +8,6 @@ import {
   fetchGithubRunArtifacts,
   getRunDate,
   normalizeGithubRunInfo,
-  readZipEntries,
   type GithubArtifact,
   type GithubWorkflowRun,
 } from './github-artifacts';
@@ -145,25 +144,3 @@ describe('extractZipEntries', () => {
     expect(parseErrors).toEqual(['bad.json']);
   });
 });
-
-describe('readZipEntries', () => {
-  it('decodes only the entries the predicate selects and skips directories', () => {
-    const zip = new AdmZip();
-    zip.addFile('LOGS/power/', Buffer.alloc(0));
-    zip.addFile('LOGS/power/samples.csv', Buffer.from('a,b\n1,2', 'utf8'));
-    zip.addFile('LOGS/big/results.json', Buffer.alloc(64 * 1024, 0x41));
-    zip.addFile('power_validation_x_conc8.json', Buffer.from('{"power_valid":true}', 'utf8'));
-
-    const files = readZipEntries(
-      zip.toBuffer(),
-      (name) => name === 'LOGS/power/samples.csv' || name.startsWith('power_validation_'),
-    );
-
-    expect([...files.keys()].toSorted()).toEqual([
-      'LOGS/power/samples.csv',
-      'power_validation_x_conc8.json',
-    ]);
-    expect(files.get('LOGS/power/samples.csv')).toBe('a,b\n1,2');
-    expect(files.get('power_validation_x_conc8.json')).toBe('{"power_valid":true}');
-  });
-});
diff --git a/packages/app/src/lib/inference-labels.test.ts b/packages/app/src/lib/inference-labels.test.ts
index 25658e580..b044c4974 100644
--- a/packages/app/src/lib/inference-labels.test.ts
+++ b/packages/app/src/lib/inference-labels.test.ts
@@ -4,10 +4,8 @@ import { getHardwareConfig } from '@/lib/constants';
 import {
   getInferenceHardwareConfig,
   getInferenceRunLabel,
-  getOverlayLineLabel,
   getPointHardwareConfig,
   inferenceFrameworkLabelOverride,
-  shortRunTag,
 } from './inference-labels';
 
 const runUrl = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34926284365';
@@ -125,36 +123,3 @@ describe('run-specific MoRI UMBP labels', () => {
     expect(getInferenceHardwareConfig(hwKey, undefined, []).suffix).toBe('(MoRI SGLang)');
   });
 });
-
-describe('overlay line labels', () => {
-  const klaud = {
-    id: 35319969159,
-    branch: 'klaud/qwen3.5-fp8-gb300-dynamo-sglang-nightly-dev-cu13-20260918-20518d85',
-  };
-
-  it('names the hardware and leaves the branch to the legend when one run draws it', () => {
-    expect(getOverlayLineLabel('GB300 NVL72 (Dynamo SGLang)', klaud, false)).toBe(
-      '✕ GB300 NVL72 (Dynamo SGLang)',
-    );
-  });
-
-  it('adds a short run tag only when several runs draw the same hardware', () => {
-    expect(getOverlayLineLabel('GB200 NVL72 (Dynamo SGLang)', klaud, true)).toBe(
-      '✕ GB200 NVL72 (Dynamo SGLang) · …20260918-20518d85',
-    );
-    expect(getOverlayLineLabel('B300', { id: 31756025413, branch: 'main' }, true)).toBe(
-      '✕ B300 · main',
-    );
-  });
-
-  it.each([
-    ['main', 'main'],
-    ['feat/short-name', 'feat/short-name'],
-    ['release/2026-09-18-hotfix', '2026-09-18-hotfix'],
-    [klaud.branch, '…20260918-20518d85'],
-    ['', 'run 42'],
-    [null, 'run 42'],
-  ])('shortens branch %j to %j', (branch, expected) => {
-    expect(shortRunTag({ id: 42, branch })).toBe(expected);
-  });
-});
diff --git a/packages/app/src/lib/power-basis.test.ts b/packages/app/src/lib/power-basis.test.ts
index 9f2bf53f1..0aa67a4f5 100644
--- a/packages/app/src/lib/power-basis.test.ts
+++ b/packages/app/src/lib/power-basis.test.ts
@@ -3,15 +3,7 @@ import { describe, expect, it } from 'vitest';
 import type { BenchmarkRow } from '@/lib/api';
 import { rowToAggDataEntry, transformBenchmarkRows } from '@/lib/benchmark-transform';
 import { buildDerivedChartFields, getHardwareKey } from '@/lib/chart-utils';
-import { getGpuSpecs } from '@/lib/constants';
-import {
-  computePowerBasisFields,
-  modeledFacilityWattsPerGpu,
-  POWER_BASES,
-  POWER_BASIS_FIELDS,
-  POWER_BASIS_LABELS,
-  powerBasisNormalization,
-} from '@/lib/power-basis';
+import { POWER_BASIS_FIELDS } from '@/lib/power-basis';
 
 // Qwen3.5 B200 c1, run 34175132645: actual rounded telemetry, eight GPUs
 // (same fixture as modeled-system-power.test.ts) plus an output rate.
@@ -67,322 +59,7 @@ function derive(source: BenchmarkRow) {
   return { entry, hwKey, fields: buildDerivedChartFields(entry, hwKey) };
 }
 
-const y = (metric: { y: number } | undefined) => metric?.y;
-
-describe('computePowerBasisFields', () => {
-  // H200-like aggregate deployment: 8 GPUs at 50 output tok/s each.
-  const h200 = {
-    tdpWatts: 700,
-    utilityWatts: 1370,
-    allocatedGpus: 8,
-    totalOutputTokPerSec: 400,
-    measuredWatts: 350,
-    measuredJPerOutputToken: 7,
-    modeledFacilityWattsPerGpu: 650,
-  };
-
-  it('derives provisioned and modeled boundaries for an aggregate deployment', () => {
-    const values = computePowerBasisFields(h200);
-    expect(values).toMatchObject({
-      gpuProvisionedWatts: 700,
-      gpuProvisionedJPerOutputToken: 14,
-      utilityProvisionedWatts: 1370,
-      utilityModeledWatts: 650,
-      utilityModeledJPerOutputToken: 13,
-    });
-    expect(values.utilityProvisionedJPerOutputToken).toBeCloseTo(27.4, 10);
-  });
-
-  it('charges the prefill pool to every output token of a 4P+4D deployment', () => {
-    // GB200-like disaggregation: only 4 decode GPUs emit tokens (50 tok/s each),
-    // but all 8 allocated GPUs are provisioned, so J/token doubles versus a
-    // per-decode-GPU reading (1200 / 50 = 24).
-    const values = computePowerBasisFields({
-      tdpWatts: 1200,
-      utilityWatts: 1870,
-      allocatedGpus: 8,
-      totalOutputTokPerSec: 200,
-      measuredWatts: null,
-      measuredJPerOutputToken: null,
-      modeledFacilityWattsPerGpu: null,
-    });
-    expect(values.gpuProvisionedJPerOutputToken).toBe(48);
-    expect(values.utilityProvisionedJPerOutputToken).toBeCloseTo(74.8, 10);
-    expect(values.utilityModeledWatts).toBeNull();
-    expect(values.utilityModeledJPerOutputToken).toBeNull();
-  });
-
-  it('nulls only the boundaries whose inputs are unavailable', () => {
-    const noModel = computePowerBasisFields({ ...h200, modeledFacilityWattsPerGpu: null });
-    expect(noModel.utilityModeledWatts).toBeNull();
-    expect(noModel.utilityModeledJPerOutputToken).toBeNull();
-    expect(noModel.gpuProvisionedJPerOutputToken).toBe(14);
-    expect(noModel.utilityProvisionedJPerOutputToken).toBeCloseTo(27.4, 10);
-
-    // B4 is anchored on B1: without measured watts neither modeled value exists,
-    // even when a caller supplies a modeled W from elsewhere.
-    const noMeasured = computePowerBasisFields({
-      ...h200,
-      measuredWatts: null,
-      measuredJPerOutputToken: null,
-    });
-    expect(noMeasured.utilityModeledWatts).toBeNull();
-    expect(noMeasured.utilityModeledJPerOutputToken).toBeNull();
-    expect(noMeasured.gpuProvisionedWatts).toBe(700);
-    expect(noMeasured.utilityProvisionedWatts).toBe(1370);
-
-    const noMeasuredEnergy = computePowerBasisFields({ ...h200, measuredJPerOutputToken: null });
-    expect(noMeasuredEnergy.utilityModeledWatts).toBe(650);
-    expect(noMeasuredEnergy.utilityModeledJPerOutputToken).toBeNull();
-
-    const noThroughput = computePowerBasisFields({ ...h200, totalOutputTokPerSec: null });
-    expect(noThroughput.gpuProvisionedWatts).toBe(700);
-    expect(noThroughput.gpuProvisionedJPerOutputToken).toBeNull();
-    expect(noThroughput.utilityProvisionedJPerOutputToken).toBeNull();
-    expect(noThroughput.utilityModeledJPerOutputToken).toBe(13);
-  });
-
-  it.each([0, -1, NaN, Infinity])('never turns %s into a plotted value', (bad) => {
-    const values = computePowerBasisFields({
-      tdpWatts: bad,
-      utilityWatts: bad,
-      allocatedGpus: bad,
-      totalOutputTokPerSec: bad,
-      measuredWatts: bad,
-      measuredJPerOutputToken: bad,
-      modeledFacilityWattsPerGpu: bad,
-    });
-    expect(Object.values(values).every((v) => v === null)).toBe(true);
-  });
-});
-
-describe('powerBasisNormalization', () => {
-  it('keeps aggregate rows on the per-GPU ratio because N_alloc cancels', () => {
-    expect(
-      powerBasisNormalization({
-        output_tput_per_gpu: 50,
-        disagg: false,
-        benchmark_type: 'single_turn',
-        num_prefill_gpu: 8,
-        num_decode_gpu: 8,
-      }),
-    ).toEqual({ allocatedGpus: 1, totalOutputTokPerSec: 50 });
-  });
-
-  it('counts prefill GPUs and decode-only output for fixed-sequence disaggregation', () => {
-    const disagg = {
-      output_tput_per_gpu: 50,
-      disagg: true,
-      benchmark_type: 'single_turn',
-      num_prefill_gpu: 4,
-      num_decode_gpu: 4,
-    };
-    expect(powerBasisNormalization(disagg)).toEqual({
-      allocatedGpus: 8,
-      totalOutputTokPerSec: 200,
-    });
-    expect(powerBasisNormalization({ ...disagg, num_prefill_gpu: 0 })).toEqual({
-      allocatedGpus: null,
-      totalOutputTokPerSec: null,
-    });
-    expect(powerBasisNormalization({ ...disagg, benchmark_type: 'agentic_traces' })).toEqual({
-      allocatedGpus: null,
-      totalOutputTokPerSec: null,
-    });
-    expect(powerBasisNormalization({ ...disagg, output_tput_per_gpu: 0 })).toEqual({
-      allocatedGpus: null,
-      totalOutputTokPerSec: null,
-    });
-  });
-});
-
 describe('power boundaries through the derived-field builder', () => {
-  it('orders B3 ≥ B4 ≥ B1 and B2 ≥ B1 for watts and energy on real B200 telemetry', () => {
-    const { entry, fields } = derive(row());
-    const b1W = y(fields.measuredAvgPower)!;
-    const b2W = y(fields.gpuProvisionedWatts)!;
-    const b3W = y(fields.utilityProvisionedWatts)!;
-    const b4W = y(fields.utilityModeledWatts)!;
-    expect(b1W).toBe(349.859);
-    expect(b2W).toBe(getGpuSpecs('b200').tdp);
-    expect(b3W).toBe(getGpuSpecs('b200').power * 1000);
-    expect(b4W).toBeCloseTo(6288.4 / 8, 6);
-    expect(b3W).toBeGreaterThanOrEqual(b4W);
-    expect(b4W).toBeGreaterThanOrEqual(b1W);
-    expect(b2W).toBeGreaterThanOrEqual(b1W);
-
-    const b1J = y(fields.measuredJPerOutputToken)!;
-    const b2J = y(fields.gpuProvisionedJPerOutputToken)!;
-    const b3J = y(fields.utilityProvisionedJPerOutputToken)!;
-    const b4J = y(fields.utilityModeledJPerOutputToken)!;
-    expect(b1J).toBe(12.937902);
-    expect(b2J).toBeCloseTo(b2W / 30, 10);
-    expect(b3J).toBeCloseTo(b3W / 30, 10);
-    expect(b4J).toBeCloseTo((b1J * b4W) / b1W, 10);
-    expect(b3J).toBeGreaterThanOrEqual(b4J);
-    expect(b4J).toBeGreaterThanOrEqual(b1J);
-    expect(b2J).toBeGreaterThanOrEqual(b1J);
-
-    // B4 W ÷ B1 W is the facility-to-board ratio of the attached estimate.
-    const model = entry.modeledSystemPower;
-    expect(model?.status).toBe('supported');
-    if (model?.status !== 'supported') return;
-    expect(b4W / b1W).toBeCloseTo(model.deploymentFacilityWatts / (model.gpuCount * b1W), 10);
-  });
-
-  it('applies PUE exactly once: B4 W ÷ chassis AC per GPU equals the model PUE', () => {
-    const { entry, fields } = derive(row());
-    const model = entry.modeledSystemPower;
-    if (model?.status !== 'supported') throw new Error('fixture must be supported');
-    const chassisAcPerMeasuredGpu = model.chassisAcWatts / model.gpuCount;
-    expect(y(fields.utilityModeledWatts)! / chassisAcPerMeasuredGpu).toBeCloseTo(model.pue, 4);
-    expect(y(fields.utilityModeledWatts)! / y(fields.modeledChassisPowerPerGpu)!).toBeCloseTo(
-      model.pue,
-      4,
-    );
-  });
-
-  it('normalizes a fixed-sequence 4P+4D row by all eight GPUs while jOutput stays per decode GPU', () => {
-    const { entry, fields } = derive(
-      row({
-        hardware: 'gb200',
-        disagg: true,
-        prefill_tp: 4,
-        decode_tp: 4,
-        num_prefill_gpu: 4,
-        num_decode_gpu: 4,
-        metrics: { ...row().metrics, tput_per_gpu: 450, output_tput_per_gpu: 50 },
-      }),
-    );
-    const specs = getGpuSpecs('gb200');
-    expect(y(fields.gpuProvisionedJPerOutputToken)).toBeCloseTo((specs.tdp * 8) / (50 * 4), 10);
-    expect(y(fields.utilityProvisionedJPerOutputToken)).toBeCloseTo(
-      (specs.power * 1000 * 8) / (50 * 4),
-      10,
-    );
-    // Legacy all-in energy divides one decode GPU's power by that GPU's output.
-    expect(y(fields.jOutput)).toBeCloseTo((specs.power * 1000) / 50, 10);
-    expect(y(fields.utilityProvisionedJPerOutputToken)).toBeCloseTo(2 * y(fields.jOutput)!, 10);
-    // Telemetry is validated (B1 renders) but GB200 NVL72 has no chassis
-    // model, so the modeled boundary alone is absent.
-    expect(fields.measuredAvgPower).toBeDefined();
-    expect(entry.modeledSystemPower).toMatchObject({ status: 'unsupported', reason: 'hardware' });
-    expect(fields.utilityModeledWatts).toBeUndefined();
-    expect(fields.utilityModeledJPerOutputToken).toBeUndefined();
-  });
-
-  it('divides B4 by the measured GPU count, not the modeled chassis count, on a 4P+8D H200 deployment', () => {
-    // Two worker hosts, a half-filled prefill chassis and a full decode chassis:
-    // the model evaluates 16 GPUs (two chassis) while twelve are measured.
-    const { entry, fields } = derive(
-      row({
-        hardware: 'h200',
-        disagg: true,
-        is_multinode: true,
-        prefill_tp: 4,
-        decode_tp: 8,
-        num_prefill_gpu: 4,
-        num_decode_gpu: 8,
-        workers: [
-          {
-            role: 'prefill',
-            worker_idx: 0,
-            num_gpus: 4,
-            hosts: ['prefill-node'],
-            avg_power_w: 400,
-          },
-          { role: 'decode', worker_idx: 0, num_gpus: 8, hosts: ['decode-node'], avg_power_w: 300 },
-        ],
-        metrics: {
-          power_valid: 1,
-          power_metric_schema_version: 2,
-          avg_power_w: 4000 / 12,
-          avg_total_gpu_power_w: 4000,
-          prefill_avg_power_w: 400,
-          decode_avg_power_w: 300,
-          joules_per_output_token: 14,
-          tput_per_gpu: 450,
-          output_tput_per_gpu: 50,
-        },
-      }),
-    );
-    const model = entry.modeledSystemPower;
-    expect(model?.status).toBe('supported');
-    if (model?.status !== 'supported') return;
-    expect(model.gpuCount).toBe(12);
-    expect(model.modeledGpuCount).toBe(16);
-    expect(model.chassisBasis).toBe('extrapolated');
-
-    const b1W = y(fields.measuredAvgPower)!;
-    const b3W = y(fields.utilityProvisionedWatts)!;
-    const b4W = y(fields.utilityModeledWatts)!;
-    expect(b1W).toBeCloseTo(4000 / 12, 10);
-    expect(b4W).toBeCloseTo(model.deploymentFacilityWatts / model.gpuCount, 10);
-    expect(b4W).not.toBeCloseTo(model.facilityWatts / model.modeledGpuCount, 6);
-    expect(b4W).not.toBeCloseTo(model.facilityWatts / model.gpuCount, 6);
-    expect(b4W).not.toBeCloseTo(model.deploymentFacilityWatts / model.modeledGpuCount, 6);
-
-    const b1J = y(fields.measuredJPerOutputToken)!;
-    const b3J = y(fields.utilityProvisionedJPerOutputToken)!;
-    const b4J = y(fields.utilityModeledJPerOutputToken)!;
-    expect(b1J).toBe(14);
-    expect(b4J).toBeCloseTo((14 * b4W) / (4000 / 12), 10);
-    expect(b3J).toBeCloseTo(1.5 * y(fields.jOutput)!, 10);
-    expect(b3W).toBeGreaterThanOrEqual(b4W);
-    expect(b4W).toBeGreaterThanOrEqual(b1W);
-    expect(b3J).toBeGreaterThanOrEqual(b4J);
-    expect(b4J).toBeGreaterThanOrEqual(b1J);
-  });
-
-  it('omits the modeled boundary off the 8k/1k workload but keeps provisioned ones', () => {
-    const { fields } = derive(row({ isl: 1024, osl: 1024 }));
-    expect(fields.measuredAvgPower).toBeDefined();
-    expect(fields.utilityModeledWatts).toBeUndefined();
-    expect(fields.utilityModeledJPerOutputToken).toBeUndefined();
-    expect(y(fields.gpuProvisionedWatts)).toBe(getGpuSpecs('b200').tdp);
-    expect(fields.utilityProvisionedJPerOutputToken).toBeDefined();
-  });
-
-  it('omits the modeled boundary with B1 when telemetry is invalid, keeps provisioned ones', () => {
-    const invalid = derive(row({ metrics: { ...row().metrics, power_valid: 0 } })).fields;
-    expect(invalid.measuredAvgPower).toBeUndefined();
-    expect(invalid.utilityModeledWatts).toBeUndefined();
-    expect(invalid.utilityModeledJPerOutputToken).toBeUndefined();
-    expect(invalid.gpuProvisionedWatts).toBeDefined();
-    expect(invalid.utilityProvisionedWatts).toBeDefined();
-  });
-
-  it('renders the modeled boundary wherever B1 renders, including validated unversioned single-node rows', () => {
-    const { power_metric_schema_version: _schema, ...unversioned } = row().metrics;
-    const legacy = derive(row({ metrics: unversioned }));
-    const model = legacy.entry.modeledSystemPower;
-    expect(model).toMatchObject({
-      status: 'supported',
-      telemetryBasis: 'validated-unversioned-single-node',
-    });
-    if (model?.status !== 'supported') return;
-    expect(legacy.fields.measuredAvgPower).toBeDefined();
-    expect(legacy.fields.measuredJPerOutputToken).toBeDefined();
-    expect(
-      y(legacy.fields.utilityModeledWatts)! / y(legacy.fields.modeledChassisPowerPerGpu)!,
-    ).toBeCloseTo(model.pue, 4);
-    expect(y(legacy.fields.utilityModeledJPerOutputToken)).toBeCloseTo(
-      (y(legacy.fields.measuredJPerOutputToken)! * y(legacy.fields.utilityModeledWatts)!) /
-        y(legacy.fields.measuredAvgPower)!,
-      10,
-    );
-    // Same numbers as the versioned row: the schema marker changes admission, not the estimate.
-    expect(legacy.fields.utilityModeledWatts).toEqual(derive(row()).fields.utilityModeledWatts);
-  });
-
-  it('omits provisioned boundaries for hardware without registry specs', () => {
-    const { fields } = derive(row({ hardware: 'unlistedchip' }));
-    expect(fields.gpuProvisionedWatts).toBeUndefined();
-    expect(fields.gpuProvisionedJPerOutputToken).toBeUndefined();
-    expect(fields.utilityProvisionedWatts).toBeUndefined();
-    expect(fields.utilityProvisionedJPerOutputToken).toBeUndefined();
-  });
-
   it('serves the same fields to ?unofficialrun= overlays through transformBenchmarkRows', () => {
     const { chartData } = transformBenchmarkRows([row()], 'median', 'external');
     const point = chartData[0][0];
@@ -393,52 +70,4 @@ describe('power boundaries through the derived-field builder', () => {
       expect(point[basis.watts]?.roof).toBe(false);
     }
   });
-
-  it('emits exactly the requested boundary fields for historical trends', () => {
-    const { entry, hwKey } = derive(row());
-    const requested = buildDerivedChartFields(entry, hwKey, [
-      'utilityModeledWatts',
-      'gpuProvisionedJPerOutputToken',
-    ]);
-    expect(Object.keys(requested).sort()).toEqual(
-      ['gpuProvisionedJPerOutputToken', 'utilityModeledWatts'].sort(),
-    );
-    const unavailable = buildDerivedChartFields(
-      rowToAggDataEntry(row({ hardware: 'gb200' })),
-      'gb200',
-      ['tpPerGpu', 'utilityModeledWatts'],
-    );
-    expect(Object.keys(unavailable)).toEqual(['tpPerGpu']);
-  });
-});
-
-describe('modeledFacilityWattsPerGpu', () => {
-  const supported = rowToAggDataEntry(row()).modeledSystemPower;
-
-  it('divides the deployment facility share by the measured GPU count', () => {
-    expect(modeledFacilityWattsPerGpu({ modeledSystemPower: supported })).toBeCloseTo(
-      6288.4 / 8,
-      6,
-    );
-  });
-
-  it('returns null without a supported model', () => {
-    expect(
-      modeledFacilityWattsPerGpu({
-        modeledSystemPower: { status: 'unsupported', reason: 'hardware', modelRevision: 'x' },
-      }),
-    ).toBeNull();
-    expect(modeledFacilityWattsPerGpu({ modeledSystemPower: undefined })).toBeNull();
-  });
-});
-
-describe('power basis registry', () => {
-  it('labels every basis in both locales and maps every derived basis to two fields', () => {
-    for (const basis of POWER_BASES) {
-      expect(POWER_BASIS_LABELS[basis].en.length).toBeGreaterThan(0);
-      expect(POWER_BASIS_LABELS[basis].zh.length).toBeGreaterThan(0);
-    }
-    const keys = Object.values(POWER_BASIS_FIELDS).flatMap((f) => [f.watts, f.energy]);
-    expect(new Set(keys).size).toBe(6);
-  });
 });
diff --git a/packages/app/src/lib/url-state.test.ts b/packages/app/src/lib/url-state.test.ts
index 392b1bf94..39a1937e0 100644
--- a/packages/app/src/lib/url-state.test.ts
+++ b/packages/app/src/lib/url-state.test.ts
@@ -104,16 +104,6 @@ describe('PARAM_DEFAULTS', () => {
     expect(PARAM_DEFAULTS.i_revenue).toBe('normalized');
   });
 
-  it('has an empty default for perf rulers (none placed)', async () => {
-    const { PARAM_DEFAULTS } = await import('@/lib/url-state');
-    expect(PARAM_DEFAULTS.i_rulers).toBe('');
-  });
-
-  it('has an empty default for the power comparison (metric drawn alone)', async () => {
-    const { PARAM_DEFAULTS } = await import('@/lib/url-state');
-    expect(PARAM_DEFAULTS.i_pcompare).toBe('');
-  });
-
   it('has empty string defaults for legend-active params', async () => {
     const { PARAM_DEFAULTS } = await import('@/lib/url-state');
     expect(PARAM_DEFAULTS.i_active).toBe('');
@@ -152,17 +142,6 @@ describe('readUrlParams', () => {
     expect(params.i_seq).toBe('2k/4k');
   });
 
-  it('reads perf rulers decoded, with curve ids and separators intact', async () => {
-    const encoded = new URLSearchParams({
-      i_rulers: '41.5|roofline-b200_trt_fp8|overlay-roofline-h100_vllm_fp8_run1__2026-09%2F11',
-    }).toString();
-    setupWindow(`?${encoded}`);
-    const { readUrlParams } = await import('@/lib/url-state');
-    expect(readUrlParams().i_rulers).toBe(
-      '41.5|roofline-b200_trt_fp8|overlay-roofline-h100_vllm_fp8_run1__2026-09%2F11',
-    );
-  });
-
   it('reads the Internal TCO basis from the URL', async () => {
     setupWindow('?g_tco=internal');
     const { readUrlParams } = await import('@/lib/url-state');
@@ -392,17 +371,6 @@ describe('writeUrlParams + buildShareUrl', () => {
     expect(url).not.toContain('g_model');
   });
 
-  it('drops i_rulers from the share link once the last ruler is cleared', async () => {
-    setupWindow('?i_rulers=41.5%7Croofline-a%7Croofline-b', '/inference');
-    const { writeUrlParams, buildShareUrl } = await import('@/lib/url-state');
-    expect(buildShareUrl()).toContain('i_rulers=');
-
-    writeUrlParams({ i_rulers: '' });
-    await vi.advanceTimersByTimeAsync(200);
-
-    expect(buildShareUrl()).not.toContain('i_rulers');
-  });
-
   it('removes the revenue source instead of emitting an empty query param off-metric', async () => {
     setupWindow('?i_revenue=openrouter', '/inference');
     const { writeUrlParams, buildShareUrl } = await import('@/lib/url-state');
@@ -672,28 +640,6 @@ describe('buildShareUrl tab filtering', () => {
     expect(url).not.toContain('r_active');
   });
 
-  it('shares i_rulers on /inference and its compare routes but not on other tabs', async () => {
-    const rulers = '41.5|roofline-b200_trt_fp8|roofline-mi355x_sglang_fp4';
-    for (const pathname of ['/inference', '/zh/inference', '/compare/b200-vs-mi355x']) {
-      vi.resetModules();
-      setupWindow('', pathname);
-      const { writeUrlParams, buildShareUrl } = await import('@/lib/url-state');
-      writeUrlParams({ i_rulers: rulers });
-      await vi.advanceTimersByTimeAsync(200);
-      const url = buildShareUrl();
-      expect(url, pathname).toContain('i_rulers=');
-      expect(new URL(url).searchParams.get('i_rulers'), pathname).toBe(rulers);
-    }
-    for (const pathname of ['/evaluation', '/reliability']) {
-      vi.resetModules();
-      setupWindow('', pathname);
-      const { writeUrlParams, buildShareUrl } = await import('@/lib/url-state');
-      writeUrlParams({ i_rulers: rulers });
-      await vi.advanceTimersByTimeAsync(200);
-      expect(buildShareUrl(), pathname).not.toContain('i_rulers');
-    }
-  });
-
   it('includes e_active on /evaluation but not i_active or r_active', async () => {
     setupWindow('', '/evaluation');
     const { writeUrlParams, buildShareUrl } = await import('@/lib/url-state');
@@ -1044,37 +990,3 @@ describe('rememberChartStateInUrl — params this module does not own', () => {
     expect(params.has('unofficialrun')).toBe(false);
   });
 });
-
-describe('chartStateHref', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.resetModules();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.unstubAllGlobals();
-  });
-
-  it('rebuilds the page URL from the chart state, canonical unofficial-run key and overrides', async () => {
-    setupWindow(
-      '?unofficialrun=31415926535&i_metric=y_tpPerGpu&utm_source=x',
-      '/inference',
-      '#chart',
-    );
-    const { chartStateHref, writeUrlParams } = await import('@/lib/url-state');
-    // A default value (i_prec) is not chart state and stays out of the link.
-    writeUrlParams({ g_model: 'Qwen-3.5-397B-A17B', i_metric: 'y_measuredAvgPower', i_prec: '' });
-
-    const url = new URL(chartStateHref({ i_metric: 'y_measuredPowerTimeline' }));
-    expect(url.origin).toBe('https://example.com');
-    expect(url.pathname).toBe('/inference');
-    expect(url.hash).toBe('#chart');
-    expect(url.searchParams.get('utm_source')).toBe('x');
-    expect(url.searchParams.get('g_model')).toBe('Qwen-3.5-397B-A17B');
-    expect(url.searchParams.has('i_prec')).toBe(false);
-    expect(url.searchParams.get('i_metric')).toBe('y_measuredPowerTimeline');
-    expect(url.searchParams.get('unofficialruns')).toBe('31415926535');
-    expect(url.searchParams.has('unofficialrun')).toBe(false);
-  });
-});
diff --git a/packages/app/timings.json b/packages/app/timings.json
index 2f1e8638d..5ad312efa 100644
--- a/packages/app/timings.json
+++ b/packages/app/timings.json
@@ -236,18 +236,6 @@
       "spec": "cypress/e2e/performance.cy.ts",
       "duration": 2377
     },
-    {
-      "spec": "cypress/e2e/powerx-basis.cy.ts",
-      "duration": 3000
-    },
-    {
-      "spec": "cypress/e2e/powerx-timeline.cy.ts",
-      "duration": 24000
-    },
-    {
-      "spec": "cypress/e2e/powerx-compare.cy.ts",
-      "duration": 24000
-    },
     {
       "spec": "cypress/e2e/profit-estimator.cy.ts",
       "duration": 39450
diff --git a/packages/db/src/backfill-gpu-metrics.test.ts b/packages/db/src/backfill-gpu-metrics.test.ts
deleted file mode 100644
index 8ad63bf29..000000000
--- a/packages/db/src/backfill-gpu-metrics.test.ts
+++ /dev/null
@@ -1,1200 +0,0 @@
-/**
- * Candidate-selection and real persistence tests for the gpu_metrics backfill CLI.
- *
- * The script owns its `sql` handle and calls `runBackfillMain` at import time,
- * so the seam here is the module boundary: `createAdminSql` is redirected at a
- * PGlite database that has the real migrations applied, `runBackfillMain`
- * captures `main` instead of running it, and `listRunArtifacts` records which
- * runs the CLI actually reached. Downloads copy local fixture directories;
- * mapping, ingest transactions and receipt queries run for real without GitHub.
- */
-
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { PGlite } from '@electric-sql/pglite';
-import type postgres from 'postgres';
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import type * as DbUtilsModule from './etl/db-utils';
-import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest';
-import {
-  benchmarkPublicationIdentity,
-  type PowerPublicationManifest,
-} from './etl/power-publication';
-import {
-  readTelemetryReceipt,
-  verifyTelemetryApi,
-  type TelemetryReceipt,
-} from './etl/telemetry-receipt';
-import { NonRetryableArtifactError } from './lib/artifact-retry';
-import { readMappedBenchmarkRows } from './lib/benchmark-result-lookup';
-import type * as BackfillRunnerModule from './lib/backfill-runner';
-import type * as GithubArtifactsModule from './lib/github-artifacts';
-import type { ArtifactMeta } from './lib/github-artifacts';
-
-type Sql = postgres.Sql;
-let db: PGlite;
-let sql: Sql;
-let main: () => Promise<void>;
-const listedRunIds: string[] = [];
-const retainedArtifacts = new Map<string, ArtifactMeta[]>();
-const artifactSources = new Map<string, string>();
-const downloadFailures = new Set<string>();
-const downloadedNames: string[] = [];
-const roots: string[] = [];
-/** GitHub run ids whose artifact listing should 404 (the run was deleted). */
-const goneRunIds = new Set<string>();
-const latestRunAttempts = new Map<string, number>();
-const originalArgv = process.argv;
-const originalExitCode = process.exitCode;
-
-vi.mock('./etl/db-utils.js', async (importOriginal) => ({
-  ...(await importOriginal<typeof DbUtilsModule>()),
-  createAdminSql: () => sql,
-}));
-
-vi.mock('./lib/github-artifacts.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof GithubArtifactsModule>();
-  return {
-    ...actual,
-    fetchRunMeta: (_repository: string, runId: string) => ({
-      id: Number(runId),
-      name: 'Run Sweep',
-      path: '.github/workflows/run-sweep.yml',
-      run_attempt: latestRunAttempts.get(runId) ?? 1,
-      run_started_at: '2026-09-01T00:00:00Z',
-      head_sha: 'local-fixture',
-      head_branch: 'main',
-      status: 'completed',
-      conclusion: 'success',
-    }),
-    downloadArtifact: (artifact: ArtifactMeta, tempDir: string) => {
-      downloadedNames.push(artifact.name);
-      const source = artifactSources.get(artifact.name);
-      if (!source || downloadFailures.has(artifact.name))
-        throw new NonRetryableArtifactError(`Fixture download unavailable: ${artifact.name}`);
-      const destination = path.join(tempDir, artifact.name);
-      fs.cpSync(source, destination, { recursive: true });
-      return destination;
-    },
-    listRunArtifacts: (repository: string, runId: string): Promise<ArtifactMeta[]> => {
-      listedRunIds.push(runId);
-      if (goneRunIds.has(runId)) {
-        return Promise.reject(new actual.WorkflowRunNotFoundError(repository, runId));
-      }
-      return Promise.resolve(retainedArtifacts.get(runId) ?? []);
-    },
-  };
-});
-
-vi.mock('./lib/backfill-runner.js', async (importOriginal) => ({
-  ...(await importOriginal<typeof BackfillRunnerModule>()),
-  runBackfillMain: (_name: string, _sql: Sql, entry: () => Promise<void>) => {
-    main = entry;
-  },
-}));
-
-function queryClient(database: Pick<PGlite, 'query'>) {
-  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
-    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
-    const result = await database.query(query, values);
-    return result.rows;
-  };
-  return Object.assign(client, { json: JSON.stringify, array: (value: unknown) => value });
-}
-
-const daysAgo = (days: number): string =>
-  new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
-
-const FRESH_NO_SERIES = 34000000001;
-const FRESH_WITH_SERIES = 34000000002;
-const STALE_WITH_SERIES = 34000000003;
-const FRESH_NO_BENCHMARKS = 34000000004;
-
-/** Run the CLI in --dry-run and report which GitHub run ids it selected, in order. */
-async function selectedRuns(...args: string[]): Promise<number[]> {
-  listedRunIds.length = 0;
-  process.argv = ['bun', 'src/backfill-gpu-metrics.ts', '--dry-run', ...args];
-  await main();
-  return listedRunIds.map(Number);
-}
-
-beforeAll(async () => {
-  db = await PGlite.create();
-  const migrations = new URL('../migrations/', import.meta.url);
-  for (const name of fs.readdirSync(migrations).toSorted())
-    if (name.endsWith('.sql')) await db.exec(fs.readFileSync(new URL(name, migrations), 'utf8'));
-  sql = Object.assign(queryClient(db), {
-    begin: (fn: (tx: Sql) => Promise<unknown>) =>
-      db.transaction((tx) => fn(queryClient(tx) as unknown as Sql)),
-  }) as unknown as Sql;
-  await import('./backfill-gpu-metrics');
-  expect(typeof main).toBe('function');
-}, 20_000);
-
-afterAll(async () => {
-  process.argv = originalArgv;
-  await db?.close();
-});
-
-afterEach(() => {
-  process.exitCode = originalExitCode;
-  vi.unstubAllEnvs();
-  vi.restoreAllMocks();
-  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
-});
-
-/**
- * Four runs covering each axis of the candidate filter: fresh/stale relative to
- * GitHub's 90-day artifact retention, with/without an already-stored series, and
- * one run that produced no benchmark rows at all.
- */
-beforeEach(async () => {
-  listedRunIds.length = 0;
-  goneRunIds.clear();
-  retainedArtifacts.clear();
-  artifactSources.clear();
-  downloadFailures.clear();
-  downloadedNames.length = 0;
-  latestRunAttempts.clear();
-  vi.spyOn(console, 'log').mockImplementation(() => {});
-  vi.spyOn(console, 'error').mockImplementation(() => {});
-  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
-    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, html_url, created_at, date)
-    VALUES (1, ${FRESH_NO_SERIES}, 1, 'Run Sweep', null, now(), '${daysAgo(10)}'),
-           (2, ${FRESH_WITH_SERIES}, 1, 'Run Sweep', null, now(), '${daysAgo(10)}'),
-           (3, ${STALE_WITH_SERIES}, 1, 'Run Sweep', null, now(), '${daysAgo(100)}'),
-           (4, ${FRESH_NO_BENCHMARKS}, 1, 'Run Sweep', null, now(), '${daysAgo(10)}');
-
-    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
-      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
-    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 8, 8, 8, 8);
-
-    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
-      isl, osl, conc, metrics)
-    VALUES (10, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 32, '{}'),
-           (11, 2, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 32, '{}'),
-           (12, 3, 1, 'single_turn', '${daysAgo(100)}', 8192, 1024, 32, '{}');
-
-    INSERT INTO gpu_metric_series (workflow_run_id, artifact_name, config_key, file_name,
-      vendor, csv_sha256, sample_count, gpu_count, started_at, ended_at)
-    VALUES (2, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
-              'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'gpu_metrics.csv', 'nvidia', 'sha-2',
-              1, 8, now(), now()),
-           (3, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
-              'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'gpu_metrics.csv', 'nvidia', 'sha-3',
-              1, 8, now(), now());`);
-});
-
-describe('attempt selection', () => {
-  beforeEach(async () => {
-    await db.exec(`
-      INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
-      VALUES (5, ${FRESH_NO_SERIES}, 2, 'Run Sweep', now(), '${daysAgo(10)}');
-      INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
-        isl, osl, conc, metrics)
-      VALUES (13, 5, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 32, '{}');
-    `);
-    latestRunAttempts.set(String(FRESH_NO_SERIES), 2);
-  });
-
-  it('selects only the latest persisted attempt by default', async () => {
-    expect(await selectedRuns('--run', String(FRESH_NO_SERIES))).toEqual([FRESH_NO_SERIES]);
-  });
-
-  it('selects an explicit matching attempt and does not substitute an absent attempt', async () => {
-    expect(await selectedRuns('--run', String(FRESH_NO_SERIES), '--attempt', '2')).toEqual([
-      FRESH_NO_SERIES,
-    ]);
-    await expect(selectedRuns('--run', String(FRESH_NO_SERIES), '--attempt', '3')).rejects.toThrow(
-      'No persisted benchmark target',
-    );
-  });
-
-  it('rejects historical-attempt recovery against the latest GitHub artifact listing', async () => {
-    const before = await db.query('select id, workflow_run_id from benchmark_results order by id');
-    await expect(selectedRuns('--run', String(FRESH_NO_SERIES), '--attempt', '1')).rejects.toThrow(
-      'GitHub attempt 2 differs from target 1; refusing mixed-attempt',
-    );
-    expect(listedRunIds).toEqual([String(FRESH_NO_SERIES)]);
-    const after = await db.query('select id, workflow_run_id from benchmark_results order by id');
-    expect(after.rows).toEqual(before.rows);
-  });
-
-  it('continues a bulk dry run after one metadata mismatch and reports a failed run', async () => {
-    latestRunAttempts.set(String(FRESH_WITH_SERIES), 2);
-    expect(await selectedRuns('--all', '--force')).toEqual([FRESH_WITH_SERIES, FRESH_NO_SERIES]);
-    expect(process.exitCode).toBe(1);
-    const errors = vi.mocked(console.error).mock.calls.map((call) => call.join(' '));
-    expect(errors).toContainEqual(expect.stringContaining(`run ${FRESH_WITH_SERIES}`));
-    expect(errors).toContainEqual(expect.stringContaining('refusing mixed-attempt'));
-    const lines = vi.mocked(console.log).mock.calls.map((call) => call.join(' '));
-    expect(lines).toContainEqual(expect.stringContaining(`run ${FRESH_NO_SERIES}`));
-    expect(lines.at(-1)).toContain('1 failed');
-  });
-});
-
-describe('candidate selection', () => {
-  it('defaults --since to GitHub 90-day artifact retention window', async () => {
-    // --force removes the series filter, isolating the date cutoff. The 100-day-old
-    // run is unreachable on GitHub, so it must not be queued.
-    expect(await selectedRuns('--all', '--force')).toEqual([FRESH_WITH_SERIES, FRESH_NO_SERIES]);
-  });
-
-  it('reaches past the retention window when --since is given explicitly', async () => {
-    expect(await selectedRuns('--all', '--force', '--since', '2020-01-01')).toEqual([
-      FRESH_WITH_SERIES,
-      FRESH_NO_SERIES,
-      STALE_WITH_SERIES,
-    ]);
-  });
-
-  it('resume hazard: a run that stored any series is skipped on a rerun without --force', async () => {
-    // An interrupted backfill leaves a run with one of its several artifacts
-    // stored. Re-invoking --all silently treats that run as finished.
-    expect(await selectedRuns('--all')).toEqual([FRESH_NO_SERIES]);
-  });
-
-  it('a run GitHub has deleted is reported and skipped, not fatal for the sweep', async () => {
-    // GitHub 404s the artifact listing once a run is deleted (or purged past
-    // retention). One such run must not abort a months-long --all pass.
-    goneRunIds.add(String(FRESH_WITH_SERIES));
-    expect(await selectedRuns('--all', '--force')).toEqual([FRESH_WITH_SERIES, FRESH_NO_SERIES]);
-    const lines = vi.mocked(console.log).mock.calls.map((call) => call.join(' '));
-    expect(lines).toContainEqual(expect.stringContaining(`run ${FRESH_WITH_SERIES}`));
-    expect(lines).toContainEqual(expect.stringContaining('gone from GitHub'));
-    expect(lines.at(-1)).toContain('1 gone from GitHub');
-  });
-
-  it('--run bypasses both the retention cutoff and the already-has-series filter', async () => {
-    expect(await selectedRuns('--run', String(STALE_WITH_SERIES))).toEqual([STALE_WITH_SERIES]);
-  });
-
-  it('--run still requires the run to have benchmark rows to attach telemetry to', async () => {
-    expect(await selectedRuns('--run', String(FRESH_NO_BENCHMARKS))).toEqual([]);
-  });
-
-  it('--from-run raises the GitHub run id floor', async () => {
-    expect(await selectedRuns('--all', '--force', '--from-run', String(FRESH_WITH_SERIES))).toEqual(
-      [FRESH_WITH_SERIES],
-    );
-  });
-
-  it('--limit truncates the ordered candidate list', async () => {
-    expect(await selectedRuns('--all', '--force', '--limit', '1')).toEqual([FRESH_WITH_SERIES]);
-  });
-
-  it('accepts --shard-count/--shard-index but does not partition the candidate set', async () => {
-    // Unlike the other sharded backfills, this script never applies the shard to
-    // its query, so every shard process would download the same artifacts.
-    const unsharded = await selectedRuns('--all', '--force');
-    for (const shardIndex of ['0', '1', '2', '3']) {
-      expect(
-        await selectedRuns('--all', '--force', '--shard-count', '4', '--shard-index', shardIndex),
-      ).toEqual(unsharded);
-    }
-  });
-});
-
-describe('flag validation', () => {
-  it('refuses to run without a run selector', async () => {
-    process.argv = ['bun', 'src/backfill-gpu-metrics.ts', '--dry-run'];
-    await expect(main()).rejects.toThrow('Pass --run <github run id> or --all');
-    expect(listedRunIds).toEqual([]);
-  });
-
-  it.each([
-    { args: ['--all', '--since', '09/01/2026'], message: '--since requires a YYYY-MM-DD date' },
-    { args: ['--all', '--parallel', '0'], message: '--parallel requires a positive integer' },
-    { args: ['--run', '0'], message: '--run requires a positive integer' },
-    {
-      args: ['--run', String(FRESH_NO_SERIES), '--attempt', '0'],
-      message: '--attempt requires a positive integer',
-    },
-    {
-      args: ['--all', '--attempt', '2'],
-      message: '--attempt, --artifact and --receipt require --run',
-    },
-  ])('rejects $args', async ({ args, message }) => {
-    process.argv = ['bun', 'src/backfill-gpu-metrics.ts', '--dry-run', ...args];
-    await expect(main()).rejects.toThrow(message);
-    expect(listedRunIds).toEqual([]);
-  });
-});
-
-function fixtureArtifact(name: string, files: Record<string, string>): ArtifactMeta {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'backfill-telemetry-fixture-'));
-  roots.push(root);
-  for (const [file, content] of Object.entries(files)) {
-    fs.mkdirSync(path.dirname(path.join(root, file)), { recursive: true });
-    fs.writeFileSync(path.join(root, file), content);
-  }
-  artifactSources.set(name, root);
-  return { name, archive_download_url: `fixture://${name}`, created_at: '2026-09-02T00:00:00Z' };
-}
-
-function benchmarkArtifact(suffix: string, concs = [32]): ArtifactMeta {
-  return fixtureArtifact(`bmk_${suffix}`, {
-    'results.json': JSON.stringify(
-      concs.map((conc) => ({
-        infmax_model_prefix: 'dsr1',
-        hw: 'b200-nv',
-        framework: 'sglang',
-        precision: 'fp4',
-        isl: 8192,
-        osl: 1024,
-        conc,
-        tp: 8,
-        ep: 1,
-        dp_attention: false,
-        tput_per_gpu: 1234.5,
-      })),
-    ),
-  });
-}
-
-const TELEMETRY_CSV =
-  'timestamp, index, power.draw [W]\n2026/09/02 00:00:00.000, 0, 100 W\n2026/09/02 00:00:01.000, 0, 200 W';
-function telemetryArtifact(suffix: string, csv = TELEMETRY_CSV): ArtifactMeta {
-  return fixtureArtifact(`gpu_metrics_${suffix}`, { 'gpu_metrics.csv': csv });
-}
-
-function receiptFile(): string {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'backfill-telemetry-receipt-'));
-  roots.push(root);
-  return path.join(root, 'power-publication.json');
-}
-
-async function recover(receipt: string, artifact?: string, attempt = 1): Promise<TelemetryReceipt> {
-  process.exitCode = 0;
-  process.argv = [
-    'bun',
-    'src/backfill-gpu-metrics.ts',
-    '--run',
-    String(FRESH_NO_SERIES),
-    '--attempt',
-    String(attempt),
-    '--receipt',
-    receipt,
-    '--parallel',
-    '1',
-    '--yes',
-    ...(artifact ? ['--artifact', artifact] : []),
-  ];
-  await main();
-  return (JSON.parse(fs.readFileSync(receipt, 'utf8')) as PowerPublicationManifest).telemetry!;
-}
-
-describe('targeted recovery receipts', () => {
-  it.each([true, false])(
-    'counts a unique historical offload fallback once with paired=%s',
-    async (paired) => {
-      await db.exec("UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10");
-      const bmk = benchmarkArtifact('historical');
-      const gpu = telemetryArtifact('historical');
-      retainedArtifacts.set(String(FRESH_NO_SERIES), paired ? [bmk, gpu] : [bmk]);
-      const receiptPath = receiptFile();
-      for (let attempt = 0; attempt < 2; attempt++) {
-        const receipt = await recover(receiptPath);
-        expect(receipt.counts).toMatchObject({ expectedPoints: 1, linkedPoints: paired ? 1 : 0 });
-        expect(receipt.points).toHaveLength(1);
-        expect(receipt.points[0]).toMatchObject({
-          benchmarkResultId: 10,
-          identity: { offload_mode: 'on' },
-          produced: paired,
-          reasons: paired ? [] : ['artifact_missing', 'series_not_stored'],
-        });
-      }
-      const count = await db.query(
-        'SELECT count(*)::int AS count FROM benchmark_result_gpu_metrics',
-      );
-      expect(count.rows).toEqual([{ count: paired ? 1 : 0 }]);
-    },
-  );
-
-  it('keeps real offload on/off points separate and leaves ambiguous fallback candidates unlinked', async () => {
-    await db.exec(`INSERT INTO benchmark_results
-      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, offload_mode, metrics)
-      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 32, 'on', '{}')`);
-    const bmk = benchmarkArtifact('offload');
-    const file = path.join(artifactSources.get(bmk.name)!, 'results.json');
-    const [raw] = JSON.parse(fs.readFileSync(file, 'utf8'));
-    fs.writeFileSync(file, JSON.stringify([raw, { ...raw, offload_mode: 'on' }]));
-    const gpu = telemetryArtifact('offload');
-    retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
-    const exact = await recover(receiptFile());
-    expect(exact.counts).toMatchObject({ expectedPoints: 2, linkedPoints: 2, storedSeries: 1 });
-    expect(exact.points.map((p) => p.benchmarkResultId).toSorted()).toEqual([10, 14]);
-    expect(exact.points.map((p) => p.identity.offload_mode).toSorted()).toEqual(['off', 'on']);
-
-    await db.exec(
-      "TRUNCATE gpu_metric_series CASCADE; UPDATE benchmark_results SET offload_mode = 'dram' WHERE id = 10",
-    );
-    fs.writeFileSync(file, JSON.stringify([raw]));
-    const ambiguous = await recover(receiptFile());
-    expect(process.exitCode).toBe(1);
-    expect(ambiguous.counts.linkedPoints).toBe(0);
-    expect(ambiguous.points.find((p) => p.identity.offload_mode === 'off')).toMatchObject({
-      benchmarkResultId: null,
-      error: expect.stringContaining('no matching benchmark rows'),
-    });
-    const links = await db.query('SELECT * FROM benchmark_result_gpu_metrics');
-    expect(links.rows).toEqual([]);
-  });
-
-  it.each([true, false])(
-    'removes only a proven prior offload phantom on paired=%s retry',
-    async (paired) => {
-      await db.exec(`UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10;
-      INSERT INTO benchmark_results
-      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
-      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 64, '{}')`);
-      const bmk = benchmarkArtifact('historical');
-      const gpu = telemetryArtifact('historical');
-      const otherBmk = benchmarkArtifact('unrelated', [64]);
-      const otherGpu = telemetryArtifact('unrelated');
-      retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu, otherBmk, otherGpu]);
-      // Build the old receipt through the real reader without fallback metadata.
-      const old = await readTelemetryReceipt(sql, { runId: FRESH_NO_SERIES, runAttempt: 1 }, [
-        {
-          identity: benchmarkPublicationIdentity(
-            readMappedBenchmarkRows(artifactSources.get(bmk.name)!)[0]!,
-          ),
-          artifactNames: [gpu.name, 'power_audit_historical'],
-          produced: false,
-        },
-      ]);
-      expect(old.points).toHaveLength(3);
-      const unrelated = point(old, 14);
-      unrelated.error = 'unrelated failure';
-      unrelated.api = { status: 'readable' };
-      unrelated.reasons.push('ingest_failed');
-      const receiptPath = receiptFile();
-      fs.writeFileSync(
-        receiptPath,
-        JSON.stringify({
-          version: 1,
-          runId: FRESH_NO_SERIES,
-          runAttempt: 1,
-          points: [],
-          telemetry: old,
-        }),
-      );
-      retainedArtifacts.set(
-        String(FRESH_NO_SERIES),
-        paired ? [bmk, gpu, otherBmk, otherGpu] : [bmk, otherBmk, otherGpu],
-      );
-      for (let attempt = 0; attempt < 2; attempt++) {
-        const repaired = await recover(receiptPath, gpu.name);
-        expect(repaired.counts.expectedPoints).toBe(2);
-        expect(repaired.points.map((p) => p.benchmarkResultId).toSorted()).toEqual([10, 14]);
-        expect(point(repaired, 14)).toEqual(unrelated);
-        expect(point(repaired, 10)).toMatchObject({
-          identity: { offload_mode: 'on' },
-          produced: paired,
-        });
-      }
-    },
-  );
-
-  it('clears a legacy run recovery error after a full unique-offload repair without retaining its phantom', async () => {
-    await db.exec("UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10");
-    const bmk = benchmarkArtifact('historical');
-    const gpu = telemetryArtifact('historical');
-    retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
-    const old = await readTelemetryReceipt(sql, { runId: FRESH_NO_SERIES, runAttempt: 1 }, [
-      {
-        identity: benchmarkPublicationIdentity(
-          readMappedBenchmarkRows(artifactSources.get(bmk.name)!)[0]!,
-        ),
-        artifactNames: [gpu.name],
-        produced: true,
-      },
-    ]);
-    old.recoveryError = 'previous full-run failure';
-    const receiptPath = receiptFile();
-    fs.writeFileSync(
-      receiptPath,
-      JSON.stringify({
-        version: 1,
-        runId: FRESH_NO_SERIES,
-        runAttempt: 1,
-        points: [],
-        telemetry: old,
-      }),
-    );
-    const repaired = await recover(receiptPath);
-    expect(repaired.recoveryError).toBeUndefined();
-    expect(repaired.counts.expectedPoints).toBe(1);
-    await verifyTelemetryApi(repaired, 'http://local.test', {
-      fetch: () =>
-        Promise.resolve(
-          Response.json({
-            benchmarkResultId: 10,
-            series: point(repaired, 10).series.map((series) => ({
-              ...series,
-              data: [{ power: 100 }, { power: 200 }],
-            })),
-          }),
-        ),
-    });
-    expect(repaired.counts).toMatchObject({ apiReadablePoints: 1, apiCompletePoints: 1 });
-  });
-
-  it.each([
-    { paired: true, invalid: 'unmapped' },
-    { paired: true, invalid: 'non-object' },
-    { paired: false, invalid: 'unmapped' },
-    { paired: false, invalid: 'non-object' },
-  ])(
-    'retains unknown expectations for $invalid rows with paired=$paired',
-    async ({ paired, invalid }) => {
-      const bmk = benchmarkArtifact('point1');
-      const gpu = telemetryArtifact('point1');
-      retainedArtifacts.set(String(FRESH_NO_SERIES), paired ? [bmk, gpu] : [bmk]);
-      const file = path.join(artifactSources.get(bmk.name)!, 'results.json');
-      const [valid] = JSON.parse(fs.readFileSync(file, 'utf8'));
-      const receiptPath = receiptFile();
-      fs.writeFileSync(file, '{broken');
-      const broken = await recover(receiptPath);
-      expect(broken.counts.expectedPoints).toBeNull();
-
-      fs.writeFileSync(
-        file,
-        JSON.stringify([
-          valid,
-          invalid === 'unmapped'
-            ? { ...valid, conc: 64, infmax_model_prefix: 'unknown-model' }
-            : 42,
-          null,
-        ]),
-      );
-      const partial = await recover(receiptPath);
-      expect(partial.counts.expectedPoints).toBeNull();
-      expect(process.exitCode).toBe(1);
-      expect(partial.expectationErrors).toEqual(
-        [2, 3].map((row) =>
-          expect.objectContaining({
-            benchmarkArtifact: bmk.name,
-            artifactNames: expect.arrayContaining([gpu.name]),
-            error: `Unmappable benchmark row: results.json row ${row}`,
-          }),
-        ),
-      );
-      const summary = vi
-        .mocked(console.log)
-        .mock.calls.map((call) => call.join(' '))
-        .findLast((line) => line.startsWith('\n=== backfill complete:'));
-      expect(summary).toContain('1 failed artifact(s), 0 failed run(s)');
-      expect(point(partial, 10)).toMatchObject({
-        produced: paired,
-        storage: { status: paired ? 'complete' : 'incomplete' },
-      });
-      expect(point(partial, 10).error).toBeUndefined();
-      expect(partial.counts.apiCompletePoints).toBe(0);
-
-      await db.exec(`INSERT INTO benchmark_results
-      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
-      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 64, '{}')`);
-      fs.writeFileSync(file, JSON.stringify([valid, { ...valid, conc: 64 }]));
-      const repaired = await recover(receiptPath);
-      expect(process.exitCode).toBe(0);
-      expect(repaired.expectationErrors).toEqual([]);
-      expect(repaired.counts).toMatchObject({ expectedPoints: 2, storedPoints: paired ? 2 : 0 });
-    },
-  );
-
-  it.each(['download', 'parse'])(
-    'records a paired benchmark %s failure as an unknown expectation',
-    async (failure) => {
-      const bmk = benchmarkArtifact('point1');
-      const gpu = telemetryArtifact('point1');
-      retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
-      if (failure === 'download') downloadFailures.add(bmk.name);
-      else fs.writeFileSync(path.join(artifactSources.get(bmk.name)!, 'results.json'), '{broken');
-      const receipt = await recover(receiptFile(), gpu.name);
-      expect(process.exitCode).toBe(1);
-      expect(receipt.expectationErrors).toEqual([
-        {
-          benchmarkArtifact: bmk.name,
-          artifactNames: [gpu.name],
-          error: expect.any(String),
-        },
-      ]);
-      expect(receipt.counts.expectedPoints).toBeNull();
-      expect(receipt.counts.apiCompletePoints).toBe(0);
-    },
-  );
-
-  it('records a missing GitHub run as failed recovery instead of a successful empty backfill', async () => {
-    goneRunIds.add(String(FRESH_NO_SERIES));
-    const receipt = await recover(receiptFile(), 'gpu_metrics_point1');
-    expect(process.exitCode).toBe(1);
-    expect(receipt.recoveryError).toContain('gone from GitHub');
-    expect(receipt.recoveryArtifactNames).toEqual(['gpu_metrics_point1']);
-    expect(receipt.counts.apiCompletePoints).toBe(0);
-  });
-
-  it('keeps unknown expectations when a later full refresh cannot recover the failed sibling', async () => {
-    const broken = benchmarkArtifact('unreadable');
-    const gpu = telemetryArtifact('unreadable');
-    const good = benchmarkArtifact('point1');
-    const goodGpu = telemetryArtifact('point1');
-    retainedArtifacts.set(String(FRESH_NO_SERIES), [broken, gpu, good, goodGpu]);
-    fs.writeFileSync(path.join(artifactSources.get(broken.name)!, 'results.json'), '{broken');
-    const receiptPath = receiptFile();
-    const failed = await recover(receiptPath);
-    expect(failed.counts.expectedPoints).toBeNull();
-    retainedArtifacts.set(String(FRESH_NO_SERIES), [good, goodGpu]);
-    const refreshed = await recover(receiptPath);
-    expect(refreshed.expectationErrors).toEqual(failed.expectationErrors);
-    expect(refreshed.counts.expectedPoints).toBeNull();
-  });
-
-  it('does not accept readable old data after a corrective artifact contains no parseable telemetry', async () => {
-    const bmk = benchmarkArtifact('point1');
-    const gpu = telemetryArtifact('point1');
-    retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
-    const receiptPath = receiptFile();
-    const original = await recover(receiptPath, gpu.name);
-    expect(original.counts.storedPoints).toBe(1);
-    fs.writeFileSync(path.join(artifactSources.get(gpu.name)!, 'gpu_metrics.csv'), '');
-    const failed = await recover(receiptPath, gpu.name);
-    expect(process.exitCode).toBe(1);
-    expect(failed.points[0]).toMatchObject({
-      error: expect.stringContaining('no parseable gpu_metrics CSV'),
-      reasons: ['ingest_failed'],
-      storage: { status: 'complete' },
-    });
-    await verifyTelemetryApi(failed, 'http://local.test', {
-      fetch: () =>
-        Promise.resolve(
-          Response.json({
-            benchmarkResultId: 10,
-            series: original.points[0]!.series.map((series) => ({
-              ...series,
-              data: [{ power: 100 }, { power: 200 }],
-            })),
-          }),
-        ),
-    });
-    expect(failed.counts).toMatchObject({
-      storedPoints: 1,
-      apiReadablePoints: 1,
-      apiCompletePoints: 0,
-    });
-  });
-
-  it('retains both failed targets until each is repaired', async () => {
-    await db.exec(`INSERT INTO benchmark_results
-      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
-      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 64, '{}')`);
-    const a = telemetryArtifact('point1');
-    const b = telemetryArtifact('point2');
-    const artifacts = [benchmarkArtifact('point1'), benchmarkArtifact('point2', [64])];
-    retainedArtifacts.set(String(FRESH_NO_SERIES), artifacts);
-    const receiptPath = receiptFile();
-    await recover(receiptPath, a.name);
-    let receipt = await recover(receiptPath, b.name);
-    expect(receipt.recoveryArtifactNames).toEqual([a.name, b.name]);
-    expect(receipt.recoveryError).toContain(a.name);
-    expect(receipt.recoveryError).toContain(b.name);
-    artifacts.push(b);
-    receipt = await recover(receiptPath, b.name);
-    expect(receipt.recoveryArtifactNames).toEqual([a.name]);
-    expect(receipt.recoveryError).toContain(a.name);
-    artifacts.push(a);
-    receipt = await recover(receiptPath, a.name);
-    expect(receipt.recoveryArtifactNames).toBeUndefined();
-    expect(receipt.recoveryError).toBeUndefined();
-  });
-
-  it.each([
-    { name: 'fully unmatched', concs: [64] },
-    { name: 'partially unmatched', concs: [32, 64] },
-  ])(
-    'keeps a $name correction failed until its benchmark target is persisted',
-    async ({ concs }) => {
-      await db.exec(`INSERT INTO benchmark_results
-      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
-      VALUES (15, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 96, '{}')`);
-      const bmk = benchmarkArtifact('point1');
-      const gpu = telemetryArtifact('point1');
-      const unrelated = telemetryArtifact('unrelated');
-      retainedArtifacts.set(String(FRESH_NO_SERIES), [
-        bmk,
-        gpu,
-        benchmarkArtifact('unrelated', [96]),
-        unrelated,
-      ]);
-      const receiptPath = receiptFile();
-      const original = await recover(receiptPath);
-      for (const receiptPoint of original.points) receiptPoint.api = { status: 'readable' };
-      const manifest = JSON.parse(fs.readFileSync(receiptPath, 'utf8'));
-      manifest.telemetry = original;
-      fs.writeFileSync(receiptPath, JSON.stringify(manifest));
-      const storedBefore = await db.query(
-        'SELECT * FROM gpu_metric_samples ORDER BY series_id, sampled_at',
-      );
-      const unrelatedBefore = point(original, 15);
-
-      goneRunIds.add(String(FRESH_NO_SERIES));
-      const missing = await recover(receiptPath, gpu.name);
-      expect(missing.recoveryArtifactNames).toEqual([gpu.name]);
-      expect(missing.counts.apiCompletePoints).toBe(0);
-      goneRunIds.clear();
-      benchmarkArtifact('point1', concs);
-      downloadedNames.length = 0;
-      const unmatched = await recover(receiptPath, gpu.name);
-      expect(unmatched.recoveryError).toBe(missing.recoveryError);
-      expect(unmatched.recoveryArtifactNames).toEqual([gpu.name]);
-      expect(process.exitCode).toBe(1);
-      expect(downloadedNames).toEqual([bmk.name]);
-      expect(
-        unmatched.points.find((receiptPoint) => receiptPoint.identity.conc === 64),
-      ).toMatchObject({
-        produced: true,
-        benchmarkResultId: null,
-        error: expect.stringContaining('no matching benchmark rows'),
-        reasons: expect.arrayContaining(['ingest_failed', 'benchmark_not_stored']),
-      });
-      expect(unmatched.counts.apiCompletePoints).toBe(0);
-      if (concs.includes(32)) {
-        expect(point(unmatched, 10)).toMatchObject({
-          storage: { status: 'complete' },
-          error: expect.stringContaining('no matching benchmark rows'),
-          reasons: ['ingest_failed'],
-        });
-      } else expect(point(unmatched, 10)).toEqual(point(missing, 10));
-      expect(point(unmatched, 15)).toEqual(unrelatedBefore);
-      expect(
-        await db.query('SELECT * FROM gpu_metric_samples ORDER BY series_id, sampled_at'),
-      ).toEqual(storedBefore);
-
-      await db.exec(`INSERT INTO benchmark_results
-      (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
-      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 64, '{}')`);
-      const repaired = await recover(receiptPath, gpu.name);
-      expect(process.exitCode).toBe(0);
-      expect(repaired.recoveryError).toBeUndefined();
-      expect(repaired.recoveryArtifactNames).toBeUndefined();
-      expect(point(repaired, 14)).toMatchObject({
-        produced: true,
-        storage: { status: 'complete' },
-        reasons: [],
-      });
-      expect(point(repaired, 14).error).toBeUndefined();
-      if (concs.includes(32)) {
-        expect(point(repaired, 10).reasons).toEqual([]);
-        expect(point(repaired, 10).error).toBeUndefined();
-      } else expect(point(repaired, 10)).toEqual(point(missing, 10));
-      expect(point(repaired, 15)).toEqual(unrelatedBefore);
-      expect(
-        await db.query('SELECT * FROM gpu_metric_samples ORDER BY series_id, sampled_at'),
-      ).toEqual(storedBefore);
-    },
-  );
-
-  it('rejects an absent explicit target without touching its receipt', async () => {
-    const receipt = receiptFile();
-    fs.writeFileSync(receipt, '{"preserve":"existing evidence"}');
-    await expect(recover(receipt, 'gpu_metrics_point1', 3)).rejects.toThrow(
-      'No persisted benchmark target',
-    );
-    expect(fs.readFileSync(receipt, 'utf8')).toBe('{"preserve":"existing evidence"}');
-    expect(downloadedNames).toEqual([]);
-  });
-});
-
-function point(value: TelemetryReceipt, id: number) {
-  return value.points.find((p) => p.benchmarkResultId === id)!;
-}
-
-describe('benchmark metadata cache recovery', () => {
-  const audit = {
-    source: 'power_validation_agentx.json',
-    window_start_unix: 10,
-    window_end_unix: 20,
-  };
-
-  async function pendingReceipt() {
-    vi.stubEnv('CACHE_INVALIDATE_URL', 'http://127.0.0.1:3137/api/v1/invalidate');
-    vi.stubEnv('CACHE_INVALIDATE_SECRET', 'local-test-secret');
-    await sql`UPDATE workflow_runs SET date = current_date WHERE id = 1`;
-    await sql`UPDATE benchmark_results SET power_audit = ${JSON.stringify(audit)}::jsonb, date = current_date WHERE id = 10`;
-    const file = receiptFile();
-    const [identity] =
-      await sql`SELECT c.*, br.id, br.benchmark_type, br.isl, br.osl, br.conc, br.offload_mode, br.recipe_fingerprint
-      FROM benchmark_results br JOIN configs c ON c.id = br.config_id WHERE br.id = 10`;
-    const manifest: PowerPublicationManifest = {
-      version: 1,
-      runId: FRESH_NO_SERIES,
-      runAttempt: 1,
-      points: [],
-      benchmarkRefresh: {
-        status: 'pending',
-        benchmarkResultIds: [10],
-        auditUpdates: [{ benchmarkResultId: 10, identity: identity!, powerAudit: audit }],
-        endpoint: 'http://127.0.0.1:3137/api/v1/invalidate',
-      },
-    };
-    fs.writeFileSync(file, JSON.stringify(manifest));
-    return file;
-  }
-
-  function successfulFetch() {
-    return vi
-      .spyOn(globalThis, 'fetch')
-      .mockImplementation((_url, init) =>
-        Promise.resolve(
-          Response.json(
-            init?.method === 'POST'
-              ? { invalidated: true, blobsDeleted: 1 }
-              : [{ id: 10, power_audit: audit }],
-          ),
-        ),
-      );
-  }
-
-  it.each([true, false])(
-    'checkpoints source evidence before metadata writes with configured=%s',
-    async (configured) => {
-      vi.stubEnv(
-        'CACHE_INVALIDATE_URL',
-        configured ? 'http://127.0.0.1:3137/api/v1/invalidate' : '',
-      );
-      vi.stubEnv('CACHE_INVALIDATE_SECRET', 'local-test-secret');
-      await sql`UPDATE benchmark_results SET benchmark_type = 'agentic_traces', isl = NULL, osl = NULL WHERE id = 10`;
-      const bmk = benchmarkArtifact('metadata');
-      const source = artifactSources.get(bmk.name)!;
-      const [raw] = JSON.parse(fs.readFileSync(path.join(source, 'results.json'), 'utf8'));
-      fs.writeFileSync(
-        path.join(source, 'results.json'),
-        JSON.stringify([{ ...raw, scenario_type: 'agentic-coding', users: 32 }]),
-      );
-      const expectedAudit = {
-        source: 'power_validation_metadata_conc32.json',
-        window_start_unix: 10,
-        window_end_unix: 20,
-      };
-      const gpu = fixtureArtifact('power_audit_metadata', {
-        'LOGS/power/samples.csv':
-          'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w\n1,10,0,host-a,0,GPU-0,100\n1,11,1,host-a,0,GPU-0,200',
-        'LOGS/power/manifest.json': JSON.stringify({ producer: 'srt-slurm.dcgm-power' }),
-        [expectedAudit.source]: JSON.stringify({
-          validation_path: 'LOGS/agentic/conc_32/power_validation.json',
-          result_file: 'metadata_conc32.json',
-          selected_window: { concurrency: 32, start_time_unix: 10, end_time_unix: 20 },
-        }),
-      });
-      retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
-      const [mapped] = readMappedBenchmarkRows(source);
-      const identity = benchmarkPublicationIdentity(mapped!);
-      await sql`UPDATE benchmark_results SET offload_mode = ${mapped!.offloadMode} WHERE id = 10`;
-      const original = {
-        identity,
-        metrics: { power_valid: 0, tput_per_gpu: 1234.5 },
-        workers: null,
-        power_invalid_reasons: ['original'],
-        power_audit: null,
-        artifact: { path: 'original.json', sha256: 'preserve-original-hash' },
-      };
-      const unrelated = { ...original, identity: { ...identity, conc: 64 } };
-      const file = receiptFile();
-      fs.writeFileSync(
-        file,
-        JSON.stringify({
-          version: 1,
-          runId: FRESH_NO_SERIES,
-          runAttempt: 1,
-          points: [original, unrelated],
-        }),
-      );
-      const request = vi
-        .spyOn(globalThis, 'fetch')
-        .mockImplementation((_url, init) =>
-          Promise.resolve(
-            Response.json(
-              init?.method === 'POST'
-                ? { invalidated: true, blobsDeleted: 1 }
-                : [{ id: 10, power_audit: expectedAudit }],
-            ),
-          ),
-        );
-      await recover(file, gpu.name);
-      const result: PowerPublicationManifest = JSON.parse(fs.readFileSync(file, 'utf8'));
-      expect(result.benchmarkRefresh?.status).toBe(configured ? 'complete' : 'failed');
-      expect(result.benchmarkRefresh?.auditUpdates?.[0]?.powerAudit).toEqual(expectedAudit);
-      expect(result.points).toEqual([
-        { ...original, power_audit: configured ? expectedAudit : null },
-        unrelated,
-      ]);
-      expect(await sql`SELECT power_audit FROM benchmark_results WHERE id = 10`).toEqual([
-        { power_audit: configured ? expectedAudit : null },
-      ]);
-      if (configured) expect(process.exitCode).toBe(0);
-      else {
-        expect(process.exitCode).toBe(1);
-        expect(request).not.toHaveBeenCalled();
-        expect(await sql`SELECT * FROM gpu_metric_samples`).toEqual([]);
-      }
-    },
-  );
-
-  it('refreshes a saved target without listing/downloading artifacts or changing telemetry', async () => {
-    const file = await pendingReceipt();
-    successfulFetch();
-    const before = await sql`SELECT * FROM gpu_metric_series ORDER BY id`;
-    process.argv = [
-      'bun',
-      'backfill-gpu-metrics.ts',
-      '--refresh-cache-only',
-      '--run',
-      String(FRESH_NO_SERIES),
-      '--attempt',
-      '1',
-      '--receipt',
-      file,
-      '--yes',
-    ];
-    await main();
-    expect(JSON.parse(fs.readFileSync(file, 'utf8')).benchmarkRefresh.status).toBe('complete');
-    expect(listedRunIds).toEqual([]);
-    expect(downloadedNames).toEqual([]);
-    expect(await sql`SELECT * FROM gpu_metric_series ORDER BY id`).toEqual(before);
-    expect(await sql`SELECT power_audit FROM latest_benchmarks WHERE id = 10`).toEqual([
-      { power_audit: audit },
-    ]);
-  });
-
-  it('retries a failed cache phase on unchanged ingest with zero sample rewrites', async () => {
-    const file = await pendingReceipt();
-    const bmk = benchmarkArtifact('metadata');
-    const gpu = telemetryArtifact('metadata');
-    retainedArtifacts.set(String(FRESH_NO_SERIES), [bmk, gpu]);
-    const request = successfulFetch();
-    request.mockResolvedValueOnce(new Response('unavailable', { status: 503 }));
-    await recover(file, gpu.name);
-    expect(process.exitCode).toBe(1);
-    expect(JSON.parse(fs.readFileSync(file, 'utf8')).benchmarkRefresh).toMatchObject({
-      status: 'failed',
-      benchmarkResultIds: [10],
-      error: 'invalidate cache: HTTP 503',
-    });
-    const before =
-      await sql`SELECT * FROM gpu_metric_samples ORDER BY series_id, sampled_at, gpu_index`;
-    await recover(file, gpu.name);
-    expect(process.exitCode).toBe(0);
-    expect(JSON.parse(fs.readFileSync(file, 'utf8')).benchmarkRefresh.status).toBe('complete');
-    expect(
-      await sql`SELECT * FROM gpu_metric_samples ORDER BY series_id, sampled_at, gpu_index`,
-    ).toEqual(before);
-    expect(
-      vi
-        .mocked(console.log)
-        .mock.calls.flat()
-        .some((line) => String(line).includes('+0 samples')),
-    ).toBe(true);
-  });
-
-  it('rejects a receipt for another run before any cache request or artifact download', async () => {
-    const file = await pendingReceipt();
-    const request = successfulFetch();
-    process.argv = [
-      'bun',
-      'backfill-gpu-metrics.ts',
-      '--refresh-cache-only',
-      '--run',
-      String(FRESH_WITH_SERIES),
-      '--receipt',
-      file,
-      '--yes',
-    ];
-    await expect(main()).rejects.toThrow('receipt run/attempt');
-    expect(request).not.toHaveBeenCalled();
-    expect(downloadedNames).toEqual([]);
-  });
-});
-
-describe('real persistence through the recovery CLI', () => {
-  it('repairs absent, failed and unlinked points separately without duplicating shared series or crossing attempts', async () => {
-    await db.exec(`
-      INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
-      VALUES (5, ${FRESH_NO_SERIES}, 2, 'Later attempt', now(), '${daysAgo(10)}');
-      INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
-      VALUES (14, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 64, '{}'),
-             (15, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 96, '{}'),
-             (16, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 128, '{}'),
-             (17, 1, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 160, '{}'),
-             (20, 5, 1, 'single_turn', '${daysAgo(10)}', 8192, 1024, 32, '{}');
-    `);
-    const benchmarks = [
-      benchmarkArtifact('absent', [32]),
-      benchmarkArtifact('failed', [64]),
-      benchmarkArtifact('unlinked', [96]),
-      benchmarkArtifact('shared', [128, 160]),
-    ];
-    const absent = telemetryArtifact('absent');
-    const failed = telemetryArtifact('failed', TELEMETRY_CSV.replaceAll(', 0,', ', 999999,'));
-    const unlinked = telemetryArtifact('unlinked');
-    const shared = telemetryArtifact('shared');
-    retainedArtifacts.set(String(FRESH_NO_SERIES), [...benchmarks, failed, unlinked, shared]);
-    const persisted = (artifact: ArtifactMeta, ids: number[], workflowRunId = 1) =>
-      ingestGpuMetricsArtifact(sql, {
-        workflowRunId,
-        artifact: { artifactName: artifact.name, artifactDir: artifactSources.get(artifact.name)! },
-        benchmarkResultIds: ids,
-      });
-    await persisted(unlinked, [15]);
-    await db.exec('DELETE FROM benchmark_result_gpu_metrics WHERE benchmark_result_id = 15');
-    await persisted(shared, [16, 17]);
-    await persisted(absent, [20], 5);
-
-    const observations = benchmarks.flatMap((bmk, index) =>
-      readMappedBenchmarkRows(artifactSources.get(bmk.name)!).map((row) => ({
-        identity: benchmarkPublicationIdentity(row),
-        artifactNames: [[absent, failed, unlinked, shared][index]!.name],
-        produced: index !== 0,
-      })),
-    );
-    const receiptPath = receiptFile();
-    const seed = await readTelemetryReceipt(
-      sql,
-      { runId: FRESH_NO_SERIES, runAttempt: 1 },
-      observations,
-      { expectedSource: 'benchmark_artifacts' },
-    );
-    fs.writeFileSync(
-      receiptPath,
-      JSON.stringify({
-        version: 1,
-        runId: FRESH_NO_SERIES,
-        runAttempt: 1,
-        points: [],
-        telemetry: seed,
-      } satisfies PowerPublicationManifest),
-    );
-
-    // Missing telemetry is discovered from the retained benchmark sibling.
-    let receipt = await recover(receiptPath, absent.name);
-    expect(process.exitCode).toBe(1);
-    expect(receipt.recoveryError).toContain(`No retained telemetry pair for ${absent.name}`);
-    expect(receipt.recoveryArtifactNames).toEqual([absent.name]);
-    // The failure is a real smallint violation inside the ingest transaction.
-    receipt = await recover(receiptPath, failed.name);
-    expect(process.exitCode).toBe(1);
-    expect(point(receipt, 10).reasons).toContain('artifact_missing');
-    expect(point(receipt, 14).reasons).toContain('ingest_failed');
-    expect(point(receipt, 14).error).toContain('smallint');
-    expect(receipt.recoveryError).toContain(`No retained telemetry pair for ${absent.name}`);
-    expect(receipt.recoveryArtifactNames).toEqual([absent.name]);
-    expect(point(receipt, 15).reasons).toContain('point_link_missing');
-    for (const [id, artifact] of [
-      [10, absent],
-      [14, failed],
-      [15, unlinked],
-    ] as const) {
-      expect(point(receipt, id).key).toBe(point(seed, id).key);
-      expect(point(receipt, id).recovery).toEqual({
-        runId: FRESH_NO_SERIES,
-        runAttempt: 1,
-        artifactNames: expect.arrayContaining([artifact.name]),
-      });
-    }
-    expect(receipt.counts).toMatchObject({
-      expectedPoints: 5,
-      producedPoints: 4,
-      producedArtifacts: 3,
-      storedPoints: 3,
-      linkedPoints: 2,
-      storedSeries: 2,
-      storedSamples: 4,
-      apiReadablePoints: 0,
-      apiCompletePoints: 0,
-      apiUnknownPoints: 5,
-    });
-    expect(receipt.plannedPointCount).toBeNull();
-
-    const storedState = async () => {
-      const result = await db.query<{
-        series: { artifact_name: string; workflow_run_id: number };
-      }>(`
-      SELECT to_jsonb(s) AS series,
-        (SELECT jsonb_agg(to_jsonb(x) ORDER BY x.gpu_index, x.sampled_at)
-          FROM gpu_metric_samples x WHERE x.series_id = s.id) AS samples,
-        (SELECT jsonb_agg(to_jsonb(x) ORDER BY x.gpu_index, x.metric)
-          FROM gpu_metric_gpu_stats x WHERE x.series_id = s.id) AS stats,
-        (SELECT jsonb_agg(to_jsonb(l) ORDER BY l.benchmark_result_id)
-          FROM benchmark_result_gpu_metrics l WHERE l.series_id = s.id) AS links
-      FROM gpu_metric_series s ORDER BY s.id
-    `);
-      return result.rows;
-    };
-    const protectedBefore = await storedState();
-    const benchmarksBefore = await db.query('SELECT * FROM benchmark_results ORDER BY id');
-
-    retainedArtifacts.get(String(FRESH_NO_SERIES))!.push(absent);
-    fs.writeFileSync(
-      path.join(artifactSources.get(failed.name)!, 'gpu_metrics.csv'),
-      TELEMETRY_CSV,
-    );
-    const repairCases = [
-      { artifact: absent, id: 10, stored: 4, linked: 3, series: 3, samples: 6 },
-      { artifact: failed, id: 14, stored: 5, linked: 4, series: 4, samples: 8 },
-      { artifact: unlinked, id: 15, stored: 5, linked: 5, series: 4, samples: 8 },
-    ];
-    for (const target of repairCases) {
-      const previous = receipt;
-      downloadedNames.length = 0;
-      receipt = await recover(receiptPath, target.artifact.name);
-      expect(process.exitCode).toBe(0);
-      expect(receipt.recoveryError).toBeUndefined();
-      expect(receipt.recoveryArtifactNames).toBeUndefined();
-      expect(downloadedNames).toEqual([
-        `bmk_${target.artifact.name.slice('gpu_metrics_'.length)}`,
-        target.artifact.name,
-      ]);
-      expect(point(receipt, target.id).reasons).toEqual([]);
-      expect(point(receipt, target.id).key).toBe(point(previous, target.id).key);
-      expect(receipt.points.filter((p) => p.benchmarkResultId !== target.id)).toEqual(
-        previous.points.filter((p) => p.benchmarkResultId !== target.id),
-      );
-      expect(receipt.counts).toMatchObject({
-        expectedPoints: 5,
-        producedArtifacts: 4,
-        storedPoints: target.stored,
-        linkedPoints: target.linked,
-        storedSeries: target.series,
-        storedSamples: target.samples,
-        apiReadablePoints: 0,
-        apiCompletePoints: 0,
-        apiUnknownPoints: 5,
-      });
-      const repairedState = await storedState();
-      const replay = await recover(receiptPath, target.artifact.name);
-      expect(replay.points).toEqual(receipt.points);
-      expect(await storedState()).toEqual(repairedState);
-    }
-    // Shared telemetry counts once; the other attempt and unrelated runs retain exact bytes.
-    const finalState = await storedState();
-    expect(
-      finalState.filter((row) => {
-        const series = row.series;
-        return series.workflow_run_id !== 1 || series.artifact_name === shared.name;
-      }),
-    ).toEqual(
-      protectedBefore.filter((row) => {
-        const series = row.series;
-        return series.artifact_name !== unlinked.name;
-      }),
-    );
-    const benchmarksAfter = await db.query('SELECT * FROM benchmark_results ORDER BY id');
-    expect(benchmarksAfter.rows).toEqual(benchmarksBefore.rows);
-    const otherAttemptLinks = await db.query(
-      'SELECT * FROM benchmark_result_gpu_metrics WHERE benchmark_result_id = 20',
-    );
-    expect(otherAttemptLinks.rows).toHaveLength(1);
-  });
-});
diff --git a/packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json b/packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json
deleted file mode 100644
index 4d17ed15a..000000000
--- a/packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json
+++ /dev/null
@@ -1,50 +0,0 @@
-{
-  "single_node": {},
-  "multi_node": {
-    "agentic": [
-      {
-        "image": "vllm/vllm-openai:nightly-dev-x86_64-cu13.0.1-728d3ad",
-        "model": "moonshotai/Kimi-K3",
-        "model-prefix": "kimik3",
-        "precision": "fp4",
-        "framework": "dynamo-vllm",
-        "spec-decoding": "mtp",
-        "runner": "cluster:b200-nscale",
-        "require-power": true,
-        "node-count": 2,
-        "prefill": {
-          "num-worker": 1,
-          "tp": 8,
-          "pp": 2,
-          "dcp-size": 8,
-          "pcp-size": 1,
-          "ep": 1,
-          "dp-attn": false,
-          "additional-settings": [
-            "CONFIG_FILE=recipes/vllm/kimi-k3/agentic/agg-b200-tp8pp2-mooncake-c1-agentic.yaml",
-            "SYNTHETIC_ACCEPTANCE=true",
-            "SYNTHETIC_ACCEPTANCE_LENGTH=3.84"
-          ]
-        },
-        "decode": {
-          "num-worker": 0,
-          "tp": 8,
-          "pp": 2,
-          "dcp-size": 8,
-          "pcp-size": 1,
-          "ep": 1,
-          "dp-attn": false,
-          "additional-settings": []
-        },
-        "conc": [1],
-        "kv-offloading": "none",
-        "total-cpu-dram-gb": 0,
-        "duration": 3600,
-        "exp-name": "kimik3_p1x8_d0x8_conc1",
-        "disagg": false,
-        "scenario-type": "agentic-coding",
-        "recipe-fingerprint": "ebb89391c58441525072eeffe36b6a6f6f52445116c68c99c017f06d662b972e"
-      }
-    ]
-  }
-}
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.test.ts b/packages/db/src/etl/gpu-metrics-artifacts.test.ts
deleted file mode 100644
index 02c1e9ea0..000000000
--- a/packages/db/src/etl/gpu-metrics-artifacts.test.ts
+++ /dev/null
@@ -1,177 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { afterEach, describe, expect, it } from 'vitest';
-
-import {
-  contextUtcOffsetMinutes,
-  discoverGpuMetricsArtifacts,
-  gpuMetricsArtifactSuffix,
-  listGpuMetricsCsvFiles,
-  listMultinodePowerSampleFiles,
-  parseEnergyCsv,
-  readGpuMetricsSidecars,
-  readPowerAuditValidations,
-} from './gpu-metrics-artifacts.js';
-
-const roots: string[] = [];
-
-afterEach(() => {
-  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
-});
-
-function tempRoot(): string {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-artifacts-'));
-  roots.push(root);
-  return root;
-}
-
-describe('gpu_metrics artifact discovery', () => {
-  it('pairs by the bare suffix and ignores eval-only uploads', () => {
-    expect(gpuMetricsArtifactSuffix('gpu_metrics_dsr1_8k1k_conc1_b200-x_0')).toBe(
-      'dsr1_8k1k_conc1_b200-x_0',
-    );
-    expect(gpuMetricsArtifactSuffix('eval_gpu_metrics_dsr1_8k1k_conc1_b200-x_0')).toBeNull();
-    expect(gpuMetricsArtifactSuffix('bmk_dsr1')).toBeNull();
-    expect(gpuMetricsArtifactSuffix('power_audit_kimik3_conc8_b200-slurm_0')).toBe(
-      'kimik3_conc8_b200-slurm_0',
-    );
-  });
-
-  it('lists the multinode power CSV but none of the bundle metadata', () => {
-    const root = tempRoot();
-    fs.mkdirSync(path.join(root, 'LOGS', 'power', 'windows'), { recursive: true });
-    fs.writeFileSync(path.join(root, 'LOGS', 'power', 'samples.csv'), 'schema_version\n');
-    fs.writeFileSync(path.join(root, 'LOGS', 'power', 'manifest.json'), '{}');
-    fs.writeFileSync(path.join(root, 'agg_cfg_conc8.json'), '{}');
-    expect(listMultinodePowerSampleFiles(root).map((file) => file.fileName)).toEqual([
-      'LOGS/power/samples.csv',
-    ]);
-    expect(listGpuMetricsCsvFiles(root)).toEqual([]);
-  });
-
-  it('lists telemetry CSVs recursively but skips identity and energy sidecars', () => {
-    const root = tempRoot();
-    fs.mkdirSync(path.join(root, 'results'));
-    fs.writeFileSync(path.join(root, 'gpu_metrics.csv'), 'timestamp\n');
-    fs.writeFileSync(path.join(root, 'gpu_metrics_identity.csv'), 'index\n');
-    fs.writeFileSync(path.join(root, 'results', 'gpu_metrics_energy_start.csv'), 'gpu\n');
-    fs.writeFileSync(path.join(root, 'results', 'gpu_metrics_rank1.csv'), 'timestamp\n');
-    fs.writeFileSync(path.join(root, 'results', 'server.log'), '');
-
-    expect(listGpuMetricsCsvFiles(root).map((file) => file.fileName)).toEqual([
-      'gpu_metrics.csv',
-      'results/gpu_metrics_rank1.csv',
-    ]);
-  });
-
-  it('indexes extracted artifact directories by suffix', () => {
-    const root = tempRoot();
-    fs.mkdirSync(path.join(root, 'gpu_metrics_cfg-a_runner_0'));
-    fs.mkdirSync(path.join(root, 'bmk_cfg-a_runner_0'));
-    fs.writeFileSync(path.join(root, 'gpu_metrics_not-a-dir_0'), '');
-    const discovered = discoverGpuMetricsArtifacts(root);
-    expect([...discovered.keys()]).toEqual(['cfg-a_runner_0']);
-    expect(discovered.get('cfg-a_runner_0')?.artifactName).toBe('gpu_metrics_cfg-a_runner_0');
-  });
-
-  it('uses the power_audit bundle only for suffixes without a gpu_metrics upload', () => {
-    const root = tempRoot();
-    for (const name of [
-      'power_audit_cfg-a_runner_0',
-      'gpu_metrics_cfg-a_runner_0',
-      'power_audit_cfg-mn_slurm_0',
-      'bmk_cfg-mn_slurm_0',
-    ]) {
-      fs.mkdirSync(path.join(root, name));
-    }
-    const discovered = discoverGpuMetricsArtifacts(root);
-    expect(
-      [...discovered.entries()].map(([suffix, artifact]) => [suffix, artifact.artifactName]),
-    ).toEqual([
-      ['cfg-a_runner_0', 'gpu_metrics_cfg-a_runner_0'],
-      ['cfg-mn_slurm_0', 'power_audit_cfg-mn_slurm_0'],
-    ]);
-  });
-});
-
-describe('sidecars', () => {
-  it.each([
-    ['z_gpu_metrics_context.json', 'a_gpu_metrics_context.json', '-07:00'],
-    ['a_gpu_metrics_context.json', 'Z_gpu_metrics_context.json', '+02:00'],
-  ])(
-    'chooses the first valid context in code-unit filename order (%s, %s)',
-    (first, second, expected) => {
-      const root = tempRoot();
-      const csv = path.join(root, 'gpu_metrics.csv');
-      fs.writeFileSync(csv, 'timestamp\n');
-      for (const name of [first, second]) {
-        fs.writeFileSync(
-          path.join(root, name),
-          JSON.stringify({
-            timestamp_timezone: name.startsWith('a_') ? '-07:00' : '+02:00',
-          }),
-        );
-      }
-      fs.writeFileSync(path.join(root, '0_gpu_metrics_context.json'), '{bad json');
-      fs.writeFileSync(path.join(root, '1_gpu_metrics_context.json'), '[]');
-      expect(readGpuMetricsSidecars(csv).context).toEqual({ timestamp_timezone: expected });
-    },
-  );
-
-  it('reads context, identity CSV, and energy counters next to the CSV', () => {
-    const root = tempRoot();
-    const csv = path.join(root, 'gpu_metrics.csv');
-    fs.writeFileSync(csv, 'timestamp\n');
-    fs.writeFileSync(path.join(root, 'gpu_metrics_context.json'), '{"timestamp_timezone":"UTC"}');
-    fs.writeFileSync(
-      path.join(root, 'gpu_metrics_identity.csv'),
-      'index, uuid, name\n0, GPU-abc, NVIDIA B200\n',
-    );
-    fs.writeFileSync(
-      path.join(root, 'gpu_metrics_energy_start.csv'),
-      'gpu,total_energy_consumption\n0,162815801.936\n',
-    );
-    const sidecars = readGpuMetricsSidecars(csv);
-    expect(sidecars.context).toEqual({ timestamp_timezone: 'UTC' });
-    expect(sidecars.identity).toEqual([{ index: '0', uuid: 'GPU-abc', name: 'NVIDIA B200' }]);
-    expect(sidecars.energyStart).toEqual({ '0': 162815801.936 });
-    expect(sidecars.energyEnd).toBeNull();
-  });
-
-  it('parses energy CSVs and rejects header-only files', () => {
-    expect(parseEnergyCsv('gpu,total_energy_consumption\n0,1.5\n1,2.5\n')).toEqual({
-      '0': 1.5,
-      '1': 2.5,
-    });
-    expect(parseEnergyCsv('gpu,total_energy_consumption\n')).toBeNull();
-  });
-
-  it('derives a fixed UTC offset only from ±HH:MM zones', () => {
-    expect(contextUtcOffsetMinutes({ timestamp_timezone: 'UTC' })).toBe(0);
-    expect(contextUtcOffsetMinutes({ timestamp_timezone: '-05:00' })).toBe(-300);
-    expect(contextUtcOffsetMinutes({ timestamp_timezone: '+0530' })).toBe(330);
-    expect(contextUtcOffsetMinutes(null)).toBe(0);
-  });
-});
-
-describe('readPowerAuditValidations', () => {
-  it('retains only valid top-level validation documents and tolerates missing inputs', () => {
-    const root = tempRoot();
-    const validation = {
-      selected_window: { start_time_unix: 10, end_time_unix: 20 },
-      per_gpu_role: { 'host-a/GPU-a': 'prefill' },
-    };
-    fs.writeFileSync(path.join(root, 'power_validation_point.json'), JSON.stringify(validation));
-    fs.writeFileSync(path.join(root, 'power_validation_malformed.json'), '{');
-    fs.writeFileSync(path.join(root, 'power_validation_array.json'), '[]');
-    fs.writeFileSync(path.join(root, 'power_validation_null.json'), 'null');
-    fs.writeFileSync(path.join(root, 'unrelated.json'), '{}');
-    fs.mkdirSync(path.join(root, 'LOGS'));
-    fs.writeFileSync(path.join(root, 'LOGS', 'power_validation_copy.json'), '{}');
-    expect(readPowerAuditValidations(root)).toEqual({ 'power_validation_point.json': validation });
-    expect(readPowerAuditValidations(path.join(root, 'missing'))).toEqual({});
-    expect(readPowerAuditValidations(path.join(root, 'unrelated.json'))).toEqual({});
-  });
-});
diff --git a/packages/db/src/etl/gpu-metrics-csv.test.ts b/packages/db/src/etl/gpu-metrics-csv.test.ts
index 2a2e2d0e0..be0425149 100644
--- a/packages/db/src/etl/gpu-metrics-csv.test.ts
+++ b/packages/db/src/etl/gpu-metrics-csv.test.ts
@@ -1,13 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import {
-  computeGpuMetricStats,
-  parseAmdTimestamp,
-  parseGpuMetricsCsv,
-  parseMetricCell,
-  parseNvidiaTimestamp,
-  summarizeGpuMetricSamples,
-} from './gpu-metrics-csv.js';
+import { computeGpuMetricStats, parseGpuMetricsCsv } from './gpu-metrics-csv.js';
 
 const NVIDIA_CSV = [
   'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
@@ -46,16 +39,6 @@ describe('parseGpuMetricsCsv — NVIDIA', () => {
     // The `[N/A]` power row for GPU 1 is not a usable sample.
     expect(parsed!.samples.filter((s) => s.gpuIndex === 1)).toHaveLength(1);
   });
-
-  it('applies a fixed collector offset when the context is not UTC', () => {
-    const parsed = parseGpuMetricsCsv(NVIDIA_CSV, { nvidiaUtcOffsetMinutes: -300 });
-    expect(parsed!.samples[0]!.timestampMs).toBe(Date.UTC(2026, 8, 11, 9, 19, 41, 982));
-  });
-
-  it('returns null for a header-only file or an unknown header', () => {
-    expect(parseGpuMetricsCsv(NVIDIA_CSV.split('\n')[0]!)).toBeNull();
-    expect(parseGpuMetricsCsv('a,b,c\n1,2,3')).toBeNull();
-  });
 });
 
 describe('parseGpuMetricsCsv — AMD', () => {
@@ -81,29 +64,6 @@ describe('parseGpuMetricsCsv — AMD', () => {
   });
 });
 
-describe('timestamp and cell helpers', () => {
-  it('parses nvidia-smi timestamps with and without milliseconds', () => {
-    expect(parseNvidiaTimestamp('2026/01/02 03:04:05')).toBe(Date.UTC(2026, 0, 2, 3, 4, 5));
-    expect(parseNvidiaTimestamp('2026/01/02 03:04:05.5')).toBe(Date.UTC(2026, 0, 2, 3, 4, 5, 500));
-    expect(parseNvidiaTimestamp('not a date')).toBeNull();
-  });
-
-  it('accepts epoch seconds, epoch milliseconds, and ISO strings for amd-smi', () => {
-    expect(parseAmdTimestamp('1789515524')).toBe(1789515524000);
-    expect(parseAmdTimestamp('1789515524.25')).toBe(1789515524250);
-    expect(parseAmdTimestamp('1789515524000')).toBe(1789515524000);
-    expect(parseAmdTimestamp('2026-09-16T00:00:00Z')).toBe(Date.UTC(2026, 8, 16));
-    expect(parseAmdTimestamp('12')).toBeNull();
-  });
-
-  it('treats N/A and blanks as null', () => {
-    expect(parseMetricCell('N/A')).toBeNull();
-    expect(parseMetricCell('')).toBeNull();
-    expect(parseMetricCell(undefined)).toBeNull();
-    expect(parseMetricCell(' 12.5 W')).toBe(12.5);
-  });
-});
-
 describe('computeGpuMetricStats', () => {
   it('digests every non-null metric per GPU with interpolated percentiles', () => {
     const parsed = parseGpuMetricsCsv(NVIDIA_CSV)!;
@@ -121,23 +81,4 @@ describe('computeGpuMetricStats', () => {
     expect(stats.some((s) => s.metric === 'edgeTempC')).toBe(false);
     expect(stats.filter((s) => s.gpuIndex === 1 && s.metric === 'powerW')[0]!.count).toBe(1);
   });
-
-  it('returns an empty digest for no samples', () => {
-    expect(computeGpuMetricStats([])).toEqual([]);
-  });
-});
-
-describe('summarizeGpuMetricSamples', () => {
-  it('reports the window, GPU count, and median per-GPU cadence', () => {
-    const summary = summarizeGpuMetricSamples(parseGpuMetricsCsv(NVIDIA_CSV)!.samples)!;
-    expect(summary.sampleCount).toBe(4);
-    expect(summary.gpuCount).toBe(2);
-    expect(summary.startedAtMs).toBe(Date.UTC(2026, 8, 11, 4, 19, 41, 982));
-    expect(summary.endedAtMs).toBe(Date.UTC(2026, 8, 11, 4, 19, 43, 990));
-    expect(summary.sampleIntervalS).toBeCloseTo(1.004, 3);
-  });
-
-  it('returns null for an empty series', () => {
-    expect(summarizeGpuMetricSamples([])).toBeNull();
-  });
 });
diff --git a/packages/db/src/etl/gpu-metrics-ingest.test.ts b/packages/db/src/etl/gpu-metrics-ingest.test.ts
index 9d35fb2fc..b3bf9a088 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.test.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.test.ts
@@ -115,7 +115,7 @@ const MULTINODE_MANIFEST = {
   sample_interval_seconds: 1,
 };
 
-function writePowerAuditArtifact(options: { withGpuMetricsCsv?: boolean } = {}) {
+function writePowerAuditArtifact() {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-ingest-'));
   roots.push(root);
   const artifactName = 'power_audit_kimik3_conc8_fp4_dynamo-vllm_b200-slurm_0';
@@ -127,9 +127,6 @@ function writePowerAuditArtifact(options: { withGpuMetricsCsv?: boolean } = {})
     JSON.stringify(MULTINODE_MANIFEST),
   );
   fs.writeFileSync(path.join(artifactDir, 'agg_kimik3_conc8.json'), '{}');
-  if (options.withGpuMetricsCsv) {
-    fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), NVIDIA_CSV);
-  }
   return { artifactName, artifactDir };
 }
 
@@ -159,59 +156,38 @@ describe('prepareGpuMetricsArtifact', () => {
     ]);
     expect(hostA!.sidecars.energyStart).toBeNull();
   });
-
-  it('prefers an nvidia-smi CSV in the same bundle over the power-only samples', () => {
-    // Single-node jobs upload gpu_metrics.csv inside power_audit_ as well.
-    const prepared = prepareGpuMetricsArtifact(
-      writePowerAuditArtifact({ withGpuMetricsCsv: true }),
-    );
-    expect(prepared.map((series) => series.fileName)).toEqual(['gpu_metrics.csv']);
-  });
-
-  it('parses each CSV with its sidecars and digest', () => {
-    const [series] = prepareGpuMetricsArtifact(writeArtifact(NVIDIA_CSV));
-    expect(series?.fileName).toBe('gpu_metrics.csv');
-    expect(series?.vendor).toBe('nvidia');
-    expect(series?.samples).toHaveLength(4);
-    expect(series?.gpuCount).toBe(2);
-    expect(series?.sidecars.context).toEqual({ timestamp_timezone: 'UTC' });
-    expect(series?.stats.find((s) => s.gpuIndex === 0 && s.metric === 'powerW')?.max).toBe(912.1);
-  });
 });
 
 describe('ingestGpuMetricsArtifact', () => {
-  it.each(['unrecognized telemetry header\nno samples', NVIDIA_CSV.split('\n')[0]!])(
-    'refuses a partial artifact when a discovered host CSV cannot be ingested: %s',
-    async (brokenCsv) => {
-      const artifact = writeArtifact(NVIDIA_CSV);
-      const missingHostFile = path.join(artifact.artifactDir, 'host-b', 'gpu_metrics.csv');
-      fs.mkdirSync(path.dirname(missingHostFile));
-      fs.writeFileSync(missingHostFile, brokenCsv);
-      await expect(
-        ingestGpuMetricsArtifact(sql, {
-          workflowRunId: 1,
-          artifact,
-          benchmarkResultIds: [10],
-        }),
-      ).rejects.toThrow('host-b/gpu_metrics.csv');
-      const before = await sql`select count(*)::int as n from gpu_metric_series`;
-      expect(before).toEqual([{ n: 0 }]);
-      fs.writeFileSync(missingHostFile, NVIDIA_CSV);
-      const recovered = await ingestGpuMetricsArtifact(sql, {
-        workflowRunId: 1,
-        artifact,
-        benchmarkResultIds: [10],
-      });
-      expect(recovered.seriesIds).toHaveLength(2);
-      expect(recovered.samplesInserted).toBe(8);
-      const replay = await ingestGpuMetricsArtifact(sql, {
+  it('refuses a partial artifact when a discovered host CSV has only a header', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const missingHostFile = path.join(artifact.artifactDir, 'host-b', 'gpu_metrics.csv');
+    fs.mkdirSync(path.dirname(missingHostFile));
+    fs.writeFileSync(missingHostFile, NVIDIA_CSV.split('\n')[0]!);
+    await expect(
+      ingestGpuMetricsArtifact(sql, {
         workflowRunId: 1,
         artifact,
         benchmarkResultIds: [10],
-      });
-      expect(replay.samplesInserted).toBe(0);
-    },
-  );
+      }),
+    ).rejects.toThrow('host-b/gpu_metrics.csv');
+    const before = await sql`select count(*)::int as n from gpu_metric_series`;
+    expect(before).toEqual([{ n: 0 }]);
+    fs.writeFileSync(missingHostFile, NVIDIA_CSV);
+    const recovered = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(recovered.seriesIds).toHaveLength(2);
+    expect(recovered.samplesInserted).toBe(8);
+    const replay = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(replay.samplesInserted).toBe(0);
+  });
 
   it('stores series, samples, digest, and point links; reruns are no-ops', async () => {
     const artifact = writeArtifact(NVIDIA_CSV);
@@ -284,80 +260,6 @@ describe('ingestGpuMetricsArtifact', () => {
     expect(count!.n).toBe(4);
   });
 
-  it('stores every host of a multinode power bundle under the bare config key', async () => {
-    const artifact = writePowerAuditArtifact();
-    const first = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    expect(first.seriesIds).toHaveLength(2);
-    expect(first.samplesInserted).toBe(7);
-
-    const series = await sql<{ config_key: string; file_name: string; gpu_count: number }[]>`
-      select config_key, file_name, gpu_count from gpu_metric_series order by file_name`;
-    expect(series).toEqual([
-      {
-        config_key: 'kimik3_conc8_fp4_dynamo-vllm_b200-slurm_0',
-        file_name: 'LOGS/power/samples.csv#host-a',
-        gpu_count: 2,
-      },
-      {
-        config_key: 'kimik3_conc8_fp4_dynamo-vllm_b200-slurm_0',
-        file_name: 'LOGS/power/samples.csv#host-b',
-        gpu_count: 2,
-      },
-    ]);
-    const metrics = await sql<{ metric: string }[]>`
-      select distinct metric from gpu_metric_gpu_stats`;
-    expect(metrics.map((m) => m.metric)).toEqual(['power_w']);
-    const links = await sql<{ n: number }[]>`
-      select count(*)::int as n from benchmark_result_gpu_metrics where benchmark_result_id = 10`;
-    expect(links[0]!.n).toBe(2);
-    const [hostA] = await sql<{ sample_count: number; mean_value: number; power_w: number }[]>`
-      select stats.sample_count, stats.mean_value, samples.power_w
-      from gpu_metric_series series
-      join gpu_metric_gpu_stats stats on stats.series_id = series.id
-      join gpu_metric_samples samples on samples.series_id = series.id
-        and samples.gpu_index = stats.gpu_index
-      where series.file_name = 'LOGS/power/samples.csv#host-a'
-        and stats.gpu_index = 0 and stats.metric = 'power_w'
-      order by samples.sampled_at desc limit 1`;
-    expect(hostA!.sample_count).toBe(2);
-    expect(hostA!.mean_value).toBeCloseTo((186.656 + 700.25) / 2, 3);
-    expect(hostA!.power_w).toBe(700.25);
-
-    const rerun = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    expect(rerun.samplesInserted).toBe(0);
-    expect(rerun.seriesSkipped).toBe(2);
-  });
-
-  it('replaces samples and digest when the CSV content changes', async () => {
-    const artifact = writeArtifact(NVIDIA_CSV);
-    await ingestGpuMetricsArtifact(sql, { workflowRunId: 1, artifact, benchmarkResultIds: [10] });
-
-    const longer = `${NVIDIA_CSV}\n2026/09/11 04:19:43.990, 0, 950.00 W, 65, 1965 MHz, 3996 MHz, 99 %, 75 %`;
-    fs.writeFileSync(path.join(artifact.artifactDir, 'gpu_metrics.csv'), longer);
-    const result = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    expect(result.samplesInserted).toBe(5);
-    expect(result.seriesSkipped).toBe(0);
-    const [series] = await sql<{ n: number; sample_count: number }[]>`
-      select (select count(*)::int from gpu_metric_series) as n, sample_count from gpu_metric_series`;
-    expect(series!.n).toBe(1);
-    expect(series!.sample_count).toBe(5);
-    const [stat] = await sql<{ max_value: number }[]>`
-      select max_value from gpu_metric_gpu_stats where gpu_index = 0 and metric = 'power_w'`;
-    expect(stat!.max_value).toBe(950);
-  });
-
   it('rolls back a replacement when point linking fails and retries without losing existing links', async () => {
     const artifact = writeArtifact(NVIDIA_CSV);
     const first = await ingestGpuMetricsArtifact(sql, {
@@ -412,237 +314,4 @@ describe('ingestGpuMetricsArtifact', () => {
     });
     expect(after.links.map((row) => Number(row.benchmark_result_id))).toEqual([10, 11]);
   });
-
-  it('retries a partial artifact after a later series fails without rewriting its committed series', async () => {
-    const artifact = writeArtifact(NVIDIA_CSV);
-    const first = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    const seriesId = first.seriesIds[0]!;
-    const secondFile = path.join(artifact.artifactDir, 'host-b', 'gpu_metrics.csv');
-    fs.mkdirSync(path.dirname(secondFile));
-    // Both CSVs parse, but the second series exceeds the database smallint range.
-    fs.writeFileSync(secondFile, NVIDIA_CSV.replaceAll(', 0,', ', 999999,'));
-    await expect(
-      ingestGpuMetricsArtifact(sql, {
-        workflowRunId: 1,
-        artifact,
-        benchmarkResultIds: [11],
-      }),
-    ).rejects.toMatchObject({ code: '22003' });
-    expect(await sql`select file_name from gpu_metric_series order by file_name`).toEqual([
-      { file_name: 'gpu_metrics.csv' },
-    ]);
-    const committed = await storedSeries(seriesId);
-    expect(committed.samples).toHaveLength(4);
-    expect(committed.stats).toHaveLength(12);
-    expect(committed.links.map((row) => Number(row.benchmark_result_id))).toEqual([10, 11]);
-
-    fs.writeFileSync(secondFile, NVIDIA_CSV);
-    const recovered = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [11],
-    });
-    expect(recovered.seriesIds).toHaveLength(2);
-    expect(recovered.seriesIds[0]).toBe(seriesId);
-    expect(recovered.samplesInserted).toBe(4);
-    expect(recovered.seriesSkipped).toBe(1);
-    expect(await storedSeries(seriesId)).toEqual(committed);
-    const second = await storedSeries(recovered.seriesIds[1]!);
-    expect(second.samples).toHaveLength(4);
-    expect(second.stats).toHaveLength(12);
-    expect(second.links.map((row) => Number(row.benchmark_result_id))).toEqual([11]);
-    expect(await sql`select count(*)::int as n from gpu_metric_series`).toEqual([{ n: 2 }]);
-    expect(await sql`select count(*)::int as n from gpu_metric_samples`).toEqual([{ n: 8 }]);
-
-    const replay = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [11],
-    });
-    expect(replay).toEqual({
-      metadataUpdatedBenchmarkResultIds: [],
-      seriesIds: recovered.seriesIds,
-      samplesInserted: 0,
-      seriesSkipped: 2,
-    });
-    expect(await storedSeries(seriesId)).toEqual(committed);
-    expect(await storedSeries(recovered.seriesIds[1]!)).toEqual(second);
-  });
-
-  it('uses the first reading per GPU/timestamp for stored samples, metadata, and digest', async () => {
-    const csv = [
-      NVIDIA_CSV.split('\n')[0],
-      '2026/09/11 04:19:41.000, 0, 100 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
-      '2026/09/11 04:19:41.000, 1, 200 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
-      '2026/09/11 04:19:42.000, 0, 300 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
-      '2026/09/11 04:19:42.000, 0, 900 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
-    ].join('\n');
-    const artifact = writeArtifact(csv);
-    await ingestGpuMetricsArtifact(sql, { workflowRunId: 1, artifact, benchmarkResultIds: [10] });
-
-    const samples = await sql<{ gpu_index: number; power_w: number }[]>`
-      select gpu_index, power_w from gpu_metric_samples order by sampled_at, gpu_index`;
-    expect(samples).toEqual([
-      { gpu_index: 0, power_w: 100 },
-      { gpu_index: 1, power_w: 200 },
-      { gpu_index: 0, power_w: 300 },
-    ]);
-    const [series] = await sql<{ sample_count: number; gpu_count: number }[]>`
-      select sample_count, gpu_count from gpu_metric_series`;
-    expect(series).toEqual({ sample_count: 3, gpu_count: 2 });
-    const stats = await sql<{ gpu_index: number; sample_count: number; mean_value: number }[]>`
-      select gpu_index, sample_count, mean_value from gpu_metric_gpu_stats
-      where metric = 'power_w' order by gpu_index`;
-    expect(stats).toEqual([
-      { gpu_index: 0, sample_count: 2, mean_value: 200 },
-      { gpu_index: 1, sample_count: 1, mean_value: 200 },
-    ]);
-  });
-
-  it('repairs an existing duplicate-inflated digest when the same CSV is re-ingested', async () => {
-    const artifact = writeArtifact(NVIDIA_CSV);
-    const first = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    // Model an earlier ingest: SQL stored unique samples, but metadata and stats
-    // counted the repeated final CSV row. Its CSV hash and sidecars still match.
-    await sql`update gpu_metric_series set sample_count = 5`;
-    await sql`update gpu_metric_gpu_stats set sample_count = 3, mean_value = 667.1867
-      where gpu_index = 1 and metric = 'power_w'`;
-
-    const result = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    expect(result.seriesIds).toEqual(first.seriesIds);
-    expect(result.seriesSkipped).toBe(0);
-    const [series] = await sql<{ sample_count: number; stored_count: number }[]>`
-      select sample_count, (select count(*)::int from gpu_metric_samples) as stored_count
-      from gpu_metric_series`;
-    expect(series).toEqual({ sample_count: 4, stored_count: 4 });
-    const [stat] = await sql<{ sample_count: number; mean_value: number }[]>`
-      select sample_count, mean_value from gpu_metric_gpu_stats
-      where gpu_index = 1 and metric = 'power_w'`;
-    expect(stat!.sample_count).toBe(2);
-    expect(stat!.mean_value).toBeCloseTo((190.96 + 905.3) / 2, 3);
-  });
-
-  it('replaces timestamps when only the context timezone is corrected', async () => {
-    const artifact = writeArtifact(NVIDIA_CSV);
-    const first = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    const before = await sql<{ sampled_at: Date }[]>`
-      select sampled_at from gpu_metric_samples order by sampled_at, gpu_index`;
-    fs.writeFileSync(
-      path.join(artifact.artifactDir, 'gpu_metrics_context.json'),
-      JSON.stringify({ timestamp_timezone: '+02:00' }),
-    );
-
-    const result = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    expect(result.seriesIds).toEqual(first.seriesIds);
-    expect(result.samplesInserted).toBe(4);
-    expect(result.seriesSkipped).toBe(0);
-    const after = await sql<{ sampled_at: Date }[]>`
-      select sampled_at from gpu_metric_samples order by sampled_at, gpu_index`;
-    expect(after.map((s) => new Date(s.sampled_at).getTime())).toEqual(
-      before.map((s) => new Date(s.sampled_at).getTime() - 2 * 60 * 60 * 1000),
-    );
-    const [series] = await sql<{ started_at: Date; ended_at: Date; context: unknown }[]>`
-      select started_at, ended_at, sidecars -> 'context' as context from gpu_metric_series`;
-    expect(new Date(series!.started_at).toISOString()).toBe('2026-09-11T02:19:41.982Z');
-    expect(new Date(series!.ended_at).toISOString()).toBe('2026-09-11T02:19:42.994Z');
-    expect(series!.context).toEqual({ timestamp_timezone: '+02:00' });
-  });
-
-  it('persists identity-only sidecar corrections without changing the series or samples', async () => {
-    const artifact = writeArtifact(NVIDIA_CSV);
-    const first = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    const before = await sql`select * from gpu_metric_samples order by sampled_at, gpu_index`;
-    fs.writeFileSync(
-      path.join(artifact.artifactDir, 'gpu_metrics_identity.csv'),
-      'index, uuid, name\n0, GPU-corrected, NVIDIA B200\n1, GPU-b, NVIDIA B200\n',
-    );
-
-    const result = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    expect(result.seriesIds).toEqual(first.seriesIds);
-    const [series] = await sql<{ identity: unknown }[]>`
-      select sidecars -> 'identity' as identity from gpu_metric_series`;
-    expect(series!.identity).toEqual([
-      { index: '0', uuid: 'GPU-corrected', name: 'NVIDIA B200' },
-      { index: '1', uuid: 'GPU-b', name: 'NVIDIA B200' },
-    ]);
-    expect(await sql`select * from gpu_metric_samples order by sampled_at, gpu_index`).toEqual(
-      before,
-    );
-  });
-
-  it('keeps reruns as no-ops when only JSON object key order changes', async () => {
-    const artifact = writeArtifact(NVIDIA_CSV);
-    const contextPath = path.join(artifact.artifactDir, 'gpu_metrics_context.json');
-    fs.writeFileSync(
-      contextPath,
-      JSON.stringify({ timestamp_timezone: 'UTC', collector: { name: 'nvidia-smi', version: 1 } }),
-    );
-    const first = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    const [before] = await sql<{ ingested_at: Date }[]>`select ingested_at from gpu_metric_series`;
-    fs.writeFileSync(
-      contextPath,
-      JSON.stringify({ collector: { version: 1, name: 'nvidia-smi' }, timestamp_timezone: 'UTC' }),
-    );
-
-    const result = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    expect(result).toEqual({
-      metadataUpdatedBenchmarkResultIds: [],
-      seriesIds: first.seriesIds,
-      samplesInserted: 0,
-      seriesSkipped: 1,
-    });
-    const [after] = await sql<{ ingested_at: Date }[]>`select ingested_at from gpu_metric_series`;
-    expect(after!.ingested_at).toEqual(before!.ingested_at);
-  });
-
-  it('ignores artifacts whose CSVs cannot be parsed', async () => {
-    const artifact = writeArtifact('nonsense,header\n1,2\n');
-    const result = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact,
-      benchmarkResultIds: [10],
-    });
-    expect(result).toEqual({
-      metadataUpdatedBenchmarkResultIds: [],
-      seriesIds: [],
-      samplesInserted: 0,
-      seriesSkipped: 0,
-    });
-  });
 });
diff --git a/packages/db/src/etl/multinode-power-samples.test.ts b/packages/db/src/etl/multinode-power-samples.test.ts
deleted file mode 100644
index 3ec8b5024..000000000
--- a/packages/db/src/etl/multinode-power-samples.test.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-  isMultinodePowerSamplesPath,
-  multinodePowerVendor,
-  parseMultinodePowerSamples,
-} from './multinode-power-samples.js';
-
-// Shape of run 34674595026's LOGS/power/samples.csv (Kimi K3 B200, two hosts),
-// trimmed to two GPUs and two scrapes, with one malformed row of each kind.
-const CSV = [
-  'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
-  '1,1789194365.2924976,4,im-b200-c002,0,GPU-c2-0,401.5',
-  '1,1789194365.2924976,4,im-b200-c001,0,GPU-c1-0,186.656',
-  '1,1789194365.2924976,4,im-b200-c001,1,GPU-c1-1,190.1',
-  '1,1789194366.29,5,im-b200-c001,0,GPU-c1-0,700.25',
-  '1,1789194366.29,5,im-b200-c001,1,GPU-c1-1,702.0',
-  '1,1789194366.29,5,im-b200-c002,0,GPU-c2-0,650.0',
-  '1,not-a-time,6,im-b200-c001,0,GPU-c1-0,1.0',
-  '1,1789194367.29,6,im-b200-c001,x,GPU-c1-0,1.0',
-  '1,1789194367.29,6,,0,GPU-c1-0,1.0',
-  '',
-].join('\n');
-
-describe('parseMultinodePowerSamples', () => {
-  it('regroups the deployment CSV into power-only samples per host, sorted by hostname', () => {
-    const hosts = parseMultinodePowerSamples(CSV);
-    expect(hosts?.map((host) => host.hostname)).toEqual(['im-b200-c001', 'im-b200-c002']);
-    const [c001, c002] = hosts!;
-    expect(c001.samples).toHaveLength(4);
-    expect(c002.samples).toHaveLength(2);
-    expect(c001.samples[0]).toEqual({
-      timestampMs: 1789194365292,
-      gpuIndex: 0,
-      powerW: 186.656,
-      temperatureC: null,
-      smClockMhz: null,
-      memClockMhz: null,
-      gpuUtilPct: null,
-      memUtilPct: null,
-      edgeTempC: null,
-      memTempC: null,
-      gfxVoltageMv: null,
-      socVoltageMv: null,
-      memVoltageMv: null,
-      fclkMhz: null,
-      socclkMhz: null,
-      mmActivityPct: null,
-    });
-    expect(c001.gpuUuids).toEqual({ 0: 'GPU-c1-0', 1: 'GPU-c1-1' });
-    expect(c002.gpuUuids).toEqual({ 0: 'GPU-c2-0' });
-  });
-
-  it('rejects other CSV layouts instead of guessing', () => {
-    expect(parseMultinodePowerSamples('timestamp, index, power.draw [W]\n1,0,1\n')).toBeNull();
-    expect(
-      parseMultinodePowerSamples('schema_version,timestamp_unix,gpu_index,power_w\n1,1,0,1\n'),
-    ).toBeNull();
-    expect(parseMultinodePowerSamples(CSV.split('\n')[0]!)).toBeNull();
-    expect(parseMultinodePowerSamples('')).toBeNull();
-  });
-});
-
-describe('multinode power bundle layout', () => {
-  it('recognises only samples.csv under LOGS/', () => {
-    expect(isMultinodePowerSamplesPath('LOGS/power/samples.csv')).toBe(true);
-    expect(isMultinodePowerSamplesPath('LOGS/native_power/node-1/samples.csv')).toBe(true);
-    expect(isMultinodePowerSamplesPath(String.raw`LOGS\power\samples.csv`)).toBe(true);
-    expect(isMultinodePowerSamplesPath('samples.csv')).toBe(false);
-    expect(isMultinodePowerSamplesPath('LOGS/power/manifest.json')).toBe(false);
-    expect(isMultinodePowerSamplesPath('results/gpu_metrics.csv')).toBe(false);
-  });
-
-  it('maps the producer manifest to a vendor, defaulting to NVIDIA/DCGM', () => {
-    expect(
-      multinodePowerVendor({
-        producer: 'srt-slurm.dcgm-power',
-        source_metric: 'DCGM_FI_DEV_POWER_USAGE',
-      }),
-    ).toBe('nvidia');
-    expect(multinodePowerVendor({ producer: 'srt-slurm.amd-smi-power' })).toBe('amd');
-    expect(multinodePowerVendor({ source_metric: 'rocm_smi_power' })).toBe('amd');
-    expect(multinodePowerVendor(null)).toBe('nvidia');
-  });
-});
diff --git a/packages/db/src/etl/power-audit-recovery.test.ts b/packages/db/src/etl/power-audit-recovery.test.ts
index 569b1aed2..f90d1a0ae 100644
--- a/packages/db/src/etl/power-audit-recovery.test.ts
+++ b/packages/db/src/etl/power-audit-recovery.test.ts
@@ -1,10 +1,7 @@
 import { describe, expect, it } from 'vitest';
 
 import type { BenchmarkPersistenceInput } from './benchmark-ingest.js';
-import {
-  createBenchmarkPowerAuditRecovery,
-  type BenchmarkPowerAuditEvidence,
-} from './power-audit-recovery.js';
+import { createBenchmarkPowerAuditRecovery } from './power-audit-recovery.js';
 
 const resultFile = 'kimik3_recipe-a_conc48.json';
 const source = `power_validation_${resultFile}`;
@@ -40,15 +37,11 @@ function point(overrides: Partial<BenchmarkPersistenceInput> = {}): BenchmarkPer
 }
 
 describe('CI benchmark audit recovery', () => {
-  it.each([
-    ['aggregate before sibling', [false, true]],
-    ['aggregate after sibling', [true, false]],
-    ['repeated/no-op sibling ingest', [true, false, true, false]],
-  ])('retains exact provenance with %s and preserves benchmark values', (_label, paired) => {
+  it('retains exact provenance with aggregate after sibling and preserves benchmark values', () => {
     const recover = createBenchmarkPowerAuditRecovery();
     const original = point();
     let latest = original;
-    for (const isPaired of paired) {
+    for (const isPaired of [true, false]) {
       latest = recover(original, isPaired ? evidence : undefined);
       expect(latest.metrics).toBe(original.metrics);
       expect(latest.workers).toBe(original.workers);
@@ -58,67 +51,11 @@ describe('CI benchmark audit recovery', () => {
     expect(original.powerAudit).toBeUndefined();
   });
 
-  it('preserves every explicit audit, including one without a source', () => {
+  it('does not reuse the same run/concurrency audit for a point with another offload mode', () => {
     const recover = createBenchmarkPowerAuditRecovery();
     recover(point(), evidence);
-    for (const powerAudit of [{ source: 'producer-original.json' }, { sample_count: 42 }, {}]) {
-      const original = point({ powerAudit });
-      expect(recover(original, evidence)).toBe(original);
-      expect(recover(original)).toBe(original);
-    }
-  });
-
-  it.each([
-    { configId: 2 },
-    { recipeFingerprint: 'recipe-b' },
-    { offloadMode: 'off' },
-    { conc: 56 },
-    { isl: 8192 },
-    { osl: 1024 },
-    { benchmarkType: 'single_turn' as const },
-  ])('does not reuse the same run/concurrency audit for another point: %j', (difference) => {
-    const recover = createBenchmarkPowerAuditRecovery();
-    recover(point(), evidence);
-    const other = point(difference);
+    const other = point({ offloadMode: 'off' });
     expect(recover(other)).toBe(other);
     expect(other.powerAudit).toBeUndefined();
   });
-
-  it('does not carry evidence into another run', () => {
-    createBenchmarkPowerAuditRecovery()(point(), evidence);
-    const nextRun = point();
-    expect(createBenchmarkPowerAuditRecovery()(nextRun)).toBe(nextRun);
-  });
-
-  it('restores audit metadata without promoting an invalid power verdict', () => {
-    const original = point({ metrics: { power_valid: 0, mean_ttft: 0.2 } });
-    const restored = createBenchmarkPowerAuditRecovery()(original, {
-      resultFile,
-      validations: { [source]: { ...validation, power_valid: false } },
-    });
-    expect(restored.powerAudit).toEqual(expectedAudit);
-    expect(restored.metrics).toBe(original.metrics);
-    expect(restored.metrics).toEqual({ power_valid: 0, mean_ttft: 0.2 });
-  });
-
-  it.each<BenchmarkPowerAuditEvidence>([
-    { resultFile: 'different-result.json', validations: evidence.validations },
-    {
-      resultFile,
-      validations: {
-        [source]: {
-          ...validation,
-          selected_window: { ...validation.selected_window, concurrency: 56 },
-        },
-      },
-    },
-    { resultFile, validations: { [source]: { ...validation, validation_path: undefined } } },
-    { resultFile, validations: {} },
-    { resultFile, validations: { [source]: validation, [`other/${source}`]: validation } },
-  ])('leaves missing or ambiguous exact sibling evidence unknown', (candidate) => {
-    const recover = createBenchmarkPowerAuditRecovery();
-    const original = point();
-    expect(recover(original, candidate)).toBe(original);
-    expect(recover(original)).toBe(original);
-  });
 });
diff --git a/packages/db/src/etl/power-audit-validations.test.ts b/packages/db/src/etl/power-audit-validations.test.ts
index d272b39cb..426073200 100644
--- a/packages/db/src/etl/power-audit-validations.test.ts
+++ b/packages/db/src/etl/power-audit-validations.test.ts
@@ -1,10 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import {
-  isPowerAuditValidationEntry,
-  normalizePowerAuditValidations,
-  recoveredPowerAudit,
-} from './power-audit-validations.js';
+import { normalizePowerAuditValidations } from './power-audit-validations.js';
 
 const ARTIFACT = 'power_audit_kimik3_agentx_fp4';
 const RESULT = 'kimik3_agentx_fp4_conc48.json';
@@ -49,46 +45,7 @@ function fixture() {
   return { selected, validation, result, window, files };
 }
 
-describe('isPowerAuditValidationEntry', () => {
-  it.each([SOURCE, VALIDATION, WINDOW, RESULT])('selects required input %s', (name) => {
-    expect(isPowerAuditValidationEntry(name)).toBe(true);
-  });
-
-  it.each([
-    'manifest.json',
-    'unrelated.json',
-    'results/kimik3_agentx_fp4_conc48.json',
-    'LOGS/power_validation_point.json',
-    'LOGS/agentic/conc_048/power_validation.json',
-    'LOGS/agentic/conc_0/power_validation.json',
-    'LOGS/agentic/conc_48/power_validation_copy.json',
-    'logs/agentic/conc_48/power_validation.json',
-    'LOGS/power/windows/unrelated_conc48.json',
-    'LOGS/power/windows/agentic_power_concurrency_48.json.bak',
-  ])('does not select unrelated or unsupported input %s', (name) => {
-    expect(isPowerAuditValidationEntry(name)).toBe(false);
-  });
-});
-
 describe('normalizePowerAuditValidations', () => {
-  it('preserves legacy top-level objects without adding new validity gates', () => {
-    const legacy = { power_valid: false, selected_window: null, note: 'retained as published' };
-    const files = new Map([
-      ['power_validation_legacy.json', JSON.stringify(legacy)],
-      ['power_validation_empty.json', '{}'],
-      ['power_validation_broken.json', '{'],
-      ['power_validation_array.json', '[]'],
-      ['power_validation_null.json', 'null'],
-      ['LOGS/power_validation_copy.json', '{}'],
-    ]);
-    expect(normalizePowerAuditValidations('legacy-upload', files)).toEqual(
-      new Map<string, Record<string, unknown>>([
-        ['power_validation_legacy.json', legacy],
-        ['power_validation_empty.json', {}],
-      ]),
-    );
-  });
-
   it('aliases an exactly matched nested document without changing its window, roles or verdict', () => {
     const input = fixture();
     const files = input.files();
@@ -102,146 +59,9 @@ describe('normalizePowerAuditValidations', () => {
     expect(input.validation).not.toHaveProperty('validation_path');
   });
 
-  it.each([false, undefined])(
-    'does not manufacture a valid verdict from power_valid=%s',
-    (valid) => {
-      const input = fixture();
-      if (valid === undefined) delete input.validation.power_valid;
-      else input.validation.power_valid = valid;
-      const normalized = normalizePowerAuditValidations(ARTIFACT, input.files()).get(SOURCE)!;
-      expect(normalized).toEqual({
-        ...input.validation,
-        validation_path: VALIDATION,
-        result_file: RESULT,
-      });
-      expect(Object.hasOwn(normalized, 'power_valid')).toBe(valid !== undefined);
-      expect(recoveredPowerAudit(SOURCE, normalized)).toEqual({
-        source: SOURCE,
-        window_start_unix: START,
-        window_end_unix: END,
-      });
-    },
-  );
-
-  it.each([VALIDATION, RESULT, WINDOW])('requires the exact paired input %s', (name) => {
-    const files = fixture().files();
-    files.delete(name);
-    expect(normalizePowerAuditValidations(ARTIFACT, files).size).toBe(0);
-  });
-
-  it.each([VALIDATION, RESULT, WINDOW])('rejects malformed or non-object input %s', (name) => {
-    for (const text of ['{bad json', '[]', 'null', '48']) {
-      const files = fixture().files();
-      files.set(name, text);
-      expect(normalizePowerAuditValidations(ARTIFACT, files).size).toBe(0);
-    }
-  });
-
-  it.each([
-    ['result', 'conc', 64],
-    ['result', 'conc', '48'],
-    ['selected', 'concurrency', 64],
-    ['selected', 'concurrency', '48'],
-    ['selected', 'result_path', 'agentic/conc_64/agentic_power_concurrency_64.json'],
-    ['selected', 'window_file', 'windows/agentic_power_concurrency_64.json'],
-    ['window', 'concurrency', 64],
-    ['window', 'result_path', 'agentic/conc_64/agentic_power_concurrency_64.json'],
-    ['window', 'benchmark_start_time_unix', START + 1],
-    ['window', 'benchmark_end_time_unix', END - 1],
-  ] as const)('rejects mismatched %s.%s', (document, field, value) => {
+  it('rejects mismatched window.benchmark_start_time_unix', () => {
     const input = fixture();
-    input[document][field] = value;
+    input.window.benchmark_start_time_unix = START + 1;
     expect(normalizePowerAuditValidations(ARTIFACT, input.files()).size).toBe(0);
   });
-
-  it.each([
-    [0, END],
-    [-1, END],
-    [START, START],
-    [END, START],
-    [null, END],
-    [START, '1789943769.371839'],
-  ])('rejects an invalid selected time range %s to %s', (start, end) => {
-    const input = fixture();
-    input.selected.start_time_unix = start;
-    input.window.benchmark_start_time_unix = start;
-    input.selected.end_time_unix = end;
-    input.window.benchmark_end_time_unix = end;
-    expect(normalizePowerAuditValidations(ARTIFACT, input.files()).size).toBe(0);
-  });
-
-  it('rejects an overflowing JSON number instead of emitting an infinite time', () => {
-    const files = fixture().files();
-    files.set(VALIDATION, files.get(VALIDATION)!.replace(String(START), '1e400'));
-    files.set(WINDOW, files.get(WINDOW)!.replace(String(START), '1e400'));
-    expect(normalizePowerAuditValidations(ARTIFACT, files).size).toBe(0);
-  });
-
-  it('does not guess the result from another root file with the same concurrency', () => {
-    const files = fixture().files();
-    files.set('different_config_conc48.json', files.get(RESULT)!);
-    files.delete(RESULT);
-    expect(normalizePowerAuditValidations(ARTIFACT, files).size).toBe(0);
-  });
-
-  it('does not borrow a document from a different nested concurrency directory', () => {
-    const files = fixture().files();
-    files.set('LOGS/agentic/conc_64/power_validation.json', files.get(VALIDATION)!);
-    files.delete(VALIDATION);
-    files.set('kimik3_agentx_fp4_conc64.json', JSON.stringify({ conc: 64 }));
-    expect(normalizePowerAuditValidations(ARTIFACT, files).size).toBe(0);
-  });
-
-  it('leaves a canonical legacy document authoritative regardless of insertion order', () => {
-    const files = fixture().files();
-    const legacy = { power_valid: false, selected_window: null, note: 'legacy wins' };
-    files.set(SOURCE, JSON.stringify(legacy));
-    expect(normalizePowerAuditValidations(ARTIFACT, files)).toEqual(new Map([[SOURCE, legacy]]));
-    expect(normalizePowerAuditValidations(ARTIFACT, new Map([...files].toReversed()))).toEqual(
-      new Map([[SOURCE, legacy]]),
-    );
-  });
-
-  it('does not derive AgentX aliases for an unrelated artifact', () => {
-    expect(
-      normalizePowerAuditValidations('gpu_metrics_kimik3_agentx_fp4', fixture().files()).size,
-    ).toBe(0);
-  });
-});
-
-describe('recoveredPowerAudit', () => {
-  it('returns only source and recorded times from a normalized nested validation', () => {
-    const normalized = normalizePowerAuditValidations(ARTIFACT, fixture().files()).get(SOURCE)!;
-    expect(recoveredPowerAudit(SOURCE, normalized)).toEqual({
-      source: SOURCE,
-      window_start_unix: START,
-      window_end_unix: END,
-    });
-  });
-
-  it('does not treat an ordinary legacy validation as recovered AgentX metadata', () => {
-    expect(recoveredPowerAudit(SOURCE, fixture().validation)).toBeNull();
-  });
-
-  it.each([
-    ['validation_path', 'LOGS/agentic/conc_64/power_validation.json'],
-    ['validation_path', 'power_validation_legacy.json'],
-    ['result_file', 'kimik3_agentx_fp4_conc64.json'],
-    ['result_file', 'nested/kimik3_agentx_fp4_conc48.json'],
-    ['selected_window', null],
-    ['selected_window', { concurrency: 48, start_time_unix: START, end_time_unix: Infinity }],
-    ['selected_window', { concurrency: 48, start_time_unix: END, end_time_unix: START }],
-    ['selected_window', { concurrency: 64, start_time_unix: START, end_time_unix: END }],
-  ])('rejects inconsistent recovery metadata in %s', (field, value) => {
-    const normalized = normalizePowerAuditValidations(ARTIFACT, fixture().files()).get(SOURCE)!;
-    normalized[String(field)] = value;
-    expect(recoveredPowerAudit(SOURCE, normalized)).toBeNull();
-  });
-
-  it('requires the alias to match the actual result filename', () => {
-    const normalized = normalizePowerAuditValidations(ARTIFACT, fixture().files()).get(SOURCE)!;
-    expect(
-      recoveredPowerAudit('power_validation_different_config_conc48.json', normalized),
-    ).toBeNull();
-  });
 });
diff --git a/packages/db/src/etl/power-publication.test.ts b/packages/db/src/etl/power-publication.test.ts
index 60a95e3e1..b31ce0f98 100644
--- a/packages/db/src/etl/power-publication.test.ts
+++ b/packages/db/src/etl/power-publication.test.ts
@@ -2,7 +2,6 @@ import { describe, expect, it } from 'vitest';
 import { mapBenchmarkRow } from './benchmark-mapper';
 import { createSkipTracker } from './skip-tracker';
 import {
-  fatalPublicationErrors,
   powerPublicationPoint,
   verifyPowerPublication,
   type PublishedPowerRow,
@@ -141,30 +140,3 @@ describe('PowerX publication', () => {
     expect(tracker.skips.failedRun).toBe(1);
   });
 });
-
-/**
- * Regression for the ingest-reddening chain: a gpu_metrics digest failure used to
- * be recorded as a DB error, reach the publication manifest's `ingestErrors`, and
- * set exitCode 1 on the required "Verify PowerX source, database and public API"
- * step — failing a production ingest whose benchmark data had landed fine.
- */
-describe('fatalPublicationErrors', () => {
-  it('ignores telemetry warnings, so a bad gpu_metrics CSV cannot fail the ingest', () => {
-    expect(
-      fatalPublicationErrors({ telemetryWarnings: ['3 gpu_metrics digest errors'] }, []),
-    ).toEqual([]);
-  });
-
-  it('still fails on real ingest errors and on verification mismatches', () => {
-    expect(
-      fatalPublicationErrors(
-        { ingestErrors: ['2 database ingest errors'], telemetryWarnings: ['1 gpu_metrics'] },
-        ['point 441871 expected absent, got 642'],
-      ),
-    ).toEqual(['2 database ingest errors', 'point 441871 expected absent, got 642']);
-  });
-
-  it('treats both fields as optional', () => {
-    expect(fatalPublicationErrors({}, [])).toEqual([]);
-  });
-});
diff --git a/packages/db/src/etl/required-power-curve-db.test.ts b/packages/db/src/etl/required-power-curve-db.test.ts
index a5ec3da12..7ffcbfb06 100644
--- a/packages/db/src/etl/required-power-curve-db.test.ts
+++ b/packages/db/src/etl/required-power-curve-db.test.ts
@@ -55,24 +55,6 @@ describe('read-only required-power DB preflight', () => {
     const published = await getLatestBenchmarks(sql, 'qwen3.5', '9999-12-31');
     expect(published.map((row) => row.conc)).toEqual([1, 64]);
   });
-  it('accepts complete incoming point coverage', async () => {
-    await addPoint(1);
-    await expect(
-      preflightRequiredPowerCurves(sql, golden, source, options),
-    ).resolves.toBeUndefined();
-    expect(await sql`SELECT count(*)::int AS n FROM workflow_runs`).toEqual([{ n: 1 }]);
-  });
-  it('inherits same-image append-only state but rejects a changed image', async () => {
-    await addPoint(1);
-    await addPoint(64);
-    await expect(
-      preflightRequiredPowerCurves(sql, golden, source, { ...options, appendOnly: true }),
-    ).resolves.toBeUndefined();
-    await sql`UPDATE benchmark_results SET image='old-image'`;
-    await expect(
-      preflightRequiredPowerCurves(sql, golden, source, { ...options, appendOnly: true }),
-    ).rejects.toThrow('shrink');
-  });
   it('detects retry removal from a scope omitted entirely by incoming artifacts', async () => {
     await sql`UPDATE workflow_runs SET github_run_id=123`;
     await sql`UPDATE configs SET hardware='h200'`;
@@ -104,30 +86,4 @@ describe('read-only required-power DB preflight', () => {
       fs.rmSync(dir, { recursive: true, force: true });
     }
   });
-  it('models mixed dates on same-attempt upserts instead of overlooking a newer snapshot', async () => {
-    await sql`UPDATE workflow_runs SET github_run_id=123`;
-    await addPoint(1);
-    await sql`UPDATE benchmark_results SET date='2026-09-10'`;
-    await sql`INSERT INTO workflow_runs (id,github_run_id,run_attempt,name,date,created_at,run_started_at)
-      VALUES (2,222,1,'competing','2026-09-12','2026-09-12T00:00:00Z','2026-09-12T00:00:00Z')`;
-    await sql`INSERT INTO benchmark_results (config_id,workflow_run_id,date,benchmark_type,isl,osl,conc,offload_mode,recipe_fingerprint,image,metrics)
-      VALUES (1,2,'2026-09-12','agentic_traces',NULL,NULL,8,'off',${'a'.repeat(64)},'example/serving:golden','{}')`;
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-dates-'));
-    try {
-      fs.cpSync(golden, dir, { recursive: true });
-      fs.mkdirSync(path.join(dir, 'results_optional'));
-      const row = JSON.parse(
-        fs.readFileSync(path.join(golden, 'bmk_agentic_golden/agg.json'), 'utf8'),
-      );
-      Object.assign(row, { conc: 4, users: 4 });
-      fs.writeFileSync(path.join(dir, 'results_optional/extra.json'), JSON.stringify(row));
-      await expect(preflightRequiredPowerCurves(sql, dir, source, options)).rejects.toThrow(
-        'shrink',
-      );
-      const published = await getLatestBenchmarks(sql, 'qwen3.5', '9999-12-31');
-      expect(published.map((point) => point.conc)).toEqual([8]);
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
 });
diff --git a/packages/db/src/etl/required-power-curve.test.ts b/packages/db/src/etl/required-power-curve.test.ts
index b94378c09..8dafa5033 100644
--- a/packages/db/src/etl/required-power-curve.test.ts
+++ b/packages/db/src/etl/required-power-curve.test.ts
@@ -45,28 +45,16 @@ describe('pure projected publication curve', () => {
     expect(() => assertCurvePreserved(old, proposed, policy)).toThrow('shrink');
     expect([...publishedCurve(old).values()][0]).toHaveLength(3);
   });
-  it('accepts a complete refresh and unrelated curve additions', () => {
+  it('does not inherit append-only history with an incompatible image', () => {
     const old = [point(1, 1), point(1, 16)];
-    expect(() =>
-      assertCurvePreserved(old, [...old, point(2, 1), point(2, 16)], policy),
-    ).not.toThrow();
     expect(() =>
       assertCurvePreserved(
         old,
-        [...old, point(2, 1, { identity: { ...identity, hardware: 'h200' } })],
+        [...old, point(2, 32, { appendOnly: true, image: 'new-image' })],
         policy,
       ),
-    ).not.toThrow();
+    ).toThrow('shrink');
   });
-  it.each([null, 'new-image'])(
-    'does not inherit append-only history with incompatible image %s',
-    (image) => {
-      const old = [point(1, 1), point(1, 16)];
-      expect(() =>
-        assertCurvePreserved(old, [...old, point(2, 32, { appendOnly: true, image })], policy),
-      ).toThrow('shrink');
-    },
-  );
   it('inherits only an uninterrupted same-image append-only chain', () => {
     const old = [point(1, 1), point(1, 16), point(2, 32, { appendOnly: true })];
     expect([...publishedCurve(old).values()][0].map((row) => row.identity.conc)).toEqual([
@@ -116,8 +104,4 @@ describe('pure projected publication curve', () => {
       ).toThrow('shrink');
     }
   });
-  it('does not let an older run replace newer curve state', () => {
-    const old = [point(2, 1), point(2, 16)];
-    expect(() => assertCurvePreserved(old, [...old, point(1, 1)], policy)).not.toThrow();
-  });
 });
diff --git a/packages/db/src/etl/required-power-publication.test.ts b/packages/db/src/etl/required-power-publication.test.ts
index 7ad044559..ec1822234 100644
--- a/packages/db/src/etl/required-power-publication.test.ts
+++ b/packages/db/src/etl/required-power-publication.test.ts
@@ -118,14 +118,6 @@ afterEach(() => {
 });
 
 describe('required power publication contract', () => {
-  it('accepts the shared producer golden fixture and an earlier declared attempt of the same head', () => {
-    expect(verifyRequiredPowerArtifacts(golden, source, true)).toMatchObject([
-      { conc: 1, benchmarkType: 'agentic_traces', metrics: { total_gpu_energy_j: 1000 } },
-    ]);
-    expect(verifyRequiredPowerArtifacts(golden, { ...source, runAttempt: 2 }, true)).toHaveLength(
-      1,
-    );
-  });
   it('fails missing required manifests even when changelog metadata is also missing', () => {
     const dir = fixture();
     fs.rmSync(path.join(dir, 'required-power-sweep-manifest'), { recursive: true });
@@ -134,24 +126,6 @@ describe('required power publication contract', () => {
     expect(() => verifyRequiredPowerArtifacts(dir, source, true)).toThrow('sweep manifest missing');
     expect(verifyRequiredPowerArtifacts(dir, source)).toEqual([]);
   });
-  it.each([undefined, 1, 3, '2'])(
-    'rejects missing or incompatible manifest version %s',
-    (version) => {
-      const dir = fixture();
-      changeManifest(dir, (manifest) => {
-        manifest['schema-version'] = version;
-      });
-      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('schema-version');
-    },
-  );
-  it.each(['agentic_golden/gpu_metrics.csv', auditPath, benchmarkPath])(
-    'rejects missing required artifact %s',
-    (file) => {
-      const dir = fixture();
-      fs.unlinkSync(path.join(dir, file));
-      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing required artifact');
-    },
-  );
   it('rejects hash mismatches and explicit invalid evidence', () => {
     const dir = fixture();
     fs.appendFileSync(path.join(dir, 'agentic_golden/gpu_metrics.csv'), '\n');
@@ -162,18 +136,15 @@ describe('required power publication contract', () => {
     });
     expect(() => verifyRequiredPowerArtifacts(invalid, source)).toThrow('validation');
   });
-  it.each([undefined, null, 0, -1, '1000'])(
-    'rejects missing, invalid and measured nonpositive energy separately: %s',
-    (energy) => {
-      const dir = fixture();
-      changeArtifact(dir, benchmarkPath, (rows) => {
-        rows.total_gpu_energy_j = energy;
-      });
-      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow(
-        'total_gpu_energy_j must be finite and positive',
-      );
-    },
-  );
+  it('rejects a measured zero energy', () => {
+    const dir = fixture();
+    changeArtifact(dir, benchmarkPath, (rows) => {
+      rows.total_gpu_energy_j = 0;
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow(
+      'total_gpu_energy_j must be finite and positive',
+    );
+  });
   it('does not replace canonical AgentX users with a conflicting raw conc', () => {
     const dir = fixture();
     changeArtifact(dir, benchmarkPath, (rows) => {
@@ -182,33 +153,6 @@ describe('required power publication contract', () => {
     });
     expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing benchmark point');
   });
-  it.each(['model', 'hardware', 'framework', 'precision'])(
-    'rejects substituted %s identity',
-    (field) => {
-      const dir = fixture();
-      changeManifest(dir, (manifest) => {
-        manifest.points[0].identity[field] = 'other';
-      });
-      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow(`${field} identity differs`);
-    },
-  );
-  it('rejects absent physical GPU, duplicate physical GPU, and changed measurement boundaries', () => {
-    for (const edit of [
-      (point: any) => {
-        point.devices = [];
-      },
-      (point: any) => {
-        point.devices[0].gpu_uuid = '0';
-      },
-      (point: any) => {
-        point.measurement_window.end_time_unix += 1;
-      },
-    ]) {
-      const dir = fixture();
-      changeManifest(dir, (manifest) => edit(manifest.points[0]));
-      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('Required power:');
-    }
-  });
   it('requires both prefill and decode physical evidence and matching role energy', () => {
     const dir = multinodeFixture();
     expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
@@ -224,51 +168,6 @@ describe('required power publication contract', () => {
       'prefill energy differs',
     );
   });
-  it('normalizes producer dp-attn strings and binds nested planned role topology', () => {
-    const dir = fixture();
-    changeArtifact(dir, benchmarkPath, (row) => {
-      row.dp_attention = 'false';
-    });
-    changeManifest(dir, (manifest) => {
-      manifest.points[0].topology.dp_attention = 'false';
-      manifest.matrix.single_node.agentic[0]['dp-attn'] = false;
-    });
-    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
-    const split = multinodeFixture();
-    changeManifest(split, (manifest) => {
-      manifest.matrix.multi_node.agentic[0].prefill = { tp: 8, 'num-worker': 1 };
-    });
-    expect(() => verifyRequiredPowerArtifacts(split, source)).toThrow(
-      'prefill_tp topology differs from required matrix',
-    );
-  });
-  it('supports fixed-window sidecar names and AMD physical UUID artifacts', () => {
-    const dir = fixture();
-    fs.renameSync(
-      path.join(dir, auditPath),
-      path.join(dir, 'agentic_golden/power_validation_conc1.json'),
-    );
-    fs.unlinkSync(path.join(dir, 'agentic_golden/gpu_metrics_identity.csv'));
-    const amdPath = 'agentic_golden/gpu_metrics_devices.json';
-    write(dir, amdPath, { devices: [{ gpu: 0, uuid: 'amd-physical-uuid' }] });
-    changeManifest(dir, (manifest) => {
-      const point = manifest.points[0];
-      point.devices[0].gpu_uuid = 'amd-physical-uuid';
-      point.artifacts = point.artifacts.filter(
-        (artifact: any) => !artifact.path.endsWith('gpu_metrics_identity.csv'),
-      );
-      point.artifacts.find((artifact: any) => artifact.path === auditPath).path =
-        'agentic_golden/power_validation_conc1.json';
-      point.artifacts.push({
-        path: amdPath,
-        sha256: createHash('sha256')
-          .update(fs.readFileSync(path.join(dir, amdPath)))
-          .digest('hex'),
-        validation_state: 'valid',
-      });
-    });
-    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
-  });
   it('rejects invalid sidecar verdict and device energy disagreement despite valid hashes', () => {
     const dir = fixture();
     changeArtifact(dir, auditPath, (audit) => {
@@ -281,27 +180,6 @@ describe('required power publication contract', () => {
     });
     expect(() => verifyRequiredPowerArtifacts(other, source)).toThrow('differs from audit');
   });
-  it('rejects duplicate points, required matrix omissions, wrong source, and paths outside the artifact root', () => {
-    const edits = [
-      (manifest: any) => {
-        manifest.points.push(manifest.points[0]);
-      },
-      (manifest: any) => {
-        manifest.matrix.single_node.agentic[0].conc = [1, 2];
-      },
-      (manifest: any) => {
-        manifest['run-id'] = 999;
-      },
-      (manifest: any) => {
-        manifest.points[0].artifacts[0].path = '../secret';
-      },
-    ];
-    for (const edit of edits) {
-      const dir = fixture();
-      changeManifest(dir, edit);
-      expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('Required power:');
-    }
-  });
   it('accepts identical aggregate copies but rejects conflicting duplicate rows', () => {
     const dir = fixture();
     fs.mkdirSync(path.join(dir, 'results_bmk'));
diff --git a/packages/db/src/etl/skip-tracker.test.ts b/packages/db/src/etl/skip-tracker.test.ts
index 0e3ba64ee..1851b0417 100644
--- a/packages/db/src/etl/skip-tracker.test.ts
+++ b/packages/db/src/etl/skip-tracker.test.ts
@@ -54,26 +54,6 @@ describe('recordDbError', () => {
   });
 });
 
-describe('recordTelemetryError', () => {
-  it('counts separately from dbError, which is the counter that fails the ingest', () => {
-    const tracker = createSkipTracker();
-    tracker.recordTelemetryError('gpu_metrics for dsv4-b200', new Error('malformed CSV'));
-    tracker.recordTelemetryError('gpu_metrics for dsv4-b300', new Error('malformed CSV'));
-    expect(tracker.skips.telemetryError).toBe(2);
-    expect(tracker.skips.dbError).toBe(0);
-  });
-
-  it('keeps its own print budget, so telemetry noise cannot silence DB errors', () => {
-    const tracker = createSkipTracker();
-    for (let i = 0; i < 15; i++) {
-      tracker.recordTelemetryError(`context ${i}`, new Error(`error ${i}`));
-    }
-    tracker.recordDbError('availability', new Error('boom'));
-    expect(tracker.skips.telemetryError).toBe(15);
-    expect(tracker.skips.dbError).toBe(1);
-  });
-});
-
 describe('snapshot', () => {
   it('captures current counters', () => {
     const tracker = createSkipTracker();
diff --git a/packages/db/src/etl/telemetry-receipt.test.ts b/packages/db/src/etl/telemetry-receipt.test.ts
index 417e91df7..661894867 100644
--- a/packages/db/src/etl/telemetry-receipt.test.ts
+++ b/packages/db/src/etl/telemetry-receipt.test.ts
@@ -1,382 +1,8 @@
-import fs from 'node:fs';
-import { createServer } from 'node:http';
-import os from 'node:os';
-import path from 'node:path';
-import { PGlite } from '@electric-sql/pglite';
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { DbClient } from '../connection';
-import { getGpuMetricsForPoint } from '../queries/gpu-metrics';
-import type * as DbUtils from './db-utils';
-import type { Sql } from './db-utils';
-import { ingestGpuMetricsArtifact } from './gpu-metrics-ingest';
-import {
-  fatalPublicationErrors,
-  stablePowerPointIdentity,
-  type PowerPublicationManifest,
-} from './power-publication';
-import {
-  readTelemetryReceipt,
-  summarizeTelemetryReceipt,
-  verifyTelemetryApi,
-  telemetryArtifactsForAttempt,
-  type TelemetryObservation,
-} from './telemetry-receipt';
+import { describe, expect, it } from 'vitest';
 
-let db: PGlite;
-let sql: Sql;
-const roots: string[] = [];
-const run = { runId: 123, runAttempt: 2 };
-vi.mock('./db-utils', async (importOriginal) => ({
-  ...(await importOriginal<typeof DbUtils>()),
-  createAdminSql: () => Object.assign(sql, { end: async () => {} }),
-}));
-function queryClient(database: Pick<PGlite, 'query'>) {
-  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
-    const text = strings.reduce((query, part, i) => query + (i ? `$${i}` : '') + part, '');
-    const result = await database.query(text, values);
-    return result.rows;
-  };
-  return Object.assign(client, { json: JSON.stringify, array: (value: unknown) => value });
-}
-
-beforeAll(async () => {
-  db = await PGlite.create();
-  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql'])
-    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
-  await db.exec(
-    "alter table benchmark_results add column offload_mode text not null default 'off'; alter table benchmark_results add column recipe_fingerprint text; alter table benchmark_results add column workers jsonb; alter table benchmark_results add column power_audit jsonb;",
-  );
-  sql = Object.assign(queryClient(db), {
-    begin: (fn: (tx: Sql) => Promise<unknown>) =>
-      db.transaction((tx) => fn(queryClient(tx) as unknown as Sql)),
-  }) as unknown as Sql;
-}, 20_000);
-
-beforeEach(async () => {
-  await db.exec(`truncate workflow_runs, configs restart identity cascade;
-    insert into workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
-    values (1, 123, 2, 'Sweep', '2026-09-21', '2026-09-21'),
-      (2, 123, 1, 'Previous attempt', '2026-09-20', '2026-09-20');
-    insert into configs (id, model, hardware, framework, precision, spec_method, prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
-    values (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', 1, 1, 1, 1);
-    insert into benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
-    values (10, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 1, '{}'),
-      (11, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 2, '{}'),
-      (12, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 3, '{}'),
-      (13, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 4, '{}'),
-      (20, 2, 1, 'single_turn', '2026-09-20', 8192, 1024, 1, '{}');`);
-});
-afterEach(() => {
-  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
-});
-afterAll(async () => {
-  await db?.close();
-});
-
-function artifact(name: string) {
-  const artifactDir = fs.mkdtempSync(path.join(os.tmpdir(), 'telemetry-receipt-'));
-  roots.push(artifactDir);
-  fs.writeFileSync(
-    path.join(artifactDir, 'gpu_metrics.csv'),
-    'timestamp, index, power.draw [W]\n2026/09/21 00:00:00.000, 0, 100 W\n2026/09/21 00:00:01.000, 0, 200 W',
-  );
-  return { artifactName: name, artifactDir };
-}
-async function observations(): Promise<TelemetryObservation[]> {
-  const rows =
-    await sql`select c.*, br.id, br.benchmark_type, br.isl, br.osl, br.conc, br.offload_mode, br.recipe_fingerprint
-    from benchmark_results br join configs c on c.id = br.config_id where br.workflow_run_id = 1 order by br.id`;
-  return rows.map((identity, i) => ({
-    identity,
-    artifactNames: [`gpu_metrics_point${i + 1}`],
-    produced: true,
-  }));
-}
+import { telemetryArtifactsForAttempt } from './telemetry-receipt';
 
 describe('telemetry attachment receipts', () => {
-  it.each(['object', 'encoded string', 'null', 'malformed', 'array', 'invalid inventory'])(
-    'reads persisted JSONB %s sidecars without confusing unknown inventory with DB failure',
-    async (encoding) => {
-      const points = await observations();
-      const shared = artifact('gpu_metrics_shared');
-      fs.writeFileSync(
-        path.join(shared.artifactDir, 'gpu_metrics_host2.csv'),
-        fs.readFileSync(path.join(shared.artifactDir, 'gpu_metrics.csv')),
-      );
-      await ingestGpuMetricsArtifact(sql, {
-        workflowRunId: 1,
-        artifact: shared,
-        benchmarkResultIds: [10, 11],
-      });
-      const stored = await db.query<{ sidecars: unknown }>(
-        'select sidecars from gpu_metric_series order by id',
-      );
-      const inventory = stored.rows[0]!.sidecars;
-      const value =
-        encoding === 'object'
-          ? inventory
-          : encoding === 'encoded string'
-            ? JSON.stringify(inventory)
-            : encoding === 'null'
-              ? null
-              : encoding === 'malformed'
-                ? '{broken'
-                : encoding === 'array'
-                  ? []
-                  : { seriesInventory: [{ fileName: 'gpu_metrics.csv', sampleCount: '2' }] };
-      await db.query('update gpu_metric_series set sidecars = $1::jsonb', [JSON.stringify(value)]);
-      const raw = await db.query<{ kind: string }>(
-        'select jsonb_typeof(sidecars) as kind from gpu_metric_series',
-      );
-      const kind =
-        encoding === 'encoded string' || encoding === 'malformed'
-          ? 'string'
-          : encoding === 'null'
-            ? 'null'
-            : encoding === 'array'
-              ? 'array'
-              : 'object';
-      expect(raw.rows).toEqual([{ kind }, { kind }]);
-      const receipt = await readTelemetryReceipt(
-        sql,
-        run,
-        points.slice(0, 2).map((point) => ({ ...point, artifactNames: [shared.artifactName] })),
-      );
-      const complete = encoding === 'object' || encoding === 'encoded string';
-      expect(receipt.databaseError).toBeUndefined();
-      expect(receipt.counts).toMatchObject({
-        expectedPoints: 4,
-        storedPoints: complete ? 2 : 0,
-        linkedPoints: complete ? 2 : 0,
-        storageUnknownPoints: complete ? 0 : 2,
-        storedSeries: 2,
-        storedSamples: 4,
-      });
-      for (const point of receipt.points.filter((candidate) =>
-        [10, 11].includes(candidate.benchmarkResultId!),
-      )) {
-        expect(point.storage.status).toBe(complete ? 'complete' : 'unknown');
-        expect(point.reasons).toEqual(complete ? [] : ['series_inventory_unknown']);
-        expect(point.linkedSeriesIds).toHaveLength(2);
-      }
-      const repaired = await readTelemetryReceipt(
-        sql,
-        run,
-        [{ ...points[0]!, artifactNames: [shared.artifactName] }],
-        { previous: receipt, targeted: true },
-      );
-      expect(repaired.points.filter((point) => point.benchmarkResultId !== 10)).toEqual(
-        receipt.points.filter((point) => point.benchmarkResultId !== 10),
-      );
-      expect(repaired.counts).toEqual(receipt.counts);
-    },
-  );
-
-  it('keeps a database query failure separate from an unknown stored inventory', async () => {
-    await db.exec('alter table gpu_metric_series rename to unavailable_gpu_metric_series');
-    try {
-      const receipt = await readTelemetryReceipt(sql, run, await observations());
-      expect(receipt.databaseError).toContain('gpu_metric_series');
-      expect(receipt.counts).toMatchObject({
-        expectedPoints: 4,
-        storedPoints: null,
-        linkedPoints: null,
-        storedSeries: null,
-        storedSamples: null,
-      });
-      expect(receipt.points.every((point) => point.reasons.includes('database_check_failed'))).toBe(
-        true,
-      );
-      expect(
-        receipt.points.every((point) => !point.reasons.includes('series_inventory_unknown')),
-      ).toBe(true);
-    } finally {
-      await db.exec('alter table unavailable_gpu_metric_series rename to gpu_metric_series');
-    }
-  });
-
-  it('preserves an unrelated prior artifact failure at the canonical offload identity', async () => {
-    await db.exec("UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10");
-    const [canonical] = await observations();
-    canonical!.error = 'prior artifact failed';
-    const previous = await readTelemetryReceipt(sql, run, [canonical!]);
-    const alias = {
-      identity: { ...canonical!.identity, offload_mode: 'off' },
-      artifactNames: ['gpu_metrics_other'],
-      produced: true,
-    };
-    const receipt = await readTelemetryReceipt(sql, run, [alias], {
-      previous,
-      targeted: true,
-      uniqueFallbacks: new Map([[stablePowerPointIdentity(alias.identity), 10]]),
-    });
-    expect(receipt.points.find((p) => p.benchmarkResultId === 10)).toEqual(
-      previous.points.find((p) => p.benchmarkResultId === 10),
-    );
-    expect(receipt.counts.expectedPoints).toBeNull();
-  });
-
-  it('retains conflicting artifact observations when a historical fallback reaches an occupied identity', async () => {
-    await db.exec("UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 10");
-    const [canonical] = await observations();
-    const alias = {
-      ...canonical!,
-      identity: { ...canonical!.identity, offload_mode: 'off' },
-      artifactNames: ['gpu_metrics_other'],
-      error: 'failed correction',
-    };
-    const receipt = await readTelemetryReceipt(sql, run, [canonical!, alias], {
-      uniqueFallbacks: new Map([[stablePowerPointIdentity(alias.identity), 10]]),
-    });
-    expect(receipt.counts.expectedPoints).toBeNull();
-    expect(
-      receipt.points.find((p) => p.key === stablePowerPointIdentity(alias.identity)),
-    ).toMatchObject({
-      error: 'failed correction',
-      benchmarkResultId: null,
-      artifactNames: ['gpu_metrics_other'],
-    });
-    expect(receipt.points.find((p) => p.benchmarkResultId === 10)?.artifactNames).toEqual(
-      canonical!.artifactNames,
-    );
-  });
-
-  it.each([11, 20])(
-    'does not canonicalize a fallback to a different point or attempt (id=%s)',
-    async (id) => {
-      const [source] = await observations();
-      const alias = { ...source!, identity: { ...source!.identity, offload_mode: 'on' } };
-      const previous = await readTelemetryReceipt(sql, run, [alias]);
-      const receipt = await readTelemetryReceipt(sql, run, [alias], {
-        previous,
-        targeted: true,
-        uniqueFallbacks: new Map([[stablePowerPointIdentity(alias.identity), id]]),
-      });
-      expect(receipt.counts.expectedPoints).toBe(previous.counts.expectedPoints);
-      expect(
-        receipt.points.find((p) => p.key === stablePowerPointIdentity(alias.identity)),
-      ).toMatchObject({
-        benchmarkResultId: null,
-        identity: { conc: 1, offload_mode: 'on' },
-      });
-    },
-  );
-
-  it('persists real HTTP query results through the publication verifier without failing benchmark publication', async () => {
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: artifact('gpu_metrics_point1'),
-      benchmarkResultIds: [10],
-    });
-    const points = await observations();
-    points[1]!.produced = false;
-    const telemetry = await readTelemetryReceipt(sql, run, points, {
-      expectedSource: 'benchmark_artifacts',
-    });
-    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'telemetry-verifier-'));
-    roots.push(directory);
-    const manifestPath = path.join(directory, 'power-publication.json');
-    const manifest: PowerPublicationManifest = {
-      version: 1,
-      ...run,
-      points: points.map((point) => ({
-        identity: point.identity,
-        metrics: {},
-        workers: null,
-        power_invalid_reasons: null,
-        power_audit: null,
-        artifact: { path: 'bmk_fixture/results.json', sha256: 'fixture' },
-      })),
-      telemetryWarnings: ['Fixture telemetry unavailable for three benchmark points'],
-      telemetry,
-    };
-    fs.writeFileSync(manifestPath, JSON.stringify(manifest));
-    const requests: string[] = [];
-    let unavailable = false;
-    // Exercise the production SQL reader over loopback HTTP. This does not
-    // stand in for a Next deployment, Blob/CDN, or retained-artifact replay.
-    const server = createServer(async (request, response) => {
-      try {
-        const url = new URL(request.url!, 'http://127.0.0.1');
-        requests.push(url.pathname + url.search);
-        let payload: unknown;
-        if (url.pathname === '/api/v1/benchmarks') {
-          payload = await sql`select c.*, br.* from benchmark_results br
-            join configs c on c.id = br.config_id where br.workflow_run_id = 1`;
-        } else if (unavailable) {
-          response.writeHead(503).end();
-          return;
-        } else {
-          payload = await getGpuMetricsForPoint(
-            sql as unknown as DbClient,
-            Number(url.searchParams.get('id')),
-          );
-        }
-        response.writeHead(payload ? 200 : 404, { 'Content-Type': 'application/json' });
-        response.end(JSON.stringify(payload));
-      } catch (error) {
-        response.writeHead(500).end(String(error));
-      }
-    });
-    await new Promise<void>((resolve) => {
-      server.listen(0, '127.0.0.1', resolve);
-    });
-    const address = server.address();
-    if (!address || typeof address === 'string') throw new Error('Expected TCP address');
-    const originalArgv = process.argv;
-    const originalExitCode = process.exitCode;
-    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      process.argv = [
-        'bun',
-        'verify-power-publication.ts',
-        manifestPath,
-        `http://127.0.0.1:${address.port}`,
-      ];
-      await import('../verify-power-publication');
-      const result = JSON.parse(fs.readFileSync(`${manifestPath}.verification.json`, 'utf8'));
-      const updated = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-      expect(result).toMatchObject({ status: 'matched', points: 4, errors: [] });
-      expect(result.telemetryWarnings).toEqual(manifest.telemetryWarnings);
-      expect(result.telemetry).toEqual(updated.telemetry);
-      expect(result.telemetry.counts).toMatchObject({
-        expectedPoints: 4,
-        apiReadablePoints: 1,
-        apiCompletePoints: 1,
-        apiUnknownPoints: 0,
-      });
-      expect(result.telemetry.plannedPointCount).toBeNull();
-      expect(requests).toHaveLength(5);
-      expect(requests[0]).toContain('runId=123&exactRun=true');
-      expect(
-        result.telemetry.points.find(
-          (point: { benchmarkResultId: number }) => point.benchmarkResultId === 11,
-        ).api.error,
-      ).toBe('HTTP 404');
-      expect(process.exitCode).toBe(originalExitCode);
-
-      unavailable = true;
-      vi.resetModules();
-      await import('../verify-power-publication');
-      const failed = JSON.parse(fs.readFileSync(`${manifestPath}.verification.json`, 'utf8'));
-      expect(failed).toMatchObject({ status: 'matched', errors: [] });
-      expect(failed.telemetry.counts).toMatchObject({ apiReadablePoints: 0, apiCompletePoints: 0 });
-      expect(
-        failed.telemetry.points.every(
-          (point: { api: { error: string } }) => point.api.error === 'HTTP 503',
-        ),
-      ).toBe(true);
-      expect(process.exitCode).toBe(originalExitCode);
-    } finally {
-      process.argv = originalArgv;
-      process.exitCode = originalExitCode;
-      log.mockRestore();
-      await new Promise<void>((resolve, reject) => {
-        server.close((error) => (error ? reject(error) : resolve()));
-      });
-    }
-  });
-
   it('isolates the source attempt before selecting or downloading artifact pairs', () => {
     const old = {
       name: 'gpu_metrics_old',
@@ -395,446 +21,4 @@ describe('telemetry attachment receipts', () => {
       'start time',
     );
   });
-  it('retains missing/failed/unlinked point identities and targeted recovery changes only the repaired point', async () => {
-    const points = await observations();
-    const first = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: artifact('gpu_metrics_point1'),
-      benchmarkResultIds: [10],
-    });
-    points[1]!.produced = false;
-    const badArtifact = artifact('gpu_metrics_point3');
-    fs.writeFileSync(
-      path.join(badArtifact.artifactDir, 'gpu_metrics.csv'),
-      'timestamp, index, power.draw [W]\n2026/09/21 00:00:00.000, 999999, 100 W',
-    );
-    try {
-      await ingestGpuMetricsArtifact(sql, {
-        workflowRunId: 1,
-        artifact: badArtifact,
-        benchmarkResultIds: [12],
-      });
-      throw new Error('Expected the invalid GPU index to fail persistence');
-    } catch (error) {
-      points[2]!.error = error instanceof Error ? error.message : String(error);
-    }
-    expect(points[2]!.error).toContain('smallint');
-    const orphan = artifact('gpu_metrics_point4');
-    const fourth = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: orphan,
-      benchmarkResultIds: [13],
-    });
-    await sql`delete from benchmark_result_gpu_metrics where benchmark_result_id = 13`;
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 2,
-      artifact: artifact('gpu_metrics_point1'),
-      benchmarkResultIds: [20],
-    });
-    const receipt = await readTelemetryReceipt(sql, run, points, {
-      expectedSource: 'benchmark_artifacts',
-    });
-    expect(receipt.counts).toEqual({
-      expectedPoints: 4,
-      producedPoints: 3,
-      productionUnknownPoints: 0,
-      storedPoints: 2,
-      linkedPoints: 1,
-      storageUnknownPoints: 0,
-      apiReadablePoints: 0,
-      apiCompletePoints: 0,
-      apiUnknownPoints: 4,
-      producedArtifacts: 3,
-      storedSeries: 2,
-      storedSamples: 4,
-    });
-    expect(receipt.plannedPointCount).toBeNull();
-    expect(receipt.points.find((p) => p.benchmarkResultId === 11)?.reasons).toContain(
-      'artifact_missing',
-    );
-    expect(receipt.points.find((p) => p.benchmarkResultId === 12)).toMatchObject({
-      error: points[2]!.error,
-      reasons: ['ingest_failed', 'series_not_stored'],
-    });
-    const missingLink = receipt.points.find((p) => p.benchmarkResultId === 13)!;
-    expect(missingLink.reasons).toEqual(['point_link_missing']);
-    expect(missingLink.series).toEqual([
-      {
-        id: fourth.seriesIds[0],
-        artifactName: 'gpu_metrics_point4',
-        fileName: 'gpu_metrics.csv',
-        sampleCount: 2,
-      },
-    ]);
-    expect(missingLink.recovery).toEqual({
-      runId: 123,
-      runAttempt: 2,
-      artifactNames: ['gpu_metrics_point4'],
-    });
-    receipt.expectationErrors = [
-      {
-        benchmarkArtifact: 'bmk_unreadable',
-        artifactNames: ['gpu_metrics_unreadable'],
-        error: 'Download failed',
-      },
-    ];
-    expect(summarizeTelemetryReceipt(receipt).counts.expectedPoints).toBeNull();
-    const refreshed = await readTelemetryReceipt(sql, run, points, { previous: receipt });
-    expect(refreshed.expectationErrors).toEqual(receipt.expectationErrors);
-    expect(refreshed.counts.expectedPoints).toBeNull();
-    const recovered = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: orphan,
-      benchmarkResultIds: [13],
-    });
-    expect(recovered.samplesInserted).toBe(0);
-    const repaired = await readTelemetryReceipt(sql, run, [points[3]!], {
-      previous: receipt,
-      targeted: true,
-    });
-    expect(repaired.points).toHaveLength(4);
-    expect(repaired.expectationErrors).toEqual(receipt.expectationErrors);
-    expect(repaired.counts.expectedPoints).toBeNull();
-    expect(repaired.counts).toMatchObject({ storedSeries: 2, storedSamples: 4, linkedPoints: 2 });
-    expect(repaired.points.find((p) => p.benchmarkResultId === 13)?.reasons).toEqual([]);
-    expect(repaired.points.filter((p) => p.benchmarkResultId !== 13)).toEqual(
-      receipt.points.filter((p) => p.benchmarkResultId !== 13),
-    );
-    expect(repaired.points.find((p) => p.benchmarkResultId === 10)?.series).toEqual([
-      {
-        id: first.seriesIds[0],
-        artifactName: 'gpu_metrics_point1',
-        fileName: 'gpu_metrics.csv',
-        sampleCount: 2,
-      },
-    ]);
-    expect(fatalPublicationErrors({ telemetryWarnings: ['CSV parse failed'] }, [])).toEqual([]);
-  });
-
-  it('counts a shared series once and keeps unavailable expectations unknown', async () => {
-    const points = await observations();
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: artifact('gpu_metrics_shared'),
-      benchmarkResultIds: [10, 11],
-    });
-    const receipt = await readTelemetryReceipt(
-      sql,
-      run,
-      points.slice(0, 2).map((p) => ({ ...p, artifactNames: ['gpu_metrics_shared'] })),
-    );
-    expect(receipt.counts).toMatchObject({
-      expectedPoints: 4,
-      storedPoints: 2,
-      linkedPoints: 2,
-      storedSeries: 1,
-      storedSamples: 2,
-      productionUnknownPoints: 2,
-    });
-    const unavailable = await readTelemetryReceipt(sql, { runId: 999, runAttempt: 1 }, [], {
-      expectedSource: 'unknown',
-    });
-    expect(unavailable.counts.expectedPoints).toBeNull();
-    await expect(
-      readTelemetryReceipt(sql, { runId: 123, runAttempt: 1 }, [], { previous: receipt }),
-    ).rejects.toThrow('run/attempt');
-  });
-
-  it('keeps a partial host artifact incomplete until targeted recovery restores its inventory', async () => {
-    const points = await observations();
-    const multi = artifact('gpu_metrics_point1');
-    const csv = fs.readFileSync(path.join(multi.artifactDir, 'gpu_metrics.csv'));
-    fs.unlinkSync(path.join(multi.artifactDir, 'gpu_metrics.csv'));
-    for (const host of ['host-a', 'host-b']) {
-      fs.mkdirSync(path.join(multi.artifactDir, host));
-      fs.writeFileSync(path.join(multi.artifactDir, host, 'gpu_metrics.csv'), csv);
-    }
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: multi,
-      benchmarkResultIds: [10],
-    });
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: artifact('gpu_metrics_point4'),
-      benchmarkResultIds: [13],
-    });
-    await sql`delete from gpu_metric_series where file_name = 'host-b/gpu_metrics.csv'`;
-    const receipt = await readTelemetryReceipt(sql, run, points);
-    const partial = receipt.points.find((point) => point.benchmarkResultId === 10)!;
-    expect(partial.storage).toEqual({
-      status: 'incomplete',
-      expectedSeries: [
-        { artifactName: 'gpu_metrics_point1', fileName: 'host-a/gpu_metrics.csv', sampleCount: 2 },
-        { artifactName: 'gpu_metrics_point1', fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
-      ],
-    });
-    expect(partial.series).toMatchObject([{ fileName: 'host-a/gpu_metrics.csv', sampleCount: 2 }]);
-    expect(partial.reasons).toContain('series_coverage_incomplete');
-    expect(partial.recovery).toEqual({ ...run, artifactNames: ['gpu_metrics_point1'] });
-    expect(receipt.counts).toMatchObject({
-      storedPoints: 1,
-      linkedPoints: 1,
-      storedSeries: 2,
-      storedSamples: 4,
-    });
-    await verifyTelemetryApi(receipt, 'http://local.test', {
-      fetch: (input) =>
-        Promise.resolve(
-          new URL(String(input)).searchParams.get('id') === '10'
-            ? Response.json({
-                benchmarkResultId: 10,
-                series: partial.series.map((entry) => ({
-                  id: entry.id,
-                  sampleCount: entry.sampleCount,
-                  data: [{ power: 100 }, { power: 200 }],
-                })),
-              })
-            : new Response('missing', { status: 404 }),
-        ),
-    });
-    expect(partial.api.status).toBe('readable');
-    expect(receipt.counts).toMatchObject({ apiReadablePoints: 1, apiCompletePoints: 0 });
-    const recovered = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: multi,
-      benchmarkResultIds: [10],
-    });
-    expect(recovered).toMatchObject({ seriesSkipped: 1, samplesInserted: 2 });
-    const repaired = await readTelemetryReceipt(sql, run, [points[0]!], {
-      previous: receipt,
-      targeted: true,
-    });
-    const repairedPoint = repaired.points.find((point) => point.benchmarkResultId === 10)!;
-    expect(repairedPoint.storage.status).toBe('complete');
-    expect(repairedPoint.reasons).toEqual([]);
-    expect(repairedPoint.api.status).toBe('unknown');
-    expect(repaired.counts).toMatchObject({
-      storedPoints: 2,
-      linkedPoints: 2,
-      storedSeries: 3,
-      storedSamples: 6,
-    });
-    expect(repaired.points.filter((point) => point.benchmarkResultId !== 10)).toEqual(
-      receipt.points.filter((point) => point.benchmarkResultId !== 10),
-    );
-    const replay = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: multi,
-      benchmarkResultIds: [10],
-    });
-    expect(replay).toMatchObject({ seriesSkipped: 2, samplesInserted: 0 });
-    const sampleCount = await sql`select count(*)::int as count from gpu_metric_samples`;
-    expect(sampleCount).toEqual([{ count: 6 }]);
-  });
-
-  it('distinguishes missing sample coverage from legacy unknown inventory', async () => {
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: artifact('gpu_metrics_point1'),
-      benchmarkResultIds: [10],
-    });
-    await sql`delete from gpu_metric_samples where sampled_at = '2026-09-21T00:00:01Z'`;
-    const partial = await readTelemetryReceipt(sql, run, await observations());
-    expect(partial.points.find((point) => point.benchmarkResultId === 10)?.reasons).toContain(
-      'sample_coverage_incomplete',
-    );
-    expect(partial.counts).toMatchObject({ storedPoints: 0, linkedPoints: 0, storedSamples: 1 });
-    await sql`update gpu_metric_series set sidecars = sidecars - 'seriesInventory'`;
-    const legacy = await readTelemetryReceipt(sql, run, await observations());
-    expect(legacy.points.find((point) => point.benchmarkResultId === 10)).toMatchObject({
-      storage: { status: 'unknown', expectedSeries: null },
-      reasons: ['series_inventory_unknown'],
-    });
-    expect(legacy.counts).toMatchObject({
-      storedPoints: 0,
-      linkedPoints: 0,
-      storageUnknownPoints: 1,
-    });
-  });
-
-  it('does not count readable old data as a successful corrective ingest', async () => {
-    const source = artifact('gpu_metrics_point1');
-    const csvPath = path.join(source.artifactDir, 'gpu_metrics.csv');
-    const originalCsv = fs.readFileSync(csvPath, 'utf8');
-    const original = await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: source,
-      benchmarkResultIds: [10],
-    });
-    const points = await observations();
-    fs.writeFileSync(csvPath, originalCsv.replaceAll(', 0,', ', 999999,'));
-    try {
-      await ingestGpuMetricsArtifact(sql, {
-        workflowRunId: 1,
-        artifact: source,
-        benchmarkResultIds: [10],
-      });
-      throw new Error('Expected the corrective ingest to fail');
-    } catch (error) {
-      points[0]!.error = error instanceof Error ? error.message : String(error);
-    }
-    expect(points[0]!.error).toContain('smallint');
-    const failed = await readTelemetryReceipt(sql, run, points);
-    const fetcher: typeof fetch = (input) =>
-      Promise.resolve(
-        new URL(String(input)).searchParams.get('id') === '10'
-          ? Response.json({
-              benchmarkResultId: 10,
-              series: [
-                {
-                  id: original.seriesIds[0],
-                  sampleCount: 2,
-                  data: [{ power: 100 }, { power: 200 }],
-                },
-              ],
-            })
-          : new Response('missing', { status: 404 }),
-      );
-    await verifyTelemetryApi(failed, 'http://local.test', { fetch: fetcher });
-    expect(failed.points.find((point) => point.benchmarkResultId === 10)).toMatchObject({
-      storage: { status: 'complete' },
-      api: { status: 'readable' },
-      reasons: ['ingest_failed'],
-    });
-    expect(failed.counts).toMatchObject({
-      storedPoints: 1,
-      apiReadablePoints: 1,
-      apiCompletePoints: 0,
-    });
-
-    fs.writeFileSync(csvPath, originalCsv);
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: source,
-      benchmarkResultIds: [10],
-    });
-    delete points[0]!.error;
-    const repaired = await readTelemetryReceipt(sql, run, [points[0]!], {
-      previous: failed,
-      targeted: true,
-    });
-    await verifyTelemetryApi(repaired, 'http://local.test', { fetch: fetcher });
-    expect(repaired.points.find((point) => point.benchmarkResultId === 10)?.error).toBeUndefined();
-    expect(repaired.counts.apiCompletePoints).toBe(1);
-
-    repaired.recoveryError = 'Artifact recovery did not finish';
-    repaired.recoveryArtifactNames = ['gpu_metrics_point1'];
-    expect(summarizeTelemetryReceipt(repaired).counts).toMatchObject({
-      apiReadablePoints: 1,
-      apiCompletePoints: 0,
-    });
-    const retried = await readTelemetryReceipt(sql, run, [points[0]!], {
-      previous: repaired,
-      targeted: true,
-    });
-    await verifyTelemetryApi(retried, 'http://local.test', { fetch: fetcher });
-    expect(retried.recoveryError).toBeUndefined();
-    expect(retried.counts.apiCompletePoints).toBe(1);
-  });
-
-  it('does not clear a failed recovery when only an unrelated artifact is repaired', async () => {
-    const points = await observations();
-    for (const index of [0, 1])
-      await ingestGpuMetricsArtifact(sql, {
-        workflowRunId: 1,
-        artifact: artifact(`gpu_metrics_point${index + 1}`),
-        benchmarkResultIds: [10 + index],
-      });
-    const previous = await readTelemetryReceipt(sql, run, points);
-    previous.recoveryError = 'No retained telemetry pair for gpu_metrics_point1';
-    previous.recoveryArtifactNames = ['gpu_metrics_point1'];
-    const stillMissing = await readTelemetryReceipt(
-      sql,
-      run,
-      [{ ...points[0]!, produced: false }, points[1]!],
-      { previous },
-    );
-    expect(stillMissing.recoveryError).toBe(previous.recoveryError);
-    expect(stillMissing.recoveryArtifactNames).toEqual(['gpu_metrics_point1']);
-    const unrelated = await readTelemetryReceipt(sql, run, [points[1]!], {
-      previous,
-      targeted: true,
-    });
-    expect(unrelated.recoveryError).toBe(previous.recoveryError);
-    expect(unrelated.recoveryArtifactNames).toEqual(['gpu_metrics_point1']);
-    await verifyTelemetryApi(unrelated, 'http://local.test', {
-      fetch: async (input) => {
-        const payload = await getGpuMetricsForPoint(
-          sql as unknown as DbClient,
-          Number(new URL(String(input)).searchParams.get('id')),
-        );
-        return payload ? Response.json(payload) : new Response(null, { status: 404 });
-      },
-    });
-    expect(unrelated.counts).toMatchObject({ apiReadablePoints: 2, apiCompletePoints: 0 });
-    const recovered = await readTelemetryReceipt(sql, run, [points[0]!], {
-      previous: unrelated,
-      targeted: true,
-    });
-    expect(recovered.recoveryError).toBeUndefined();
-    expect(recovered.recoveryArtifactNames).toBeUndefined();
-
-    previous.recoveryArtifactNames = ['gpu_metrics_point1', 'gpu_metrics_point2'];
-    const firstRepair = await readTelemetryReceipt(sql, run, [points[0]!], {
-      previous,
-      targeted: true,
-    });
-    expect(firstRepair.recoveryArtifactNames).toEqual(['gpu_metrics_point2']);
-    const secondRepair = await readTelemetryReceipt(sql, run, [points[1]!], {
-      previous: firstRepair,
-      targeted: true,
-    });
-    expect(secondRepair.recoveryError).toBeUndefined();
-
-    delete previous.recoveryArtifactNames;
-    const legacy = await readTelemetryReceipt(sql, run, [points[0]!], {
-      previous,
-      targeted: true,
-    });
-    expect(legacy.recoveryError).toBe(previous.recoveryError);
-    const partialRefresh = await readTelemetryReceipt(sql, run, [points[0]!], { previous: legacy });
-    expect(partialRefresh.recoveryError).toBe(previous.recoveryError);
-    const refreshed = await readTelemetryReceipt(sql, run, points, { previous: legacy });
-    expect(refreshed.recoveryError).toBeUndefined();
-  });
-
-  it('advances API readability only after the matching HTTP payload, preserving 404/error evidence', async () => {
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: artifact('gpu_metrics_point1'),
-      benchmarkResultIds: [10],
-    });
-    const receipt = await readTelemetryReceipt(sql, run, await observations());
-    const point = receipt.points.find((p) => p.benchmarkResultId === 10)!;
-    const requests: string[] = [];
-    const fetcher: typeof fetch = (input) => {
-      const url = new URL(String(input));
-      requests.push(url.toString());
-      if (url.searchParams.get('id') !== '10')
-        return Promise.resolve(new Response('missing', { status: 404 }));
-      return Promise.resolve(
-        Response.json({
-          benchmarkResultId: 10,
-          series: [
-            { id: point.series[0]!.id, sampleCount: 2, data: [{ power: 100 }, { power: 200 }] },
-          ],
-        }),
-      );
-    };
-    expect(receipt.counts.apiReadablePoints).toBe(0);
-    const checked = await verifyTelemetryApi(receipt, 'http://local.test', { fetch: fetcher });
-    expect(requests).toHaveLength(4);
-    expect(checked.counts).toMatchObject({
-      apiReadablePoints: 1,
-      apiCompletePoints: 1,
-      apiUnknownPoints: 0,
-    });
-    expect(point.api.status).toBe('readable');
-    expect(checked.points.find((p) => p.benchmarkResultId === 11)?.api.error).toBe('HTTP 404');
-    await verifyTelemetryApi(receipt, 'http://local.test', {
-      fetch: () => Promise.resolve(Response.json({ benchmarkResultId: 10, series: [] })),
-    });
-    expect(point.api.status).toBe('failed');
-  });
 });
diff --git a/packages/db/src/ingest-ci-run.test.ts b/packages/db/src/ingest-ci-run.test.ts
index cc464e52d..520028343 100644
--- a/packages/db/src/ingest-ci-run.test.ts
+++ b/packages/db/src/ingest-ci-run.test.ts
@@ -6,10 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { describe, expect, it } from 'vitest';
 
 describe('explicit download attempt identity', () => {
-  it.each([
-    { requestedAttempt: 1, expectedStatus: 1 },
-    { requestedAttempt: 2, expectedStatus: 0 },
-  ])('checks the requested attempt $requestedAttempt', ({ requestedAttempt, expectedStatus }) => {
+  it('rejects a download whose GitHub attempt differs from the requested one', () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'attempt-ingest-'));
     const manifestPath = path.join(dir, 'power-publication.json');
     try {
@@ -23,7 +20,7 @@ describe('explicit download attempt identity', () => {
         [
           fileURLToPath(new URL('ingest-ci-run.ts', import.meta.url)),
           '--download',
-          `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/25199291771/attempts/${requestedAttempt}`,
+          'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/25199291771/attempts/1',
         ],
         {
           cwd: dir,
@@ -40,13 +37,9 @@ describe('explicit download attempt identity', () => {
         },
       );
       expect(result.error).toBeUndefined();
-      expect(result.status, result.stderr).toBe(expectedStatus);
-      if (expectedStatus === 0) {
-        expect(JSON.parse(fs.readFileSync(manifestPath, 'utf8')).runAttempt).toBe(2);
-      } else {
-        expect(result.stderr).toContain('GitHub attempt 2 differs from requested 1');
-        expect(fs.existsSync(manifestPath)).toBe(false);
-      }
+      expect(result.status, result.stderr).toBe(1);
+      expect(result.stderr).toContain('GitHub attempt 2 differs from requested 1');
+      expect(fs.existsSync(manifestPath)).toBe(false);
     } finally {
       fs.rmSync(dir, { recursive: true, force: true });
     }
diff --git a/packages/db/src/ingest-ci-telemetry.test.ts b/packages/db/src/ingest-ci-telemetry.test.ts
deleted file mode 100644
index 0d0506b2f..000000000
--- a/packages/db/src/ingest-ci-telemetry.test.ts
+++ /dev/null
@@ -1,219 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, expect, it, vi } from 'vitest';
-import type * as DbUtils from './etl/db-utils';
-import type * as ConfigCache from './etl/config-cache';
-import type * as BenchmarkIngest from './etl/benchmark-ingest';
-import type * as ChangelogIngest from './etl/changelog-ingest';
-import type * as TelemetryReceipt from './etl/telemetry-receipt';
-import type * as RunOverrides from './etl/run-overrides';
-
-const mocks = vi.hoisted(() => ({
-  finish: undefined as (() => void) | undefined,
-  persistBenchmark: vi.fn(() => Promise.resolve({ newCount: 1, dupCount: 0, insertedIds: [10] })),
-  configFailure: false,
-  purgeExtra: false,
-  serverLogFailure: false,
-}));
-vi.mock('./etl/db-utils', async (importOriginal) => ({
-  ...(await importOriginal<typeof DbUtils>()),
-  createAdminSql: () =>
-    Object.assign(() => Promise.resolve([{ n: 1 }]), {
-      end: () => Promise.resolve(mocks.finish?.()),
-    }),
-  refreshLatestBenchmarks: async () => {},
-}));
-vi.mock('./etl/config-cache', async (importOriginal) => ({
-  ...(await importOriginal<typeof ConfigCache>()),
-  createConfigCache: () => ({
-    getOrCreateConfig: (config: { hardware: string }) =>
-      mocks.configFailure && config.hardware === 'b200'
-        ? Promise.reject(new Error('Fixture config failure'))
-        : Promise.resolve(1),
-    preloadConfigs: async () => {},
-    size: 1,
-  }),
-}));
-vi.mock('./etl/workflow-run', () => ({
-  createWorkflowRunServices: () => ({
-    fetchGithubRun: () => Promise.resolve({ createdAt: '2026-09-21T00:00:00Z' }),
-    getOrCreateWorkflowRun: () => Promise.resolve(1),
-  }),
-}));
-vi.mock('./etl/benchmark-ingest', async (importOriginal) => ({
-  ...(await importOriginal<typeof BenchmarkIngest>()),
-  bulkIngestBenchmarkRows: mocks.persistBenchmark,
-  bulkUpsertAvailability: async () => {},
-  insertServerLogFiles: () => Promise.reject(new Error('Fixture server log failure')),
-}));
-vi.mock('./etl/changelog-ingest', async (importOriginal) => ({
-  ...(await importOriginal<typeof ChangelogIngest>()),
-  ingestChangelogEntries: () => Promise.resolve(1),
-}));
-vi.mock('./etl/telemetry-receipt', async (importOriginal) => ({
-  ...(await importOriginal<typeof TelemetryReceipt>()),
-  readTelemetryReceipt: (
-    _sql: unknown,
-    run: unknown,
-    observations: unknown,
-    options: { expectedSource: string },
-  ) =>
-    Promise.resolve({
-      run,
-      points: observations,
-      expectedSource: options.expectedSource,
-    }),
-}));
-vi.mock('./etl/run-overrides', async (importOriginal) => {
-  const actual = await importOriginal<typeof RunOverrides>();
-  return {
-    ...actual,
-    isBenchmarkPointPurged: (...args: Parameters<typeof RunOverrides.isBenchmarkPointPurged>) =>
-      (mocks.purgeExtra && args[2].conc === 2) || actual.isBenchmarkPointPurged(...args),
-  };
-});
-
-beforeEach(() => {
-  vi.resetModules();
-  vi.clearAllMocks();
-  mocks.configFailure = false;
-  mocks.purgeExtra = false;
-  mocks.serverLogFailure = false;
-});
-
-afterEach(() => {
-  vi.unstubAllEnvs();
-  vi.restoreAllMocks();
-});
-
-interface Scenario {
-  name: string;
-  extra?: Record<string, unknown> | string;
-  unknown?: boolean;
-  configFailure?: boolean;
-  purgeExtra?: boolean;
-  serverLogFailure?: boolean;
-  ingestError?: string;
-}
-const scenarios: Scenario[] = [
-  { name: 'unreadable telemetry alone' },
-  {
-    name: 'unreadable benchmark JSON',
-    extra: '{',
-    unknown: true,
-    ingestError: 'Unreadable benchmark JSON: bmk_agentic_extra/agg.json',
-  },
-  { name: 'non-object benchmark JSON', extra: '42', unknown: true },
-  { name: 'unmapped model', extra: { infmax_model_prefix: 'unknown-model' }, unknown: true },
-  { name: 'unmapped hardware', extra: { hw: 'unknown-hardware' }, unknown: true },
-  { name: 'missing concurrency', extra: { users: null, conc: null }, unknown: true },
-  {
-    name: 'missing sequence length',
-    extra: { scenario_type: 'single_turn', isl: null, osl: 1024 },
-    unknown: true,
-  },
-  {
-    name: 'config resolution failure',
-    extra: { hw: 'b200' },
-    configFailure: true,
-    unknown: true,
-    ingestError: '1 database ingest errors',
-  },
-  { name: 'explicit failed benchmark', extra: { benchmark_outcome: { status: 'failed' } } },
-  {
-    name: 'zero successful requests',
-    extra: { num_requests_total: 2, num_requests_successful: 0 },
-  },
-  { name: 'purged benchmark', extra: {}, purgeExtra: true },
-  {
-    name: 'unrelated server log failure',
-    serverLogFailure: true,
-    ingestError: '1 database ingest errors',
-  },
-];
-
-it.each(scenarios)(
-  'keeps the benchmark and honest expectation scope with $name',
-  async (scenario) => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ci-telemetry-'));
-    const originalArgv = process.argv;
-    const originalExitCode = process.exitCode;
-    try {
-      mocks.configFailure = scenario.configFailure ?? false;
-      mocks.purgeExtra = scenario.purgeExtra ?? false;
-      mocks.serverLogFailure = scenario.serverLogFailure ?? false;
-      process.argv = ['bun', 'ingest-ci-run.ts'];
-      process.exitCode = undefined;
-      for (const [key, value] of Object.entries({
-        DATABASE_WRITE_URL: 'postgres://unused:unused@127.0.0.1:1/unused',
-        GITHUB_TOKEN: 'unused',
-        INGEST_RUN_ID: '123',
-        INGEST_RUN_ATTEMPT: '2',
-        INGEST_ARTIFACTS_PATH: dir,
-        INGEST_REPO: 'SemiAnalysisAI/InferenceX',
-        POWER_PUBLICATION_MANIFEST: path.join(dir, 'power-publication.json'),
-        INGEST_REQUIRE_POWER: 'false',
-      }))
-        vi.stubEnv(key, value);
-      vi.spyOn(console, 'log').mockImplementation(() => {});
-      vi.spyOn(console, 'warn').mockImplementation(() => {});
-      vi.spyOn(console, 'error').mockImplementation(() => {});
-      fs.cpSync(
-        new URL(
-          '../../../docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/',
-          import.meta.url,
-        ),
-        path.join(dir, 'bmk_agentic_golden'),
-        { recursive: true },
-      );
-      fs.mkdirSync(path.join(dir, 'gpu_metrics_golden'));
-      fs.writeFileSync(
-        path.join(dir, 'gpu_metrics_golden', 'gpu_metrics.csv'),
-        'not,a,telemetry,csv\n',
-      );
-      if (scenario.extra !== undefined) {
-        fs.mkdirSync(path.join(dir, 'bmk_agentic_extra'));
-        const row = JSON.parse(
-          fs.readFileSync(path.join(dir, 'bmk_agentic_golden', 'agg.json'), 'utf8'),
-        );
-        fs.writeFileSync(
-          path.join(dir, 'bmk_agentic_extra', 'agg.json'),
-          typeof scenario.extra === 'string'
-            ? scenario.extra
-            : JSON.stringify({ ...row, conc: 2, users: 2, ...scenario.extra }),
-        );
-      }
-      if (mocks.serverLogFailure) {
-        fs.mkdirSync(path.join(dir, 'server_logs_golden'));
-        fs.writeFileSync(path.join(dir, 'server_logs_golden', 'server.log'), 'server ready\n');
-      }
-      const complete = new Promise<void>((resolve) => {
-        mocks.finish = resolve;
-      });
-      await import('./ingest-ci-run');
-      await complete;
-      const manifest = JSON.parse(
-        fs.readFileSync(path.join(dir, 'power-publication.json'), 'utf8'),
-      );
-      expect(mocks.persistBenchmark, JSON.stringify(manifest)).toHaveBeenCalledOnce();
-      expect(process.exitCode).toBeUndefined();
-      expect(manifest.ingestErrors).toEqual(scenario.ingestError ? [scenario.ingestError] : []);
-      expect(manifest.telemetry.expectedSource).toBe(
-        scenario.unknown ? 'unknown' : 'benchmark_artifacts',
-      );
-      expect(manifest.telemetryWarnings).toEqual(['1 gpu_metrics digest errors']);
-      expect(manifest.telemetry.points).toEqual([
-        expect.objectContaining({
-          produced: true,
-          artifactNames: ['gpu_metrics_golden'],
-          error: 'No parseable telemetry series in gpu_metrics_golden',
-        }),
-      ]);
-    } finally {
-      process.argv = originalArgv;
-      process.exitCode = originalExitCode;
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  },
-);
diff --git a/packages/db/src/lib/artifact-retry.test.ts b/packages/db/src/lib/artifact-retry.test.ts
index d369efc88..675355b59 100644
--- a/packages/db/src/lib/artifact-retry.test.ts
+++ b/packages/db/src/lib/artifact-retry.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 
-import { NonRetryableArtifactError, retryArtifactOperation } from './artifact-retry.js';
+import { retryArtifactOperation } from './artifact-retry.js';
 
 describe('retryArtifactOperation', () => {
   it('retries transient failures using the configured delays', async () => {
@@ -39,22 +39,4 @@ describe('retryArtifactOperation', () => {
     ).rejects.toBe(failure);
     expect(wait).toHaveBeenCalledOnce();
   });
-
-  it('rethrows a non-retryable failure at once without waiting or warning', async () => {
-    // A deleted run 404s forever; sleeping through the full backoff schedule
-    // (~3.8 min at the default delays) per such run would stall a history sweep.
-    const gone = new NonRetryableArtifactError('run is gone');
-    const operation = vi.fn(() => {
-      throw gone;
-    });
-    const wait = vi.fn<(delayMs: number) => Promise<void>>(() => Promise.resolve());
-    const warn = vi.fn<(message: string) => void>();
-
-    await expect(
-      retryArtifactOperation('artifact', operation, { delaysMs: [5, 15], wait, warn }),
-    ).rejects.toBe(gone);
-    expect(operation).toHaveBeenCalledOnce();
-    expect(wait).not.toHaveBeenCalled();
-    expect(warn).not.toHaveBeenCalled();
-  });
 });
diff --git a/packages/db/src/lib/backfill-benchmark-refresh.test.ts b/packages/db/src/lib/backfill-benchmark-refresh.test.ts
deleted file mode 100644
index 623595ed9..000000000
--- a/packages/db/src/lib/backfill-benchmark-refresh.test.ts
+++ /dev/null
@@ -1,306 +0,0 @@
-import fs from 'node:fs';
-import { createServer } from 'node:http';
-import os from 'node:os';
-import path from 'node:path';
-
-import { PGlite } from '@electric-sql/pglite';
-import { afterAll, afterEach, beforeAll, beforeEach, expect, it, vi } from 'vitest';
-
-import type { Sql } from '../etl/db-utils';
-import type { PowerPublicationManifest } from '../etl/power-publication';
-import {
-  checkpointBenchmarkRefresh,
-  refreshBackfillBenchmarks,
-} from './backfill-benchmark-refresh';
-
-let db: PGlite;
-let sql: Sql;
-let manifest: PowerPublicationManifest;
-let root: string;
-let origin: string;
-let failure: 'invalidate' | 'stale' | undefined;
-let apiIds: unknown[] | undefined;
-const audit = {
-  source: 'power_validation.json',
-  sample_count: 1,
-  window_start_unix: 1788220800,
-  window_end_unix: 1788220801,
-};
-const identity = {
-  hardware: 'b200',
-  framework: 'sglang',
-  model: 'dsr1',
-  precision: 'fp4',
-  spec_method: 'none',
-  disagg: false,
-  is_multinode: false,
-  prefill_tp: 8,
-  prefill_ep: 1,
-  prefill_dp_attention: false,
-  prefill_num_workers: 0,
-  decode_tp: 8,
-  decode_ep: 1,
-  decode_dp_attention: false,
-  decode_num_workers: 0,
-  num_prefill_gpu: 8,
-  num_decode_gpu: 8,
-  benchmark_type: 'single_turn',
-  isl: 8192,
-  osl: 1024,
-  conc: 32,
-  offload_mode: 'off',
-};
-const auditUpdates = [{ benchmarkResultId: 10, identity, powerAudit: audit }];
-const requests: { method: string; url: string; auth?: string; audit?: unknown }[] = [];
-const save = () => fs.writeFileSync(path.join(root, 'receipt.json'), JSON.stringify(manifest));
-const read = (): PowerPublicationManifest =>
-  JSON.parse(fs.readFileSync(path.join(root, 'receipt.json'), 'utf8'));
-const samples = async () => {
-  const result = await db.query('SELECT ctid::text, * FROM gpu_metric_samples');
-  return result.rows;
-};
-
-// Real HTTP transport around local SQL; this is not a deployed API/Blob acceptance test.
-const server = createServer(async (request, response) => {
-  try {
-    const entry: (typeof requests)[number] = {
-      method: request.method!,
-      url: request.url!,
-      auth: request.headers.authorization,
-    };
-    requests.push(entry);
-    let body: unknown;
-    if (entry.method === 'POST' && entry.url === '/api/v1/invalidate') {
-      const result = await db.query<{ power_audit: unknown }>(
-        'SELECT power_audit FROM latest_benchmarks WHERE id = 10',
-      );
-      entry.audit = result.rows[0]?.power_audit;
-      if (failure === 'invalidate') {
-        response.writeHead(503).end();
-        return;
-      }
-      body = { invalidated: true, blobsDeleted: 1 };
-    } else if (entry.url.startsWith('/api/v1/benchmarks?')) {
-      const result = await db.query<{ id: number; power_audit: unknown }>(
-        'SELECT id, power_audit FROM benchmark_results WHERE id = 10',
-      );
-      body = failure === 'stale' ? [{ id: 10, power_audit: null }] : result.rows;
-      if (apiIds) body = apiIds.map((id) => ({ ...result.rows[0], id }));
-    } else {
-      response.writeHead(404).end();
-      return;
-    }
-    response.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify(body));
-  } catch (error) {
-    response.writeHead(500).end(String(error));
-  }
-});
-
-beforeAll(async () => {
-  db = await PGlite.create();
-  const migrations = new URL('../../migrations/', import.meta.url);
-  for (const name of fs.readdirSync(migrations).toSorted())
-    if (name.endsWith('.sql')) await db.exec(fs.readFileSync(new URL(name, migrations), 'utf8'));
-  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
-    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
-    const result = await db.query(query, values);
-    return result.rows;
-  };
-  sql = Object.assign(client, { array: (value: unknown) => value }) as unknown as Sql;
-  await new Promise<void>((resolve) => {
-    server.listen(0, '127.0.0.1', resolve);
-  });
-  const address = server.address();
-  if (!address || typeof address === 'string') throw new Error('Expected loopback TCP address');
-  origin = `http://127.0.0.1:${address.port}`;
-}, 30_000);
-
-beforeEach(async () => {
-  root = fs.mkdtempSync(path.join(os.tmpdir(), 'benchmark-refresh-'));
-  requests.length = 0;
-  failure = undefined;
-  apiIds = undefined;
-  manifest = { version: 1, runId: 123, runAttempt: 2, points: [] };
-  vi.stubEnv('CACHE_INVALIDATE_URL', `${origin}/api/v1/invalidate`);
-  vi.stubEnv('CACHE_INVALIDATE_SECRET', 'local-secret');
-  vi.stubEnv('CACHE_PROTECTION_BYPASS_SECRET', undefined);
-  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
-    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
-      VALUES (1, 123, 2, 'Run Sweep', 'completed', 'success', '2026-09-01', '2026-09-01');
-    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
-      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
-      VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 8, 8, 8, 8);
-    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
-      VALUES (10, 1, 1, 'single_turn', '2026-09-01', 8192, 1024, 32, '{}');
-    INSERT INTO gpu_metric_series (id, workflow_run_id, artifact_name, config_key, file_name,
-      vendor, csv_sha256, sample_count, gpu_count, started_at, ended_at)
-      VALUES (1, 1, 'gpu_metrics_fixture', 'fixture', 'gpu_metrics.csv', 'nvidia', 'fixture', 1, 1, '2026-09-01', '2026-09-01');
-    INSERT INTO gpu_metric_samples (series_id, gpu_index, sampled_at, power_w) VALUES (1, 0, '2026-09-01', 351.4);
-    REFRESH MATERIALIZED VIEW latest_benchmarks;`);
-});
-
-afterEach(() => {
-  vi.unstubAllEnvs();
-  fs.rmSync(root, { recursive: true, force: true });
-});
-afterAll(async () => {
-  await new Promise<void>((resolve, reject) => {
-    server.close((error) => (error ? reject(error) : resolve()));
-  });
-  await db?.close();
-});
-
-async function updateAudit() {
-  await db.query('UPDATE benchmark_results SET power_audit = $1 WHERE id = 10', [audit]);
-}
-
-it('resumes the pre-write disk checkpoint and refreshes the materialized view before POST', async () => {
-  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
-  expect(read().benchmarkRefresh).toMatchObject({
-    status: 'pending',
-    benchmarkResultIds: [10],
-    auditUpdates,
-  });
-  await updateAudit();
-  const before = await db.query('SELECT power_audit FROM latest_benchmarks WHERE id = 10');
-  expect(before.rows).toEqual([{ power_audit: null }]);
-  manifest = read(); // Simulate losing all in-process state after the committed UPDATE.
-  await refreshBackfillBenchmarks(sql, manifest, save);
-  expect(requests).toHaveLength(2);
-  expect(requests[0]).toMatchObject({ method: 'POST', auth: 'Bearer local-secret', audit });
-  expect(new URL(requests[1].url, origin).searchParams.get('runId')).toBe('123');
-  expect(new URL(requests[1].url, origin).searchParams.get('exactRun')).toBe('true');
-  expect(read().benchmarkRefresh?.status).toBe('complete');
-});
-
-it.each(['invalidate', 'stale'] as const)(
-  'retains %s failure and retries without rewriting samples',
-  async (mode) => {
-    checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
-    await updateAudit();
-    const before = await samples();
-    failure = mode;
-    await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(
-      mode === 'invalidate' ? 'invalidate cache: HTTP 503' : 'power_audit differs',
-    );
-    expect(read().benchmarkRefresh).toMatchObject({ status: 'failed', benchmarkResultIds: [10] });
-    manifest = read();
-    failure = undefined;
-    await refreshBackfillBenchmarks(sql, manifest, save);
-    expect(read().benchmarkRefresh).toMatchObject({ status: 'complete', benchmarkResultIds: [10] });
-    expect(read().benchmarkRefresh).not.toHaveProperty('error');
-    expect(await samples()).toEqual(before);
-  },
-);
-
-it('verifies string benchmark IDs returned by native PostgreSQL without rewriting samples', async () => {
-  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
-  await updateAudit();
-  const before = await samples();
-  apiIds = ['10'];
-  manifest = read();
-  await refreshBackfillBenchmarks(sql, manifest, save);
-  expect(read().benchmarkRefresh).toMatchObject({ status: 'complete', benchmarkResultIds: [10] });
-  expect(requests).toHaveLength(2);
-  expect(await samples()).toEqual(before);
-});
-
-it('rejects duplicate benchmark API IDs after numeric normalization', async () => {
-  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
-  await updateAudit();
-  for (const ids of [
-    [10, '10'],
-    ['10', '10'],
-  ]) {
-    apiIds = ids;
-    await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(
-      'power_audit differs',
-    );
-    expect(read().benchmarkRefresh).toMatchObject({ status: 'failed', benchmarkResultIds: [10] });
-  }
-});
-
-it('rejects malformed benchmark API IDs instead of coercing them into matches', async () => {
-  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
-  await updateAudit();
-  for (const id of [['10'], {}, null, true, ' 10 ', '010', '10.0', '1e1', '0xa', '10oops']) {
-    apiIds = [id];
-    await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(
-      'power_audit differs',
-    );
-    expect(read().benchmarkRefresh).toMatchObject({ status: 'failed', benchmarkResultIds: [10] });
-  }
-});
-
-it('rejects a receipt for a different host before POST', async () => {
-  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
-  manifest.benchmarkRefresh!.endpoint = `${origin.replace('127.0.0.1', '127.0.0.2')}/api/v1/invalidate`;
-  await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow('target differs');
-  expect(read().benchmarkRefresh?.status).toBe('failed');
-  expect(requests).toEqual([]);
-});
-
-it('rejects a stringified audit even though the API fixture would return the same DB value', async () => {
-  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
-  await db.query('UPDATE benchmark_results SET power_audit = $1::jsonb WHERE id = 10', [
-    JSON.stringify(JSON.stringify(audit)),
-  ]);
-  const stored = await db.query('SELECT power_audit FROM benchmark_results WHERE id = 10');
-  expect(stored.rows).toEqual([{ power_audit: JSON.stringify(audit) }]);
-  await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(
-    'power_audit must be an object with a nonempty source',
-  );
-  expect(read().benchmarkRefresh?.status).toBe('failed');
-  expect(requests).toEqual([]);
-});
-
-it('rejects wrong run, attempt, foreign IDs and malformed IDs before POST', async () => {
-  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
-  const original = read();
-  for (const change of [
-    { runId: 999 },
-    { runAttempt: 1 },
-    ...[[11], [10, 10], [-1], [1.5]].map((ids) => ({
-      benchmarkRefresh: { ...original.benchmarkRefresh!, benchmarkResultIds: ids },
-    })),
-  ]) {
-    manifest = { ...structuredClone(original), ...change };
-    await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(
-      /run\/attempt|Invalid benchmarkResultIds/,
-    );
-    expect(read().benchmarkRefresh?.status).toBe('failed');
-  }
-  expect(requests).toEqual([]);
-});
-
-it('retains a NULL pre-write checkpoint and requires artifact re-ingest without purging', async () => {
-  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
-  manifest = read();
-  await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(/NULL.*re-ingest/);
-  expect(read().benchmarkRefresh).toMatchObject({
-    status: 'failed',
-    benchmarkResultIds: [10],
-    auditUpdates,
-  });
-  expect(requests).toEqual([]);
-});
-
-it('retains confirmed refresh responsibility when a later upsert clears the audit to NULL', async () => {
-  checkpointBenchmarkRefresh(manifest, [10], save, auditUpdates);
-  await updateAudit();
-  failure = 'invalidate';
-  await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow('HTTP 503');
-  const pending = read().benchmarkRefresh!;
-  const before = await samples();
-  await db.exec('UPDATE benchmark_results SET power_audit = NULL WHERE id = 10');
-  manifest = read();
-  failure = undefined;
-  await expect(refreshBackfillBenchmarks(sql, manifest, save)).rejects.toThrow(/NULL.*re-ingest/);
-  expect(read().benchmarkRefresh).toMatchObject({
-    status: 'failed',
-    benchmarkResultIds: pending.benchmarkResultIds,
-    auditUpdates: pending.auditUpdates,
-  });
-  expect(requests).toHaveLength(1);
-  expect(await samples()).toEqual(before);
-});
diff --git a/packages/db/src/lib/benchmark-result-lookup.test.ts b/packages/db/src/lib/benchmark-result-lookup.test.ts
index 2985969e4..7168f6fcf 100644
--- a/packages/db/src/lib/benchmark-result-lookup.test.ts
+++ b/packages/db/src/lib/benchmark-result-lookup.test.ts
@@ -1,6 +1,4 @@
 import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 
 import { PGlite } from '@electric-sql/pglite';
 import type postgres from 'postgres';
@@ -8,7 +6,7 @@ import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from
 
 import { mapBenchmarkRow, type BenchmarkParams } from '../etl/benchmark-mapper';
 import { createSkipTracker } from '../etl/skip-tracker';
-import { findBenchmarkResultIds, readMappedBenchmarkRows } from './benchmark-result-lookup';
+import { findBenchmarkResultIds } from './benchmark-result-lookup';
 
 type Sql = postgres.Sql;
 let db: PGlite;
@@ -99,41 +97,6 @@ beforeEach(async () => {
 });
 
 describe('findBenchmarkResultIds', () => {
-  it('resolves one persisted point per mapped row using the run attempt and config key', async () => {
-    const ids = await findBenchmarkResultIds(sql, RUN, [
-      mapped(rawRow()),
-      mapped(rawRow({ conc: 64 })),
-    ]);
-    expect(ids.toSorted()).toEqual([20, 21]);
-  });
-
-  it('never matches another attempt of the same run or a config with different parallelism', async () => {
-    // Point 23 is the same natural key under attempt 1; point 22 is attempt 2 but
-    // decode_tp 4. Neither may be linked to the attempt-2 telemetry.
-    expect(
-      await findBenchmarkResultIds(sql, { ...RUN, run_attempt: 3 }, [mapped(rawRow())]),
-    ).toEqual([]);
-    expect(await findBenchmarkResultIds(sql, RUN, [mapped(rawRow({ tp: 4 }))])).toEqual([]);
-    const attempt1 = await findBenchmarkResultIds(sql, { ...RUN, run_attempt: 1 }, [
-      mapped(rawRow()),
-    ]);
-    expect(attempt1).toEqual([23]);
-  });
-
-  it('matches an agentic row whose isl and osl are null', async () => {
-    const agentic = mapped({
-      infmax_model_prefix: 'dsv4',
-      hw: 'b200-nv',
-      framework: 'vllm',
-      precision: 'fp4',
-      scenario_type: 'agentic-coding',
-      users: 72,
-      tput_per_gpu: 20000,
-    });
-    expect(agentic.isl).toBeNull();
-    expect(await findBenchmarkResultIds(sql, RUN, [agentic])).toEqual([24]);
-  });
-
   it('prefers the offload-exact point and reports no unique fallback', async () => {
     await db.exec(`INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type,
       date, isl, osl, conc, offload_mode, metrics)
@@ -145,95 +108,4 @@ describe('findBenchmarkResultIds', () => {
     expect(ids).toEqual([20]);
     expect(fallbacks).toEqual([]);
   });
-
-  it('accepts a lone offload-drifted point through the unique fallback', async () => {
-    // Historical mapper drift: the only surviving point carries 'on' while the
-    // current mapper derives 'off'. Attaching telemetry is still unambiguous.
-    await db.exec(`UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 20;`);
-    const fallbacks: number[] = [];
-    const ids = await findBenchmarkResultIds(sql, RUN, [mapped(rawRow())], (id) =>
-      fallbacks.push(id),
-    );
-    expect(ids).toEqual([20]);
-    expect(fallbacks).toEqual([20]);
-  });
-
-  it('leaves ambiguous offload-drifted points unlinked', async () => {
-    await db.exec(`UPDATE benchmark_results SET offload_mode = 'on' WHERE id = 20;
-      INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type,
-        date, isl, osl, conc, offload_mode, metrics)
-      VALUES (26, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'dram', '{}');`);
-    const fallbacks: number[] = [];
-    const ids = await findBenchmarkResultIds(sql, RUN, [mapped(rawRow())], (id) =>
-      fallbacks.push(id),
-    );
-    expect(ids).toEqual([]);
-    expect(fallbacks).toEqual([]);
-  });
-});
-
-describe('readMappedBenchmarkRows', () => {
-  function writeArtifact(files: Record<string, string>): string {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'bmk-lookup-'));
-    roots.push(root);
-    for (const [name, body] of Object.entries(files)) {
-      const target = path.join(root, name);
-      fs.mkdirSync(path.dirname(target), { recursive: true });
-      fs.writeFileSync(target, body);
-    }
-    return root;
-  }
-
-  it('maps every benchmark JSON under the artifact, accepting arrays and single objects', () => {
-    const root = writeArtifact({
-      'conc32.json': JSON.stringify(rawRow()),
-      'nested/conc64.json': JSON.stringify([rawRow({ conc: 64 }), rawRow({ conc: 128 })]),
-    });
-    const rows = readMappedBenchmarkRows(root);
-    expect(rows.map((row) => row.conc).toSorted((a, b) => a - b)).toEqual([32, 64, 128]);
-    expect(rows[0]?.config).toMatchObject({
-      model: 'dsr1',
-      hardware: 'b200',
-      framework: 'sglang',
-      precision: 'fp4',
-      decodeTp: 8,
-    });
-  });
-
-  it('drops rows the production mapper rejects and files that are not JSON', () => {
-    const root = writeArtifact({
-      'conc32.json': JSON.stringify([
-        rawRow(),
-        rawRow({ hw: 'not-a-gpu' }),
-        rawRow({ conc: undefined }),
-        'not-an-object',
-        null,
-      ]),
-      'gpu_metrics.csv': 'timestamp, index\n2026/09/11 04:19:41.982, 0\n',
-      'README.md': '# ignored',
-    });
-    const rows = readMappedBenchmarkRows(root);
-    expect(rows).toHaveLength(1);
-    expect(rows[0]).toMatchObject({ conc: 32, isl: 8192, osl: 1024, offloadMode: 'off' });
-  });
-
-  it('reports unknown rows without discarding mapped points or treating known failures as unknown', () => {
-    const root = writeArtifact({
-      'results.json': JSON.stringify([
-        rawRow(),
-        rawRow({ hw: 'not-a-gpu' }),
-        null,
-        42,
-        [],
-        rawRow({ benchmark_outcome: { status: 'failed' } }),
-        rawRow({ num_requests_total: 2, num_requests_successful: 0 }),
-      ]),
-    });
-    const errors: string[] = [];
-    const rows = readMappedBenchmarkRows(root, (error) => errors.push(error));
-    expect(rows.map((row) => row.conc)).toEqual([32]);
-    expect(errors).toEqual(
-      [2, 3, 4, 5].map((row) => `Unmappable benchmark row: results.json row ${row}`),
-    );
-  });
 });
diff --git a/packages/db/src/lib/github-artifacts.test.ts b/packages/db/src/lib/github-artifacts.test.ts
index ae71f8890..e612d5c1b 100644
--- a/packages/db/src/lib/github-artifacts.test.ts
+++ b/packages/db/src/lib/github-artifacts.test.ts
@@ -1,12 +1,5 @@
 import { describe, expect, it } from 'vitest';
-
-import { NonRetryableArtifactError } from './artifact-retry.js';
-import {
-  RUNNER_SUFFIX_RE,
-  WorkflowRunNotFoundError,
-  dedupeArtifactsByLogicalName,
-  isGithubNotFoundError,
-} from './github-artifacts.js';
+import { RUNNER_SUFFIX_RE, dedupeArtifactsByLogicalName } from './github-artifacts.js';
 
 const art = (name: string, created_at: string) => ({
   name,
@@ -46,44 +39,3 @@ describe('dedupeArtifactsByLogicalName', () => {
     expect(deduped.get('run-stats')?.name).toBe('run-stats');
   });
 });
-
-describe('isGithubNotFoundError', () => {
-  it('recognises the status gh prints to stderr for a deleted run', () => {
-    // Shape of the error execSync throws with `encoding: 'utf8'`: the message
-    // only names the command; the HTTP status lives in stderr.
-    const error = Object.assign(
-      new Error('Command failed: gh api repos/o/r/actions/runs/1/artifacts'),
-      {
-        status: 1,
-        stderr: 'gh: Not Found (HTTP 404)\n{"message":"Not Found"}\n',
-      },
-    );
-    expect(isGithubNotFoundError(error)).toBe(true);
-  });
-
-  it('leaves transient failures retryable', () => {
-    expect(
-      isGithubNotFoundError(
-        Object.assign(new Error('Command failed'), {
-          stderr: 'gh: error connecting to api.github.com\n',
-        }),
-      ),
-    ).toBe(false);
-    expect(
-      isGithubNotFoundError(
-        Object.assign(new Error('Command failed'), { stderr: 'gh: Server Error (HTTP 502)\n' }),
-      ),
-    ).toBe(false);
-    expect(isGithubNotFoundError(null)).toBe(false);
-    expect(isGithubNotFoundError('HTTP 404')).toBe(false);
-  });
-});
-
-describe('WorkflowRunNotFoundError', () => {
-  it('is non-retryable and names the run', () => {
-    const error = new WorkflowRunNotFoundError('SemiAnalysisAI/InferenceX', '34533943809');
-    expect(error).toBeInstanceOf(NonRetryableArtifactError);
-    expect(error.runId).toBe('34533943809');
-    expect(error.message).toContain('34533943809');
-  });
-});
diff --git a/packages/db/src/lib/gpu-metrics-backfill.test.ts b/packages/db/src/lib/gpu-metrics-backfill.test.ts
index 771f6ad79..bb9607ca7 100644
--- a/packages/db/src/lib/gpu-metrics-backfill.test.ts
+++ b/packages/db/src/lib/gpu-metrics-backfill.test.ts
@@ -1,18 +1,7 @@
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it } from 'vitest';
 
 import type { ArtifactMeta } from './github-artifacts.js';
-import {
-  collectMissingTelemetryExpectations,
-  pairGpuMetricsArtifacts,
-} from './gpu-metrics-backfill.js';
-import { mapBenchmarkRow } from '../etl/benchmark-mapper.js';
-import { createSkipTracker } from '../etl/skip-tracker.js';
-import type { Sql } from '../etl/db-utils.js';
-import {
-  readTelemetryReceipt,
-  summarizeTelemetryReceipt,
-  telemetryArtifactsForAttempt,
-} from '../etl/telemetry-receipt.js';
+import { pairGpuMetricsArtifacts } from './gpu-metrics-backfill.js';
 
 const meta = (
   name: string,
@@ -28,170 +17,6 @@ const meta = (
 });
 
 describe('pairGpuMetricsArtifacts', () => {
-  it('keeps expired sibling expectations unknown through an unrelated targeted repair', async () => {
-    const artifacts = telemetryArtifactsForAttempt(
-      [
-        meta('bmk_previous_h200-cw_0', 1, '2026-09-10T00:00:00Z', true),
-        meta('bmk_expired_h200-cw_0', 2, '2026-09-11T01:00:00Z', true),
-        meta('bmk_healthy_h200-cw_0', 3, '2026-09-11T01:00:00Z'),
-        meta('gpu_metrics_healthy_h200-cw_0', 4, '2026-09-11T01:00:00Z'),
-      ],
-      { run_attempt: 2, run_started_at: '2026-09-11T00:00:00Z' },
-      2,
-    );
-    const pairs = pairGpuMetricsArtifacts(artifacts);
-    const readRows = vi.fn(() => Promise.resolve([]));
-    const missing = await collectMissingTelemetryExpectations(artifacts, pairs, null, readRows);
-    expect(missing.errors).toEqual([
-      {
-        benchmarkArtifact: 'bmk_expired_h200-cw_0',
-        artifactNames: ['gpu_metrics_expired_h200-cw_0', 'power_audit_expired_h200-cw_0'],
-        error: 'Benchmark artifact expired; point identities unavailable',
-      },
-    ]);
-    expect(missing.observations).toEqual([]);
-    expect(readRows).not.toHaveBeenCalled();
-
-    const storedPoint = { id: 10, model: 'dsr1', conc: 8, offload_mode: 'off' };
-    const series = {
-      id: 5,
-      artifact_name: pairs[0]!.gpuMetrics.name,
-      file_name: 'gpu_metrics.csv',
-      sidecars: { seriesInventory: [{ fileName: 'gpu_metrics.csv', sampleCount: 1 }] },
-      sample_count: 1,
-      benchmark_result_ids: [storedPoint.id],
-    };
-    const sql = vi
-      .fn()
-      .mockResolvedValueOnce([storedPoint])
-      .mockResolvedValueOnce([series])
-      .mockResolvedValueOnce([storedPoint])
-      .mockResolvedValueOnce([series]) as unknown as Sql;
-    const observation = {
-      identity: storedPoint,
-      artifactNames: [series.artifact_name],
-      produced: true,
-    };
-    const run = { runId: 123, runAttempt: 2 };
-    const receipt = await readTelemetryReceipt(sql, run, [observation]);
-    receipt.expectationErrors = missing.errors;
-    summarizeTelemetryReceipt(receipt);
-    expect(receipt.counts).toMatchObject({
-      expectedPoints: null,
-      storedPoints: 1,
-      linkedPoints: 1,
-      apiReadablePoints: 0,
-    });
-
-    const targeted = await collectMissingTelemetryExpectations(
-      artifacts,
-      pairs,
-      series.artifact_name,
-      readRows,
-    );
-    expect(targeted).toEqual({ observations: [], errors: [] });
-    expect(readRows).not.toHaveBeenCalled();
-    const repaired = await readTelemetryReceipt(sql, run, [observation], {
-      previous: receipt,
-      targeted: true,
-    });
-    expect(repaired.expectationErrors).toEqual(missing.errors);
-    expect(repaired.counts.expectedPoints).toBeNull();
-  });
-
-  it.each(['gpu_metrics', 'power_audit'])(
-    'records the expired sibling for the selected %s target without downloading',
-    async (prefix) => {
-      const artifacts = [meta('bmk_expired_h200-cw_0', 1, undefined, true)];
-      const readRows = vi.fn(() => Promise.resolve([]));
-      const result = await collectMissingTelemetryExpectations(
-        artifacts,
-        [],
-        `${prefix}_expired_h200-cw_0`,
-        readRows,
-      );
-      expect(result.observations).toEqual([]);
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toMatchObject({
-        benchmarkArtifact: artifacts[0]!.name,
-        artifactNames: expect.arrayContaining([`${prefix}_expired_h200-cw_0`]),
-      });
-      expect(readRows).not.toHaveBeenCalled();
-    },
-  );
-
-  it('does not report an expired retry superseded by a retained sibling', async () => {
-    const artifacts = [
-      meta('bmk_healthy_h200-cw_0', 1, '2026-09-11T00:00:00Z', true),
-      meta('bmk_healthy_h200-dgxc-slurm_1', 2, '2026-09-11T01:00:00Z'),
-      meta('gpu_metrics_healthy_h200-dgxc-slurm_1', 3, '2026-09-11T01:00:00Z'),
-    ];
-    const pairs = pairGpuMetricsArtifacts(artifacts);
-    const readRows = vi.fn(() => Promise.resolve([]));
-    expect(await collectMissingTelemetryExpectations(artifacts, pairs, null, readRows)).toEqual({
-      observations: [],
-      errors: [],
-    });
-    expect(readRows).not.toHaveBeenCalled();
-  });
-
-  it('isolates a corrupt unpaired sibling while retaining later expectations and valid recovery pairs', async () => {
-    const artifacts = [
-      meta('bmk_broken_h200-cw_0', 1),
-      meta('bmk_missing_h200-cw_0', 2),
-      meta('bmk_healthy_h200-cw_0', 3),
-      meta('gpu_metrics_healthy_h200-cw_0', 4),
-    ];
-    const pairs = pairGpuMetricsArtifacts(artifacts);
-    const row = mapBenchmarkRow(
-      {
-        infmax_model_prefix: 'dsr1',
-        hw: 'b200',
-        framework: 'sglang',
-        precision: 'fp4',
-        isl: 8192,
-        osl: 1024,
-        conc: 8,
-        tp: 1,
-      },
-      createSkipTracker(),
-    )!;
-    const result = await collectMissingTelemetryExpectations(artifacts, pairs, null, (artifact) =>
-      artifact.id === 1
-        ? Promise.reject(new Error('Malformed benchmark JSON'))
-        : Promise.resolve([row]),
-    );
-    expect(result.errors).toEqual([
-      {
-        benchmarkArtifact: 'bmk_broken_h200-cw_0',
-        artifactNames: ['gpu_metrics_broken_h200-cw_0', 'power_audit_broken_h200-cw_0'],
-        error: 'Malformed benchmark JSON',
-      },
-    ]);
-    expect(result.observations).toHaveLength(1);
-    expect(result.observations[0]).toMatchObject({
-      identity: { model: 'dsr1', conc: 8 },
-      artifactNames: ['gpu_metrics_missing_h200-cw_0', 'power_audit_missing_h200-cw_0'],
-      produced: false,
-    });
-    expect(pairs.map((pair) => pair.gpuMetrics.name)).toEqual(['gpu_metrics_healthy_h200-cw_0']);
-  });
-  it('pairs gpu_metrics with the exact bmk sibling and prefers the agentic sibling', () => {
-    const pairs = pairGpuMetricsArtifacts([
-      meta('gpu_metrics_cfg-a_h200-cw_0', 1),
-      meta('bmk_cfg-a_h200-cw_0', 2),
-      meta('gpu_metrics_cfg-b_h200-cw_0', 3),
-      meta('bmk_agentic_cfg-b_h200-cw_0', 4),
-      meta('bmk_cfg-b_h200-cw_0', 5),
-      meta('gpu_metrics_orphan_h200-cw_0', 6),
-      meta('eval_gpu_metrics_cfg-a_h200-cw_0', 7),
-    ]);
-    expect(pairs.map((pair) => [pair.gpuMetrics.name, pair.benchmarks.name])).toEqual([
-      ['gpu_metrics_cfg-a_h200-cw_0', 'bmk_cfg-a_h200-cw_0'],
-      ['gpu_metrics_cfg-b_h200-cw_0', 'bmk_agentic_cfg-b_h200-cw_0'],
-    ]);
-  });
-
   it('lets a power_audit bundle stand in only when its suffix has no gpu_metrics upload', () => {
     // The bundle is listed before its gpu_metrics sibling on purpose: input
     // order alone must not decide the winner.
diff --git a/packages/db/src/lib/telemetry-purge.test.ts b/packages/db/src/lib/telemetry-purge.test.ts
deleted file mode 100644
index 9224172f3..000000000
--- a/packages/db/src/lib/telemetry-purge.test.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-/**
- * Telemetry purge behaviour against a PGlite database with the real migrations
- * applied, so the FK cascades declared in 016_gpu_metrics.sql are the ones under
- * test rather than a hand-written stand-in.
- *
- * The regression these cover: before this change both purge levels relied on
- * `on delete cascade`, so a purge destroyed telemetry with no count anywhere. The
- * point-level case was worse than silent — it left the series stranded, paying
- * storage while the per-point endpoint could never reach it again.
- */
-
-import fs from 'node:fs';
-
-import { PGlite } from '@electric-sql/pglite';
-import type postgres from 'postgres';
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-
-import {
-  countRunTelemetry,
-  deleteRunTelemetry,
-  describeTelemetry,
-  unlinkPointTelemetry,
-} from './telemetry-purge';
-
-type Sql = postgres.Sql;
-let db: PGlite;
-let sql: Sql;
-
-function queryClient(database: Pick<PGlite, 'query'>) {
-  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
-    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
-    const result = await database.query(query, values);
-    return result.rows;
-  };
-  return Object.assign(client, { json: JSON.stringify, array: (value: unknown) => value });
-}
-
-const count = async (table: string): Promise<number> => {
-  const result = await db.query<{ n: number }>(`SELECT count(*)::int AS n FROM ${table}`);
-  return result.rows[0].n;
-};
-
-beforeAll(async () => {
-  db = await PGlite.create();
-  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
-    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
-  }
-  sql = queryClient(db) as unknown as Sql;
-}, 20_000);
-
-afterAll(async () => {
-  await db?.close();
-});
-
-/**
- * Two runs. Run 1 has two benchmark points sharing one series plus a second
- * series linked to nothing, which is the shape a multinode upload produces. Run 2
- * exists to prove a purge never reaches past the runs it was given.
- */
-beforeEach(async () => {
-  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
-
-    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, html_url, created_at, date)
-    VALUES (1, 44000000001, 1, 'Run Sweep', null, now(), '2026-09-01'),
-           (2, 44000000002, 1, 'Run Sweep', null, now(), '2026-09-02');
-
-    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
-      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
-    VALUES (1, 'dsv4', 'b200', 'sglang', 'fp8', 'none', false, 8, 8, 8, 8);
-
-    INSERT INTO benchmark_results (id, workflow_run_id, config_id, date, isl, osl, conc,
-      benchmark_type, metrics)
-    VALUES (11, 1, 1, '2026-09-01', 8192, 1024, 32, 'single_turn', '{}'::jsonb),
-           (12, 1, 1, '2026-09-01', 8192, 1024, 64, 'single_turn', '{}'::jsonb),
-           (21, 2, 1, '2026-09-02', 8192, 1024, 32, 'single_turn', '{}'::jsonb);
-
-    INSERT INTO gpu_metric_series (id, workflow_run_id, artifact_name, config_key, file_name,
-      vendor, csv_sha256, sample_count, gpu_count, started_at, ended_at)
-    VALUES (101, 1, 'gpu_metrics_a', 'a', 'a.csv', 'nvidia', 'sha-a', 1000, 8,
-              '2026-09-01T00:00:00Z', '2026-09-01T00:10:00Z'),
-           (102, 1, 'gpu_metrics_b', 'b', 'b.csv', 'nvidia', 'sha-b', 2000, 8,
-              '2026-09-01T00:00:00Z', '2026-09-01T00:20:00Z'),
-           (201, 2, 'gpu_metrics_c', 'c', 'c.csv', 'nvidia', 'sha-c', 4000, 8,
-              '2026-09-02T00:00:00Z', '2026-09-02T00:40:00Z');
-
-    INSERT INTO benchmark_result_gpu_metrics (benchmark_result_id, series_id)
-    VALUES (11, 101), (12, 101), (21, 201);
-  `);
-});
-
-describe('countRunTelemetry', () => {
-  it('sums the stored sample counts for the targeted runs only', async () => {
-    await expect(countRunTelemetry(sql, [1])).resolves.toEqual({ series: 2, samples: 3000 });
-    await expect(countRunTelemetry(sql, [2])).resolves.toEqual({ series: 1, samples: 4000 });
-    await expect(countRunTelemetry(sql, [1, 2])).resolves.toEqual({ series: 3, samples: 7000 });
-  });
-
-  it('reports zero for a run with no telemetry and reads nothing for an empty list', async () => {
-    await db.exec('DELETE FROM gpu_metric_series WHERE workflow_run_id = 2');
-    await expect(countRunTelemetry(sql, [2])).resolves.toEqual({ series: 0, samples: 0 });
-    await expect(countRunTelemetry(sql, [])).resolves.toEqual({ series: 0, samples: 0 });
-  });
-
-  it('does not delete anything', async () => {
-    await countRunTelemetry(sql, [1, 2]);
-    expect(await count('gpu_metric_series')).toBe(3);
-  });
-});
-
-describe('deleteRunTelemetry', () => {
-  it('removes the run series and reports what went', async () => {
-    await expect(deleteRunTelemetry(sql, [1])).resolves.toEqual({ series: 2, samples: 3000 });
-    expect(await count('gpu_metric_series')).toBe(1);
-  });
-
-  it('leaves other runs untouched', async () => {
-    await deleteRunTelemetry(sql, [1]);
-    await expect(countRunTelemetry(sql, [2])).resolves.toEqual({ series: 1, samples: 4000 });
-  });
-
-  it('takes the point links with it, so no link outlives its series', async () => {
-    await deleteRunTelemetry(sql, [1]);
-    expect(await count('benchmark_result_gpu_metrics')).toBe(1);
-  });
-
-  it('is a no-op on an empty list', async () => {
-    await expect(deleteRunTelemetry(sql, [])).resolves.toEqual({ series: 0, samples: 0 });
-    expect(await count('gpu_metric_series')).toBe(3);
-  });
-});
-
-describe('unlinkPointTelemetry', () => {
-  it('drops only the links for the given points', async () => {
-    await expect(unlinkPointTelemetry(sql, [11])).resolves.toBe(1);
-    const rows = await db.query<{ benchmark_result_id: number }>(
-      'SELECT benchmark_result_id FROM benchmark_result_gpu_metrics ORDER BY benchmark_result_id',
-    );
-    expect(rows.rows.map((r) => r.benchmark_result_id)).toEqual([12, 21]);
-  });
-
-  it('keeps the series, which still belongs to a run that was not purged', async () => {
-    await unlinkPointTelemetry(sql, [11, 12]);
-    expect(await count('benchmark_result_gpu_metrics')).toBe(1);
-    await expect(countRunTelemetry(sql, [1])).resolves.toEqual({ series: 2, samples: 3000 });
-  });
-
-  it('returns 0 for points that have no telemetry and for an empty list', async () => {
-    await expect(unlinkPointTelemetry(sql, [12, 999])).resolves.toBe(1);
-    await expect(unlinkPointTelemetry(sql, [999])).resolves.toBe(0);
-    await expect(unlinkPointTelemetry(sql, [])).resolves.toBe(0);
-  });
-});
-
-describe('describeTelemetry', () => {
-  it('groups the sample count so a large loss reads as large', () => {
-    expect(describeTelemetry({ series: 23, samples: 207_345 })).toBe(
-      '23 gpu_metric_series (207,345 samples)',
-    );
-  });
-});
diff --git a/packages/db/src/prepare-ci-artifacts.test.ts b/packages/db/src/prepare-ci-artifacts.test.ts
deleted file mode 100644
index c327bf9e9..000000000
--- a/packages/db/src/prepare-ci-artifacts.test.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-import fs from 'node:fs';
-import { execFileSync } from 'node:child_process';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const fixture = fileURLToPath(
-  new URL('../../../docs/fixtures/powerx-manifest-v2/artifacts/', import.meta.url),
-);
-const mocks = vi.hoisted(() => ({ names: [] as string[], fixture: '', corrupt: false }));
-vi.mock('node:child_process', () => ({
-  execFileSync: vi.fn(() => JSON.stringify({ head_sha: 'b'.repeat(40), run_attempt: 1 })),
-}));
-vi.mock('./lib/github-artifacts.js', () => ({
-  listRunArtifacts: () =>
-    mocks.names.map((name, id) => ({
-      id,
-      name,
-      expired: false,
-      created_at: '2026-09-16T00:00:00Z',
-    })),
-  downloadArtifact: (artifact: { name: string }, root: string) => {
-    fs.cpSync(path.join(mocks.fixture, artifact.name), path.join(root, artifact.name), {
-      recursive: true,
-    });
-    if (mocks.corrupt && artifact.name === 'agentic_golden')
-      fs.appendFileSync(path.join(root, artifact.name, 'gpu_metrics.csv'), 'corrupt\n');
-  },
-}));
-
-let directory: string;
-let originalArgs: string[];
-let originalExitCode: typeof process.exitCode;
-beforeEach(() => {
-  vi.resetModules();
-  directory = fs.mkdtempSync(path.join(os.tmpdir(), 'power-prepare-'));
-  mocks.fixture = fixture;
-  mocks.names = fs.readdirSync(fixture);
-  mocks.corrupt = false;
-  originalArgs = process.argv;
-  originalExitCode = process.exitCode;
-  process.argv = ['bun', 'prepare-ci-artifacts.ts'];
-  process.exitCode = undefined;
-  vi.stubEnv('SOURCE_RUN_ID', '123');
-  vi.stubEnv('MERGE_RUN_ID', '123');
-  vi.stubEnv('ARTIFACTS_PATH', directory);
-  vi.stubEnv('INGEST_REQUIRE_POWER', 'true');
-  vi.stubEnv('GITHUB_OUTPUT', '');
-  vi.spyOn(console, 'log').mockImplementation(() => {});
-  vi.spyOn(console, 'error').mockImplementation(() => {});
-});
-afterEach(() => {
-  process.argv = originalArgs;
-  process.exitCode = originalExitCode;
-  vi.unstubAllEnvs();
-  vi.restoreAllMocks();
-  fs.rmSync(directory, { recursive: true, force: true });
-});
-
-describe('artifact preparation gate before migrations', () => {
-  it('preserves earlier successful artifacts when only failed jobs are rerun', async () => {
-    vi.mocked(execFileSync).mockReturnValueOnce(
-      JSON.stringify({
-        head_sha: 'b'.repeat(40),
-        run_attempt: 2,
-        run_started_at: '2026-09-17T00:00:00Z',
-      }),
-    );
-    await import('./prepare-ci-artifacts');
-    expect(process.exitCode).toBeUndefined();
-    expect(fs.readdirSync(directory).toSorted()).toEqual(mocks.names.toSorted());
-    expect(console.log).toHaveBeenCalledWith(
-      expect.stringContaining('declared attempt 1, ingest attempt 2'),
-    );
-  });
-
-  it('accepts the actual golden source bundle without a database connection', async () => {
-    await import('./prepare-ci-artifacts');
-    expect(process.exitCode).toBeUndefined();
-    expect(console.error).not.toHaveBeenCalled();
-  });
-
-  it('fails the preparation command when both manifest and changelog are lost', async () => {
-    mocks.names = mocks.names.filter(
-      (name) => name !== 'required-power-sweep-manifest' && name !== 'changelog-metadata',
-    );
-    await import('./prepare-ci-artifacts');
-    expect(process.exitCode).toBe(1);
-    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('required dispatch'));
-  });
-
-  it('fails preparation on corrupt downloaded telemetry', async () => {
-    mocks.corrupt = true;
-    await import('./prepare-ci-artifacts');
-    expect(process.exitCode).toBe(1);
-    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('hash'));
-  });
-
-  it('retains optional-power compatibility when there is no required marker', async () => {
-    vi.stubEnv('INGEST_REQUIRE_POWER', 'false');
-    mocks.names = ['bmk_agentic_golden'];
-    await import('./prepare-ci-artifacts');
-    expect(process.exitCode).toBeUndefined();
-    expect(console.error).not.toHaveBeenCalled();
-  });
-});
diff --git a/packages/db/src/queries/gpu-metrics-timeline.test.ts b/packages/db/src/queries/gpu-metrics-timeline.test.ts
index 4f6bc2a81..294fbc912 100644
--- a/packages/db/src/queries/gpu-metrics-timeline.test.ts
+++ b/packages/db/src/queries/gpu-metrics-timeline.test.ts
@@ -7,9 +7,7 @@ import type postgres from 'postgres';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 
 import { cutPowerAuditBundle } from '../../../app/src/components/gpu-power/power-audit-bundle';
-import { bucketPowerSeries } from '../../../app/src/components/gpu-power/power-series';
 import { storedPowerSeries } from '../../../app/src/components/gpu-power/stored-power-series';
-import { parseCsvData } from '../../../app/src/components/gpu-power/types';
 import type { DbClient } from '../connection';
 import { ingestGpuMetricsArtifact } from '../etl/gpu-metrics-ingest';
 import { getGpuMetricsForPoint, getGpuMetricsForRun } from './gpu-metrics';
@@ -147,57 +145,6 @@ beforeEach(async () => {
 });
 
 describe('artifact → ingest → stored Timeline', () => {
-  it('restores nested AgentX provenance on ingest and sample no-op without changing metrics or validity', async () => {
-    await db.exec(`UPDATE benchmark_results SET benchmark_type = 'agentic_traces',
-      metrics = '{"power_valid":0,"throughput":17}' WHERE id = 10`);
-    const files = agentxBundle();
-    const input = {
-      workflowRunId: 1,
-      artifact: writeArtifact(NAME, files),
-      benchmarkResultIds: [10, 11],
-    };
-    const initial = await ingestGpuMetricsArtifact(sql, input);
-    expect(initial.metadataUpdatedBenchmarkResultIds).toEqual([10]);
-    const expected = {
-      source: SOURCE,
-      window_start_unix: START,
-      window_end_unix: START + 1,
-    };
-    const row = () => db.query('SELECT power_audit, metrics FROM benchmark_results WHERE id = 10');
-    const initialRow = await row();
-    expect(initialRow.rows[0]).toEqual({
-      power_audit: expected,
-      metrics: { power_valid: 0, throughput: 17 },
-    });
-    const stored = await getGpuMetricsForRun(readSql, RUN);
-    expect(storedPowerSeries(stored!.series)).toEqual(cutPowerAuditBundle(NAME, files));
-    expect(storedPowerSeries(stored!.series)).toHaveLength(1);
-    expect(stored!.series[0].sidecars).toMatchObject({
-      validations: {
-        [SOURCE]: {
-          validation_path: 'LOGS/agentic/conc_32/power_validation.json',
-          validation_sha256: expect.stringMatching(/^[a-f0-9]{64}$/u),
-          power_valid: false,
-        },
-      },
-    });
-    await db.exec('UPDATE benchmark_results SET power_audit = NULL WHERE id = 10');
-    expect(await ingestGpuMetricsArtifact(sql, input)).toMatchObject({
-      samplesInserted: 0,
-      seriesSkipped: 2,
-      metadataUpdatedBenchmarkResultIds: [10],
-    });
-    const unchanged = await ingestGpuMetricsArtifact(sql, input);
-    expect(unchanged.metadataUpdatedBenchmarkResultIds).toEqual([]);
-    const repaired = await row();
-    expect(repaired.rows[0]).toEqual({
-      power_audit: expected,
-      metrics: { power_valid: 0, throughput: 17 },
-    });
-    const unrelated = await db.query('SELECT power_audit FROM benchmark_results WHERE id = 11');
-    expect(unrelated.rows).toEqual([{ power_audit: null }]);
-  });
-
   it.each(['explicit', 'wrong-run', 'wrong-id', 'wrong-conc', 'ambiguous'])(
     'does not infer or overwrite point provenance for %s identity',
     async (scenario) => {
@@ -277,65 +224,6 @@ describe('artifact → ingest → stored Timeline', () => {
     expect(actual[0].devices?.[0]).toEqual({ id: 'host-b/GPU-b0', role: 'prefill' });
   });
 
-  it('recovers a previously ingested bundle from linked audit source/window and retained manifest', async () => {
-    const files = bundle();
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: writeArtifact(NAME, files),
-      benchmarkResultIds: [10, 11],
-    });
-    await sql`UPDATE gpu_metric_series SET sidecars = sidecars - 'validations'`;
-    const audit = {
-      source: `some/path/${SOURCE}`,
-      window_start_unix: START,
-      window_end_unix: START + 1,
-    };
-    await sql`UPDATE benchmark_results SET power_audit = ${JSON.stringify(audit)}::jsonb`;
-    const stored = await getGpuMetricsForRun(readSql, RUN);
-    expect(stored!.series[0].powerAudits).toHaveLength(2);
-    expect(storedPowerSeries(stored!.series)).toEqual(cutPowerAuditBundle(NAME, files));
-  });
-
-  it('does not fabricate a whole-run validation window when legacy provenance is absent', async () => {
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: writeArtifact(NAME, bundle()),
-      benchmarkResultIds: [10],
-    });
-    await sql`UPDATE gpu_metric_series SET sidecars = sidecars - 'validations'`;
-    const stored = await getGpuMetricsForRun(readSql, RUN);
-    expect(() => storedPowerSeries(stored!.series)).toThrow(
-      'validation window provenance is missing',
-    );
-    expect((await getGpuMetricsForPoint(readSql, 10))!.series).toHaveLength(2);
-  });
-
-  it('matches the CSV artifact path after duplicate flushes without changing distinct-sample means', async () => {
-    const name = 'gpu_metrics_qwen3.5_8k1k_fp8_sglang_conc32_b200_0';
-    const csv = [
-      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
-      '2026/09/12 04:00:00.100, 2, 300 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %',
-      '2026/09/12 04:00:00.100, 2, 300 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %', // repeated monitor flush
-      '2026/09/12 04:00:00.100, 2, 999 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %',
-      '2026/09/12 04:00:00.800, 2, 500 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %',
-      '2026/09/12 04:00:01.100, 7, 0 W, 60, 1000 MHz, 2000 MHz, 0 %, 0 %',
-    ].join('\n');
-    await ingestGpuMetricsArtifact(sql, {
-      workflowRunId: 1,
-      artifact: writeArtifact(name, new Map([['gpu_metrics.csv', csv]])),
-      benchmarkResultIds: [10],
-    });
-    const stored = await getGpuMetricsForRun(readSql, RUN);
-    expect(storedPowerSeries(stored!.series)).toEqual([bucketPowerSeries(name, parseCsvData(csv))]);
-    expect(storedPowerSeries(stored!.series)[0]).toMatchObject({
-      gpus: [2, 7],
-      power: [
-        [400, null],
-        [null, 0],
-      ],
-    });
-  });
-
   it('keeps SMI telemetry embedded in a power_audit bundle readable with the same source/window cuts', async () => {
     const files = bundle();
     files.set(
diff --git a/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts b/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
index 8a7a430ca..3e8f3bd09 100644
--- a/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
+++ b/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
@@ -30,11 +30,7 @@ import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from
 
 import type { DbClient } from '../connection';
 import { ingestGpuMetricsArtifact } from '../etl/gpu-metrics-ingest';
-import {
-  getGpuMetricsForPoint,
-  type GpuMetricSeries,
-  TelemetrySnapshotChangedError,
-} from './gpu-metrics';
+import { getGpuMetricsForPoint, type GpuMetricSeries } from './gpu-metrics';
 
 type Sql = postgres.Sql;
 let db: PGlite;
@@ -119,12 +115,9 @@ function csvVersion(extraScrapes: number): string {
 
 /** Version 2: the same artifact re-uploaded with one more scrape per GPU = 6 unique samples. */
 const NVIDIA_CSV_V2 = csvVersion(1);
-/** Version 3: one more scrape per GPU again = 8 unique samples. */
-const NVIDIA_CSV_V3 = csvVersion(2);
 
 const V1_UNIQUE_SAMPLES = 4;
 const V2_UNIQUE_SAMPLES = 6;
-const V3_UNIQUE_SAMPLES = 8;
 
 function writeArtifact(csv: string, contextZone = 'UTC') {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-reingest-'));
@@ -197,21 +190,6 @@ function expectCoherent(series: GpuMetricSeries) {
 }
 
 describe('getGpuMetricsForPoint under telemetry re-ingest', () => {
-  it('serial read after re-ingest is coherent', async () => {
-    const first = await ingest(NVIDIA_CSV_V1);
-    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
-    const second = await ingest(NVIDIA_CSV_V2);
-    expect(second.samplesInserted).toBe(V2_UNIQUE_SAMPLES);
-    expect(second.seriesIds).toEqual(first.seriesIds);
-
-    const payload = await getGpuMetricsForPoint(reader, 10);
-    expect(payload?.series).toHaveLength(1);
-    for (const series of payload!.series) {
-      expect(series.sampleCount).toBe(V2_UNIQUE_SAMPLES);
-      expectCoherent(series);
-    }
-  });
-
   it('a re-ingest committed between the stats and samples statements yields one version', async () => {
     const first = await ingest(NVIDIA_CSV_V1);
     expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
@@ -237,63 +215,4 @@ describe('getGpuMetricsForPoint under telemetry re-ingest', () => {
       expectCoherent(series);
     }
   });
-
-  it('an identical re-ingest committed between the stats and samples statements is coherent', async () => {
-    const first = await ingest(NVIDIA_CSV_V1);
-    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
-
-    let reingest: Awaited<ReturnType<typeof ingest>> | undefined;
-    const interleaved = interleaveAfterStats(reader, async (statsReadIndex) => {
-      if (statsReadIndex === 1) reingest = await ingest(NVIDIA_CSV_V1);
-    });
-
-    const payload = await getGpuMetricsForPoint(interleaved.client, 10);
-
-    // Unchanged digest, sidecars and sample count: the no-op path wrote nothing.
-    expect(reingest?.samplesInserted).toBe(0);
-    expect(reingest?.seriesSkipped).toBe(1);
-    expect(payload?.series).toHaveLength(1);
-    // Same version key, so no retry.
-    expect(interleaved.seriesReads()).toBe(1);
-
-    for (const series of payload!.series) {
-      expect(series.sampleCount).toBe(V1_UNIQUE_SAMPLES);
-      expectCoherent(series);
-    }
-  });
-
-  it('converges when a second re-ingest lands during the retry', async () => {
-    const first = await ingest(NVIDIA_CSV_V1);
-    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
-
-    const interleaved = interleaveAfterStats(reader, async (statsReadIndex) => {
-      if (statsReadIndex === 1) await ingest(NVIDIA_CSV_V2);
-      if (statsReadIndex === 2) await ingest(NVIDIA_CSV_V3);
-    });
-
-    const payload = await getGpuMetricsForPoint(interleaved.client, 10);
-
-    expect(payload?.series).toHaveLength(1);
-    expect(interleaved.seriesReads()).toBe(3);
-    for (const series of payload!.series) {
-      expect(series.sampleCount).toBe(V3_UNIQUE_SAMPLES);
-      expect(series.data).toHaveLength(V3_UNIQUE_SAMPLES);
-      expectCoherent(series);
-    }
-  });
-
-  it('gives up after three attempts when the series keeps changing', async () => {
-    const first = await ingest(NVIDIA_CSV_V1);
-    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
-
-    const interleaved = interleaveAfterStats(reader, async (statsReadIndex) => {
-      // Every attempt sees a fresh, distinct version committed under it.
-      await ingest(csvVersion(statsReadIndex));
-    });
-
-    await expect(getGpuMetricsForPoint(interleaved.client, 10)).rejects.toBeInstanceOf(
-      TelemetrySnapshotChangedError,
-    );
-    expect(interleaved.seriesReads()).toBe(3);
-  });
 });
diff --git a/packages/db/src/queries/gpu-metrics.test.ts b/packages/db/src/queries/gpu-metrics.test.ts
index fc313acb2..6962145b6 100644
--- a/packages/db/src/queries/gpu-metrics.test.ts
+++ b/packages/db/src/queries/gpu-metrics.test.ts
@@ -4,7 +4,7 @@ import { PGlite } from '@electric-sql/pglite';
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 
 import type { DbClient } from '../connection';
-import { getGpuMetricsForPoint, getGpuMetricsForRun } from './gpu-metrics';
+import { getGpuMetricsForRun } from './gpu-metrics';
 
 let db: PGlite;
 const sql: DbClient = async (strings, ...values) => {
@@ -14,7 +14,6 @@ const sql: DbClient = async (strings, ...values) => {
 };
 
 const WITH_SERIES = 34557177019;
-const WITHOUT_SERIES = 34557177020;
 const RETRIED = 34557177021;
 
 beforeAll(async () => {
@@ -31,8 +30,8 @@ afterAll(async () => {
 
 /**
  * Run 1 holds a two-node artifact (one CSV per serving node) whose first CSV is
- * shared by points 10 and 11; run 3 is a rerun of run 2's GitHub id. Point 12
- * is deliberately left unlinked.
+ * shared by points 10 and 11; runs 3 and 4 are two attempts of one GitHub run.
+ * Point 12 is deliberately left unlinked.
  */
 beforeEach(async () => {
   await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
@@ -41,8 +40,6 @@ beforeEach(async () => {
     VALUES (1, ${WITH_SERIES}, 1, 'Run Sweep', 'completed', 'success', 'main', 'abc123',
         'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${WITH_SERIES}',
         '2026-09-11T04:19:00Z', '2026-09-11'),
-      (2, ${WITHOUT_SERIES}, 1, 'Run Sweep', 'completed', 'success', null, null, null,
-        '2026-09-12T04:19:00Z', '2026-09-12'),
       (3, ${RETRIED}, 1, 'Run Sweep', 'completed', 'failure', null, null, null,
         '2026-09-13T04:19:00Z', '2026-09-13'),
       (4, ${RETRIED}, 2, 'Run Sweep', 'completed', 'success', null, null, null,
@@ -105,18 +102,6 @@ beforeEach(async () => {
 });
 
 describe('getGpuMetricsForRun', () => {
-  it('returns null for a GitHub run id that was never ingested', async () => {
-    expect(await getGpuMetricsForRun(sql, 99999999999)).toBeNull();
-  });
-
-  it('returns null for an ingested run that stored no telemetry series', async () => {
-    // The run row exists, so the null must come from the empty-series branch and
-    // not from a missing workflow_runs lookup.
-    const [row] = await sql`select id from workflow_runs where github_run_id = ${WITHOUT_SERIES}`;
-    expect(Number(row!.id)).toBe(2);
-    expect(await getGpuMetricsForRun(sql, WITHOUT_SERIES)).toBeNull();
-  });
-
   it('returns the run header, every series, its per-GPU stats, and its samples', async () => {
     const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
 
@@ -243,25 +228,3 @@ describe('getGpuMetricsForRun', () => {
     expect(dropped?.edgeTemp).toBeUndefined();
   });
 });
-
-describe('getGpuMetricsForPoint', () => {
-  it('returns null for a benchmark point with no linked series', async () => {
-    expect(await getGpuMetricsForPoint(sql, 12)).toBeNull();
-    expect(await getGpuMetricsForPoint(sql, 9999)).toBeNull();
-  });
-
-  it('returns every series linked to a multinode point, with each series full sample set', async () => {
-    const payload = await getGpuMetricsForPoint(sql, 10);
-    expect(payload?.benchmarkResultId).toBe(10);
-    expect(payload?.series.map((series) => [series.id, series.fileName])).toEqual([
-      [100, 'node0/gpu_metrics.csv'],
-      [101, 'node1/gpu_metrics.csv'],
-    ]);
-    expect(payload?.series.map((series) => series.data.length)).toEqual([3, 1]);
-    // Each series carries every point that references it, not just the queried one.
-    expect(payload?.series.map((series) => series.benchmarkResultIds)).toEqual([[10, 11], [10]]);
-
-    const single = await getGpuMetricsForPoint(sql, 11);
-    expect(single?.series.map((series) => series.id)).toEqual([100]);
-  });
-});

From 3582eef150d6d03b7a74f4228bbe9ab72a935162 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 03:45:18 -0700
Subject: [PATCH 043/103] test: remove redundant chart-coverage tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Keep 10 cases for the views API numbers, the mean x statistic and the
required ?unofficialrun= overlay paths. Drop the other 55 audited cases,
trim the topology E2E case to its overlay filter assertion, and restore
the timeline spec timing.

中文：删除冗余的 chart-coverage 测试。保留 10 个用例，覆盖 views API 数值、mean x 统计量以及必需的 ?unofficialrun= overlay 路径；删除其余 55 个审计用例，将 topology E2E 用例精简为 overlay 过滤断言，并补回 timeline spec 的计时条目。
---
 .../component/power-service-comparison.cy.tsx | 251 ------------------
 .../component/quick-filters-dialog.cy.tsx     |  77 ------
 .../cypress/component/scatter-graph.cy.tsx    |  52 ----
 .../app/cypress/e2e/inference-chart.cy.ts     | 188 ++-----------
 packages/app/cypress/support/e2e.ts           |   2 +-
 .../app/api/v1/views/inference/route.test.ts  | 102 -------
 .../app/api/v1/views/options/route.test.ts    |   4 -
 .../inference/InferenceContext.test.ts        |   9 -
 .../axis-metric-explanations.test.ts          |   3 -
 .../hooks/useChartData.x-axis-wiring.test.tsx |  12 -
 .../src/components/inference/utils.test.ts    |  83 ------
 .../utils/equal-service-comparison.test.ts    | 151 +----------
 .../inference/utils/powerCurves.test.ts       |  43 ---
 .../inference/utils/quickFilters.test.ts      | 122 ---------
 .../inference/utils/x-axis-scale.test.ts      |  11 -
 .../app/src/lib/benchmark-transform.test.ts   |  32 ---
 packages/app/src/lib/url-state.test.ts        |   9 -
 packages/app/src/lib/views-api/series.test.ts |  76 ------
 packages/app/timings.json                     |   4 +
 19 files changed, 24 insertions(+), 1207 deletions(-)
 delete mode 100644 packages/app/cypress/component/power-service-comparison.cy.tsx

diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
deleted file mode 100644
index 3ca436d2e..000000000
--- a/packages/app/cypress/component/power-service-comparison.cy.tsx
+++ /dev/null
@@ -1,251 +0,0 @@
-import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
-
-import type { AggDataEntry, InferenceData } from '@/components/inference/types';
-import PowerServiceComparison from '@/components/inference/ui/PowerServiceComparison';
-import { equalServiceSourceKey } from '@/components/inference/utils/equal-service-comparison';
-import { buildShareUrl, readUrlParams, writeUrlParams } from '@/lib/url-state';
-import { createMockInferenceData } from '../support/mock-data';
-import { mountWithProviders } from '../support/test-utils';
-
-const metric = (y: number) => ({ y, roof: false });
-const point = (overrides: Partial<InferenceData> = {}) =>
-  createMockInferenceData({
-    hwKey: 'b200_sglang',
-    hw: 'B200',
-    framework: 'sglang',
-    precision: 'fp8',
-    physicalChips: 4,
-    tp: 4,
-    decode_tp: 4,
-    conc: 8,
-    date: '2026-09-23',
-    run_url: 'https://example.invalid/runs/900000001',
-    benchmark_type: 'single_turn',
-    mean_tpot_intvty: 20,
-    output_tput_per_gpu: 50,
-    measuredAvgPower: metric(400),
-    measuredJPerOutputToken: metric(10),
-    ...overrides,
-  });
-const baseline = [
-  point({ id: 1 }),
-  point({
-    id: 2,
-    conc: 1,
-    mean_tpot_intvty: 60,
-    measuredAvgPower: metric(800),
-    output_tput_per_gpu: 150,
-    measuredJPerOutputToken: metric(30),
-  }),
-];
-const comparator = [
-  point({
-    id: 3,
-    hwKey: 'b300_sglang',
-    run_url: 'https://example.invalid/runs/900000002',
-    measuredAvgPower: metric(800),
-    output_tput_per_gpu: 100,
-    measuredJPerOutputToken: metric(8),
-  }),
-  point({
-    id: 4,
-    hwKey: 'b300_sglang',
-    run_url: 'https://example.invalid/runs/900000002',
-    mean_tpot_intvty: 60,
-    conc: 1,
-    measuredAvgPower: metric(1000),
-    output_tput_per_gpu: 200,
-    measuredJPerOutputToken: metric(16),
-  }),
-];
-const data = [...baseline, ...comparator];
-const baseKey = equalServiceSourceKey(baseline[0]);
-const peerKey = equalServiceSourceKey(comparator[0]);
-const roles = [40, 50, 60].map((share, index) =>
-  point({
-    id: 10 + index,
-    hwKey: 'gb200',
-    disagg: true,
-    physicalChips: 8,
-    num_prefill_gpu: 4,
-    num_decode_gpu: 4,
-    mean_tpot_intvty: 20 + index * 20,
-    conc: 2 ** index,
-    power_valid: 1,
-    power_metric_schema_version: 2,
-    joules_per_input_token: 2,
-    joules_per_output_token: 10,
-    prefill_joules_per_input_token: share / 50,
-    decode_joules_per_output_token: 10 - share / 10,
-  }),
-);
-
-function mountComparison(points = data, xField: keyof AggDataEntry = 'mean_tpot_intvty') {
-  mountWithProviders(
-    <PathnameContext.Provider value="/inference">
-      <div style={{ width: '100%', maxWidth: 1120, padding: 12, boxSizing: 'border-box' }}>
-        <PowerServiceComparison
-          data={points}
-          xField={xField}
-          xLabel={xField === 'conc' ? 'Concurrency' : 'Mean interactivity (output tok/s/user)'}
-          chartId="power-service-test"
-        />
-      </div>
-    </PathnameContext.Provider>,
-    { inference: {}, unofficial: {} },
-  );
-}
-const normalizedText = (element: JQuery<HTMLElement>) => element.text().replaceAll('−', '-');
-const target = () => cy.get('[data-testid="equal-service-target"]');
-const row = (metricName: string) => cy.get(`[data-testid="equal-service-${metricName}"]`);
-const roleSvg = () => cy.get('[data-testid="power-service-test-role-share-plot"]');
-
-function checkNoHorizontalOverflow() {
-  cy.document().should((doc) => {
-    expect(doc.documentElement.scrollWidth).to.be.at.most(doc.documentElement.clientWidth + 1);
-  });
-  cy.get('[data-testid="power-service-comparison"]').should(($panel) => {
-    const rect = $panel[0].getBoundingClientRect();
-    expect(rect.left).to.be.at.least(0);
-    expect(rect.right).to.be.at.most($panel[0].ownerDocument.documentElement.clientWidth + 1);
-  });
-}
-
-describe('PowerServiceComparison', () => {
-  beforeEach(() => {
-    writeUrlParams({
-      i_servicecompare: '0',
-      i_roleshare: '0',
-      i_servicebase: '',
-      i_servicepeer: '',
-      i_servicetarget: '',
-    });
-    readUrlParams();
-    cy.on('uncaught:exception', (error) => {
-      if (error.message.includes('ResizeObserver loop')) return false;
-    });
-  });
-
-  for (const width of [1280, 390]) {
-    it(`shows raw interpolation, signed deltas and source endpoints without page overflow (${width}px)`, () => {
-      cy.viewport(width, 1000);
-      mountComparison();
-      cy.get('[data-testid="equal-service-toggle"]').check();
-      target().type('40');
-      row('meanWattsPerGpu').within(() => {
-        cy.get('td')
-          .eq(0)
-          .should('contain.text', '600')
-          .and('contain.text', 'Interpolated')
-          .and('contain.text', 'Observation 1: 20 · c8')
-          .and('contain.text', 'Observation 2: 60 · c1');
-        cy.get('td').eq(1).should('contain.text', '900');
-        cy.get('td').eq(2).should('have.text', '+50.00%');
-      });
-      row('outputTokensPerSecond').within(() => {
-        cy.get('td strong').eq(0).should('have.text', '400');
-        cy.get('td strong').eq(1).should('have.text', '600');
-        cy.get('td').eq(2).should('have.text', '+50.00%');
-      });
-      row('joulesPerOutputToken').should(($row) =>
-        expect(normalizedText($row)).to.include('-40.00%'),
-      );
-      cy.get('[data-testid="power-service-test-service-plot"] circle.point').should(
-        'have.length',
-        9,
-      );
-      cy.get<SVGCircleElement & { __data__: { x: number; y: number } }>(
-        '[data-testid="power-service-test-service-plot"] circle.point[r="6"]',
-      )
-        .should('have.length', 3)
-        .and(($points) => {
-          const values = Array.from($points, (element) => element.__data__);
-          expect(values.map((entry) => entry.x)).to.deep.equal([40, 40, 40]);
-          expect(values.map((entry) => entry.y)).to.deep.equal([50, 50, -40]);
-        });
-      checkNoHorizontalOverflow();
-      cy.get('[data-testid="power-service-comparison"]').screenshot(`equal-service-${width}`, {
-        overwrite: true,
-      });
-    });
-  }
-
-  it('marks out-of-range values unavailable instead of extrapolating', () => {
-    mountComparison();
-    cy.get('[data-testid="equal-service-toggle"]').check();
-    target().type('80');
-    cy.get('[data-testid="equal-service-table"] tbody tr').each(($row) => {
-      cy.wrap($row).find('td').eq(2).should('have.text', 'Target is outside a source range.');
-      cy.wrap($row).find('strong').should('not.exist');
-    });
-  });
-
-  it('changes comparison direction and persists exact source keys and target in a share URL', () => {
-    mountComparison();
-    cy.get('[data-testid="equal-service-toggle"]').check();
-    target().type('40');
-    cy.get('[data-testid="equal-service-baseline"]').select(peerKey);
-    cy.get('[data-testid="equal-service-comparator"]').select(baseKey);
-    row('meanWattsPerGpu').should(($row) => expect(normalizedText($row)).to.include('-33.33%'));
-    row('joulesPerOutputToken').should('contain.text', '+66.67%');
-    cy.then(() => {
-      const params = new URL(buildShareUrl()).searchParams;
-      expect(params.get('i_servicebase')).to.equal(peerKey);
-      expect(params.get('i_servicepeer')).to.equal(baseKey);
-      expect(params.get('i_servicetarget')).to.equal('40');
-      expect(params.get('i_servicecompare')).to.equal('1');
-    });
-  });
-
-  it('restores source direction and target from a shared comparison URL', () => {
-    writeUrlParams({
-      i_servicecompare: '1',
-      i_servicebase: peerKey,
-      i_servicepeer: baseKey,
-      i_servicetarget: '40',
-    });
-    readUrlParams();
-    mountComparison();
-    cy.get('[data-testid="equal-service-baseline"]').should('have.value', peerKey);
-    target().should('have.value', '40');
-    row('joulesPerOutputToken').should('contain.text', '+66.67%');
-  });
-
-  it('draws observed role shares with a 50% equality reference and omits invalid telemetry', () => {
-    cy.viewport(1280, 1000);
-    mountComparison([...roles, { ...roles[0], id: 99, power_valid: 0 }]);
-    cy.get('[data-testid="role-share-toggle"]').check();
-    roleSvg()
-      .find<SVGCircleElement & { __data__: { y: number } }>('circle.point')
-      .should('have.length', 3)
-      .then(($points) => {
-        const values = [...$points].map((element) => element.__data__.y);
-        expect(values).to.deep.equal([40, 50, 60]);
-        const center = Number($points[1].getAttribute('cy'));
-        roleSvg()
-          .find('line[stroke-dasharray="5,4"]')
-          .should('have.length', 1)
-          .should(($line) => {
-            expect(Number($line.attr('y1'))).to.be.closeTo(center, 0.5);
-            expect(Number($line.attr('y2'))).to.be.closeTo(center, 0.5);
-          });
-      });
-    checkNoHorizontalOverflow();
-  });
-
-  it('keeps concurrency diagnostic role shares while suppressing equal-service comparisons on mobile', () => {
-    cy.viewport(390, 1000);
-    mountComparison(roles, 'conc');
-    cy.get('[data-testid="equal-service-toggle"]').check();
-    cy.get('[data-testid="equal-service-concurrency-note"]')
-      .should('be.visible')
-      .and('contain.text', 'load diagnostic');
-    cy.get('[data-testid="equal-service-panel"]').should('not.exist');
-    cy.get('[data-testid="role-share-toggle"]').check();
-    roleSvg().find('circle.point').should('have.length', 3);
-    checkNoHorizontalOverflow();
-    cy.get('[data-testid="prefill-share-panel"]').screenshot('prefill-share-mobile', {
-      overwrite: true,
-    });
-  });
-});
diff --git a/packages/app/cypress/component/quick-filters-dialog.cy.tsx b/packages/app/cypress/component/quick-filters-dialog.cy.tsx
index 6617c4a43..7fb249e45 100644
--- a/packages/app/cypress/component/quick-filters-dialog.cy.tsx
+++ b/packages/app/cypress/component/quick-filters-dialog.cy.tsx
@@ -2,9 +2,7 @@ import { QuickFiltersDialog } from '@/components/inference/ui/QuickFiltersDialog
 import { ActiveQuickFilters } from '@/components/inference/ui/ActiveQuickFilters';
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
 import type { QuickFilters } from '@/components/inference/types';
-import { pointTopologyKey } from '@/components/inference/utils/topology-filter';
 import { Sequence } from '@/lib/data-mappings';
-import { createMockInferenceData } from '../support/mock-data';
 import { mountWithProviders } from '../support/test-utils';
 
 const availableQuickFilters: QuickFilters = {
@@ -16,81 +14,6 @@ const availableQuickFilters: QuickFilters = {
 };
 
 describe('QuickFiltersDialog', () => {
-  for (const width of [390, 1280]) {
-    it(`wraps long topology options without overlap and scrolls to exact selection (${width}px)`, () => {
-      cy.viewport(width, 900);
-      const topologies = Array.from({ length: 12 }, (_, index) =>
-        pointTopologyKey(
-          createMockInferenceData({
-            disagg: true,
-            physicalChips: 8 * (index + 1),
-            num_prefill_gpu: 4 * (index + 1),
-            num_decode_gpu: 4 * (index + 1),
-            prefill_num_workers: index + 1,
-            decode_num_workers: index + 1,
-            prefill_tp: 4,
-            decode_tp: 4,
-            prefill_ep: 1 + (index % 2),
-            decode_ep: 1 + (index % 2),
-            prefill_pp: 1 + (index % 2),
-            decode_pp: 1 + (index % 2),
-            prefill_dcp_size: 1 + (index % 2),
-            decode_dcp_size: 1 + (index % 2),
-            prefill_pcp_size: 1 + (index % 2),
-            decode_pcp_size: 1 + (index % 2),
-            prefill_dp_attention: index % 2 === 0,
-            decode_dp_attention: index % 2 === 0,
-            offload_mode: index % 2 === 0 ? 'off' : 'on',
-          }),
-        ),
-      );
-      mountWithProviders(<QuickFiltersDialog open onOpenChange={cy.stub()} />, {
-        inference: { availableQuickFilters: { ...availableQuickFilters, topologies } },
-      });
-
-      cy.get('[data-testid="quick-filter-topology-options"]')
-        .scrollIntoView()
-        .should(($options) => {
-          const options = $options[0];
-          expect(options.scrollHeight).to.be.greaterThan(options.clientHeight);
-          expect(options.scrollWidth).to.be.at.most(options.clientWidth + 1);
-          const buttons = [...options.querySelectorAll('button')];
-          const bounds = buttons.map((button) => button.getBoundingClientRect());
-          expect(bounds[0].height, 'fixture exercises a multiline label').to.be.greaterThan(32);
-          buttons.forEach((button, index) => {
-            const range = button.ownerDocument.createRange();
-            range.selectNodeContents(button);
-            const text = range.getBoundingClientRect();
-            expect(text.top, 'label stays inside button').to.be.at.least(bounds[index].top - 1);
-            expect(text.bottom).to.be.at.most(bounds[index].bottom + 1);
-            expect(text.left).to.be.at.least(bounds[index].left - 1);
-            expect(text.right).to.be.at.most(bounds[index].right + 1);
-            for (const other of bounds.slice(index + 1)) {
-              const overlapX =
-                Math.min(bounds[index].right, other.right) -
-                Math.max(bounds[index].left, other.left);
-              const overlapY =
-                Math.min(bounds[index].bottom, other.bottom) -
-                Math.max(bounds[index].top, other.top);
-              expect(overlapX > 1 && overlapY > 1, 'topology buttons do not overlap').to.equal(
-                false,
-              );
-            }
-          });
-        })
-        .scrollTo('bottom')
-        .should(($options) => expect($options[0].scrollTop).to.be.greaterThan(0))
-        .find('button')
-        .last()
-        .should('be.visible')
-        .click();
-      cy.get('@setQuickFilterTopologies').should('have.been.calledOnceWith', [topologies.at(-1)!]);
-      cy.get('[data-testid="quick-filters-dialog"]')
-        .scrollTo('bottom')
-        .screenshot(`topology-options-${width}`, { overwrite: true });
-    });
-  }
-
   for (const locale of ['en', 'zh'] as const) {
     for (const width of [390, 1280]) {
       it(`explains every filter on hover without changing selections (${locale}, ${width}px)`, () => {
diff --git a/packages/app/cypress/component/scatter-graph.cy.tsx b/packages/app/cypress/component/scatter-graph.cy.tsx
index df42d1a91..fac02fad5 100644
--- a/packages/app/cypress/component/scatter-graph.cy.tsx
+++ b/packages/app/cypress/component/scatter-graph.cy.tsx
@@ -26,58 +26,6 @@ const defaultChartDef = createMockChartDefinition();
 const hwConfig = createMockHardwareConfig();
 
 describe('ScatterGraph', () => {
-  it('retains the explicit observed-concurrency sweep without frontier or ruler controls', () => {
-    const data = [1, 4, 128].map((conc, index) =>
-      createMockInferenceData({
-        id: 9000 + index,
-        hwKey: 'h100',
-        precision: Precision.FP4,
-        conc,
-        x: conc,
-        y: [500, 600, 470][index],
-        run_url: 'https://github.com/org/repo/actions/runs/123',
-      }),
-    );
-    mountWithProviders(
-      <div style={{ width: 1000 }}>
-        <ScatterGraph
-          chartId="observed-load-test"
-          modelLabel="DeepSeek R1"
-          data={data}
-          xLabel="Concurrency"
-          yLabel="Throughput / Chip (tok/s)"
-          chartDefinition={createMockChartDefinition({ x: 'conc' })}
-          transitionDuration={0}
-        />
-      </div>,
-      {
-        inference: {
-          activeHwTypes: new Set(['h100']),
-          hwTypesWithData: new Set(['h100']),
-          selectedXAxisMode: 'concurrency',
-          hideNonOptimal: true,
-          showParetoFrontier: true,
-          hardwareConfig: hwConfig,
-        },
-        unofficial: {},
-      },
-    );
-    cy.get('#observed-load-test .dot-group')
-      .should('have.length', 3)
-      .each(($point) => {
-        cy.wrap($point).should('have.css', 'opacity', '1');
-      });
-    cy.get('#observed-load-test path[data-curve-kind="observed-load"]')
-      .should('have.length', 1)
-      .invoke('attr', 'd')
-      .should('not.match', /[CQ]/u);
-    expandLegendAdvanced();
-    cy.get(
-      '#scatter-hide-non-optimal, #scatter-perf-ruler, #observed-load-test-pareto-frontier',
-    ).should('not.exist');
-    cy.get('.global-pareto-frontier').should('not.exist');
-  });
-
   it('keeps the frontier modes and overlay winners without exposing the retired hinterland', () => {
     const official = [
       createMockInferenceData({ hwKey: 'h100', precision: Precision.FP8, x: 20, y: 80 }),
diff --git a/packages/app/cypress/e2e/inference-chart.cy.ts b/packages/app/cypress/e2e/inference-chart.cy.ts
index 983c9ff42..e7b53acf9 100644
--- a/packages/app/cypress/e2e/inference-chart.cy.ts
+++ b/packages/app/cypress/e2e/inference-chart.cy.ts
@@ -1,5 +1,4 @@
 import type { InferenceData } from '@/components/inference/types';
-import { expandLegendAdvanced } from '../support/legend-advanced';
 import {
   interceptVrPublicationData,
   VR_FIXTURE_DATE,
@@ -862,173 +861,22 @@ const assertObservedLoads = (expected: number[]) => {
 };
 
 describe('Observed concurrency and exact topology', () => {
-  for (const locale of ['en', 'zh'] as const) {
-    it(`preserves official and overlay loads, topology and share state in ${locale}`, () => {
-      const officialRun = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/800001';
-      const officialBase = boundaryRows(null).map((row) => ({ ...row, run_url: officialRun }));
-      const overlayBase = boundaryRows(OVERLAY_RUN_URL);
-      interceptMeasuredComparison(withTp4(officialBase), withTp4(overlayBase));
-      cy.viewport(1440, 900);
-      cy.visit(
-        `${locale === 'zh' ? '/zh' : ''}/inference?g_model=DeepSeek-V4-Pro&unofficialrun=${OVERLAY_RUN_ID}&i_seq=1k%2F1k&i_prec=fp4&i_metric=y_measuredAvgPower&i_xmode=concurrency&i_optimal=1&i_best=1`,
-        { onBeforeLoad: unlockAgenticGate },
-      );
-      cy.wait('@measuredOverlay');
-      cy.get('[data-testid="x-axis-mode-selector"]')
-        .should('have.attr', 'data-value', 'concurrency')
-        .and('contain.text', locale === 'zh' ? '并发数' : 'Concurrency');
-      cy.get('[data-testid="chart-figure"] h2').should(
-        'contain.text',
-        locale === 'zh' ? '与并发数的关系' : 'vs. Concurrency',
-      );
-
-      assertObservedLoads([1, 1, 2, 2, 8, 8, 48, 48]);
-      cy.get<SVGPathElement & { __data__: { points: InferenceData[] } }>(
-        '[data-testid="inference-chart-display"] path[data-curve-kind="observed-load"]',
-      )
-        .should('have.length', 4)
-        .and(($curves) => {
-          for (const curve of $curves) {
-            expect(new Set(curve.__data__.points.map((point) => point.tp)).size).to.equal(1);
-            expect(curve.__data__.points.map((point) => point.x)).to.deep.equal([1, 2, 8, 48]);
-            expect(curve.getAttribute('d')).to.be.a('string').and.not.match(/[CQ]/u);
-          }
-        });
-      expandLegendAdvanced();
-      cy.get('#scatter-hide-non-optimal, #scatter-perf-ruler, #chart-0-pareto-frontier').should(
-        'not.exist',
-      );
-      cy.get('[data-testid="scatter-quick-filters"]').click();
-      cy.get('[data-testid="quick-filter-best-per-sku"]').should('not.exist');
-      cy.get('[data-testid="quick-filter-topology-options"] button').should('have.length', 2);
-      cy.contains('[data-testid="quick-filter-topology-options"] button', /GPU=?4.*TP=?4/u).click();
-      cy.get('body').type('{esc}');
-      cy.get('[data-testid="quick-filters-dialog"]').should('not.exist');
-      assertObservedLoads([1, 2, 8, 48]);
-      cy.get('[data-testid="chart-figure"]')
-        .first()
-        .screenshot(`powerx-concurrency-${locale}-desktop`);
-      cy.viewport(390, 844);
-      assertObservedLoads([1, 2, 8, 48]);
-      expectNoPageOverflow();
-      cy.get('[data-testid="chart-figure"]')
-        .first()
-        .screenshot(`powerx-concurrency-${locale}-mobile`);
-      cy.viewport(1440, 900);
-      // The address bar stays clean: Share flushes the in-memory filter state.
-      cy.get('[data-testid="share-button"]').first().click();
-      cy.get('[data-testid="share-url-input"]')
-        .invoke('val')
-        .should((value) => {
-          const params = new URL(String(value)).searchParams;
-          expect(params.get('i_xmode')).to.equal('concurrency');
-          expect(params.get('i_topology')).to.include('GPU=4');
-        })
-        .then((value) => {
-          const shared = new URL(String(value));
-          cy.visit(`${shared.pathname}${shared.search}`, { onBeforeLoad: unlockAgenticGate });
-        });
-      cy.wait('@measuredOverlay');
-      assertObservedLoads([1, 2, 8, 48]);
-      cy.get('[data-testid="x-axis-mode-selector"]').should(
-        'have.attr',
-        'data-value',
-        'concurrency',
-      );
-      selectXAxisMode('interactivity');
-      cy.get(
-        '[data-testid="inference-chart-display"] svg path[data-curve-kind="observed-load"]',
-      ).should('not.exist');
-      cy.get('#scatter-hide-non-optimal').should('exist');
-      cy.get<SVGElement & { __data__: InferenceData }>(
-        '[data-testid="inference-chart-display"] svg .dot-group',
-      ).should(($points) => {
-        expect(
-          [...$points].map((element) => element.__data__.x).sort((a, b) => a - b),
-        ).to.deep.equal([10.6, 68.5, 111.1, 130.2]);
-      });
-      selectXAxisMode('concurrency', locale === 'zh' ? '并发数' : 'Concurrency');
-      assertObservedLoads([1, 2, 8, 48]);
-      cy.get('#scatter-hide-non-optimal, #scatter-perf-ruler').should('not.exist');
-      cy.get('[data-testid="inference-view-toggle-0"]')
-        .contains(locale === 'zh' ? '表格' : 'Table')
-        .click();
-      cy.get('[data-testid="inference-results-table"] tbody tr').should('have.length', 8);
-      cy.get('[data-testid="inference-results-table"]').should(
-        'contain.text',
-        locale === 'zh' ? '并发数' : 'Concurrency',
-      );
-    });
-  }
-});
-
-describe('Fixed-sequence service statistics', () => {
-  for (const locale of ['en', 'zh'] as const) {
-    it(`shares mean TPOT-derived speed and switches statistics on desktop/mobile in ${locale}`, () => {
-      const withMeans = (runUrl: string | null) =>
-        measuredRows(runUrl).map((row, index) => ({
-          ...row,
-          metrics: {
-            ...row.metrics,
-            mean_intvty: 999,
-            ...(index < 3
-              ? {
-                  mean_tpot: 1 / [20, 40, 80][index],
-                  mean_ttft: [1, 2, 4][index],
-                  mean_e2el: [10, 20, 40][index],
-                }
-              : {}),
-          },
-        }));
-      const official = withMeans(null);
-      interceptMeasuredComparison(official, withMeans(OVERLAY_RUN_URL));
-      cy.viewport(1440, 900);
-      cy.visit(
-        `${locale === 'zh' ? '/zh' : ''}/inference?g_model=DeepSeek-V4-Pro&unofficialrun=${OVERLAY_RUN_ID}&i_seq=1k%2F1k&i_prec=fp4&i_metric=y_measuredAvgPower&i_xmode=interactivity&i_mstat=mean&i_optimal=0&i_best=0`,
-        { onBeforeLoad: unlockAgenticGate },
-      );
-      cy.wait('@measuredOverlay');
-      cy.get('[data-testid="fixed-sequence-statistic-selector"]')
-        .should('have.attr', 'data-value', 'mean')
-        .and('contain.text', locale === 'zh' ? '平均值' : 'Mean');
-      cy.get('[data-testid="chart-figure"] h2').should(
-        'contain.text',
-        locale === 'zh' ? '平均交互性' : 'Mean Interactivity',
-      );
-      assertObservedLoads([20, 40, 80]);
-      cy.get('[data-testid="fixed-sequence-statistic-selector"]').click();
-      cy.get('[data-testid="fixed-sequence-statistic-median"]').click();
-      assertObservedLoads(
-        singleTurnRows(null)
-          .map((row) => row.metrics.median_intvty)
-          .sort((a, b) => a - b),
-      );
-      cy.viewport(390, 844);
-      selectXAxisMode('interactivity');
-      cy.get('[data-testid="fixed-sequence-statistic-selector"]').click();
-      cy.get('[data-testid="fixed-sequence-statistic-mean"]').click();
-      assertObservedLoads([20, 40, 80]);
-      expectNoPageOverflow();
-      cy.viewport(1440, 900);
-      selectXAxisMode('ttft');
-      assertObservedLoads([1, 2, 4]);
-      selectXAxisMode('e2e');
-      assertObservedLoads([10, 20, 40]);
-      cy.get('[data-testid="share-button"]').first().click();
-      cy.get('[data-testid="share-url-input"]')
-        .invoke('val')
-        .then((value) => {
-          const shared = new URL(String(value));
-          expect(shared.searchParams.get('i_mstat')).to.equal('mean');
-          cy.visit(`${shared.pathname}${shared.search}`, { onBeforeLoad: unlockAgenticGate });
-        });
-      cy.wait('@measuredOverlay');
-      assertObservedLoads([10, 20, 40]);
-      // Click the chevron, away from the label's separate help button and sticky header.
-      cy.get('[data-testid="x-axis-mode-selector"]').click('right', { scrollBehavior: 'center' });
-      cy.get('[data-testid="x-axis-mode-concurrency"]').click();
-      cy.get('[data-testid="fixed-sequence-statistic-selector"]').should('not.exist');
-      assertObservedLoads(official.map((row) => row.conc).sort((a, b) => a - b));
-    });
-  }
+  it('applies the exact-topology filter to official and ?unofficialrun= overlay loads', () => {
+    const officialRun = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/800001';
+    const officialBase = boundaryRows(null).map((row) => ({ ...row, run_url: officialRun }));
+    const overlayBase = boundaryRows(OVERLAY_RUN_URL);
+    interceptMeasuredComparison(withTp4(officialBase), withTp4(overlayBase));
+    cy.viewport(1440, 900);
+    cy.visit(
+      `/inference?g_model=DeepSeek-V4-Pro&unofficialrun=${OVERLAY_RUN_ID}&i_seq=1k%2F1k&i_prec=fp4&i_metric=y_measuredAvgPower&i_xmode=concurrency&i_optimal=1&i_best=1`,
+      { onBeforeLoad: unlockAgenticGate },
+    );
+    cy.wait('@measuredOverlay');
+    assertObservedLoads([1, 1, 2, 2, 8, 8, 48, 48]);
+    cy.get('[data-testid="scatter-quick-filters"]').click();
+    cy.contains('[data-testid="quick-filter-topology-options"] button', /GPU=?4.*TP=?4/u).click();
+    cy.get('body').type('{esc}');
+    cy.get('[data-testid="quick-filters-dialog"]').should('not.exist');
+    assertObservedLoads([1, 2, 8, 48]);
+  });
 });
diff --git a/packages/app/cypress/support/e2e.ts b/packages/app/cypress/support/e2e.ts
index 48a6c72c1..17f3f55c2 100644
--- a/packages/app/cypress/support/e2e.ts
+++ b/packages/app/cypress/support/e2e.ts
@@ -164,7 +164,7 @@ export function openXAxisMenu(): void {
 
 /** Select an axis and verify that the single-select menu closes immediately. */
 export function selectXAxisMode(
-  mode: 'interactivity' | 'e2e' | 'ttft' | 'e2e-normalized-interactivity' | 'concurrency',
+  mode: 'interactivity' | 'e2e' | 'ttft' | 'e2e-normalized-interactivity',
   label?: string,
 ): void {
   openXAxisMenu();
diff --git a/packages/app/src/app/api/v1/views/inference/route.test.ts b/packages/app/src/app/api/v1/views/inference/route.test.ts
index 3bfb6ea21..03077bf42 100644
--- a/packages/app/src/app/api/v1/views/inference/route.test.ts
+++ b/packages/app/src/app/api/v1/views/inference/route.test.ts
@@ -173,39 +173,6 @@ describe('GET /api/v1/views/inference', () => {
     expect(body.equalServiceCurve).toHaveLength(2);
   });
 
-  it('preserves explicit unavailable sources, omits target by default and rejects unsupported CSV panels', async () => {
-    const response = await GET(
-      request('/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&serviceCompare=true'),
-    );
-    const responseBody = await response.json();
-    expect(responseBody.equalServiceComparison).toBeNull();
-    const stale = await GET(
-      request(
-        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&serviceCompare=true&serviceBaseline=missing&serviceTarget=40',
-      ),
-    );
-    const body = await stale.json();
-    expect(body.params.serviceBaseline).toBe('missing');
-    expect(body.equalServiceComparison.reason).toBe('unknown-source');
-    const diagnostic = await GET(
-      request(
-        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&serviceCompare=true&serviceTarget=40&xmode=concurrency',
-      ),
-    );
-    const diagnosticBody = await diagnostic.json();
-    expect(diagnosticBody.equalServiceComparison.reason).toBe('unsupported-axis');
-    for (const extra of [
-      'format=csv&serviceCompare=true',
-      'format=csv&roleShare=true',
-      'serviceTarget=0',
-      'serviceTarget=',
-      'serviceTarget=NaN',
-    ]) {
-      const invalid = await GET(request(`/api/v1/views/inference?model=DeepSeek-R1-0528&${extra}`));
-      expect(invalid.status).toBe(400);
-    }
-  });
-
   it('includes unofficial sources and validated role shares using one output-token denominator', async () => {
     const row = makeRow({
       hardware: 'gb200',
@@ -286,27 +253,6 @@ describe('GET /api/v1/views/inference', () => {
     expect(invalidBody.param).toBe('xstat');
   });
 
-  it('keeps AgentX percentile selection independent of fixed-sequence xstat', async () => {
-    mockGetLatestBenchmarks.mockResolvedValue([
-      makeRow({
-        benchmark_type: 'agentic_traces',
-        isl: null,
-        osl: null,
-        metrics: { ...makeRow().metrics, p75_itl: 1 / 35, mean_tpot: 0.025 },
-      }),
-    ]);
-    const response = await GET(
-      request(
-        '/api/v1/views/inference?model=DeepSeek-R1-0528&sequence=agentic&metric=tpPerGpu&xstat=mean&percentile=p75',
-      ),
-    );
-    const body = await response.json();
-    expect(response.status).toBe(200);
-    expect(body.params.xstat).toBeNull();
-    expect(body.xAxis).toMatchObject({ field: 'p75_intvty', statistic: 'p75' });
-    expect(body.series[0].points[0].x).toBe(35);
-  });
-
   it('returns chart-ready series with resolved params for the default selection', async () => {
     const res = await GET(
       request('/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu'),
@@ -453,54 +399,6 @@ describe('GET /api/v1/views/inference', () => {
     expect(body.series[0].gpu).toBe('mi300x');
   });
 
-  it('discovers exact topology keys and retains every observed concurrency in that topology', async () => {
-    const discover = await GET(
-      request(
-        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&xmode=concurrency&optimal=true&best=true',
-      ),
-    );
-    const initial = await discover.json();
-    const key = initial.series[0].points[0].topologyKey;
-    expect(typeof key).toBe('string');
-    const otherTopology = makeRow({
-      decode_tp: 4,
-      num_decode_gpu: 4,
-      num_prefill_gpu: 4,
-      conc: 128,
-    });
-    mockGetLatestBenchmarks.mockResolvedValue([...ROWS, otherTopology]);
-    const query = new URLSearchParams({
-      model: 'DeepSeek-R1-0528',
-      metric: 'tpPerGpu',
-      xmode: 'concurrency',
-      optimal: 'true',
-      best: 'true',
-      topologies: key,
-    });
-    const response = await GET(request(`/api/v1/views/inference?${query}`));
-    expect(response.status).toBe(200);
-    const body = await response.json();
-    expect(body.params).toMatchObject({ optimal: false, best: false, topologies: [key] });
-    expect(body.xAxis).toMatchObject({ mode: 'concurrency', field: 'conc' });
-    expect(body.frontier).toEqual({ direction: null, points: 0 });
-    expect(body.count).toBe(3);
-    const points = body.series.flatMap(
-      (series: { points: { x: number; concurrency: number; topologyKey: string }[] }) =>
-        series.points,
-    );
-    expect(
-      points.map((point: { x: number }) => point.x).sort((a: number, b: number) => a - b),
-    ).toEqual([16, 32, 64]);
-    for (const point of points) {
-      expect(point.x).toBe(point.concurrency);
-      expect(point.topologyKey).toBe(key);
-    }
-    query.set('topologies', 'unavailable-topology');
-    const missing = await GET(request(`/api/v1/views/inference?${query}`));
-    const missingBody = await missing.json();
-    expect(missingBody.count).toBe(0);
-  });
-
   it('case-folds the gpus filter: uppercase base keys select the same series', async () => {
     const upperRes = await GET(
       request('/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&gpus=MI300X'),
diff --git a/packages/app/src/app/api/v1/views/options/route.test.ts b/packages/app/src/app/api/v1/views/options/route.test.ts
index 612016adc..24469746f 100644
--- a/packages/app/src/app/api/v1/views/options/route.test.ts
+++ b/packages/app/src/app/api/v1/views/options/route.test.ts
@@ -86,16 +86,12 @@ describe('GET /api/v1/views/options', () => {
   it('exposes dashboard-parity defaults', async () => {
     const bodyRes = await GET(request('/api/v1/views/options'));
     const body = await bodyRes.json();
-    expect(body.fixedSequenceStatistics).toEqual(['median', 'mean']);
     expect(body.defaults).toMatchObject({
       model: 'DeepSeek-V4-Pro',
       sequence: '8k/1k',
       metric: 'y_tokensPerDollarH',
       percentile: 'p90',
       xmode: 'interactivity',
-      xstat: 'median',
-      serviceCompare: false,
-      roleShare: false,
     });
     // Same vendors, in the dashboard's quick-filter pill order.
     expect(body.quickFilters.vendors).toEqual(VENDOR_ORDER);
diff --git a/packages/app/src/components/inference/InferenceContext.test.ts b/packages/app/src/components/inference/InferenceContext.test.ts
index c0e18de60..ecc2eee41 100644
--- a/packages/app/src/components/inference/InferenceContext.test.ts
+++ b/packages/app/src/components/inference/InferenceContext.test.ts
@@ -66,15 +66,6 @@ describe('inference requested and effective axis selectors', () => {
     );
   });
 
-  it('uses fixed-sequence mean TTFT without changing Agentic percentile semantics', () => {
-    expect(resolveE2eXAxisMetric(null, 'ttft', Sequence.EightK_OneK, 'p90', 'mean')).toBe(
-      'mean_ttft',
-    );
-    expect(resolveE2eXAxisMetric(null, 'ttft', Sequence.AgenticTraces, 'p90', 'mean')).toBe(
-      'p90_ttft',
-    );
-  });
-
   it('uses natural E2E x-axis and preserves inactive requested metric', () => {
     expect(resolveE2eXAxisMetric('p90_ttft', 'e2e', Sequence.AgenticTraces, 'p75')).toBeNull();
     expect(resolveE2eXAxisMetric('p90_ttft', 'interactivity', Sequence.AgenticTraces, 'p75')).toBe(
diff --git a/packages/app/src/components/inference/axis-metric-explanations.test.ts b/packages/app/src/components/inference/axis-metric-explanations.test.ts
index 3051bc9d8..e5c12cfe6 100644
--- a/packages/app/src/components/inference/axis-metric-explanations.test.ts
+++ b/packages/app/src/components/inference/axis-metric-explanations.test.ts
@@ -165,9 +165,6 @@ describe('xAxisPercentileFromLabel', () => {
   it('extracts percentile words', () => {
     expect(xAxisPercentileFromLabel('P90 Time To First Token (s)')).toBe('P90');
     expect(xAxisPercentileFromLabel('Median Time To First Token (s)')).toBe('Median');
-    expect(xAxisPercentileFromLabel('Mean Interactivity (tok/s/user)')).toBe('Mean');
-    expect(xAxisPercentileFromLabel('平均交互性（tok/s/user）')).toBe('Mean');
-    expect(xAxisPercentileFromLabel('中位首 token 延迟 (s)')).toBe('Median');
     expect(xAxisPercentileFromLabel('P75 E2E Normalized Interactivity (tok/s/user)')).toBe('P75');
     expect(xAxisPercentileFromLabel('P99.9 End-to-end Latency (s)')).toBe('P99.9');
   });
diff --git a/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx b/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx
index d716c5bef..4318fa12c 100644
--- a/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx
+++ b/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx
@@ -208,18 +208,6 @@ describe('useChartData x-axis scale wiring', () => {
     },
   );
 
-  it('uses observed concurrency, preserves every point and removes preference directions', () => {
-    act(() => root.render(<Probe mode="concurrency" />));
-    for (const graph of result!.graphs) {
-      expect(graph.data.map((point) => point.x)).toEqual([8, 16]);
-      expect(graph.chartDefinition.x_scale_field).toBe('conc');
-      expect(graph.chartDefinition.x_label).toBe('Concurrency');
-      expect(graph.chartDefinition.x_labelZh).toBe('并发数');
-      expect(graph.chartDefinition.y_inputTputPerGpu_roofline).toBeUndefined();
-      expect(graph.clippedData).toEqual([]);
-    }
-  });
-
   it.each([
     ['interactivity', 'interactivity', 'median_intvty'],
     ['ttft', 'e2e', 'median_ttft'],
diff --git a/packages/app/src/components/inference/utils.test.ts b/packages/app/src/components/inference/utils.test.ts
index 3af37c473..2b07210fb 100644
--- a/packages/app/src/components/inference/utils.test.ts
+++ b/packages/app/src/components/inference/utils.test.ts
@@ -1,7 +1,6 @@
 import { describe, it, expect } from 'vitest';
 
 import type { ChartDefinition, InferenceData } from '@/components/inference/types';
-import { resolveXAxisField } from './utils/resolveXAxisField';
 import {
   filterDataByCostLimit,
   partitionChartDataByLimits,
@@ -248,17 +247,6 @@ describe('processOverlayChartData', () => {
     expect(result.clippedData).toEqual([]);
   });
 
-  it('never substitutes latency coordinates for missing concurrency', () => {
-    const result = processOverlayChartDataWithClipping(
-      [{ ...prefillEnergyPoint(68, 120), conc: Number.NaN }],
-      'e2e',
-      'y_measuredPrefillJPerInputToken',
-      null,
-      { selectedXAxisMode: 'concurrency' },
-    );
-    expect(result.data).toEqual([]);
-  });
-
   it('uses median TTFT for fixed-sequence overlays in TTFT mode and omits missing measurements', () => {
     const result = processOverlayChartDataWithClipping(
       [prefillEnergyPoint(68, 1.5), prefillEnergyPoint(55)],
@@ -656,74 +644,3 @@ describe('TPUv7 overlay TCO basis', () => {
     ).toBe(1.21);
   });
 });
-
-describe('fixed-sequence service statistic resolution', () => {
-  it.each([
-    ['interactivity', 'interactivity', 'median_intvty', 'mean_tpot_intvty'],
-    ['e2e', 'e2e', 'median_e2el', 'mean_e2el'],
-    ['ttft', 'e2e', 'median_e2el', 'mean_ttft'],
-  ] as const)(
-    'resolves mean %s without changing its preference direction',
-    (mode, type, natural, mean) => {
-      const definition = chartDef({ chartType: type, x: natural });
-      const resolved = resolveXAxisField(definition, 'y_tpPerGpu', 'p90_ttft', {
-        isAgentic: false,
-        percentile: 'p90',
-        xAxisMode: mode,
-        fixedSequenceStatistic: 'mean',
-      });
-      expect(resolved.xAxisField).toBe(mean);
-      expect(
-        resolveXAxisField(definition, 'y_tpPerGpu', null, {
-          isAgentic: false,
-          percentile: 'p90',
-          xAxisMode: mode,
-        }).xAxisField,
-      ).toBe(mode === 'ttft' ? 'median_ttft' : natural);
-      if (mode !== 'ttft') expect(resolved.naturalX).toBe(mean);
-    },
-  );
-
-  it('does not apply fixed-sequence means to agentic percentiles or observed concurrency', () => {
-    const definition = chartDef({ chartType: 'interactivity', x: 'median_intvty' });
-    expect(
-      resolveXAxisField(definition, 'y_tpPerGpu', null, {
-        isAgentic: true,
-        percentile: 'p90',
-        xAxisMode: 'interactivity',
-        fixedSequenceStatistic: 'mean',
-      }).xAxisField,
-    ).toBe('p90_intvty');
-    expect(
-      resolveXAxisField(definition, 'y_tpPerGpu', null, {
-        isAgentic: false,
-        percentile: 'p90',
-        xAxisMode: 'concurrency',
-        fixedSequenceStatistic: 'mean',
-      }).xAxisField,
-    ).toBe('conc');
-  });
-
-  it.each(['mean_tpot_intvty', 'mean_ttft', 'mean_e2el'] as const)(
-    'omits missing/invalid %s from overlays rather than reusing median or raw speed',
-    (field) => {
-      const mode =
-        field === 'mean_tpot_intvty' ? 'interactivity' : field === 'mean_ttft' ? 'ttft' : 'e2e';
-      const type = mode === 'interactivity' ? 'interactivity' : 'e2e';
-      const points = [undefined, 0, -1, NaN, Infinity, 4].map((value) =>
-        pt({
-          [field]: value,
-          mean_intvty: 999,
-          median_intvty: 100,
-          median_ttft: 1,
-          median_e2el: 3,
-        }),
-      );
-      const result = processOverlayChartData(points, type, 'y_tpPerGpu', null, {
-        selectedXAxisMode: mode,
-        fixedSequenceStatistic: 'mean',
-      });
-      expect(result.map((point) => point.x)).toEqual([4]);
-    },
-  );
-});
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
index f202b7b30..f02df8334 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
@@ -1,12 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { InferenceData } from '../types';
-import {
-  buildEqualServiceComparison,
-  equalServiceSourceKey,
-  getEqualServiceComparisonCurve,
-  getEqualServiceSources,
-  getPrefillSharePoints,
-} from './equal-service-comparison';
+import { buildEqualServiceComparison, equalServiceSourceKey } from './equal-service-comparison';
 
 const metric = (y: number) => ({ y, roof: false });
 function point(overrides: Partial<InferenceData> = {}): InferenceData {
@@ -108,20 +102,6 @@ describe('equal-service comparison', () => {
     expect(result.metrics.meanWattsPerGpu.changePercent).not.toBe(62.5);
   });
 
-  it('uses exact observations without interpolation and accepts consistent repeated observations', () => {
-    const result = buildEqualServiceComparison([...a, { ...a[0], id: 5 }, ...b], {
-      ...options,
-      target: 20,
-    });
-    expect(result.metrics.meanWattsPerGpu.baseline).toMatchObject({
-      value: 400,
-      interpolated: false,
-    });
-    expect(result.metrics.meanWattsPerGpu.baseline?.endpoints.map(({ point: p }) => p.id)).toEqual([
-      1, 5,
-    ]);
-  });
-
   it('does not skip a missing interior measurement or turn it into zero', () => {
     const gap = point({ id: 5, mean_intvty: 40, measuredAvgPower: undefined });
     const result = buildEqualServiceComparison([...a, gap, ...b], { ...options, target: 50 });
@@ -133,99 +113,6 @@ describe('equal-service comparison', () => {
     expect(result.metrics.outputTokensPerSecond.changePercent).not.toBeNull();
   });
 
-  it('rejects conflicting duplicate X per quantity instead of averaging them', () => {
-    const conflict = point({ ...a[0], id: 5, measuredAvgPower: metric(401) });
-    const result = buildEqualServiceComparison([...a, conflict, ...b], options);
-    expect(result.metrics.meanWattsPerGpu.reason).toBe('ambiguous-x');
-    expect(result.metrics.meanWattsPerGpu.changePercent).toBeNull();
-    expect(result.metrics.joulesPerOutputToken.changePercent).toBe(-40);
-  });
-
-  it.each([0, -1, Number.NaN, Number.POSITIVE_INFINITY])('withholds invalid metric %s', (value) => {
-    const rows = a.map((p) => ({ ...p, measuredAvgPower: metric(value) }));
-    expect(
-      buildEqualServiceComparison([...rows, ...b], options).metrics.meanWattsPerGpu.reason,
-    ).toBe('missing-metric');
-  });
-
-  it('rejects extrapolation, invalid target, same source, unknown source and concurrency as service', () => {
-    expect(
-      buildEqualServiceComparison([...a, ...b], { ...options, target: 61 }).metrics.meanWattsPerGpu
-        .reason,
-    ).toBe('out-of-range');
-    expect(buildEqualServiceComparison([...a, ...b], { ...options, target: NaN }).reason).toBe(
-      'invalid-target',
-    );
-    expect(
-      buildEqualServiceComparison([...a, ...b], { ...options, comparator: options.baseline })
-        .reason,
-    ).toBe('same-source');
-    expect(
-      buildEqualServiceComparison([...a, ...b], { ...options, comparator: 'missing' }).reason,
-    ).toBe('unknown-source');
-    expect(buildEqualServiceComparison([...a, ...b], { ...options, xField: 'conc' }).reason).toBe(
-      'unsupported-axis',
-    );
-  });
-
-  it('keeps run, actual date, topology, recipe, image, runtime and attempt isolated', () => {
-    const variants = [
-      { run_url: 'https://example.invalid/runs/3' },
-      { actualDate: '2026-09-22' },
-      { decode_pp: 2 },
-      { recipe_fingerprint: 'recipe-2' },
-      { image: 'new-image' },
-      { spec_decoding: 'mtp' },
-      { kv_offload_backend: 'other' },
-    ];
-    for (const variant of variants) {
-      const altered = point({ ...a[1], ...variant });
-      expect(equalServiceSourceKey(altered)).not.toBe(options.baseline);
-      expect(
-        buildEqualServiceComparison([a[0], altered, ...b], options).metrics.meanWattsPerGpu.reason,
-      ).toBe('out-of-range');
-    }
-    const attempted = { ...a[0], run_attempt: 2 };
-    expect(equalServiceSourceKey(attempted)).not.toBe(options.baseline);
-    expect(equalServiceSourceKey(point({ id: 1, run_url: undefined }))).not.toBe(
-      equalServiceSourceKey(point({ id: 2, run_url: undefined })),
-    );
-    expect(getEqualServiceSources([...b, ...a])).toEqual(getEqualServiceSources([...a, ...b]));
-  });
-
-  it('keeps source keys stable across UI display-date overrides and uses the requested mean basis', () => {
-    expect(equalServiceSourceKey({ ...a[0], date: '2026-09-24', actualDate: a[0].date })).toBe(
-      equalServiceSourceKey(a[0]),
-    );
-    const rows = [...a, ...b].map((p) => ({ ...p, mean_tpot_intvty: p.mean_intvty! / 2 }));
-    const result = buildEqualServiceComparison(rows, {
-      ...options,
-      xField: 'mean_tpot_intvty',
-      target: 20,
-    });
-    expect(result.metrics.meanWattsPerGpu.baseline?.value).toBe(600);
-    expect(result.metrics.meanWattsPerGpu.changePercent).toBe(50);
-  });
-
-  it('ignores comparison clones and hidden sources, supports ordinary overlay run URLs', () => {
-    const overlay = a.map((p) => ({
-      ...p,
-      id: undefined,
-      run_url: 'https://example.invalid/runs/overlay',
-    }));
-    const result = buildEqualServiceComparison(
-      [
-        ...overlay,
-        ...b,
-        { ...a[0], powerVariant: { kind: 'basis', id: 'gpu-provisioned' } },
-        { ...a[1], hidden: true },
-      ],
-      { ...options, baseline: equalServiceSourceKey(overlay[0]) },
-    );
-    expect(result.metrics.meanWattsPerGpu.changePercent).toBe(50);
-    expect(result.baseline?.label).toContain('overlay');
-  });
-
   it('scales aggregate output by physical chips, but PD output by decode GPUs only', () => {
     const aggregate = point({ physicalChips: 8, tp: 2 });
     const pd = point({
@@ -256,40 +143,4 @@ describe('equal-service comparison', () => {
       }).metrics.outputTokensPerSecond.reason,
     ).toBe('missing-metric');
   });
-
-  it('evaluates sorted observed-X union only within overlap and retains missing knots', () => {
-    const inner = b.map((p, i) => ({ ...p, mean_intvty: i ? 50 : 30 }));
-    const curve = getEqualServiceComparisonCurve(
-      [...a, ...inner, point({ id: 5, mean_intvty: 40, measuredAvgPower: undefined })],
-      options,
-    );
-    expect(curve.map((row) => row.target)).toEqual([30, 40, 50]);
-    expect(curve[1].metrics.meanWattsPerGpu.reason).toBe('missing-metric');
-    expect(getEqualServiceComparisonCurve([...a, ...b], { ...options, xField: 'conc' })).toEqual(
-      [],
-    );
-  });
-
-  it('reuses measured same-window role accounting, not the nominal input:output ratio', () => {
-    const pd = point({
-      disagg: true,
-      power_valid: 1,
-      power_metric_schema_version: 2,
-      joules_per_input_token: 2,
-      joules_per_output_token: 10,
-      prefill_joules_per_input_token: 1,
-      decode_joules_per_output_token: 5,
-    });
-    const [share] = getPrefillSharePoints([pd, { ...pd, power_valid: 0 }], 'mean_intvty');
-    expect(share).toMatchObject({
-      x: 20,
-      prefill: 5,
-      decode: 5,
-      total: 10,
-      prefillShare: 50,
-      sourceKey: equalServiceSourceKey(pd),
-      point: pd,
-    });
-    expect(getPrefillSharePoints([pd], 'conc')[0]).toMatchObject({ x: pd.conc, prefillShare: 50 });
-  });
 });
diff --git a/packages/app/src/components/inference/utils/powerCurves.test.ts b/packages/app/src/components/inference/utils/powerCurves.test.ts
index c5c355a21..dc0125649 100644
--- a/packages/app/src/components/inference/utils/powerCurves.test.ts
+++ b/packages/app/src/components/inference/utils/powerCurves.test.ts
@@ -1,4 +1,3 @@
-import { groupConcurrencySeries } from './concurrency-series';
 import { describe, expect, it } from 'vitest';
 
 import type { InferenceData } from '@/components/inference/types';
@@ -132,45 +131,3 @@ describe('upper power envelope', () => {
     ).toEqual([valid]);
   });
 });
-
-describe('observed concurrency series', () => {
-  const load = (conc: number, overrides: Partial<InferenceData> = {}) =>
-    point(conc, conc, 500, {
-      run_url: 'https://github.com/org/repo/actions/runs/123',
-      ...overrides,
-    });
-
-  it('retains non-monotonic measured points and sorts by exact load', () => {
-    const points = [load(128, { y: 470 }), load(1, { y: 500 }), load(4, { y: 600 })];
-    const segments = [...groupConcurrencySeries(points).values()];
-    expect(segments).toHaveLength(1);
-    expect(segments[0].map((sample) => [sample.x, sample.y])).toEqual([
-      [1, 500],
-      [4, 600],
-      [128, 470],
-    ]);
-  });
-
-  it('never connects different topology, recipes, runs, dates or role variants', () => {
-    const base = load(1);
-    const points = [
-      base,
-      load(4, { tp: 4 }),
-      load(8, { recipe_fingerprint: 'other-recipe' }),
-      load(16, { run_url: 'https://github.com/org/repo/actions/runs/456' }),
-      load(32, { date: '2026-09-11' }),
-      load(64, { powerVariant: { kind: 'role', id: 'prefill' } }),
-    ];
-    const segments = [...groupConcurrencySeries(points).values()];
-    expect(segments).toHaveLength(points.length);
-    expect(segments.flat()).toEqual(points);
-  });
-
-  it('keeps repeated load observations and unknown runs as markers, not an arbitrary average', () => {
-    const points = [load(4), load(4, { y: 650 }), load(8), load(16, { run_url: undefined })];
-    const segments = [...groupConcurrencySeries(points).values()];
-    expect(segments.every((segment) => segment.length === 1)).toBe(true);
-    expect(segments.flat()).toHaveLength(points.length);
-    expect(segments.flat().map((sample) => sample.y)).toEqual([500, 650, 500, 500]);
-  });
-});
diff --git a/packages/app/src/components/inference/utils/quickFilters.test.ts b/packages/app/src/components/inference/utils/quickFilters.test.ts
index 6c1c61ce0..15c4ae01a 100644
--- a/packages/app/src/components/inference/utils/quickFilters.test.ts
+++ b/packages/app/src/components/inference/utils/quickFilters.test.ts
@@ -1,7 +1,6 @@
 import { describe, it, expect } from 'vitest';
 
 import type { InferenceData } from '@/components/inference/types';
-import { pointTopologyKey, topologyLabel } from './topology-filter';
 
 import {
   EMPTY_QUICK_FILTERS,
@@ -118,127 +117,6 @@ describe('computeAvailableQuickFilters', () => {
   });
 });
 
-describe('exact topology filtering', () => {
-  it('retains shared TP4 loads across hardware but excludes TP8 and different EP', () => {
-    const b200 = point({
-      hwKey: 'b200_sglang',
-      physicalChips: 4,
-      decode_tp: 4,
-      decode_ep: 1,
-      conc: 4,
-    });
-    const mi355x = point({ ...b200, hwKey: 'mi355x_sglang', conc: 256 });
-    const tp8 = point({ ...b200, physicalChips: 8, decode_tp: 8 });
-    const ep4 = point({ ...b200, decode_ep: 4 });
-    const selected = filters({ topologies: [pointTopologyKey(b200)] });
-    expect(quickFiltersActive(selected)).toBe(true);
-    expect(applyQuickFilters([b200, mi355x, tp8, ep4], selected)).toEqual([b200, mi355x]);
-    expect(computeAvailableQuickFilters([b200, mi355x, tp8, ep4]).topologies).toHaveLength(3);
-  });
-
-  it('does not mix 4P+4D with 16P+16D or another pool allocation', () => {
-    const gb200 = point({
-      hwKey: 'gb200_dynamo-sglang',
-      physicalChips: 8,
-      disagg: true,
-      num_prefill_gpu: 4,
-      num_decode_gpu: 4,
-    });
-    const gb300 = point({ ...gb200, hwKey: 'gb300_dynamo-sglang', conc: 128 });
-    const larger = point({ ...gb200, physicalChips: 32, num_prefill_gpu: 16, num_decode_gpu: 16 });
-    const unbalanced = point({ ...gb200, num_prefill_gpu: 2, num_decode_gpu: 6 });
-    expect(
-      applyQuickFilters(
-        [gb200, gb300, larger, unbalanced],
-        filters({ topologies: [pointTopologyKey(gb200)] }),
-      ),
-    ).toEqual([gb200, gb300]);
-    expect(applyQuickFilters([gb200], filters({ topologies: ['missing-topology'] }))).toEqual([]);
-  });
-
-  it('does not treat absent physical or parallelism metadata as a measured size', () => {
-    const unknown = point({ tp: 4 });
-    const known = point({ tp: 4, decode_tp: 4, decode_ep: 1 });
-    expect(pointTopologyKey(unknown)).not.toBe(pointTopologyKey(known));
-  });
-
-  it('resolves aggregate context parallelism from either schema side without mixing widths', () => {
-    const prefillShaped = point({
-      physicalChips: 8,
-      decode_tp: 8,
-      prefill_dcp_size: 8,
-      decode_dcp_size: 1,
-      prefill_pcp_size: 4,
-      decode_pcp_size: 1,
-    });
-    const decodeShaped = point({
-      ...prefillShaped,
-      prefill_dcp_size: 1,
-      decode_dcp_size: 8,
-      prefill_pcp_size: 1,
-      decode_pcp_size: 4,
-    });
-    const unpartitioned = point({ ...prefillShaped, prefill_dcp_size: 1, prefill_pcp_size: 1 });
-    expect(
-      applyQuickFilters(
-        [prefillShaped, decodeShaped, unpartitioned],
-        filters({ topologies: [pointTopologyKey(prefillShaped)] }),
-      ),
-    ).toEqual([prefillShaped, decodeShaped]);
-    expect(pointTopologyKey(point({ ...prefillShaped, disagg: true }))).not.toBe(
-      pointTopologyKey(point({ ...decodeShaped, disagg: true })),
-    );
-  });
-
-  it.each(['en', 'zh'] as const)(
-    'keeps distinct default, unknown, DPA and offload configurations visibly distinct in %s',
-    (locale) => {
-      const base = point({
-        physicalChips: 8,
-        decode_tp: 8,
-        decode_ep: 1,
-        decode_pp: 1,
-        decode_dp_attention: false,
-        offload_mode: 'off',
-      });
-      const variants = [
-        base,
-        point({ ...base, decode_dp_attention: true }),
-        point({ ...base, decode_dp_attention: undefined }),
-        point({ ...base, decode_pp: undefined }),
-        point({ ...base, offload_mode: undefined }),
-        point({ ...base, offload_mode: 'on' }),
-      ];
-      const keys = variants.map(pointTopologyKey);
-      for (const siblings of [undefined, keys]) {
-        const labels = keys.map((key) => topologyLabel(key, locale, siblings));
-        expect(new Set(labels).size).toBe(variants.length);
-      }
-    },
-  );
-
-  it.each(['en', 'zh'] as const)(
-    'omits shared details but retains allocation, widths and every differing field in %s',
-    (locale) => {
-      const base = point({
-        physicalChips: 4,
-        decode_tp: 4,
-        decode_ep: 1,
-        decode_pp: 1,
-        decode_dp_attention: false,
-        offload_mode: 'off',
-      });
-      const keys = [base, point({ ...base, decode_dp_attention: true })].map(pointTopologyKey);
-      const label = topologyLabel(keys[0], locale, keys);
-      expect(label).toContain('GPU4 · TP4 · EP1');
-      expect(label).toContain('DPA0');
-      expect(label).not.toMatch(/PP1|DP\?|offload/u);
-      expect(topologyLabel(keys[1], locale, keys)).toContain('DPA1');
-      expect(topologyLabel(keys[0], locale)).toContain('PP1');
-    },
-  );
-});
-
 describe('quickFiltersActive', () => {
   it('is false only when every category is empty', () => {
     expect(quickFiltersActive(EMPTY_QUICK_FILTERS)).toBe(false);
diff --git a/packages/app/src/components/inference/utils/x-axis-scale.test.ts b/packages/app/src/components/inference/utils/x-axis-scale.test.ts
index 78897dd09..f94310d9f 100644
--- a/packages/app/src/components/inference/utils/x-axis-scale.test.ts
+++ b/packages/app/src/components/inference/utils/x-axis-scale.test.ts
@@ -3,17 +3,6 @@ import { describe, expect, it } from 'vitest';
 import { resolveScatterXAxisScale } from './x-axis-scale';
 
 describe('resolveScatterXAxisScale', () => {
-  it('keeps observed concurrency linear despite a saved latency log preference', () => {
-    expect(
-      resolveScatterXAxisScale({
-        extent: [1, 128],
-        selectedYAxisMetric: 'y_inputTputPerGpu',
-        xAxisField: 'conc',
-        scaleType: 'log',
-      }),
-    ).toBe('linear');
-  });
-
   it.each(['P90 Time To First Token (s)', 'P90 首 token 延迟 (s)'])(
     'selects log for wide-range TTFT independently of the %s display label',
     (displayLabel) => {
diff --git a/packages/app/src/lib/benchmark-transform.test.ts b/packages/app/src/lib/benchmark-transform.test.ts
index 1ac13bbaf..5054825f7 100644
--- a/packages/app/src/lib/benchmark-transform.test.ts
+++ b/packages/app/src/lib/benchmark-transform.test.ts
@@ -69,38 +69,6 @@ function makeRow(overrides: Partial<BenchmarkRow> = {}): BenchmarkRow {
 }
 
 describe('rowToAggDataEntry', () => {
-  it('preserves raw interactivity and derives reciprocal mean TPOT separately', () => {
-    const entry = rowToAggDataEntry(
-      makeRow({
-        metrics: {
-          mean_tpot: 0.04,
-          mean_intvty: 777,
-          median_intvty: 12.5,
-        },
-      }),
-    );
-    expect(entry.mean_tpot_intvty).toBe(25);
-    expect(entry.mean_intvty).toBe(777);
-    expect(entry.median_intvty).toBe(12.5);
-  });
-
-  it.each([undefined, 0, -1, NaN, Infinity])(
-    'does not invent speed for invalid mean TPOT %s',
-    (mean_tpot) => {
-      const entry = rowToAggDataEntry(
-        makeRow({
-          metrics: {
-            ...(mean_tpot === undefined ? {} : { mean_tpot }),
-            mean_intvty: 777,
-            median_intvty: 12.5,
-          },
-        }),
-      );
-      expect(entry).not.toHaveProperty('mean_tpot_intvty');
-      expect(entry.mean_intvty).toBe(777);
-    },
-  );
-
   it.each([1, undefined])(
     'keeps canonical identity but labels UMBP for official/overlay rows (DB id %s)',
     (id) => {
diff --git a/packages/app/src/lib/url-state.test.ts b/packages/app/src/lib/url-state.test.ts
index 202e63e27..39a1937e0 100644
--- a/packages/app/src/lib/url-state.test.ts
+++ b/packages/app/src/lib/url-state.test.ts
@@ -26,15 +26,6 @@ describe('PARAM_DEFAULTS', () => {
     vi.unstubAllGlobals();
   });
 
-  it('round-trips mean service statistics while omitting the median default', async () => {
-    setupWindow('?i_mstat=mean');
-    const { readUrlParams, buildShareUrl, writeUrlParams } = await import('@/lib/url-state');
-    expect(readUrlParams().i_mstat).toBe('mean');
-    expect(new URL(buildShareUrl()).searchParams.get('i_mstat')).toBe('mean');
-    writeUrlParams({ i_mstat: 'median' });
-    expect(new URL(buildShareUrl()).searchParams.has('i_mstat')).toBe(false);
-  });
-
   it('has expected default for g_model', async () => {
     const { PARAM_DEFAULTS } = await import('@/lib/url-state');
     expect(PARAM_DEFAULTS.g_model).toBe('DeepSeek-V4-Pro');
diff --git a/packages/app/src/lib/views-api/series.test.ts b/packages/app/src/lib/views-api/series.test.ts
index 4df0c2b2f..78a4c5c7a 100644
--- a/packages/app/src/lib/views-api/series.test.ts
+++ b/packages/app/src/lib/views-api/series.test.ts
@@ -116,29 +116,6 @@ function powerSweepRows(): BenchmarkRow[] {
 }
 
 describe('buildInferenceSeries', () => {
-  it.each([
-    ['interactivity', 'mean_tpot_intvty', 20],
-    ['ttft', 'mean_ttft', 0.6],
-    ['e2e', 'mean_e2el', 5],
-  ] as const)('uses recorded means without median fallback for %s', (xmode, field, expected) => {
-    const rows = [
-      makeRow({
-        conc: 1,
-        metrics: metrics({ mean_tpot: 0.05, mean_intvty: 77, mean_ttft: 0.6, mean_e2el: 5 }),
-      }),
-      makeRow({ conc: 2 }),
-    ];
-    const result = buildInferenceSeries(rows, {
-      ...BASE_OPTIONS,
-      xmode,
-      fixedSequenceStatistic: 'mean',
-    });
-    expect(result.xAxis).toMatchObject({ field, statistic: 'mean' });
-    expect(result.series.flatMap((entry) => entry.points).map((point) => point.x)).toEqual([
-      expected,
-    ]);
-  });
-
   it('assembles one series per hardware config with x-sorted points', () => {
     const result = buildInferenceSeries(fixtureRows(), BASE_OPTIONS);
 
@@ -311,59 +288,6 @@ describe('buildInferenceSeries', () => {
     expect(best.series[0].bestPerSku).toBe(true);
   });
 
-  it.each(['y_measuredAvgPower', 'y_measuredJPerOutputToken'] as const)(
-    'retains all observed loads for %s without optimal/best ranking',
-    (metricConfigKey) => {
-      const rows = powerSweepRows();
-      const result = buildInferenceSeries(rows, {
-        ...BASE_OPTIONS,
-        xmode: 'concurrency',
-        metricConfigKey,
-        optimal: true,
-        best: true,
-      });
-      expect(result.xAxis).toEqual({
-        mode: 'concurrency',
-        field: 'conc',
-        label: 'Concurrency',
-        statistic: null,
-      });
-      expect(result.count).toBe(rows.length);
-      const points = result.series.flatMap((series) => series.points);
-      expect(points.map((point) => point.x)).toEqual(
-        rows.map((row) => row.conc).toSorted((a, b) => a - b),
-      );
-      expect(points.every((point) => !point.frontier && !point.bestPerSku)).toBe(true);
-      expect(result.frontier).toEqual({ direction: null, points: 0 });
-      expect(result.metric.direction).toBeNull();
-    },
-  );
-
-  it('exports reusable topology keys and preserves every load within the chosen topology', () => {
-    const rows = [
-      makeRow({ conc: 1 }),
-      makeRow({ conc: 4 }),
-      makeRow({ conc: 4, prefill_tp: 4, decode_tp: 4, num_prefill_gpu: 4, num_decode_gpu: 4 }),
-    ];
-    const all = buildInferenceSeries(rows, { ...BASE_OPTIONS, xmode: 'concurrency' });
-    const points = all.series.flatMap((series) => series.points);
-    expect(new Set(points.map((point) => point.topologyKey)).size).toBe(2);
-    const topology = points.find((point) => point.concurrency === 1)!.topologyKey;
-    const filtered = buildInferenceSeries(rows, {
-      ...BASE_OPTIONS,
-      xmode: 'concurrency',
-      quickFilters: { ...BASE_OPTIONS.quickFilters, topologies: [topology] },
-    });
-    expect(filtered.series.flatMap((series) => series.points).map((point) => point.x)).toEqual([
-      1, 4,
-    ]);
-    expect(
-      filtered.series
-        .flatMap((series) => series.points)
-        .every((point) => point.topologyKey === topology),
-    ).toBe(true);
-  });
-
   it('switches x axis per xmode', () => {
     const rows = fixtureRows();
 
diff --git a/packages/app/timings.json b/packages/app/timings.json
index 5ad312efa..b8bfd9ba6 100644
--- a/packages/app/timings.json
+++ b/packages/app/timings.json
@@ -236,6 +236,10 @@
       "spec": "cypress/e2e/performance.cy.ts",
       "duration": 2377
     },
+    {
+      "spec": "cypress/e2e/powerx-timeline.cy.ts",
+      "duration": 4000
+    },
     {
       "spec": "cypress/e2e/profit-estimator.cy.ts",
       "duration": 39450

From 7759a8b3042fbeb6caf0509aecd0357b22818860 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 10:28:29 -0700
Subject: [PATCH 044/103] fix: space word values in topology labels
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

topologyLabel dropped the "=" from every part, so offload modes read
"offloadoff". Word values now keep a space ("offload off"); numeric and
unknown tokens stay compact (TP4, DP?).

中文：修复 topology 标签中的文字取值。topologyLabel 会删除每个字段的 "="，导致 offload 模式显示为 "offloadoff"。现在文字取值保留空格（"offload off"），数字和未知值仍保持紧凑格式（TP4、DP?）。
---
 .../inference/utils/topology-filter.test.ts    | 18 ++++++++++++++++++
 .../inference/utils/topology-filter.ts         |  3 ++-
 2 files changed, 20 insertions(+), 1 deletion(-)
 create mode 100644 packages/app/src/components/inference/utils/topology-filter.test.ts

diff --git a/packages/app/src/components/inference/utils/topology-filter.test.ts b/packages/app/src/components/inference/utils/topology-filter.test.ts
new file mode 100644
index 000000000..abd9eb195
--- /dev/null
+++ b/packages/app/src/components/inference/utils/topology-filter.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+
+import type { InferenceData } from '@/components/inference/types';
+
+import { pointTopologyKey, topologyLabel } from './topology-filter';
+
+describe('topologyLabel', () => {
+  it('spells out offload modes beside compact parallelism tokens', () => {
+    const base = { physicalChips: 8, decode_tp: 8, decode_ep: 1, offload_mode: 'off' };
+    const keys = [base, { ...base, offload_mode: 'on' }].map((point) =>
+      pointTopologyKey(point as InferenceData),
+    );
+    expect(keys.map((key) => topologyLabel(key, 'en', keys))).toEqual([
+      'Single-node · GPU8 · TP8 · EP1 · offload off',
+      'Single-node · GPU8 · TP8 · EP1 · offload on',
+    ]);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/topology-filter.ts b/packages/app/src/components/inference/utils/topology-filter.ts
index c5f731f4c..23a4c5e19 100644
--- a/packages/app/src/components/inference/utils/topology-filter.ts
+++ b/packages/app/src/components/inference/utils/topology-filter.ts
@@ -75,8 +75,9 @@ export function topologyLabel(
       !peers.every((sibling) => sibling.split('|').includes(part))
     );
   });
+  // Numbers and unknowns join their name (TP4, DP?); word values need a space (offload off).
   return [
     modes[mode as keyof typeof modes] ?? mode,
-    ...visible.map((part) => part.replace('=', '')),
+    ...visible.map((part) => part.replace(/=(?=\p{L})/u, ' ').replace('=', '')),
   ].join(' · ');
 }

From 995e008e2b336f5c08c66163225c2aa3b06e5f72 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 11:26:14 -0700
Subject: [PATCH 045/103] fix: version PowerX digests and recover stale
 statistics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Track the full-record algorithm independently of source revisions. Recompute stale reads from retained samples, upgrade unchanged ingests, and add transactional stats-only backfill with version-aware caches.

Validation: local PGlite and real Blob cache regressions; old upsert fails the new unchanged-input regression. Workspace unit suite, lint, format, typecheck and typography pass. Cypress smoke: 56 component and 128 integration tests pass. No production migration or data repair executed.

中文：为 PowerX 完整记录统计增加算法版本。旧摘要可从保留样本只读重算，原样重新入库也能升级；新增事务化 stats-only 定向修复，并同步更新缓存版本和读取一致性检查。已通过本地数据库、真实缓存、仓库检查及浏览器 smoke；未执行生产迁移或数据修复。
---
 docs/data-pipeline.md                         |  64 ++++++++++-
 .../api/v1/gpu-metrics-point/route.test.ts    |  70 +++++++++++-
 packages/app/src/lib/api-route-catalog.ts     |   4 +-
 .../app/src/lib/views-api/docs/extensions.ts  |   6 +-
 .../017_gpu_metric_stats_version.sql          |   3 +
 packages/db/src/backfill-gpu-metrics.ts       |  44 +++++++-
 .../db/src/etl/gpu-metrics-ingest.test.ts     | 103 +++++++++++++++++-
 packages/db/src/etl/gpu-metrics-ingest.ts     |  85 ++++++++++-----
 packages/db/src/lib/gpu-metric-stats.ts       |  61 +++++++++++
 packages/db/src/lib/gpu-metrics-backfill.ts   |  29 +++++
 .../db/src/queries/gpu-metrics-revision.ts    |   5 +-
 .../src/queries/gpu-metrics-timeline.test.ts  |   6 +-
 .../gpu-metrics.reingest-consistency.test.ts  |  22 +++-
 packages/db/src/queries/gpu-metrics.test.ts   |  38 +++++--
 packages/db/src/queries/gpu-metrics.ts        |  71 ++++++++----
 15 files changed, 531 insertions(+), 80 deletions(-)
 create mode 100644 packages/db/migrations/017_gpu_metric_stats_version.sql
 create mode 100644 packages/db/src/lib/gpu-metric-stats.ts

diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index f1090f22b..db4b2029e 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -563,12 +563,13 @@ digests them at ingest time, in the same step that links server logs:
   zone-less `YYYY/MM/DD HH:MM:SS.mmm` is interpreted with the context sidecar's
   `timestamp_timezone` (the producer writes UTC).
 - `gpu_metric_gpu_stats` — per (series, GPU, metric) count/min/max/mean/median/
-  p95/p99/stddev computed once at ingest so readers never rescan samples.
+  p95/p99/stddev computed at ingest; matching algorithm versions avoid rescanning samples.
 - `benchmark_result_gpu_metrics` — links each benchmark point to the series that
   was recorded while it ran (several series per point for multinode artifacts).
 
 Ingest is idempotent: the same CSV hash, sidecars, and unique sample count refresh
-only the point links. A change replaces the samples and digest inside one
+only the point links when `stats_version` matches `GPU_STATS_VERSION`. An outdated
+digest is rebuilt without replacing samples or links. A source change replaces the samples and digest inside one
 transaction, including corrected timezone or identity sidecars. Repeated samples
 keep the first row per (GPU, timestamp) before computing counts and statistics,
 matching the sample table's primary key. Explicitly re-ingesting a run also
@@ -582,7 +583,7 @@ start-up and warm-up so both phases can be inspected.
 
 The point and run readers assemble a series from separate autocommit statements
 (series rows, statistics, samples). After loading, they re-read the series
-version key (`csv_sha256`, `sample_count`, `ingested_at`) and retry the whole
+version key (`csv_sha256`, `sample_count`, `ingested_at`, `stats_version`) and retry the whole
 read when a re-ingest committed in between, so one payload never mixes the
 statistics of one version with the samples of another.
 
@@ -628,8 +629,11 @@ is 404 and database failures remain errors. Cache-write failures log a warning a
 serve the fresh uncached result; the next request retries cache population.
 
 The public `/api/v1/views/gpu-metrics` projection and full-record UI table use the
-same stored per-GPU statistics digest for the selected file/host series. Empty or
-missing metric digests remain empty; only live artifacts calculate from samples.
+same per-GPU statistics digest for the selected file/host series. Current-version
+empty or missing metric digests remain empty. Unversioned or outdated digests
+are recomputed read-only from retained DB samples with the shared ingest algorithm.
+Incomplete retained samples leave statistics empty while preserving raw data for
+the existing source-gap recovery path; stats-only writes fail until the source is repaired.
 Statistics include startup and warmup, retain measured zero, and exclude missing
 readings per metric after first-wins timestamp/GPU deduplication. Mean is
 sample-weighted, percentiles interpolate at `p * (N - 1)`, and standard deviation
@@ -644,9 +648,57 @@ Serving-window power, J/token and selected-time-window calculations remain separ
 的完整性；普通 CSV 与 bundle、ingest 使用相同的 context 时区。
 点详情每次读取先核对数据库版本，修正 sidecar 或共享关联后
 无需手动清缓存；响应均为 no-store。全记录统计使用已存摘要，包含启动与 warmup；
-缺失读数不补零，已有摘要为空时不重新计算。它与 serving-window 功率、J/token 和
+缺失读数不补零；当前版本的摘要为空时保留为空，旧版本或无版本摘要从 DB 样本只读重算。它与 serving-window 功率、J/token 和
 用户所选时间窗口的统计分别处理。
 
+### Full-record statistics upgrades (migration 017)
+
+`GPU_STATS_VERSION` identifies the full-record digest algorithm, independently
+of source hashes and serving-window power schema versions. Bump it whenever
+metric populations, mappings, units or statistical definitions change. Migration
+017 marks existing series as version 0 (unknown); it does not certify old digests.
+Readers also treat a not-yet-migrated column as version 0, allowing app deployment
+before the writer migration. Read fallback does not write to the database.
+
+Point-cache revisions include both the deployed algorithm version and the stored
+version, so an algorithm deployment and subsequent digest repair each bypass old
+payloads for every linked point. Browser responses remain no-store; an already
+open tab receives the new result on its existing refetch/focus path.
+
+After applying migration 017 to the explicitly selected DB, use the existing
+backfill entry point (commands below are operator instructions, not automatic writes):
+
+```bash
+bun run admin:db:backfill-gpu-metrics --stats-only --all --dry-run
+bun run admin:db:backfill-gpu-metrics --stats-only --run <run-id> --attempt <attempt> --artifact <artifact-name> --dry-run
+bun run admin:db:backfill-gpu-metrics --stats-only --run <run-id> --attempt <attempt> --artifact <artifact-name> --yes
+```
+
+This mode uses DB samples only: no GitHub, artifact-retention cutoff, GPU work,
+benchmark publication, or cache purge. Unspecified attempts include all stored
+attempts; `--limit` counts series. Each series is locked and its digest/version
+replaced in one transaction. Current versions are no-ops, failures retain the old
+complete digest and print a scoped retry command with a nonzero exit status.
+Missing samples require source re-ingest. Successful retries skip completed series.
+DB `real` columns round to float32; comparisons with original CSV computations
+should allow float32 tolerance (e.g. 1e-5 relative), not require bit equality.
+
+Before production repair, retain a DB snapshot of affected series metadata and
+digests. Rollback stops the repair worker and restores the prior app/ingest build;
+leave the additive column in place. A prior version-aware build recomputes from
+samples when versions differ. To restore pre-versioned software and old stored
+results, restore the saved digest plus version together while writers are stopped,
+then invalidate the legacy cache. Raw samples and links are never changed by
+stats-only repair. Parser/timezone/identity fixes still require source re-ingest.
+
+中文：统计版本独立于数据 revision 和 serving-window schema。迁移先把旧摘要标记为
+未知版本；读取时可从 DB 样本重算，但不写库。`--stats-only` 支持按 run、attempt、artifact
+定向持久修复，也可覆盖全部保留历史，不依赖 GitHub 产物。每个 series 在事务内更新摘要与
+版本，失败保留旧结果并输出重试命令；成功后再次执行为 no-op。部署算法或修复摘要都会
+改变点详情缓存键，页面下次 refetch 时生效。生产修复前保留快照，回滚保留新增列；旧软件
+需要旧摘要时，停写后成对恢复摘要与版本，并清除旧缓存。此过程不修改 samples、关联或
+serving-window 指标。
+
 ### PowerX publication receipts
 
 The normal CI importer writes `POWER_PUBLICATION_MANIFEST` when configured. Each
diff --git a/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts b/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
index ec75a4b89..0fdad8907 100644
--- a/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
+++ b/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
@@ -7,10 +7,22 @@ import { PGlite } from '@electric-sql/pglite';
 import { NextRequest } from 'next/server';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { ingestGpuMetricsArtifact } from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
+import type * as GpuMetricStatsModule from '@semianalysisai/inferencex-db/lib/gpu-metric-stats';
 import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
 import { getGpuMetricsPointRevision } from '@semianalysisai/inferencex-db/queries/gpu-metrics-revision';
 import { startPowerxBlobFixture } from '../../../../../scripts/powerx-blob-fixture';
 
+const algorithm = vi.hoisted(() => ({ version: 1 }));
+vi.mock('@semianalysisai/inferencex-db/lib/gpu-metric-stats', async (importOriginal) => {
+  const actual = await importOriginal<typeof GpuMetricStatsModule>();
+  return {
+    ...actual,
+    get GPU_STATS_VERSION() {
+      return algorithm.version;
+    },
+  };
+});
+
 const connection = vi.hoisted(() => ({ getDb: vi.fn() }));
 vi.mock('@semianalysisai/inferencex-db/connection', () => connection);
 // The query, cache abstraction, Blob SDK, HTTP transport and ETL are real.
@@ -39,7 +51,11 @@ function client(database: Pick<PGlite, 'query'>) {
 
 beforeAll(async () => {
   db = await PGlite.create();
-  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
     await db.exec(
       fs.readFileSync(new URL(`../../../../../../db/migrations/${name}`, import.meta.url), 'utf8'),
     );
@@ -79,6 +95,7 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
+  algorithm.version = 1;
   await db.exec(
     'TRUNCATE gpu_metric_series RESTART IDENTITY CASCADE; UPDATE benchmark_results SET power_audit = null;',
   );
@@ -194,3 +211,54 @@ describe('artifact → local DB → real Blob cache → point API recovery', ()
     expect(samples.rows).toEqual([{ n: 24 }]);
   });
 });
+
+const power = (body: { series: GpuMetricSeries[] }) =>
+  body.series[0]!.stats.find((s) => s.gpuIndex === 0 && s.metric === 'power_w')!;
+
+it('bypasses warmed shared-point caches on algorithm upgrade, then persists through unchanged re-ingest', async () => {
+  const input = { workflowRunId: 1, artifact: artifact(), benchmarkResultIds: [10, 11] };
+  const first = await ingestGpuMetricsArtifact(sql, input);
+  await sql`update gpu_metric_gpu_stats set mean_value = -1`;
+
+  for (const id of [10, 11]) {
+    const cached = await request(id);
+    expect(power(cached.body).mean).toBe(-1);
+  }
+  const oldRevision = await getGpuMetricsPointRevision(client(db), 10);
+  const originalSamples =
+    await sql`select * from gpu_metric_samples order by series_id, sampled_at, gpu_index`;
+  // Model a code deploy: no DB row, sample, sidecar or link has changed.
+  algorithm.version = 2;
+  expect(await getGpuMetricsPointRevision(client(db), 10)).not.toBe(oldRevision);
+  for (const id of [10, 11]) {
+    const refreshed = await request(id);
+    expect(power(refreshed.body).mean).toBeCloseTo(351.403333, 3);
+  }
+  expect(await sql`select stats_version from gpu_metric_series`).toEqual([{ stats_version: 1 }]);
+  expect(await sql`select distinct mean_value from gpu_metric_gpu_stats`).toEqual([
+    { mean_value: -1 },
+  ]);
+  const upgradedRevision = await getGpuMetricsPointRevision(client(db), 10);
+  const repaired = await ingestGpuMetricsArtifact(sql, input);
+  expect(repaired).toMatchObject({
+    seriesIds: first.seriesIds,
+    samplesInserted: 0,
+    seriesSkipped: 0,
+  });
+  expect(await getGpuMetricsPointRevision(client(db), 10)).not.toBe(upgradedRevision);
+  for (const id of [10, 11]) {
+    const refreshed = await request(id);
+    expect(power(refreshed.body).mean).toBeCloseTo(351.403333, 3);
+  }
+  expect(await sql`select stats_version from gpu_metric_series`).toEqual([{ stats_version: 2 }]);
+  expect(
+    await sql`select * from gpu_metric_samples order by series_id, sampled_at, gpu_index`,
+  ).toEqual(originalSamples);
+  const beforeHit = sampleReads;
+  await request(10);
+  expect(sampleReads).toBe(beforeHit);
+  expect(await ingestGpuMetricsArtifact(sql, input)).toMatchObject({
+    samplesInserted: 0,
+    seriesSkipped: 1,
+  });
+});
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index e4f0ca1b4..16228ff8d 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -512,8 +512,8 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'page-bff',
     exclusionReason: {
-      en: 'Point-detail BFF returning linked PowerX telemetry series, per-GPU digests and retained validation/audit metadata. Every read checks a live DB revision before using the Blob payload cache; responses use no-store, missing data returns 404, and database failures remain errors. Re-ingest and shared-link changes do not require manual cache purges. Coupled to the PowerX tab implementation.',
-      zh: '数据点详情页专用 BFF；返回关联的 PowerX 遥测序列、每 GPU 统计摘要及保留的验证与审计元数据。每次读取先核对数据库版本再使用 Blob 缓存；响应使用 no-store，数据缺失返回 404，数据库故障仍作为错误返回。重新入库及共享链接变化无需手动清理缓存。与 PowerX 标签页实现紧密耦合。',
+      en: 'Point-detail BFF returning linked PowerX telemetry series, per-GPU digests and retained validation/audit metadata. Every read checks a live DB revision before using the Blob payload cache; responses use no-store, missing data returns 404, and database failures remain errors. Re-ingest, shared-link and digest algorithm/stored-version changes do not require manual cache purges. Outdated digests are recomputed read-only from retained samples. Coupled to the PowerX tab implementation.',
+      zh: '数据点详情页专用 BFF；返回关联的 PowerX 遥测序列、每 GPU 统计摘要及保留的验证与审计元数据。每次读取先核对数据库版本再使用 Blob 缓存；响应使用 no-store，数据缺失返回 404，数据库故障仍作为错误返回。重新入库、共享链接及摘要算法或存储版本变化无需手动清理缓存；旧摘要从保留样本只读重算。与 PowerX 标签页实现紧密耦合。',
     },
     sourceSha256: 'c04a01fcd8e1cb4cb7101a46a0ba44b227f2696819c499bcc93be8ee7a8ce255',
   },
diff --git a/packages/app/src/lib/views-api/docs/extensions.ts b/packages/app/src/lib/views-api/docs/extensions.ts
index 40b9fd9df..8b3e679de 100644
--- a/packages/app/src/lib/views-api/docs/extensions.ts
+++ b/packages/app/src/lib/views-api/docs/extensions.ts
@@ -400,7 +400,7 @@ const NEW_VIEWS = {
       stats: {
         ...objects,
         description:
-          'Per-GPU statistics for the selected file/host series, including startup and warmup. Stored digests are authoritative, including an empty or missing metric digest; only live artifacts compute from samples. Count is the finite-reading count after first-wins timestamp/GPU deduplication. Mean is sample-weighted, P50/P95/P99 use linear interpolation at p*(N-1), and standard deviation divides by N. Values use the selected metric unit. GPU visibility and chart downsampling do not change this population. These are not serving-window power or J/token.',
+          'Per-GPU statistics for the selected file/host series, including startup and warmup. Current-version stored digests are authoritative, including an empty or missing metric digest. Outdated or unversioned digests are recomputed read-only from retained DB samples using the current full-record algorithm. Count is the finite-reading count after first-wins timestamp/GPU deduplication. Mean is sample-weighted, P50/P95/P99 use linear interpolation at p*(N-1), and standard deviation divides by N. Values use the selected metric unit. GPU visibility and chart downsampling do not change this population. These are not serving-window power or J/token.',
       },
       rendering: object,
     },
@@ -432,14 +432,14 @@ export const operations: ApiOperation[] = Object.entries(NEW_VIEWS).map(
           view === 'video'
             ? ' Only already published artifacts are read. Cell, phase, slot and GPU-basis choices select result evidence and normalized serving rates; x/y/cost/workload filters produce computed tradeoff points. Local bundles and arbitrary URLs are excluded. Responses are no-store.'
             : view === 'gpu-metrics'
-              ? ' Telemetry reads stored DB series first and falls back to GitHub artifacts when storage is absent. Responses use private, no-store; an upstream database failure remains HTTP 503 rather than an empty dataset. File/host series retain separate identities. Full-record statistics include startup and warmup and use the stored per-GPU digest when present; an empty or missing metric digest stays empty. Only live artifacts compute statistics from samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings.'
+              ? ' Telemetry reads stored DB series first and falls back to GitHub artifacts when storage is absent. Responses use private, no-store; an upstream database failure remains HTTP 503 rather than an empty dataset. File/host series retain separate identities. Full-record statistics include startup and warmup and use current-version stored per-GPU digests; a current empty or missing metric digest stays empty. Outdated or unversioned digests are recomputed read-only from retained DB samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings.'
               : ''
         }`,
         `只读${zh}，使用仪表板的数据读取和计算函数。未知或重复查询键返回 400；响应包含解析后的参数，保留缺失数据。仅影响样式的控件不作为 API 参数。${
           view === 'video'
             ? ' 仅读取已发布产物。cell、阶段、slot 和 GPU 口径选择对应结果证据，并计算 serving 归一化速率；x/y、成本及工作负载筛选生成权衡图数据点。不读取本地数据包或任意 URL。响应不缓存。'
             : view === 'gpu-metrics'
-              ? ' 遥测优先读取数据库中已存储的序列；缺少存储数据时回退到 GitHub 产物。响应使用 private, no-store；上游数据库故障保留 HTTP 503，不作为空数据返回。各文件、主机的序列身份独立保留。全记录统计包含服务启动与 warmup，已有数据使用数据库中的每 GPU 统计摘要；摘要为空或缺少所选指标时仍返回空统计数组。仅实时产物按样本计算统计。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。'
+              ? ' 遥测优先读取数据库中已存储的序列；缺少存储数据时回退到 GitHub 产物。响应使用 private, no-store；上游数据库故障保留 HTTP 503，不作为空数据返回。各文件、主机的序列身份独立保留。全记录统计包含服务启动与 warmup，已有数据使用当前算法版本的每 GPU 统计摘要；当前摘要为空或缺少所选指标时仍返回空统计数组。旧版本或无版本摘要从保留的 DB 样本只读重算。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。'
               : ''
         }`,
       ),
diff --git a/packages/db/migrations/017_gpu_metric_stats_version.sql b/packages/db/migrations/017_gpu_metric_stats_version.sql
new file mode 100644
index 000000000..68f7104b3
--- /dev/null
+++ b/packages/db/migrations/017_gpu_metric_stats_version.sql
@@ -0,0 +1,3 @@
+-- Zero means unversioned, not computed by the current algorithm.
+ALTER TABLE gpu_metric_series
+  ADD COLUMN IF NOT EXISTS stats_version integer NOT NULL DEFAULT 0;
diff --git a/packages/db/src/backfill-gpu-metrics.ts b/packages/db/src/backfill-gpu-metrics.ts
index cfd53819c..6aa9c5ce4 100644
--- a/packages/db/src/backfill-gpu-metrics.ts
+++ b/packages/db/src/backfill-gpu-metrics.ts
@@ -16,6 +16,12 @@
  *   bun run --cwd packages/db db:backfill-gpu-metrics --all --since 2026-08-01 --dry-run
  *   bun run --cwd packages/db db:backfill-gpu-metrics --all --force --limit 20 --yes
  *
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --stats-only --all --dry-run
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --stats-only --run 34557177019 --yes
+ *
+ * --stats-only upgrades outdated digests from DB samples without GitHub access.
+ * It includes all retained attempts and dates unless explicitly filtered.
+ *
  * Runs that already have at least one stored series are skipped unless
  * --force is passed. --parallel N (default 4) bounds concurrent artifact
  * downloads within one run.
@@ -28,7 +34,7 @@ import path from 'node:path';
 import { hasNoSslFlag } from './cli-utils.js';
 import { AsyncSemaphore } from './etl/async-semaphore.js';
 import { createAdminSql } from './etl/db-utils.js';
-import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest.js';
+import { ingestGpuMetricsArtifact, refreshGpuMetricStats } from './etl/gpu-metrics-ingest.js';
 import { readPowerAuditValidations } from './etl/gpu-metrics-artifacts.js';
 import { recoveredPowerAudit } from './etl/power-audit-validations.js';
 import {
@@ -59,6 +65,7 @@ import { findBenchmarkResultIds, readMappedBenchmarkRows } from './lib/benchmark
 import { downloadArtifact, fetchRunMeta } from './lib/github-artifacts.js';
 import {
   pairGpuMetricsArtifacts,
+  findOutdatedGpuMetricSeries,
   collectMissingTelemetryExpectations,
   type GpuMetricsArtifactPair,
 } from './lib/gpu-metrics-backfill.js';
@@ -88,6 +95,7 @@ interface BackfillFlags {
   artifact: string | null;
   receipt: string | null;
   refreshCacheOnly: boolean;
+  statsOnly: boolean;
 }
 
 function positiveIntFlag(flag: string): number | null {
@@ -125,6 +133,7 @@ function parseFlags(): BackfillFlags {
     artifact: stringFlag('--artifact'),
     receipt: stringFlag('--receipt'),
     refreshCacheOnly: process.argv.includes('--refresh-cache-only'),
+    statsOnly: process.argv.includes('--stats-only'),
   };
 }
 
@@ -309,6 +318,39 @@ async function main(): Promise<void> {
   if (flags.refreshCacheOnly && !fs.existsSync(flags.receipt!))
     throw new Error('--refresh-cache-only requires an existing receipt');
 
+  if (flags.statsOnly) {
+    if (flags.refreshCacheOnly || flags.receipt || force)
+      throw new Error(
+        '--stats-only cannot be combined with --refresh-cache-only, --receipt or --force',
+      );
+    const series = await findOutdatedGpuMetricSeries(sql, flags, limit);
+    console.log(`${series.length} outdated digest(s); --limit counts series in --stats-only mode`);
+    if (flags.dryRun) {
+      console.table(series);
+      return;
+    }
+    if (
+      series.length === 0 ||
+      !(await confirmProceed('Recompute only these stored telemetry digests?'))
+    )
+      return;
+    for (const row of series) {
+      try {
+        const updated = await refreshGpuMetricStats(sql, Number(row.id));
+        console.log(
+          `series ${row.id} run ${row.github_run_id} attempt ${row.run_attempt}: ${updated ? 'updated' : 'current'}`,
+        );
+      } catch (error) {
+        process.exitCode = 1;
+        console.error(
+          `series ${row.id} failed; retry --stats-only --run ${row.github_run_id} --attempt ${row.run_attempt} --artifact ${row.artifact_name} --yes`,
+          error,
+        );
+      }
+    }
+    return;
+  }
+
   console.log('=== backfill-gpu-metrics ===');
   const runs = await loadCandidateRuns(flags, limit, force);
   const staleRuns = runs.filter((run) => !isWithinGithubRetention(run.date)).length;
diff --git a/packages/db/src/etl/gpu-metrics-ingest.test.ts b/packages/db/src/etl/gpu-metrics-ingest.test.ts
index b3bf9a088..92d1506ba 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.test.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.test.ts
@@ -6,7 +6,14 @@ import { PGlite } from '@electric-sql/pglite';
 import type postgres from 'postgres';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 
-import { ingestGpuMetricsArtifact, prepareGpuMetricsArtifact } from './gpu-metrics-ingest';
+import {
+  ingestGpuMetricsArtifact,
+  prepareGpuMetricsArtifact,
+  refreshGpuMetricStats,
+} from './gpu-metrics-ingest';
+
+import { findOutdatedGpuMetricSeries } from '../lib/gpu-metrics-backfill';
+import { GPU_STATS_VERSION } from '../lib/gpu-metric-stats';
 
 type Sql = postgres.Sql;
 let db: PGlite;
@@ -39,7 +46,11 @@ async function storedSeries(seriesId: number) {
 
 beforeAll(async () => {
   db = await PGlite.create();
-  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
     await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
   }
   sql = Object.assign(queryClient(db), {
@@ -315,3 +326,91 @@ describe('ingestGpuMetricsArtifact', () => {
     expect(after.links.map((row) => Number(row.benchmark_result_id))).toEqual([10, 11]);
   });
 });
+
+describe('versioned full-record digests', () => {
+  it('upgrades unchanged input without rewriting samples or links, then becomes a no-op', async () => {
+    const input = {
+      workflowRunId: 1,
+      artifact: writeArtifact(NVIDIA_CSV),
+      benchmarkResultIds: [10, 11],
+    };
+    const first = await ingestGpuMetricsArtifact(sql, input);
+    const id = first.seriesIds[0]!;
+    const original = await storedSeries(id);
+    await sql`update gpu_metric_series set stats_version = 0 where id = ${id}`;
+    await sql`update gpu_metric_gpu_stats set mean_value = -1 where series_id = ${id}`;
+    const updated = await ingestGpuMetricsArtifact(sql, input);
+    expect(updated).toMatchObject({ samplesInserted: 0, seriesSkipped: 0 });
+    expect(await storedSeries(id)).toEqual(original);
+    expect(await ingestGpuMetricsArtifact(sql, input)).toMatchObject({
+      samplesInserted: 0,
+      seriesSkipped: 1,
+    });
+  });
+
+  it('backfills both retained hosts without artifacts; preserves null metrics, links and unrelated series', async () => {
+    const artifact = writePowerAuditArtifact();
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 11],
+    });
+    const unrelated = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NVIDIA_CSV),
+      benchmarkResultIds: [10],
+    });
+    const untouched = await storedSeries(unrelated.seriesIds[0]!);
+    const originals = await Promise.all(first.seriesIds.map(storedSeries));
+    await sql`update gpu_metric_series set stats_version = 0 where id = any(${sql.array(first.seriesIds)}::bigint[])`;
+    await sql`update gpu_metric_gpu_stats set mean_value = -1 where series_id = any(${sql.array(first.seriesIds)}::bigint[])`;
+    fs.rmSync(artifact.artifactDir, { recursive: true });
+    // No default retention cutoff: old runs remain repairable.
+    await sql`update workflow_runs set date = '2020-01-01' where id = 1`;
+    const targets = await findOutdatedGpuMetricSeries(
+      sql,
+      { run: null, attempt: null, artifact: null, fromRun: null, since: null },
+      null,
+    );
+    expect(targets.map((row) => Number(row.id))).toEqual(first.seriesIds);
+    expect(
+      await findOutdatedGpuMetricSeries(
+        sql,
+        { run: 34557177019, attempt: 2, artifact: null, fromRun: null, since: null },
+        null,
+      ),
+    ).toEqual([]);
+    for (const [index, id] of first.seriesIds.entries()) {
+      expect(await refreshGpuMetricStats(sql, id)).toBe(true);
+      expect(await storedSeries(id)).toEqual(originals[index]);
+      expect(await refreshGpuMetricStats(sql, id)).toBe(false);
+    }
+    expect(await storedSeries(unrelated.seriesIds[0]!)).toEqual(untouched);
+  });
+
+  it('rolls back a failed digest replacement and permits retry; refuses incomplete samples', async () => {
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NVIDIA_CSV),
+      benchmarkResultIds: [10],
+    });
+    const id = first.seriesIds[0]!;
+    await sql`update gpu_metric_series set stats_version = 0 where id = ${id}`;
+    await sql`update gpu_metric_gpu_stats set mean_value = -1 where series_id = ${id}`;
+    const before = await storedSeries(id);
+    await db.exec(
+      'ALTER TABLE gpu_metric_gpu_stats ADD CONSTRAINT reject_stats CHECK (mean_value < 0)',
+    );
+    await expect(refreshGpuMetricStats(sql, id)).rejects.toMatchObject({ code: '23514' });
+    expect(await storedSeries(id)).toEqual(before);
+    await db.exec('ALTER TABLE gpu_metric_gpu_stats DROP CONSTRAINT reject_stats');
+    expect(await refreshGpuMetricStats(sql, id)).toBe(true);
+    const recovered = await storedSeries(id);
+    expect(recovered.metadata[0]?.stats_version).toBe(GPU_STATS_VERSION);
+    await sql`update gpu_metric_series set stats_version = 0 where id = ${id}`;
+    await sql`delete from gpu_metric_samples where series_id = ${id} and gpu_index = 0`;
+    const incomplete = await storedSeries(id);
+    await expect(refreshGpuMetricStats(sql, id)).rejects.toThrow('missing samples');
+    expect(await storedSeries(id)).toEqual(incomplete);
+  });
+});
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
index 18f60b82d..a00fe9872 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -4,8 +4,8 @@
  *
  * Idempotency: a series is identified by (workflow run, artifact name, CSV
  * path). Re-ingesting an identical CSV, sidecars and sample count only refreshes
- * the point links; a change replaces the stored samples and digest inside one
- * transaction so readers never observe a half-written series.
+ * the point links when the statistics version is current; a source change
+ * replaces samples and digest atomically.
  */
 
 import { createHash } from 'node:crypto';
@@ -13,6 +13,15 @@ import fs from 'node:fs';
 
 import type postgres from 'postgres';
 
+import {
+  GPU_STATS_VERSION,
+  statMetricColumn,
+  computeStoredGpuMetricStats,
+  type StoredGpuMetricSample,
+} from '../lib/gpu-metric-stats.js';
+
+export { statMetricColumn } from '../lib/gpu-metric-stats.js';
+
 import type { Sql } from './db-utils.js';
 
 /** Either a pooled client or the transaction handle passed to `sql.begin` callbacks. */
@@ -175,28 +184,6 @@ export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): Prepare
   return series;
 }
 
-const STAT_METRIC_COLUMN: Record<GpuMetricStats['metric'], string> = {
-  powerW: 'power_w',
-  temperatureC: 'temperature_c',
-  smClockMhz: 'sm_clock_mhz',
-  memClockMhz: 'mem_clock_mhz',
-  gpuUtilPct: 'gpu_util_pct',
-  memUtilPct: 'mem_util_pct',
-  edgeTempC: 'edge_temp_c',
-  memTempC: 'mem_temp_c',
-  gfxVoltageMv: 'gfx_voltage_mv',
-  socVoltageMv: 'soc_voltage_mv',
-  memVoltageMv: 'mem_voltage_mv',
-  fclkMhz: 'fclk_mhz',
-  socclkMhz: 'socclk_mhz',
-  mmActivityPct: 'mm_activity_pct',
-};
-
-/** Stored metric names use the column spelling so SQL readers need no mapping. */
-export function statMetricColumn(metric: GpuMetricStats['metric']): string {
-  return STAT_METRIC_COLUMN[metric];
-}
-
 async function insertSampleBatch(
   tx: TxLike,
   seriesId: number,
@@ -277,16 +264,27 @@ export function upsertGpuMetricSeries(
     series: PreparedGpuMetricSeries;
     benchmarkResultIds: readonly number[];
   },
-): Promise<{ seriesId: number; samplesInserted: number; replaced: boolean }> {
+): Promise<{
+  seriesId: number;
+  samplesInserted: number;
+  replaced: boolean;
+  statsUpdated: boolean;
+}> {
   const { workflowRunId, artifactName, series, benchmarkResultIds } = input;
   const configKey = gpuMetricsArtifactSuffix(artifactName) ?? artifactName;
   const sidecarsJson = JSON.stringify(series.sidecars);
 
   return sql.begin(async (tx) => {
     const existing = await tx<
-      { id: number; csv_sha256: string; sample_count: number; sidecars_match: boolean }[]
+      {
+        id: number;
+        csv_sha256: string;
+        sample_count: number;
+        stats_version: number;
+        sidecars_match: boolean;
+      }[]
     >`
-      select id, csv_sha256, sample_count, sidecars = ${sidecarsJson}::jsonb as sidecars_match
+      select id, csv_sha256, sample_count, stats_version, sidecars = ${sidecarsJson}::jsonb as sidecars_match
       from gpu_metric_series
       where workflow_run_id = ${workflowRunId}
         and artifact_name = ${artifactName}
@@ -351,7 +349,12 @@ export function upsertGpuMetricSeries(
           series.samples.slice(offset, offset + SAMPLE_BATCH_SIZE),
         );
       }
+    }
+    const statsUpdated = needsSamples || existing[0]?.stats_version !== GPU_STATS_VERSION;
+    if (statsUpdated) {
+      if (!needsSamples) await tx`delete from gpu_metric_gpu_stats where series_id = ${seriesId}`;
       await insertStats(tx, seriesId, series.stats);
+      await tx`update gpu_metric_series set stats_version = ${GPU_STATS_VERSION} where id = ${seriesId}`;
     }
 
     if (benchmarkResultIds.length > 0) {
@@ -362,7 +365,30 @@ export function upsertGpuMetricSeries(
       `;
     }
 
-    return { seriesId, samplesInserted, replaced };
+    return { seriesId, samplesInserted, replaced, statsUpdated };
+  });
+}
+
+export function refreshGpuMetricStats(sql: Sql, seriesId: number): Promise<boolean> {
+  return sql.begin(async (tx) => {
+    const [series] = await tx<{ sample_count: number; stats_version: number }[]>`
+      select sample_count, stats_version from gpu_metric_series where id = ${seriesId} for update
+    `;
+    if (!series) throw new Error(`Unknown telemetry series ${seriesId}`);
+    if (series.stats_version === GPU_STATS_VERSION) return false;
+    const samples = await tx<StoredGpuMetricSample[]>`
+      select * from gpu_metric_samples where series_id = ${seriesId} order by sampled_at, gpu_index
+    `;
+    if (samples.length !== Number(series.sample_count)) {
+      throw new Error(
+        `Telemetry series ${seriesId} has missing samples; re-ingest its source artifact`,
+      );
+    }
+    const stats = computeStoredGpuMetricStats(samples);
+    await tx`delete from gpu_metric_gpu_stats where series_id = ${seriesId}`;
+    await insertStats(tx, seriesId, stats);
+    await tx`update gpu_metric_series set stats_version = ${GPU_STATS_VERSION} where id = ${seriesId}`;
+    return true;
   });
 }
 
@@ -391,7 +417,8 @@ export async function ingestGpuMetricsArtifact(
     });
     result.seriesIds.push(upserted.seriesId);
     result.samplesInserted += upserted.samplesInserted;
-    if (upserted.samplesInserted === 0 && !upserted.replaced) result.seriesSkipped++;
+    if (upserted.samplesInserted === 0 && !upserted.replaced && !upserted.statsUpdated)
+      result.seriesSkipped++;
   }
   // The caller has resolved this artifact's exact benchmark identities. Recover
   // only a unique AgentX point within that explicit set, after every host is
diff --git a/packages/db/src/lib/gpu-metric-stats.ts b/packages/db/src/lib/gpu-metric-stats.ts
new file mode 100644
index 000000000..2cc2b5ee5
--- /dev/null
+++ b/packages/db/src/lib/gpu-metric-stats.ts
@@ -0,0 +1,61 @@
+import {
+  computeGpuMetricStats,
+  type GpuMetricSample,
+  type GpuMetricStats,
+} from '../etl/gpu-metrics-csv.js';
+
+/** Bump whenever full-record digest definitions change. Independent of serving-window metrics. */
+export const GPU_STATS_VERSION = 1;
+
+export const STAT_METRIC_COLUMN = {
+  powerW: 'power_w',
+  temperatureC: 'temperature_c',
+  smClockMhz: 'sm_clock_mhz',
+  memClockMhz: 'mem_clock_mhz',
+  gpuUtilPct: 'gpu_util_pct',
+  memUtilPct: 'mem_util_pct',
+  edgeTempC: 'edge_temp_c',
+  memTempC: 'mem_temp_c',
+  gfxVoltageMv: 'gfx_voltage_mv',
+  socVoltageMv: 'soc_voltage_mv',
+  memVoltageMv: 'mem_voltage_mv',
+  fclkMhz: 'fclk_mhz',
+  socclkMhz: 'socclk_mhz',
+  mmActivityPct: 'mm_activity_pct',
+} as const satisfies Record<GpuMetricStats['metric'], string>;
+
+/** Stored metric names use the column spelling so SQL readers need no mapping. */
+export function statMetricColumn(metric: GpuMetricStats['metric']): string {
+  return STAT_METRIC_COLUMN[metric];
+}
+
+export type StoredGpuMetricSample = {
+  gpu_index: number;
+  sampled_at: string | Date;
+} & Record<(typeof STAT_METRIC_COLUMN)[keyof typeof STAT_METRIC_COLUMN], number | null>;
+
+/** Preserve nulls: chart adapters intentionally zero-fill power, digest inputs must not. */
+export function computeStoredGpuMetricStats(
+  rows: readonly StoredGpuMetricSample[],
+): GpuMetricStats[] {
+  return computeGpuMetricStats(
+    rows.map((row): GpuMetricSample => ({
+      timestampMs: new Date(row.sampled_at).getTime(),
+      gpuIndex: Number(row.gpu_index),
+      powerW: row.power_w,
+      temperatureC: row.temperature_c,
+      smClockMhz: row.sm_clock_mhz,
+      memClockMhz: row.mem_clock_mhz,
+      gpuUtilPct: row.gpu_util_pct,
+      memUtilPct: row.mem_util_pct,
+      edgeTempC: row.edge_temp_c,
+      memTempC: row.mem_temp_c,
+      gfxVoltageMv: row.gfx_voltage_mv,
+      socVoltageMv: row.soc_voltage_mv,
+      memVoltageMv: row.mem_voltage_mv,
+      fclkMhz: row.fclk_mhz,
+      socclkMhz: row.socclk_mhz,
+      mmActivityPct: row.mm_activity_pct,
+    })),
+  );
+}
diff --git a/packages/db/src/lib/gpu-metrics-backfill.ts b/packages/db/src/lib/gpu-metrics-backfill.ts
index 30f4799f8..d1600e2d3 100644
--- a/packages/db/src/lib/gpu-metrics-backfill.ts
+++ b/packages/db/src/lib/gpu-metrics-backfill.ts
@@ -1,3 +1,6 @@
+import type { Sql } from '../etl/db-utils.js';
+import { GPU_STATS_VERSION } from './gpu-metric-stats.js';
+
 /** Pairing rules for the historical gpu_metrics backfill. */
 
 import { gpuMetricsArtifactSuffix, isPowerAuditArtifact } from '../etl/gpu-metrics-artifacts.js';
@@ -103,3 +106,29 @@ export async function collectMissingTelemetryExpectations(
   }
   return { observations, errors };
 }
+
+/** Stored samples outlive artifacts, including superseded attempts. */
+export function findOutdatedGpuMetricSeries(
+  sql: Sql,
+  flags: {
+    run: number | null;
+    attempt: number | null;
+    artifact: string | null;
+    fromRun: number | null;
+    since: string | null;
+  },
+  limit: number | null,
+) {
+  return sql`
+    select s.id, wr.github_run_id, wr.run_attempt, s.artifact_name, s.file_name
+    from gpu_metric_series s join workflow_runs wr on wr.id = s.workflow_run_id
+    where s.stats_version <> ${GPU_STATS_VERSION}
+      and (${flags.run}::bigint is null or wr.github_run_id = ${flags.run})
+      and (${flags.attempt}::integer is null or wr.run_attempt = ${flags.attempt})
+      and (${flags.artifact}::text is null or s.artifact_name = ${flags.artifact})
+      and (${flags.fromRun}::bigint is null or wr.github_run_id >= ${flags.fromRun})
+      and (${flags.since}::date is null or wr.date >= ${flags.since}::date)
+    order by wr.github_run_id, wr.run_attempt, s.id
+    limit ${limit}::integer
+  `;
+}
diff --git a/packages/db/src/queries/gpu-metrics-revision.ts b/packages/db/src/queries/gpu-metrics-revision.ts
index d80711129..fb7364b38 100644
--- a/packages/db/src/queries/gpu-metrics-revision.ts
+++ b/packages/db/src/queries/gpu-metrics-revision.ts
@@ -1,3 +1,5 @@
+import { GPU_STATS_VERSION } from '../lib/gpu-metric-stats';
+
 import type { DbClient } from '../connection';
 
 /** Re-ingest and shared-link changes must bypass older point payloads. */
@@ -8,6 +10,7 @@ export async function getGpuMetricsPointRevision(
   const [row] = await sql`
     select md5(jsonb_agg(jsonb_build_array(
       s.id, s.ingested_at, s.csv_sha256, s.sample_count, s.sidecars,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0),
       (
         select jsonb_agg(jsonb_build_array(l.benchmark_result_id, b.power_audit)
           order by l.benchmark_result_id)
@@ -20,5 +23,5 @@ export async function getGpuMetricsPointRevision(
     join gpu_metric_series s on s.id = link.series_id
     where link.benchmark_result_id = ${benchmarkResultId}
   `;
-  return typeof row?.revision === 'string' ? row.revision : null;
+  return typeof row?.revision === 'string' ? `${GPU_STATS_VERSION}:${row.revision}` : null;
 }
diff --git a/packages/db/src/queries/gpu-metrics-timeline.test.ts b/packages/db/src/queries/gpu-metrics-timeline.test.ts
index 294fbc912..2283453ce 100644
--- a/packages/db/src/queries/gpu-metrics-timeline.test.ts
+++ b/packages/db/src/queries/gpu-metrics-timeline.test.ts
@@ -115,7 +115,11 @@ function agentxBundle() {
 beforeAll(async () => {
   root = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-timeline-'));
   db = await PGlite.create();
-  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
     await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
   }
   await db.exec('ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb');
diff --git a/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts b/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
index 3e8f3bd09..7cba11008 100644
--- a/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
+++ b/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
@@ -29,7 +29,7 @@ import type postgres from 'postgres';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 
 import type { DbClient } from '../connection';
-import { ingestGpuMetricsArtifact } from '../etl/gpu-metrics-ingest';
+import { ingestGpuMetricsArtifact, refreshGpuMetricStats } from '../etl/gpu-metrics-ingest';
 import { getGpuMetricsForPoint, type GpuMetricSeries } from './gpu-metrics';
 
 type Sql = postgres.Sql;
@@ -54,7 +54,11 @@ function queryClient(database: Pick<PGlite, 'query'>) {
 
 beforeAll(async () => {
   db = await PGlite.create();
-  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
     await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
   }
   // The point reader aggregates benchmark_results.power_audit (migration 015).
@@ -216,3 +220,17 @@ describe('getGpuMetricsForPoint under telemetry re-ingest', () => {
     }
   });
 });
+
+it('retries when only the digest version changes between statements', async () => {
+  const first = await ingest(NVIDIA_CSV_V1);
+  await sql`update gpu_metric_series set stats_version = 0`;
+  await sql`update gpu_metric_gpu_stats set mean_value = -1`;
+  const interleaved = interleaveAfterStats(reader, async (index) => {
+    if (index === 1) await refreshGpuMetricStats(sql, first.seriesIds[0]!);
+  });
+  const payload = await getGpuMetricsForPoint(interleaved.client, 10);
+  expect(interleaved.seriesReads()).toBe(2);
+  expect(
+    payload?.series[0]?.stats.find((s) => s.gpuIndex === 0 && s.metric === 'power_w')?.mean,
+  ).toBeCloseTo(549.95, 3);
+});
diff --git a/packages/db/src/queries/gpu-metrics.test.ts b/packages/db/src/queries/gpu-metrics.test.ts
index 6962145b6..ed2df8669 100644
--- a/packages/db/src/queries/gpu-metrics.test.ts
+++ b/packages/db/src/queries/gpu-metrics.test.ts
@@ -138,22 +138,23 @@ describe('getGpuMetricsForRun', () => {
       sidecars: { context: { timestamp_timezone: 'UTC' } },
       benchmarkResultIds: [10, 11],
     });
-    expect(node0?.stats).toEqual([
+    // Pre-migration (unversioned) digests are recomputed read-only; null is not zero.
+    expect(node0?.stats.filter((stat) => stat.metric === 'power_w')).toEqual([
       {
         gpuIndex: 0,
-        metric: 'powerW',
-        count: 2,
+        metric: 'power_w',
+        count: 1,
         min: 187.5,
-        max: 912.25,
-        mean: 549.875,
-        median: 549.875,
-        p95: 912.25,
-        p99: 912.25,
-        stddev: 362.375,
+        max: 187.5,
+        mean: 187.5,
+        median: 187.5,
+        p95: 187.5,
+        p99: 187.5,
+        stddev: 0,
       },
       {
         gpuIndex: 1,
-        metric: 'powerW',
+        metric: 'power_w',
         count: 1,
         min: 190.5,
         max: 190.5,
@@ -164,6 +165,13 @@ describe('getGpuMetricsForRun', () => {
         stddev: 0,
       },
     ]);
+    expect(node0?.stats).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ gpuIndex: 0, metric: 'edge_temp_c', mean: 35.5, count: 1 }),
+        expect.objectContaining({ gpuIndex: 0, metric: 'gpu_util_pct', mean: 0, count: 1 }),
+        expect.objectContaining({ gpuIndex: 0, metric: 'mem_voltage_mv', mean: 1350, count: 1 }),
+      ]),
+    );
     expect(node0?.data.map((sample) => [sample.timestamp, sample.index, sample.power])).toEqual([
       ['2026-09-11T04:19:41.000Z', 0, 187.5],
       ['2026-09-11T04:19:41.000Z', 1, 190.5],
@@ -228,3 +236,13 @@ describe('getGpuMetricsForRun', () => {
     expect(dropped?.edgeTemp).toBeUndefined();
   });
 });
+
+it('keeps healthy hosts readable when an unversioned sibling has incomplete samples', async () => {
+  await sql`update gpu_metric_series set sample_count = 4 where id = 100`;
+  const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
+  expect(payload?.series[0]?.stats).toEqual([]);
+  expect(payload?.series[0]?.data).toHaveLength(3);
+  expect(payload?.series[1]?.stats).toEqual(
+    expect.arrayContaining([expect.objectContaining({ metric: 'power_w', mean: 500.5, count: 1 })]),
+  );
+});
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
index 2597b2f6c..aba55e497 100644
--- a/packages/db/src/queries/gpu-metrics.ts
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -7,6 +7,13 @@
  * ISO timestamps so the existing D3 charts consume them unchanged.
  */
 
+import {
+  GPU_STATS_VERSION,
+  computeStoredGpuMetricStats,
+  statMetricColumn,
+  type StoredGpuMetricSample,
+} from '../lib/gpu-metric-stats.js';
+
 import type { DbClient } from '../connection.js';
 
 export interface GpuMetricSampleRow {
@@ -99,6 +106,7 @@ interface RawSeriesRow {
   power_audits: Record<string, unknown>[] | null;
   csv_sha256: string;
   ingested_at: string | Date;
+  stats_version: number;
 }
 
 /** The columns `upsertGpuMetricSeries` rewrites whenever it replaces a series. */
@@ -107,6 +115,7 @@ interface RawSeriesVersionRow {
   csv_sha256: string;
   sample_count: number;
   ingested_at: string | Date;
+  stats_version: number;
 }
 
 interface RawStatRow {
@@ -123,24 +132,8 @@ interface RawStatRow {
   stddev_value: number;
 }
 
-interface RawSampleRow {
+interface RawSampleRow extends StoredGpuMetricSample {
   series_id: number | string;
-  gpu_index: number;
-  sampled_at: string | Date;
-  power_w: number | null;
-  temperature_c: number | null;
-  sm_clock_mhz: number | null;
-  mem_clock_mhz: number | null;
-  gpu_util_pct: number | null;
-  mem_util_pct: number | null;
-  edge_temp_c: number | null;
-  mem_temp_c: number | null;
-  gfx_voltage_mv: number | null;
-  soc_voltage_mv: number | null;
-  mem_voltage_mv: number | null;
-  fclk_mhz: number | null;
-  socclk_mhz: number | null;
-  mm_activity_pct: number | null;
 }
 
 const isoString = (value: string | Date): string =>
@@ -162,7 +155,7 @@ export class TelemetrySnapshotChangedError extends Error {
 const MAX_SNAPSHOT_ATTEMPTS = 3;
 
 const seriesVersionKey = (row: RawSeriesVersionRow): string =>
-  `${Number(row.id)}:${row.csv_sha256}:${Number(row.sample_count)}:${isoString(row.ingested_at)}`;
+  `${Number(row.id)}:${row.csv_sha256}:${Number(row.sample_count)}:${isoString(row.ingested_at)}:${row.stats_version}`;
 
 async function withConsistentSnapshot<T>(read: () => Promise<T>): Promise<T> {
   for (let attempt = 1; ; attempt += 1) {
@@ -239,11 +232,12 @@ async function loadSeriesDetails(
   // The three statements above run as separate autocommit queries (the DbClient
   // has no transaction), so a re-ingest can commit between them. The writer
   // replaces samples, stats and the series row in one transaction and stamps
-  // `ingested_at`, so a version key that is unchanged after the samples were
-  // read proves stats and samples belong to the same series version.
+  // `ingested_at`; digest-only upgrades change `stats_version`. An unchanged
+  // key after the sample read proves both belong to the same series version.
   const versionRows = (await sql`
-    select id, csv_sha256, sample_count, ingested_at
-    from gpu_metric_series
+    select id, csv_sha256, sample_count, ingested_at,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0) as stats_version
+    from gpu_metric_series s
     where id = any(${ids}::bigint[])
   `) as unknown as RawSeriesVersionRow[];
   const versionKeys = new Set(versionRows.map(seriesVersionKey));
@@ -261,6 +255,37 @@ async function loadSeriesDetails(
     if (bucket) bucket.push(toStatRow(raw));
     else statsBySeries.set(key, [toStatRow(raw)]);
   }
+  const staleIds = new Set(
+    seriesRows
+      .filter((row) => row.stats_version !== GPU_STATS_VERSION)
+      .map((row) => Number(row.id)),
+  );
+  const staleSamples = new Map<number, RawSampleRow[]>();
+  for (const sample of sampleRows) {
+    const id = Number(sample.series_id);
+    if (!staleIds.has(id)) continue;
+    const rows = staleSamples.get(id) ?? [];
+    rows.push(sample);
+    staleSamples.set(id, rows);
+  }
+  for (const row of seriesRows) {
+    const id = Number(row.id);
+    if (!staleIds.has(id)) continue;
+    const samples = staleSamples.get(id) ?? [];
+    if (samples.length !== Number(row.sample_count)) {
+      // Keep samples available to the existing source-gap recovery path, but
+      // never present a partial-population digest as full-record statistics.
+      statsBySeries.set(id, []);
+      continue;
+    }
+    statsBySeries.set(
+      id,
+      computeStoredGpuMetricStats(samples).map((stat) => ({
+        ...stat,
+        metric: statMetricColumn(stat.metric),
+      })),
+    );
+  }
   const samplesBySeries = new Map<number, GpuMetricSampleRow[]>();
   for (const raw of sampleRows) {
     const key = Number(raw.series_id);
@@ -337,6 +362,7 @@ async function readGpuMetricsForRun(
     select s.id, s.workflow_run_id, s.artifact_name, s.config_key, s.file_name, s.vendor,
       s.sample_interval_s, s.sample_count, s.gpu_count, s.started_at, s.ended_at, s.sidecars,
       s.csv_sha256, s.ingested_at,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0) as stats_version,
       (
         select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
         from benchmark_result_gpu_metrics l where l.series_id = s.id
@@ -392,6 +418,7 @@ async function readGpuMetricsForPoint(
     select s.id, s.workflow_run_id, s.artifact_name, s.config_key, s.file_name, s.vendor,
       s.sample_interval_s, s.sample_count, s.gpu_count, s.started_at, s.ended_at, s.sidecars,
       s.csv_sha256, s.ingested_at,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0) as stats_version,
       (
         select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
         from benchmark_result_gpu_metrics l where l.series_id = s.id

From 864a0c79904cfb63696d19a77c81b7f44587f182 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 12:20:11 -0700
Subject: [PATCH 046/103] feat: simplify PowerX measured views
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove the availability panel, point-count summary, historical rings and
their legend key, the power-curve caption, selector hints, and per-panel
method notes, so measured metrics read like every other dashboard metric.
Panel subtitles stay in exported images only. Comparison sources get short
"hardware · date" labels that add details only where two sources would
otherwise look the same.

中文：精简 PowerX 实测指标视图。移除可用性面板、数据点统计、历史数据圆环及其图例、
功率曲线图注、选择器提示和各面板的方法说明，使实测指标与仪表板其他指标的交互保持一致。
面板副标题仅保留在导出图片中；对比数据源改用“硬件 · 日期”短标签，只有在两个数据源
无法区分时才补充细节。
---
 docs/d3-charts.md                             |   2 +-
 docs/dashboard-readonly-views.md              |   5 +
 docs/data-pipeline.md                         |   5 -
 docs/powerx-permanent-view.md                 |  40 +-
 .../component/frontier-points-panel.cy.tsx    |   2 -
 .../app/cypress/component/gpu-graph.cy.tsx    |  70 +---
 .../power-metric-availability.cy.tsx          |  88 -----
 .../component/power-service-comparison.cy.tsx |   7 +-
 .../cypress/component/scatter-graph.cy.tsx    |  13 -
 .../cypress/e2e/certified-power-filter.cy.ts  |  28 +-
 .../app/cypress/e2e/inference-chart.cy.ts     |  14 +-
 packages/app/cypress/e2e/powerx-compare.cy.ts |   8 +-
 .../inference/axis-metric-explanations.ts     |   8 +-
 .../components/inference/metric-registry.ts   |   5 +-
 .../components/inference/ui/ChartControls.tsx |  27 +-
 .../components/inference/ui/ChartDisplay.tsx  |  10 +-
 .../inference/ui/FrontierPointsPanel.tsx      |  58 +--
 .../src/components/inference/ui/GPUGraph.tsx  |  61 +--
 .../inference/ui/LegacyPowerLegendKey.tsx     |  51 ---
 .../inference/ui/MatchedConcurrencyTable.tsx  |  10 -
 .../inference/ui/MeasuredMetricControls.tsx   |  31 --
 .../inference/ui/MeasuredPowerSummary.tsx     | 117 ------
 .../components/inference/ui/PowerFitPanel.tsx |  12 +-
 .../inference/ui/PowerMetricAvailability.tsx  | 368 ------------------
 .../inference/ui/PowerRoleGroup.tsx           |   7 +-
 .../inference/ui/PowerServiceComparison.tsx   |  23 +-
 .../components/inference/ui/PowerTimeline.tsx |  75 ----
 .../inference/ui/PowerTimelineSummary.tsx     |   8 -
 .../ui/ScatterGraph.decoration.test.tsx       |  35 --
 .../ui/ScatterGraph.overlay.test.tsx          |  42 --
 .../components/inference/ui/ScatterGraph.tsx  |  87 +----
 .../utils/equal-service-comparison.test.ts    |  21 +-
 .../utils/equal-service-comparison.ts         |  87 +++--
 .../inference/utils/frontier-points.ts        |  41 +-
 .../inference/utils/legacy-power-marker.ts    |  34 --
 .../utils/power-metric-availability.test.ts   |  61 ---
 .../utils/power-metric-availability.ts        |  68 ----
 packages/app/src/lib/api-route-catalog.ts     |   2 +-
 38 files changed, 152 insertions(+), 1479 deletions(-)
 delete mode 100644 packages/app/cypress/component/power-metric-availability.cy.tsx
 delete mode 100644 packages/app/src/components/inference/ui/LegacyPowerLegendKey.tsx
 delete mode 100644 packages/app/src/components/inference/ui/MeasuredPowerSummary.tsx
 delete mode 100644 packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
 delete mode 100644 packages/app/src/components/inference/utils/legacy-power-marker.ts
 delete mode 100644 packages/app/src/components/inference/utils/power-metric-availability.test.ts
 delete mode 100644 packages/app/src/components/inference/utils/power-metric-availability.ts

diff --git a/docs/d3-charts.md b/docs/d3-charts.md
index 33d0ba017..f38539689 100644
--- a/docs/d3-charts.md
+++ b/docs/d3-charts.md
@@ -118,7 +118,7 @@ The six measured-power metrics (average, prefill, decode, P75, P90 and percentag
 
 Modeled chassis power retains its existing behavior: **Optimal Only** on shows the minimum-power Pareto frontier, which can legitimately contain one point. Turning it off draws the upper power boundary. In that mode, the separate **Show all measurements** switch (`i_allpoints=1`) reveals off-boundary points without changing the curve.
 
-Dividing watts by one hardware's positive, constant TDP preserves its boundary membership. A lower percentage across different chips is not, by itself, an energy-efficiency comparison. Historical rings remain attached to visible historical points.
+Dividing watts by one hardware's positive, constant TDP preserves its boundary membership. A lower percentage across different chips is not, by itself, an energy-efficiency comparison.
 
 Upper boundaries use monotone interpolation between unique-X vertices, including after zoom. Curves are grouped by hardware, precision and date, and additionally by run for unofficial overlays; unrelated dates and runs never share a curve.
 
diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index fac4e62e2..63d3100bf 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -107,6 +107,8 @@ effective percentile or null.
 `serviceTarget` is present) `equalServiceComparison`. Select exact opaque
 `serviceBaseline` and `serviceComparator` keys returned by `serviceSources`,
 encoded with `URLSearchParams`; omitted selections use its first two entries.
+Each source's `label` is display text only: hardware and date, plus precision, topology,
+run or other details only where two sources would otherwise look the same.
 Stale explicit selections remain unavailable. Missing target returns null, not an
 invented operating point. Streaming-speed targets are tok/s/user; TTFT/E2E targets
 are seconds. Concurrency remains a separate observed-load diagnostic, not an
@@ -206,6 +208,9 @@ GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全
 使用硬件注册表。原始遥测、全记录统计和 API 响应均不因这些显示设置而改变。
 响应使用 private, no-store，上游 503 保留为错误响应。
 
+`serviceSources` 中各数据源的 `label` 仅供显示，由硬件和日期组成；只有两个数据源无法区分时，
+才补充精度、拓扑、运行等信息。选择数据源时应使用其 `key`。
+
 `serviceCompare=true` 还返回 `matchedConcurrency`：按并发数逐行配对两个所选数据源，任一方在
 该并发数下有观测即列出一行；每侧为 `observed`、`missing`，或同一负载下观测值不一致时的
 `ambiguous`（全部列出、不选其一）；仅当两侧都有观测时才计算变化百分比。同一并发下两者
diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index aa753431a..7f8ad77a4 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -631,8 +631,3 @@ empty receipt says `no_8k1k_points`, never that power coverage was validated.
 The workflow retains both the input manifest and verification receipt. Cache
 invalidation errors fail the workflow instead of being swallowed. Imported P75/P90
 ledger edits trigger the existing reviewed override workflow.
-
-The dashboard availability panel uses scoped points before Y-metric filtering,
-including visible unofficial overlays. It distinguishes schema-2 validation,
-other validated data, missing verdicts, withheld measurements, unavailable metrics,
-and non-applicable separate-pool metrics without filling missing values.
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 7aec57ed1..147e22875 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -76,26 +76,13 @@ existing `inference_y_axis_metric_selected` fired by `ChartControls`.
 
 A point without a value for the selected boundary is omitted from that series only (the
 builders never emit `{ y: 0 }`, and both the official and overlay paths filter by
-`metricKey in point`). The PowerX availability panel explains the gap per point:
-
-| State              | Meaning                                                                                                                                                  |
-| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `noSpec`           | hardware has no `tdp` / `power` in `HW_REGISTRY`                                                                                                         |
-| `noThroughput`     | provisioned watts exist but the row has no output throughput                                                                                             |
-| `noNormalization`  | disaggregated row with throughput but no whole-deployment GPU count (`powerBasisNormalization`: not `single_turn`, or non-integer prefill/decode counts) |
-| `noTelemetry`      | modeled boundary needs validated GPU telemetry (B4 follows B1)                                                                                           |
-| `invalid`          | `power_valid === 0`                                                                                                                                      |
-| `modelWorkload`    | chassis model covers 8K / 1K only                                                                                                                        |
-| `modelHardware`    | hardware outside the chassis profiles (GB200 / GB300 NVL72)                                                                                              |
-| `modelUnsupported` | other `modelSystemPower` reasons (gpu-count, topology, role-power …)                                                                                     |
+`metricKey in point`).
 
 The chart caption (`data-testid="power-basis-assumptions"`) names the boundary, the formula in
 words, the PUE constant and the chassis-model revision so a screenshot records its method.
 The pinned tooltip's "Modeled system power" block (`tooltipUtils.ts` `modeledSystemPowerHTML`)
 renders only for `measured*` keys and `y_modeledChassisPowerPerGpu`, so on the boundary keys the
 caption is the only per-chart provenance; the caption does not promise more.
-The empty state for the utility-modeled boundary says why nothing rendered and points at the
-Boundary select.
 
 ## Article figure → share link
 
@@ -143,9 +130,9 @@ role's availability rules carry through unchanged.
 Siblings exist only where the metric names the whole-deployment **average W/chip** or **J per
 output token** (the only quantities every boundary and role publishes on one axis); role
 energy additionally excludes the prefill J per input token scope. Elsewhere
-`powerCompareVariants` returns nothing, the Compare select disables the option, and — when a
-link arrives with an inapplicable mode — a hint (`measured-compare-hint`) says the comparison is
-paused. The parameter is kept, so switching back to an applicable setting resumes it.
+`powerCompareVariants` returns nothing and the Compare select disables the option. A link that
+arrives with an inapplicable mode keeps the parameter, so switching back to an applicable
+setting resumes it.
 
 Rendering (`ScatterGraph`): the series key is `scatterSeriesKey(point)` =
 `<hwKey>_<precision>[-v-<variant>]` (`utils/point-identity.ts`), so rooflines, frontiers,
@@ -165,8 +152,7 @@ line-swatch row per series present (base first); rows toggle chart-local visibil
 Tooltips add a "Series" line; on the energy axis a role clone also reports its share of the
 reconstructed request energy. Table adds a "Series" column and CSV a trailing "Power Series"
 column only while clones are present. Comparison clones are excluded from `bestSeriesPerSku`,
-the power-tier counts, the legend points table, the availability panel (which reads
-`selectionPoints`) and the date-comparison `GPUGraph`. Unofficial-run pills read `✕ <hardware>` (`getOverlayLineLabel`); the branch stays in the
+the legend points table and the date-comparison `GPUGraph`. Unofficial-run pills read `✕ <hardware>` (`getOverlayLineLabel`); the branch stays in the
 legend and a short run tag (` · main`, ` · …<date>-<sha>`) is appended only when several overlay
 runs draw the same hardware.
 
@@ -185,8 +171,8 @@ track `inference_power_compare_series_toggled { series, visible }`.
 
 `y_measuredPowerTimeline` is the third value of the Measured Power **Display** control
 (`watts` / `tdp` / `timeline`, `MeasuredPowerDisplay` in `measured-metric-config.ts`). Its
-registry field aliases `measuredAvgPower`, so the point set, the availability panel, the Table
-view and the share link are those of the measured average; only the chart body changes:
+registry field aliases `measuredAvgPower`, so the point set, the Table view and the share link
+are those of the measured average; only the chart body changes:
 `ChartDisplay` renders `ui/PowerTimeline.tsx` instead of `ScatterGraph` when the resolved
 config is `display: 'timeline'`.
 
@@ -204,8 +190,8 @@ config is `display: 'timeline'`.
     matches before falling back to the artifact name.
 
   Nothing is matched by hardware or concurrency. Rows whose telemetry is missing (expired
-  artifact, bundle over the download cap, another collector) are listed under the chart
-  (`data-testid="power-timeline-missing"`), never estimated. Trace keys are
+  artifact, bundle over the download cap, another collector) are not drawn, never
+  estimated. Trace keys are
   `<runId>:<name>` (`traceKeyForPoint`), unique per point in both collectors.
 
 - **Fetch.** One request per workflow run in the visible points
@@ -305,7 +291,7 @@ source per exact run and recipe (`equalServiceSourceKey`), and colour overlay so
 | 6 / 7 / 9    | Same-concurrency table: baseline and comparator J/output token, W/GPU and streaming speed, with % change                                      | _Compare at the same speed / latency_ (`i_servicecompare=1`, sources `i_servicebase` / `i_servicepeer`) | `utils/matched-concurrency.ts`                         |
 | 12 / 13 / 14 | Role group: W/GPU by role, role-local J/input and J/output (not added), J/output token by role with the total, prefill share                  | _Prefill / decode roles_ (`i_roleshare=1`)                                                              | `getRolePoints` in `utils/equal-service-comparison.ts` |
 | 15           | Least-squares fit of mean W/GPU against output tok/s per allocated GPU: points, line, dashed extension to zero, P₀, P₀ ÷ TDP, m, R², n, range | _Power vs output-rate fit_ (`i_powerfit=1`)                                                             | `utils/power-fit.ts`                                   |
-| 16           | Frontier points: the drawn cross-platform frontier, its competing scope, points per hardware, and each point's run and attempt                | Legend _Pareto frontier_ (`i_frontier`) on a measured metric                                            | `utils/frontier-points.ts`                             |
+| 16           | Frontier points: the drawn cross-platform frontier and each point's run and attempt                                                           | Legend _Pareto frontier_ (`i_frontier`) on a measured metric                                            | `utils/frontier-points.ts`                             |
 
 - **Same concurrency** pairs only observations; nothing is interpolated. A side missing at a
   load reads _Not measured_. Disagreeing duplicates of one source read as ambiguous, with none
@@ -317,8 +303,10 @@ source per exact run and recipe (`equalServiceSourceKey`), and colour overlay so
   all allocated GPUs, on the same basis as the mean W/GPU. P₀ is an extrapolated intercept,
   not measured idle power, and R² describes only that line.
 - **Frontier** lists `globalParetoFrontier`'s own output, so the table is exactly what is
-  drawn. Ties keep the first point, official before overlay. It notes when the competing
-  points span several topologies or images.
+  drawn. Ties keep the first point, official before overlay.
+- **Source labels** (`getEqualServiceSources`) read hardware and date, adding precision,
+  topology, run, attempt, recipe, image or point only where two sources would otherwise look
+  the same. The opaque key stays the exact identity.
 - Plots export PNG and CSV; the frontier table exports CSV only. The views API returns
   `matchedConcurrency`, `rolePoints` and `powerFits`
   ([Dashboard read-only views](./dashboard-readonly-views.md#fixed-sequence-service-comparisons));
diff --git a/packages/app/cypress/component/frontier-points-panel.cy.tsx b/packages/app/cypress/component/frontier-points-panel.cy.tsx
index 029e8632c..4d1af5c0a 100644
--- a/packages/app/cypress/component/frontier-points-panel.cy.tsx
+++ b/packages/app/cypress/component/frontier-points-panel.cy.tsx
@@ -66,8 +66,6 @@ function mountPanel() {
           frontier={frontier}
           xLabel="Interactivity (tok/s/user)"
           yLabel="J/output token"
-          maximizeX
-          maximizeY={false}
           overlayPoints={overlay}
           hardwareLabel={(entry) => entry.hwKey.split('_')[0].toUpperCase()}
           hardwareColor={() => 'rgb(200, 0, 0)'}
diff --git a/packages/app/cypress/component/gpu-graph.cy.tsx b/packages/app/cypress/component/gpu-graph.cy.tsx
index b3aa046b2..b19375402 100644
--- a/packages/app/cypress/component/gpu-graph.cy.tsx
+++ b/packages/app/cypress/component/gpu-graph.cy.tsx
@@ -195,58 +195,6 @@ describe('GPUGraph', () => {
     cy.get('[data-testid="gpu-graph"] svg .visible-shape').should('have.length.greaterThan', 0);
   });
 
-  it('draws the historical-power ring and reports measured-point coverage', () => {
-    const data = [
-      createMockInferenceData({
-        hwKey: 'h100',
-        x: 32,
-        y: 2.1,
-        date: '2025-03-01',
-        precision: Precision.FP4,
-        power_tier: 'legacy',
-      }),
-      createMockInferenceData({
-        hwKey: 'h100',
-        x: 64,
-        y: 1.8,
-        date: '2025-03-01',
-        precision: Precision.FP4,
-        power_tier: 'certified',
-      }),
-    ];
-
-    mountWithProviders(
-      <div style={{ width: 800, height: 600 }}>
-        <GPUGraph
-          chartId="test-gpu-measured-power"
-          modelLabel="DeepSeek R1"
-          data={data}
-          xLabel="Interactivity (tok/s/user)"
-          yLabel="Measured Joules per Output Token (J/tok)"
-          chartDefinition={defaultChartDef}
-        />
-      </div>,
-      {
-        inference: {
-          hardwareConfig: hwConfig,
-          selectedGPUs: ['h100'],
-          selectedDates: ['2025-03-01'],
-          selectedDateRange: { startDate: '', endDate: '' },
-          activeDates: new Set(['2025-03-01_h100']),
-          selectedPrecisions: [Precision.FP4],
-          selectedYAxisMetric: 'y_measuredJPerOutputToken',
-          hideNonOptimal: false,
-        },
-      },
-    );
-
-    cy.get('#test-gpu-measured-power svg .legacy-power-ring').should('have.length', 1);
-    cy.get('[data-testid="measured-power-summary"]')
-      .should('contain.text', 'Showing 2 of 2 measured points')
-      .and('contain.text', '1/1 validated')
-      .and('contain.text', '1/1 historical');
-  });
-
   it('shows spec decoding only on hover while retaining the offload halo', () => {
     const data = [
       createMockInferenceData({
@@ -557,15 +505,10 @@ describe('GPU comparison power envelopes', () => {
     );
   }
 
-  it('reveals off-boundary measurements and historical rings without changing power envelopes or axes', () => {
+  it('reveals off-boundary measurements without changing power envelopes or axes', () => {
     mountWithProviders(<PowerComparison />);
     cy.get('#gpu-show-all-measurements').should('not.exist');
     cy.get('#gpu-power-curves .dot-group').should('have.length', 6);
-    cy.get('#gpu-power-curves .legacy-power-ring').should('have.length', 2);
-    cy.get('[data-testid="measured-power-summary"]')
-      .should('contain.text', 'Showing 6 of 12 measured points')
-      .and('contain.text', '4/6 validated')
-      .and('contain.text', '2/6 historical');
     cy.get('#gpu-power-curves .roofline-path')
       .should('have.length', 2)
       .each(($path) => {
@@ -582,11 +525,6 @@ describe('GPU comparison power envelopes', () => {
       );
       cy.get('#gpu-hide-non-optimal').click({ force: true });
       cy.get('#gpu-power-curves .dot-group').should('have.length', 12);
-      cy.get('#gpu-power-curves .legacy-power-ring').should('have.length', 6);
-      cy.get('[data-testid="measured-power-summary"]').should(
-        'contain.text',
-        'Showing 12 of 12 measured points',
-      );
       cy.get('#gpu-hide-non-optimal').should('have.attr', 'data-state', 'unchecked');
       cy.get('#gpu-power-curves svg').should(($current) => {
         expect(
@@ -599,7 +537,6 @@ describe('GPU comparison power envelopes', () => {
       cy.get('#gpu-show-all-measurements').should('not.exist');
       cy.get('#gpu-hide-non-optimal').click({ force: true });
       cy.get('#gpu-power-curves .dot-group').should('have.length', 6);
-      cy.get('#gpu-power-curves .legacy-power-ring').should('have.length', 2);
     });
     cy.get('#gpu-power-curves .line-label').should('have.length', 2);
     cy.get('[data-testid="legend-advanced-toggle"]').click();
@@ -653,9 +590,6 @@ describe('GPU comparison power envelopes', () => {
     cy.get('#gpu-power-curves .roofline-path')
       .should('have.length', 2)
       .each(($path) => expect($path.attr('d')).to.contain('C'));
-    cy.get('#gpu-power-curves [data-testid="power-curve-description"]')
-      .should('contain.text', 'upper power boundary')
-      .and('contain.text', 'not efficiency frontiers');
   });
 
   it('uses the same boundary toggle for percent TDP and fleet percentiles while preserving energy Pareto', () => {
@@ -669,7 +603,6 @@ describe('GPU comparison power envelopes', () => {
       cy.get('#gpu-hide-non-optimal').should('have.attr', 'data-state', 'checked');
       cy.get('#gpu-power-curves .dot-group').should('have.length', 6);
       cy.get('#gpu-power-curves .roofline-path').should('have.length', 2);
-      cy.get('[data-testid="power-curve-description"]').should('contain', '不代表能效 Pareto 前沿');
       cy.get('#gpu-show-all-measurements').should('not.exist');
       cy.get('#gpu-hide-non-optimal').click({ force: true });
       cy.get('#gpu-power-curves .dot-group').should('have.length', 12);
@@ -684,6 +617,5 @@ describe('GPU comparison power envelopes', () => {
     cy.get('#gpu-power-curves .roofline-path')
       .should('have.length', 2)
       .each(($path) => expect($path.attr('d')).to.contain('C'));
-    cy.get('[data-testid="power-curve-description"]').should('not.exist');
   });
 });
diff --git a/packages/app/cypress/component/power-metric-availability.cy.tsx b/packages/app/cypress/component/power-metric-availability.cy.tsx
deleted file mode 100644
index 6a6c7b1a6..000000000
--- a/packages/app/cypress/component/power-metric-availability.cy.tsx
+++ /dev/null
@@ -1,88 +0,0 @@
-import { useState } from 'react';
-import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
-import {
-  PowerMetricAvailability,
-  PowerMetricAvailabilityPanel,
-} from '@/components/inference/ui/PowerMetricAvailability';
-import { createMockInferenceData } from '../support/mock-data';
-import { mountWithProviders } from '../support/test-utils';
-import { Precision, Model, Sequence } from '@/lib/data-mappings';
-
-const source = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/123/attempts/2';
-const base = { model: Model.Qwen3_5, precision: Precision.FP8, run_url: source };
-const missing = createMockInferenceData({ ...base, hwKey: 'gb200' });
-const invalid = createMockInferenceData({
-  ...base,
-  hwKey: 'mi355x',
-  power_valid: 0,
-  power_invalid_reasons: ['sampling_gap_exceeded'],
-});
-const measured = createMockInferenceData({
-  ...base,
-  hwKey: 'b200',
-  power_valid: 1,
-  power_metric_schema_version: 2,
-  measuredAvgPower: { y: 640, roof: false },
-});
-function Panel() {
-  const [metric, select] = useState('y_measuredAvgPower');
-  return (
-    <PowerMetricAvailabilityPanel
-      points={[missing, invalid, measured]}
-      metric={metric}
-      onSelect={select}
-    />
-  );
-}
-
-describe('PowerX metric availability', () => {
-  it('explains missing GB and withheld AMD data, exposes source links, and switches metrics', () => {
-    cy.mount(<Panel />);
-    cy.contains('1 of 3 points have this metric');
-    cy.contains('Validation failed: 1');
-    cy.contains('Metric not reported: 1');
-    cy.contains('summary', 'source details').click();
-    cy.contains('sampling_gap_exceeded');
-    cy.contains('a', 'Source run').should('have.attr', 'href', source);
-    cy.contains('summary', 'all measured metrics').click();
-    cy.contains('button', 'Measured Prefill Power per Chip').click();
-    cy.contains('No separate worker pools: 3');
-    cy.contains('0 of 3 points have this metric');
-  });
-  it('uses Chinese copy for the same coverage states', () => {
-    cy.mount(
-      <PathnameContext.Provider value="/zh/inference/qwen-3-5">
-        <Panel />
-      </PathnameContext.Provider>,
-    );
-    cy.contains('3 个数据点中有 1 个提供此指标');
-    cy.contains('验证失败: 1');
-    cy.contains('summary', '所有实测指标的可用性').click();
-    cy.contains('缺失值不会被替换为零或 TDP 估算值');
-  });
-  it('counts filtered unofficial rows before the metric filter and respects hidden overlay hardware', () => {
-    mountWithProviders(
-      <PowerMetricAvailability metric="y_measuredAvgPower" onSelect={cy.stub()} />,
-      {
-        inference: {
-          selectionPoints: [missing],
-          activeHwTypes: new Set(['gb200']),
-          selectedModel: Model.Qwen3_5,
-          selectedSequence: Sequence.EightK_OneK,
-          selectedPrecisions: [Precision.FP8],
-        },
-        unofficial: {
-          isUnofficialRun: true,
-          activeOverlayHwTypes: new Set(['b200']),
-          getOverlayData: () => ({ data: [measured, invalid], hardwareConfig: {} }),
-        },
-      },
-    );
-    cy.contains('1 of 2 points have this metric');
-    cy.contains('Metric not reported: 1');
-    cy.get('[data-testid="power-metric-availability"]').should(
-      'not.contain',
-      'Validation failed: 1',
-    );
-  });
-});
diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
index 3290637b9..56cf6be98 100644
--- a/packages/app/cypress/component/power-service-comparison.cy.tsx
+++ b/packages/app/cypress/component/power-service-comparison.cy.tsx
@@ -98,10 +98,9 @@ describe('PowerServiceComparison', () => {
       .not('[fill="var(--overlay-run-0)"]')
       .should('have.length', 4);
     cy.get('[data-testid="equal-service-toggle"]').check();
-    cy.get('[data-testid="equal-service-comparator"] option:selected').should(
-      'contain.text',
-      '900000002',
-    );
+    cy.get('[data-testid="equal-service-comparator"]')
+      .invoke('val')
+      .should('contain', OVERLAY_RUN_URL);
     cy.get('[data-testid="matched-concurrency-row-8"]').should('exist');
   });
 });
diff --git a/packages/app/cypress/component/scatter-graph.cy.tsx b/packages/app/cypress/component/scatter-graph.cy.tsx
index fac02fad5..3a06cb262 100644
--- a/packages/app/cypress/component/scatter-graph.cy.tsx
+++ b/packages/app/cypress/component/scatter-graph.cy.tsx
@@ -2880,13 +2880,6 @@ describe('Power envelopes', () => {
       .should('have.length', 3)
       .each(($point) => cy.wrap($point).should('have.css', 'opacity', '1'));
     cy.get('#scatter-show-all-measurements').should('not.exist');
-    cy.get('[data-testid="measured-power-summary"]')
-      .should('contain.text', 'Showing 3 of 4 measured points')
-      .and('contain.text', '1/2 historical');
-    cy.get('#power-sweep .dot-group')
-      .filter((_, element) => element.style.opacity !== '0')
-      .find('.legacy-power-ring')
-      .should('have.length', 1);
     cy.get('#power-sweep .dot-group')
       .filter((_, element) => element.style.opacity === '0')
       .should('have.css', 'pointer-events', 'none');
@@ -2898,11 +2891,6 @@ describe('Power envelopes', () => {
           .should('have.length', 4)
           .each(($point) => cy.wrap($point).should('have.css', 'opacity', '1'));
         cy.get('#power-sweep .roofline-path').should('have.attr', 'd', boundary);
-        cy.get('[data-testid="measured-power-summary"]').should(
-          'contain.text',
-          'Showing 4 of 4 measured points',
-        );
-        cy.get('#power-sweep .legacy-power-ring').should('have.length', 2);
         cy.get('#scatter-show-all-measurements').should('not.exist');
         cy.get('#scatter-hide-non-optimal').click({ force: true });
         cy.get('#power-sweep .dot-group')
@@ -2925,7 +2913,6 @@ describe('Power envelopes', () => {
     cy.contains('button', 'Energy').click();
     cy.get('#scatter-hide-non-optimal').should('have.attr', 'data-state', 'checked');
     cy.get('#power-sweep .roofline-path[data-curve-kind="pareto"]').should('have.length', 1);
-    cy.get('[data-testid="power-curve-description"]').should('not.exist');
     cy.get('#scatter-show-all-measurements').should('not.exist');
   });
 
diff --git a/packages/app/cypress/e2e/certified-power-filter.cy.ts b/packages/app/cypress/e2e/certified-power-filter.cy.ts
index 30098dbff..d5cd54b52 100644
--- a/packages/app/cypress/e2e/certified-power-filter.cy.ts
+++ b/packages/app/cypress/e2e/certified-power-filter.cy.ts
@@ -114,12 +114,9 @@ describe('Validated vs historical measured power', () => {
     });
   });
 
-  it('rings legacy points on a measured axis and filters them via Quick Filters', () => {
+  it('filters validated and historical measured points via Quick Filters', () => {
     visitCertifiedPowerChart();
 
-    cy.get('.legacy-power-ring').should('not.exist');
-    cy.get('[data-testid="legacy-power-key"]').should('not.exist');
-
     cy.get('[data-testid="yaxis-metric-selector"]').click('right');
     cy.contains('[data-slot="select-item"]', 'Measured Power')
       .scrollIntoView()
@@ -127,16 +124,8 @@ describe('Validated vs historical measured power', () => {
       .click();
     cy.get('[data-slot="select-content"]').should('not.exist');
 
-    cy.get('[data-testid="measured-power-summary"]')
-      .should('contain.text', 'Showing 2 of 6 measured points')
-      .and('contain.text', '1/3 validated')
-      .and('contain.text', '1/3 historical')
-      .and('contain.text', 'Best per SKU and Optimal Only are enabled');
-
-    cy.get('.dot-group[data-hw-key^="b200"] .legacy-power-ring').should('exist');
-    cy.get('.dot-group[data-hw-key^="mi300x"] .legacy-power-ring').should('not.exist');
-    cy.get('[data-testid="legacy-power-key"]').should('be.visible');
-    cy.screenshot('legacy-power-rings', { capture: 'viewport' });
+    cy.get('.dot-group[data-hw-key^="b200"]').should('exist');
+    cy.get('.dot-group[data-hw-key^="mi300x"]').should('exist');
 
     cy.get('[data-testid="scatter-quick-filters"]').click();
     cy.get('[data-testid="quick-filters-dialog"]').should('be.visible');
@@ -152,8 +141,6 @@ describe('Validated vs historical measured power', () => {
     cy.get('[data-testid="quick-filters-selected-count"]').should('contain.text', '1 selected');
     cy.get('.dot-group[data-hw-key^="b200"]').should('not.exist');
     cy.get('.dot-group[data-hw-key^="mi300x"]').should('exist');
-    cy.get('.legacy-power-ring').should('not.exist');
-    cy.get('[data-testid="legacy-power-key"]').should('not.exist');
     cy.get('[data-testid="inference-chart-display"] svg').should('exist');
     cy.screenshot('certified-only-filter', { capture: 'viewport' });
 
@@ -165,8 +152,7 @@ describe('Validated vs historical measured power', () => {
       'false',
     );
     cy.get('[data-testid="quick-filters-dialog"]').contains('button', 'Done').click();
-    cy.get('.dot-group[data-hw-key^="b200"] .legacy-power-ring').should('exist');
-    cy.get('[data-testid="legacy-power-key"]').should('be.visible');
+    cy.get('.dot-group[data-hw-key^="b200"]').should('exist');
   });
 
   it('restores a shared i_power=certified link with the toggle pre-selected', () => {
@@ -177,7 +163,6 @@ describe('Validated vs historical measured power', () => {
 
     cy.get('.dot-group[data-hw-key^="mi300x"]').should('exist');
     cy.get('.dot-group[data-hw-key^="b200"]').should('not.exist');
-    cy.get('[data-testid="legacy-power-key"]').should('not.exist');
 
     cy.get('[data-testid="scatter-quick-filters"]').click();
     cy.get('[data-testid="quick-filter-power-certified"]').should(
@@ -202,10 +187,6 @@ describe('Validated vs historical measured power', () => {
     cy.get('#scatter-hide-non-optimal').should('have.attr', 'data-state', 'checked');
     cy.get('#scatter-show-all-measurements').should('not.exist');
     visiblePowerPoints().should('have.length', 4);
-    cy.get('[data-testid="measured-power-summary"]').should(
-      'contain.text',
-      'Showing 4 of 6 measured points',
-    );
 
     // Let the initial ResizeObserver update reach the SVG before saving geometry.
     cy.get<SVGSVGElement>('[data-testid="d3-chart-svg"]').should(($svg) => {
@@ -239,7 +220,6 @@ describe('Validated vs historical measured power', () => {
 
         cy.get('#scatter-hide-non-optimal').click();
         visiblePowerPoints().should('have.length', 4);
-        visiblePowerPoints().find('.legacy-power-ring').should('have.length', 2);
         cy.get<SVGPathElement>('.roofline-path').should(($current) => {
           expect(Array.from($current, (curve) => curve.getAttribute('d'))).to.deep.equal(geometry);
         });
diff --git a/packages/app/cypress/e2e/inference-chart.cy.ts b/packages/app/cypress/e2e/inference-chart.cy.ts
index e7b53acf9..c23d42351 100644
--- a/packages/app/cypress/e2e/inference-chart.cy.ts
+++ b/packages/app/cypress/e2e/inference-chart.cy.ts
@@ -584,7 +584,7 @@ describe('AgentX replaces a complete curve while preserving an unofficial compar
   });
 });
 
-it('hydrates a direct PowerX metric link and shows availability for the selected workload', () => {
+it('hydrates a direct PowerX metric link', () => {
   cy.intercept('GET', '/api/v1/availability').as('powerLinkAvailability');
   cy.intercept('GET', '/api/v1/benchmarks*').as('powerLinkBenchmarks');
   cy.viewport(1440, 900);
@@ -603,17 +603,6 @@ it('hydrates a direct PowerX metric link and shows availability for the selected
     'aria-pressed',
     'true',
   );
-  cy.get('[data-testid="power-metric-availability"]').should(
-    'contain',
-    'Current workload and hardware selection',
-  );
-  cy.contains('summary', 'Availability of all measured metrics').click();
-  cy.get('[data-testid="power-metric-availability"]').within(() => {
-    cy.contains('button', 'Measured P75 Fleet Power per Chip').should('contain', '/');
-    cy.contains('button', 'Measured Joules per Output Token').click();
-  });
-  cy.get('[data-testid="yaxis-metric-selector"]').should('contain', 'Measured Energy');
-  cy.get('[data-testid="measured-energy-denominator"]').should('contain', 'Output');
   cy.get('@powerLinkConsoleErrors').should('not.be.calledWithMatch', /hydrat/i);
 });
 
@@ -700,7 +689,6 @@ it('uses Optimal Only to filter power boundary dots without replacing official o
   cy.get('[data-testid="chart-figure"] h2').should('contain', 'Measured Joules per Output Token');
   cy.get('#scatter-hide-non-optimal').should('have.attr', 'data-state', 'checked');
   cy.get('#scatter-show-all-measurements').should('not.exist');
-  cy.get('[data-testid="power-curve-description"]').should('not.exist');
   assertVisibleMeasuredValues('.dot-group', [2, 4, 5]);
   assertVisibleMeasuredValues('.unofficial-overlay-pt', [3, 5, 6]);
   cy.get(curves)
diff --git a/packages/app/cypress/e2e/powerx-compare.cy.ts b/packages/app/cypress/e2e/powerx-compare.cy.ts
index ec2645896..921bbab3c 100644
--- a/packages/app/cypress/e2e/powerx-compare.cy.ts
+++ b/packages/app/cypress/e2e/powerx-compare.cy.ts
@@ -186,14 +186,14 @@ describe('PowerX article panels', () => {
     // W/GPU 500, 600, 700 → P0 450 W, m 0.643 J/token, R² 0.964.
     cy.get('[data-testid="power-fit-row"]').should('have.length', 2);
     cy.get('[data-testid="power-fit-row"]')
-      .filter(':contains("b200")')
+      .filter(':contains("B200")')
       .should('contain.text', '450')
       .and('contain.text', '45% · 1,000 W')
       .and('contain.text', '0.643')
       .and('contain.text', '0.964')
       .and('contain.text', '100.0–400.0');
     cy.get('[data-testid="power-fit-row"]')
-      .filter(':contains("h200")')
+      .filter(':contains("H200")')
       .should('contain.text', '64% · 700 W');
 
     // The cheaper overlay rows own the frontier; each lists its run.
@@ -203,10 +203,6 @@ describe('PowerX article panels', () => {
         expect($row.text()).to.include('unofficial');
         expect($row.find('a').attr('href')).to.eq(OVERLAY_RUN_URL);
       });
-    cy.get('[data-testid="frontier-points-scope"]').should(
-      'contain.text',
-      `${CONFIGS.length} of ${CONFIGS.length * 2} visible observations`,
-    );
     assertShareLinkParams({
       i_servicecompare: '1',
       i_roleshare: '1',
diff --git a/packages/app/src/components/inference/axis-metric-explanations.ts b/packages/app/src/components/inference/axis-metric-explanations.ts
index cc198bb05..dbfd38030 100644
--- a/packages/app/src/components/inference/axis-metric-explanations.ts
+++ b/packages/app/src/components/inference/axis-metric-explanations.ts
@@ -187,11 +187,11 @@ function provisionedJoules(tokenType: TokenType): MetricExplanation {
 /** Validation-status note appended to every Measured Energy explanation. */
 const MEASURED_TIER_NOTE_EN =
   ' Validated points passed the current PowerX telemetry checks. Historical points are real ' +
-  "older measurements but lack the information needed to confirm today's method; a dotted ring " +
-  'marks them. Filter either status under Quick Filters → Measured Power.';
+  "older measurements but lack the information needed to confirm today's method. Filter either " +
+  'status under Quick Filters → Measured Power.';
 const MEASURED_TIER_NOTE_ZH =
-  '已验证数据点通过了当前 PowerX 遥测检查。历史数据点来自真实的旧版测量，但缺少按当前方法完成验证所需的信息；' +
-  '图表以虚线圆环标记这类数据点。可在快捷筛选的“实测功耗”中按测量状态筛选。';
+  '已验证数据点通过了当前 PowerX 遥测检查。历史数据点来自真实的旧版测量，但缺少按当前方法完成验证所需的信息。' +
+  '可在快捷筛选的“实测功耗”中按测量状态筛选。';
 
 type MeasuredPhase = 'run' | 'prefill' | 'decode';
 
diff --git a/packages/app/src/components/inference/metric-registry.ts b/packages/app/src/components/inference/metric-registry.ts
index 9687c561d..ee81252d4 100644
--- a/packages/app/src/components/inference/metric-registry.ts
+++ b/packages/app/src/components/inference/metric-registry.ts
@@ -654,8 +654,7 @@ export interface MetricControlGroup {
 /**
  * The runner-telemetry y-axes in the "Measured Energy" control group.
  * Exported (and referenced by the group below, so the two cannot drift) for
- * consumers that treat measured axes specially — the legacy-power point ring,
- * tooltip tier line, and footer legend key.
+ * consumers that treat measured axes specially, such as the tooltip tier line.
  */
 export const MEASURED_ENERGY_METRIC_CONFIG_KEYS = [
   'y_measuredPrefillAvgPower',
@@ -698,7 +697,7 @@ export function isRoleLocalMeasuredEnergyConfigKey(configKey: string): boolean {
  * utility modeled) that share the gated Measured Energy group and its
  * Boundary select. They are kept out of `MEASURED_ENERGY_METRIC_CONFIG_KEYS`
  * on purpose: spec constants and model output carry no telemetry tier, so the
- * legacy-power ring, tier tooltip line, and footer key do not apply to them.
+ * tier tooltip line does not apply to them.
  */
 export const POWER_BASIS_METRIC_CONFIG_KEYS = [
   'y_gpuProvisionedWatts',
diff --git a/packages/app/src/components/inference/ui/ChartControls.tsx b/packages/app/src/components/inference/ui/ChartControls.tsx
index 726a6918c..16e03f4c7 100644
--- a/packages/app/src/components/inference/ui/ChartControls.tsx
+++ b/packages/app/src/components/inference/ui/ChartControls.tsx
@@ -58,7 +58,6 @@ import {
 import { useOpenDropdown } from '@/hooks/useOpenDropdown';
 import { ModelArchitectureInfoLink } from './ModelArchitectureInfoLink';
 import { MetricExplanation } from './MetricExplanation';
-import { PowerMetricAvailability } from './PowerMetricAvailability';
 import { MeasuredMetricControls } from './MeasuredMetricControls';
 import {
   changeMeasuredMetricConfig,
@@ -565,29 +564,15 @@ export default function ChartControls({
                   noResultsLabel={locale === 'zh' ? '无结果' : undefined}
                   clearSearchLabel={locale === 'zh' ? '清除搜索' : undefined}
                 />
-                {mounted && !getMeasuredMetricConfig(selectedYAxisMetric) && (
-                  <PowerMetricAvailability
-                    metric={selectedYAxisMetric}
-                    onSelect={handleYAxisMetricChange}
-                  />
-                )}
               </div>
 
               {mounted && getMeasuredMetricConfig(selectedYAxisMetric) && (
-                <>
-                  <MeasuredMetricControls
-                    metric={selectedYAxisMetric}
-                    onChange={handleYAxisMetricChange}
-                    compare={powerCompare}
-                    onCompareChange={setPowerCompare}
-                  />
-                  <div className="col-span-full">
-                    <PowerMetricAvailability
-                      metric={selectedYAxisMetric}
-                      onSelect={handleYAxisMetricChange}
-                    />
-                  </div>
-                </>
+                <MeasuredMetricControls
+                  metric={selectedYAxisMetric}
+                  onChange={handleYAxisMetricChange}
+                  compare={powerCompare}
+                  onCompareChange={setPowerCompare}
+                />
               )}
 
               {tcoVisible && (
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index 5577c1138..c1cfaa1a1 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -7,7 +7,6 @@ import { BarChart3, Table2 } from 'lucide-react';
 import chartDefinitions, {
   costTierLabel,
   costTierOptionLabel,
-  isMeasuredEnergyConfigKey,
   isModeledSystemPowerConfigKey,
   metricCostTier,
   tokenMetricTypeForConfigKey,
@@ -101,7 +100,6 @@ import { ATOM_FOOTNOTE_MARKER, AtomEngineFootnote } from '@/components/ui/atom-e
 import { AgenticOptimizationNote } from '@/components/inference/ui/AgenticOptimizationNote';
 import { CacheReuseLink } from '@/components/inference/ui/CacheReuseLink';
 import { OffloadHaloLegendKey } from '@/components/inference/ui/OffloadHaloLegendKey';
-import { LegacyPowerLegendKey } from '@/components/inference/ui/LegacyPowerLegendKey';
 import { ActiveQuickFilters } from '@/components/inference/ui/ActiveQuickFilters';
 import { ResultContext } from '@/components/ui/result-context';
 import { ModelLogo } from '@/components/ui/model-logo';
@@ -921,11 +919,6 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
               ...(footerOverlay?.clippedData ?? []).map((entry) => entry.point),
             ];
             const hasOffloadHalo = footerPoints.some((point) => point.offload_mode === 'on');
-            // Legacy-power rings render only on Measured Energy axes, so the
-            // key follows the same gate to never advertise an absent ring.
-            const hasLegacyPowerPoints =
-              isMeasuredEnergyConfigKey(selectedYAxisMetric) &&
-              footerPoints.some((point) => point.power_tier === 'legacy');
             const hasAtomSeries = footerPoints.some(
               (point) =>
                 point.framework !== undefined &&
@@ -935,14 +928,13 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
             // here as the footer's last block rather than in the chart subtitle,
             // keeping the result-context header compact.
             const footerNotices =
-              hasOffloadHalo || hasLegacyPowerPoints || isAgenticSequence || hasAtomSeries ? (
+              hasOffloadHalo || isAgenticSequence || hasAtomSeries ? (
                 <>
                   <div
                     data-testid="chart-status-notes"
                     className="flex flex-wrap items-center gap-x-5 gap-y-2"
                   >
                     {hasOffloadHalo && <OffloadHaloLegendKey />}
-                    {hasLegacyPowerPoints && <LegacyPowerLegendKey />}
                     {isAgenticSequence && <AgenticOptimizationNote />}
                     {isAgenticSequence && !minimalChrome && <CacheReuseLink />}
                     {hasAtomSeries && (
diff --git a/packages/app/src/components/inference/ui/FrontierPointsPanel.tsx b/packages/app/src/components/inference/ui/FrontierPointsPanel.tsx
index a8dcd84a6..3c2e6aa0a 100644
--- a/packages/app/src/components/inference/ui/FrontierPointsPanel.tsx
+++ b/packages/app/src/components/inference/ui/FrontierPointsPanel.tsx
@@ -10,28 +10,13 @@ import { exportToCsv } from '@/lib/csv-export';
 import { overlayRunColor, overlayRunIndex } from '@/lib/overlay-run-style';
 import { useLocale } from '@/lib/use-locale';
 import type { InferenceData } from '../types';
-import {
-  FRONTIER_EXPORT_HEADERS,
-  frontierExportRow,
-  frontierHardwareCounts,
-  frontierScope,
-} from '../utils/frontier-points';
+import { FRONTIER_EXPORT_HEADERS, frontierExportRow } from '../utils/frontier-points';
 import { runAttemptFromUrl, runIdFromUrl } from '../utils/powerTimeline';
 import { pointTopologyKey, topologyLabel } from '../utils/topology-filter';
 
 const STRINGS = {
   en: {
     title: 'Frontier points',
-    scope: (frontier: number, eligible: number, sources: number, runs: number) =>
-      `${frontier} of ${eligible} visible observations are on the frontier; they competed across ${sources} sources from ${runs} runs.`,
-    direction: (x: string, y: string) => `Better: ${x} and ${y}.`,
-    higher: (label: string) => `higher ${label}`,
-    lower: (label: string) => `lower ${label}`,
-    method:
-      'One non-dominated set over every series visible on the chart, with the chart’s filters. Each point keeps its own run and recipe; nothing is interpolated or averaged.',
-    mixed: (topologies: number, images: number) =>
-      `The competing observations span ${topologies} topologies and ${images} images, so the frontier compares deployments as served, not one recipe.`,
-    owners: 'Frontier points by hardware',
     hardware: 'Hardware',
     config: 'Configuration',
     concurrency: 'Conc.',
@@ -43,16 +28,6 @@ const STRINGS = {
   },
   zh: {
     title: '前沿点',
-    scope: (frontier: number, eligible: number, sources: number, runs: number) =>
-      `${eligible} 个可见观测值中有 ${frontier} 个位于前沿上；这些观测值来自 ${runs} 次运行中的 ${sources} 个数据源。`,
-    direction: (x: string, y: string) => `更优方向：${x}、${y}。`,
-    higher: (label: string) => `${label}更高`,
-    lower: (label: string) => `${label}更低`,
-    method:
-      '在图表当前的筛选条件下，对图上全部可见系列统一计算一个非支配集合。每个点保留各自的运行和配置方案，不做插值或平均。',
-    mixed: (topologies: number, images: number) =>
-      `参与比较的观测值涉及 ${topologies} 种拓扑和 ${images} 个镜像，因此前沿比较的是各自的实际部署，而非同一配置方案。`,
-    owners: '各硬件的前沿点数',
     hardware: '硬件',
     config: '配置',
     concurrency: '并发',
@@ -72,8 +47,6 @@ export default function FrontierPointsPanel({
   frontier,
   xLabel,
   yLabel,
-  maximizeX,
-  maximizeY,
   overlayPoints,
   hardwareLabel,
   hardwareColor,
@@ -84,8 +57,6 @@ export default function FrontierPointsPanel({
   frontier: readonly InferenceData[];
   xLabel: string;
   yLabel: string;
-  maximizeX: boolean;
-  maximizeY: boolean;
   overlayPoints: readonly InferenceData[];
   hardwareLabel: (point: InferenceData) => string;
   hardwareColor: (point: InferenceData) => string;
@@ -94,18 +65,12 @@ export default function FrontierPointsPanel({
   const t = STRINGS[locale];
   const { runIndexByUrl } = useUnofficialRun();
   const overlaySet = useMemo(() => new Set(overlayPoints), [overlayPoints]);
-  const scope = useMemo(() => frontierScope(eligible), [eligible]);
-  const owners = useMemo(() => frontierHardwareCounts(frontier), [frontier]);
   const topologies = useMemo(() => [...new Set(eligible.map(pointTopologyKey))], [eligible]);
   const sectionId = `${chartId}-frontier-points`;
   const colorOf = (point: InferenceData) =>
     overlaySet.has(point)
       ? overlayRunColor(overlayRunIndex(point.run_url, runIndexByUrl))
       : hardwareColor(point);
-  const labelFor = (hwKey: string) => {
-    const point = frontier.find((entry) => entry.hwKey === hwKey);
-    return point ? hardwareLabel(point) : hwKey;
-  };
 
   const exportCsv = () => {
     exportToCsv(
@@ -125,27 +90,6 @@ export default function FrontierPointsPanel({
       <Heading as="h3" level="card">
         {t.title}
       </Heading>
-      <p className="text-sm" data-testid="frontier-points-scope">
-        {t.scope(frontier.length, scope.eligible, scope.sources, scope.runs)}{' '}
-        {t.direction(
-          maximizeX ? t.higher(xLabel) : t.lower(xLabel),
-          maximizeY ? t.higher(yLabel) : t.lower(yLabel),
-        )}
-      </p>
-      <p className="text-xs text-muted-foreground">{t.method}</p>
-      {(scope.topologies > 1 || scope.images > 1) && (
-        <p className="text-xs text-muted-foreground" data-testid="frontier-points-mixed">
-          {t.mixed(scope.topologies, scope.images)}
-        </p>
-      )}
-      <p className="flex flex-wrap items-center gap-x-4 gap-y-1 text-sm">
-        <span className="text-muted-foreground">{t.owners}:</span>
-        {owners.map(({ hwKey, count }) => (
-          <span key={hwKey} data-testid="frontier-points-owner">
-            {labelFor(hwKey)} ×{count}
-          </span>
-        ))}
-      </p>
       <div className="max-h-96 min-w-0 overflow-auto">
         <table
           className="w-full min-w-[48rem] table-fixed break-words text-left text-sm"
diff --git a/packages/app/src/components/inference/ui/GPUGraph.tsx b/packages/app/src/components/inference/ui/GPUGraph.tsx
index 6786040dd..de1b6462e 100644
--- a/packages/app/src/components/inference/ui/GPUGraph.tsx
+++ b/packages/app/src/components/inference/ui/GPUGraph.tsx
@@ -73,11 +73,7 @@ import {
 } from '@/components/inference/utils/knownIssueAnnotations';
 import { matchKnownConfigIssues, pointMatchesIssue } from '@/lib/known-issues';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
-import { renderLegacyPowerRing } from '@/components/inference/utils/legacy-power-marker';
-import {
-  isMeasuredEnergyConfigKey,
-  isRoleLocalMeasuredEnergyConfigKey,
-} from '@/components/inference/metric-registry';
+import { isRoleLocalMeasuredEnergyConfigKey } from '@/components/inference/metric-registry';
 import {
   clampIsoX,
   clearPerfRulers,
@@ -98,10 +94,6 @@ import {
   type PerfRulerRenderEntry,
   type PerfRulerState,
 } from '@/lib/d3-chart/layers/perf-ruler';
-import {
-  countPowerTiers,
-  MeasuredPowerSummary,
-} from '@/components/inference/ui/MeasuredPowerSummary';
 import {
   keepPointLabelsInPlot,
   parallelismLabelBoxes,
@@ -164,10 +156,6 @@ const GPU_STRINGS = {
     showAllMeasurements: 'Show all measurements',
     powerBoundaryInfo:
       'Show only points on the upper measured power boundary. Turn off to show all measurements; the boundary stays the same. This is a power-load boundary, not an energy-efficiency frontier.',
-    powerCurves:
-      'Smooth lines trace the upper power boundary across tested configurations. Dots are measured; lines are interpolated, not efficiency frontiers.',
-    powerOptimal:
-      'A power Pareto frontier can contain a single point. Turn off Optimal Only to show the upper power boundary.',
     labels: 'Labels',
     parallelismLabels: 'Parallelism Labels',
     concurrencyLabels: '# Concurrent Sessions',
@@ -190,9 +178,6 @@ const GPU_STRINGS = {
     showAllMeasurements: '显示全部测量点',
     powerBoundaryInfo:
       '仅显示实测功率上边界上的点。关闭后显示全部测量点，边界曲线保持不变。这是功率负载边界，不是能效前沿。',
-    powerCurves:
-      '平滑曲线勾勒各测试配置的功耗上边界。数据点来自实测，曲线通过插值得到，不代表能效 Pareto 前沿。',
-    powerOptimal: '功耗的 Pareto 前沿可能只有一个点。关闭“仅最优”即可查看功耗上边界。',
     labels: '标签',
     parallelismLabels: '并行配置标签',
     concurrencyLabels: '并发会话数',
@@ -281,7 +266,6 @@ const GPUGraph = React.memo(
     const isMeasuredPowerAxis = isMeasuredPowerCurveMetric(selectedYAxisMetric);
     const powerEnvelopeMode = powerCurveMetric && (isMeasuredPowerAxis || !hideNonOptimal);
     const showAllMeasurements = isMeasuredPowerAxis ? !hideNonOptimal : savedShowAllMeasurements;
-    const isMeasuredEnergyAxis = isMeasuredEnergyConfigKey(selectedYAxisMetric);
     const noDataHint = isRoleLocalMeasuredEnergyConfigKey(selectedYAxisMetric)
       ? legendT.noRoleEnergyDataHint
       : legendT.noDataHint;
@@ -505,16 +489,6 @@ const GPUGraph = React.memo(
     // Keep domains fixed so revealing off-boundary dots cannot move power curves.
     const scaleData = powerEnvelopeMode ? activeData : filteredData;
 
-    const powerTierCounts = useMemo(
-      () => ({
-        total: countPowerTiers(
-          data.filter((point) => selectedPrecisions.includes(point.precision)),
-        ),
-        visible: countPowerTiers(filteredData),
-      }),
-      [data, filteredData, selectedPrecisions],
-    );
-
     // GPU comparison currently renders official DB-backed points only. Unofficial
     // overlays have no benchmark_results id or persisted trace, so they cannot
     // open the dedicated per-point charts route.
@@ -1296,28 +1270,7 @@ const GPUGraph = React.memo(
         watermark={getChartWatermark()}
         testId="gpu-graph"
         grabCursor={true}
-        caption={
-          isMeasuredEnergyAxis || powerCurveMetric ? (
-            <>
-              {caption}
-              {isMeasuredEnergyAxis && (
-                <MeasuredPowerSummary
-                  total={powerTierCounts.total}
-                  visible={powerTierCounts.visible}
-                  bestPerSku={false}
-                  optimalOnly={hideNonOptimal}
-                />
-              )}
-              {powerCurveMetric && (
-                <p data-testid="power-curve-description" className="text-muted-foreground text-sm">
-                  {powerEnvelopeMode ? legendT.powerCurves : legendT.powerOptimal}
-                </p>
-              )}
-            </>
-          ) : (
-            caption
-          )
-        }
+        caption={caption}
         xScale={{ type: 'linear', domain: xExtent, nice: true }}
         yScale={{ type: logScale ? 'log' : 'linear', domain: yDomain, nice: true }}
         xAxis={{
@@ -1532,18 +1485,12 @@ const GPUGraph = React.memo(
             .selectAll('.dot-group, .roofline-path')
             .style('transition', 'opacity 150ms ease');
 
-          // Decorations stay inside the point group, so normal zoom transforms
-          // carry them without a separate update pass.
+          // The offload halo stays inside the point group, so normal zoom
+          // transforms carry it without a separate update pass.
           ctx.layout.zoomGroup
             .selectAll<SVGGElement, InferenceData>('.dot-group')
             .each(function (point) {
               renderOffloadHalo(d3.select(this), point, 'var(--foreground)');
-              renderLegacyPowerRing(
-                d3.select(this),
-                point,
-                isMeasuredEnergyAxis,
-                'var(--foreground)',
-              );
             });
         }}
         legendElement={
diff --git a/packages/app/src/components/inference/ui/LegacyPowerLegendKey.tsx b/packages/app/src/components/inference/ui/LegacyPowerLegendKey.tsx
deleted file mode 100644
index 3050638f6..000000000
--- a/packages/app/src/components/inference/ui/LegacyPowerLegendKey.tsx
+++ /dev/null
@@ -1,51 +0,0 @@
-import { POINT_SIZE } from '@/lib/chart-rendering';
-import { useLocale } from '@/lib/use-locale';
-
-// Nested outside the KV-offload halo (POINT_SIZE + 4, '3 2' dashes) with a
-// dotted dasharray so both decorations stay legible on one point.
-export const LEGACY_POWER_RING_RADIUS = POINT_SIZE + 7;
-export const LEGACY_POWER_RING_STROKE_WIDTH = 1.5;
-export const LEGACY_POWER_RING_DASHARRAY = '1 3';
-
-const STRINGS = {
-  en: 'Historical measurement (not validated under the current method)',
-  zh: '历史测量（尚未按当前方法验证）',
-} as const;
-
-/**
- * Key for the dotted ring drawn around measured-axis points whose power
- * telemetry predates the producer validation contract (`power_tier ===
- * 'legacy'`). Rendered in the axis-metric info footer below the chart (the
- * footer is `no-export`, so downloaded PNGs carry only the ring itself).
- */
-export function LegacyPowerLegendKey() {
-  const locale = useLocale();
-
-  return (
-    <div
-      data-testid="legacy-power-key"
-      className="inline-flex max-w-full items-center gap-2 text-xs leading-5 text-muted-foreground"
-    >
-      <svg
-        width="16"
-        height="16"
-        viewBox="0 0 24 24"
-        className="shrink-0"
-        style={{ maxWidth: 16 }}
-        aria-hidden="true"
-      >
-        <circle cx="12" cy="12" r={POINT_SIZE} fill="currentColor" opacity="0.45" />
-        <circle
-          cx="12"
-          cy="12"
-          r={LEGACY_POWER_RING_RADIUS}
-          fill="none"
-          stroke="currentColor"
-          strokeWidth={LEGACY_POWER_RING_STROKE_WIDTH}
-          strokeDasharray={LEGACY_POWER_RING_DASHARRAY}
-        />
-      </svg>
-      <span className="min-w-0 leading-tight">{STRINGS[locale]}</span>
-    </div>
-  );
-}
diff --git a/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx b/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
index a3ad3c7ca..88744ea99 100644
--- a/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
+++ b/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
@@ -16,10 +16,6 @@ import {
 const STRINGS = {
   en: {
     title: 'Matched concurrency (load diagnostic)',
-    method:
-      'Observations of the two sources at the same concurrency. Matched load is not matched service: at one concurrency the sources usually serve different speeds, so use the comparison above for equal service. Change = (comparator ÷ baseline − 1) × 100%.',
-    scope:
-      'Each cell is one observation of the selected source; repeated dispatches are separate sources and are not averaged. Measured GPU energy excludes host-system and facility power.',
     concurrency: 'Concurrency',
     baseline: 'Baseline',
     comparator: 'Comparator',
@@ -36,10 +32,6 @@ const STRINGS = {
   },
   zh: {
     title: '相同并发下的对照（负载诊断）',
-    method:
-      '在相同并发数下对比两个数据源的观测值。相同负载不等于相同服务水平：同一并发数下两者的生成速度通常不同，如需在相同服务水平下比较，请使用上方的对比。变化 =（对比对象 ÷ 基准 − 1）× 100%。',
-    scope:
-      '每个单元格是所选数据源的一次观测；重复运行计为不同的数据源，不做平均。实测 GPU 能耗不含主机系统和数据中心设施功耗。',
     concurrency: '并发数',
     baseline: '基准',
     comparator: '对比对象',
@@ -146,7 +138,6 @@ export default function MatchedConcurrencyTable({
       <Heading as="h3" level="card">
         {t.title}
       </Heading>
-      <p className="text-sm text-muted-foreground">{t.method}</p>
       {table.reason ? (
         <p className="text-sm text-muted-foreground">{t.unavailable}</p>
       ) : table.rows.length === 0 ? (
@@ -203,7 +194,6 @@ export default function MatchedConcurrencyTable({
           </table>
         </div>
       )}
-      <p className="text-xs text-muted-foreground">{t.scope}</p>
       <div className="max-h-0 overflow-hidden">
         <div id={`${sectionId}-export`} className="p-4" />
       </div>
diff --git a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
index 0373fc5bd..d2d585611 100644
--- a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
+++ b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
@@ -23,8 +23,6 @@ const STRINGS = {
     basis: 'Boundary',
     basisHelp:
       'Where power is counted. GPU measured: runner telemetry from the GPU boards. GPU provisioned: rated TDP per GPU. Utility provisioned: all-in provisioned utility power per GPU. Utility modeled: measured GPU power carried through the modeled chassis to the utility meter with PUE. Points without a value for the chosen boundary are omitted, never replaced with an estimate.',
-    basisHint:
-      'Derived boundaries report average power per chip across all GPUs, and whole-deployment joules per output token. Changing another setting returns to GPU measured.',
     scope: 'Scope',
     scopeHelp:
       'All GPUs measures the whole deployment. Prefill and decode select only GPUs serving that role.',
@@ -35,7 +33,6 @@ const STRINGS = {
     statisticHelp:
       'P75 and P90 are time-weighted percentiles of synchronized fleet power, divided by chip count. They are available for all GPUs only.',
     average: 'Average',
-    roleHint: 'Prefill and decode power support Average only.',
     display: 'Display',
     displayHelp:
       'Power per chip in watts, average power as a percentage of chip TDP, or the per-second telemetry timeline behind the average. Percent of TDP and Timeline are available for the all-GPU average only.',
@@ -56,15 +53,11 @@ const STRINGS = {
     compareNone: 'Off',
     compareBoundaries: 'All boundaries',
     compareRoles: 'Prefill vs decode',
-    compareUnavailable:
-      'The comparison is paused for this setting: it needs the whole-deployment average W/chip or J per output token.',
   },
   zh: {
     basis: '功耗边界',
     basisHelp:
       '选择功耗的计量边界。GPU 实测：来自 GPU 板卡的运行器遥测；GPU 额定：每 GPU 的额定 TDP；全电源配置：每 GPU 的全电源配置（all-in）市电功率；数据中心建模：将 GPU 实测功耗经机箱功耗模型推算至市电侧并计入 PUE。所选边界缺少数值的数据点将被省略，不会用估算值替代。',
-    basisHint:
-      '推导边界提供全部 GPU 的平均每芯片功率，以及整个部署的每输出 token 能耗；更改其他设置将返回 GPU 实测。',
     scope: '统计范围',
     scopeHelp: '全部 GPU 对应整个部署；预填充和解码仅统计承担相应任务的 GPU。',
     all: '全部 GPU',
@@ -74,7 +67,6 @@ const STRINGS = {
     statisticHelp:
       'P75 和 P90 是同步采样的集群总功率按时间加权得到的分位数，再除以芯片数。仅支持全部 GPU。',
     average: '平均值',
-    roleHint: '预填充和解码功率仅支持平均值。',
     display: '显示方式',
     displayHelp:
       '显示单芯片功率（瓦）、平均功率占芯片 TDP 的百分比，或平均值背后的逐秒遥测时间线。TDP 百分比和时间线仅支持全部 GPU 的平均功率。',
@@ -94,7 +86,6 @@ const STRINGS = {
     compareNone: '关闭',
     compareBoundaries: '全部边界',
     compareRoles: '预填充 vs 解码',
-    compareUnavailable: '当前设置下对比已暂停：需要整个部署的平均 W/芯片或每输出 token 能耗。',
   },
 } as const;
 
@@ -119,13 +110,10 @@ export function MeasuredMetricControls({
     boundaries: t.compareBoundaries,
     roles: t.compareRoles,
   };
-  const compareActive = compare !== 'none';
-  const compareApplies = powerCompareAvailable(metric, compare);
   const change = (next: MeasuredMetricConfigChange) =>
     onChange(changeMeasuredMetricConfig(metric, next));
   const basisId = `measured-${config.family}-basis`;
   const scopeId = `measured-${config.family}-scope`;
-  const derivedBasis = config.basis !== 'gpu-measured';
   const roleScope =
     config.family === 'energy'
       ? config.denominator === 'input'
@@ -282,9 +270,6 @@ export function MeasuredMetricControls({
               </SelectContent>
             </Select>
           </div>
-          {config.scope !== 'all' && (
-            <p className="col-span-full text-xs text-muted-foreground">{t.roleHint}</p>
-          )}
         </>
       ) : (
         <div className="flex min-w-0 flex-col gap-1.5">
@@ -349,22 +334,6 @@ export function MeasuredMetricControls({
           </Select>
         </div>
       )}
-      {derivedBasis && (
-        <p
-          className="col-span-full text-xs text-muted-foreground"
-          data-testid="measured-basis-hint"
-        >
-          {t.basisHint}
-        </p>
-      )}
-      {compareActive && !compareApplies && (
-        <p
-          className="col-span-full text-xs text-muted-foreground"
-          data-testid="measured-compare-hint"
-        >
-          {t.compareUnavailable}
-        </p>
-      )}
     </div>
   );
 }
diff --git a/packages/app/src/components/inference/ui/MeasuredPowerSummary.tsx b/packages/app/src/components/inference/ui/MeasuredPowerSummary.tsx
deleted file mode 100644
index dfbbf68c6..000000000
--- a/packages/app/src/components/inference/ui/MeasuredPowerSummary.tsx
+++ /dev/null
@@ -1,117 +0,0 @@
-'use client';
-
-import type { InferenceData } from '@/components/inference/types';
-import { useLocale } from '@/lib/use-locale';
-
-export interface PowerTierCounts {
-  certified: number;
-  legacy: number;
-}
-
-export function countPowerTiers(points: readonly InferenceData[]): PowerTierCounts {
-  const counts: PowerTierCounts = { certified: 0, legacy: 0 };
-  for (const point of points) {
-    if (point.power_tier === 'certified') counts.certified += 1;
-    else if (point.power_tier === 'legacy') counts.legacy += 1;
-  }
-  return counts;
-}
-
-const STRINGS = {
-  en: {
-    validated: 'validated',
-    historical: 'historical',
-    single: (shown: number, total: number, tier: string) =>
-      `Showing ${shown} of ${total} ${tier} measurements.`,
-    combined: (
-      shown: number,
-      total: number,
-      validatedShown: number,
-      validatedTotal: number,
-      historicalShown: number,
-      historicalTotal: number,
-    ) =>
-      `Showing ${shown} of ${total} measured points: ${validatedShown}/${validatedTotal} validated · ${historicalShown}/${historicalTotal} historical.`,
-    bestPerSku: 'Best per SKU',
-    optimalOnly: 'Optimal Only',
-    controlsEnabled: (controls: string) =>
-      `${controls} ${controls.includes(' and ') ? 'are' : 'is'} enabled.`,
-    reducedBySelections: 'Chart selections are hiding some points.',
-  },
-  zh: {
-    validated: '已验证',
-    historical: '历史',
-    single: (shown: number, total: number, tier: string) =>
-      `当前显示 ${shown}/${total} 个${tier}测量数据点。`,
-    combined: (
-      shown: number,
-      total: number,
-      validatedShown: number,
-      validatedTotal: number,
-      historicalShown: number,
-      historicalTotal: number,
-    ) =>
-      `当前显示 ${shown}/${total} 个实测数据点：已验证 ${validatedShown}/${validatedTotal} · 历史 ${historicalShown}/${historicalTotal}。`,
-    bestPerSku: '每个 SKU 仅显示最佳配置',
-    optimalOnly: '仅最优',
-    controlsEnabled: (controls: string) => `已启用：${controls}。`,
-    reducedBySelections: '当前图表选项隐藏了部分数据点。',
-  },
-} as const;
-
-function joinControls(controls: string[], locale: 'en' | 'zh'): string {
-  if (controls.length < 2) return controls[0] ?? '';
-  return locale === 'zh' ? controls.join('、') : controls.join(' and ');
-}
-
-export function MeasuredPowerSummary({
-  total,
-  visible,
-  bestPerSku,
-  optimalOnly,
-}: {
-  total: PowerTierCounts;
-  visible: PowerTierCounts;
-  bestPerSku: boolean;
-  optimalOnly: boolean;
-}) {
-  const locale = useLocale();
-  const t = STRINGS[locale];
-  const totalCount = total.certified + total.legacy;
-  const visibleCount = visible.certified + visible.legacy;
-  if (totalCount === 0) return null;
-
-  const summary =
-    total.certified > 0 && total.legacy > 0
-      ? t.combined(
-          visibleCount,
-          totalCount,
-          visible.certified,
-          total.certified,
-          visible.legacy,
-          total.legacy,
-        )
-      : total.certified > 0
-        ? t.single(visible.certified, total.certified, t.validated)
-        : t.single(visible.legacy, total.legacy, t.historical);
-
-  const controls: string[] = [];
-  if (bestPerSku) controls.push(t.bestPerSku);
-  if (optimalOnly) controls.push(t.optimalOnly);
-  const reduction =
-    visibleCount >= totalCount
-      ? null
-      : controls.length > 0
-        ? t.controlsEnabled(joinControls(controls, locale))
-        : t.reducedBySelections;
-
-  return (
-    <div
-      data-testid="measured-power-summary"
-      className="no-export mt-2 flex flex-wrap gap-x-1 px-1 text-2xs leading-relaxed text-muted-foreground"
-    >
-      <span>{summary}</span>
-      {reduction && <span>{reduction}</span>}
-    </div>
-  );
-}
diff --git a/packages/app/src/components/inference/ui/PowerFitPanel.tsx b/packages/app/src/components/inference/ui/PowerFitPanel.tsx
index 470265074..deab9eb45 100644
--- a/packages/app/src/components/inference/ui/PowerFitPanel.tsx
+++ b/packages/app/src/components/inference/ui/PowerFitPanel.tsx
@@ -15,10 +15,6 @@ import { PowerPanelPlot, type PanelLine, type PanelMarker } from './PowerPanelPl
 const STRINGS = {
   en: {
     title: 'Power versus output rate (least-squares fit)',
-    method:
-      'Each source is fitted on its own observations: mean GPU power (W/GPU over all allocated GPUs) = P₀ + m × output rate (output tok/s per allocated GPU). Disaggregated output is spread over the prefill and decode GPUs. Solid lines span the observed range; the dashed segment only extends the line to zero output to read P₀.',
-    reading:
-      'P₀ is a fitted intercept, not measured idle power. m is the marginal GPU energy per output token (W per tok/s = J/token). R² describes this line only.',
     xAxis: 'Output rate (tok/s per allocated GPU)',
     yAxis: 'Mean GPU power (W/GPU)',
     source: 'Source',
@@ -35,10 +31,6 @@ const STRINGS = {
   },
   zh: {
     title: '功耗与输出速率（最小二乘拟合）',
-    method:
-      '每个数据源只用自己的观测值拟合：平均 GPU 功耗（按全部已分配 GPU 计的 W/GPU）= P₀ + m × 输出速率（每个已分配 GPU 的输出 tok/s）。分离式部署的输出量均摊到预填充和解码 GPU 上。实线覆盖观测范围；虚线仅将直线延伸到零输出处，用于读取 P₀。',
-    reading:
-      'P₀ 是拟合截距，不是实测空载功耗。m 是每个输出 token 的边际 GPU 能耗（W/(tok/s) = J/token）。R² 仅描述这条拟合直线。',
     xAxis: '输出速率（每个已分配 GPU 的 tok/s）',
     yAxis: '平均 GPU 功耗（W/GPU）',
     source: '数据源',
@@ -149,8 +141,7 @@ export default function PowerFitPanel({
       <Heading as="h3" level="card">
         {t.title}
       </Heading>
-      <p className="text-sm text-muted-foreground">{contextLabel}</p>
-      <p className="text-xs text-muted-foreground">{t.method}</p>
+      <p className="export-only hidden text-sm text-muted-foreground">{contextLabel}</p>
       {fits.length === 0 ? (
         <p className="py-6 text-sm text-muted-foreground">{t.empty}</p>
       ) : (
@@ -217,7 +208,6 @@ export default function PowerFitPanel({
               </tbody>
             </table>
           </div>
-          <p className="text-xs text-muted-foreground">{t.reading}</p>
           <div className="max-h-0 overflow-hidden">
             <div id={`${sectionId}-export`} className="p-4" />
           </div>
diff --git a/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx b/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
deleted file mode 100644
index f08575523..000000000
--- a/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
+++ /dev/null
@@ -1,368 +0,0 @@
-'use client';
-
-import { useMemo } from 'react';
-import { useInferenceData, useInferenceFilters } from '../InferenceContext';
-import {
-  isMeasuredEnergyConfigKey,
-  isPowerBasisConfigKey,
-  metricOptionTitle,
-  POWER_BASIS_METRIC_CONFIG_KEYS,
-  type MetricKey,
-} from '../metric-registry';
-import { getMeasuredMetricConfig } from '../measured-metric-config';
-import type { InferenceData } from '../types';
-import { powerBasisNormalization } from '@/lib/power-basis';
-import { matchesQuickFilters } from '../utils/quickFilters';
-import {
-  powerMetricAvailability,
-  powerMetricState,
-  type PowerAvailabilityState,
-} from '../utils/power-metric-availability';
-import { useUnofficialRun } from '@/components/unofficial-run-provider';
-import { hardwareKeyMatchesAnyBase } from '@/lib/constants';
-import { useLocale } from '@/lib/use-locale';
-import { track } from '@/lib/analytics';
-
-const STRINGS = {
-  en: {
-    title: 'PowerX availability',
-    scope:
-      'Current workload and hardware selection, before Optimal Only. Includes visible unofficial runs.',
-    loading: 'Updating measurement availability…',
-    none: 'No benchmark points match this selection.',
-    summary: (available: number, total: number) =>
-      `${available} of ${total} points have this metric`,
-    labels: {
-      strict: 'Validated · schema 2',
-      validated: 'Validated · other or missing schema',
-      unverified: 'No validation verdict',
-      invalid: 'Validation failed',
-      inapplicable: 'No separate worker pools',
-      ambiguous: 'Whole-deployment energy schema unavailable',
-      missing: 'Metric not reported',
-    },
-    basisLabels: {
-      available: 'Value available',
-      noSpec: 'No published spec for this hardware',
-      noThroughput: 'No output throughput reported',
-      noNormalization: 'Whole-deployment GPU count unavailable for this disaggregated row',
-      noTelemetry: 'No validated GPU telemetry',
-      invalid: 'Validation failed',
-      modelWorkload: 'Chassis model covers 8K / 1K only',
-      modelHardware: 'Hardware not in the chassis power model',
-      modelUnsupported: 'Chassis model unsupported for this deployment',
-    },
-    note: 'A missing verdict does not establish age or validity. Prefill/decode metrics measure separate worker pools. Missing values are never replaced with zero or TDP estimates.',
-    all: 'Availability of all measured metrics',
-    evidence: 'Selected metric: source details',
-    run: 'Source run',
-  },
-  zh: {
-    title: 'PowerX 指标可用性',
-    scope: '按当前工作负载与硬件选择统计，不受“仅最优”影响，包含已显示的非官方运行。',
-    loading: '正在更新指标可用性…',
-    none: '当前选择没有匹配的基准测试数据点。',
-    summary: (available: number, total: number) =>
-      `${total} 个数据点中有 ${available} 个提供此指标`,
-    labels: {
-      strict: '已验证 · schema 2',
-      validated: '已验证 · 其他或未标注 schema',
-      unverified: '未提供验证结论',
-      invalid: '验证失败',
-      inapplicable: '无独立 worker 池',
-      ambiguous: '缺少整个部署的能耗 schema',
-      missing: '未提供此指标',
-    },
-    basisLabels: {
-      available: '有数值',
-      noSpec: '该硬件没有公开的规格参数',
-      noThroughput: '未报告输出吞吐量',
-      noNormalization: '无法确定该分离式部署的 GPU 总数',
-      noTelemetry: '没有已验证的 GPU 遥测',
-      invalid: '验证失败',
-      modelWorkload: '机箱功耗模型仅覆盖 8K / 1K',
-      modelHardware: '硬件不在机箱功耗模型范围内',
-      modelUnsupported: '机箱功耗模型不支持此部署',
-    },
-    note: '缺少验证结论不能判断数据新旧或有效性。prefill/decode 指标仅衡量独立 worker 池。缺失值不会被替换为零或 TDP 估算值。',
-    all: '所有实测指标的可用性',
-    evidence: '当前指标的来源详情',
-    run: '来源运行',
-  },
-} as const;
-
-/**
- * Why a point lacks a derived power boundary (lib/power-basis.ts). Provisioned
- * boundaries are spec constants, so their watts exist for any registered
- * hardware and their energy additionally needs output throughput plus, for
- * disaggregated rows, the whole-deployment GPU count that
- * `powerBasisNormalization` recovers only for fixed-sequence runs with integer
- * prefill/decode counts. The modeled boundary is measured telemetry carried
- * through the chassis model, so it inherits the telemetry verdict and the
- * model's own unsupported reasons.
- */
-const POWER_BASIS_AVAILABILITY_STATES = [
-  'available',
-  'noSpec',
-  'noThroughput',
-  'noNormalization',
-  'noTelemetry',
-  'invalid',
-  'modelWorkload',
-  'modelHardware',
-  'modelUnsupported',
-] as const;
-export type PowerBasisAvailabilityState = (typeof POWER_BASIS_AVAILABILITY_STATES)[number];
-
-const hasFiniteValue = (point: InferenceData, key: MetricKey): boolean => {
-  const value = point[key];
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'y' in value &&
-    typeof value.y === 'number' &&
-    Number.isFinite(value.y)
-  );
-};
-
-export function powerBasisState(
-  point: InferenceData,
-  configKey: string,
-): PowerBasisAvailabilityState {
-  const key = configKey.replace(/^y_/u, '') as MetricKey;
-  if (hasFiniteValue(point, key)) return 'available';
-  const config = getMeasuredMetricConfig(configKey);
-  if (config?.basis === 'utility-modeled') {
-    if (point.power_valid === 0) return 'invalid';
-    const model = point.modeledSystemPower;
-    if (model?.status === 'unsupported') {
-      if (model.reason === 'workload') return 'modelWorkload';
-      if (model.reason === 'hardware') return 'modelHardware';
-      if (model.reason === 'telemetry') return 'noTelemetry';
-      return 'modelUnsupported';
-    }
-    // A supported model without a plotted value means B1 is absent (B4 follows B1).
-    return 'noTelemetry';
-  }
-  // Provisioned energy needs the watts sibling plus the whole-deployment
-  // normalization; the same helper that withheld the value says which half is
-  // missing, so the explanation cannot drift from the formula.
-  const wattsKey = (
-    config?.basis === 'gpu-provisioned' ? 'gpuProvisionedWatts' : 'utilityProvisionedWatts'
-  ) satisfies MetricKey;
-  if (!hasFiniteValue(point, wattsKey)) return 'noSpec';
-  const perGpu = point.output_tput_per_gpu;
-  if (typeof perGpu !== 'number' || !Number.isFinite(perGpu) || perGpu <= 0) return 'noThroughput';
-  // Throughput exists, so only the disaggregated GPU count can be missing.
-  // Chart points may lack the counts an aggregate entry always has; an
-  // unknown count is exactly the "unavailable" case the helper reports.
-  const { allocatedGpus } = powerBasisNormalization({
-    output_tput_per_gpu: perGpu,
-    disagg: point.disagg ?? false,
-    benchmark_type: point.benchmark_type,
-    num_prefill_gpu: point.num_prefill_gpu ?? Number.NaN,
-    num_decode_gpu: point.num_decode_gpu ?? Number.NaN,
-  });
-  return allocatedGpus === null ? 'noNormalization' : 'noThroughput';
-}
-
-function powerBasisAvailability(points: readonly InferenceData[], metric: string) {
-  const counts = Object.fromEntries(
-    POWER_BASIS_AVAILABILITY_STATES.map((state) => [state, 0]),
-  ) as Record<PowerBasisAvailabilityState, number>;
-  for (const point of points) counts[powerBasisState(point, metric)]++;
-  return { metric, counts, available: counts.available, total: points.length };
-}
-
-export function PowerMetricAvailabilityPanel({
-  points,
-  metric,
-  onSelect,
-  loading = false,
-}: {
-  points: readonly InferenceData[];
-  metric: string;
-  onSelect: (metric: string) => void;
-  loading?: boolean;
-}) {
-  const locale = useLocale();
-  const t = STRINGS[locale];
-  const availability = useMemo(
-    () => [
-      ...powerMetricAvailability(points),
-      ...POWER_BASIS_METRIC_CONFIG_KEYS.map((key) => powerBasisAvailability(points, key)),
-    ],
-    [points],
-  );
-  const selected = availability.find((entry) => entry.metric === metric);
-  if (!selected) return null;
-  const isBasis = isPowerBasisConfigKey(metric);
-  const stateOf = (point: InferenceData) =>
-    isBasis ? powerBasisState(point, metric) : powerMetricState(point, metric);
-  // The two dictionaries overlap on `invalid`; the selected metric, not the
-  // key, decides which copy applies so the measured strings stay untouched.
-  const labelOf = (state: PowerAvailabilityState | PowerBasisAvailabilityState) =>
-    isBasis
-      ? t.basisLabels[state as PowerBasisAvailabilityState]
-      : t.labels[state as PowerAvailabilityState];
-  const sources = new Map<
-    string,
-    {
-      point: InferenceData;
-      state: PowerAvailabilityState | PowerBasisAvailabilityState;
-      count: number;
-    }
-  >();
-  for (const point of points) {
-    const state = stateOf(point);
-    if (state === 'strict' || state === 'available') continue;
-    const key = JSON.stringify([point.hwKey, point.run_url, state, point.power_invalid_reasons]);
-    const group = sources.get(key);
-    if (group) group.count++;
-    else sources.set(key, { point, state, count: 1 });
-  }
-  return (
-    <div
-      data-testid="power-metric-availability"
-      className="space-y-2 text-xs text-muted-foreground"
-    >
-      <p className="font-medium text-foreground">
-        {t.title}:{' '}
-        {loading
-          ? t.loading
-          : points.length > 0
-            ? t.summary(selected.available, selected.total)
-            : t.none}
-      </p>
-      {!loading && (
-        <>
-          <p>{t.scope}</p>
-          <p>
-            {Object.entries(selected.counts)
-              .filter(([, count]) => count > 0)
-              .map(
-                ([state, count]) =>
-                  `${labelOf(state as PowerAvailabilityState | PowerBasisAvailabilityState)}: ${count}`,
-              )
-              .join(' · ')}
-          </p>
-          <details
-            onToggle={(event) => {
-              if (event.currentTarget.open) track('inference_power_availability_opened');
-            }}
-          >
-            <summary className="cursor-pointer">{t.all}</summary>
-            <ul className="mt-2 space-y-1">
-              {availability.map((entry) => (
-                <li key={entry.metric}>
-                  <button
-                    type="button"
-                    className="text-left underline underline-offset-2"
-                    onClick={() => onSelect(entry.metric)}
-                  >
-                    {metricOptionTitle(entry.metric.slice(2) as MetricKey, locale)}:{' '}
-                    {entry.available}/{entry.total}
-                  </button>
-                </li>
-              ))}
-            </ul>
-            <p className="mt-2">{t.note}</p>
-          </details>
-          {sources.size > 0 && (
-            <details>
-              <summary className="cursor-pointer">{t.evidence}</summary>
-              <ul className="mt-2 max-h-48 space-y-2 overflow-auto">
-                {[...sources.values()].map(({ point, state, count }, index) => (
-                  <li key={index}>
-                    {point.hwKey}: {labelOf(state)} ({count})
-                    {point.power_invalid_reasons?.length
-                      ? ` · ${point.power_invalid_reasons.join(', ')}`
-                      : ''}
-                    {point.power_audit?.source ? ` · ${point.power_audit.source}` : ''}
-                    {point.run_url &&
-                      /^https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/actions\/runs\/\d+(?:\/attempts\/\d+)?$/u.test(
-                        point.run_url,
-                      ) && (
-                        <>
-                          {' '}
-                          ·{' '}
-                          <a
-                            href={point.run_url}
-                            target="_blank"
-                            rel="noreferrer"
-                            className="underline"
-                          >
-                            {t.run}
-                          </a>
-                        </>
-                      )}
-                  </li>
-                ))}
-              </ul>
-            </details>
-          )}
-        </>
-      )}
-    </div>
-  );
-}
-
-/** Reuse pre-metric rows, including overlays: absent power must not erase its own explanation. */
-export function PowerMetricAvailability({
-  metric,
-  onSelect,
-}: {
-  metric: string;
-  onSelect: (metric: string) => void;
-}) {
-  const { selectionPoints = [], loading, refreshing } = useInferenceData();
-  const {
-    selectedModel,
-    selectedSequence,
-    selectedPrecisions,
-    activeHwTypes,
-    quickFilters,
-    compareGpuPair,
-  } = useInferenceFilters();
-  const { getOverlayData, activeOverlayHwTypes, isUnofficialRun, localOfficialOverride } =
-    useUnofficialRun();
-  const points = useMemo(() => {
-    const officialHw = isUnofficialRun ? (localOfficialOverride ?? activeHwTypes) : activeHwTypes;
-    const official = selectionPoints.filter(
-      (point) =>
-        selectedPrecisions.includes(point.precision) && officialHw.has(String(point.hwKey)),
-    );
-    const overlay = getOverlayData?.(selectedModel, selectedSequence, 'interactivity')?.data ?? [];
-    return [
-      ...official,
-      ...overlay.filter(
-        (point) =>
-          selectedPrecisions.includes(point.precision) &&
-          activeOverlayHwTypes.has(String(point.hwKey)) &&
-          matchesQuickFilters(point, quickFilters) &&
-          (!compareGpuPair || hardwareKeyMatchesAnyBase(String(point.hwKey), compareGpuPair)),
-      ),
-    ];
-  }, [
-    selectionPoints,
-    selectedPrecisions,
-    activeHwTypes,
-    getOverlayData,
-    selectedModel,
-    selectedSequence,
-    activeOverlayHwTypes,
-    isUnofficialRun,
-    localOfficialOverride,
-    quickFilters,
-    compareGpuPair,
-  ]);
-  if (!isMeasuredEnergyConfigKey(metric) && !isPowerBasisConfigKey(metric)) return null;
-  return (
-    <PowerMetricAvailabilityPanel
-      points={points}
-      metric={metric}
-      onSelect={onSelect}
-      loading={loading || refreshing}
-    />
-  );
-}
diff --git a/packages/app/src/components/inference/ui/PowerRoleGroup.tsx b/packages/app/src/components/inference/ui/PowerRoleGroup.tsx
index 7fedb94a1..e8ce4cef6 100644
--- a/packages/app/src/components/inference/ui/PowerRoleGroup.tsx
+++ b/packages/app/src/components/inference/ui/PowerRoleGroup.tsx
@@ -23,8 +23,6 @@ type RolePanelId = 'power' | 'local-energy' | 'output-energy' | 'share';
 const STRINGS = {
   en: {
     title: 'Prefill and decode roles',
-    method:
-      'Validated disaggregated observations only. Each panel names its denominator. Missing role telemetry is omitted, never drawn as zero.',
     empty: 'No validated prefill/decode telemetry is available for these filters.',
     panelEmpty: 'These observations do not report this role figure.',
     roles: { prefill: 'Prefill', decode: 'Decode', total: 'Prefill + decode' },
@@ -60,8 +58,6 @@ const STRINGS = {
   },
   zh: {
     title: '预填充与解码角色',
-    method:
-      '仅包含经过验证的分离式部署观测值。每个面板都注明了分母。缺少角色遥测数据的点不绘制，不会按 0 处理。',
     empty: '当前筛选条件下没有经过验证的预填充 / 解码遥测数据。',
     panelEmpty: '这些观测值没有报告该角色指标。',
     roles: { prefill: '预填充', decode: '解码', total: '预填充 + 解码' },
@@ -279,8 +275,7 @@ export default function PowerRoleGroup({
       <Heading as="h3" level="card">
         {t.title}
       </Heading>
-      <p className="text-sm text-muted-foreground">{contextLabel}</p>
-      <p className="text-xs text-muted-foreground">{t.method}</p>
+      <p className="export-only hidden text-sm text-muted-foreground">{contextLabel}</p>
       {points.length > 0 ? (
         <>
           <div className="flex flex-wrap gap-x-5 gap-y-2 text-sm">
diff --git a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
index 15ba274cc..e0299efca 100644
--- a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
+++ b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
@@ -36,12 +36,6 @@ const STRINGS = {
     target: 'Target',
     change: 'Change',
     title: 'Power, throughput and energy at the same service point',
-    method:
-      'Change = (comparator ÷ baseline − 1) × 100%. A negative energy change means lower energy use. Matches the selected axis only; other latencies may differ.',
-    interpolation:
-      'Within each source, raw quantities are linearly interpolated between neighboring observations, then compared. No extrapolation. Larger markers show the selected target. Lines connect the derived comparisons; they are not additional measurements.',
-    targetHelp:
-      'Enter a target within both source ranges to inspect values and bracketing observations.',
     concurrency:
       'Concurrency is a load diagnostic, not equal service. Select interactivity, TTFT or end-to-end latency for the equal-service comparison; the table below pairs observations at each concurrency.',
     metric: 'Metric',
@@ -64,11 +58,6 @@ const STRINGS = {
     target: '目标值',
     change: '变化',
     title: '相同服务指标下的功耗、吞吐量与能耗',
-    method:
-      '变化 =（对比对象 ÷ 基准 − 1）× 100%。能耗变化率为负表示能耗更低。只匹配所选横轴，其他延迟可能不同。',
-    interpolation:
-      '各数据源在相邻观测点间对原始数值进行线性插值，再计算变化率；不做外推。大圆点标记所选目标值。连线连接推导出的比较结果，不代表额外实测。',
-    targetHelp: '输入两个数据源范围内的目标值，查看数值及插值两端的观测点。',
     concurrency:
       '并发数用于分析负载，并不代表相同服务水平。相同服务水平的比较请选择交互性、首 token 延迟或端到端延迟；下表按各并发数配对观测值。',
     metric: '指标',
@@ -350,12 +339,7 @@ export default function PowerServiceComparison({
               <Heading as="h3" level="card">
                 {t.title}
               </Heading>
-              <p className="text-sm text-muted-foreground">{contextLabel}</p>
-              <p className="text-sm text-muted-foreground">{t.method}</p>
-              <p className="break-words text-sm">
-                {t.baseline}: {sourceLabel(base)} → {t.comparator}: {sourceLabel(peer)}
-              </p>
-
+              <p className="export-only hidden text-sm text-muted-foreground">{contextLabel}</p>
               <div className="flex flex-wrap gap-x-5 gap-y-2 text-sm">
                 {METRICS.map((key, index) => (
                   <span key={key} className="inline-flex items-center gap-2">
@@ -393,7 +377,6 @@ export default function PowerServiceComparison({
               ) : (
                 <p className="py-6 text-sm text-muted-foreground">{t.empty}</p>
               )}
-              <p className="text-xs text-muted-foreground">{t.interpolation}</p>
               <div className="max-h-0 overflow-hidden">
                 <div id={`${chartId}-service-export`} className="p-4" />
               </div>
@@ -414,7 +397,7 @@ export default function PowerServiceComparison({
                   data-testid="equal-service-target"
                 />
               </label>
-              {comparison ? (
+              {comparison && (
                 <div className="min-w-0">
                   <table
                     className="w-full table-fixed break-words text-left text-sm"
@@ -451,8 +434,6 @@ export default function PowerServiceComparison({
                     </tbody>
                   </table>
                 </div>
-              ) : (
-                <p className="text-xs text-muted-foreground">{t.targetHelp}</p>
               )}
             </section>
           )}
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index 6bb77e5a8..8ea9fbe13 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -79,8 +79,6 @@ import {
   traceKeyRunId,
   tracePools,
   windowPhase,
-  type MissingTrace,
-  type MissingTraceReason,
   type PoolSizeGroup,
   type PowerPool,
   type PowerPoolRole,
@@ -97,8 +95,6 @@ export const POWER_TIMELINE_MAX_RUNS = 4;
 const HIT_POINTS_PER_TRACE = 200;
 /** Above this many visible traces the `c<conc>` end labels would only overlap. */
 const MAX_LABELED_TRACES = 40;
-/** Up to this many undrawn configs are named individually; beyond, per hardware. */
-const MAX_LISTED_MISSING = 8;
 const CHART_HEIGHT = 600;
 const MARGIN = { top: 24, right: 84, bottom: 60, left: 64 };
 
@@ -118,8 +114,6 @@ const STRINGS = {
       `${count} trace${count === 1 ? '' : 's'} omitted: no valid serving-window bounds.`,
     missingFocus:
       'The selected trace is unavailable for these filters or has no retained telemetry.',
-    methodWindow:
-      'One-second means of GPU-board power inside each recorded validated serving window; window boundaries are not interpolated. Dashed lines: rated TDP from the hardware registry.',
     xWall: 'Time (UTC)',
     xElapsed: 'Time since telemetry start (m:ss)',
     perGpu: 'One line per GPU',
@@ -133,17 +127,6 @@ const STRINGS = {
     loading: (runs: number) =>
       `Loading GPU telemetry for ${runs} run${runs === 1 ? '' : 's'}… (may take a minute)`,
     loadError: (runId: string, message: string) => `Run ${runId}: ${message}`,
-    missing: (missing: number, total: number) =>
-      `${missing} of ${total} measured configs have no telemetry trace and are not drawn.`,
-    missingReason: {
-      'no-source': (count: number) =>
-        `${count} predate per-config telemetry provenance in the benchmark row`,
-      'no-run': (count: number) => `${count} carry no workflow run`,
-      'run-not-fetched': (count: number) => `${count} come from runs that were not loaded`,
-      'not-in-run': (count: number) =>
-        `${count} have no gpu_metrics artifact or power-audit bundle in their run (expired, or another collector)`,
-    } satisfies Record<MissingTraceReason, (count: number) => string>,
-    missingUndrawn: 'Not drawn',
     noTraces:
       'No telemetry traces for the visible hardware. Enable a series in the legend or choose another date.',
     noArtifacts:
@@ -151,10 +134,6 @@ const STRINGS = {
     droppedRuns: (runs: number) =>
       `Telemetry from ${runs} more run${runs === 1 ? '' : 's'} was not loaded (limit ${POWER_TIMELINE_MAX_RUNS} runs per chart).`,
     telemetry: 'Telemetry',
-    method:
-      'One-second means of per-GPU board power (nvidia-smi / amd-smi, or DCGM on Slurm / Dynamo runs) over the whole benchmark job; the emphasized segment is the validated window behind the measured average. Dashed lines: rated TDP per hardware from the hardware registry.',
-    methodPools:
-      'In pool mode each line is the summed power of one worker-role pool (prefill or decode GPUs) and the dashed references are pool size × rated TDP.',
     instructions:
       'Shift+Scroll to zoom horizontally · Drag to pan · Double-click to reset · Click a point to pin tooltip',
     dismiss: 'Click elsewhere to dismiss',
@@ -198,8 +177,6 @@ const STRINGS = {
     windowOnlyHelp: '仅显示已记录的有效服务窗口内保留的采样点；缺少有效窗口边界的曲线不绘制。',
     missingWindow: (count: number) => `${count} 条曲线缺少有效服务窗口边界，未绘制。`,
     missingFocus: '所选曲线不符合当前筛选条件，或没有保留的遥测数据。',
-    methodWindow:
-      '显示各有效服务窗口内的 GPU 板卡功耗一秒平均值，窗口边界不作插值。虚线为硬件注册表中的额定 TDP。',
     xWall: '时间（UTC）',
     xElapsed: '距遥测开始的时间（分:秒）',
     perGpu: '每个 GPU 一条线',
@@ -212,25 +189,11 @@ const STRINGS = {
       '按硬件注册表中每 GPU 的全电源配置（all-in）市电功率绘制虚线参考（SemiAnalysis 数据中心行业模型）。默认关闭，因为它会压缩曲线的纵向分辨率。',
     loading: (runs: number) => `正在加载 ${runs} 个运行的 GPU 遥测数据……（可能需要约一分钟）`,
     loadError: (runId: string, message: string) => `运行 ${runId}：${message}`,
-    missing: (missing: number, total: number) =>
-      `${total} 个有实测值的配置中有 ${missing} 个没有遥测曲线，未绘制。`,
-    missingReason: {
-      'no-source': (count: number) => `${count} 个的基准测试行早于按配置记录的遥测来源`,
-      'no-run': (count: number) => `${count} 个没有工作流运行信息`,
-      'run-not-fetched': (count: number) => `${count} 个来自未加载的运行`,
-      'not-in-run': (count: number) =>
-        `${count} 个在其运行中没有 gpu_metrics 产物或 power-audit 数据包（产物已过期，或使用其他采集器）`,
-    } satisfies Record<MissingTraceReason, (count: number) => string>,
-    missingUndrawn: '未绘制',
     noTraces: '当前可见硬件没有遥测曲线。请在图例中启用一个系列或选择其他日期。',
     noArtifacts: '这些数据点早于按配置上传的遥测产物，因此没有可用的时间线。',
     droppedRuns: (runs: number) =>
       `另有 ${runs} 个运行的遥测数据未加载（每张图表最多 ${POWER_TIMELINE_MAX_RUNS} 个运行）。`,
     telemetry: '遥测来源',
-    method:
-      '整个基准测试任务期间每个 GPU 板卡功耗（nvidia-smi / amd-smi，Slurm / Dynamo 运行为 DCGM）的一秒平均值；加粗段为实测平均值所依据的有效测量窗口。虚线：硬件注册表中各硬件的额定 TDP。',
-    methodPools:
-      '在 GPU 池模式下，每条线是一个 worker 角色池（预填充或解码 GPU）的功耗总和，虚线参考为池内 GPU 数量 × 额定 TDP。',
     instructions: 'Shift+滚轮横向缩放 · 拖动平移 · 双击重置 · 点击数据点固定提示框',
     dismiss: '点击其他区域关闭',
     phase: {
@@ -696,33 +659,6 @@ function drawReferenceLines(
   });
 }
 
-/** Reasons, then the undrawn configs (named when few, counted per hardware when many). */
-function describeMissing(
-  missing: readonly MissingTrace[],
-  t: (typeof STRINGS)[keyof typeof STRINGS],
-  hardwareLabel: (point: InferenceData) => string,
-): string {
-  const reasons = new Map<MissingTraceReason, number>();
-  for (const { reason } of missing) reasons.set(reason, (reasons.get(reason) ?? 0) + 1);
-  const reasonText = [...reasons.entries()]
-    .map(([reason, count]) => t.missingReason[reason](count))
-    .join('; ');
-  let list: string;
-  if (missing.length <= MAX_LISTED_MISSING) {
-    list = missing
-      .map(({ point }) => `${hardwareLabel(point)} ${traceConfigLabel(point)}`)
-      .join(' · ');
-  } else {
-    const perHardware = new Map<string, number>();
-    for (const { point } of missing) {
-      const label = hardwareLabel(point);
-      perHardware.set(label, (perHardware.get(label) ?? 0) + 1);
-    }
-    list = [...perHardware.entries()].map(([label, count]) => `${label} ×${count}`).join(' · ');
-  }
-  return `${reasonText}. ${t.missingUndrawn}: ${list}`;
-}
-
 export default function PowerTimeline({
   chartId,
   data,
@@ -1577,21 +1513,12 @@ export default function PowerTimeline({
         {focusKey && !focusedTrace && loadingRuns === 0 && (
           <p data-testid="power-timeline-focus-missing">{t.missingFocus}</p>
         )}
-        {missingWindows > 0 && (
-          <p data-testid="power-timeline-window-missing">{t.missingWindow(missingWindows)}</p>
-        )}
         {errors.map(({ request, error }) => (
           <p key={request.runId} className="text-destructive" role="alert">
             {t.loadError(request.runId, error.message)}
           </p>
         ))}
         {droppedRuns > 0 && <p>{t.droppedRuns(droppedRuns)}</p>}
-        {loadingRuns === 0 && missing.length > 0 && traces.length > 0 && (
-          <p data-testid="power-timeline-missing">
-            {t.missing(missing.length, traces.length + missing.length)}{' '}
-            {describeMissing(missing, t, hardwareLabel)}
-          </p>
-        )}
         {runInfos.length > 0 && (
           <p data-testid="power-timeline-source">
             {t.telemetry}:{' '}
@@ -1611,8 +1538,6 @@ export default function PowerTimeline({
             ))}
           </p>
         )}
-        <p>{windowOnly ? t.methodWindow : t.method}</p>
-        {hasPools && <p>{t.methodPools}</p>}
       </div>
       {loadingRuns === 0 && visibleTraces.length > 0 && (
         <PowerTimelineSummary
diff --git a/packages/app/src/components/inference/ui/PowerTimelineSummary.tsx b/packages/app/src/components/inference/ui/PowerTimelineSummary.tsx
index 968bc43ba..41e49ccef 100644
--- a/packages/app/src/components/inference/ui/PowerTimelineSummary.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimelineSummary.tsx
@@ -36,8 +36,6 @@ const STRINGS = {
     attempt: (attempt: number) => `attempt ${attempt}`,
     unofficial: 'unofficial',
     noWindow: 'Not recorded',
-    method: (bucket: number | null) =>
-      `Validated averages are the benchmark row’s figures, not recomputed here. Peak is the highest ${bucket === null ? '' : `${bucket}-s `}sum of the pool’s GPUs inside the recorded validated window, as drawn; buckets missing a pool GPU are skipped. Pool TDP = GPUs × rated TDP from the hardware registry. The telemetry source is per run: database when every requested series was stored, GitHub artifact fallback when any had to be read live.`,
   },
   zh: {
     title: '有效测量窗口汇总',
@@ -56,8 +54,6 @@ const STRINGS = {
     attempt: (attempt: number) => `第 ${attempt} 次尝试`,
     unofficial: '非官方',
     noWindow: '未记录',
-    method: (bucket: number | null) =>
-      `有效窗口平均值取自基准测试记录，此处不重新计算。峰值是在已记录的有效测量窗口内，${bucket === null ? '' : `按 ${bucket} 秒区间`}对该池各 GPU 功耗求和后的最大值，与图中曲线一致；缺少任一 GPU 采样的区间不计入。池 TDP = GPU 数 × 硬件注册表中的额定 TDP。遥测来源按运行标注：所有请求的序列都已入库时为数据库；只要有序列需要实时读取，就标为 GitHub 产物回退。`,
   },
 };
 
@@ -103,7 +99,6 @@ export default function PowerTimelineSummary({
       })),
     [traces],
   );
-  const buckets = [...new Set(rows.map((row) => row.summary.bucketSeconds))];
   return (
     <section className="min-w-0 space-y-2 px-1" data-testid="power-timeline-summary">
       <h3 className="text-sm font-medium">{t.title}</h3>
@@ -189,9 +184,6 @@ export default function PowerTimelineSummary({
           })}
         </table>
       </div>
-      <p className="text-xs text-muted-foreground">
-        {t.method(buckets.length === 1 ? buckets[0] : null)}
-      </p>
     </section>
   );
 }
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.decoration.test.tsx b/packages/app/src/components/inference/ui/ScatterGraph.decoration.test.tsx
index cd77b5e09..f70037913 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.decoration.test.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.decoration.test.tsx
@@ -127,41 +127,6 @@ describe('ScatterGraph toggle decoration', () => {
     unmount();
   });
 
-  it('rings legacy-power points only on Measured Energy axes', () => {
-    const legacy = {
-      ...point('h100', 'fp8', 10, 100, 1),
-      power_tier: 'legacy',
-    } as InferenceData;
-    const certified = {
-      ...point('h100', 'fp8', 20, 200, 2),
-      power_tier: 'certified',
-    } as InferenceData;
-    const tierless = point('h100', 'fp8', 40, 400, 4);
-
-    inferenceState.current = {
-      ...baseInferenceState(),
-      selectedYAxisMetric: 'y_measuredAvgPower',
-    };
-    const measured = mountChart({ data: [legacy, certified, tierless] });
-    const groups = dotGroups(measured.container);
-
-    expect(groups[0].querySelector('.legacy-power-ring')).not.toBeNull();
-    expect(groups[1].querySelector('.legacy-power-ring')).toBeNull();
-    expect(groups[2].querySelector('.legacy-power-ring')).toBeNull();
-    // The legend key lives in ChartDisplay's axis-metric footer, not the chart.
-    expect(measured.container.querySelector('[data-testid="legacy-power-key"]')).toBeNull();
-    measured.unmount();
-
-    // Non-measured axis: the same legacy point renders without a ring.
-    inferenceState.current = {
-      ...baseInferenceState(),
-      selectedYAxisMetric: 'y',
-    };
-    const throughput = mountChart({ data: [legacy, certified, tierless] });
-    expect(throughput.container.querySelectorAll('.legacy-power-ring')).toHaveLength(0);
-    throughput.unmount();
-  });
-
   it('reads current trace availability without changing metric identity', () => {
     const agenticPoint = {
       ...point('h100', 'fp8', 20, 200, 2),
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.overlay.test.tsx b/packages/app/src/components/inference/ui/ScatterGraph.overlay.test.tsx
index 13f930f08..22d68c48a 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.overlay.test.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.overlay.test.tsx
@@ -214,17 +214,7 @@ describe('ScatterGraph unofficial overlays', () => {
         const visible = showAllMeasurements || datum.x !== 20;
         expect(group.style.opacity).toBe(visible ? '1' : '0');
         expect(group.style.pointerEvents).toBe(visible ? 'auto' : 'none');
-        expect(Boolean(group.querySelector('.legacy-power-ring'))).toBe(
-          datum.power_tier === 'legacy',
-        );
       }
-      expect(
-        container.querySelector('[data-testid="measured-power-summary"]')?.textContent,
-      ).toContain(
-        showAllMeasurements
-          ? 'Showing 9 of 9 measured points: 3/3 validated · 6/6 historical.'
-          : 'Showing 6 of 9 measured points: 3/3 validated · 3/6 historical.',
-      );
       expect(curves.map((curve) => curve.getAttribute('d'))).toEqual(paths);
       expect(axes.map((axis) => axis.innerHTML)).toEqual(axisGeometry);
       expect(groups.map((group) => group.getAttribute('transform'))).toEqual(positions);
@@ -233,38 +223,6 @@ describe('ScatterGraph unofficial overlays', () => {
     unmount();
   });
 
-  it('includes unofficial measured points in the validated/historical coverage summary', () => {
-    const runUrl = 'https://github.com/o/r/actions/runs/123';
-    const overlayPoints = [
-      { ...point('h100', 'fp8', 30, 300, 2), power_tier: 'certified', run_url: runUrl },
-      { ...point('h100', 'fp8', 35, 350, 4), power_tier: 'legacy', run_url: runUrl },
-    ] as InferenceData[];
-    inferenceState.current = {
-      ...baseInferenceState(),
-      selectedYAxisMetric: 'y_measuredJPerOutputToken',
-    };
-    overlayState.current = {
-      ...baseOverlayState(),
-      isUnofficialRun: true,
-      activeOverlayHwTypes: new Set(['h100']),
-      allOverlayHwTypes: new Set(['h100']),
-      runIndexByUrl: { [runUrl]: 0 },
-      unofficialRunInfos: [{ id: '123', branch: 'test-branch', url: runUrl }],
-    };
-
-    const { container, unmount } = mountChart({
-      overlayData: {
-        data: overlayPoints,
-        hardwareConfig: HARDWARE_CONFIG,
-      } as unknown as Parameters<typeof ScatterGraph>[0]['overlayData'],
-    });
-
-    expect(
-      container.querySelector('[data-testid="measured-power-summary"]')?.textContent,
-    ).toContain('Showing 2 of 2 measured points: 1/1 validated · 1/1 historical.');
-    unmount();
-  });
-
   it('keeps unofficial-run overlay markers rendered through official toggles', () => {
     const overlayPoints = [point('h100', 'fp8', 30, 300, 2), point('h100', 'fp8', 35, 350, 4)].map(
       (p) => ({ ...p, run_url: 'https://github.com/o/r/actions/runs/123' }),
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 8873cddd0..170b52cb8 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -164,15 +164,7 @@ import {
 import FrontierPointsPanel from '@/components/inference/ui/FrontierPointsPanel';
 import LegendPointsDialog from '@/components/inference/ui/LegendPointsDialog';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
-import { renderLegacyPowerRing } from '@/components/inference/utils/legacy-power-marker';
-import {
-  countPowerTiers,
-  MeasuredPowerSummary,
-} from '@/components/inference/ui/MeasuredPowerSummary';
-import {
-  isMeasuredEnergyConfigKey,
-  isRoleLocalMeasuredEnergyConfigKey,
-} from '@/components/inference/metric-registry';
+import { isRoleLocalMeasuredEnergyConfigKey } from '@/components/inference/metric-registry';
 import { buildLegendPointsRows } from '@/components/inference/utils/legend-points-table';
 import { groupConcurrencySeries } from '@/components/inference/utils/concurrency-series';
 import { resolveScatterXAxisScale } from '@/components/inference/utils/x-axis-scale';
@@ -454,10 +446,6 @@ const SCATTER_STRINGS = {
     optimalInfo: 'Optimal points form the Pareto frontier for the selected axes.',
     powerBoundaryInfo:
       'Show only points on the upper measured power boundary. Turn off to show all measurements; the boundary stays the same. This is a power-load boundary, not an energy-efficiency frontier.',
-    powerCurves:
-      'Smooth lines trace the upper power boundary across tested configurations. Dots are measured; lines are interpolated, not efficiency frontiers.',
-    powerOptimal:
-      'A power Pareto frontier can contain a single point. Turn off Optimal Only to show the upper power boundary.',
     labels: 'Labels',
     highContrast: 'High Contrast',
     parallelismLabels: 'Parallelism Labels',
@@ -494,9 +482,6 @@ const SCATTER_STRINGS = {
     optimalInfo: '最优点构成当前所选坐标轴的 Pareto 前沿。',
     powerBoundaryInfo:
       '仅显示实测功率上边界上的点。关闭后显示全部测量点，边界曲线保持不变。这是功率负载边界，不是能效前沿。',
-    powerCurves:
-      '平滑曲线勾勒各测试配置的功耗上边界。数据点来自实测，曲线通过插值得到，不代表能效 Pareto 前沿。',
-    powerOptimal: '功耗的 Pareto 前沿可能只有一个点。关闭“仅最优”即可查看功耗上边界。',
     labels: '标签',
     highContrast: '高对比度',
     parallelismLabels: '并行配置标签',
@@ -648,9 +633,6 @@ const ScatterGraph = React.memo(
     const ephemeralUrlState = useEphemeralUrlState();
     const costLimit = chartDefinition.y_cost_limit ?? 0;
     const latencyLimit = chartDefinition.y_latency_limit ?? 0;
-    // Legacy-power rings decorate points only while a Measured Energy y-axis
-    // is selected (see legacy-power-marker.ts).
-    const isMeasuredEnergyAxis = isMeasuredEnergyConfigKey(selectedYAxisMetric);
 
     const {
       isUnofficialRun,
@@ -1901,31 +1883,6 @@ const ScatterGraph = React.memo(
       hiddenPowerVariants,
     ]);
 
-    const powerTierCounts = useMemo(() => {
-      // Comparison clones re-plot the same measurements; count each once.
-      const officialTotal = pointsData.filter(
-        (point) => !point.powerVariant && selectedPrecisions.includes(point.precision),
-      );
-      const overlayTotal = processedOverlayData.filter(
-        (point) => !point.powerVariant && selectedPrecisions.includes(point.precision),
-      );
-      const officialVisible = officialTotal.filter(isPointVisible);
-      const overlayVisible = overlayTotal.filter(
-        (point) => activeOverlayHwTypes.has(String(point.hwKey)) && isOverlayPointVisible(point),
-      );
-      return {
-        total: countPowerTiers([...officialTotal, ...overlayTotal]),
-        visible: countPowerTiers([...officialVisible, ...overlayVisible]),
-      };
-    }, [
-      pointsData,
-      processedOverlayData,
-      selectedPrecisions,
-      isPointVisible,
-      activeOverlayHwTypes,
-      isOverlayPointVisible,
-    ]);
-
     // --- Legend hover highlight ---
     const isRooflineVisible = useCallback(
       (el: SVGElement) => {
@@ -3543,15 +3500,14 @@ const ScatterGraph = React.memo(
                   overlayRunColor(overlayRunIndex(d.run_url ?? null, runIndexByUrl)),
                 );
 
-              // Match official points: KV offload and the measured-axis
-              // legacy-power ring are the only persistent point decorations.
-              // Decode method remains in the tooltip.
+              // Match official points: KV offload is the only persistent point
+              // decoration. Decode method remains in the tooltip.
               overlayPoints.each(function (d) {
-                const overlayStroke = overlayRunColor(
-                  overlayRunIndex(d.run_url ?? null, runIndexByUrl),
+                renderOffloadHalo(
+                  d3.select(this),
+                  d,
+                  overlayRunColor(overlayRunIndex(d.run_url ?? null, runIndexByUrl)),
                 );
-                renderOffloadHalo(d3.select(this), d, overlayStroke);
-                renderLegacyPowerRing(d3.select(this), d, isMeasuredEnergyAxis, overlayStroke);
               });
 
               updateOverlayLabels(zoomGroup);
@@ -3893,7 +3849,6 @@ const ScatterGraph = React.memo(
       yLabel,
       selectedYAxisMetric,
       powerCompareBaseId,
-      isMeasuredEnergyAxis,
       chartDefinition,
       locale,
       drawPerfRuler,
@@ -3917,10 +3872,8 @@ const ScatterGraph = React.memo(
         zoomGroup.selectAll('.dot-group').style('transition', 'opacity 150ms ease');
 
         // Offload halo: dashed ring on every point that used KV offload (Pareto or not).
-        // Legacy-power ring: dotted ring on unvalidated telemetry, measured axes only.
         zoomGroup.selectAll<SVGGElement, InferenceData>('.dot-group').each(function (d) {
           renderOffloadHalo(d3.select(this), d, 'var(--foreground)');
-          renderLegacyPowerRing(d3.select(this), d, isMeasuredEnergyAxis, 'var(--foreground)');
         });
 
         avoidPointLabelCollisions(zoomGroup);
@@ -3950,9 +3903,6 @@ const ScatterGraph = React.memo(
         optimalPointKeys,
         getCssColor,
         resolveColor,
-        // A metric-only change must re-run the decoration pass so legacy-power
-        // rings appear/disappear with the Measured Energy axis selection.
-        isMeasuredEnergyAxis,
       ],
     );
 
@@ -3988,9 +3938,8 @@ const ScatterGraph = React.memo(
           color,
         );
         // A precision toggle may replace and append the visible SVG shape.
-        // Keep the decorations above that shape after the swap.
+        // Keep the offload halo above that shape after the swap.
         point.selectAll('.offload-halo').raise();
-        point.selectAll('.legacy-power-ring').raise();
       });
 
       // Overlay points keep their X marker and run-derived color. Only their
@@ -4343,18 +4292,14 @@ const ScatterGraph = React.memo(
           testId="scatter-graph"
           grabCursor={true}
           caption={
-            isPowerAxis || isConcurrencyAxis ? (
+            isConcurrencyAxis ? (
               <>
                 {caption}
                 <p
-                  data-testid="power-curve-description"
+                  data-testid="concurrency-curve-description"
                   className="mt-2 text-2xs text-muted-foreground"
                 >
-                  {isConcurrencyAxis
-                    ? legendT.concurrencyCurves
-                    : showPowerEnvelope
-                      ? legendT.powerCurves
-                      : legendT.powerOptimal}
+                  {legendT.concurrencyCurves}
                 </p>
               </>
             ) : (
@@ -4715,14 +4660,6 @@ const ScatterGraph = React.memo(
             />
           }
         />
-        {isMeasuredEnergyAxis && (
-          <MeasuredPowerSummary
-            total={powerTierCounts.total}
-            visible={powerTierCounts.visible}
-            bestPerSku={!isConcurrencyAxis && bestPerSku}
-            optimalOnly={hideNonOptimal}
-          />
-        )}
         <QuickFiltersDialog
           open={quickFiltersOpen}
           onOpenChange={setQuickFiltersOpen}
@@ -4759,8 +4696,6 @@ const ScatterGraph = React.memo(
             frontier={globalFrontier}
             xLabel={xLabel}
             yLabel={yLabel}
-            maximizeX={maximizeParetoX}
-            maximizeY={maximizeParetoY}
             overlayPoints={processedOverlayData}
             hardwareLabel={frontierHardwareLabel}
             hardwareColor={frontierHardwareColor}
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
index f02df8334..1cc0dffe6 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
@@ -1,6 +1,10 @@
 import { describe, expect, it } from 'vitest';
 import type { InferenceData } from '../types';
-import { buildEqualServiceComparison, equalServiceSourceKey } from './equal-service-comparison';
+import {
+  buildEqualServiceComparison,
+  equalServiceSourceKey,
+  getEqualServiceSources,
+} from './equal-service-comparison';
 
 const metric = (y: number) => ({ y, roof: false });
 function point(overrides: Partial<InferenceData> = {}): InferenceData {
@@ -143,4 +147,19 @@ describe('equal-service comparison', () => {
       }).metrics.outputTokensPerSecond.reason,
     ).toBe('missing-metric');
   });
+
+  it('labels sources by hardware and date, adding only the details that tell them apart', () => {
+    const sources = getEqualServiceSources([
+      point({ id: 1 }),
+      point({ id: 2, physicalChips: 8, decode_tp: 8 }),
+      point({ id: 3, run_url: 'https://example.invalid/runs/3' }),
+      point({ id: 4, hwKey: 'b300_sglang', run_url: 'https://example.invalid/runs/2' }),
+    ]);
+    expect(sources.map((source) => source.label)).toEqual([
+      'B200 (SGLang) · 2026-09-23 · Single-node · GPU4 · TP4 · EP? · Run #1',
+      'B200 (SGLang) · 2026-09-23 · Single-node · GPU8 · TP8 · EP?',
+      'B200 (SGLang) · 2026-09-23 · Single-node · GPU4 · TP4 · EP? · Run #3',
+      'B300 (SGLang) · 2026-09-23',
+    ]);
+  });
 });
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.ts b/packages/app/src/components/inference/utils/equal-service-comparison.ts
index 0ef533672..a4f2fefa6 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.ts
@@ -1,6 +1,9 @@
 import type { AggDataEntry, InferenceData } from '../types';
 import { chipCounts } from '@/lib/chip-counts';
+import { getHardwareConfig } from '@/lib/constants';
 import { isPositive, powerBasisNormalization } from '@/lib/power-basis';
+import { getDisplayLabel } from '@/lib/utils';
+import { runIdFromUrl } from './powerTimeline';
 import { reconstructedRoleEnergy, type ReconstructedRoleEnergy } from './role-energy';
 import { pointTopologyKey, topologyLabel } from './topology-filter';
 
@@ -85,37 +88,75 @@ export function equalServiceSourceKey(point: InferenceData): string {
 }
 
 const SOURCE_LABEL_WORDS = {
-  en: { point: 'Point', attempt: (attempt: unknown) => `Attempt ${attempt}`, recipe: 'Recipe' },
-  zh: { point: '数据点', attempt: (attempt: unknown) => `第 ${attempt} 次尝试`, recipe: '配方' },
+  en: {
+    point: 'Point',
+    run: (id: string) => `Run #${id}`,
+    attempt: (attempt: unknown) => `Attempt ${attempt}`,
+    recipe: 'Recipe',
+  },
+  zh: {
+    point: '数据点',
+    run: (id: string) => `运行 #${id}`,
+    attempt: (attempt: unknown) => `第 ${attempt} 次尝试`,
+    recipe: '配方',
+  },
 };
 
+/**
+ * Hardware and date, plus only the details that tell otherwise identical
+ * sources apart, in this order; the opaque key stays the exact identity.
+ */
+function sourceLabels(points: readonly InferenceData[], locale: 'en' | 'zh'): string[] {
+  const words = SOURCE_LABEL_WORDS[locale];
+  const details: ((point: InferenceData, group: readonly InferenceData[]) => string | null)[] = [
+    (point) => point.precision.toUpperCase(),
+    (point, group) => topologyLabel(pointTopologyKey(point), locale, group.map(pointTopologyKey)),
+    (point) => {
+      const runId = runIdFromUrl(point.run_url);
+      return runId ? words.run(runId) : null;
+    },
+    (point) => ('run_attempt' in point ? words.attempt(point.run_attempt) : null),
+    (point) =>
+      point.recipe_fingerprint ? `${words.recipe} ${point.recipe_fingerprint.slice(0, 8)}` : null,
+    (point) => point.image ?? null,
+    (point) => `${words.point} ${point.id ?? '?'}`,
+  ];
+  const labels = points.map((point) => {
+    const hardware = getHardwareConfig(point.hwKey);
+    return [
+      hardware.name === 'unknown' ? point.hwKey : getDisplayLabel(hardware),
+      point.actualDate ?? point.date,
+    ].join(' · ');
+  });
+  for (const detail of details) {
+    const groups = new Map<string, number[]>();
+    labels.forEach((label, index) => groups.set(label, [...(groups.get(label) ?? []), index]));
+    for (const indices of groups.values()) {
+      if (indices.length < 2) continue;
+      const group = indices.map((index) => points[index]);
+      const values = group.map((point) => detail(point, group));
+      if (new Set(values).size < 2) continue;
+      indices.forEach((index, position) => {
+        if (values[position]) labels[index] += ` · ${values[position]}`;
+      });
+    }
+  }
+  return labels;
+}
+
 /** Labels are English by default: the read-only API has no locale. */
 export function getEqualServiceSources(
   points: readonly InferenceData[],
   locale: 'en' | 'zh' = 'en',
 ): EqualServiceSource[] {
-  const words = SOURCE_LABEL_WORDS[locale];
-  const sources = new Map(
-    observedPoints(points).map((point) => [equalServiceSourceKey(point), point]),
+  const sources = [
+    ...new Map(observedPoints(points).map((point) => [equalServiceSourceKey(point), point])),
+  ].sort(([a], [b]) => a.localeCompare(b));
+  const labels = sourceLabels(
+    sources.map(([, point]) => point),
+    locale,
   );
-  const topologies = [...sources.values()].map(pointTopologyKey);
-  return [...sources]
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([key, point]) => ({
-      key,
-      label: [
-        point.hwKey,
-        point.precision.toUpperCase(),
-        topologyLabel(pointTopologyKey(point), locale, topologies),
-        point.actualDate ?? point.date,
-        point.run_url ?? `${words.point} ${point.id ?? '?'}`,
-        'run_attempt' in point ? words.attempt(point.run_attempt) : null,
-        point.recipe_fingerprint ? `${words.recipe} ${point.recipe_fingerprint}` : null,
-        point.image ?? null,
-      ]
-        .filter(Boolean)
-        .join(' · '),
-    }));
+  return sources.map(([key], index) => ({ key, label: labels[index] }));
 }
 
 function deploymentOutput(point: InferenceData): number | undefined {
diff --git a/packages/app/src/components/inference/utils/frontier-points.ts b/packages/app/src/components/inference/utils/frontier-points.ts
index 4b0a4c01e..8af690d21 100644
--- a/packages/app/src/components/inference/utils/frontier-points.ts
+++ b/packages/app/src/components/inference/utils/frontier-points.ts
@@ -1,47 +1,12 @@
 import type { InferenceData } from '../types';
-import { equalServiceSourceKey } from './equal-service-comparison';
 import { runAttemptFromUrl, runIdFromUrl } from './powerTimeline';
 import { pointTopologyKey } from './topology-filter';
 
 /**
- * Provenance of a cross-platform frontier (PowerX Figure 16). The frontier is
- * the chart's own global non-dominated set; this only makes the comparison
- * scope explicit: how many observations, sources, runs, topologies and images
- * competed, and which hardware owns the frontier.
+ * CSV export of a cross-platform frontier (PowerX Figure 16): the chart's own
+ * global non-dominated set, one row per observation with its provenance.
+ * Stable export columns: identity first, then plotted coordinates and provenance.
  */
-export interface FrontierScope {
-  /** Observations that competed for the frontier. */
-  eligible: number;
-  sources: number;
-  runs: number;
-  topologies: number;
-  images: number;
-}
-
-export function frontierScope(eligible: readonly InferenceData[]): FrontierScope {
-  const distinct = (key: (point: InferenceData) => string | null | undefined) =>
-    new Set(eligible.map(key).filter((value) => value !== null && value !== undefined)).size;
-  return {
-    eligible: eligible.length,
-    sources: distinct(equalServiceSourceKey),
-    runs: distinct((point) => point.run_url),
-    topologies: distinct(pointTopologyKey),
-    images: distinct((point) => point.image),
-  };
-}
-
-/** Frontier points per hardware key, most first; ties keep hardware order. */
-export function frontierHardwareCounts(
-  frontier: readonly InferenceData[],
-): { hwKey: string; count: number }[] {
-  const counts = new Map<string, number>();
-  for (const point of frontier) counts.set(point.hwKey, (counts.get(point.hwKey) ?? 0) + 1);
-  return [...counts]
-    .map(([hwKey, count]) => ({ hwKey, count }))
-    .toSorted((a, b) => b.count - a.count || a.hwKey.localeCompare(b.hwKey));
-}
-
-/** Stable export columns: identity first, then plotted coordinates and provenance. */
 export const FRONTIER_EXPORT_HEADERS = [
   'hardware',
   'framework',
diff --git a/packages/app/src/components/inference/utils/legacy-power-marker.ts b/packages/app/src/components/inference/utils/legacy-power-marker.ts
deleted file mode 100644
index b0a9ae92f..000000000
--- a/packages/app/src/components/inference/utils/legacy-power-marker.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import type * as d3 from 'd3';
-
-import type { InferenceData } from '@/components/inference/types';
-import {
-  LEGACY_POWER_RING_DASHARRAY,
-  LEGACY_POWER_RING_RADIUS,
-  LEGACY_POWER_RING_STROKE_WIDTH,
-} from '@/components/inference/ui/LegacyPowerLegendKey';
-
-/**
- * Dotted ring flagging measured-power telemetry without a producer validation
- * verdict (`power_tier === 'legacy'`). Drawn only while a Measured Energy
- * y-axis is selected; the join-on-empty-data pattern removes the ring when the
- * axis changes or the point's tier is not legacy.
- */
-export function renderLegacyPowerRing(
-  group: d3.Selection<SVGGElement, InferenceData, null, undefined>,
-  point: InferenceData,
-  isMeasuredAxis: boolean,
-  stroke: string,
-): void {
-  group
-    .selectAll<SVGCircleElement, boolean>('.legacy-power-ring')
-    .data(isMeasuredAxis && point.power_tier === 'legacy' ? [true] : [])
-    .join('circle')
-    .attr('class', 'legacy-power-ring')
-    .attr('r', LEGACY_POWER_RING_RADIUS)
-    .attr('fill', 'none')
-    .attr('stroke', stroke)
-    .attr('stroke-width', LEGACY_POWER_RING_STROKE_WIDTH)
-    .attr('stroke-dasharray', LEGACY_POWER_RING_DASHARRAY)
-    .attr('opacity', 0.9)
-    .attr('pointer-events', 'none');
-}
diff --git a/packages/app/src/components/inference/utils/power-metric-availability.test.ts b/packages/app/src/components/inference/utils/power-metric-availability.test.ts
deleted file mode 100644
index d63c225ce..000000000
--- a/packages/app/src/components/inference/utils/power-metric-availability.test.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { InferenceData } from '../types';
-import { powerMetricAvailability, powerMetricState } from './power-metric-availability';
-import { createMockInferenceData } from '../../../../cypress/support/mock-data';
-
-function point(overrides: Partial<InferenceData> = {}) {
-  return createMockInferenceData(overrides);
-}
-describe('PowerX availability', () => {
-  it('separates strict, validated unversioned, no verdict, invalid and missing without hiding zero', () => {
-    const values = { measuredAvgPower: { y: 0, roof: false } };
-    const rows = [
-      point({ ...values, power_valid: 1, power_metric_schema_version: 2 }),
-      point({ ...values, power_valid: 1 }),
-      point(values),
-      point({ power_valid: 0, ...values }),
-      point(),
-    ];
-    expect(
-      powerMetricAvailability(rows).find((row) => row.metric === 'y_measuredAvgPower'),
-    ).toMatchObject({
-      available: 3,
-      total: 5,
-      counts: { strict: 1, validated: 1, unverified: 1, invalid: 1, missing: 1 },
-    });
-  });
-  it('retains real role metrics while distinguishing shared pools and ambiguous old deployment energy', () => {
-    expect(powerMetricState(point(), 'y_measuredPrefillAvgPower')).toBe('inapplicable');
-    expect(
-      powerMetricState(
-        point({
-          disagg: true,
-          power_valid: 1,
-          power_metric_schema_version: 2,
-          measuredPrefillJPerInputToken: { y: 2, roof: false },
-        }),
-        'y_measuredPrefillJPerInputToken',
-      ),
-    ).toBe('strict');
-    expect(
-      powerMetricState(point({ disagg: true, power_valid: 1 }), 'y_measuredJPerInputToken'),
-    ).toBe('ambiguous');
-  });
-  it('counts the actual conversion and percentile fields independently', () => {
-    const rows = [
-      point({
-        power_valid: 1,
-        power_metric_schema_version: 2,
-        measuredWhPerSuccessfulQuery: { y: 1, roof: false },
-        measuredPowerPercentTdp: { y: 40, roof: false },
-      }),
-    ];
-    const byMetric = Object.fromEntries(
-      powerMetricAvailability(rows).map((row) => [row.metric, row.available]),
-    );
-    expect(byMetric.y_measuredWhPerSuccessfulQuery).toBe(1);
-    expect(byMetric.y_measuredPowerPercentTdp).toBe(1);
-    expect(byMetric.y_measuredP75Power).toBe(0);
-    expect(byMetric.y_measuredP90Power).toBe(0);
-  });
-});
diff --git a/packages/app/src/components/inference/utils/power-metric-availability.ts b/packages/app/src/components/inference/utils/power-metric-availability.ts
deleted file mode 100644
index 6a2e7882f..000000000
--- a/packages/app/src/components/inference/utils/power-metric-availability.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { MEASURED_ENERGY_METRIC_CONFIG_KEYS, isMetricKey } from '../metric-registry';
-import type { InferenceData } from '../types';
-
-export const POWER_AVAILABILITY_STATES = [
-  'strict',
-  'validated',
-  'unverified',
-  'invalid',
-  'inapplicable',
-  'ambiguous',
-  'missing',
-] as const;
-export type PowerAvailabilityState = (typeof POWER_AVAILABILITY_STATES)[number];
-export type PowerAvailabilityCounts = Record<PowerAvailabilityState, number>;
-const ROLE_METRICS = new Set([
-  'y_measuredPrefillAvgPower',
-  'y_measuredDecodeAvgPower',
-  'y_measuredPrefillJPerInputToken',
-  'y_measuredDecodeJPerOutputToken',
-]);
-const WHOLE_ENERGY_METRICS = new Set([
-  'y_measuredJPerInputToken',
-  'y_measuredJPerOutputToken',
-  'y_measuredJPerTotalToken',
-  'y_measuredJPerSuccessfulQuery',
-  'y_measuredWhPerSuccessfulQuery',
-]);
-
-/** Uses the chart's actual admitted field, so conversions and semantic gates agree. */
-export function powerMetricState(point: InferenceData, configKey: string): PowerAvailabilityState {
-  if (ROLE_METRICS.has(configKey) && !point.disagg) return 'inapplicable';
-  if (point.power_valid === 0) return 'invalid';
-  const key = configKey.replace(/^y_/u, '');
-  const value = isMetricKey(key) ? point[key] : undefined;
-  if (
-    value &&
-    typeof value === 'object' &&
-    'y' in value &&
-    typeof value.y === 'number' &&
-    Number.isFinite(value.y)
-  ) {
-    if (point.power_valid === 1)
-      return point.power_metric_schema_version === 2 ? 'strict' : 'validated';
-    return 'unverified';
-  }
-  if (
-    WHOLE_ENERGY_METRICS.has(configKey) &&
-    point.disagg &&
-    point.power_metric_schema_version !== 2
-  )
-    return 'ambiguous';
-  return 'missing';
-}
-
-export function powerMetricAvailability(points: readonly InferenceData[]) {
-  return [...MEASURED_ENERGY_METRIC_CONFIG_KEYS].map((metric) => {
-    const counts = Object.fromEntries(
-      POWER_AVAILABILITY_STATES.map((state) => [state, 0]),
-    ) as PowerAvailabilityCounts;
-    for (const point of points) counts[powerMetricState(point, metric)]++;
-    return {
-      metric,
-      counts,
-      available: counts.strict + counts.validated + counts.unverified,
-      total: points.length,
-    };
-  });
-}
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 4c17db4bf..544112b5d 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -814,7 +814,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/inference/utils/equal-service-comparison.ts',
-    sourceSha256: '8611179bb7230362e9aebd79b71d1f8240d8f8e69669ac9fd83c6f2a3e35caf0',
+    sourceSha256: '9a7989e04f0228983f5f1069b8e35e221d85561bd95fdfd1ba9e4210f42bb0c1',
     reviewArea: {
       en: 'Source-scoped equal-service interpolation, comparator-relative changes, endpoint provenance, prefill share projection and role points.',
       zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源、prefill 占比视图以及各角色数据点。',

From 37a75d65c11ead95d0cb476cc2534093473ca518 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 12:20:28 -0700
Subject: [PATCH 047/103] fix: explain missing measured power for chosen chip
 configs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Chip Config already follows the standard dashboard path; GB200/GB300 NVL72
DSR1 8K/1K rows carry no power telemetry, so Measured Power had nothing to
plot. The measured-axis empty state now says so. Best per SKU also keeps
the full selection when no config reports the metric, matching the rule
that metric coverage never narrows the selection.

中文：说明所选芯片配置缺少实测功耗的情况。芯片配置本身沿用仪表板的标准逻辑；
DSR1 8K/1K 的 GB200/GB300 NVL72 数据没有功耗遥测，因此实测功耗图表无点可画。
实测坐标轴的空状态现在会明确说明这一点。当没有任何配置提供该指标时，
“每个 SKU 仅显示最佳配置”会保留完整选择，符合“指标覆盖范围不收窄选择”的规则。
---
 docs/powerx-permanent-view.md                 |  2 ++
 .../app/cypress/e2e/inference-chart.cy.ts     | 27 +++++++++++++++++--
 .../components/inference/InferenceContext.tsx | 10 ++++---
 .../src/components/inference/ui/GPUGraph.tsx  | 13 +++++++--
 .../components/inference/ui/ScatterGraph.tsx  | 17 +++++++++---
 5 files changed, 58 insertions(+), 11 deletions(-)

diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 147e22875..cb9d0fc05 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -83,6 +83,8 @@ words, the PUE constant and the chassis-model revision so a screenshot records i
 The pinned tooltip's "Modeled system power" block (`tooltipUtils.ts` `modeledSystemPowerHTML`)
 renders only for `measured*` keys and `y_modeledChassisPowerPerGpu`, so on the boundary keys the
 caption is the only per-chart provenance; the caption does not promise more.
+When no point in the selection reports the selected telemetry axis, the chart's empty state says
+the selection has no measured GPU power (`noMeasuredDataHint`) instead of the generic hint.
 
 ## Article figure → share link
 
diff --git a/packages/app/cypress/e2e/inference-chart.cy.ts b/packages/app/cypress/e2e/inference-chart.cy.ts
index c23d42351..c2edf1376 100644
--- a/packages/app/cypress/e2e/inference-chart.cy.ts
+++ b/packages/app/cypress/e2e/inference-chart.cy.ts
@@ -55,8 +55,8 @@ const boundaryRows = (runUrl: string | null) =>
   }));
 
 function interceptMeasuredComparison(
-  official = measuredRows(null),
-  overlay = measuredRows(OVERLAY_RUN_URL),
+  official: object[] = measuredRows(null),
+  overlay: object[] = measuredRows(OVERLAY_RUN_URL),
 ) {
   cy.intercept('GET', '/api/v1/availability', { body: official.slice(0, 1) });
   cy.intercept('GET', '/api/v1/benchmarks*', { body: official });
@@ -633,6 +633,29 @@ it('replots measured settings for official and unofficial data and preserves ove
   assertMeasuredValues('.dot-group', [2, 3, 4, 5]);
 });
 
+it('says when chosen chip configs report no measured power, and plots them on other metrics', () => {
+  // The config has benchmarks but no power telemetry, like GB200/GB300 NVL72 on DSR1 8K/1K.
+  interceptMeasuredComparison(singleTurnRows(null), []);
+  cy.viewport(1440, 900);
+  cy.visit(
+    '/inference?g_model=DeepSeek-V4-Pro&i_seq=1k%2F1k&i_prec=fp4&i_metric=y_measuredAvgPower&i_gpus=b300_sglang',
+    { onBeforeLoad: unlockAgenticGate },
+  );
+  cy.get('[data-testid="gpu-multiselect"]').should('contain', 'B300 (SGLang)');
+  cy.get('[data-testid="scatter-empty-state"]')
+    .should('have.attr', 'data-reason', 'selection')
+    .and('contain', 'No measured GPU power is reported for this selection.');
+  cy.get('[data-testid="yaxis-metric-selector"]').click('right');
+  cy.contains('[data-slot="select-item"]', /^Token Throughput per Chip/u)
+    .scrollIntoView()
+    .click();
+  cy.get('[data-testid="scatter-empty-state"]').should('not.exist');
+  cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
+    'have.length.at.least',
+    1,
+  );
+});
+
 it('uses Optimal Only to filter power boundary dots without replacing official or overlay curves', () => {
   interceptMeasuredComparison(boundaryRows(null), boundaryRows(OVERLAY_RUN_URL));
   cy.viewport(1440, 900);
diff --git a/packages/app/src/components/inference/InferenceContext.tsx b/packages/app/src/components/inference/InferenceContext.tsx
index 4db326d7f..bbcaf77cf 100644
--- a/packages/app/src/components/inference/InferenceContext.tsx
+++ b/packages/app/src/components/inference/InferenceContext.tsx
@@ -1241,7 +1241,7 @@ export function InferenceProvider({
   const bestHwTypes = useMemo(() => {
     const wantedType = selectedXAxisMode === 'interactivity' ? 'interactivity' : 'e2e';
     const graph = graphs.find((candidate) => candidate.chartDefinition.chartType === wantedType);
-    if (!graph) return hwTypesWithData;
+    if (!graph) return selectableHwTypes;
     const direction =
       graph.chartDefinition[
         `${selectedYAxisMetric}_roofline` as keyof typeof graph.chartDefinition
@@ -1252,11 +1252,13 @@ export function InferenceProvider({
       direction !== 'lower_left' &&
       direction !== 'lower_right'
     ) {
-      return hwTypesWithData;
+      return selectableHwTypes;
     }
     const best = bestSeriesPerSku(graph.data, direction);
-    return best.size > 0 ? best : hwTypesWithData;
-  }, [graphs, hwTypesWithData, selectedXAxisMode, selectedYAxisMetric]);
+    // With nothing to rank (no config reports this metric), keep the whole
+    // selection universe: metric coverage never narrows the selection.
+    return best.size > 0 ? best : selectableHwTypes;
+  }, [graphs, selectableHwTypes, selectedXAxisMode, selectedYAxisMetric]);
 
   const setBestPerSkuAndApply = useCallback(
     (enabled: boolean, options?: { applySelection?: boolean }) => {
diff --git a/packages/app/src/components/inference/ui/GPUGraph.tsx b/packages/app/src/components/inference/ui/GPUGraph.tsx
index de1b6462e..5b59f4fe5 100644
--- a/packages/app/src/components/inference/ui/GPUGraph.tsx
+++ b/packages/app/src/components/inference/ui/GPUGraph.tsx
@@ -73,7 +73,10 @@ import {
 } from '@/components/inference/utils/knownIssueAnnotations';
 import { matchKnownConfigIssues, pointMatchesIssue } from '@/lib/known-issues';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
-import { isRoleLocalMeasuredEnergyConfigKey } from '@/components/inference/metric-registry';
+import {
+  isMeasuredEnergyConfigKey,
+  isRoleLocalMeasuredEnergyConfigKey,
+} from '@/components/inference/metric-registry';
 import {
   clampIsoX,
   clearPerfRulers,
@@ -170,6 +173,8 @@ const GPU_STRINGS = {
     noDataHint: 'Please change the model, sequence, precision, date range or chip selection.',
     noRoleEnergyDataHint:
       'This dataset does not report role-level prefill/decode energy. Choose a different model, scenario, precision, date, or measured-energy metric.',
+    noMeasuredDataHint:
+      'No measured GPU power is reported for this selection. Choose other chip configs, or a different model, scenario, precision or date.',
   },
   zh: {
     logScale: '对数缩放',
@@ -192,6 +197,8 @@ const GPU_STRINGS = {
     noDataHint: '请调整模型、序列长度、精度、日期范围或芯片选项。',
     noRoleEnergyDataHint:
       '当前数据集未提供 Prefill/Decode 各角色的能耗数据。请选择其他模型、场景、精度、日期或实测能耗指标。',
+    noMeasuredDataHint:
+      '当前选择没有实测 GPU 功耗数据。请选择其他芯片配置，或更换模型、场景、精度或日期。',
   },
 } as const;
 
@@ -268,7 +275,9 @@ const GPUGraph = React.memo(
     const showAllMeasurements = isMeasuredPowerAxis ? !hideNonOptimal : savedShowAllMeasurements;
     const noDataHint = isRoleLocalMeasuredEnergyConfigKey(selectedYAxisMetric)
       ? legendT.noRoleEnergyDataHint
-      : legendT.noDataHint;
+      : isMeasuredEnergyConfigKey(selectedYAxisMetric)
+        ? legendT.noMeasuredDataHint
+        : legendT.noDataHint;
     const ephemeralUrlState = useEphemeralUrlState();
     const { resolvedTheme } = useTheme();
     const chartRef = useRef<D3ChartHandle>(null);
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 170b52cb8..b2fd5e74c 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -164,7 +164,10 @@ import {
 import FrontierPointsPanel from '@/components/inference/ui/FrontierPointsPanel';
 import LegendPointsDialog from '@/components/inference/ui/LegendPointsDialog';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
-import { isRoleLocalMeasuredEnergyConfigKey } from '@/components/inference/metric-registry';
+import {
+  isMeasuredEnergyConfigKey,
+  isRoleLocalMeasuredEnergyConfigKey,
+} from '@/components/inference/metric-registry';
 import { buildLegendPointsRows } from '@/components/inference/utils/legend-points-table';
 import { groupConcurrencySeries } from '@/components/inference/utils/concurrency-series';
 import { resolveScatterXAxisScale } from '@/components/inference/utils/x-axis-scale';
@@ -465,6 +468,8 @@ const SCATTER_STRINGS = {
     noDataHint: 'Please change the model, sequence, precision, date range or chip selection.',
     noRoleEnergyDataHint:
       'This dataset does not report role-level prefill/decode energy. Choose a different model, scenario, precision, date, or measured-energy metric.',
+    noMeasuredDataHint:
+      'No measured GPU power is reported for this selection. Choose other chip configs, or a different model, scenario, precision or date.',
     unofficialTitle: (branch: string) => `UNOFFICIAL: ${branch}`,
     unofficialRun: 'UNOFFICIAL RUN',
     branch: 'Branch',
@@ -501,6 +506,8 @@ const SCATTER_STRINGS = {
     noDataHint: '请调整模型、序列长度、精度、日期范围或芯片选项。',
     noRoleEnergyDataHint:
       '当前数据集未提供 Prefill/Decode 各角色的能耗数据。请选择其他模型、场景、精度、日期或实测能耗指标。',
+    noMeasuredDataHint:
+      '当前选择没有实测 GPU 功耗数据。请选择其他芯片配置，或更换模型、场景、精度或日期。',
     unofficialTitle: (branch: string) => `非官方：${branch}`,
     unofficialRun: '非官方运行',
     branch: '分支',
@@ -4236,8 +4243,12 @@ const ScatterGraph = React.memo(
       <ScatterEmptyState
         reason={emptyReason}
         description={
-          emptyReason === 'selection' && isRoleLocalMeasuredEnergyConfigKey(selectedYAxisMetric)
-            ? legendT.noRoleEnergyDataHint
+          emptyReason === 'selection'
+            ? isRoleLocalMeasuredEnergyConfigKey(selectedYAxisMetric)
+              ? legendT.noRoleEnergyDataHint
+              : isMeasuredEnergyConfigKey(selectedYAxisMetric)
+                ? legendT.noMeasuredDataHint
+                : undefined
             : undefined
         }
         onShowChips={() => {

From 238977a4a3112b883c07b4db51cb20d76e5b76d2 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 12:20:44 -0700
Subject: [PATCH 048/103] test: update x-axis spec for concurrency and median
 labels
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Concurrency axis and the Service Statistic label shipped earlier in
this branch; the x-axis spec still expected the old option count and the
unprefixed "Interactivity" label.

中文：更新 X 轴测试，适配本分支已上线的“并发数”选项和带统计量前缀的坐标轴标签。
---
 packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts b/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts
index 114b1e2c0..4aba05b46 100644
--- a/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts
+++ b/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts
@@ -140,12 +140,12 @@ describe('X-Axis Mode Toggle (inference chart)', () => {
     interceptDerivedAgenticMetrics();
   });
 
-  it('defaults to Interactivity and offers all four full names in one axis dropdown', () => {
+  it('defaults to Interactivity and offers every full name in one axis dropdown', () => {
     cy.get('[data-testid="scenario-selector"]').should('contain.text', 'Agentic');
     cy.get('[data-testid="x-axis-mode-selector"]').should('contain.text', 'Interactivity');
     cy.get('[data-testid="x-axis-mode-buttons"]').should('not.exist');
     openXAxisMenu();
-    cy.get('[role="grid"] [data-select-option]').should('have.length', 4);
+    cy.get('[role="grid"] [data-select-option]').should('have.length', 5);
     cy.get('[data-testid="x-axis-mode-e2e-normalized-interactivity"]')
       .should('have.text', 'E2E Normalized Interactivity')
       .and('have.attr', 'aria-pressed', 'false');
@@ -479,11 +479,12 @@ describe('Label defaults for fixed-sequence scenarios', () => {
     cy.get('[data-testid="chart-figure"] h2').should('contain.text', 'Time To First Token');
   });
 
-  it('offers only the three supported axes for fixed sequences', () => {
+  it('offers only the four supported axes for fixed sequences', () => {
     interceptFixedSequenceData();
     cy.visit('/inference?i_seq=8k%2F1k');
     openXAxisMenu();
-    cy.get('[role="grid"] [data-select-option]').should('have.length', 3);
+    cy.get('[role="grid"] [data-select-option]').should('have.length', 4);
+    cy.get('[data-testid="x-axis-mode-concurrency"]').should('be.visible');
     cy.get('[data-testid="x-axis-mode-interactivity"]').should('be.visible');
     cy.get('[data-testid="x-axis-mode-e2e"]').should('be.visible');
     cy.get('[data-testid="x-axis-mode-ttft"]').should('be.visible');
@@ -586,8 +587,8 @@ const expectCoordinates = (selector: string, expected: number[]) => {
   });
 };
 const expectInteractivity = () => {
-  cy.get('#chart-0 .x-axis-label').should('have.text', 'Interactivity (tok/s/user)');
-  cy.get('[data-testid="chart-figure"] h2').should('contain.text', 'vs. Interactivity');
+  cy.get('#chart-0 .x-axis-label').should('have.text', 'Median Interactivity (tok/s/user)');
+  cy.get('[data-testid="chart-figure"] h2').should('contain.text', 'vs. Median Interactivity');
   expectCoordinates('.dot-group', [80, 40, 20]);
   expectCoordinates('.unofficial-overlay-pt', [60, 30]);
 };

From f6ede5d1473a57cdd9a350f35e47cc749cd3248c Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 12:27:45 -0700
Subject: [PATCH 049/103] fix: restore Best per SKU fallback for empty metrics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Falling back to every selectable config re-ran engine-conflict resolution
when no config reported the metric, which could raise a toast over an
empty chart. The empty selection is harmless now that the availability
panel is gone; the measured empty-state hint stays.

中文：恢复“每个 SKU 仅显示最佳配置”在指标无数据时的原有回退逻辑。改为回退到全部可选配置后，
一旦没有任何配置提供该指标，就会重新执行引擎冲突处理，可能在空图表上弹出提示。
可用性面板移除后，空选择已不再有副作用；实测空状态提示保持不变。
---
 .../app/src/components/inference/InferenceContext.tsx  | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/packages/app/src/components/inference/InferenceContext.tsx b/packages/app/src/components/inference/InferenceContext.tsx
index bbcaf77cf..4db326d7f 100644
--- a/packages/app/src/components/inference/InferenceContext.tsx
+++ b/packages/app/src/components/inference/InferenceContext.tsx
@@ -1241,7 +1241,7 @@ export function InferenceProvider({
   const bestHwTypes = useMemo(() => {
     const wantedType = selectedXAxisMode === 'interactivity' ? 'interactivity' : 'e2e';
     const graph = graphs.find((candidate) => candidate.chartDefinition.chartType === wantedType);
-    if (!graph) return selectableHwTypes;
+    if (!graph) return hwTypesWithData;
     const direction =
       graph.chartDefinition[
         `${selectedYAxisMetric}_roofline` as keyof typeof graph.chartDefinition
@@ -1252,13 +1252,11 @@ export function InferenceProvider({
       direction !== 'lower_left' &&
       direction !== 'lower_right'
     ) {
-      return selectableHwTypes;
+      return hwTypesWithData;
     }
     const best = bestSeriesPerSku(graph.data, direction);
-    // With nothing to rank (no config reports this metric), keep the whole
-    // selection universe: metric coverage never narrows the selection.
-    return best.size > 0 ? best : selectableHwTypes;
-  }, [graphs, selectableHwTypes, selectedXAxisMode, selectedYAxisMetric]);
+    return best.size > 0 ? best : hwTypesWithData;
+  }, [graphs, hwTypesWithData, selectedXAxisMode, selectedYAxisMetric]);
 
   const setBestPerSkuAndApply = useCallback(
     (enabled: boolean, options?: { applySelection?: boolean }) => {

From 08c21897b28294b8b17ea93239ca0a13ef995eeb Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 12:27:56 -0700
Subject: [PATCH 050/103] fix: name comparison sources in exported images
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The source selects are no-export, so exported same-service and
same-concurrency images no longer said which baseline and comparator
produced the numbers. Both panels now carry an export-only
"Baseline → Comparator" line; the screen is unchanged.

中文：在导出图片中标明对比数据源。数据源下拉框不参与导出，因此同服务水平与同并发对比的导出图片
无法看出基准和对比对象。两个面板现在都带有仅在导出时显示的“基准 → 对比对象”一行，屏幕显示不变。
---
 docs/powerx-permanent-view.md                            | 4 +++-
 .../cypress/component/power-service-comparison.cy.tsx    | 9 +++++++++
 .../components/inference/ui/MatchedConcurrencyTable.tsx  | 3 +++
 .../components/inference/ui/PowerServiceComparison.tsx   | 7 +++++++
 4 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index cb9d0fc05..72758f66b 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -309,7 +309,9 @@ source per exact run and recipe (`equalServiceSourceKey`), and colour overlay so
 - **Source labels** (`getEqualServiceSources`) read hardware and date, adding precision,
   topology, run, attempt, recipe, image or point only where two sources would otherwise look
   the same. The opaque key stays the exact identity.
-- Plots export PNG and CSV; the frontier table exports CSV only. The views API returns
+- Plots export PNG and CSV; the frontier table exports CSV only. Panel subtitles and the
+  baseline → comparator pair are export-only, so a PNG names its workload and sources while
+  the screen shows only the source selects. The views API returns
   `matchedConcurrency`, `rolePoints` and `powerFits`
   ([Dashboard read-only views](./dashboard-readonly-views.md#fixed-sequence-service-comparisons));
   it has no global-frontier parameter.
diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
index 56cf6be98..e1ab4eb39 100644
--- a/packages/app/cypress/component/power-service-comparison.cy.tsx
+++ b/packages/app/cypress/component/power-service-comparison.cy.tsx
@@ -101,6 +101,15 @@ describe('PowerServiceComparison', () => {
     cy.get('[data-testid="equal-service-comparator"]')
       .invoke('val')
       .should('contain', OVERLAY_RUN_URL);
+    // The selects are screen-only; exported images name the pair instead.
+    for (const pair of ['equal-service-pair', 'matched-concurrency-pair']) {
+      cy.get(`[data-testid="${pair}"]`)
+        .should('not.be.visible')
+        .and(
+          'have.text',
+          'Baseline: B200 (SGLang) · 2026-09-23 → Comparator: B300 (SGLang) · 2026-09-23',
+        );
+    }
     cy.get('[data-testid="matched-concurrency-row-8"]').should('exist');
   });
 });
diff --git a/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx b/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
index 88744ea99..f535542a2 100644
--- a/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
+++ b/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
@@ -138,6 +138,9 @@ export default function MatchedConcurrencyTable({
       <Heading as="h3" level="card">
         {t.title}
       </Heading>
+      <p className="export-only hidden break-words text-sm" data-testid="matched-concurrency-pair">
+        {t.baseline}: {sourceLabel(baseline)} → {t.comparator}: {sourceLabel(comparator)}
+      </p>
       {table.reason ? (
         <p className="text-sm text-muted-foreground">{t.unavailable}</p>
       ) : table.rows.length === 0 ? (
diff --git a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
index e0299efca..4324ff1c8 100644
--- a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
+++ b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
@@ -340,6 +340,13 @@ export default function PowerServiceComparison({
                 {t.title}
               </Heading>
               <p className="export-only hidden text-sm text-muted-foreground">{contextLabel}</p>
+              {/* The source selects are no-export, so exported images name the pair here. */}
+              <p
+                className="export-only hidden break-words text-sm"
+                data-testid="equal-service-pair"
+              >
+                {t.baseline}: {sourceLabel(base)} → {t.comparator}: {sourceLabel(peer)}
+              </p>
               <div className="flex flex-wrap gap-x-5 gap-y-2 text-sm">
                 {METRICS.map((key, index) => (
                   <span key={key} className="inline-flex items-center gap-2">

From d812b35cfb3f8c55130de09f245aadec4d987718 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 25 Sep 2026 19:49:54 +0000
Subject: [PATCH 051/103] fix(db): drop .js suffix from PowerX stats imports so
 Turbopack resolves them
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`packages/db/src/lib/gpu-metric-stats.ts` and
`packages/db/src/queries/gpu-metrics.ts` are bundled into the
`/api/v1/gpu-metrics-point` App Route. Turbopack does not rewrite
`.js`-suffixed relative specifiers to their `.ts` sources, so the
`bun run build` step of every E2E shard failed with
"Module not found: Can't resolve '../etl/gpu-metrics-csv.js'" and
"Can't resolve '../lib/gpu-metric-stats.js'". Use extensionless
specifiers, matching the other app-reachable db modules.

中文：`gpu-metric-stats.ts` 与 `queries/gpu-metrics.ts` 会被打包进
`/api/v1/gpu-metrics-point` 路由，Turbopack 不会把带 `.js` 后缀的相对
导入映射到 `.ts` 源文件，导致 E2E 各分片的 `bun run build` 报 Module not
found。改为不带扩展名的导入，与其他被应用引用的 db 模块保持一致。

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FxD3ovk3KPrcotWoeNuUAL
---
 packages/db/src/lib/gpu-metric-stats.ts | 2 +-
 packages/db/src/queries/gpu-metrics.ts  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/db/src/lib/gpu-metric-stats.ts b/packages/db/src/lib/gpu-metric-stats.ts
index 2cc2b5ee5..63bd4ec2a 100644
--- a/packages/db/src/lib/gpu-metric-stats.ts
+++ b/packages/db/src/lib/gpu-metric-stats.ts
@@ -2,7 +2,7 @@ import {
   computeGpuMetricStats,
   type GpuMetricSample,
   type GpuMetricStats,
-} from '../etl/gpu-metrics-csv.js';
+} from '../etl/gpu-metrics-csv';
 
 /** Bump whenever full-record digest definitions change. Independent of serving-window metrics. */
 export const GPU_STATS_VERSION = 1;
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
index aba55e497..38116afb4 100644
--- a/packages/db/src/queries/gpu-metrics.ts
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -12,7 +12,7 @@ import {
   computeStoredGpuMetricStats,
   statMetricColumn,
   type StoredGpuMetricSample,
-} from '../lib/gpu-metric-stats.js';
+} from '../lib/gpu-metric-stats';
 
 import type { DbClient } from '../connection.js';
 

From 12de0af3edd7e6a382cea68c38747893a35c029c Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 16:41:34 -0700
Subject: [PATCH 052/103] fix: keep unofficial runs, date toggles and
 concurrency in date comparison
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Date comparison dropped ?unofficialrun= rows, its Timeline ignored the
per-date legend, and the Concurrency axis fell back to the scatter
chart. GPUGraph now draws overlay runs in their run colour and dash and
splits concurrency sweeps per date, run and topology. The Timeline
shares its series colours and date toggles; table, CSV and panels
follow the same toggles.

中文：日期对比会丢失 ?unofficialrun= 数据，其 Timeline 忽略按日期的图例，并发数 X 轴会退回散点图。
GPUGraph 现在以运行配色和虚线绘制非官方运行，并按日期、运行和拓扑拆分并发扫描。
Timeline 沿用其序列配色和按日期显隐，表格、CSV 和面板也遵循同一套显隐。
---
 docs/d3-charts.md                             |   6 +-
 docs/dashboard-readonly-views.md              |  14 +
 docs/powerx-permanent-view.md                 |  18 +-
 docs/state-ownership.md                       |   4 +-
 .../app/cypress/component/gpu-graph.cy.tsx    | 223 +++++-
 .../cypress/component/power-timeline.cy.tsx   |  86 +++
 .../app/cypress/e2e/inference-chart.cy.ts     |  25 +
 .../inference/hooks/useComparisonSeries.ts    | 129 ++++
 .../inference/hooks/usePowerTraceAction.ts    |  56 ++
 .../components/inference/ui/ChartDisplay.tsx  |  72 +-
 .../src/components/inference/ui/GPUGraph.tsx  | 650 ++++++++++++------
 .../components/inference/ui/PowerTimeline.tsx | 147 +++-
 .../components/inference/ui/ScatterGraph.tsx  |  45 +-
 .../src/lib/d3-chart/layers/rooflines.test.ts |  32 +-
 .../app/src/lib/d3-chart/layers/rooflines.ts  |  23 +-
 15 files changed, 1197 insertions(+), 333 deletions(-)
 create mode 100644 packages/app/src/components/inference/hooks/useComparisonSeries.ts
 create mode 100644 packages/app/src/components/inference/hooks/usePowerTraceAction.ts

diff --git a/docs/d3-charts.md b/docs/d3-charts.md
index f38539689..8438b41db 100644
--- a/docs/d3-charts.md
+++ b/docs/d3-charts.md
@@ -130,7 +130,11 @@ Upper boundaries use monotone interpolation between unique-X vertices, including
 
 `groupConcurrencySeries` groups straight-line segments by hardware, precision, topology (`pointTopologyKey`), recipe fingerprint, date, run and power-comparison variant. It never joins TP4 to TP8 or 4P/4D to 16P/16D. A group with repeated concurrency values, or points without run provenance, stays as markers instead of being reduced to an arbitrary average or envelope. Markers retain their original values and identities. These segments connect observations; they do not establish a hardware-controlled comparison or estimate untested loads.
 
-Official and unofficial paths share this behavior. Concurrency history comparisons use `ScatterGraph` with independent run segments, not the performance-oriented `GPUGraph` path. Exact topology quick filters retain that topology's entire load sweep. Share URLs, tables and CSV exports preserve the selected `conc` coordinates.
+Official and unofficial paths share this behavior. Date comparisons stay on `GPUGraph` and split each compared (date, hardware) series and each unofficial run into the same segments, drawn with linear curves and without frontier, power envelope, Optimal Only or Perf Ruler; each series keeps one line label, on its longest segment. Exact topology quick filters retain that topology's entire load sweep. Share URLs, tables and CSV exports preserve the selected `conc` coordinates.
+
+### Unofficial runs in date comparisons
+
+`GPUGraph` plots `?unofficialrun=` rows next to the compared dates as their own (run, hardware) series, `overlay-run<index>_<hwKey>`. They pass the same precision, quick-filter and overlay-hardware (`activeOverlayHwTypes`) gates as `ScatterGraph`, draw as X markers in `overlayRunColor(runIndex)`, and their curves take `overlayRooflineDasharray(runIndex)` through the roofline layer's per-curve `getDasharray`. They are not date series, so `activeDates` toggles leave them on; the legend lists them first, one `UNOFFICIAL: <branch>` group per run, and dismissing the run removes them. Pinned overlay tooltips offer **View power trace**, which opens the comparison Timeline focused on that trace; official points keep **View PowerX**.
 
 ## Gradient Roofline Labels
 
diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 90e7cec14..a46347454 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -100,6 +100,14 @@ are unchanged by all six display settings. The reusable client helpers are
 `components/inference/utils/powerTimeline.ts`, and `sumPowerAt` in
 `components/gpu-power/power-series.ts`.
 
+Date comparisons are presentation-only as well. With compared dates, `/inference` keeps the
+date-comparison chart on every x-axis mode, including concurrency, draws `?unofficialrun=`
+rows beside the compared series, and the Timeline display follows the same per-date legend
+toggles and colours. The inference view already returns `comparisons` (one projection per
+`dates` or `start`/`end` entry) and `overlays` (one per unofficial run) for every `xmode`.
+The per-date toggles are renderer state, not query keys, so no API or OpenAPI contract
+change is required.
+
 ## Fixed-sequence service comparisons
 
 The inference view exposes the same mean/median selector as the dashboard through
@@ -215,6 +223,12 @@ GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全
 使用硬件注册表。原始遥测、全记录统计和 API 响应均不因这些显示设置而改变。
 响应使用 private, no-store，上游 503 保留为错误响应。
 
+日期对比同样只影响显示。选择对比日期后，`/inference` 在所有 X 轴模式（包括并发数）下都使用日期对比图，
+并与对比序列一同绘制 `?unofficialrun=` 数据；时间线显示沿用同一套按日期切换的图例和配色。
+只读 inference 视图已对每种 `xmode` 返回 `comparisons`（每个 `dates` 或 `start`/`end`
+条目一份投影）和 `overlays`（每个非官方运行一份）。按日期显隐属于渲染状态，不是查询参数，
+因此无需修改 API 或 OpenAPI 契约。
+
 `serviceSources` 中各数据源的 `label` 仅供显示，由硬件和日期组成；只有两个数据源无法区分时，
 才补充精度、拓扑、运行等信息。选择数据源时应使用其 `key`。
 
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 72758f66b..221c61c4e 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -221,6 +221,17 @@ config is `display: 'timeline'`.
   (`setUnifiedOverlaySelection`, `computeToggle` solo semantics) exactly as `ScatterGraph`
   does; the context's `toggleHwType` alone would change nothing visible there.
 
+- **Date comparison.** With chip configs and comparison dates selected, `ChartDisplay` passes
+  `comparison`, and official traces become the compared (date, chip config) series of the
+  date-comparison `GPUGraph`. `useComparisonSeries` gives both displays the same series, run
+  numbers and colours. The legend lists one row per series with a trace candidate, grouped
+  under its hardware; a click calls `toggleActiveDate` with the same solo semantics, and a
+  soloed date hides the other dates' traces. Overlay runs stay in one _Unofficial run_ group
+  in their run colour and still follow `activeOverlayHwTypes`. The tooltip header, the focus
+  chip and the summary's hardware column add the date or run
+  (`B200 (SGLang) · 2026-09-23`); end labels lead with it only while more than one entry is
+  visible (`2026-09-23 c1`).
+
 - **Drawing.** One trace per config, mean of its GPUs (legend switch: one line per GPU),
   coloured by hardware for official rows and by `overlayRunColor(runIndex)` for
   `?unofficialrun=` rows; legend toggles follow `activeHwTypes` / `activeOverlayHwTypes`
@@ -332,7 +343,12 @@ source per exact run and recipe (`equalServiceSourceKey`), and colour overlay so
   failure as 503, known missing hosts, and the retained-inventory recount before a CSV
   fallback.
 - `cypress/component/power-timeline.cy.tsx`, `power-compare.cy.tsx` — overlay-run colour and
-  the overlay hardware filter.
+  the overlay hardware filter; in date comparison, per-date trace colours, legend solo toggles
+  and date-prefixed end labels.
+- `cypress/component/gpu-graph.cy.tsx`, `cypress/e2e/inference-chart.cy.ts` and
+  `lib/d3-chart/layers/rooflines.test.ts` — `?unofficialrun=` runs stay on the date-comparison
+  `GPUGraph` in their run colour and dash on the interactivity and concurrency axes, per-curve
+  dashes survive display updates, and concurrency sweeps split per date, run and topology.
 - `utils/matched-concurrency.test.ts`, `utils/power-fit.test.ts`, `utils/powerTimeline.test.ts`
   — signed same-concurrency deltas, the least-squares fit and R², disaggregated fits on output
   per allocated GPU, and the peak pool power inside the validated window.
diff --git a/docs/state-ownership.md b/docs/state-ownership.md
index d6b1d39c5..9c4014ccc 100644
--- a/docs/state-ownership.md
+++ b/docs/state-ownership.md
@@ -319,8 +319,8 @@ How the GPU-across-time comparison works in the inference tab:
 2. `useChartData` (in `InferenceProvider`) calls `buildComparisonDates()` to deduplicate and exclude the main `effectiveRunDate`.
 3. `useQueries` fires one `useBenchmarks(model, date)` request per comparison date in parallel, alongside the main date query.
 4. **Date stamping**: Each row from a comparison query is overwritten with `{ date: comparisonDates[i], actualDate: r.date }`. The `actualDate` field preserves the real DB date. Without this stamp, `activeDates` (keyed by user-selected date strings like `2025-01-15_h100-sxm`) would never match the rows' `date` field, so the toggle set would have no effect.
-5. `activeDates` is a `Set<string>` of `${date}_${gpuKey}` composite keys. It is initialised to all IDs whenever `allDateIds` changes (effect at line 473). Users toggle individual overlays on/off.
-6. Rows from all dates are merged into a single `rows` array and passed through `transformBenchmarkRows` — the chart renders all of them on the same axes, coloured by GPU + date.
+5. `activeDates` is a `Set<string>` of `${date}_${gpuKey}` composite keys. It is initialised to all IDs whenever `allDateIds` changes (effect at line 473). Users toggle individual overlays on/off: the `GPUGraph` legend and, on the Measured Power Timeline display, the `PowerTimeline` legend both call `toggleActiveDate` (`computeToggle` solo semantics). `ChartDisplay`'s `visibleDateComparisonRows` applies the same set to the table, CSV export and PowerX analysis panels. `?unofficialrun=` rows are not date series, so `activeDates` never hides them; they follow `activeOverlayHwTypes`.
+6. Rows from all dates are merged into a single `rows` array and passed through `transformBenchmarkRows` — the chart renders all of them on the same axes, coloured by GPU + date. `useComparisonSeries` owns the series order, run numbers and colours, so `GPUGraph` and `PowerTimeline` draw one (date, GPU) pair in the same colour.
 
 **When the latest date is selected as the main run date**: `useChartData` maps the selected date to `''` if it equals `latestAvailableDate`, reusing the no-date query key from the materialized view rather than firing a duplicate request.
 
diff --git a/packages/app/cypress/component/gpu-graph.cy.tsx b/packages/app/cypress/component/gpu-graph.cy.tsx
index b19375402..3c8e7de13 100644
--- a/packages/app/cypress/component/gpu-graph.cy.tsx
+++ b/packages/app/cypress/component/gpu-graph.cy.tsx
@@ -1,19 +1,33 @@
 import GPUGraph from '@/components/inference/ui/GPUGraph';
 import { InferenceContextsProvider } from '@/components/inference/InferenceContext';
-import { useState } from 'react';
+import type { ChartDefinition, InferenceData } from '@/components/inference/types';
+import {
+  UnofficialRunContext,
+  type UnofficialRunContextType,
+} from '@/components/unofficial-run-provider';
+import { useState, type ReactElement } from 'react';
 import { mountWithProviders } from '../support/test-utils';
 import {
   createMockInferenceData,
   createMockChartDefinition,
   createMockHardwareConfig,
   createMockInferenceContextValues,
+  createMockUnofficialRunContext,
 } from '../support/mock-data';
 import { Precision, Sequence } from '@/lib/data-mappings';
+import { overlayRooflineDasharray, overlayRunColor } from '@/lib/overlay-run-style';
+import { computeToggle } from '@/lib/toggle-set';
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
 
 const defaultChartDef = createMockChartDefinition();
 const hwConfig = createMockHardwareConfig();
 
+// GPUGraph reads the unofficial-run context; no run is loaded unless a test says so.
+const mountGpuGraph = (
+  tree: ReactElement,
+  overrides: Parameters<typeof mountWithProviders>[1] = {},
+) => mountWithProviders(tree, { unofficial: {}, ...overrides });
+
 describe('GPUGraph', () => {
   it('renders SVG within chart container', () => {
     const data = [
@@ -26,7 +40,7 @@ describe('GPUGraph', () => {
       }),
     ];
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu"
@@ -53,7 +67,7 @@ describe('GPUGraph', () => {
   });
 
   it('shows empty state when data is empty', () => {
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-empty"
@@ -80,7 +94,7 @@ describe('GPUGraph', () => {
   });
 
   it('explains missing role-local energy in GPU comparison mode', () => {
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-role-energy-empty"
@@ -110,7 +124,7 @@ describe('GPUGraph', () => {
   });
 
   it('localizes the Chinese comparison empty state', () => {
-    mountWithProviders(
+    mountGpuGraph(
       <PathnameContext.Provider value="/zh/inference">
         <div style={{ width: 390, height: 600 }}>
           <GPUGraph
@@ -166,7 +180,7 @@ describe('GPUGraph', () => {
       }),
     ];
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-data"
@@ -219,7 +233,7 @@ describe('GPUGraph', () => {
       }),
     ];
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-agentic-decorations"
@@ -310,7 +324,7 @@ describe('GPUGraph', () => {
       y_tpPerGpu_roofline: 'upper_left',
     });
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-line-labels"
@@ -368,7 +382,7 @@ describe('GPUGraph', () => {
       }),
     ];
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-no-line-labels"
@@ -409,7 +423,7 @@ describe('GPUGraph', () => {
       }),
     ];
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-legend"
@@ -506,7 +520,7 @@ describe('GPU comparison power envelopes', () => {
   }
 
   it('reveals off-boundary measurements without changing power envelopes or axes', () => {
-    mountWithProviders(<PowerComparison />);
+    mountGpuGraph(<PowerComparison />);
     cy.get('#gpu-show-all-measurements').should('not.exist');
     cy.get('#gpu-power-curves .dot-group').should('have.length', 6);
     cy.get('#gpu-power-curves .roofline-path')
@@ -548,7 +562,7 @@ describe('GPU comparison power envelopes', () => {
   });
 
   it('measures power boundaries by comparison date and resets rulers when the metric changes', () => {
-    mountWithProviders(<PowerComparison />);
+    mountGpuGraph(<PowerComparison />);
     cy.get('[data-testid="legend-advanced-toggle"]').click();
     cy.get('#gpu-perf-ruler').click({ force: true });
     const chartId = 'gpu-power-curves';
@@ -585,7 +599,7 @@ describe('GPU comparison power envelopes', () => {
   });
 
   it('keeps boundary measurements by default toward lower latency', () => {
-    mountWithProviders(<PowerComparison latency />);
+    mountGpuGraph(<PowerComparison latency />);
     cy.get('#gpu-power-curves .dot-group').should('have.length', 6);
     cy.get('#gpu-power-curves .roofline-path')
       .should('have.length', 2)
@@ -593,7 +607,7 @@ describe('GPU comparison power envelopes', () => {
   });
 
   it('uses the same boundary toggle for percent TDP and fleet percentiles while preserving energy Pareto', () => {
-    mountWithProviders(
+    mountGpuGraph(
       <PathnameContext.Provider value="/zh/inference">
         <PowerComparison />
       </PathnameContext.Provider>,
@@ -619,3 +633,184 @@ describe('GPU comparison power envelopes', () => {
       .each(($path) => expect($path.attr('d')).to.contain('C'));
   });
 });
+
+const runUrl = (id: number) => `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${id}`;
+
+describe('GPU comparison with unofficial runs and load sweeps', () => {
+  const OVERLAY_RUN_URL = runUrl(31415926535);
+  const DATES = ['2025-03-01', '2025-03-15'];
+  const ALL_SERIES = new Set(DATES.map((date) => `${date}_h100`));
+
+  const official = (date: string, conc: number, y: number, tp = 8) =>
+    createMockInferenceData({
+      hwKey: 'h100',
+      date,
+      conc,
+      tp,
+      x: conc,
+      y,
+      precision: Precision.FP4,
+      run_url: runUrl(DATES.indexOf(date) + 1000),
+    });
+  const overlay = (conc: number, y: number) =>
+    createMockInferenceData({
+      hwKey: 'b200',
+      date: '2025-03-20',
+      conc,
+      tp: 8,
+      x: conc,
+      y,
+      precision: Precision.FP4,
+      run_url: OVERLAY_RUN_URL,
+    });
+
+  function Comparison({
+    chartDefinition,
+    data,
+    overlayPoints,
+    unofficial,
+  }: {
+    chartDefinition: ChartDefinition;
+    data: InferenceData[];
+    overlayPoints: InferenceData[];
+    unofficial: UnofficialRunContextType;
+  }) {
+    const [activeDates, setActiveDates] = useState(new Set(ALL_SERIES));
+    const [overlayHw, setOverlayHw] = useState(new Set(['b200']));
+    const value = createMockInferenceContextValues({
+      hardwareConfig: hwConfig,
+      selectedGPUs: ['h100'],
+      selectedDates: DATES,
+      selectedDateRange: { startDate: '', endDate: '' },
+      activeDates,
+      toggleActiveDate: (id: string) =>
+        setActiveDates((prev) => computeToggle(prev, id, ALL_SERIES)),
+      selectedPrecisions: [Precision.FP4],
+      showLineLabels: true,
+    });
+    return (
+      <UnofficialRunContext.Provider value={{ ...unofficial, activeOverlayHwTypes: overlayHw }}>
+        <InferenceContextsProvider data={value} filters={value} display={value} actions={value}>
+          <button onClick={() => setOverlayHw(new Set())}>Hide overlay hardware</button>
+          <div style={{ width: 1000, height: 600 }}>
+            <GPUGraph
+              chartId="gpu-overlay"
+              modelLabel="DeepSeek R1"
+              data={data}
+              xLabel="X"
+              yLabel="Throughput / Chip (tok/s)"
+              chartDefinition={chartDefinition}
+              overlayData={{
+                data: overlayPoints,
+                hardwareConfig: hwConfig,
+                label: 'feat/power-sweep',
+                runUrl: OVERLAY_RUN_URL,
+              }}
+            />
+          </div>
+        </InferenceContextsProvider>
+      </UnofficialRunContext.Provider>
+    );
+  }
+
+  const mountComparison = (
+    chartDefinition: ChartDefinition,
+    data: InferenceData[],
+    overlayPoints: InferenceData[],
+  ) => {
+    const unofficial = createMockUnofficialRunContext({
+      isUnofficialRun: true,
+      unofficialRunInfos: [
+        {
+          id: 31415926535,
+          name: 'Run Sweep',
+          branch: 'feat/power-sweep',
+          sha: 'abc123',
+          createdAt: '2025-03-20T00:00:00Z',
+          url: OVERLAY_RUN_URL,
+          conclusion: 'success',
+          status: 'completed',
+          isNonMainBranch: true,
+        },
+      ],
+      runIndexByUrl: { [OVERLAY_RUN_URL]: 0 },
+    });
+    mountWithProviders(
+      <Comparison
+        chartDefinition={chartDefinition}
+        data={data}
+        overlayPoints={overlayPoints}
+        unofficial={unofficial}
+      />,
+    );
+  };
+
+  it('keeps unofficial runs on the date comparison in the run color and dash', () => {
+    mountComparison(
+      createMockChartDefinition({ chartType: 'interactivity', y_tpPerGpu_roofline: 'upper_left' }),
+      DATES.flatMap((date, d) => [8, 16, 32].map((x, i) => official(date, x, 300 - i * 60 + d))),
+      [8, 16, 32].map((x, i) => overlay(x, 400 - i * 60)),
+    );
+
+    cy.get('#gpu-overlay .unofficial-overlay-pt').should('have.length', 3);
+    cy.get('#gpu-overlay .unofficial-overlay-pt .overlay-x').each(($marker) => {
+      expect($marker.attr('stroke')).to.equal(overlayRunColor(0));
+    });
+    cy.get('#gpu-overlay .roofline-overlay-run0_b200_fp4')
+      .should('have.attr', 'stroke', overlayRunColor(0))
+      .and('have.attr', 'stroke-dasharray', overlayRooflineDasharray(0));
+    cy.get('.sidebar-legend')
+      .should('contain.text', 'UNOFFICIAL: feat/power-sweep')
+      .and('contain.text', '✕ B200');
+    cy.get('#gpu-overlay .line-label').should('have.length', 3).and('contain.text', '✕ B200');
+
+    // A date toggle hides that official series; the unofficial run stays.
+    cy.get('.sidebar-legend label').contains('2025-03-15').click();
+    cy.get('#gpu-overlay .dot-group').should('have.length', 3);
+    cy.get('#gpu-overlay .unofficial-overlay-pt').should('have.length', 3);
+
+    cy.contains('button', 'Hide overlay hardware').click();
+    cy.get('#gpu-overlay .unofficial-overlay-pt').should('not.exist');
+    cy.get('#gpu-overlay .roofline-overlay-run0_b200_fp4').should('not.exist');
+    cy.get('.sidebar-legend').should('not.contain.text', 'UNOFFICIAL');
+  });
+
+  it('draws concurrency load sweeps per date, run and topology without frontier tools', () => {
+    mountComparison(
+      createMockChartDefinition({
+        chartType: 'interactivity',
+        x_scale_field: 'conc',
+        y_tpPerGpu_roofline: 'upper_left',
+      }),
+      [
+        // A load sweep is not a frontier: the dip at c16 stays on the line.
+        ...DATES.flatMap((date, d) => [
+          official(date, 8, 300 + d),
+          official(date, 16, 250 + d),
+          official(date, 32, 320 + d),
+        ]),
+        // Another topology on the later date is a separate sweep.
+        official(DATES[1], 8, 150, 4),
+        official(DATES[1], 16, 180, 4),
+      ],
+      [overlay(8, 400), overlay(16, 380), overlay(32, 450)],
+    );
+
+    cy.get('#gpu-overlay .roofline-path').should('have.length', 4);
+    cy.get('#gpu-overlay .roofline-path').each(($path) => {
+      expect($path.attr('d'), 'straight segments between observations').not.to.contain('C');
+    });
+    cy.get('#gpu-overlay .roofline-path[class*="2025-03-01_h100_fp4"]')
+      .invoke('attr', 'd')
+      .should('match', /^M[^L]+L[^L]+L[^L]+$/u);
+    cy.get('#gpu-overlay .roofline-path[class*="overlay-run0_b200_fp4"]').should(
+      'have.attr',
+      'stroke-dasharray',
+      overlayRooflineDasharray(0),
+    );
+    cy.get('#gpu-overlay .dot-group').should('have.length', 8);
+    cy.get('#gpu-hide-non-optimal').should('not.exist');
+    cy.get('[data-testid="legend-advanced-toggle"]').click();
+    cy.get('#gpu-perf-ruler').should('not.exist');
+  });
+});
diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index 44732cf31..033125976 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -1,14 +1,18 @@
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+import { useState } from 'react';
 
 import type { GpuPowerSeries, GpuPowerSeriesResponse } from '@/components/gpu-power/power-series';
+import { InferenceContextsProvider } from '@/components/inference/InferenceContext';
 import PowerTimeline from '@/components/inference/ui/PowerTimeline';
 import type { InferenceData } from '@/components/inference/types';
 import { traceKeyForPoint } from '@/components/inference/utils/powerTimeline';
 import { Model, Precision, Sequence } from '@/lib/data-mappings';
 import { overlayRunColor } from '@/lib/overlay-run-style';
+import { computeToggle } from '@/lib/toggle-set';
 
 import {
   createMockHardwareConfig,
+  createMockInferenceContextValues,
   createMockInferenceData,
   createMockUnofficialRunContext,
 } from '../support/mock-data';
@@ -206,4 +210,86 @@ describe('PowerTimeline', () => {
       .should('have.attr', 'style')
       .and('contain', overlayRunColor(0));
   });
+
+  it('follows the date comparison series: colours, legend toggles and labels', () => {
+    const EARLIER_RUN_ID = '34600000001';
+    const EARLIER_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${EARLIER_RUN_ID}`;
+    const DATES = ['2026-09-11', '2026-09-12'];
+    const ALL_SERIES = new Set(DATES.map((date) => `${date}_b200`));
+    cy.intercept('POST', `/api/gpu-metrics?runId=${EARLIER_RUN_ID}*`, {
+      body: {
+        runInfo: { ...response.runInfo, id: Number(EARLIER_RUN_ID), url: EARLIER_RUN_URL },
+        series: [series('b200', 16, 600)],
+      },
+    }).as('earlier');
+    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('later');
+
+    function DateComparison() {
+      const [activeDates, setActiveDates] = useState(new Set(ALL_SERIES));
+      const value = createMockInferenceContextValues({
+        selectedModel: Model.DeepSeek_V4_Pro,
+        selectedSequence: Sequence.EightK_OneK,
+        selectedYAxisMetric: 'y_measuredPowerTimeline',
+        hardwareConfig: hwConfig,
+        activeHwTypes: new Set(HW_TYPES),
+        hwTypesWithData: new Set(HW_TYPES),
+        selectedGPUs: ['b200'],
+        selectedDates: DATES,
+        selectedDateRange: { startDate: '', endDate: '' },
+        activeDates,
+        toggleActiveDate: (id: string) =>
+          setActiveDates((prev) => computeToggle(prev, id, ALL_SERIES)),
+      });
+      return (
+        <InferenceContextsProvider data={value} filters={value} display={value} actions={value}>
+          <div style={{ width: 1100, height: 700 }}>
+            <PowerTimeline
+              chartId="power-timeline-test"
+              comparison
+              data={[
+                measuredPoint('b200', 16, 600, { date: DATES[0], run_url: EARLIER_RUN_URL }),
+                measuredPoint('b200', 16, 700, { date: DATES[1] }),
+              ]}
+              yLabel="Measured Average Power per Chip over Time (W)"
+            />
+          </div>
+        </InferenceContextsProvider>
+      );
+    }
+    mountWithProviders(
+      <PathnameContext.Provider value="/inference">
+        <DateComparison />
+      </PathnameContext.Provider>,
+      { unofficial: {} },
+    );
+    cy.wait(['@earlier', '@later']);
+
+    // One legend row per compared date, under the hardware, as in GPUGraph.
+    cy.get('[data-testid="chart-legend"] .gpu-legend-title').should('have.text', 'B200');
+    cy.get('[data-testid="chart-legend"] label').then(($labels) => {
+      const rows = $labels.toArray().map((label) => label.textContent?.trim());
+      expect(rows).to.include.members(DATES);
+    });
+    svg().within(() => {
+      cy.get('path.power-trace[data-segment="window"]').then(($paths) => {
+        expect($paths).to.have.length(2);
+        const strokes = new Set($paths.toArray().map((path) => path.getAttribute('stroke')));
+        expect(strokes.size, 'each date has its own colour').to.equal(2);
+      });
+      cy.get('text.power-trace-label').then(($labels) => {
+        expect($labels.toArray().map((label) => label.textContent)).to.have.members(
+          DATES.map((date) => `${date} c16`),
+        );
+      });
+    });
+
+    // Soloing the later date removes the earlier date's trace.
+    cy.get('[data-testid="chart-legend"] label').contains(DATES[1]).click();
+    svg().within(() => {
+      cy.get('path.power-trace[data-segment="window"]')
+        .should('have.length', 1)
+        .and('have.attr', 'data-trace-key', `${RUN_ID}:${resultName('b200', 16)}`);
+      cy.get('text.power-trace-label').should('have.length', 1).and('have.text', 'c16');
+    });
+  });
 });
diff --git a/packages/app/cypress/e2e/inference-chart.cy.ts b/packages/app/cypress/e2e/inference-chart.cy.ts
index c2edf1376..3f00279c4 100644
--- a/packages/app/cypress/e2e/inference-chart.cy.ts
+++ b/packages/app/cypress/e2e/inference-chart.cy.ts
@@ -871,6 +871,31 @@ const assertObservedLoads = (expected: number[]) => {
   }
 };
 
+describe('Date comparison with unofficial runs', () => {
+  for (const [axis, xMode] of [
+    ['interactivity', ''],
+    ['concurrency', '&i_xmode=concurrency'],
+  ]) {
+    // Every measurement is shown (i_optimal=0), so both runs plot all four loads.
+    it(`keeps ?unofficialrun= overlays on the ${axis} date comparison`, () => {
+      interceptMeasuredComparison();
+      cy.viewport(1440, 900);
+      cy.visit(
+        `/inference?g_model=DeepSeek-V4-Pro&unofficialrun=${OVERLAY_RUN_ID}&i_seq=1k%2F1k&i_prec=fp4&i_metric=y_measuredAvgPower&i_gpus=b300_sglang&i_dstart=${SINGLE_TURN_DATE}&i_dend=${SINGLE_TURN_DATE}&i_optimal=0${xMode}`,
+        { onBeforeLoad: unlockAgenticGate },
+      );
+      cy.wait('@measuredOverlay');
+      cy.get('[data-testid="gpu-graph"]').should('exist');
+      cy.get('[data-testid="scatter-graph"]').should('not.exist');
+      assertMeasuredValues('.dot-group', [450, 460, 470, 480]);
+      assertMeasuredValues('.unofficial-overlay-pt', [450, 460, 470, 480]);
+      cy.get('[aria-label="Dismiss measured-comparison"]').click();
+      cy.get('[data-testid="gpu-graph"] .unofficial-overlay-pt').should('not.exist');
+      assertMeasuredValues('.dot-group', [450, 460, 470, 480]);
+    });
+  }
+});
+
 describe('Observed concurrency and exact topology', () => {
   it('applies the exact-topology filter to official and ?unofficialrun= overlay loads', () => {
     const officialRun = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/800001';
diff --git a/packages/app/src/components/inference/hooks/useComparisonSeries.ts b/packages/app/src/components/inference/hooks/useComparisonSeries.ts
new file mode 100644
index 000000000..23df41ecc
--- /dev/null
+++ b/packages/app/src/components/inference/hooks/useComparisonSeries.ts
@@ -0,0 +1,129 @@
+'use client';
+
+import { useMemo } from 'react';
+import { useTheme } from 'next-themes';
+
+import { useInferenceDisplay, useInferenceFilters } from '@/components/inference/InferenceContext';
+import {
+  buildRunNumbering,
+  comparisonEntrySortValue,
+  resolveComparisonEntries,
+} from '@/components/inference/utils/comparisonEntry';
+import { useThemeColors } from '@/hooks/useThemeColors';
+import { getModelSortIndex } from '@/lib/constants';
+import { generateGpuDateColors, generateHighContrastGpuDateColors } from '@/lib/dynamic-colors';
+
+/** One (comparison entry, chip config) series of the date comparison view. */
+export interface ComparisonSeries {
+  date: string;
+  hwKey: string;
+  /** `${date}_${hwKey}`: the key of the `activeDates` toggle set. */
+  id: string;
+  color: string;
+}
+
+/**
+ * Series, run numbers and colours of the date comparison view. GPUGraph and
+ * the Power Timeline share them so one (date, chip config) pair reads the
+ * same in both displays.
+ */
+export function useComparisonSeries(providedRunNumbering?: Map<string, number>) {
+  const { selectedGPUs, selectedDateRange, selectedDates } = useInferenceFilters();
+  const { highContrast } = useInferenceDisplay();
+  const { resolvedTheme } = useTheme();
+
+  // Shared date+GPU pairs. `dates` holds comparison-series entries (plain dates
+  // and/or specific-run entries); a same-day range endpoint is dropped when that
+  // date also has run entries (resolveComparisonEntries), then sorted earliest →
+  // latest so a day's runs read #1 → #N.
+  const gpuDatePairs = useMemo(() => {
+    const deduplicated = resolveComparisonEntries(selectedDates, selectedDateRange);
+    deduplicated.sort((a, b) => {
+      const [ta, ia] = comparisonEntrySortValue(a);
+      const [tb, ib] = comparisonEntrySortValue(b);
+      return ta - tb || ia - ib;
+    });
+    const sortedGPUs = [...selectedGPUs].toSorted(
+      (a, b) => getModelSortIndex(a) - getModelSortIndex(b) || a.localeCompare(b),
+    );
+    return { dates: deduplicated, sortedGPUs };
+  }, [selectedDateRange, selectedDates, selectedGPUs]);
+
+  // Run numbers for legend/line labels. Prefer the stable numbering passed by
+  // the parent (shared with the changelog, so labels match it and removed runs
+  // leave a gap); fall back to gap-free numbering of the on-chart series.
+  const runNumbering = useMemo(
+    () => providedRunNumbering ?? buildRunNumbering(gpuDatePairs.dates),
+    [providedRunNumbering, gpuDatePairs.dates],
+  );
+
+  const graphIdentifiers = useMemo(() => {
+    const ids: string[] = [];
+    gpuDatePairs.sortedGPUs.forEach((gpu) =>
+      gpuDatePairs.dates.forEach((date) => ids.push(`${date}_${gpu}`)),
+    );
+    return ids;
+  }, [gpuDatePairs]);
+
+  // High contrast keys off the GPU (not `date_gpu`) so each hardware config
+  // gets exactly one hue; the dates within a config are separated by the
+  // lightness ramp built below rather than by unrelated hues.
+  const { resolveColor, getCssColor } = useThemeColors({
+    highContrast,
+    identifiers: graphIdentifiers,
+    hcKeys: gpuDatePairs.sortedGPUs,
+  });
+
+  // Dynamic GPU×date color map
+  const gpuDateColorMap = useMemo(() => {
+    const { dates, sortedGPUs } = gpuDatePairs;
+    if (sortedGPUs.length === 0 || dates.length === 0) return {};
+    const theme = resolvedTheme === 'dark' || resolvedTheme === 'minecraft' ? 'dark' : 'light';
+    return generateGpuDateColors(sortedGPUs, dates.length, theme);
+  }, [gpuDatePairs, resolvedTheme]);
+
+  // High-contrast GPU×date color map: one iwanthue hue per GPU, ramped across
+  // the compared dates so a config's runs stay recognisably the same color
+  // while still reading oldest → newest.
+  const hcGpuDateColorMap = useMemo(() => {
+    const { dates, sortedGPUs } = gpuDatePairs;
+    if (!highContrast || sortedGPUs.length === 0 || dates.length === 0) return {};
+    const theme = resolvedTheme === 'dark' || resolvedTheme === 'minecraft' ? 'dark' : 'light';
+    const baseColors: Record<string, string> = {};
+    for (const gpu of sortedGPUs) baseColors[gpu] = getCssColor(resolveColor(gpu));
+    return generateHighContrastGpuDateColors(baseColors, dates.length, theme);
+  }, [gpuDatePairs, highContrast, resolvedTheme, resolveColor, getCssColor]);
+
+  const allGraphs = useMemo(() => {
+    const { dates, sortedGPUs } = gpuDatePairs;
+    const result: ComparisonSeries[] = [];
+    sortedGPUs.forEach((gpu) => {
+      dates.forEach((date, dateIndex) => {
+        const id = `${date}_${gpu}`;
+        const compositeKey = `${dateIndex}_${gpu}`;
+        const dynamicColor = gpuDateColorMap[compositeKey];
+        result.push({
+          date,
+          hwKey: gpu,
+          id,
+          color: highContrast
+            ? hcGpuDateColorMap[compositeKey] || getCssColor(resolveColor(gpu))
+            : dynamicColor || 'var(--foreground)',
+        });
+      });
+    });
+    return result;
+  }, [gpuDatePairs, gpuDateColorMap, hcGpuDateColorMap, highContrast, resolveColor, getCssColor]);
+
+  const paletteIdentity = useMemo(
+    () =>
+      [
+        resolvedTheme ?? 'system',
+        highContrast ? 'high-contrast' : 'standard',
+        ...allGraphs.map(({ id, color }) => `${id}:${color}`),
+      ].join('|'),
+    [resolvedTheme, highContrast, allGraphs],
+  );
+
+  return { gpuDatePairs, runNumbering, allGraphs, paletteIdentity, resolveColor, getCssColor };
+}
diff --git a/packages/app/src/components/inference/hooks/usePowerTraceAction.ts b/packages/app/src/components/inference/hooks/usePowerTraceAction.ts
new file mode 100644
index 000000000..09b559126
--- /dev/null
+++ b/packages/app/src/components/inference/hooks/usePowerTraceAction.ts
@@ -0,0 +1,56 @@
+'use client';
+
+import { useCallback, type RefObject } from 'react';
+
+import { useInferenceActions } from '@/components/inference/InferenceContext';
+import type { InferenceData } from '@/components/inference/types';
+import {
+  POWER_TIMELINE_METRIC_KEY,
+  requestPowerTraceFocus,
+  traceKeyForPoint,
+} from '@/components/inference/utils/powerTimeline';
+import { track } from '@/lib/analytics';
+import type { D3ChartHandle } from '@/lib/d3-chart/D3Chart/types';
+
+/**
+ * "View power trace" on a pinned tooltip (official or overlay point): the
+ * same-tab click stays in-page — remember which trace to emphasise, switch
+ * the metric to the Timeline display, and let the anchor's href keep
+ * serving open-in-new-tab. Listeners are attached per pin because the
+ * tooltip HTML is replaced on every pin.
+ */
+export function usePowerTraceAction(chartRef: RefObject<D3ChartHandle | null>) {
+  const { setSelectedYAxisMetric } = useInferenceActions();
+  return useCallback(
+    (tooltipEl: HTMLElement, d: InferenceData, overlay: boolean) => {
+      const action = tooltipEl.querySelector('[data-action="view-power-trace"]');
+      const traceKey = traceKeyForPoint(d);
+      if (!action || !traceKey) return;
+      action.addEventListener('click', (actionEvent) => {
+        actionEvent.stopPropagation();
+        // Modifier / auxiliary clicks keep the anchor's own behaviour: the
+        // href opens this chart's timeline in a new tab or window.
+        const mouse = actionEvent as MouseEvent;
+        if (
+          mouse.button !== 0 ||
+          mouse.metaKey ||
+          mouse.ctrlKey ||
+          mouse.shiftKey ||
+          mouse.altKey
+        ) {
+          return;
+        }
+        actionEvent.preventDefault();
+        requestPowerTraceFocus(traceKey);
+        chartRef.current?.dismissTooltip();
+        setSelectedYAxisMetric(POWER_TIMELINE_METRIC_KEY);
+        track('inference_power_trace_opened', {
+          hwKey: String(d.hwKey),
+          conc: d.conc,
+          overlay,
+        });
+      });
+    },
+    [chartRef, setSelectedYAxisMetric],
+  );
+}
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index c1cfaa1a1..cfc859e7f 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -693,6 +693,25 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     },
     [selectedPrecisions, quickFilters, selectedOfficialHwTypes, scopedActiveOverlayHwTypes],
   );
+  // Date comparison (GPUGraph, Timeline): official rows follow the per-date
+  // legend toggles instead of the scatter hardware selection, and unofficial
+  // runs keep the overlay hardware selection. Boundary / role siblings are a
+  // same-run comparison, so neither side draws them here.
+  const visibleDateComparisonRows = useCallback(
+    (officialRows: InferenceData[], overlay: OverlayData | null | undefined) => ({
+      officialRows: officialRows.filter(
+        (point) =>
+          !point.powerVariant &&
+          selectedPrecisions.includes(point.precision) &&
+          matchesQuickFilters(point, quickFilters) &&
+          activeDates.has(`${point.date}_${point.hwKey}`),
+      ),
+      overlayRows: visibleComparisonRows([], overlay).overlayRows.filter(
+        (point) => !point.powerVariant,
+      ),
+    }),
+    [selectedPrecisions, quickFilters, activeDates, visibleComparisonRows],
+  );
 
   if (!loading && error) {
     console.error(error);
@@ -883,10 +902,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
         : renderableGraphs.map((graph, graphIndex) => {
             const resolvedXLabel = xAxisLabel(graph.chartDefinition, locale);
             const isTimelineMode = Boolean(
-              selectedXAxisMode !== 'concurrency' &&
-              selectedDateRange.startDate &&
-              selectedDateRange.endDate &&
-              selectedGPUs.length > 0,
+              selectedDateRange.startDate && selectedDateRange.endDate && selectedGPUs.length > 0,
             );
             const replayAvailable =
               getViewMode(graphIndex) === 'chart' &&
@@ -898,21 +914,17 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
             // official points plus any loaded unofficial-run overlay for
             // this chart type — so they moved out of the legend without
             // changing when they appear.
-            // GPU/date comparison renders GPUGraph, which plots official
-            // points only — skip the unofficial overlay there so the footer
-            // can't advertise a halo or ATOM series that isn't on the chart.
+            // GPU/date comparison renders GPUGraph, which plots the loaded
+            // unofficial runs next to the compared dates on every x-axis.
             const isGpuComparison =
-              selectedXAxisMode !== 'concurrency' &&
               selectedGPUs.length > 0 &&
               ((selectedDateRange.startDate && selectedDateRange.endDate) ||
                 selectedDates.length > 0);
-            const footerOverlay = isGpuComparison
-              ? undefined
-              : selectUnofficialOverlayForMode(
-                  selectedXAxisMode,
-                  graph.chartDefinition.chartType,
-                  overlayDataByChartType,
-                );
+            const footerOverlay = selectUnofficialOverlayForMode(
+              selectedXAxisMode,
+              graph.chartDefinition.chartType,
+              overlayDataByChartType,
+            );
             const footerPoints = [
               ...graph.data,
               ...(footerOverlay?.data ?? []),
@@ -1000,9 +1012,6 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                           : undefined
                       }
                       onExportCsv={() => {
-                        const candidateVisibleData = isTimelineMode
-                          ? graph.data.filter((d) => activeDates.has(`${d.date}_${d.hwKey}`))
-                          : graph.data;
                         const overlay = selectUnofficialOverlayForMode(
                           selectedXAxisMode,
                           graph.chartDefinition.chartType,
@@ -1011,9 +1020,9 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                         const {
                           officialRows: visibleData,
                           overlayRows: visibleOverlayRowsForExport,
-                        } = isTimelineMode
-                          ? { officialRows: candidateVisibleData, overlayRows: [] }
-                          : visibleComparisonRows(candidateVisibleData, overlay);
+                        } = isGpuComparison
+                          ? visibleDateComparisonRows(graph.data, overlay)
+                          : visibleComparisonRows(graph.data, overlay);
                         const { headers, rows } = inferenceChartToCsv(
                           visibleData,
                           graph.model,
@@ -1242,10 +1251,9 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                               ],
                             }
                           : overlay;
-                        const { officialRows, overlayRows } = visibleComparisonRows(
-                          tableOfficialData,
-                          tableOverlay,
-                        );
+                        const { officialRows, overlayRows } = isGpuComparison
+                          ? visibleDateComparisonRows(tableOfficialData, tableOverlay)
+                          : visibleComparisonRows(tableOfficialData, tableOverlay);
                         return (
                           <>
                             {chartCaption}
@@ -1282,6 +1290,8 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                                 locale,
                               )}
                               caption={chartCaption}
+                              comparison={Boolean(isGpuComparison)}
+                              runNumbering={runNumbering}
                             />
                           </div>
                         );
@@ -1298,6 +1308,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                           yLabel={metricLabel(graph.chartDefinition, selectedYAxisMetric, locale)}
                           chartDefinition={graph.chartDefinition}
                           caption={chartCaption}
+                          overlayData={footerOverlay ?? undefined}
                           runNumbering={runNumbering}
                         />
                       ) : (
@@ -1332,14 +1343,9 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                           graph.chartDefinition.chartType,
                           overlayDataByChartType,
                         );
-                        const { officialRows, overlayRows } = visibleComparisonRows(
-                          isGpuComparison
-                            ? graph.data.filter((point) =>
-                                activeDates.has(`${point.date}_${point.hwKey}`),
-                              )
-                            : graph.data,
-                          isGpuComparison ? undefined : overlay,
-                        );
+                        const { officialRows, overlayRows } = isGpuComparison
+                          ? visibleDateComparisonRows(graph.data, overlay)
+                          : visibleComparisonRows(graph.data, overlay);
                         return (
                           <PowerServiceComparison
                             chartId={`chart-${graphIndex}`}
diff --git a/packages/app/src/components/inference/ui/GPUGraph.tsx b/packages/app/src/components/inference/ui/GPUGraph.tsx
index 5b59f4fe5..a57113680 100644
--- a/packages/app/src/components/inference/ui/GPUGraph.tsx
+++ b/packages/app/src/components/inference/ui/GPUGraph.tsx
@@ -9,7 +9,6 @@ import { rememberChartStateInUrl } from '@/lib/url-state';
 import * as d3 from 'd3';
 import dynamic from 'next/dynamic';
 import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
-import { useTheme } from 'next-themes';
 
 import {
   useInferenceActions,
@@ -20,17 +19,21 @@ import {
 import ChartLegend from '@/components/ui/chart-legend';
 import { Button } from '@/components/ui/button';
 import { OFFICIAL_PREVIEW_SERIES } from '@/components/official-preview-notice';
-import { getHardwareConfig, getModelSortIndex, hardwareKeyMatchesAnyBase } from '@/lib/constants';
-import { getInferenceHardwareConfig } from '@/lib/inference-labels';
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
+import { getHardwareConfig, hardwareKeyMatchesAnyBase } from '@/lib/constants';
+import {
+  getInferenceHardwareConfig,
+  getInferenceRunLabel,
+  getOverlayLineLabel,
+} from '@/lib/inference-labels';
 import { getChartWatermark, Sequence } from '@/lib/data-mappings';
-import { generateGpuDateColors, generateHighContrastGpuDateColors } from '@/lib/dynamic-colors';
 import { useLocale } from '@/lib/use-locale';
 import { formatNumber, getDisplayLabel, updateRepoUrl } from '@/lib/utils';
-import { useThemeColors } from '@/hooks/useThemeColors';
 import { perfRulerAxisMetricKey, usePerfRulerAxisReset } from '@/hooks/usePerfRulerAxisReset';
 import { useTraceAvailability } from '@/hooks/api/use-trace-availability';
 import { useLogAvailability } from '@/hooks/api/use-log-availability';
 import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import { CHART_TYPE, px } from '@/lib/d3-chart/typography';
 import type {
   CustomLayerConfig,
   D3ChartHandle,
@@ -43,8 +46,20 @@ import {
   applyNormalState,
   formatLargeNumber,
   getShapeKeyForPrecision,
+  HIT_AREA_RADIUS,
   logTickFormat,
 } from '@/lib/chart-rendering';
+import { computeTooltipPosition } from '@/lib/d3-chart/layers/scatter-points';
+import {
+  attachOverlayXMarkerHandlers,
+  overlayMarkerPosition,
+  xMarkerPath,
+} from '@/lib/d3-chart/overlay-x-marker';
+import {
+  overlayRooflineDasharray,
+  overlayRunColor,
+  overlayRunIndex,
+} from '@/lib/overlay-run-style';
 import type { ParetoDirection } from '@/lib/chart-utils';
 import {
   chartFrontier,
@@ -58,13 +73,15 @@ import type {
   InferenceData,
   ScatterGraphProps,
 } from '@/components/inference/types';
+import { comparisonEntryLabel } from '@/components/inference/utils/comparisonEntry';
+import { groupConcurrencySeries } from '@/components/inference/utils/concurrency-series';
+import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
 import {
-  buildRunNumbering,
-  comparisonEntryLabel,
-  comparisonEntrySortValue,
-  resolveComparisonEntries,
-} from '@/components/inference/utils/comparisonEntry';
-import { generateGPUGraphTooltipContent } from '@/components/inference/utils/tooltipUtils';
+  generateGPUGraphTooltipContent,
+  generateOverlayTooltipContent,
+} from '@/components/inference/utils/tooltipUtils';
+import { useComparisonSeries } from '@/components/inference/hooks/useComparisonSeries';
+import { usePowerTraceAction } from '@/components/inference/hooks/usePowerTraceAction';
 import { pointLabelText } from '@/components/inference/ui/point-label';
 import { scatterPointConfigId } from '@/components/inference/utils/point-identity';
 import {
@@ -124,10 +141,14 @@ const FixedSequenceLogDialog = dynamic(() =>
 const CHART_MARGIN = { top: 24, right: 10, bottom: 60, left: 60 };
 
 // Roofline paths in this chart carry the class `roofline-<key>` where key is
-// `${date}_${hwKey}_${precision}` (see `renderRooflines`). The perf ruler
-// identifies curves by that class token.
+// `${seriesId}_${precision}` (see `renderRooflines`); a concurrency sweep adds
+// a `__<segment>` suffix. The perf ruler identifies curves by that class token.
 const ROOFLINE_CLASS_PREFIX = 'roofline-';
 
+// Series id of an unofficial run: `overlay-run<index>_<hwKey>`. Official series
+// ids are `${date}_${hwKey}`, the `activeDates` key.
+const OVERLAY_SERIES_PREFIX = 'overlay-run';
+
 // Scales as currently drawn: the base render scales rescaled through the
 // active zoom transform (identity when the chart is not zoomed).
 const currentZoomRenderContext = (svg: SVGSVGElement, ctx: RenderContext): RenderContext => {
@@ -144,11 +165,14 @@ const currentZoomRenderContext = (svg: SVGSVGElement, ctx: RenderContext): Rende
 // both dimensions of the GPU comparison view are legible on the chart,
 // not only the legend. Falls back to the raw hwKey if the config
 // lookup misses (legacy data).
-function labelTextFor(pts: InferenceData[], numbering: Map<string, number>): string {
+function hardwareLabelFor(pts: InferenceData[]): string {
   const hwKey = String(pts[0].hwKey);
   const cfg = getInferenceHardwareConfig(hwKey, pts[0].model, pts);
-  const hwLabel = cfg ? getDisplayLabel(cfg) : hwKey;
-  return `${hwLabel} • ${comparisonEntryLabel(String(pts[0].date), numbering)}`;
+  return cfg ? getDisplayLabel(cfg) : hwKey;
+}
+
+function labelTextFor(pts: InferenceData[], numbering: Map<string, number>): string {
+  return `${hardwareLabelFor(pts)} • ${comparisonEntryLabel(String(pts[0].date), numbering)}`;
 }
 
 const GPU_STRINGS = {
@@ -175,6 +199,7 @@ const GPU_STRINGS = {
       'This dataset does not report role-level prefill/decode energy. Choose a different model, scenario, precision, date, or measured-energy metric.',
     noMeasuredDataHint:
       'No measured GPU power is reported for this selection. Choose other chip configs, or a different model, scenario, precision or date.',
+    unofficialTitle: (branch: string) => `UNOFFICIAL: ${branch}`,
   },
   zh: {
     logScale: '对数缩放',
@@ -199,6 +224,7 @@ const GPU_STRINGS = {
       '当前数据集未提供 Prefill/Decode 各角色的能耗数据。请选择其他模型、场景、精度、日期或实测能耗指标。',
     noMeasuredDataHint:
       '当前选择没有实测 GPU 功耗数据。请选择其他芯片配置，或更换模型、场景、精度或日期。',
+    unofficialTitle: (branch: string) => `非官方：${branch}`,
   },
 } as const;
 
@@ -211,6 +237,7 @@ const GPUGraph = React.memo(
     yLabel,
     chartDefinition,
     caption,
+    overlayData,
     runNumbering: providedRunNumbering,
   }: ScatterGraphProps) => {
     const { hardwareConfig } = useInferenceData();
@@ -265,13 +292,19 @@ const GPUGraph = React.memo(
     const showPowerTelemetryRef = useRef(showPowerTelemetry);
     showPowerTelemetryRef.current = showPowerTelemetry;
     const legendT = GPU_STRINGS[locale];
-    const frontierDirection = chartDefinition[
-      `${selectedYAxisMetric}_roofline` as keyof ChartDefinition
-    ] as ParetoDirection | undefined;
+    // The Concurrency axis plots observed load sweeps: no frontier, power
+    // envelope or perf ruler, same as ScatterGraph.
+    const isConcurrencyAxis = chartDefinition.x_scale_field === 'conc';
+    const frontierDirection = isConcurrencyAxis
+      ? undefined
+      : (chartDefinition[`${selectedYAxisMetric}_roofline` as keyof ChartDefinition] as
+          | ParetoDirection
+          | undefined);
     const hideNonOptimal = Boolean(frontierDirection) && savedHideNonOptimal;
     const powerCurveMetric = isPowerCurveMetric(selectedYAxisMetric);
     const isMeasuredPowerAxis = isMeasuredPowerCurveMetric(selectedYAxisMetric);
-    const powerEnvelopeMode = powerCurveMetric && (isMeasuredPowerAxis || !hideNonOptimal);
+    const powerEnvelopeMode =
+      !isConcurrencyAxis && powerCurveMetric && (isMeasuredPowerAxis || !hideNonOptimal);
     const showAllMeasurements = isMeasuredPowerAxis ? !hideNonOptimal : savedShowAllMeasurements;
     const noDataHint = isRoleLocalMeasuredEnergyConfigKey(selectedYAxisMetric)
       ? legendT.noRoleEnergyDataHint
@@ -279,7 +312,6 @@ const GPUGraph = React.memo(
         ? legendT.noMeasuredDataHint
         : legendT.noDataHint;
     const ephemeralUrlState = useEphemeralUrlState();
-    const { resolvedTheme } = useTheme();
     const chartRef = useRef<D3ChartHandle>(null);
     const [quickFiltersOpen, setQuickFiltersOpen] = useState(false);
     // A framework lock (embed routes) is not a user filter, so it is not counted.
@@ -306,29 +338,39 @@ const GPUGraph = React.memo(
       setQuickFilterTopologies,
     ]);
 
-    // Shared date+GPU pairs. `dates` holds comparison-series entries (plain dates
-    // and/or specific-run entries); a same-day range endpoint is dropped when that
-    // date also has run entries (resolveComparisonEntries), then sorted earliest →
-    // latest so a day's runs read #1 → #N.
-    const gpuDatePairs = useMemo(() => {
-      const deduplicated = resolveComparisonEntries(selectedDates, selectedDateRange);
-      deduplicated.sort((a, b) => {
-        const [ta, ia] = comparisonEntrySortValue(a);
-        const [tb, ib] = comparisonEntrySortValue(b);
-        return ta - tb || ia - ib;
-      });
-      const sortedGPUs = [...selectedGPUs].toSorted(
-        (a, b) => getModelSortIndex(a) - getModelSortIndex(b) || a.localeCompare(b),
-      );
-      return { dates: deduplicated, sortedGPUs };
-    }, [selectedDateRange, selectedDates, selectedGPUs]);
-
-    // Run numbers for legend/line labels. Prefer the stable numbering passed by
-    // the parent (shared with the changelog, so labels match it and removed runs
-    // leave a gap); fall back to gap-free numbering of the on-chart series.
-    const runNumbering = useMemo(
-      () => providedRunNumbering ?? buildRunNumbering(gpuDatePairs.dates),
-      [providedRunNumbering, gpuDatePairs.dates],
+    const { runNumbering, allGraphs, paletteIdentity, resolveColor, getCssColor } =
+      useComparisonSeries(providedRunNumbering);
+
+    // Unofficial runs stay on this chart as their own (run, chip config)
+    // series in the run's colour, next to the compared dates. Same gates as
+    // ScatterGraph: precision, quick filters and overlay hardware selection;
+    // dismissing a run removes its rows from `overlayData`.
+    const { runIndexByUrl, unofficialRunInfos, activeOverlayHwTypes } = useUnofficialRun();
+    const overlayPoints = useMemo(
+      () =>
+        (overlayData?.data ?? []).filter(
+          (point) =>
+            // Boundary / role siblings are a same-run comparison (see ChartDisplay).
+            !point.powerVariant &&
+            selectedPrecisions.includes(point.precision) &&
+            matchesQuickFilters(point, quickFilters) &&
+            activeOverlayHwTypes.has(String(point.hwKey)),
+        ),
+      [overlayData, selectedPrecisions, quickFilters, activeOverlayHwTypes],
+    );
+    const overlayPointSet = useMemo(() => new Set(overlayPoints), [overlayPoints]);
+    const overlayRunOf = useCallback(
+      (point: InferenceData) => overlayRunIndex(point.run_url ?? null, runIndexByUrl),
+      [runIndexByUrl],
+    );
+    const overlaySeriesId = useCallback(
+      (point: InferenceData) => `${OVERLAY_SERIES_PREFIX}${overlayRunOf(point)}_${point.hwKey}`,
+      [overlayRunOf],
+    );
+    const seriesIdOf = useCallback(
+      (point: InferenceData) =>
+        overlayPointSet.has(point) ? overlaySeriesId(point) : `${point.date}_${point.hwKey}`,
+      [overlayPointSet, overlaySeriesId],
     );
 
     // Removing a series from the legend should also drop it from the comparison
@@ -348,94 +390,24 @@ const GPUGraph = React.memo(
       [selectedGPUs, selectedDates, setSelectedDates, removeActiveDate],
     );
 
-    const graphIdentifiers = useMemo(() => {
-      const ids: string[] = [];
-      gpuDatePairs.sortedGPUs.forEach((gpu) =>
-        gpuDatePairs.dates.forEach((date) => ids.push(`${date}_${gpu}`)),
-      );
-      return ids;
-    }, [gpuDatePairs]);
-
-    // High contrast keys off the GPU (not `date_gpu`) so each hardware config
-    // gets exactly one hue; the dates within a config are separated by the
-    // lightness ramp built below rather than by unrelated hues.
-    const { resolveColor, getCssColor } = useThemeColors({
-      highContrast,
-      identifiers: graphIdentifiers,
-      hcKeys: gpuDatePairs.sortedGPUs,
-    });
-
-    // Dynamic GPU×date color map
-    const gpuDateColorMap = useMemo(() => {
-      const { dates, sortedGPUs } = gpuDatePairs;
-      if (sortedGPUs.length === 0 || dates.length === 0) return {};
-      const theme = resolvedTheme === 'dark' || resolvedTheme === 'minecraft' ? 'dark' : 'light';
-      return generateGpuDateColors(sortedGPUs, dates.length, theme);
-    }, [gpuDatePairs, resolvedTheme]);
-
-    // High-contrast GPU×date color map: one iwanthue hue per GPU, ramped across
-    // the compared dates so a config's runs stay recognisably the same color
-    // while still reading oldest → newest.
-    const hcGpuDateColorMap = useMemo(() => {
-      const { dates, sortedGPUs } = gpuDatePairs;
-      if (!highContrast || sortedGPUs.length === 0 || dates.length === 0) return {};
-      const theme = resolvedTheme === 'dark' || resolvedTheme === 'minecraft' ? 'dark' : 'light';
-      const baseColors: Record<string, string> = {};
-      for (const gpu of sortedGPUs) baseColors[gpu] = getCssColor(resolveColor(gpu));
-      return generateHighContrastGpuDateColors(baseColors, dates.length, theme);
-    }, [gpuDatePairs, highContrast, resolvedTheme, resolveColor, getCssColor]);
-
-    const allGraphs = useMemo(() => {
-      const { dates, sortedGPUs } = gpuDatePairs;
-      const result: { date: string; color: string; hwKey: string; id: string }[] = [];
-      sortedGPUs.forEach((gpu) => {
-        dates.forEach((date, dateIndex) => {
-          const id = `${date}_${gpu}`;
-          const compositeKey = `${dateIndex}_${gpu}`;
-          const dynamicColor = gpuDateColorMap[compositeKey];
-          result.push({
-            date,
-            hwKey: gpu,
-            id,
-            color: highContrast
-              ? hcGpuDateColorMap[compositeKey] || getCssColor(resolveColor(gpu))
-              : dynamicColor || 'var(--foreground)',
-          });
-        });
+    const groupedData = useMemo(() => {
+      const groups: Record<string, InferenceData[]> = {};
+      const add = (point: InferenceData) => {
+        const key = `${seriesIdOf(point)}_${point.precision}`;
+        (groups[key] ??= []).push(point);
+      };
+      data.forEach((point) => {
+        if (selectedPrecisions.includes(point.precision)) add(point);
       });
-      return result;
-    }, [gpuDatePairs, gpuDateColorMap, hcGpuDateColorMap, highContrast, resolveColor, getCssColor]);
-
-    const paletteIdentity = useMemo(
-      () =>
-        [
-          resolvedTheme ?? 'system',
-          highContrast ? 'high-contrast' : 'standard',
-          ...allGraphs.map(({ id, color }) => `${id}:${color}`),
-        ].join('|'),
-      [resolvedTheme, highContrast, allGraphs],
-    );
-
-    const groupedData = useMemo(
-      () =>
-        data.reduce(
-          (acc, point) => {
-            if (!selectedPrecisions.includes(point.precision)) return acc;
-            const key = `${point.date}_${point.hwKey}_${point.precision}`;
-            if (!acc[key]) acc[key] = [];
-            acc[key].push(point);
-            return acc;
-          },
-          {} as Record<string, InferenceData[]>,
-        ),
-      [data, selectedPrecisions],
-    );
+      overlayPoints.forEach(add);
+      return groups;
+    }, [data, selectedPrecisions, overlayPoints, seriesIdOf]);
 
     // Track which date+GPU combos have actual data points
     const idsWithData = useMemo(() => {
       const ids = new Set<string>();
       for (const key of Object.keys(groupedData)) {
-        // key = "date_hwKey_precision" — strip last segment
+        // key = "seriesId_precision" — strip last segment
         const lastUnderscore = key.lastIndexOf('_');
         ids.add(key.slice(0, lastUnderscore));
       }
@@ -453,6 +425,17 @@ const GPUGraph = React.memo(
     }, [groupedData, frontierDirection]);
 
     const rooflines = useMemo(() => {
+      // One path per observed load sweep, never joined across runs or
+      // topologies (see groupConcurrencySeries).
+      if (isConcurrencyAxis) {
+        const result: Record<string, InferenceData[]> = {};
+        for (const [key, points] of Object.entries(groupedData)) {
+          for (const [segment, sweep] of groupConcurrencySeries(points)) {
+            result[`${key}__${encodeURIComponent(segment)}`] = sweep;
+          }
+        }
+        return result;
+      }
       if (!powerEnvelopeMode) return paretoRooflines;
       const result: Record<string, InferenceData[]> = {};
       for (const [key, points] of Object.entries(groupedData)) {
@@ -464,6 +447,7 @@ const GPUGraph = React.memo(
       }
       return result;
     }, [
+      isConcurrencyAxis,
       powerEnvelopeMode,
       groupedData,
       paretoRooflines,
@@ -471,44 +455,60 @@ const GPUGraph = React.memo(
       selectedYAxisMetric,
     ]);
 
+    const boundaryKeyOf = useCallback(
+      (p: InferenceData) => `${seriesIdOf(p)}_${p.precision}-${p.x}-${p.y}`,
+      [seriesIdOf],
+    );
     const boundaryPointKeys = useMemo(() => {
       const keys = new Set<string>();
-      Object.values(rooflines).forEach((pts) =>
-        pts.forEach((p) => keys.add(`${p.date}_${p.hwKey}_${p.precision}-${p.x}-${p.y}`)),
-      );
+      Object.values(rooflines).forEach((pts) => pts.forEach((p) => keys.add(boundaryKeyOf(p))));
       return keys;
-    }, [rooflines]);
+    }, [rooflines, boundaryKeyOf]);
 
+    // Unofficial runs are not date series: the `activeDates` toggles leave them on.
     const activeData = useMemo(
       () =>
         Object.values(groupedData)
           .flat()
-          .filter((p) => activeDates.has(`${p.date}_${p.hwKey}`)),
-      [groupedData, activeDates],
+          .filter((p) => overlayPointSet.has(p) || activeDates.has(`${p.date}_${p.hwKey}`)),
+      [groupedData, activeDates, overlayPointSet],
     );
 
     const filteredData = useMemo(() => {
       if (hideNonOptimal || (powerEnvelopeMode && !showAllMeasurements))
-        return activeData.filter((p) =>
-          boundaryPointKeys.has(`${p.date}_${p.hwKey}_${p.precision}-${p.x}-${p.y}`),
-        );
+        return activeData.filter((p) => boundaryPointKeys.has(boundaryKeyOf(p)));
       return activeData;
-    }, [activeData, hideNonOptimal, powerEnvelopeMode, showAllMeasurements, boundaryPointKeys]);
+    }, [
+      activeData,
+      hideNonOptimal,
+      powerEnvelopeMode,
+      showAllMeasurements,
+      boundaryPointKeys,
+      boundaryKeyOf,
+    ]);
+    // Official points join the scatter layer; unofficial ones draw as X markers.
+    const officialPoints = useMemo(
+      () => filteredData.filter((point) => !overlayPointSet.has(point)),
+      [filteredData, overlayPointSet],
+    );
+    const visibleOverlayPoints = useMemo(
+      () => filteredData.filter((point) => overlayPointSet.has(point)),
+      [filteredData, overlayPointSet],
+    );
 
     // Keep domains fixed so revealing off-boundary dots cannot move power curves.
     const scaleData = powerEnvelopeMode ? activeData : filteredData;
 
-    // GPU comparison currently renders official DB-backed points only. Unofficial
-    // overlays have no benchmark_results id or persisted trace, so they cannot
-    // open the dedicated per-point charts route.
+    // Only official DB-backed points have a benchmark_results id, a persisted
+    // trace and logs; unofficial overlays cannot open those routes.
     const agenticIds = useMemo(
       () =>
-        filteredData.flatMap((point) =>
+        officialPoints.flatMap((point) =>
           point.benchmark_type === 'agentic_traces' && isPersistedBenchmarkId(point.id)
             ? [point.id]
             : [],
         ),
-      [filteredData],
+      [officialPoints],
     );
     const { data: traceAvailability } = useTraceAvailability(agenticIds);
     const traceAvailabilityRef = useRef(traceAvailability);
@@ -517,8 +517,8 @@ const GPUGraph = React.memo(
     // Log availability applies to every persisted official point in the
     // comparison, including fixed-sequence runs.
     const persistedPointIds = useMemo(
-      () => filteredData.flatMap((point) => (isPersistedBenchmarkId(point.id) ? [point.id] : [])),
-      [filteredData],
+      () => officialPoints.flatMap((point) => (isPersistedBenchmarkId(point.id) ? [point.id] : [])),
+      [officialPoints],
     );
     const { data: logAvailability } = useLogAvailability(persistedPointIds);
     const logAvailabilityRef = useRef(logAvailability);
@@ -526,10 +526,10 @@ const GPUGraph = React.memo(
     const [fixedLogPointId, setFixedLogPointId] = useState<number | null>(null);
     const [powerTelemetryPoint, setPowerTelemetryPoint] = useState<InferenceData | null>(null);
 
-    // Warning annotations for visible series with known upstream issues —
-    // same treatment the scatter view gets, applied to the date-comparison view.
-    // Lines here are colored per (gpu, date) pair, so take the first active
-    // pair's color as the series swatch.
+    // Warning annotations for visible series (official and unofficial) with
+    // known upstream issues — same treatment the scatter view gets. Lines here
+    // are colored per (gpu, date) pair, so take the first active pair's color
+    // as the series swatch. Official-preview notices follow official data only.
     const knownIssueAnnotations = useMemo((): KnownIssueAnnotation[] => {
       const annotations: KnownIssueAnnotation[] = matchKnownConfigIssues(
         modelLabel,
@@ -549,7 +549,7 @@ const GPUGraph = React.memo(
         };
       });
       for (const previewConfig of OFFICIAL_PREVIEW_SERIES) {
-        const previewPoints = filteredData.filter((point) =>
+        const previewPoints = officialPoints.filter((point) =>
           hardwareKeyMatchesAnyBase(String(point.hwKey), previewConfig.baseGpuKeys),
         );
         if (previewPoints.length === 0) continue;
@@ -571,7 +571,16 @@ const GPUGraph = React.memo(
         });
       }
       return annotations;
-    }, [modelLabel, filteredData, allGraphs, activeDates, resolveColor, getCssColor, locale]);
+    }, [
+      modelLabel,
+      filteredData,
+      officialPoints,
+      allGraphs,
+      activeDates,
+      resolveColor,
+      getCssColor,
+      locale,
+    ]);
 
     const knownIssueLayer = useMemo(
       () =>
@@ -616,13 +625,16 @@ const GPUGraph = React.memo(
       return [yMin, yExtent[1] * 1.05] as [number, number];
     }, [scaleData, logScale]);
 
+    const pointIdentity = useCallback(
+      (point: InferenceData) =>
+        overlayPointSet.has(point)
+          ? `overlay:${overlaySeriesId(point)}:${scatterPointConfigId(point)}`
+          : `${point.date}:${scatterPointConfigId(point)}`,
+      [overlayPointSet, overlaySeriesId],
+    );
     const dataIdentity = useMemo(
-      () =>
-        filteredData
-          .map((point) => `${point.date}:${scatterPointConfigId(point)}`)
-          .toSorted()
-          .join('|'),
-      [filteredData],
+      () => filteredData.map(pointIdentity).toSorted().join('|'),
+      [filteredData, pointIdentity],
     );
     // Tooltip-only trace availability is deliberately excluded from chart
     // identity; the long-lived D3 content callback reads its latest value via
@@ -636,9 +648,7 @@ const GPUGraph = React.memo(
           powerEnvelopeMode ? 'power-envelope' : 'pareto-curves',
           `linear:${xExtent.join(',')}`,
           `${logScale ? 'log' : 'linear'}:${yDomain.join(',')}`,
-          ...filteredData.map(
-            (point) => `${point.date}:${scatterPointConfigId(point)}:${point.x}:${point.y}`,
-          ),
+          ...filteredData.map((point) => `${pointIdentity(point)}:${point.x}:${point.y}`),
         ]
           .toSorted()
           .join('|'),
@@ -651,18 +661,20 @@ const GPUGraph = React.memo(
         logScale,
         yDomain,
         filteredData,
+        pointIdentity,
       ],
     );
 
-    // Color resolver for points/rooflines
+    // Color resolver for points/rooflines; an unofficial run keeps its run color.
     const getColor = useMemo(
       () => (d: InferenceData) => {
+        if (overlayPointSet.has(d)) return overlayRunColor(overlayRunOf(d));
         const graphIndex = allGraphs.findIndex(
           ({ date, hwKey }) => d.date === date && d.hwKey === hwKey,
         );
         return graphIndex === -1 ? '#6b7280' : allGraphs[graphIndex].color;
       },
-      [allGraphs],
+      [allGraphs, overlayPointSet, overlayRunOf],
     );
 
     const getRooflineColor = useMemo(
@@ -676,9 +688,21 @@ const GPUGraph = React.memo(
     const isRooflineVisible = useMemo(
       () => (key: string) => {
         const point = rooflines[key]?.[0];
-        return point !== undefined && activeDates.has(`${point.date}_${point.hwKey}`);
+        if (point === undefined) return false;
+        return overlayPointSet.has(point) || activeDates.has(`${point.date}_${point.hwKey}`);
+      },
+      [activeDates, rooflines, overlayPointSet],
+    );
+
+    // Unofficial-run curves keep the run's dash, as in ScatterGraph.
+    const getRooflineDasharray = useCallback(
+      (key: string) => {
+        const point = rooflines[key]?.[0];
+        return point && overlayPointSet.has(point)
+          ? overlayRooflineDasharray(overlayRunOf(point))
+          : null;
       },
-      [activeDates, rooflines],
+      [rooflines, overlayPointSet, overlayRunOf],
     );
 
     // ── Line labels (date along each roofline) ──
@@ -694,16 +718,32 @@ const GPUGraph = React.memo(
         >();
         for (const [key, points] of Object.entries(rooflines)) {
           if (points.length < 2 || !isRooflineVisible(key)) continue;
-          const graphId = `${points[0].date}_${points[0].hwKey}`;
+          const graphId = seriesIdOf(points[0]);
           const previous = bestByGraph.get(graphId);
           if (!previous || points.length > previous.points.length) {
             bestByGraph.set(graphId, { key, graphId, points });
           }
         }
+        // Runs drawing the same hardware need a run tag on their pills.
+        const overlayRunsByHw = new Map<string, Set<number>>();
+        for (const { points } of bestByGraph.values()) {
+          if (!overlayPointSet.has(points[0])) continue;
+          const hwKey = String(points[0].hwKey);
+          const runs = overlayRunsByHw.get(hwKey) ?? new Set<number>();
+          overlayRunsByHw.set(hwKey, runs.add(overlayRunOf(points[0])));
+        }
+        const overlayLabelFor = (points: InferenceData[]) => {
+          const info = unofficialRunInfos[overlayRunOf(points[0])];
+          const hardwareLabel = hardwareLabelFor(points);
+          const sharesHardware = (overlayRunsByHw.get(String(points[0].hwKey))?.size ?? 0) > 1;
+          return info ? getOverlayLineLabel(hardwareLabel, info, sharesHardware) : hardwareLabel;
+        };
         return [...bestByGraph.values()].map(({ key, graphId, points }) => ({
           key,
           seriesId: graphId,
-          label: labelTextFor(points, runNumbering),
+          label: overlayPointSet.has(points[0])
+            ? overlayLabelFor(points)
+            : labelTextFor(points, runNumbering),
           color: getRooflineColor(key),
           points,
         }));
@@ -774,19 +814,25 @@ const GPUGraph = React.memo(
       chartDefinition.chartType,
       runNumbering,
       paletteIdentity,
+      seriesIdOf,
+      overlayPointSet,
+      overlayRunOf,
+      unofficialRunInfos,
     ]);
 
     // ── Perf ruler (opt-in: click two curves, drag the ruler to any iso-x) ──
     // Same curve-to-curve ISO-X semantics as ScatterGraph, applied to the
     // date/chip comparison view: each measurement is two rendered roofline
-    // paths (class tokens `roofline-<date>_<hwKey>_<precision>`) plus an
-    // iso-x stored in DATA space so it survives zoom (axis-metric changes
-    // clear rulers; see usePerfRulerAxisReset).
+    // paths (class tokens `roofline-<seriesId>_<precision>`) plus an iso-x
+    // stored in DATA space so it survives zoom (axis-metric changes clear
+    // rulers; see usePerfRulerAxisReset).
     // Any two curves may be paired — two dates of the same chip config, two
-    // chip configs on the same date, or a mix — which is the point of this
-    // view: quantify the multiple between comparison series at a glance.
+    // chip configs on the same date, an unofficial run, or a mix — which is
+    // the point of this view: quantify the multiple between comparison series
+    // at a glance. Load sweeps on the Concurrency axis have no ruler.
     const [savedPerfRulerMode, setPerfRulerMode] = useState(false);
-    const perfRulerMode = savedPerfRulerMode && (!powerEnvelopeMode || isMeasuredPowerAxis);
+    const perfRulerMode =
+      savedPerfRulerMode && !isConcurrencyAxis && (!powerEnvelopeMode || isMeasuredPowerAxis);
     const [perfRulerState, setPerfRulerState] = useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
     // Changing the x- or y-axis metric clears every ruler: the curves are
     // redrawn in different units, so a ruler that persisted would measure a
@@ -873,15 +919,15 @@ const GPUGraph = React.memo(
     const perfRulerCurveClickRef = useRef(handlePerfRulerCurveClick);
     perfRulerCurveClickRef.current = handlePerfRulerCurveClick;
 
-    // A point click selects its (date, chip, precision) curve at that point's
-    // x, including when the measurement itself is off the power boundary.
+    // A point click selects its (series, precision) curve at that point's x,
+    // including when the measurement itself is off the power boundary.
     // Ruler-mode clicks measure INSTEAD of pinning the tooltip, so drop the
     // pin the shared click handler applied just before this callback ran.
     const handlePerfRulerPointClick = useCallback(
       (point: InferenceData) => {
         const ctx = perfRulerDrawCtxRef.current;
         if (!ctx) return;
-        const curve = `${ROOFLINE_CLASS_PREFIX}${point.date}_${String(point.hwKey)}_${point.precision}`;
+        const curve = `${ROOFLINE_CLASS_PREFIX}${seriesIdOf(point)}_${point.precision}`;
         // Single-point series render no roofline path — nothing to measure.
         if (ctx.zoomGroup.select(`.${CSS.escape(curve)}`).empty()) return;
         setPerfRulerState((prev) =>
@@ -890,7 +936,7 @@ const GPUGraph = React.memo(
         chartRef.current?.dismissTooltip();
         chartRef.current?.hideTooltip();
       },
-      [clampPerfRulerIsoXToOverlap],
+      [clampPerfRulerIsoXToOverlap, seriesIdOf],
     );
 
     // Read by the long-lived D3 click closure in the tooltip config, which is
@@ -1179,11 +1225,16 @@ const GPUGraph = React.memo(
       rooflines,
     ]);
 
-    // Dismiss tooltip when pinned point's combo is hidden
+    // Dismiss tooltip when pinned point's series is hidden
     useEffect(() => {
-      const pp = chartRef.current?.getPinnedPoint() as InferenceData | null;
-      if (pp && !activeDates.has(`${pp.date}_${pp.hwKey}`)) chartRef.current?.dismissTooltip();
-    }, [activeDates]);
+      const handle = chartRef.current;
+      const pp = handle?.getPinnedPoint() as InferenceData | null;
+      if (!pp) return;
+      const visible = handle?.getPinnedPointIsOverlay()
+        ? activeOverlayHwTypes.has(String(pp.hwKey))
+        : activeDates.has(`${pp.date}_${pp.hwKey}`);
+      if (!visible) handle?.dismissTooltip();
+    }, [activeDates, activeOverlayHwTypes]);
 
     // Dismiss on filter changes
     useEffect(() => {
@@ -1195,6 +1246,169 @@ const GPUGraph = React.memo(
       selectedDates,
       selectedDateRange,
       showAllMeasurements,
+      overlayData,
+    ]);
+
+    // One legend group per unofficial run (grouped legends split on the first
+    // word of `name`), one row per chip config the run draws. Runs are
+    // dismissed from the banner, not the legend.
+    const overlayLegendItems = useMemo(() => {
+      const bySeries = new Map<string, InferenceData[]>();
+      for (const point of overlayPoints) {
+        const id = overlaySeriesId(point);
+        bySeries.set(id, [...(bySeries.get(id) ?? []), point]);
+      }
+      return [...bySeries].map(([id, points]) => {
+        const runIndex = overlayRunOf(points[0]);
+        const info = unofficialRunInfos[runIndex];
+        const branch = info?.branch || (info ? `run ${info.id}` : id);
+        return {
+          name: `unofficial-run-${info?.id ?? runIndex} ${points[0].hwKey}`,
+          hw: id,
+          label: getInferenceRunLabel(`✕ ${hardwareLabelFor(points)}`, points),
+          color: overlayRunColor(runIndex),
+          title: legendT.unofficialTitle(branch),
+          isActive: true,
+          isRemovable: false,
+          onClick: () => {},
+        };
+      });
+    }, [overlayPoints, overlaySeriesId, overlayRunOf, unofficialRunInfos, legendT]);
+
+    // ── Unofficial-run points: ScatterGraph's X markers in the run color. The
+    // run curves go through the roofline layer; index keys let repeated
+    // observations of one config all draw. ──
+    const attachPowerTraceAction = usePowerTraceAction(chartRef);
+    const overlayPointsLayer: CustomLayerConfig = useMemo(() => {
+      const updateLabels = (zoomGroup: d3.Selection<SVGGElement, unknown, null, undefined>) => {
+        zoomGroup
+          .selectAll<SVGGElement, InferenceData>('.unofficial-overlay-pt')
+          .each(function (d) {
+            const lines = pointLabelText(d, useAdvancedLabels, showConcurrencyLabels).split('\n');
+            d3.select(this)
+              .selectAll<SVGTextElement, boolean>('.overlay-label')
+              .data([true])
+              .join('text')
+              .attr('class', 'overlay-label')
+              .attr('text-anchor', 'middle')
+              .attr('font-size', px(CHART_TYPE.dataLabel))
+              .attr('font-weight', '700')
+              .attr('pointer-events', 'none')
+              .style('fill', 'var(--foreground)')
+              .style('display', showPointLabels ? '' : 'none')
+              .selectAll<SVGTSpanElement, string>('tspan')
+              .data(lines)
+              .join('tspan')
+              .attr('x', 0)
+              .attr('dy', (_line, i) =>
+                i === 0 ? `${-(1 + (lines.length - 1) * 1.1)}em` : '1.1em',
+              )
+              .text((line) => line);
+          });
+      };
+      return {
+        type: 'custom',
+        key: 'overlay-points',
+        displayIdentity: `labels:${showPointLabels}`,
+        render: (zoomGroup, ctx) => {
+          const xScale = ctx.xScale as ContinuousScale;
+          const yScale = ctx.yScale as ContinuousScale;
+          const marks = zoomGroup
+            .selectAll<SVGGElement, InferenceData>('.unofficial-overlay-pt')
+            .data(visibleOverlayPoints, (_d, i) => String(i))
+            .join((enter) => {
+              const g = enter.append('g').attr('class', 'unofficial-overlay-pt');
+              g.append('circle')
+                .attr('r', HIT_AREA_RADIUS)
+                .attr('fill', 'transparent')
+                .attr('cursor', 'pointer');
+              g.append('path')
+                .attr('class', 'visible-shape overlay-x')
+                .attr('d', xMarkerPath(5, 0.7))
+                .attr('fill', 'none')
+                .attr('stroke-width', 2.5)
+                .attr('stroke-linecap', 'round')
+                .attr('cursor', 'pointer');
+              return g;
+            });
+          marks.attr('transform', (d) => `translate(${xScale(d.x)},${yScale(d.y)})`);
+          marks.select('.overlay-x').attr('stroke', (d) => overlayRunColor(overlayRunOf(d)));
+          marks.each(function (d) {
+            renderOffloadHalo(d3.select(this), d, overlayRunColor(overlayRunOf(d)));
+          });
+          updateLabels(zoomGroup);
+
+          const container = ctx.layout.svg.node()!.parentElement as HTMLDivElement;
+          const tooltip = d3.select(ctx.tooltipElement);
+          attachOverlayXMarkerHandlers(marks, {
+            markerSelector: '.overlay-x',
+            normalPath: xMarkerPath(5, 0.7),
+            hoverPath: xMarkerPath(7, 0.7),
+            tooltip,
+            handle: chartRef.current,
+            content: (point, pinned) =>
+              overlayData
+                ? generateOverlayTooltipContent({
+                    data: point,
+                    isPinned: pinned,
+                    xLabel,
+                    yLabel,
+                    selectedYAxisMetric,
+                    hardwareConfig: overlayData.hardwareConfig,
+                    overlayData,
+                    locale,
+                  })
+                : '',
+            position: (event) => {
+              const [mouseX, mouseY] = d3.pointer(event, container);
+              return computeTooltipPosition(mouseX, mouseY, tooltip, container);
+            },
+            rulers: {
+              show: (point, marker) => {
+                const position = overlayMarkerPosition(marker) ?? {
+                  x: xScale(point.x),
+                  y: yScale(point.y),
+                };
+                zoomGroup.select('.ruler-group').style('display', 'block');
+                zoomGroup.select('.vertical-ruler').attr('x1', position.x).attr('x2', position.x);
+                zoomGroup.select('.horizontal-ruler').attr('y1', position.y).attr('y2', position.y);
+              },
+              hide: () => zoomGroup.select('.ruler-group').style('display', 'none'),
+            },
+            onClick: (point) => {
+              const ruler = perfRulerRef.current;
+              const event = { hw: String(point.hwKey), x: point.x, y: point.y, overlay: true };
+              if (ruler.mode) {
+                track('gpu_timeseries_data_point_clicked', { ...event, perfRuler: true });
+                ruler.onPointClick(point);
+                return;
+              }
+              track('gpu_timeseries_data_point_clicked', event);
+              attachPowerTraceAction(ctx.tooltipElement, point, true);
+            },
+          });
+        },
+        onDisplayUpdate: updateLabels,
+        onZoom: (zoomGroup, ctx) => {
+          const xScale = ctx.newXScale as ContinuousScale;
+          const yScale = ctx.newYScale as ContinuousScale;
+          zoomGroup
+            .selectAll<SVGGElement, InferenceData>('.unofficial-overlay-pt')
+            .attr('transform', (d) => `translate(${xScale(d.x)},${yScale(d.y)})`);
+        },
+      };
+    }, [
+      visibleOverlayPoints,
+      overlayRunOf,
+      overlayData,
+      showPointLabels,
+      useAdvancedLabels,
+      showConcurrencyLabels,
+      xLabel,
+      yLabel,
+      selectedYAxisMetric,
+      locale,
+      attachPowerTraceAction,
     ]);
 
     // Hover dimming animates via the inline `transition: opacity 150ms ease`
@@ -1202,29 +1416,35 @@ const GPUGraph = React.memo(
     // d3 `.transition()` here would re-write opacity every animation frame,
     // each write restarting the CSS transition (transitionrun/cancel per node
     // per frame). Same rationale as ScatterGraph's hover handlers.
-    const handleLegendHover = useCallback((seriesId: string) => {
-      const svg = chartRef.current?.getSvgElement?.();
-      if (!svg) return;
-      const root = d3.select(svg);
-      root
-        .selectAll<SVGGElement, InferenceData>('.dot-group')
-        .style('opacity', (d) => (`${d.date}_${d.hwKey}` === seriesId ? 1 : 0.15));
-      root.selectAll<SVGPathElement, unknown>('.roofline-path').style('opacity', function () {
-        const point = (d3.select(this).datum() as { points: InferenceData[] } | null)?.points[0];
-        const series = point ? `${point.date}_${point.hwKey}` : '';
-        return series === seriesId ? null : '0.15';
-      });
-    }, []);
+    const handleLegendHover = useCallback(
+      (seriesId: string) => {
+        const svg = chartRef.current?.getSvgElement?.();
+        if (!svg) return;
+        const root = d3.select(svg);
+        root
+          .selectAll<SVGGElement, InferenceData>('.dot-group')
+          .style('opacity', (d) => (`${d.date}_${d.hwKey}` === seriesId ? 1 : 0.15));
+        root
+          .selectAll<SVGGElement, InferenceData>('.unofficial-overlay-pt')
+          .style('opacity', (d) => (overlaySeriesId(d) === seriesId ? 1 : 0.15));
+        root.selectAll<SVGPathElement, unknown>('.roofline-path').style('opacity', function () {
+          const point = (d3.select(this).datum() as { points: InferenceData[] } | null)?.points[0];
+          const series = point ? seriesIdOf(point) : '';
+          return series === seriesId ? null : '0.15';
+        });
+      },
+      [overlaySeriesId, seriesIdOf],
+    );
 
     const handleLegendHoverEnd = useCallback(() => {
       const svg = chartRef.current?.getSvgElement?.();
       if (!svg) return;
       const root = d3.select(svg);
-      root.selectAll('.dot-group').style('opacity', null);
+      root.selectAll('.dot-group, .unofficial-overlay-pt').style('opacity', null);
       root.selectAll('.roofline-path').style('opacity', null);
     }, []);
 
-    if (data.length === 0) {
+    if (data.length === 0 && overlayPoints.length === 0) {
       return (
         <div className="relative w-full p-3">
           <div className="flex flex-col items-center justify-center min-h-100 text-center">
@@ -1274,7 +1494,7 @@ const GPUGraph = React.memo(
         dataIdentity={dataIdentity}
         metricIdentity={metricIdentity}
         displayIdentity={`${showPointLabels}:${paletteIdentity}:${selectedPrecisions.join(',')}`}
-        data={filteredData}
+        data={officialPoints}
         margin={CHART_MARGIN}
         watermark={getChartWatermark()}
         testId="gpu-graph"
@@ -1300,13 +1520,15 @@ const GPUGraph = React.memo(
             config: {
               getColor: getRooflineColor,
               isVisible: isRooflineVisible,
-              curve: d3.curveMonotoneX,
+              getDasharray: getRooflineDasharray,
+              // Load sweeps join measured points; they are not fitted curves.
+              curve: isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX,
             },
           },
           {
             type: 'scatter',
             key: 'points',
-            data: filteredData,
+            data: officialPoints,
             config: {
               getColor,
               hideLabels: !showPointLabels,
@@ -1323,6 +1545,7 @@ const GPUGraph = React.memo(
             },
             keyFn: (point) => `${point.date}:${scatterPointConfigId(point)}`,
           },
+          overlayPointsLayer,
           lineLabelLayer,
           perfRulerLayer,
           knownIssueLayer,
@@ -1491,7 +1714,7 @@ const GPUGraph = React.memo(
           // CSS transitions for smooth opacity animation on legend hover —
           // the hover handlers write opacity once and let these animate.
           ctx.layout.zoomGroup
-            .selectAll('.dot-group, .roofline-path')
+            .selectAll('.dot-group, .unofficial-overlay-pt, .roofline-path')
             .style('transition', 'opacity 150ms ease');
 
           // The offload halo stays inside the point group, so normal zoom
@@ -1510,20 +1733,23 @@ const GPUGraph = React.memo(
             onItemHover={handleLegendHover}
             onItemHoverEnd={handleLegendHoverEnd}
             onItemRemove={handleLegendRemove}
-            legendItems={allGraphs
-              .filter(({ id }) => idsWithData.has(id))
-              .map(({ date, color, hwKey, id }) => ({
-                name: `${hwKey} ${comparisonEntryLabel(date, runNumbering)}`,
-                hw: id,
-                label: comparisonEntryLabel(date, runNumbering),
-                color,
-                title: getDisplayLabel(getHardwareConfig(hwKey, modelLabel)),
-                isActive: activeDates.has(id),
-                onClick: () => {
-                  toggleActiveDate(id);
-                  track('interactivity_date_toggled', { date, hw: hwKey });
-                },
-              }))}
+            legendItems={[
+              ...overlayLegendItems,
+              ...allGraphs
+                .filter(({ id }) => idsWithData.has(id))
+                .map(({ date, color, hwKey, id }) => ({
+                  name: `${hwKey} ${comparisonEntryLabel(date, runNumbering)}`,
+                  hw: id,
+                  label: comparisonEntryLabel(date, runNumbering),
+                  color,
+                  title: getDisplayLabel(getHardwareConfig(hwKey, modelLabel)),
+                  isActive: activeDates.has(id),
+                  onClick: () => {
+                    toggleActiveDate(id);
+                    track('interactivity_date_toggled', { date, hw: hwKey });
+                  },
+                })),
+            ]}
             isLegendExpanded={isLegendExpanded}
             onExpandedChange={(expanded) => {
               setIsLegendExpanded(expanded);
@@ -1623,7 +1849,7 @@ const GPUGraph = React.memo(
                   if (c && !showPointLabels) setShowPointLabels(true);
                 },
               },
-              ...(powerEnvelopeMode && !isMeasuredPowerAxis
+              ...(isConcurrencyAxis || (powerEnvelopeMode && !isMeasuredPowerAxis)
                 ? []
                 : [
                     {
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index 8ea9fbe13..66cac065b 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -13,7 +13,9 @@
  * (`components/gpu-power/power-series.ts`).
  *
  * One trace per config, coloured by hardware (official) or by run (unofficial
- * overlay). The validated measurement window is emphasized; the rest of the
+ * overlay); in date comparison, official traces take the GPUGraph colour and
+ * legend toggle of their (date, hardware) series. The validated measurement
+ * window is emphasized; the rest of the
  * job (server start, warmup) is drawn faint. Rated TDP is a dashed reference
  * per hardware; the all-in provisioned line is opt-in because it would halve
  * the vertical resolution of the traces.
@@ -35,6 +37,8 @@ import {
   type GpuPowerSeries,
   type GpuPowerSeriesResponse,
 } from '@/components/gpu-power/power-series';
+import { useComparisonSeries } from '@/components/inference/hooks/useComparisonSeries';
+import { comparisonEntryLabel } from '@/components/inference/utils/comparisonEntry';
 import ChartLegend, { type LegendSwitchConfig } from '@/components/ui/chart-legend';
 import { SegmentedToggle } from '@/components/ui/segmented-toggle';
 import { useUnofficialRun } from '@/components/unofficial-run-provider';
@@ -257,6 +261,8 @@ interface TracePath {
   id: string;
   traceKey: string;
   hwKey: string;
+  /** Date comparison: the official trace's `${date}_${hwKey}` legend series. */
+  series?: string;
   overlayIndex: number | null;
   color: string;
   segment: 'full' | 'window';
@@ -285,6 +291,7 @@ interface TraceLabel {
   id: string;
   traceKey: string;
   hwKey: string;
+  series?: string;
   pool?: PowerPoolRole;
   color: string;
   text: string;
@@ -304,6 +311,10 @@ export interface PowerTimelineProps {
   overlayData?: OverlayData;
   yLabel: string;
   caption?: React.ReactNode;
+  /** Date comparison: official traces follow the per-date legend series. */
+  comparison?: boolean;
+  /** Run numbers shared with the comparison changelog and GPUGraph legend. */
+  runNumbering?: Map<string, number>;
 }
 
 async function fetchPowerSeries(
@@ -564,15 +575,17 @@ function drawTraces(
     .attr('d', (path) => line(path.points));
 }
 
+function isHighlighted(mark: TracePath | TraceLabel, highlight: string): boolean {
+  return highlight === mark.hwKey || highlight === mark.traceKey || highlight === mark.series;
+}
+
 function traceOpacity(path: TracePath, highlight: string | null): number {
   if (highlight === null) return path.opacity;
-  return highlight === path.hwKey || highlight === path.traceKey
-    ? Math.min(1, path.opacity + 0.15)
-    : path.opacity * 0.15;
+  return isHighlighted(path, highlight) ? Math.min(1, path.opacity + 0.15) : path.opacity * 0.15;
 }
 
 function labelOpacity(label: TraceLabel, highlight: string | null): number {
-  return highlight === null || highlight === label.hwKey || highlight === label.traceKey ? 1 : 0.2;
+  return highlight === null || isHighlighted(label, highlight) ? 1 : 0.2;
 }
 
 function drawLabels(
@@ -665,13 +678,17 @@ export default function PowerTimeline({
   overlayData,
   yLabel,
   caption,
+  comparison = false,
+  runNumbering: providedRunNumbering,
 }: PowerTimelineProps) {
   const locale = useLocale();
   const t = STRINGS[locale];
   const { hardwareConfig, hwTypesWithData } = useInferenceData();
-  const { activeHwTypes, selectedPrecisions, quickFilters } = useInferenceFilters();
+  const { activeHwTypes, selectedPrecisions, quickFilters, activeDates } = useInferenceFilters();
   const { isLegendExpanded, highContrast } = useInferenceDisplay();
-  const { setBestPerSku, toggleHwType, setIsLegendExpanded } = useInferenceActions();
+  const { setBestPerSku, toggleHwType, setIsLegendExpanded, toggleActiveDate } =
+    useInferenceActions();
+  const { allGraphs: comparisonSeries, runNumbering } = useComparisonSeries(providedRunNumbering);
   const {
     unofficialRunInfos,
     runIndexByUrl,
@@ -763,13 +780,21 @@ export default function PowerTimeline({
   const focusRun = traceKeyRunId(requestedFocusRef.current ?? focusKey);
   // Same visibility source as ScatterGraph: an overlay session may hold a
   // local official selection that has not been written back to the filters.
+  // Date comparison instead shows the (date, hardware) series toggled on in
+  // the legend, as GPUGraph does.
   const officialHwTypes = localOfficialOverride ?? activeHwTypes;
-  const isShown = useCallback(
+  const comparisonSeriesOf = useCallback(
     (point: InferenceData) =>
-      overlayPointSet.has(point)
-        ? activeOverlayHwTypes.has(point.hwKey)
-        : officialHwTypes.has(point.hwKey),
-    [overlayPointSet, activeOverlayHwTypes, officialHwTypes],
+      comparison && !overlayPointSet.has(point) ? `${point.date}_${point.hwKey}` : undefined,
+    [comparison, overlayPointSet],
+  );
+  const isShown = useCallback(
+    (point: InferenceData) => {
+      if (overlayPointSet.has(point)) return activeOverlayHwTypes.has(point.hwKey);
+      const series = comparisonSeriesOf(point);
+      return series ? activeDates.has(series) : officialHwTypes.has(point.hwKey);
+    },
+    [overlayPointSet, activeOverlayHwTypes, comparisonSeriesOf, activeDates, officialHwTypes],
   );
   // Overlay runs were requested explicitly (`?unofficialrun=`), so they take
   // the cap's slots before official runs; runs the legend shows go before runs
@@ -840,15 +865,29 @@ export default function PowerTimeline({
     });
   }, [loadingRuns, responses.size, traces.length, missing.length]);
 
+  const comparisonColors = useMemo(
+    () => new Map(comparisonSeries.map((series) => [series.id, series.color])),
+    [comparisonSeries],
+  );
   const colorForTrace = useCallback(
     (trace: PowerTimelineTrace): { color: string; overlayIndex: number | null } => {
       if (overlayPointSet.has(trace.point)) {
         const index = overlayRunIndex(trace.point.run_url ?? null, runIndexByUrl);
         return { color: overlayRunColor(index), overlayIndex: index };
       }
-      return { color: getCssColor(resolveColor(trace.point.hwKey)), overlayIndex: null };
+      const series = comparisonSeriesOf(trace.point);
+      const color =
+        (series && comparisonColors.get(series)) ?? getCssColor(resolveColor(trace.point.hwKey));
+      return { color, overlayIndex: null };
     },
-    [overlayPointSet, runIndexByUrl, getCssColor, resolveColor],
+    [
+      overlayPointSet,
+      runIndexByUrl,
+      comparisonSeriesOf,
+      comparisonColors,
+      getCssColor,
+      resolveColor,
+    ],
   );
   // With an overlay loaded the chart reads localOfficialOverride, so a legend
   // click must write the unified selection the way ScatterGraph does; the
@@ -925,6 +964,18 @@ export default function PowerTimeline({
     },
     [overlayPointSet, overlayData, hardwareConfig],
   );
+  const entryLabel = useCallback(
+    (point: InferenceData) => comparisonEntryLabel(String(point.date), runNumbering),
+    [runNumbering],
+  );
+  /** Hardware, plus the compared date or run of an official trace in date comparison. */
+  const seriesLabel = useCallback(
+    (point: InferenceData): string =>
+      comparisonSeriesOf(point)
+        ? `${hardwareLabel(point)} · ${entryLabel(point)}`
+        : hardwareLabel(point),
+    [comparisonSeriesOf, hardwareLabel, entryLabel],
+  );
 
   const model = useMemo<DrawModel>(() => {
     const paths: TracePath[] = [];
@@ -936,9 +987,20 @@ export default function PowerTimeline({
       const base = baseHardware(trace.point.hwKey);
       return `${HW_REGISTRY[base]?.label ?? base.toUpperCase()} `;
     };
+    // Several compared dates share `c4` as well; name the date or run too.
+    const entries = new Set(
+      visibleTraces
+        .filter((trace) => comparisonSeriesOf(trace.point))
+        .map((trace) => trace.point.date),
+    );
+    const entryPrefix = (trace: PowerTimelineTrace) =>
+      entries.size > 1 && comparisonSeriesOf(trace.point) ? `${entryLabel(trace.point)} ` : '';
     for (const trace of visibleTraces) {
       const { color, overlayIndex } = colorForTrace(trace);
-      const tracePathSet = tracePaths(trace, color, overlayIndex, xMode, lineMode, windowOnly);
+      const series = comparisonSeriesOf(trace.point);
+      const tracePathSet = tracePaths(trace, color, overlayIndex, xMode, lineMode, windowOnly).map(
+        (path) => ({ ...path, series }),
+      );
       paths.push(...tracePathSet);
       if (visibleTraces.length > MAX_LABELED_TRACES) continue;
       // One end label per trace; per pool in pool mode, so the role reads off the line.
@@ -959,9 +1021,10 @@ export default function PowerTimeline({
           id: group.pool ? `${trace.key}:${group.pool}` : trace.key,
           traceKey: trace.key,
           hwKey: trace.point.hwKey,
+          series,
           pool: group.pool,
           color,
-          text: `${hardwarePrefix(trace)}${
+          text: `${entryPrefix(trace)}${hardwarePrefix(trace)}${
             group.pool
               ? `c${trace.point.conc} · ${t.poolShort[group.pool]}`
               : `c${trace.point.conc}`
@@ -972,7 +1035,16 @@ export default function PowerTimeline({
       }
     }
     return { paths, labels };
-  }, [visibleTraces, colorForTrace, xMode, lineMode, windowOnly, t]);
+  }, [
+    visibleTraces,
+    colorForTrace,
+    comparisonSeriesOf,
+    entryLabel,
+    xMode,
+    lineMode,
+    windowOnly,
+    t,
+  ]);
 
   const samples = useMemo(
     () =>
@@ -1200,7 +1272,7 @@ export default function PowerTimeline({
         <div class="text-muted-foreground">${t.gpus(sample.gpuCount)} · ${t.min} ${sample.min.toFixed(1)} W · ${t.max} ${sample.max.toFixed(1)} W</div>`;
       return `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md backdrop-blur-sm" style="min-width: 210px; user-select: ${isPinned ? 'text' : 'none'}">
         ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
-        <div class="font-semibold mb-1" style="color: ${sample.color}">${hardwareLabel(point)} · ${traceConfigLabel(point)}${
+        <div class="font-semibold mb-1" style="color: ${sample.color}">${seriesLabel(point)} · ${traceConfigLabel(point)}${
           overlayInfo ? ` · ✕ ${overlayInfo.branch || `run ${overlayInfo.id}`}` : ''
         }</div>
         <div class="text-muted-foreground">${time}</div>
@@ -1213,7 +1285,7 @@ export default function PowerTimeline({
         }
       </div>`;
     },
-    [unofficialRunInfos, xMode, t, locale, hardwareLabel],
+    [unofficialRunInfos, xMode, t, locale, seriesLabel],
   );
 
   const legendItems = useMemo(() => {
@@ -1230,7 +1302,9 @@ export default function PowerTimeline({
                 name: `✕ unofficial-run-${info.id}`,
                 label: `✕ ${branch}`,
                 color: overlayRunColor(index),
-                title: `${t.unofficialRun}: ${branch}`,
+                // The comparison legend groups on the name's first word: one
+                // "Unofficial run" group over every run.
+                title: comparison ? t.unofficialRun : `${t.unofficialRun}: ${branch}`,
                 isHighlighted: true,
                 hw: `overlay-run-${info.id}`,
                 isActive: true,
@@ -1258,6 +1332,27 @@ export default function PowerTimeline({
             })
             .filter((item): item is NonNullable<typeof item> => item !== null)
         : [];
+    if (comparison) {
+      // GPUGraph's comparison legend: one row per (date, hardware) series with
+      // a trace candidate, grouped by hardware.
+      const seriesWithData = new Set(measuredData.map((point) => `${point.date}_${point.hwKey}`));
+      const comparisonItems = comparisonSeries
+        .filter(({ id }) => seriesWithData.has(id))
+        .map(({ date, hwKey, id, color }) => ({
+          name: `${hwKey} ${comparisonEntryLabel(date, runNumbering)}`,
+          label: comparisonEntryLabel(date, runNumbering),
+          color,
+          title: hardwareConfig[hwKey] ? getDisplayLabel(hardwareConfig[hwKey]) : hwKey,
+          hw: id,
+          isActive: activeDates.has(id),
+          onClick: () => {
+            toggleActiveDate(id);
+            track('interactivity_date_toggled', { date, hw: hwKey, view: 'power_timeline' });
+          },
+          tooltip: null,
+        }));
+      return [...overlayItems, ...comparisonItems];
+    }
     const officialItems = hwKeysInData
       .filter((key) => hwTypesWithData.has(key) && hardwareConfig[key])
       .map((key) => {
@@ -1289,6 +1384,12 @@ export default function PowerTimeline({
     officialHwTypes,
     handleToggleHwType,
     t,
+    comparison,
+    comparisonSeries,
+    measuredData,
+    runNumbering,
+    activeDates,
+    toggleActiveDate,
   ]);
 
   // Per-GPU and pools are two views of the same lines, so either switch turns
@@ -1341,6 +1442,8 @@ export default function PowerTimeline({
   const legendElement = (
     <ChartLegend
       variant="sidebar"
+      grouped={comparison}
+      disableActiveSort={comparison}
       legendItems={legendItems}
       isLegendExpanded={isLegendExpanded}
       onExpandedChange={(expanded) => {
@@ -1494,7 +1597,7 @@ export default function PowerTimeline({
           >
             <span>
               {t.focused(
-                `${hardwareLabel(focusedTrace.point)} · ${traceConfigLabel(focusedTrace.point)}`,
+                `${seriesLabel(focusedTrace.point)} · ${traceConfigLabel(focusedTrace.point)}`,
               )}
             </span>
             <button
@@ -1544,7 +1647,7 @@ export default function PowerTimeline({
           traces={visibleTraces}
           responses={responses}
           colorOf={(trace) => colorForTrace(trace).color}
-          hardwareLabel={hardwareLabel}
+          hardwareLabel={seriesLabel}
           isOverlay={(point) => overlayPointSet.has(point)}
         />
       )}
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index b2fd5e74c..c6a9be8cf 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -135,11 +135,7 @@ import {
   generateOverlayTooltipContent,
   generateTooltipContent,
 } from '@/components/inference/utils/tooltipUtils';
-import {
-  POWER_TIMELINE_METRIC_KEY,
-  requestPowerTraceFocus,
-  traceKeyForPoint,
-} from '@/components/inference/utils/powerTimeline';
+import { usePowerTraceAction } from '@/components/inference/hooks/usePowerTraceAction';
 import { QuickFiltersDialog } from '@/components/inference/ui/QuickFiltersDialog';
 import { ScatterEmptyState } from '@/components/inference/ui/ScatterEmptyState';
 import {
@@ -589,7 +585,6 @@ const ScatterGraph = React.memo(
       setQuickFilterSpec,
       setQuickFilterPower,
       setQuickFilterTopologies,
-      setSelectedYAxisMetric,
     } = useInferenceActions();
     const isConcurrencyAxis = chartDefinition.x_scale_field === 'conc';
     const paretoDirection = (
@@ -1313,43 +1308,7 @@ const ScatterGraph = React.memo(
     const [fixedLogPointId, setFixedLogPointId] = useState<number | null>(null);
     const [powerTelemetryPoint, setPowerTelemetryPoint] = useState<InferenceData | null>(null);
 
-    // "View power trace" on a pinned tooltip (official or overlay point): the
-    // same-tab click stays in-page — remember which trace to emphasise, switch
-    // the metric to the Timeline display, and let the anchor's href keep
-    // serving open-in-new-tab. Listeners are attached per pin because the
-    // tooltip HTML is replaced on every pin.
-    const attachPowerTraceAction = useCallback(
-      (tooltipEl: HTMLElement, d: InferenceData, overlay: boolean) => {
-        const action = tooltipEl.querySelector('[data-action="view-power-trace"]');
-        const traceKey = traceKeyForPoint(d);
-        if (!action || !traceKey) return;
-        action.addEventListener('click', (actionEvent) => {
-          actionEvent.stopPropagation();
-          // Modifier / auxiliary clicks keep the anchor's own behaviour: the
-          // href opens this chart's timeline in a new tab or window.
-          const mouse = actionEvent as MouseEvent;
-          if (
-            mouse.button !== 0 ||
-            mouse.metaKey ||
-            mouse.ctrlKey ||
-            mouse.shiftKey ||
-            mouse.altKey
-          ) {
-            return;
-          }
-          actionEvent.preventDefault();
-          requestPowerTraceFocus(traceKey);
-          chartRef.current?.dismissTooltip();
-          setSelectedYAxisMetric(POWER_TIMELINE_METRIC_KEY);
-          track('inference_power_trace_opened', {
-            hwKey: String(d.hwKey),
-            conc: d.conc,
-            overlay,
-          });
-        });
-      },
-      [setSelectedYAxisMetric],
-    );
+    const attachPowerTraceAction = usePowerTraceAction(chartRef);
 
     // --- Legend points table (per-series drill-down opened from the legend) ---
     const [pointsTableTarget, setPointsTableTarget] = useState<LegendPointsTarget | null>(null);
diff --git a/packages/app/src/lib/d3-chart/layers/rooflines.test.ts b/packages/app/src/lib/d3-chart/layers/rooflines.test.ts
index 409cc1f50..170158964 100644
--- a/packages/app/src/lib/d3-chart/layers/rooflines.test.ts
+++ b/packages/app/src/lib/d3-chart/layers/rooflines.test.ts
@@ -19,7 +19,12 @@ vi.mock('d3', async () => {
   };
 });
 
-import { renderRooflines, updateRooflinesOnZoom, type RooflineConfig } from './rooflines';
+import {
+  renderRooflines,
+  updateRooflinesForDisplay,
+  updateRooflinesOnZoom,
+  type RooflineConfig,
+} from './rooflines';
 
 // ── Fixtures ─────────────────────────────────────────────────────────
 
@@ -201,6 +206,31 @@ describe('renderRooflines', () => {
     }
   });
 
+  it('dashes each curve from getDasharray and keeps the dashes on display updates', () => {
+    const group = createMockGroup();
+    const { xScale, yScale } = makeScales();
+    // A null dash is a solid curve even when a chart-wide dash is also set.
+    const config = makeConfig({
+      strokeDasharray: '5,3',
+      getDasharray: (key) => (key === 'modelB' ? '2 3' : null),
+    });
+    const dashes = () =>
+      Object.fromEntries(
+        group
+          .selectAll('.roofline-path')
+          .elements.map((el) => [el.attrs['class'], el.attrs['stroke-dasharray']]),
+      );
+    const expected = {
+      'roofline-path roofline-modelA': null,
+      'roofline-path roofline-modelB': '2 3',
+    };
+
+    renderRooflines(group as any, SAMPLE_ROOFLINES, xScale, yScale, config);
+    expect(dashes()).toEqual(expected);
+    updateRooflinesForDisplay(group as any, config);
+    expect(dashes()).toEqual(expected);
+  });
+
   it('does not set strokeDasharray when not specified', () => {
     const group = createMockGroup();
     const { xScale, yScale } = makeScales();
diff --git a/packages/app/src/lib/d3-chart/layers/rooflines.ts b/packages/app/src/lib/d3-chart/layers/rooflines.ts
index c97b880cc..b58d0adb7 100644
--- a/packages/app/src/lib/d3-chart/layers/rooflines.ts
+++ b/packages/app/src/lib/d3-chart/layers/rooflines.ts
@@ -8,9 +8,15 @@ export interface RooflineConfig {
   isVisible?: (key: string) => boolean;
   strokeWidth?: number;
   strokeDasharray?: string;
+  /** Per-curve dash pattern; `null` draws a solid line. Takes precedence over `strokeDasharray`. */
+  getDasharray?: (key: string) => string | null;
   curve?: d3.CurveFactory;
 }
 
+function dasharrayFor(config: RooflineConfig, key: string): string | null {
+  return config.getDasharray ? config.getDasharray(key) : (config.strokeDasharray ?? null);
+}
+
 interface RooflineEntry<T> {
   key: string;
   points: T[];
@@ -27,7 +33,14 @@ export function renderRooflines<T extends { x: number; y: number }>(
   yScale: ContinuousScale,
   config: RooflineConfig,
 ): void {
-  const { getColor, getOpacity, isVisible, strokeWidth = 2, strokeDasharray } = config;
+  const {
+    getColor,
+    getOpacity,
+    isVisible,
+    strokeWidth = 2,
+    strokeDasharray,
+    getDasharray,
+  } = config;
   const lineGenerator = d3
     .line<T>()
     .x((d) => xScale(d.x))
@@ -60,7 +73,9 @@ export function renderRooflines<T extends { x: number; y: number }>(
     .attr('stroke-width', strokeWidth)
     .attr('d', (d) => lineGenerator(d.points) ?? '');
 
-  if (strokeDasharray) {
+  if (getDasharray) {
+    merged.attr('stroke-dasharray', (d) => getDasharray(d.key));
+  } else if (strokeDasharray) {
     merged.attr('stroke-dasharray', strokeDasharray);
   }
 
@@ -78,12 +93,12 @@ export function updateRooflinesForDisplay(
   zoomGroup: d3.Selection<SVGGElement, unknown, null, undefined>,
   config: RooflineConfig,
 ): void {
-  const { getColor, getOpacity, strokeWidth = 2, strokeDasharray } = config;
+  const { getColor, getOpacity, strokeWidth = 2 } = config;
   zoomGroup
     .selectAll<SVGPathElement, RooflineEntry<{ x: number; y: number }>>('.roofline-path')
     .attr('stroke', (d) => getColor(d.key))
     .attr('stroke-width', strokeWidth)
-    .attr('stroke-dasharray', strokeDasharray ?? null)
+    .attr('stroke-dasharray', (d) => dasharrayFor(config, d.key))
     .each(function (d) {
       const opacity = getOpacity?.(d.key);
       if (opacity !== undefined) d3.select(this).style('opacity', opacity);

From 581d765cc5e5b222de5cadc66674061888ef2eac Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Fri, 25 Sep 2026 16:41:49 -0700
Subject: [PATCH 053/103] test: expect concurrency in Chinese Agentic x-axis
 options
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Concurrency shipped for every sequence earlier in this branch; the
phone-width Chinese Agentic spec still counted four options.

中文：修正中文 Agentic X 轴选项测试。本分支此前已为所有场景加入并发数选项，
而手机宽度的中文 Agentic 测试仍按四个选项计数。
---
 packages/app/cypress/component/inference-chart-controls.cy.tsx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/app/cypress/component/inference-chart-controls.cy.tsx b/packages/app/cypress/component/inference-chart-controls.cy.tsx
index 4445d303b..6407da9f7 100644
--- a/packages/app/cypress/component/inference-chart-controls.cy.tsx
+++ b/packages/app/cypress/component/inference-chart-controls.cy.tsx
@@ -863,7 +863,8 @@ describe('Inference axis selector — Chinese Agentic controls', () => {
     );
     cy.get('[data-testid="inference-secondary-controls"] > button').click();
     cy.get('[data-testid="x-axis-mode-selector"]').should('contain.text', '交互性').click();
-    cy.get('[role="grid"] [data-select-option]').should('have.length', 4);
+    cy.get('[role="grid"] [data-select-option]').should('have.length', 5);
+    cy.get('[data-testid="x-axis-mode-concurrency"]').should('have.text', '并发数');
     cy.get('[data-testid="x-axis-mode-e2e-normalized-interactivity"]').should(
       'have.text',
       '端到端归一化交互性',

From 601f873568b6aa9d8b3f6a8be2bf63bfd2ac7276 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Sun, 27 Sep 2026 01:08:43 -0700
Subject: [PATCH 054/103] fix: offer View power trace on official
 date-comparison points
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Moving the Concurrency date comparison onto GPUGraph dropped the link
its official tooltips had in the scatter chart. The date-comparison
tooltip now renders it and opens the focused Timeline in place, as
overlay points already did.

中文：日期对比图中的官方数据点恢复“View power trace”。并发数日期对比改用 GPUGraph 后，
官方点 tooltip 丢失了散点图中的这个链接；现在日期对比 tooltip 会显示该链接，
并像非官方点一样在页内打开聚焦的 Timeline。
---
 docs/d3-charts.md                             |  2 +-
 docs/powerx-permanent-view.md                 |  6 ++---
 .../app/cypress/component/gpu-graph.cy.tsx    | 26 +++++++++++++++++++
 .../src/components/inference/ui/GPUGraph.tsx  |  1 +
 .../inference/utils/tooltipUtils.ts           |  1 +
 5 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/docs/d3-charts.md b/docs/d3-charts.md
index 8438b41db..8589ae5ac 100644
--- a/docs/d3-charts.md
+++ b/docs/d3-charts.md
@@ -134,7 +134,7 @@ Official and unofficial paths share this behavior. Date comparisons stay on `GPU
 
 ### Unofficial runs in date comparisons
 
-`GPUGraph` plots `?unofficialrun=` rows next to the compared dates as their own (run, hardware) series, `overlay-run<index>_<hwKey>`. They pass the same precision, quick-filter and overlay-hardware (`activeOverlayHwTypes`) gates as `ScatterGraph`, draw as X markers in `overlayRunColor(runIndex)`, and their curves take `overlayRooflineDasharray(runIndex)` through the roofline layer's per-curve `getDasharray`. They are not date series, so `activeDates` toggles leave them on; the legend lists them first, one `UNOFFICIAL: <branch>` group per run, and dismissing the run removes them. Pinned overlay tooltips offer **View power trace**, which opens the comparison Timeline focused on that trace; official points keep **View PowerX**.
+`GPUGraph` plots `?unofficialrun=` rows next to the compared dates as their own (run, hardware) series, `overlay-run<index>_<hwKey>`. They pass the same precision, quick-filter and overlay-hardware (`activeOverlayHwTypes`) gates as `ScatterGraph`, draw as X markers in `overlayRunColor(runIndex)`, and their curves take `overlayRooflineDasharray(runIndex)` through the roofline layer's per-curve `getDasharray`. They are not date series, so `activeDates` toggles leave them on; the legend lists them first, one `UNOFFICIAL: <branch>` group per run, and dismissing the run removes them. Pinned tooltips, official and overlay alike, offer **View power trace**, which opens the comparison Timeline focused on that trace; official points also keep **View PowerX**.
 
 ## Gradient Roofline Labels
 
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 221c61c4e..b29c3270c 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -255,9 +255,9 @@ config is `display: 'timeline'`.
   all-in switch scales the same way. The tooltip names the pool, its summed watts against the
   pool TDP, and the mean / min / max per GPU inside it. Pool mode and per-GPU lines are
   mutually exclusive.
-- **Deep link.** A pinned scatter tooltip on any metric of the measured family offers _View
-  power trace_ (`data-action="view-power-trace"`, official and `?unofficialrun=` points
-  alike). It switches the Display to Timeline in place and records the point's trace key in a
+- **Deep link.** A pinned tooltip on any metric of the measured family, in the scatter chart or
+  the date-comparison `GPUGraph`, offers _View power trace_ (`data-action="view-power-trace"`,
+  official and `?unofficialrun=` points alike). It switches the Display to Timeline in place and records the point's trace key in a
   one-shot module store (`requestPowerTraceFocus`); the timeline consumes it on mount, dims
   every other trace, switches to pool mode when the trace has roles, and shows a _Focused on …_
   chip (`data-testid="power-timeline-focus"`) with _Show all_ to clear. The link's `href` is
diff --git a/packages/app/cypress/component/gpu-graph.cy.tsx b/packages/app/cypress/component/gpu-graph.cy.tsx
index 3c8e7de13..f65575296 100644
--- a/packages/app/cypress/component/gpu-graph.cy.tsx
+++ b/packages/app/cypress/component/gpu-graph.cy.tsx
@@ -17,6 +17,7 @@ import {
 import { Precision, Sequence } from '@/lib/data-mappings';
 import { overlayRooflineDasharray, overlayRunColor } from '@/lib/overlay-run-style';
 import { computeToggle } from '@/lib/toggle-set';
+import { POWER_TIMELINE_METRIC_KEY } from '@/components/inference/utils/powerTimeline';
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
 
 const defaultChartDef = createMockChartDefinition();
@@ -669,11 +670,13 @@ describe('GPU comparison with unofficial runs and load sweeps', () => {
     data,
     overlayPoints,
     unofficial,
+    context,
   }: {
     chartDefinition: ChartDefinition;
     data: InferenceData[];
     overlayPoints: InferenceData[];
     unofficial: UnofficialRunContextType;
+    context?: Parameters<typeof createMockInferenceContextValues>[0];
   }) {
     const [activeDates, setActiveDates] = useState(new Set(ALL_SERIES));
     const [overlayHw, setOverlayHw] = useState(new Set(['b200']));
@@ -687,6 +690,7 @@ describe('GPU comparison with unofficial runs and load sweeps', () => {
         setActiveDates((prev) => computeToggle(prev, id, ALL_SERIES)),
       selectedPrecisions: [Precision.FP4],
       showLineLabels: true,
+      ...context,
     });
     return (
       <UnofficialRunContext.Provider value={{ ...unofficial, activeOverlayHwTypes: overlayHw }}>
@@ -717,6 +721,7 @@ describe('GPU comparison with unofficial runs and load sweeps', () => {
     chartDefinition: ChartDefinition,
     data: InferenceData[],
     overlayPoints: InferenceData[],
+    context?: Parameters<typeof createMockInferenceContextValues>[0],
   ) => {
     const unofficial = createMockUnofficialRunContext({
       isUnofficialRun: true,
@@ -741,6 +746,7 @@ describe('GPU comparison with unofficial runs and load sweeps', () => {
         data={data}
         overlayPoints={overlayPoints}
         unofficial={unofficial}
+        context={context}
       />,
     );
   };
@@ -813,4 +819,24 @@ describe('GPU comparison with unofficial runs and load sweeps', () => {
     cy.get('[data-testid="legend-advanced-toggle"]').click();
     cy.get('#gpu-perf-ruler').should('not.exist');
   });
+
+  it('opens the power trace from an official point on the concurrency comparison', () => {
+    const setSelectedYAxisMetric = cy.stub().as('setMetric');
+    const audited = (date: string, conc: number, y: number): InferenceData => ({
+      ...official(date, conc, y),
+      power_audit: {
+        source: `power_validation_h100_conc${conc}.json`,
+      } as InferenceData['power_audit'],
+    });
+    mountComparison(
+      createMockChartDefinition({ chartType: 'interactivity', x_scale_field: 'conc' }),
+      DATES.flatMap((date, d) => [audited(date, 8, 300 + d), audited(date, 16, 320 + d)]),
+      [],
+      { selectedYAxisMetric: 'y_measuredAvgPower', setSelectedYAxisMetric },
+    );
+
+    cy.get('#gpu-overlay .dot-group .visible-shape').first().click({ force: true });
+    cy.get('[data-chart-tooltip]:visible [data-action="view-power-trace"]').click();
+    cy.get('@setMetric').should('have.been.calledWith', POWER_TIMELINE_METRIC_KEY);
+  });
 });
diff --git a/packages/app/src/components/inference/ui/GPUGraph.tsx b/packages/app/src/components/inference/ui/GPUGraph.tsx
index a57113680..ce2e49416 100644
--- a/packages/app/src/components/inference/ui/GPUGraph.tsx
+++ b/packages/app/src/components/inference/ui/GPUGraph.tsx
@@ -1671,6 +1671,7 @@ const GPUGraph = React.memo(
                 });
               });
             }
+            attachPowerTraceAction(tooltipEl, d, false);
             // Pinning updates D3Chart's React state. GPU comparison rebuilds
             // several inline layer configs on that render, whose cleanup can
             // briefly hide the otherwise-pinned portal tooltip. Restore its
diff --git a/packages/app/src/components/inference/utils/tooltipUtils.ts b/packages/app/src/components/inference/utils/tooltipUtils.ts
index 2ae288497..254fa83d5 100644
--- a/packages/app/src/components/inference/utils/tooltipUtils.ts
+++ b/packages/app/src/components/inference/utils/tooltipUtils.ts
@@ -962,6 +962,7 @@ export const generateGPUGraphTooltipContent = (config: TooltipConfig): string =>
         hasLogData: Boolean(hasLog),
         point: d,
         showPowerTelemetry: config.showPowerTelemetry,
+        powerTraceMetric: selectedYAxisMetric,
         locale,
       })}
     </div>

From 14b5bec620c643f233b560617ba576b9e57d6f3d Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Mon, 28 Sep 2026 20:37:41 +0000
Subject: [PATCH 055/103] fix(powerx): persist run rulers, keep tooltip actions
 on mobile
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Wire date-comparison GPUGraph Perf Rulers into the shared i_rulers store
and accept ~ in run-qualified curve ids so share/reload keeps measurements.
Cap pinned tooltip shells to the viewport so stacked PowerX actions stay
reachable on narrow screens. Add dates-only Timeline regression coverage
(already correct on head after 12de0af3).

中文：将日期对比 GPUGraph 的性能标尺接入共享 i_rulers 存储，并允许
run 限定曲线 id 中的 ~，使分享/刷新后仍保留标尺。为固定提示框加上视口
高度上限，避免窄屏下 PowerX 操作按钮溢出。补充仅日期 Timeline 回归测试
（该路径在 12de0af3 后于当前 head 已正确）。

Co-authored-by: Wenyao Gao <edwingao28@users.noreply.github.com>
---
 artifacts/powerx-1220-delivery/README.md      |  43 +++++++++
 .../VERIFICATION_REPORT.md                    |  70 +++++++++++++++
 .../mobile-tooltip-after-scroll.webp          | Bin 0 -> 36586 bytes
 .../mobile-tooltip-before-scroll.webp         | Bin 0 -> 36852 bytes
 docs/state-ownership.md                       |   5 +-
 .../app/cypress/component/gpu-graph.cy.tsx    |  84 ++++++++++++++++++
 .../cypress/component/power-timeline.cy.tsx   |  76 ++++++++++++++++
 .../components/inference/perf-ruler-store.ts  |   6 +-
 .../src/components/inference/ui/GPUGraph.tsx  |  69 ++++++++++++--
 .../inference/utils/tooltip-utils.test.ts     |  22 +++++
 .../inference/utils/tooltipUtils.ts           |  34 ++++++-
 .../lib/d3-chart/layers/perf-ruler.test.ts    |  13 +++
 .../app/src/lib/d3-chart/layers/perf-ruler.ts |  11 ++-
 13 files changed, 415 insertions(+), 18 deletions(-)
 create mode 100644 artifacts/powerx-1220-delivery/README.md
 create mode 100644 artifacts/powerx-1220-delivery/VERIFICATION_REPORT.md
 create mode 100644 artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-after-scroll.webp
 create mode 100644 artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-before-scroll.webp

diff --git a/artifacts/powerx-1220-delivery/README.md b/artifacts/powerx-1220-delivery/README.md
new file mode 100644
index 000000000..2d900486c
--- /dev/null
+++ b/artifacts/powerx-1220-delivery/README.md
@@ -0,0 +1,43 @@
+# PowerX #1220 UX fix packet
+
+Local reviewable packet for the three confirmed UX defects on InferenceX-app PR #1220.
+
+## SHAs
+
+| Ref                                                   | SHA                                                  |
+| ----------------------------------------------------- | ---------------------------------------------------- |
+| Local base (#1220 head / preferred parent merge base) | `b07e1c76d6d2285a27e75bdda65a2d6276a7d1a2`           |
+| Parent #1167 (`feat/powerx-db-ingest`)                | `2c160b2e2238f926adeb3299754c714a2de2ceac`           |
+| Fix branch                                            | `cursor/fix-powerx-1220-share-timeline-tooltip-7b02` |
+
+Live API at start: #1220 `mergeable=true` / `mergeStateStatus=CLEAN` against #1167 — **no conflict work invented**.
+
+## Defect status
+
+| Defect                              | Pre-fix on head                                                                                                                                        | Fix in this packet                                                                           |
+| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
+| (1) Run-specific ruler share/reload | **Reproduced** — GPUGraph kept local ruler state; `PERF_RULER_CURVE_ID` rejected `~` in `date~r<runId>` curve ids, so `i_rulers` never round-tripped   | Wire GPUGraph to `PerfRulerStore` when `chartId === chart-0`; allow `~` in curve-id alphabet |
+| (2) Dates-only comparison Timeline  | **Already clean on head** after `12de0af3` — range-only (`i_dstart`/`i_dend`, empty `i_dates`) already shares colours / per-date legend / solo toggles | Regression component test only (`follows dates-only range comparison`)                       |
+| (3) Mobile tooltip action overflow  | **Confirmed by code + demo** — shell had no max-height; taller-than-viewport pinned tooltips overflow despite position clamp                           | Shared `tooltipShellStyle` with viewport-capped max-height/width + scroll                    |
+
+## Findability boundary
+
+**Out of scope for this branch.** Footer / findability / metric-unlock work is owned by `refactor dash | powerx dash` (child of #1220). This packet does not touch nav, footer, metric unlock, or publish gates. Do not merge those changes into this branch.
+
+## Evidence
+
+- `VERIFICATION_REPORT.md` — commands, results, remaining merge blockers
+- `screenshots/mobile-tooltip-before-scroll.webp` — 390×844 pinned shell before scroll
+- `screenshots/mobile-tooltip-after-scroll.webp` — same shell after scroll; all actions reachable
+
+## Reproduce tests
+
+```bash
+export PATH="$HOME/.bun/bin:$PATH"
+cd packages/app
+bun --env-file=../../.env vitest run \
+  src/lib/d3-chart/layers/perf-ruler.test.ts \
+  src/components/inference/utils/tooltip-utils.test.ts
+bunx cypress run --component --spec \
+  'cypress/component/gpu-graph.cy.tsx,cypress/component/power-timeline.cy.tsx'
+```
diff --git a/artifacts/powerx-1220-delivery/VERIFICATION_REPORT.md b/artifacts/powerx-1220-delivery/VERIFICATION_REPORT.md
new file mode 100644
index 000000000..6449a051e
--- /dev/null
+++ b/artifacts/powerx-1220-delivery/VERIFICATION_REPORT.md
@@ -0,0 +1,70 @@
+# Verification report — PowerX #1220 UX packet
+
+## Preflight
+
+- Repo: SemiAnalysisAI/InferenceX-app
+- Checked out #1220 head `b07e1c76` on `feat/powerx-article-parity`
+- Parent #1167 at `2c160b2e`; GitHub reported CLEAN/MERGEABLE
+- Sibling fix branch: `cursor/fix-powerx-1220-share-timeline-tooltip-7b02`
+
+## Reproduction notes
+
+### 1. Run-specific ruler share/reload — REPRODUCED then FIXED
+
+Production/date-comparison path (GPUGraph) enabled Perf Ruler, clicked two curves: URL never gained `i_rulers`; reload dropped rulers. Code cause:
+
+1. GPUGraph used component-local `useState` only (docs previously said this on purpose).
+2. Run-qualified curve classes are `roofline-<date>~r<runId>_<hw>_<prec>`; `PERF_RULER_CURVE_ID` was `[\w%.-]+` and dropped `~` on parse.
+
+Fix: bind GPUGraph to `PerfRulerStore` when `chartId === PERSISTED_PERF_RULER_CHART_ID` (same two-phase pending commit as ScatterGraph); expand curve-id alphabet to include `~`.
+
+### 2. Dates-only Timeline — ALREADY CLEAN on head
+
+Component test with `selectedDates: []` and `selectedDateRange: { start, end }` (the `i_dstart`/`i_dend` path) already shows two coloured traces, plain date legend labels (no `#N` run numbers), and solo toggles. No production Timeline code change in this packet; regression coverage added so the path cannot regress silently.
+
+### 3. Mobile tooltip action overflow — FIXED
+
+Pinned tooltips grow with stacked actions (logs / PowerX / power trace). `computeTooltipPosition` clamps top/left but cannot shrink content taller than the viewport. Fix: `tooltipShellStyle` applies `max-height: min(70vh, calc(100dvh - 16px))`, `max-width: min(320px, calc(100vw - 16px))`, `overflow-y: auto` on scatter / overlay / GPUGraph shells. Demo screenshots at 390×844 under `screenshots/`.
+
+## Commands run
+
+```text
+bun --env-file=../../.env vitest run \
+  src/lib/d3-chart/layers/perf-ruler.test.ts \
+  src/components/inference/utils/tooltip-utils.test.ts
+# → 173 passed
+
+bunx cypress run --component --spec \
+  'cypress/component/gpu-graph.cy.tsx,cypress/component/power-timeline.cy.tsx'
+# → 21 passed (17 gpu-graph + 4 power-timeline)
+```
+
+New / extended coverage:
+
+- `perf-ruler.test.ts` — round-trip `date~r<runId>` curve ids
+- `tooltip-utils.test.ts` — pinned shell carries viewport max-height/width
+- `gpu-graph.cy.tsx` — serializes run-qualified rulers via store into `i_rulers` form
+- `power-timeline.cy.tsx` — dates-only range comparison legend / labels / solo
+
+## Files changed (expected)
+
+- `packages/app/src/lib/d3-chart/layers/perf-ruler.ts` (+ test)
+- `packages/app/src/components/inference/ui/GPUGraph.tsx`
+- `packages/app/src/components/inference/perf-ruler-store.ts` (comment)
+- `packages/app/src/components/inference/utils/tooltipUtils.ts` (+ test)
+- `packages/app/cypress/component/gpu-graph.cy.tsx`
+- `packages/app/cypress/component/power-timeline.cy.tsx`
+- `docs/state-ownership.md`
+- `artifacts/powerx-1220-delivery/**`
+
+## Remaining merge blockers (#1167 → #1220 sequence)
+
+1. Human review + merge of parent **#1167** (`feat/powerx-db-ingest`) — preferred first candidate; this packet does not change it.
+2. Land / retarget #1220 after #1167; then run **master-gate** suites (full unit + Chrome/Firefox E2E) that feature-base CI currently skips.
+3. Findability / footer / metric-unlock child from `refactor dash | powerx dash` — separate PR on top of #1220; do not block this UX packet on that work.
+4. Production DB Timeline telemetry still returns 503 on prod (branch/preview DB has coverage) — data acceptance, not this UX packet.
+5. No GPU work; skipped remote checks are not passes.
+
+## AI / env limits
+
+- Vercel preview for #1220 requires SSO; local `DATABASE_READONLY_URL` was not available in this cloud environment (secret requested). Browser proof for Timeline/ruler used Cypress component Electron + a mobile tooltip HTML demo, not a full Next.js + Neon session.
diff --git a/artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-after-scroll.webp b/artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-after-scroll.webp
new file mode 100644
index 0000000000000000000000000000000000000000..d5ef5dcdd028d4972080523c37d5dc752de23942
GIT binary patch
literal 36586
zcmZ^~b9AIn)GgexZEIpX6Wg|JJDJ$FZD(RTnb>wFwrzYf^LyXBzWc{rt5$cf?y9Fw
z?Xzp2UHx<`N{EW?#sC0nB7*X&@*IRqe_k&b0cQhI0l)}B000*7i_z?gn<x%my)U0n
zOWaQ1@2OhaJXpSgS+wa}x=SdVk5gC$p?2inTsU0_?*P7DPo=Er0)%P4wR@gpp+~!C
zpTc{g?{Mpvx361Ip1q6o<Mh?Heot3zIjz3uug9PLpFN*nl^CzpwVNh<MPJh&rBCJW
z=}$GEBnu#K(=T%BUn&H*K6&`ATN!%rxraShpQoN`uYSJokK-qLcL>*dTOTy;I?u7U
z1TA{IJUq8H7hhYxj(q*^^FB7o-Ge^W4_q%_I|#eJ0guV=xo<VsIXs^(Z?SLFS6j(j
zL<Fh6Y+n{14NFGnU$<XHUq-tJb-w){Wsfiq^QT)+U!(40zPTSyO9)e6ZN8&l<kukY
z%Ww4W(`r4VzI$J!Z(pZikFmEsk39oE*4}<!+@F(QLhov?vFm!pHD^7~Uq9cE9v@!y
zUiCipPP&15^1poUPrtstDz~?;%)Y)p_z-hjx4ypa@O<osN5y+Hxl5wFM)zb2jQ$_Z
z0758`>DbyRDac+k5skYi5Xr<8v3ar9&r8J#-*u%TRmCVlW4I_iu^==OUO7?4RjKKb
z%66s^*F&PBgSOE~PB@p`q=nZ9F%bDrw~WgA^~}my3+WD)y4C*0r*i#PSGt45kcr)<
z^XSyaH>M?stf#k3sS6ddUf`$x#EsM2$mV9u>pADM@O5`3zkCODEhU~XfpD6=Ir7m}
zo9Wyj!hsZrePOEe=E|#Ih=x)e_kUv0ayr_9WF*b<kiaS*o#Z1?LLXCR#@@<*FRXQP
zgl^#al?$^&=^c9VhQ9{r*)Hc+l4{a&cI5UB+D0LaQLKNlKQZb-8%X^=MCMVZF1Uvp
z0ys1mg!@qWKNFsiRh%~;P5<8$GQ1f`-GB~I^lG>ga?$22+yWu`t*OSSZ^3;id(?YY
z+<tA=@w1gRkxqhh^!ARi$kxq_zsB@)2bHn#aQSI{HJ<iJ@E2Hyh!o|b-q^mW{5BB-
z#pxF%4T<q}rEMB(Qw?}yk+`fpg%bT1{tGVq2Da>gmq{QBt78FMDp!-9Dw-3y&Q38J
z?9%m4^k%@rzA6EO(gL$S^SLFuS3j$03nXG$ARCSQs*Au()4x<uw>PKEJX8T#c6P%e
zRbbo9HYw?R6p)QmXl#;7uB`f8d3CuPf7N`GM9O{E_C9p`&Z!cein5k*kEy;mF7U1Z
zF9aA7Jkol^7OVEPX#a(8Aoy@TzuvY4_$|*W?c%Hv$1;NkT1dec;K0J!Y(iR3J|c*c
z73qmIp~su7gE9RQ<cz`xgcY(mUTvn8%mh0a5ImT}*?FqebYfW*Pr6m-kp!qhQf@s!
zI+@Cvokiyn6PRpXel{Wl{GO^C68LrllCV-cLEh0-@ce3Bc%L}2;teQB=~2Hi0!1?-
zjmO4Emu({EhC@4r{P;fEdAfR!miyR+UQh0{uXS+mduxzl>Ve+i<zzAXNf|u3Sv>Fp
zv{~lWQqwJ-q8J;y0L6md1`?lPr}EOel@cv%q|jZ-V&nQ@8b<W&r@QlpxmZ8m;jT?s
zn%X|1w43P#X@o3ym(k&hJpLn!iMc!2B;4NDGk`m`L}f&O=>|Fsf#_;mE4k1N0d>%`
zN&p_t5iKKqU-Ld&Jur#qNas~A-&0kNe|o%W;DF;E7{LFiw_mm_x>BpnR|Zl{rxHTd
zow>bK7gGyn+GW;1z>qTKl9k9GY@=d>-E;~(NP+J^;xqFZ2I`8ZEzPm!_ayE`YFv3%
zd&9sztqfDFNsYQ*f~sA#m0ycEZEo7B^ATCgIkRQZUf^2t)hH?D-Cll>!}5F^l|u)y
zCe4%*`~x1*1hGfcBb1?>%4-2;(QZ70Q6zk#&ONJxM!X@GGZnzJ?p$a-JdwjH5#5m}
z^^B@aC9d~zCIrM=4v8SO!j-5l#N8F8P|Y`vf8&(t8l7|6-SMOf-Rk$*A4nd}wx}&d
ztk;N$<xKm-YW`3T+a^kxw^c;AT84|*q}68~Md-3^{AtbIi%t(l<qNV0nNfF`TU}va
zln^BxXc3=qcDW<KT9Isp2`zAsweQsEj7TG5uw>33Mh$t)o4EX_s&RtbqEXtS(f>_$
zjq#2=>k3CVm&twJT40qVxj-YO=(z3RY2F&QS#ug(F8h+Q^-kjhwLg73Erup`O@BHY
zck1eSb6g1oI)G%>YRyY{M@Rrl6x<FUiUrSyT%c>Z!+_L2)Ari^y~_oXK}__%O8=&0
zma$|G66o*KtVrQR4$B%D%RWGQ21adScJO*15P%0iVqww7$=@Qje-by)UAMn_WP|yV
zI8@mRk3j3;H6ACFh;4&{ZIju{IEAly|K}4g&}yfyG8MV>ziZj%6UI@poo!h0uJyt8
zF8yz4DB0g>{<LG1z;9&;=Ny05XoFJ@f)y34*0j#in@;2{DH{VCn(X0ErYWbVKCDI@
zjni%YgakC#O?x{4bUg(6XP!*qDG-}Nf<I%;)5iUK>tie`hRlDkg-8EsYOYFB)kfWn
zn9%VI$Qu6wOG1zR*Y!{D+VNgGIP5kRUgJOOXZAO4)+1@+!rG7DZ9E#&4ank2$J_52
zdPopQNIIIbg#Q6#{1nIG1Ofgh-zXe#&Hqz%_&$L^1d=qj|CONPog49k%yU9PmgU*0
z@R65s`ExEi!@szoU{|lc{!g9qjl9J27pl?t$DQi)B36HiYOTo4niW82dtkXD5?J47
z*WZ}tzyklW?axXgI6`^9|J+)!|NAZ^)!?@T;Sq;0unQP`G0$C8Vm7ep5;&>XEpms2
zDL)~-OTWCII^ll_ByHJYc5?UMH8vj1CR85=YW4ntKP)wXtEWh}dZoZaA5{UbE*vf^
zDuZYb!XiNQFAWwTkJ*hzf2obaja}U(HUA&NHaPj?asD^&Y(DlJC<n0k-5Xu1WZYCG
z4$;WV|8T)06Hfbs?4Pzc-0*NP^KZLE(8|PM(r&xwr4!H|_#^e2&nLx{KF-FbbN~Os
zTc5GO1o<~|J{{s0we|3AJLr;_(E$K>aYFlP^dAgyd=~4X|7B|g)Pyf<=b%O|UBJ@%
zvyZ^RD`9a`fT#>uZXXNinPM$M7)|RgAe-9*A#b9UZ@Kg@rTJ_B;`f*0;?3`>k3ar$
zXDDlgS4gecJxh(tV-ajlS}P{4-AFOBbC$9;>W=P|zH1y`U5HB6wlUTl4elSQvcUf*
z2FA+oML6f{e`SPaUGzA79fdQb#fRTF#@qucf29Cbky)?3`~s(|D@2|Qa<74y^Tt|X
zgigHtbIBw6KZsnX|Eb3xdUQKfR73;9|AfXkcLO8KN;3w7OX|}L?s4EM<Nodq!=yiD
zZYDc>nd2S$4`=q)|Hb*Dw`@eU;vcijfX5<ELF`i&No`bBnZ7|J)OyHH3b3A>!k)o@
z0YwC#K&c$gB#!>$Lrf~cKQ_%W7VFAb$9T(s0)P7pM`Z^Y)2X)et2hL-uweCI@Qd{J
z935ZnUwRiIthxS8+8<io>`i_{{RibAHcomj3_QAZ<$rc7({$F<e5~Yg<VhT0tOh_;
zKDOVL)rbB%;7&G>t+{fH?)#fC?#&(K|1oRz8V<hX|I~(4mk`CMD1`;}`j7Qlvu3T>
zG({`Y_BH7HlO%D1#*6<pc>0CbB-W?>?Vo(+H3^a8v%Cwet3wB;dLd%{3cO56nqI9X
zs%h|mlF%6WCr6G#;0{YOMi0=*-T^IWA~*7CuKqcKWhNv)f+YSj>U*3=ok4(WX{rd9
zo?%&lE&)q0BAJ=SKlQDoq@T?&q!r4wInYb%EHMNUF+u}n{Oj9f{@EyhX{}o>J^PV=
zT9#@4yHjoS%_bY6VoURdr08WN%~Lb-XyNm(en*|}lOayy$L3RVJX<cNtIoZI!|&+l
z&SXyb=9k*6vC+~E^;l4;d9|+{QZ#dIuwVqmZ`~0TgZZlKnN|^ly~`dr2O!qdiiqT$
z%(?BA{R|mrz~{hr!sa5fXhAk%RH7)Em8`B^!B%YX{m5^_|EtHNd&N85q0LKk@?tMH
zRINX!0>6z7^e#Jb{^yikqOrZg{7R*j92CTvYm0=qWof>`qM4SzX9LpHvCak%adp#_
z(F1z0bRE_=vC0=xFt}zAgxeuJw5u(?5&x#I^$h$!2u1`vBgW@TvKS%P2ALK(jS_EQ
z509WYvxsqI7){pefPVi=>XMZZmkdwAZ`H9jUW3m(H44Y^KZK%4BhUNR=12g>pe<F)
zCI4-!HFmz}<^v4V?=MnjUVze+VtC9^^9jlS5!kc>c5D?=m}#s2%0hzbJF(_YkGHJq
zKygE!@m4R&|8|vIkNDy5LbJA{M$&(kXqe^EeHhe!t0MZH3A#pVZ_GSRXRuaIzzI|O
zomwWUau;q7Vt>=ANn!u@NjRm`S?#bVQmf5FbSVJ)lBC~-Tl?3<?`8A)9>$`Atv*BE
zSaCvf+Zl-jC%AUz0`2yQdSQ=7)-KMV{}qD9gQh={`@br&Tx&pk?)KHP&fpew9u1|^
z^FqrgNLmt1m%e9#Wyit?`rWgATiY!RN=c3rWic*50BFFAm4H3%zwMp&>1~qR*)S)=
zYt?q8vy}7S5huPXnrP@T8uzx?vVGef&klwTzr+P^@8~Mi*>2j!G^+&zCV^w#yi8Wy
zF)J|zW{(6x9UTNv{O^RMvH<}RF*fS-D9HktXiGY!_0UHN<BJ!F_@pct%AwmD{pHb{
zJMl!rxuLhsK8*%h>GQXYSTwqE7h-#kEHsgWFR!u2l$Z4nX#3kS3)K4P%een@3nQwK
z&<q$D>TN1GwEvX?x}cNu?p2a9rr8s+0#-=bk;nC@!++Ihs8n^w+_HN|o1xX%q0D#j
zT7hDn-siJ;P2)@n;_r@$W{Ve2wL;Jp$1qU&J#K;}jokhpak~nIG5YZnEUP0eCk}s;
zb4~s0&C&U~NA4e>2}(BD;N}nt2W*K_TaAcL3gZ;)1dxjN_K;+V^0j;M`D>zVF3!iN
z??O}lRoK6^fNAufi5SW>z%)c>YEH&{Zo(3GQ=BN3$M<d8PrqVe>0>?Z(oIR3{!cmo
zRic0H;$Jz)pqUdrY>PoP2J5uYC@b>Bf})ymjHXptH57jFv`rcWsOesE`9TgfJsi2P
ziBhd1Ja^_(b74q?TFgi2->~+Il-(lz_)pUQ;rO2;`uoUv0O+~vvM7=w-7sFsb1d>v
zWKH|>Fl*ve85ZEj`u<PGm8vWK;kg&eLR|(3jVnMvP^HTkN;`~w$wQC5Ru%r7AQKM)
zAFxhYZs76z*>WgW^smEXmTH4gsb@kuNm-IZ^+DH8s`jS3<w>RiW3dyZETHuvn-+Iv
z(w;Kn9NNM4+^w^1=>{OK=%nk+gBV|v0Q~aEfwS>b2OU<7b45(*hO6wk;K9n_AFpxQ
zGd&!E<%^s1<LRZ<xJ4rH((z!Gs%*?775zF7#Axl!J3IDKyGSHj`mh@duT;64S<~d)
z1fJR8W+$chIh-UW4&3c9Yp)LR06F=J)z4gaG66)UX&bD%zynN!auK&o8X>^w!4vWo
zPQ9&q(=RV2hqPNC@EJ>fB}<mfi#Bh=hd;jIs4sU=^VMs{5}@3ZXAs!1Y<r%GYTq`D
z(;Y-oAKY@VYpHoIl;^AB{W}~P{A%#HY<i5TM@FQ<o1RQkTH3$Cs|kUSaY~hESh3l>
zw*~lE-^#Toq@W4!XfleG&7ObVpUxuf!u=*dvNkuKIfHRh)>Qp4^YUF=f6FhP&ND1<
zhNBJseheE2s)dJVv8MF%BIW#(-%{DTw)EZSLgLf18j0sO3Qnz(g9E&UoWGjFyL;53
zrE{FH*E2)Obt&nOhe{exO`#^H>{~<T+0y!9<={@6mx=kk#5``Z7<OniP-Gds{2o}g
zi3$k>Cc=3{#yf$|VP_nzckY)!bZ_n^kH}OTEIqNaEou&LIC)Q}Fz)ny>?^60O#g_o
z<|}r;?G8+iBlja`F^t=1qU4+!pQNd1FBt=Bm-FW9KyS_Dnx=GbamWDG?osiG7KU7^
z({xRsbKPosQp-a78uhIV-^P^0v}d?@k!nrskm4VmK35iLyhTZvAbCEMRJkL@kurKT
zXsN-(KvEyZcvy+c^-pQW!oSIuJbs1`kte$Y0I!37_IH}P69KbfSH)mX1BcpY@K&ro
zcCK0zYcl5u*}LRf=Y*Yr8(02cAc32BC$L2bIRi2BpD>zF7kbEiM>ih>GuYZZE>NF?
zSe?7Ml2UoWHTaO7!=!{3shq?oxQd8lJeU^DplK28uFDgClJ(;K9t=t#{((JM`riRi
zVH*H|IW@j_&P}^e`D2&7S#`lP^hdbHHA;l%1<sZWwRrLEQ<2QjdLis;FyaqYucqC5
zvo;)!E?_9m?2k*%n>1gfmQpSG?8W>wEaYCh?kA$)<<~~?)?Txa>b?Et86`;wx~}EJ
zyQW%N=pDufiSa@CBqrr@+Pf_@*$wWDIk@y)MOpI$=}K|)#y){yg&HI#ZmR48%tP7f
zGcAADt_n8Efp^;uUBPc|+OPV6ZY#@lnaDbb>|Tnp%!eA!NJ5axB4N$w4dcFPDB1aq
z5B7+R-j{)1*+6!j3oWll6~Eq$)9($Od*?t0#v&e2R(?AA?DIbnR%3b=*?9O>GYE`y
zd-_IzwqHavB>Jmi*}41lzg_?QuuIyZ=w(e9x5lzl`^?U*HX%h-JBQ6V8;Wk-fL-#i
z^4h#u24^a~2gS(&k!w&RiZEhzJgaWTt&YlYy_%#}f3YGZ(6|G;tVBnrAK#x|MzYF1
zPGZe$9IAN@_F62PbXi_Vo(-`)C#!s(p-WL4qSQdUZ+(4Qp^pzcbHi$l0(*&NsE%Nn
z*__rHtOgCv_7GxgT9EDbVZyahI`2==30Z^6RNd{6HD5i;={5=Fp8T{my%Od*xMCdP
z{04nTJxO8Q3d4o$xN;PFd~FoH+#};A9NQTx&7JH+X8>1MJRpWlgI0(7uv2B@+oM0x
zb58*gbmL>%<#m~VKtd>@Yr!N<3in9GSwDyz5c*L(#E%DM*w=4o)`G;JUtpIx20w)J
zWOVx}ajW^7w&u||rAh)KTqHqX-<OhI6DtYw${W}RDkNfShr0E7!&6m!E(Pw352vld
z)8zfQbOZ{il6Mf^8rJ{SH{xr~&yHTI7Vr*dc~*3Wom!ounoh82BX7G8oFtXlCa`^(
zmx3W|BRfC2)xW;ZyfpNcSc+pZ(E|iTBR6)$sbu_;ynUX^po>|nW*hm7@u#}n_-6Ju
zFukLM6j5&lVsSfOOHp>rb7-O8gdRU556Bu_9_N4E5m$TgW4uKw4HitFA8b}9J&(#Y
z`UF-3zHyhwmNf&UBewOr^l}+{<!^KP6+C6`KdXC)rp7*P<Ff;)U<cTmSg)^|w-#>H
zwm~Y1nqfW&?jmD)XP@{K_Ob<~sYg|eI6*Jcc|WdawE%h#5qJyrHJ=hgmsi2j;M|4h
zyQf=HJJWi}T`XBVomj)*1G;(Uxu&tqHgXZ9-HHwCJL1}DzJc2}oBkE+CUrJ*9+U%h
zmYPN?kK$M;)Iw2<#*VC5XmV`;_#>tYy9tdFm7(lNLP8jZK>uc7X}urB&Uc=j#d=~2
z1<qMh-~_X17SnK~+rPmFU_J&aH;WvuctDSIy8Q=fa2r3T27IRWOGX~#64ItcPmn@C
z#)(4bOW(!w8@0kS*{oM*u+R@*r{q?L_e!}mJ-F{mKtgN}=^nDU^XjY1uaWI>Prhpz
zj|fJGQA=>~d1u-h<~YH)oA9B|=w-CL+oW?#E=7(Fok7SOB-AVz4C1g9+~)K=mB4<S
zfxiw?e&w`6LyBi*3Nj-RLoC5!?yEc|6tbgU)yq(weGs@wrbvLYx>ndE&ShIq-$iug
zd;Q|H?tRf0nWHwqg#J+L9_=s*#rptza@XbCL(mACxnC5WsG3=Gx8DlApM5x+%d3WE
z#xUFztAB?S?2qRY8*_@~#?6kj_&7l%IOM3urFAg%dy#CpV@okHN$YA?JSX%Q!8%2Z
z1iJtb*_No<Y9pZA$!Q;{M5KOrtj7|RvjOO0*Dt(4dVF6_m?xR?CO`Ixb)(^02IA|~
z!y-kjD|4vGK)RM}3W!pO>Dab_5ciJ{ob{vYF3A<0NOiOqs<n>2Z<+fb1)dpQQwi&h
zjYGh$;(7oUOuo+(`9F5%7IzqyV#3r+7E!*1?q>K&nZ`^k-3^=o>hV|rIXC!#8<}Gu
z5pr(TcG*DT>Ystd{Y01D5UGIf1`3_E9)SWib-|&q?tA}W2c_mf;ToLc)#75-69eKX
zd<wRoo_$XWJmC8}dJEaK&^+Xjz;>(YT|L>#2+hnp?t$D*l5^2O3!6|!Df5aGUUbVO
z!`Th52(HGc=H_XbPD%d7OEvi}B=@fP#A29okF+#{HM}VwAOOR4Pzu|b`}fX<BmFbJ
zyq8R|6rn&BaMV~$z#$r3l}zrk-_frgZu`7-5{C$(<_Kin^8|44P#$_*0m^34-E|ri
zCx-h-P5EUgR?lS%7J0!8I3kJq6=rteb*pYv)*->yCRmqtp?62*Q&(lw)A=i(^7bxC
zEk+PYsjx{z7HQLWebs3k1QM<p&7M7b`D@y{AlAFu;p&Q*U1ZP6E&F)Q`)@K0nT{Ij
zJiTx-lH(NuJvcmLTRl5FHf^&&=f287;O~?#P3AXSNSVdRa=$#M^%5TR9Ro(LE4XMs
z1>P9_sBXI(%q(H1_qC)*#fEW#4fvcp6+wQ)%YQRXegizG5D=lBw5r{YSW%vCieZYF
z==f^~3&zT;>;nCShe}gGmvH+zWw+h+tAXkh<m-h0xd2q@;N^@CZWO_!&)Cb*5C-Bp
z?+T))nFEn;Kqh{%%Xu<7Z>HF~E4u~GhnOdf>$IZh<=t4+racfragA7L0!-W3fej-|
z*Za&{C0&M4tKEHEVB^rlyr+~`TI*7Eshcv>&XOwFhR~X)By7PAZy42W<vPWeuFX!P
zcao_m*+14T7}w)9u=MJha5&tz@wP^3Z8sw|X?$5*Z6#svQAALR0#m;xUMklI2{ec4
zH8!h?p!|;Cww)RH*y!hIiG>ju=!jDV88Q@Y53PV6oj#7a@)BOoxL)Y~q<~&%dB&hK
z;`EI%AN|3nd!JLS-?+=jQAdo#I%g>wa`+0lz~eqM{-@jEO{>a}vMO(+Tf4l92>>Ci
zlT`oZn9?h{8XvKpWS>8ZGR_1ImqFP06sMUNmc?=@Ipt9}W&rD}wCfz7|F&-bVYg?<
z)ozLU8(n6j-288z=zYCw*YVWb`kiX_Br9gRda6+{;2+xWKY^o?WQwvTV{ZCOzF(?k
zDJaj+CE>xlNDq399mFH*6X^z*uYR@F+GkSnN#O_rTEDphsKg%Z!_54Wx!I$aTT)=7
zB)EUMopY;?&w$&v8qR>jU`tLa`#++4i~aDX-hV*zrJ^gFbZStYo8}75(Is~QihM7t
ziuZ~|UODkFaWA*#=Ct9ko4+5Nb%1ns`8gh)PRZ$2069t-`B@0YsMb>MbUpEF><jx_
zHBV)VgY+zGIv+6M<n(Ye7Z2R4T9rwhTioacYQU{h+!q8oVr`Ka;=v}=86>;3-gck|
z=5uI_Wu8=(f<{?D@b})KM~T~suGOM!_5jgw0BKlI@jzAB_F+$cFa;xOFlvCp>`{=m
z_Cd-jq^l*tTrYb}EI08UtPa9)9$^o;SeAQ4x5=&0^e>jW=P*sqU!*VvEcSYw9Z>J?
zZz2eSNVngyaie_N^}35)%bzoc-;C}=e?ttJ#pEuIT^?K*KeKD(=)4%Y(0bpPcf=4(
zz)7zGM~VXp=yi<byRJ<WP4u!N!im|Cz`R#B;7Hs!aB4-4K=C&f{K#T#NXK5wUvT>=
z6(TvK`6;A{q7;sO>@L_Bjc&BH3$Hw^$RGwa+o;lBWC<lma@!2TSYorK|8weUW##74
zU)F;5`U?JeOAUl9=qvWgeBX59dMF}~fiM*L8|*nSdOW-|EEzt{4K;dvL~o95<?k6U
z8ECzPidwbv_Wr|Hu*?yn`GwRM(mRy*kb4P1i&k<+yH7@Bivq2lKDULVw&<~S9@lx0
zFU8og@1S*kX%#!bQx3dR@ITdB{1C%g%%Hm42&6<#t)dl6cZg94L2vPXLZsjKZC}VR
zcYlh~NJA35q0Bfa5I=0Vj?gKu89GoK^mN$2G62tn+%IqMMTDHufE4InW?YrYbn`_2
zY_~++uOFV8Ov_aHgasatQ%c|_z0C9!X{!lWEXO#l_%b^^GkUK?shlRZ>r_t}W^&JH
zoi~!G?Z>gv@6;Oey>WG*eU&An?sRAM93iQEG(U&l;9hD%^ZHq6wcxnO8*O+~$SEal
zv;_}O7)PX4IX8VZXnihlom(;IxsFfl^Tnw7{;l@OI1UKCPD`CC0d5}|>-DHRW4K(?
zJl_^gbd{jUy@Vo1N82Z`5a=3!3<9K3@>Y`>{EbW;SlKD)&Z@As3;~SmGN{lzlyhm6
zaehR$7%~BN1J*EN_fT5_h8(oA(sezxV6+XxvoV7=_qC|)47qQb3X1F4U%>*pUSp13
zEZT>0yg=3#iD4vkQZ^D=3}PIR9NnqL+lq{zro{@4qfmD<kILzSc`>W!$!t47IPAhd
zYX9@+x|2#`R>i_t`uu65)T`wa58)u4d!b9;F<iiF?OVI&2jq(<?SqGpd#B0+rk`dA
z{xu>wJhOwV9`*V_JN=}8nV_mcpTE#1uj;*jML{ggQp5hy92EclGo*S@Wu-^s2G)bm
zS5}yUjL%n-bFqZa-t12+O5zj+9WrmCv{H_I`PjtAvAp3GaX+ABcB2aKug;X%X$TuB
zg&z1k3N+1n;Skh8C)Ai9<}SofGH##bYR|MyyJl);zJ%?bk_k_o@fan^SGo!2M3FJA
z>vui2QFx`Dbr4p=$H`M3kv6&3=9N=aMs#Bvv!T_IFoKWQ-63_woGCePVyqk4$aVq;
zkiH&ucW)!{!5BcKu&_|U8kHIeQw@l>8)8DzVh?^8CefmdfnZoxvlyy9llP9;h1By;
zl^FYsH$Ylm%&=>_Qm}sJL9TqWq-;numt*{EplZpJOf=vt2kUI{_SpVJ>#1FDi7e!{
zTi$_oClQcC&Tw$TGH2Fd%;e!KYa0tV=e$OP(}-xlpAn*#nQ}e}osD@(g6?;&%)q+(
zah~h;m&b)gO8eOSocNElNb~3RGAjLb)fihbBv8<5Oi<R@og1MJ&fRmP;0pBy#$*L6
zdT3BD8BS!i1Wet6AhYgHegY;;JWp*?<1i4mK$3Xjml<2x{VeH@Ej=yN`WZe6?oNE$
zp%+)LVS-TO)x0ky38<@>1nF_xH;Qo%f)x1|FoK_zUoq0t>THx}w?(6fn(X;-!=9D1
zT~r|D3*cl$oKpCHoES97omq&Zg`xDh!otl=c$f`zBy^kDRFkBLnbv$ujG-X~<Bk+6
z{sC3uz80tpQp33hH^ZSEYH(a&ALtqmau%B;1!%p;0V@N~*F_}XiU^=)4wHETBPqVb
z40Scb;3+88aJe#uQiL!^fBdHNj(%jveOurtk>IGcf-vF|>q0sedf@<aBansoBtQ^i
z?p+N7N1V3USpt@C;Ps5L!(JFEPa+=2iNx<mr}4ASp%B`6wsRYygIZVFrq_A$)C}1Z
z&*?oNlZH<zVJ*PL2NJnR7;K%o*Us6UdLu>1)hl%pa8Y8R<zeAHHp{4Ve;imauZ`6m
zV0MEq!5T;+m8m}D+2XOgp@XrXZfvJjgtI{4%c>F=${PX$hB#b?08cb`H+Yp@10i81
zLclJ!by)X{+lXb@1qjwTR1BO`F3z#xo6%vCaA#<b9c3IrEtBe@Dd)N$m^&EQZR56q
z*AQsVuGdfUW4BX_^tfQ3LPO#CU-D#0XihpMtU&8n^gsjOVB2zPAny*vZnDDhGX>$F
zW`Vk_fYQgpvhA(*WbVa(w=1>wb3H>ua1F^Uf*1~jH9?O>>uHmetw&{?ZS+km<k_7J
z$3EV;M2IPw<$)!r(!D!Hau@emRtTV@mtxBj*#R}q(K3Du3zsIv6{%+J!NJT?=q~Ta
z1ResOBULRMcjEot(q2yPkLiLpS;rmK^GdYy*mZporytDi1eHyAXWXu(gcdo*1xz}M
z!IthJsIrmOc`%;W6P1bey*MwK0nEOYZt+{l^)DVXSp^skbhpI*@7~D1s!%X6@0wU$
z3cA0b5LJnoBEKgJcn-O#R+7XcvGZ;?5{G%ezu6L}<kMqe(wDR17F30R3q49Sn=Gg2
z7aI|fu3z&5kQyM*1;vfFHiaclJwr%o_Xc$*Hsxc7rq6hJz{Ta6&y0}J2RgQA?V!4y
z<Y*POPA;ayAPU0@!IS3*;Y~h}gDB$5gRx1CF++u>{eJjAjn>k{M7Poh+<r717y@CJ
z&J4Kt%P+PY`JGm~o_Nhmay^2285w@uLMF$|tww^+X7QkrAK&wgtxRU^Ry&+_*SIoK
z+`<xro6$`P^!X>G22W?ngcDu8iQOQwTo&U(yk9Vu&HZA*k5I^ph2A)(bkXSH#cSFv
z3RG`d+KV!IVZ0w)5F_M+-}$)A#hb-SHI5ULZPkT34O=`3$+sAIP^XH_`}l07!4yjQ
z86>g$vMiiI5(-6rT!A$)=r9a9!&0wB|DfOQN)l>)HXQXFp1@tOhq&iL$HNL768POP
zndC=9V9mv-RrCbs)35zP4Udjb6-Mm<bsGWIy5pOLTK>Is5!@arkrviNB7pVTUO;$|
z?f6`WXDQ8v2Z7Zk42DSmT(@3F#Ju|&1KD2w!Qkm-$2<OtjF!+MDg1zCzPm#-iY*rl
zoQCRg`mYK+9;w@%hK94JGpgR?fm5@oOe1fc21BUf0=1v~>q`NOBJ!s^5+pCPamGIM
z{K+e=VZnXMy;@Sw#=rHoi$_F?J1wdUT1$FlJ6*jVR|WlVXlHqie}q72kOYytORa;_
zT01r5lcZ16BnW(kj4mY@uMbgbBiC~!uq~kcCT&c8ccShPBYMxaetOP>?g-K?U_9=x
zL4nTWFf<UU!ETpM%h-F`R0Jm!WYis*_#TF5#;Wtsaj3N>p3^IJxOQN{CBMVhY|5bi
z3BK0BQJ)Vfr(4kSoEbf0vXDI#zi^BEOC?lVz3Tvyr<kBk-O+m3jG{TmjKQ-x|C7t|
zPH9%%HvXhza`-Ipe&QOuj+n&g0S(+X$mcg%&DC~qlUQ;y@WH1_fU=3r?7?#)MI94U
z934lsRw1M1X4jVwCnKGp$>CTX?+L2Qcjm`}-;lD6BB-UT7(tDxo+PF9D%+RWX5}}4
z((y3}LIE%3yBk!D=Rh?kM+tgy0ZK!D9b<&!%_`BiCMG8cp%aODV{z%8`kbrY>Tm+M
z)d+TdlBLEy%FClz!i?=#kAZdqi;+bKYYTXj@ZoDxF{FwWblhg*RvZ?68(=UHzDPmi
zv;dj!HJp>>DuHiHDpg-Sd=%E6S9MIu1xybCR2-_N+?>Y+!8w_f+ykM-Yu71tG?8fA
z=-hxd>J`aKW(Y{oFIgT0yIe4QTGV%-E8}rDBt69z%Ym3zJHI5J;apiu;R{hgZb@yA
zL?C>sx%>bK3;f-lTjWJPT5OzM3_es-I}(00Y<HlhMUM&L6?58d2%XTu@odyg*09!>
zr}^9+HIdJ<vC4NiFyQI+-Yk=a*FmTGhbMsr$DqMso3VHTVy6xE8lGPmYkqI&2e@Cl
zLl1X64N>)de1=SjZz`)XfLQ*~-0Fnt!Vr~B(1O%dkcYJ)JN7x>Qox|bR^V^`o2lH1
zddy;}n0^V1CwktRVZv=w_Xv6&=WDKo0=X!wy(HBvr~Wmxa%@c&m~llVh%EHIT1e16
zG;IL%!ghG+=Tcw4KiRg$iUs<uwLhIVxPabKhV^wSwbF}9o)ZWsG;ha`;un+5ow|HL
zSa1%8B$zdOj-n?WgQ^+S*N-pZ5w|3*zz>7SR1k>P@?2}ap82AMJnD)Rfw2)+*O>|Z
zK{r>;w}toSN{f>DMN+b{H=XnHCJB+qj2^}fCOl%%B7t2PK`F`gtGHU#O9KUrb9e9H
z1_jpltIVm|z24*T`SV6mLxb`svHhivoN@k6v0$LvpX13K?g9{PV=%`DHYK1kQZH8G
zz9z7OE;}LTD3|lRN4a5{=@u-<M#UiKkq+ph+Msgc-zt1+!S#q7tXa>qmUbgvu91{?
zHA?0H^bmZWBYav)ov}?W8DwDS)^KgSHJl)GMXDT9i6n6F#*2u4>#)fmBRktR#GE@!
zdv4l+ht1@yHZ_VE?e>HS5-v1Z(YV89>;%d9c+|&5_%IOdo%N-n<k<U^%8k%uKLth`
zCmX+g8*c=S!=SD^jZ`31h}_7i#Cyk?AL7vDsrSkj4({YIR~=bX3F)}r5-lh*_pM^r
zD%qZ8aqER}VBmtOCD9mG1uLMC;OXbyspn?u4XeH3F&WOKBsVIU23zLZjPUR43*N^i
zc2$W}?_AM!%NU5LpVavRqH8v4aWfqZBM3+3^n7evOwd~!m0Hd`3tO;P7t~^JmG36z
z1`o6rTYutHBtz6mmgMctmu6a~&Z!nz<ikAh^5;KtsV0vRg$;aBTs?FYWTLSg5u7Wq
zhn2Y$)U^qziuQyvfd-dMuttcByH^Y!RdUQvo!`l!9o1jW&yxKaJ<*1YID$ry>xf0C
z-^**xN{1GiEaf)+J&1v}5j!iSkV8{2YF~qzoujnQEGagOK&{wcp|BEevqs`EX4Gee
z9SaXa(^xV(A_qbp7X72I9-MQeASM&b;Vx?e)+fMgMIyNW7dP$E$ClE=?~R_U0}<0O
z<dc~?p}mTw01oDJ{nfX@buIEhE^~W46+5H?o3cq5%P0wRc}j4H!m)ZgeL*=ukO4EN
zN0==YNOppxkfV|3t<`q;!~UEPiOp04G1}RVUM}8`+cGhEBgFMjMx@oAOKRrr#Ol33
zW%CU%WLpSxvODF1P}E-H8PMIG20+p)2Dul@DBL6LI2kD}%N9zZ2o$)nG!72tw#We{
zE2Ijun3llGo$%Lt25q0w%}P?c!MXDQxJR1U8u29nfKc*l)k|IJ87j{dPgB!%mYXCH
z?n0j3BtkS<uowAANqZo|K61&h73=JgZOhc@Kw8*J9qP|*Apju7c<*K^zbm1m#8zNT
zVZe3QxNab?lf0TbR5u7Dh;4t%t&p5%!0bJtGiyR29z#AgW3MYxo1WC&hO=TxY~98&
zq|WY&O%^FR;+&l^=yNP?Y=J1THBVC8sC*oanHr)`mwPDQT+Z3V0FP-ViMl%8`VEs_
zXr^BEmpE@$GI|>WEetdbvX0PbCfH`y(5;>@YoENZflhH-1D~G{=a+#=N~yjEc6`#5
zWBbWcEeX!X(NY|FSz~#qu&I(asH(&gDHyZVj|<mOWxR-pU>n93XJpK+6}0MWhws>Z
zx9qnBte!*MA~w;Sjge{DHs@Y?%W9dUQ|W}-h9`kCDrtXi9Em-O;AT6r|4d>Flt~48
z)eCMvuD#Ph%)?fzi+bi0Q<En`tI}(-843%fVmhSrj_`MO*+_uNI9>LeaM`R-NDQ5!
zJw-WsW0%SrPwr`*E8no7@qS(cIZnP=N>Q##mNH@4*eivcza;9L3pRjtyyBPv5L*)h
z021(0PFgFwwpEFV{z5?n-R{$B8dvGixB$Z7g^m#8Ke+)Slmf;A0K`rRSoM)pD!`r+
z-f4T}?G!R|oJlf@h~hO$zP|gt8&MxeWHoJDF|ZHcIPD|{%~*!IymS0^ezBeg&PDVG
zRXA-6Rnfg~eW=$UUPjZn0_Lx4CJs4$Q=y(vKN<eY`SsfZb~(^)Odx%TSiIEsrmv8)
zPdtzjA%ql!1NIun_6dv2*7EsjL~aN7k}P#y0i+*`P5^&gG*dK~i3F!rx0k&HmLRi6
zLE<h}Eg&ugT^*|VIxGmE*=H`F@(Vg3DFhKO_ga3g9Y~u=|GfW)LBX*tFY#^44hU;O
z3Ad?%j&7ZIpfaI8&9`q^+A{>-$@qzDpNmY2AJnRDjpbz%@ibt*WY6_2K$VGZbqvnc
zKd9z!V0C=os!npTZWt@`ICA^TlMg9&g@VtP)!IHe`nFVBmEWix96fA-g}@<q$5bnC
zl|xTt5W3fP^rRO>y>6b6MpeGcZySOGTb|Sk_(-_gIdXb0#3KjKIsqFfywB5JZneYv
zU{RMeysDm|O%}Wc*!-q?e|I%zBVsyt2em@7@|6YCg$(+kD*R$oJAxkCYdVuVLJ$Y)
zXH<P6H>MV&)q+}~Q4z+>Hil?pdH@j}(4+}U8OmlP6j*jm3ia$%&FKhDiM?MS7}@$X
zo?O^P4@J++sBR~p!#NGd+M#H`*BW?@cC=1H#S@<90V(eavh;%DV`X%C=`e=8;xTJo
zqI@YfaHQY~L~=}~rw=@CM3ib79-+a3s_ZULhkBqXIGZOQvbEhBeR@soWCI~k839~E
z5%HQ&Iru5Qf6EU#tVHP(_0aJ^#Oa(j-`Qa;%~v7uk+NKKDy2thGBvL7$*H_@&le!f
z5@lntxi7N!sQ}#PBAaz%?>YTreeM>AxO4<z7tC9qs2`tCPP2!j%VqV<)+J1YG$7Ho
zwaJWv+U8I!)!S+u$?-Xd%D06dL_Eeft<mrog)M%|FRhU8=sIP6nW`ShgcOqBnU$8V
z6uLhepV1DI_x(vkh4P-_xs0a}ua%KEi-Z!;mRm7#G3hHsTz|hNkHZm(NmPP9(?Lbb
zH{&qQ4sVN$zj9l;+;U8m1}oB2A-w&n>sI`{?AEszCQmC+sIv93blnBzX+3}cD#GCH
znK)xEr-!K&yd4Z{ijZ-Q3$(IPTR>@q+PcmYvF@W@95{Wy++|5|?-BgrBp90*irFM`
z%2hE-(~DX0!`D6}5FIflf<L!Ajd1F*V9ljd4LGHn{a!wXW3(3liV_Ba0mcCULI5pJ
zZm9(>{lIc;vXuRu!yYi<UPO)Hxy1tWfu0nveT~dH9gWY3OAy_Uht2$*JnF8=P;Vup
z1l)93wt!TQd7bg5S*Q@E%ku(h#Z6r@TqJk)WUz{$g$gdQ@{nivrShm1PH%U)tnkMz
zV{oZ+lCO;FZjEp3(hYc%ljP^np}2)mE^Cu5JDGra9>{H82t+PNM*>1|UYfB<%PuJ=
zTr%}=H4BQ@Qm`){KdnE%ImP}Q|5RR^AWcf!<P9+s(dPok)9wQlNnf?9Fw$1?@HSFL
zeQS5%q|r6ap$IB#bXDK_HVq9mpmA5^4MfwQZ15dgo&pY!AMdDDkLfkF987Y}k_`nb
zlkRMutyu+cN9sfB8d}uqxS}<019~T%AWUu(K$f+-5umqMQQlRXizTY<BIG%B@xtv?
z!j(}FaIH5}Ms7xH+pJgjMN1}Eb;$pqWu-z6w}59wlSy$Wa-lB{S=jds^&yOW>?7-K
zU>8ZLCXX)n10+yi``q^x%Yqx->|)j#*W{p$D7%fS&UC)n+$eInN|E0dWz~O3kjRp3
zsM&Fq?L;w#r$Kw+7BUea(lPH1hDoqfRj6u%O*+R_{yVQn`G6b6(Hvi`tnil3I)^?t
z4%gki4fc*7m@+$nG;k{{``0ygH4C=7s;dfOQiamiC{#5XU%!cIj*7{O{V3*4aP~&6
zLfdr~>xJu?=JyDGY**t5(4=F{RL4B2u!)#?D3X-h+eqvPl5G3XVXSj+fMqEH*1O}k
z0-)0lC+NwNa~*+vo}(C9Q%#%qiB^~Q3?Qe}OplMANV+9~U!=e0`ATM3a~Q?9-KtLS
z4z8A_ku*BD<cvIDE8Ni$$~s_eWpzafBOnl=Fg-1Kz1`mF25RL%Ro=|=eBf4=mCiOw
zt2D~XmVBaOM5R-K7{+F)D7r;};&{aby+L3`DaRvzLzNCUnM*fK(!(@qeF{%A$Vi8(
z^hyP7jC}2JR8tq$<o?c>DO5aD{C$dKHdL6rKp(?_tPkb7(!6b3oEfSaJ<2eb%CPWw
zf-wd->~&O4RzXea6Dsq%sliZ)*KqBIftAvG0S8A?3vG@zQie)udX!&zv!D%>;INFL
zq$)NI!NoGhg2uzpl)Nb0>)ngDH224OvAWnxgm7lF-VUfI(N~bwo%TBNXB3UP`ed<H
z?S@!~GaJg(&!UAt9+_hEnw#G2L4vW%&p5}mvk4{Iy7?Jr0Y9GEpnsKuEa$O+zcC;0
zf*HuvXM)uL_j%oU3IY;LkC86(wVu!X8+>)8#xqq^11U<cY{DM+wb=kH*J`3dzqoX)
z9=16gGf_)be1J2`4F@GOQ22XKJ>d^d=%~jL8=9~qv}Ug`sYctr{98J;E4ntA=T60G
zLAS@nq@;WY*{^`;6?!!$ej}X_suP@jMt%U)pa0E~007)`^+eE|hwgHv=|A@lRR&vD
zDK~GcCNR%%=1EoEmaM-yXBcrNX9QGr8JSHYYS7_x;?@j7H{`>C2=7Z!jNH(wOWFCx
zvga<$Uglym0G)%KgFIv)t0xK0!=Ehsolh_Zgti!=hUOt9f;u>M6l4$7YXG>5nHmA*
z^gc(Cet5BRYfV}?5ASVq0&#`o=AAWY9A%>!Ru;Pom`V2SYkAmE6#K=_NJ6%FEcYaG
z0duQmJ&-0EnWq^rg%oc;337o8kivJ<>D}mZ?Zs$8N+<U0hmSN{Z2<rf*d&~ihxy*#
zFq`s)fV0y8Tl%idm-%xj%r~{qWpqs|V?qF(JYZ!=ABgrOV=Bv~o}m^1_%;KUhHN5X
z*i9kaB0ywkDUKN9IgFDK_5yJOgJdOadV5aKUyzjt(DI=yu0tr2!OHppK&%X%TTeg+
z269-wr9Mah<A`0tlmS5OS(n2a`+@CbybsQ(l6NE*Fuytuv#tT?EBtq<%x9pkNx|Hq
z=CGx@$j}o^-u`_)e)%uf9`@i*As$H(rgakwF`;i*GV8_nJ4wO2nwRa*lx<kl$~~Bo
z*S!(!x?g*&soW#+*Eo7jlV}!Fz5TWh!i8#4z$l%0$*RPe{>h|}tZ~d2&L7N5At+j$
zx@!C}w%qZbvO}wscIpEwf!sto7;%o<2zaNPO9+to6hLU*$cIo>nwllg(?!%Zfgi4y
znmf@DxoQ39B<+_Nmg2ouc0G$4+l>kb_mnnCvEer#M0CC#hjoyTW#q^;PDx7qf>|f-
ziA1m8;sYAd@LQ#ujSmyd`3s+EnFLC<T0-bs#Z5N({^U*|1`kE7waksXJ*b~OlkdQ^
z-=G2Nie@-J2u@a#@~22HCPS!!Kt@VkiWtl4ke|*VmVI;EhY6o(S*^+)QrvS;|KtZ>
zmdq+QS9VLr_?>faVkk3Y4xrS)fo8z2zRF8N0-_n{j)WVw(Xe8~?srzbQ2uAX368K5
zMs)j}y9CsIc_%92nb>m)Inl`OP6A%>esNjJIBaKkAX4tGmbSfWecG*WYqT|RA(@C3
zr&S4!0_AMtBSpZXm9IX*Z+ic_T#JEI9~`yf@|dG&A<g>&JH_v$x7@2+OFMLZ#Rcre
zM}^+47qL+1{FVjZIiZ$c#;wXYdr+K<zVjH#h%M_5oM`D*Dy)EtnEen1beiH7#bzEX
z!Yf-mi{wSWcik!DFmoF`zQGUno^v(bI`~~VDwZ&b>}KoZ-<-e&hcV<UH$e(eW$<}X
z>Yo#ph)>llDUB8LvUe{Jflp!Z8$yk`3dP3@w^J>SH77JnbRrXELVzVxkP%5kF%4c+
zU2$)~G|#!JLe@hFtwjSUBWLdKTXxM$46>7i;(#@Y(wyVA0pk9M05EoTJR~A+B@tFw
z4wuZ1vy8A61`r3fDgO36fM!FhdXoe0;*?=@wm$R+qVj%vo?+rFad$p8BC9AJRFGOJ
z<tdUM;CslQA0XCDezztIXAhqvfR@~+(l&)G)tiC7r2)WbYnds~XSA?isUOo01m@1O
zX>Cegi<QUj7=UO0y01~#>^tT~<nY!!u+}GJ`(bG}(XVahX9sr@M4_gnZ!B<f+nUWE
z5a3|ET*2sSLQ92Gyx8=dqLoS%`r|wSy)8`!_|>-jQu?7+$dD%uyxD5RWET=<=dzX>
zL`d&==Hb9?p@1GT+_~2P^g63y8}O?D9`BAbFPn{isE<zUw++}xs{t^yOh=%{_v+gq
zFa=DwH#@xeghHdRYMSCIOSV3oi9{r;@9^nGN-C-msbEH70!XRaYMeOXmiv6~!!YfY
z98GCYcIhDl-JL{VJ|&o~ukQRA)ur@}rRQ5$#>JfoT~J>_XFyelnF_zh{1FFh&Bha2
zuoaHTDO@PG)N%}YHeU+Nkd((Pm(-0jK~K0srF_0OOF$^c*=H%C&Q+UVzs(Lqw&AcA
z5-BU!Yn{&wb8unv()Z0<tk*2H(@|ap*AhGtXv%=~8Sl{<CuQc+f2N>5EwQ6lJzWP{
z%Up9C5k~@<12DB(0l>=H4QzKBcsA@my^E6bK#WCRW5c=Zd;nlSAA5hdEHUe3bFRtR
zei<ND*1rd)VB${Sm5?4$EnS_;KkG4ll8~SFz1%3UkkX$Ej&RRAs3`EIv=n8h^qJ;>
z{XplBqKv8axl*QL3&y3rH|6)Q-tKU)u}f5to}dWz&)!+ke#@18&MG6Um~wujxo3Ip
zzRP`%zc+NVXwRJ5iYQi`tV|SGn-NE8F<iMP)sxYBIO2;5xFB<V`{_=4Fcf?4-66k`
z3CkXb3j+~|J5W=mu{Ko)cL_~<wf1um0n%08(I+y$-xAjxqc%r*uKa@An&^$~@CJce
z?T#Sgrx>J=G1{QeQm}t5g<9};H?d6FD@q1h!BaY7@FWHsvnBDeyPKilX@{pKK1ZvB
zgY1s<CPWNVQ2Pd>GOf{35q?i<uAO$zpitPKz>KD3_sSXUqFvdl*l7GuC}pi3t^F6)
zKVT(w5}Se7t;xIQ5*MiI3tLF5ikqNrWzPxGJ1WF(=}R~cOUrTu9w4Ek8E~H>!JsI=
zFrY){yho?l0idBR000G03ywd9&Y-LetNsl)%4()_EQnDrpsnOvZNgCAkC`L2;A?h>
zdS37|A`#FnCR--a4r-E7Jrl4GE(||@1_;BzBO;$LEU0#-so4Duiu5r4XYg+YY6J-s
z*M=g<3RCxH0-CE9*~FIEyYQk`H0?ePRfRL`<R=VBBXt6pK5B@DQOzTUoB3~Gjo_<9
zf4<bZiI5*L<)@F(2Jf6$zV6>kZQ+&m4YH)bAEhj_zLec(@OK`EWY{2}h~_XP5#I|W
z(ir%y2P(Rp+eV~O7R!aA%#BPm3@Y}(kn1j#2ooE+h$&y-rn?y{u$~F@%a8#8r>_A3
zKm{TyipyK}_Ci1Vwy8P`uvYPt<)1wmhXG(Rw0_4vR*rU*3Ib413nkK!mI|YW6&E`%
z&bYXuGT%N^3ukUr@X)m*eZk9CYrbCIp0h64wM67H$vho05+B3z@sXFv%Ymc#p^9;J
zT5Z;B>j3=R`bPM-_9YLH&AJ+St)%!eTx7Htz8^`1CPd}jYzs!8oQdy`*L+0t^s#>Q
zjvxWZXhog#xEFBau?3l{zx+#qdZ$E9+lB&O!(XMp!Qb!c|Jo$HT$F!&{r(;-YoZV7
z06ejZ3l)v&VtKfRDx9M&4$3#@gyTDtn4x{)Oy<H-na<(Uxnt}<2}=Wt-Qq`ug}{n+
z&UI5~9&mm-+)SGh>-(?@cMT5!O7HLkc>L6<d6K2ig6K8Yg&K->L5#c51h67W0$}v!
z7`zuoNL8L<A8)skAO_A}E4WAo<2g)sjV}@3Iey?h`L=;ah&t6b0;6+4QK<2A(%`qi
z;RL7BK=McyO=8kV+Fv}4Cdv6%1Ig*!%EWvhN!rUn^RS4dWjJ_mxgQ-}1^o6?-QgFV
zx4%GMalEV66r&!?mwK)3ww+{ZMjTd8%t~$=5cCc_`W;;%3yDa+z=BWT^SEf4aO?TA
zB^dvan&OBxCN~a%tY!=V2`VW6{{V47j=wyYS#I^v%f|ri8Gtx*Q;2akqKf?w00QO$
zt<v+H(V_oxrFu6c!R)P&S@>S3Zp<Q`;@QpC5U+$1p)NUO(fao`Y7Cf`nUNCvy_PJ0
zjBw+NC`-xr2?Mie#+4dZwx^%|QoA+?SR_5q{$&(S#FG8+2;kH4xW0vZ{kp3>FHKZ(
zz+eLDi;Vsf2<o`IW;y5){tabw{SLT#HUkvH+}Y&DF<wn_3yp%hiIqH1?}T94F$@Qy
zOSuIsB^jwlm$NtF65>7Py)OMYnVaE6)omgy%ftR1Hx1DTglSJwr72!wpTt$=f!H)a
zK4vsy;YkXMGo7-r1f)z^oQSCZ7+zM{qq2PO`netW6;g&BGsBvq9b%r%OMsXh`DE1y
zxLtMt02;uu000p6-gquqWCz{~dKTF<7)Ou*E@!`yF+l@+3@Bt|k1~U+H-240!B?z`
z2GTp(=7iH)Idw1KXN-QY2~UOt5Lr~M0c~(_=ZFmG6`~89y3{l#YC-N%YFNSg#fTo~
z<#WDLa>L|-6BwC{ndA@%Ty&hMiD%Kj(qtBJT(vR)a;UGjbthqsUMkM%%tba&>w^Hv
zcT;byBmX%Np`7FZ02!OO00$=@T(C5L^(qzYpR`FiR1&z{RIY#kEpiv~rwZg;Ul7a|
z={6{zzr4$lwOZaCz@s*c;@ea6&SKg-Wh^f@I&)M7+;z%3tBKqHTIUYg*s*QQkS)5I
z-FU+yb6k4pAJ+<zE?R#YLc=9MNMKLeSpX<KG!x-g4B!8aLC0!J!P)Wl<5DguEp_|N
z>bPy<-R?3!OS>nS!nI5_zuc^YC^FkVd^;bVSjYe*J-7e|*lIYh+bE|M!Mqmlusr@y
z01Kb;l%hn*yVM9j{Kxv&^wBE}LS1|)K{2@Pa;CT=N(TQ4XVE`y!WT~Fv{C6NmeZuE
z2=|*Ev)T${*>grR+UjTL_Iy%oge@e7<oU@V?#BXaAzx1vaE^lXiyr~`HV0<&O$gBy
zqFk!VO03kH&8XE*d4$-<0X-6<y@8$$G1Qe6jTi(_-hfvXz>hnS#0AqrK%)r%6_tOh
zqB?qvbL0%6lD`^5vh{7&l#~cXL&dfo`v<{bY;Q16YbVbxUPyzLiB1|hO%)X!+zHFO
zT+s3*;`Nbxp<EHZ^^klihX+V?#_Srg;m`7_P5l6#$PoD_<Sp|MoK|WL?H4m6`T$36
zyLa4igKI==^Bf3Y0`+ele83Y*NSNo72LFTm@#6dXzk`UwCk+3r9F#;>VDbr1!VI37
zcv2+kEww5Mt|e5A>SMx!tIF-&5fQhIj_wgt(ds@fEcn-ZKbI6ZEv`^48r4gPhKO8z
zgwCM)iqo4w>~*elmbZNNM`K#ivkmRe-Y<suQ`S4)SUiraf;~+)bW+&H*71xJ8^h#(
zbv;dwAS!Ubas!$HTx)h)NxdlU83|uy0gbirCd=6a7g46pHMdha4Ud}<h9y*C6sn*<
zc#I49iYWZToybW9XPu7-xaRpS0lTo_)mco?)ybildI4m$zpm0Jey~C_*5dj4lDG0a
z1ndzk-~iSIkN^NCE!DjCk7-65w8$zXhX4Q;c(&87t)80uC2U6!a@C~aaVdQz=)|ie
z)tyZdW>jY^4Ml*WEHXvI;V2><Kt6Mf&`3(3w#17+L8_QgVRaS!ymg^fBm7#Ne5?F&
zu_e=DjN&l*gByDZ(eG;Nj4|8UL=bR1I03Oi-@nFar;U0(CSvQb`VCu!=ws8L^9g#i
z_5ogkIV6E^8VRO$!C7&ZFL0S$XY9+dHOm0e7W2)VbS4M@swAiGbcYn^WC^jL>|L+(
zYSb227uB%Bih2|%!YpO4d(u$5N)6Hkl<Sr%BUe1`-fC_A8av(1jHA_)aer$nWM=u~
ziS6L>%!+6A2qS~nQq}sVO_8?Kbba{cYxaTyZ>}9$(lk0Z4;%NpNIaZ<Gzc<bxcN+r
zDiKUerGamv>7Fg$I-o9j0O=9u)m7lDNPf6Yh8B$J0B<BZ<EDhSV#AMg?_EEv^JNfW
zp#@}e@~W3F82N^jvl>=$0{L@LU7c2uawa2Fm;8x0i383<H>SrCf^k4~Pa_<s3ED$c
z4qU{K>R!_9kTI2w;f$y4)l-W-J2IEy@(c~lrTs+OW&F*}Ll6kiG;G#L)h5=@abnuK
zs+jRRrm+H1#P|pB&=7n2BCBJ(G*HR2c&WA(hk5Qeg+{+1`|3q)9dqo1b=9rZ#V~`F
zdxe+pi4u5Wa@bYU3V$vN0002Y-M|1!n1<q?CdOZHA89jFf#E#cmpt$QTF*&g0PsKN
z0MxojvT%m$nal>0W>5FHNyQ4d&2Ef^GDv5wRH+IW&O}Uu>}JFnoJxP770Nvj)o|BV
zIk2*uhdi{2KI{GkO#3~ubJ2eAYkFj?n8%6lX|87RDxls;o)51EM9bLmLQl2yN}$x}
zU<sf_+j?V(o$}X`C9Oy9p<@`fl!UB4#}Wv5n=6vqaxmMf+S!Ei0fQUwW|^Q$T;dIh
z-420nhXcT{tg_P`2f;@;C?nO2Tz_+K)SeX_5L(bd6d2pDh$x5Nbxa8?6*rh0{i!;Q
zE}pfL!1vaZw559E=NGIS9T%Lo<@2}#vO@FK3Q4oiNs~h9ZuAr(^g@Kv;15Jbh{$~X
ziswEDWy3Bu2(P^#LJ);Ps#ToB(}yeF(gWt|y{rDPSTW34#7NLw?^_}L1Vgyii1t@M
zFikd`>#GLyW7vu3$&))EQ!$<3trfSy4e5CHgQXfKW`h>zoEHKq38Z17tFk@nulPYH
z8g+KNggAcJ-JAKw4_;%?P+YG^dN5wVSMg!97FZFAl+$uQGz{n}Ep5hZzj(1H%h59v
z$4s0LI*HGIEu^!AMe_>5i9mr3X1Z1mdC^e~!@;a?yI~p*q-QCSgd~4QdpN37y&ka4
z)RB2Vn?gyM>Ga)mvqX7N&r6sJ6Q}xu3}|T5nZ4B?BD{WnCBJn%eT2f)y6`)#U;M}F
zGr6`RA8SrD9g!>z<3ESKt@GN6q|`p4a{soz$i1{OzUMOEU;qIj?Z5y&mR}vD5*?f5
zRG!Ql00Pyy8NY9Jay}f?BfftDLN(MwCgALH==48qxKd>3u_~$(zoyYqeXLS>dSIcv
zg}Ml&^-efL0OYL+|MAj@&d+Fwd=EW5@r8L%GeN6@46+!Tt}C_2XOm3@RU7dqdMe~3
z^U4p3_5MxyyP9f|8NsaT{u#4zJlbSrW&Q}~jeL0vj<}Zbq&u8L{ayKo?gIRv+0qDN
zQKPBx*_c8ubn-?8Ly1l&+X)s)IF`r<wqsQz1{)`Yke~tC!t<WbC9-w7hSU{DP=U}8
zp5WS6XE7+XK+`=j#$TL0L}=n=yY(%xtjL<+05ySR000yj=pP$nbTH&AhyV**?h1?h
z$3^XU)g?@buTFAO)W5J*C5tZDtQ3QaB=;hGEI0PaA#z)y{i^>uXCz^>CP)GznNBp&
zhV@8Bqi%R=Q0BkGL3+RBm?uUz!ecglnB}MnEf%d<vf%opz=`0ERjcJjsi=7UuYsHE
z@}kUb`pedFT%A1=B5$Vlf!uDFV0*G*lS3%e$^IeyWzd*zc9-|99dPf)EkIh>O-uav
zRs0X5_`~U~0nV;iiFN1as%?_VZ0|ong}}5Dg72-4^@L;JA6h)yMRZxVKu3hkH6y20
zz-ks`R<{6Wjg#I8v1LM?07+kmHf6+RB@4~iD4m69KWlWwrvL!V-M|12^4y?CgP7EO
zym!&>_9q*{YY+fj3$R|bc}kc!-YxhjmHPfUINW`-`TG?BhntVP6l4tCqK3fG`0Mt9
zp}YBx7T8T${~}$OiHE;8Ika0u*8l+_?Z5y&n}JJ$TH(upP=y@OyZ{BQ?rI7Rt^ug3
z4;0Kwl#K=~nYA3`G7hG$fb*HWMNM8mn={Vf>gcBWl`-fMv;RvO*Ot$UizQeeF&0HB
z<#P8lKR01;-NdoKPhZ;}`;dut01(#Ukh_0|4zq3A`$y~wx{tmvDodm3yo>!rMP8F9
zB_x^hzNQA=fu{=x_gnqBTDCD%x%zxM=}?@@Z%LPH<Qy*|rr_3PKU(fLyM+Ma^Ff7|
zyQ+nG1~Z-)aTW>4%#bW~$<Ufo`5KCz?X_1%wU)j00NyS=LzFI9OOXVEB08$w;`p@2
z!cvLp?l#blFk6Nzb-*}WKXWWik5Qb52lBod8*KenlF3q<X1fiFYax3`jZ9)rrlu{N
z#DRBnXt)Lurj({jTPBIU^?!@GXGeDqVc!3vEyhyyY1(Kj3aN>R%YsGm$@@ca%ncF9
zBRM@9R&q`@W|$o1Be~MGd%L7Ngy-=7pjxCvtTFnhAM#>`A41>JJpc+>BI^quBrA#0
zT-%~BWL^2W`Hx|vBC*DLknI!+#SrTl6zOuvhqWO@gXmZ#yV>*L3SWs%wLE)TyNs$a
z0rSbobm;Hg9wM9D`og!o`)6HNJEpIiW=l+tAQv0N7xQma?*KRyi)BCnYXZms032xO
z#XGtFT57qVr6OMd1<%i){k^4j7TWtcAwRS;Lb*hUo@s#JnjP?L2Pm*&*7vD1QN|q;
zZ>9rq7mQfkhXS;t-nyxei@fu7G4ZnjJct5kS*d*jAEg<WeH}CRaqthPw_`oPJa_PO
z1%LoEH*f$FLLTh69*JH|g2BK6-CyW4HA%1Z-tLWUj3A6I-<o(fT7FqO1Kyfh;4PNq
zv&|{y4ya8zw`E>;Z8FBRlsylgeTOwxG*fx~0Q?+MZK<qQ_TbzE3Ffj{6X*RbM^<X{
zYhnnTAU^3|5F)_xcK2wMH;;T@_8O<-@1JA!b$%8xR92gT7+Z#g!X=b-Li&#o9ue$h
z_6{cuNV1foqe6M|i~igLq#Aq%vlX$)Wv><5$y5|*{|a>(ZJt??&Mp=YE`Vx9afK~;
zm5{g-BLA<3cwFuIm>kXoxP!LUx9bJ$YkXT4xO|0LtpNKvaOd9^-V&NSD6L&OT`s3Q
zjja)l39k%Bc=D5BOh`Sdm|owv|1k2`kzCzgpZiSl(}8RLVs@pXIOBnrRA}6+jV1}B
z;xza5jK}9?apUv>r)MYB<aSX2F$)$??xQXH9%T>>E=aji%r9d3!FicU+#eq1-lje@
z24Zf;bEI=`uB?s>lf%_*x4UbtB;|W;%tf%jvRyqq9Ub~UBJii9*kkYNpo{64@~JO(
zyFxZHO$fXBGr@35N-=wg5lKSa2z9Zh<PZQc#R0jM(}aICaJZeac12|*k+|M#y7swI
z$VHXhyz~w?UbZm&U8Y>oU?b?co+N9S02a8tZ#;I6=nkiqmcF=u3L%<>!L+|*5Ue0~
zZ83Z|ojepLCVU{hy;StI(I}c*aC;BQt!k@Y%iYkj+ud|Z#rp~F#}oX|L^VI;KmaCF
zE2mo?9-FB5+q~FnQkl*(jK>)pmES#U>AOuF&WI>wPqX;0<a^a*A>d5fdso@w3tKOf
z{6@dLNG|Jh8>j|j96~e|;OhCtT64f3S-<$?e-T8)Gi=mmsl7SeWv1h(4OL3j!Wl8~
zpz<{@mn8$RE(`CR5<@M$nch)P{lAw^(IWdE4hRm|<iQQ39jg_KxiWdxFv5O`Tl&3r
zel!+84mtTKF2mJ905)t5<gx@)b^%ibYFiOk+&}p7KJUU{r>vj&8h%FUUiJb0l-Lcm
z(E$4#9m(z4A1GxY09>IIsPctL?s~%Gw$<G^ZucS$vWzPNoCzKW6ww|20i#53VU_`L
zAOc^dvZl$OD^d2O1wFx@>j!mCJ3&lY9#0R|6XZD-D8b9wS~I8Y&g*pOh%@oSh7m1c
zeO+$h$e@8!4;6rPpHbG{F=J8qT0W(fnVNX)rn6WITG8jiBZ{o0&@3+Z$5D!dL>GWp
z5ZNr66b`ii)!8FziLjfeGI`o0G`>vLujag`^<btaS?+xOv_cCP2xI4BHLfhnqJBR>
z?nG_IhHL4_(UrkD@2t+4Z~zl{gs%d^$0y3s?deut{n-~5lJG^HJvC|GDhwAv;?Vcv
zhMfQhA^bG>$nZ{~r*GNrCg7oC@n{|@jTW3>wJZpuxekUM<O`V7u*01Ub6l!Y<)PeK
zf^aOp_FsTyBbef1f9Y8gTvXG3H(_r?ZEYeCsc?qf|J#erfbNYQD=0q$M_&$IN`(O8
zBpX)LAB~s&F$pLmGX`g?aeArkTf;;o!-gJN#oR=tY`r~QolmkanQ0@I;k)?+YNQV&
zQ{VL<bDsJN&+C!vKKA||KNKp=i%Zx+#3musXMDaJ6}rf6wZPo3G<`SMjg5IWD{A3b
z<0U|^(26W&&FjlOUY;jWA!ya!3B6;R0F61Pbc9o(k>VH-@)9?ZF^V<T*hw5;A}rhh
z;>mLRl}6aS*2hyhBcyCy)w8=|ACpFgCjhz&k652rLm4t*jh=sxUfA@)p^i~)QxsJ|
zE;uH6raAE!GL+vny(>ev&5a`)5%Fd94)uOlc9#6*LDky9huxsrE0MBuGVdE%SO>5d
z@c0knf5M_r7ZMu*V*&)1VM6w{w^1-`I7~j_tyfL=vMWpVM;?WH57jo2se~^kmN{F$
z5eYUjx#!>lgUD@k;v`i0D(nvCq1tjHlguy73M=JZ+>sjGPy)|V%q*ohj;>SF@ZfSw
zzwm`rytphv0q{O<G9V~rdqvQ@#vf>=uAapfOwItEKe0AO+Q{>ZyeQ7J+yR$T{yUOs
z)k5ZQZ@R{&Qs0JhtTl7FZ;uaB_$j778mLxrJVka(Z+$L0-V5X3XKOAHT|_hL2ldbf
zi}t^xM@H3giXx)Qj8)a#L?_NIJIIiM8v*nE!5x}|8ZG87O~9J)ywCtu=MbqP%6^V`
zaS5UgSt$MlWw!8H_Bof)VoQWXN*yDy7GrfY#y~=+i-3yTPpaeo*UDDnz_eExNLM{*
zq_{NEXk-2UwO2Ec5+ZmySD-Ld3f6={y3c3!6RAL`;AQkeZgta5R*UA0mhCr=^_O#c
zogs|OA$vNTxbD2GZNbC35K6CJef%RQ@r^-DZK9oU>ScP)X>&aTh&Z54?o1{9Ez;O4
zeG$Ao30HP)sg$7+;6lzgh+!-xH+NV@>L5zY0Kg9ifx%KO)qF}tArzMprR`1(o&t%n
z5~$N+>W9@svMJvs-%BE~I#>=dGowAb;}j(9AN)WEbz}er$fm1|r~S$W^vsVc0yTKj
zLmzZAvC{9b0RuzvY#iHgiiVJKtzT)MRj4JnMzq#cdsoHZZY=1AEN)}scZY5?blnmx
zw{6h)vMg*i2ccsa`HvJ<Zyk7RRUjyE-=oHBRKfH2m`V0qHZ=F&It__qP%EAWx+HUe
z*=~H<G93aG4MDcs^UVxXzbt^*I(E&@0`;LLWu7*~|HhC{cHE5hv3J4ezSAf%!wT~J
zwEur*>2b=7nVD!-nD@cwCoUGa>>;^@G-4UV&sd1|TgwN|pKTo;mP~B!@Ap2vy1(23
zIe#pG-6fj?O+GpYbKzcyI^&!Q<D!e|_G|2^`V3O>?8ylJHY$pq?m3D=hQBJq$?$+u
zmHh%IoxL|3oX>OL<69sApojvOW%BXMT$eq~PL2HbB?%pk3{%|RnMl8D*zVKi<u+|K
z8MXI+0ZR%{4qgpPW}by(&ciyaJT{pdK=kRg-wgv^lfyw2*<(FImjA<N@Q@q+(=Gr7
zuf_GtmV6p)wwZAI$w7*$2^z}P3uxV7NYcaq_5F^q|A-0Nd;kmce%iH;BuHc@Cm`3H
z?OH664`_AO#|!Uqk&klVc0`5L4BT8Gal9=8aR-`NP}Czh*Ydn6EFDaMO7IREtOjMd
zFy)<bmm`vinw8%15xkL24yTR0^-V_S)+}t8L{@wV-YfzNrh^*f=vfs8nbyDn0001-
ztPsw`Kp7~NVzbcpjgK2^)1|fOf5rH4rN%wpXe!d*B%2HNLyy44>+fzdb&sX#F?)|J
zX<d9CP@H0H`RbS0ivDbK+?)GBv?fd!mDxkJmSt7Hy@l~)4z;6DIKWPEJa#ZRQk|Hb
zbxM$49bt*HE0sd`P&AO9hy~$6Z|UTDK~J-i8>n0i1wncBRVbUr0@BUP4MinBb(8Nm
zD;Ws;J(;&v@d@b~0LI5zFv7B@*0xT@4iS;dA+UM2_6CFBTI=Vpez$&cqo%m=kw#ZA
zEjq1Biz==Qpq0Ia4slcg+^7TRB;xxp5i!#eNNf>%-zM`<F=UkjC36HF50xhjwF6Re
z4S*bHtEoD{kwv|eC9~crSNC!&zxYNjLB8USYIcB5)>%AI5mw`{Mh|&5{9_D4vB1A&
zA0HB)QzZuRg>8Ji<ug~t@!c6$iz1IqGpU3w(2vp4L-Wu7&>E>Zh`z?cC)&CF$&uI!
zuFDkS$FMV@_-9YhT8oEg&Bu+g00C-|80k1!s@Z=~IR@jdCcy25rM_}J<VK2(4Xp*O
zr&lqvD=0+#b0@!Pml#W&1OKoOOug`|*(5>smw>RaKPc?c0@T;XFCB-o3NytQVRV1y
zkYA)ZPCAULh`J9U4U2RmV|8D(m_)1iN>IJlK<}F+eFYpf?82I2xx{|W&L-h*vg=1z
z3J?pBdy*IS6cqS>WF5469&Lxw;DW$Y@vD|Etkl}aW3LP>++wanj>|0+kzLC9uZZY$
zO78R5dCik!bca=poloG3ciis`P8PCYK1NEw)BTA(fw%Z)xcQ|XhoB!B9JDl^a9S#c
zLM)Cz%SpcbjWBm%*XA+~Tn^$Zgv8ihbv{+nCWCEklJzQFN(zeQ|CD{o5kfZ$N}(vU
z?#Zw_CIT)_?hC$!b?e1=r26N9-=ARS4Fk;o5+q6wJ_;&o6h1<?Ra5GLP%(y_`R6R_
zQo{P0&S^ZzjUZ$Q4@u&=yKGUoH2lVr9)$u(?1qSRv3O2XL*D0P3OjJiWDtge2kDNe
zeT|B)&(#q5aJmA&AOS1R2z@nJ({0UX4XvmYc$byVTDPv%%1bid3SUPOq+sOIRA%N3
zL>$WBxEyDfRNq0@6+H#{9%Y|zqH>~?284j=F)Stkoz1d>U9vL6Xu0#HuM;!>yqfum
zKw?!6qMd=JZ0||MRz69Nl$04lEw3QmW699fOKqS%X<CZP0Go&3C!VN>fyg97;LqM(
z^$YKWkQo<O8wq22ha6Tg<<vI-TrborHUMaquZF^DJ9<!afm03!*%Y3(WF?k%3>WM7
zs9NzyzXH<z;8gN{@vaMr%kqjiidt7py{89LB5T(y7BYfS(!DxFYvxbipN1uLA!vN*
zQsgX7a8Lji-i}NOQ4o~ZQ>(BDPmlD}mV4j;61{(BAupa7UwCi;mQnNsl@sL8Aaoz0
z7nW<v{QaDOcE#>xoP4Vi%u=ssX`T2mXv)B$R*?|7L-1UUuoY4E5e~ZJe-IF?$qvU^
z;30MTGO({>NaIS{8n8mQ&Hd*gzntqw%_St#boTsPp^wiQ)ah7@tbTO>3tN{F9*r;v
zhVEbh5J?o?ISbqWXC?NAyJ44v|D%hW?Orrl(cF#AukV9m?$OAST=(pzqwiJ{>jy(Y
z3V*)~`W0C;0*xp+^;GDol}87LI7VR@^j#worh|$mAbE|UUszBGhtxF1yW9QIk=~zA
zmAerAV!G^b!g)<yQtIB=_DyZv@@U&Wp;FDG1|QAl%NQI=|KA@u$sU#V(TH=zgcnRH
zm8Fy=5frnf>K;wVV@Nj->)O}~HE={GE1w6H!f-bS4OkCsMn0VEn^+#jRWC2^&Ut-V
zNl$|(xHp5xhY=%?vxw?-;a-tb0dv~z&7{IcW`D(T<TL@Nq$w>E$&$I7+PeW(KAlAu
zUbiMe5OyWbvxTjcZ0C-a-AJ2MivoVy+DS-Z;@i*<fj|>}vPlWD`qsz8=P&E96~%n0
z&i1^bEh!S6n&9cT&wbZ<GW>HUav-pl^xtTyIN@nZ0VA(`DRCAKcW7qcwTnlWmB9n}
zh|DZ&h1VJ_>j02(NGXIO;J|*$=xWNi<bO8BT}#^g_=3%tYFb>Q{t30}$l&|`A`ixk
z6;&ZaKcdm5W+mx5BD&%2dkm9->`l=x>zf19=NQsAaca9MNjm>Ki<C<fzs}_NX<mX6
zqIHf|%08lS5=}cDn*!W;DW%$Uat+E4Vf%;F-o<Xi_IoKE)FdNkMB^~tn{vg~036KV
zgL`zqOmU>_%%$lhEO*M=u<|m3Am(n>K^bumHISk)HbU1ad;W%qNfPDi{X#QYeq1TQ
z7nnA*q+X{dI3bwQxcm}1c*8dA%*%!@nAlhvgqV5~B2h3)L<;Kd>kZSIhRlF^`QBGC
zz%T1shDGRgE*O7l4DJ4)CEij!S4~PHJt9JxL9+WjdHj4dqv1oP`0q$J=2`qfEoBuT
zdGy5ynX{C?1fT_iG!1IqvuY-R-HtyRfstg4KW{FonaBa{(3jJe<AVM(E&5>-$vgaX
zb-C=PVRR@jA1;fY>!Sz6i=iVCXsvPUpt>?D8K5wK69>DwsR3Dh((}83S1Tf#;~eR~
zoaY#s@RhA`9g;4PmYZGzGK%mPDXY^CH>U{p!|h-{MvrBMpl@DX`Fk5dewB_gioC~`
zvruP=N`r(#dK%JWRM{oPL~@`Y=;fKRtRi9NIJi#1xEZP(5#iX_k%YzC_sPa$Qd19n
z40LLr+Fy8DhfaBHadqqCGchczn~;m`H(~$hna_<$!1ujY_>RMeymy?2Wwy9Mm{*_F
z;95)-zg|H0b}~#$5+Gs%bZqs<2v2|zp!e17!*^pZiZz(UFTyW52h{24^h;D1F0w~R
zC`ymK43DbL`=~kTa(P!@Xh*)jXAu!J7`dhAG+VyeY-A`=QpPq4k}<SNVr*aBm1RPs
z_Mi&{UY&GP6X%d_z<%(j3~Dfl<{(<!9(x&kW_BD&z{^g6lH??81Vey+q>TN5lklO5
z5gS;`h;vMk&&WnhBoGttWCJBI#vVV-q*Xrggq#uNz4K?*n;XuPjpJl1oRC@GXgD#e
zAc$lsBal<-3Q!V;XQ9JY%DK_EA>(uMkK_NrZB;J5)X!;)GE|)af83@SPsxrpgM6Au
zsy@IOLuMh?D|(xC(7lt%1ru+V4#u@R)ax%CI;TXDN78s|GJgdnv$LF;teR$Uy(mt~
zsy?CpUkjDekEA}H5O?<Xe|h{yo&Rq&n!va@JGs&5yLV!wb%@TPFVF<7Od+%uT%lay
zKIX)vMM|}2+iSy<ys)P+f~Asu)l*hG?vFbyhGy|h{8xh1`+EvR!F#uNcf7@;?!bw9
z9Zs2k;wn{922!q#&$?*2ZqyUd#^j1a(OA)E`x12R-{`(Ay6PJ#sXhBQL1Bx-?p7<M
zy*3g@hVlE1r`EhfOMo?noOH|4&)OX_m9owB=@JwdF`37C>~j$mQ6fTG?c5#km*iWr
z=y0YL?)?w{Q>D!ZCX1!W%m5cC01Wj000*@3@y(SLg3yp$TL#E!M5!rmw{ntkLN}A8
z-4M>5tK|>vVesz)XPG&eV)mpg>-2<pDP6mEG8;JGn@>wn<4tz?>%#-oo<@D&02272
zYC14`EvopEk;`?11wnZrC&X~xwB%$(KU`wU)YC(34PZv#5yaVb*2S4W$iJg2x?F-<
zQzK@YG}g)w*G$*u#-_7Iq&Ku!TO=c+)n9@K?NM1CdmwK7Y$Ferd2iuUzJ2kOs<-;x
z2Y%n_x`qSjfHPi0){%PG*|*FR-9&$RemnU|bS6Y<ls?U6b5dEGC=2A!>>PbF;Hw?B
z1ev&f{1aDgu#KO#-V_0!E5Q9nIp}%!@I3<@#mrfHPsX<C@?t~SF?*TLx{}#@j~pBV
zGy~1X+-Jtf1M>+KK-W-|UdXTp^3ftDuBCk^NpJV4056nDr1SyFbb-8vN#z5u2q#gF
z2Nb<*br34{1Fd9ZxEK>%3P4yPP_(OPzyo{LPApq_^lc+Le$kiIe2_;ej=E=X09>HH
z^&58X1a|n!XkkZuxwX}r=#30YR69qP-zAeuuA0S*5;$Uz#Ph|$ZowY#Q2+qB{170$
zawtx!qbl^Re_$Tmq?a>>;6^PK{sE3S=b}<;OXMv3t&0ft3HnSR-?Waxc(;%c<p2@4
zhcB#oot_`NwA`Jh=^i{w0T0ty#-C^I>>;{tB{iS)b7_DAlibj7z3&%re_Z18Sfr|e
zxk70M+M>=Li1Xz^=fC~mb_@t5E>QKxMQ6}61f~Y{;$vQyKS!%wW6y_XpOk8)C-Xk1
z(UwJ5Xu=ovpMQAmArDEs^*yUP0;^>2_<H&aJcFCNDG~J+Eu2oe$8P55dW6fC0E0lm
zFw~5ZCuzITogpTU?PlMcc|7TMc;X3I*=6qHJR5|ugR)8_P2lI6A13!*0aMK5PP17(
zJyTw1jxPye{IV%8@6!M>OAQHA99S@oZ;QGIb-C-FneIj>YRi1XI{tYC1{HC-?nmHl
z-P=$eiF5Us2rEnBMJPFxD8a06Y!KQ$>h}XMo0-~yS!Y<$V0?uupvgOXYDf!c6@Sq6
zX8{omztA#mIz<b-jwkZCS~&Ng<hg<kZ^i@TN2CEEOE!X`c|tAbt1Xbv7FkVv8j4#i
zVgmp~BFWn^;8O#Dj^7+2$`4-^TWeATn#2q(Yai(V1A<NsTvzwH>(Sq_tXd<}sa1ps
z!$v-=v9;nC=jwIz27D$ZM*Sfi84j(O>?iO-LTbGd4ic-)?Sg%mAOHn=BjB8iCdns@
zLZ`Ww=)Ld{ppf($kG$uK$k&@+g{~s{dutm)x3MMuu1RXPqL9_7WT06j>H)lZDkT;R
zX*DXAbuJW-9M#4O&KOa08*&W7FDtJlS`cZHjk*~Bs&=Fz*y>LZ)I|%Ut8m7X@K<`@
zl#%%(>$dZrY%wqJ(RIjF?Z|ky^6Kuj(!Caq9&xeabIY-rf(frF2E&n?i1W<;gxN{V
z#;_wSde~8=BNs)TGo|rc+{lxMA<&RXpWp{geJ)Ly8Inj%@n*$-1Mf5dRW*iPWqzQ)
z8jf+Zo^tz)^XlA-CQR=X%sxW^WCcJ)*CImDuM)!X0HrcZ)OU80tBT_p#2<fNlENVH
zJS15E#W7uy2ZzTmM6tWii65dnjQ)>}Sc7})GSERn6=<m2f<-1h)j(8*lI+cQ6se{~
zRf-3sf^84e^?J7q{%)mU)UuSY#Jl`(vrNfua|8f<5VaI$74QkU(Yv9@K>?BYsW6P|
zG}6eOt?S#say9)v@ypfsC#_izi!A$xa5YrDoz95yTpXBy01OvNMV|i#St-7MqT<e=
zV343T#TV{K#LV_h4+(^JbFS~!i6(}I(*pHpE$bEe*4QXZ=50MFxA2T_EuQ}GmdnJb
zxf}QH=C4EGYYri^?g32fDc-1$TDrheiv|NRt#3LO4{?J*-gRvNZkmNz^(|<b#7VL#
zEBVBi->LN<O%4c915l?pa}h)DEef8)W@Bg9RoP)mZm_avfjE6t9}nY18dD6SS#%py
z*3!yHLwS36x#IDqMq!L-$EU?6jTuVxhiAe@?QIR1)0VyAzhdULajZI_O)P>8xDmhE
z8N%8VMAJ@#O|IFyal*q^Jw1j*ae=F?df?3J?u`23J7v{5%61t77)^F+b?O29lc0-5
zJ<27W_<pDt91{x{h4Pwd)x^3fsH`MliuF&f*D!Lv1MLtYmv6hR08D<+%TX*ssd(9X
z9)A0BBy`cvknq>{R>!$zlBQ^>rSaOk6|6Be?All?!Bf-l->??0^w}H?TGBN^%@Bk3
zR#KuCA~!&tlTiqMH<RR002&TxEzD`j#tsf6edrsyv6(ug6tQYKewO_VsjBDa!-T5w
zCfs&<&AL2jdqHZ(eK*uhExu8yVf4m5QoAi&7La@dR0{4MI?uD;i_a3l`<bpbzuK6j
zPNJA1a4a>2vFbo;vxZjbebzTE)oPnn2%{kkkN_=E6Tu{-OK}xqz|ISKMhc5tsIM4%
znLh+pJf@>#0m7}N0dVP{rb!$#4e9Y{^S|{%-K!P4$fK|TtdTBV#gO535Q(4K7NaL^
zs@OXCcr9bK6EfWlg`s|lbcgsGQkGs~rjh>IOFCeUsDDs|nRQuN9`CvlPqSstGVGEO
z7;KM}s88n_2cS&ZNFZ+>+dXOjB3xo2di$v`Kny3>nbV?e&`#_}Wcaf_2N}1o9?lIv
za<pEW6Qf*^(yqAg(T*-=!(U%Qi5EQcf+IK4toLB1Od)zLG#eZpSBM;e1~bJ9+1?=1
zz_Z9kJ`u5-#*CtI{+Blx_VS&U><)|x?Pymi%(T|2xm9r{+zpiDc@bM2g;M+F)jc-$
zyVaBx8_s(-D^iGvwyN<n6rrULv<|0yGu&P}@`cG)H%ms(u(VOfUW5;4eCfQTWJrPl
z_ru+T$*@C&c;!8eIcw~bQkVr2|Hu2lzu<tyEzcS{8gA^M!ma;C5sL#lHWnoV`V#gQ
z_DEEtg$ARrqIhL$JZbpad~p|`(ayv28XpuRakZE=`m1n)I33V1l}v~iP!kziSR!G{
zL?>{a=4e=&$p5RKS8uTPc|(`aeL+iIfC5S+wcM46=Sns$6U7|9NQ%g^5LWf?CQ{(@
ze>0*?-U;ZFoB$Xbg*$6v|I?n@w30sH#DlI`5#E766O5|;do6$<5xS09hiG}*>vB%5
ze$vz(Sl=L^<PX;X001PryLA8_g!@QD<MG{n38TF4Q4jzFs!!(NKp-sVAnrfV>QFdA
z&dcCAx>y~(<|B6|<PQulvA}A3+`{Q2(UwVc4<f0&sRIyVGT_|dt@gVPpN}5ZBDC%c
z12t+O+ovG@ivQYfJ&Mr@t49J78A{LMG|7IL4{iAz9(mFqtKER9t2@G*(<t(*`8{a%
zH-wl`2gNu-{Q=b4FHAT%HR~QL%`4yk!NVl48?550v?-aWVmNX+Kw37J(+2(^kewg1
znM2T2@##Oc3BwkYI)J4x_OggGO&YY0(n!1mP1#U*Xd|$=`0ffcdEmWdg!2$RF14sC
zVU<e^HFg(a$$ed?O|jP+RU}0y@d&e0W0ay)89E&3XJl~WT8Pq~d9K#wOFEJq({1el
zC*#uiVgV9k==JGFoDK<lO0}<5!lFZxKUBzpVif3~b{fN0f-2->T9sl-^0qaH{w5mk
zV%adTxjXX+`C8~rGcd9Tr-t_M&#vzh$7s3o!Q3=r<~kNtL0Ox9=@5ro6n+3{xcTZ*
zApqZIz)rF*0EP%d8#yH?cUKou&|N&FfG@fde`$Z`y%O%52;i4_M;W^lp{;|Gqqwfq
zCNSn7Y1|SYM~k+=_Bkej_YZR=wH4L(pG~504|1G`4clOU00a}q^~OXm^n6CkGiMRx
zUFM6J#-Fu^c}Pt8{ug*){J%5NNN2S*nPnr6MfdsmORU>EMLx@uJ@}b?K72)oIRQLb
zt#bC+|0B`njDSNO<&Qk10>R^oeiWKA?$TkhoCXCZNw1@dlPAMtwsd|q+m%Fe+Dz*8
zd#=%pj}~fJy(_qvR5r56(jfCdut?X3d9~O8PP}twPW}Ud4EuN4WH1lU#;mQ{4;D0R
zocLt5Wd;;UPVmiUM7vtBo~i2yWVGFDq-MkvD^>{c{lsoOjk$H8%clxZ5EbW0LXOqz
zQ=Zhw00000000166Hb<w>aFvvn?{0f+Fxp2$vcO7=%ZMJeK>&)ViJIL!PxvaqRnYA
z7z%>ml+2!t=6HL$3*w=trEa4dYg#Nc5=jso^n&vq#A1WE3@hIs9)$Z{8;^4CFTKF|
z=BnC(329QB_<Rxf9d3vZKYOY2kkEq$Ux_zqOS!E}xJN4kq4r?4UQzWh{R$RbJ&MY5
zc5T4gI34eM0$i{JPyhe`000P1YLv50EK#fA$@9$<l5ztsXfTYJNI4z$K@s)Z>xB5X
ziF|GqqjxWgikMPP03-&|d{J)MWc~f{X`P6LINb2SaJVH<SJ4NPkM2~R)_MtH3l(@$
zA2+A}njM0hOBj`pEjLAFw}x26ANOnp-5IeE5M#G-rp78#2y6i<)*oqJ6Gv~G=*JMF
zq%#S9&6uac@WQ`-2;+_p%1~z4VFd?Et55mEJ)d~rGg_W1;-`SjM!A&i(phhalt`pU
zM#k4*6}~KNRxBT9rzso2_n4A#x?vn)VwoKn<?<u;bBcIu2W#Ia8Hq_uJ@7Hns()#H
z;c6W@<*~)ruZ+yZva)VMFSOl<|DI<)H75h!^;_aQ4j%E|av6o#;g}t_L6mDTieH3Y
zau2D~(dd?_E?s1fkWiH$co`p6o%c|4(&X~4zR-_-e9j^wXfbn3&S<xNve?BTI;2z4
zko?nip;mkGVB|1ZTC7;co^(l=ei0j#>21!unUaL&IYsY?-G4sM?T=#T)dgiu3YDfZ
zy{hl@v&)R<W;+z~pyU%6E9QX_F&E^=!&9Te;s|rL1?~319`}>dCzXY4FeVIq6W(8w
zH~Mvu_=L}G-$6Kk;C2bFIcWJ_6xeD5lqf7PFZ)0V{8Kz4(ztl;6Pn6~uNYtiAb^f>
zerkQJYI{w;`A<7edF8)^<e2>#n>+73Go=eLvB$&>WDG>_uw-#`=d}HcLX18iE{LCK
zLMY@<{v_#Fi`a$?LniYsX4;*e9^Ns+MhV2X<{}D}h(+3@Fbu4SO$++xbZ90WN$Q-n
zD`z@bl-y(kf@{=t?TgdC+*?vs;3)P4DtZltXk@T(00000000)a0t6SXMWBR!fBe*R
z>gaXd+1Z|tI^*?8_k+z`C3(B%U+sXDW9G)&@$|HtvjL?Pn^=>_cm#F%UHWqSEd9Ga
z8}SY>b!cJCQg$!b>W7mgOF0w1f~z|LUR>6}f~HtXDsA;z1^>$d^2lWET&W8o@p*=a
z@h`sSSktZ_jN6$hN~>;XmcmP%9;t`ud6X@yoVzfAL^2ytmHJFw*Q60D17IEWlrGme
z*bv!mKlDvFrrp@Tj^~BX(whzufO2eLa7M{=ev~h>F_#X%{$4)81d@jjb>VOayC1tj
zMqgPXf2KH={t1S?3b9>jxyc6#2zG5v=Id)s-nf?5R%|ug=TxHe@Iu#%mC8iKU@a7N
zhBmCcN0z1hOWwQsPQ|v65R>eGKIeljJ;{~H!|-`+oyJXC#5jbJu+;j#u{ewGo$7?E
zjz+SB0V1c|!)kmaSq^H*6#Au3{JH7E;A?#VMURuX9}ywBG>M_8U(5lclLXUb1}vS6
zB>(^eQUfVc;eL;WI%+mcS`Ja84Zs8j+gcA5-RONGP%VE1d|SS^uG1X&{@wYs=`~-!
z>Z3pGyfGeUbc!t{A7mxJ@pxr6OYr{jlNo+MNsupWI?uO;I@8>|I;?r+bmJS<wIiIJ
zT7Y{~jTZpq9NQZNjX#wE5zSS?c(6CQ=2DvkN;%eTJHkehmgq~ly|7?Vf+lsZ+?HK4
zem=J!V|A!%rX^vxDEba6s7zO7^s1vn<&W1&qVq((98gQI9dY)rzlD;QDh%u|%Wuf+
zE6;I@{mmCil;wr9`6ff$NkOiMjLmfwFU%Il64?h7^gS%&_+4P*7-3on^7tfB^PIqc
zIHATN52aoMow$B!81Zo&0jwa&3Bo%z=O&{6+s&VFa~aZhr}a$r+1=wuR~h?cdy?IU
zhi!k;_}+6-9q?ERy%nNETQm<H=v?Zfi9&(#?l8s|wQKNc6o<g2qD?dfZYx{zNwGO_
z*AsY*PL?!y|B3}4exnlJwyY6dZ52i7_83mfg_-HfqY0H?fnObZ%(4=&HOj!ujCKsA
zHS&V^r83RI&GLNLLTh1rJk_L<T|?z!Y_ttHhNM;vep5p{E}84nUrjkT2Jdd(#yu|!
z!CHg}Vi0ek3;9iuWhF5;qviub2=jOY<ih<YnrcG3+k~y3U)Xa%jYtZT@_KC^DalN)
zM|L3OxAZqo?2)UygRc`X2`6m%I6;pr{DxjGQ=nU<7~7RK!KsZu^n<m>3ltK6`Mc|E
z2O*j()~>F0zODX6K#=9yaH=wwOK@p)cKp>mz@GTfiMs)5SU0N%jwLL+a=;<$p$0=+
zhOE)C;$xm|4KtI#JR1XEPOJnL%H2HNYXdkBW_-QaxL<%LHgR+>#Z|C@^6IC9+^{#m
zW-z+<`Rh6{NgP|h1hV4bqI@>sWBw<3OBMSAp}N%(MU5RDd(oA>rLU3EZ8e^3`pv=m
zGjiSwM>x(@JJ&9SS1us9`?m<lT5U_20lr!7Mx%2Ttr`9_Q+dDuR>M^f(f}S97|Q&(
z^I^%kj{3G?q0*hf0rS9^a>?cD96nPUI!#3!fWo?opJp<u=4bWW0qlj=i5i0vo*TrI
zOp#AbERWgMQGd~=6D8;LZNBoU<j?%4n9`9C`uy&A(^nTyXL>aEV?YQuaaF|?d*{aB
zC>J`1yr!M{vSGkueGA0j_IBjYtS?hiY4areDa4v-shhg>wYDgwChPN7WD$MFKH6?j
z>6sVjV~p>2r+0h{c4*`<8V2@X)DfmqU3~8T2}2WU02YH8MIiqRpy!a;cdvg2hyQJB
zu?8wFL&`2xs>pBZ!lBOf#(qk2rhy4A-S#4qb*aDjv`a+5(vFsEU2T|L^8-&oPn{}H
z0_1kaPh(d^-9{0Qn-FSw6ay~tcO`Ych(Nn7+tepT<x<nE$zM-){IO@_)vsrDgh&7k
zIn}6lFHA&WZN%o7YnVci*Dvb9S(^8aXTPh(cMUX`j0I5IoNH;FkMfnpBvMaW9=sh;
z>B)e3N((Q)G?1gz`6<f0`tr*=4HO|w7$=(KTf4HeL_FF&xoiL$2I?d2x(F!C&hK(k
zNI}5Gq4h_c_n~vhv^PyW8jEi2NrCvzATEkKmtc}A>@;+WC(-Hm;iTQbdaAiRs5{{H
z1Z~h5VU`Uezuk~@<J>Rp6#-+5HzA332(D8jJEvGeu-QSGP6@ZH2|vykjP95(dT**I
z`no}Tyb@LOl*J#Gv>7Ejv6JRbevBM1^ni8{q5LM+MWy->ys)qip)vp7j-c;btoF0!
zNykc3Te<EwuM|v3T%P8=SJi?k4<t6RflmK+(V@<UoR3RZtqVZB{AU||>}J457v68*
z9snDPjFa7`2kJNUmUh3PJn#i9n@x#)`^sE)<9tKn2Ju=w@xWHUllBB3&*N*V{VcA!
zxo3~*G*68XpAXo{oQ$x2rfI}?`)del=KNCz$2V`()W9eX!)R%i5znwde(A|`=_4a1
zZ0Nu1@AmNgjXOM33*Ca<iCR&nQA=pOqWCw!E#dBnKx>9|=h-7P=PAAEr2ta4yKNo-
zb3*eHIkT6)Xmxf$X<aD-htgZY_NCNekYTad8z1WkClUn>Gj6Br?+QUK_sOq9$`cDg
zPuS81PoSOM^9Fz1)pAT@*{c!~a9kh`0|H{!TB?oZO70M{+DJ&`^jYig5m+2H6Fz?2
ze)LksIP<nJJ$*-XR*E;CKz+{#1peE`a5dJC7=#Lg8KH9U@~>Sx|DVVhO|{0WY-3OC
zb*uCEVd)<O?U3>3nr4+8NFeD|J5t;5qco_`1Tpi|KxMdPAf|5c!u#j>j&<~xAaJZI
zObw$0n7;8%ztxwEbhm7g9giJIvmGwfH&i(!{Q{T1^}r7)P(i{rKK|QkzgN>fexrc-
zU6KQTgn%-OE0+cq+-1%%fL8qg8VS-8en@D1|Kr0QU0zns*=5ZA4YmN3-6*O{YV<_1
z4mX`3++^P=P(ZCbXm=|LOKVwd9TP+JF#21igIQSJwaD3Cv2B<&C^t^HB?l%n)H=R`
z{~Ke{=B8C9Z}(S~YFG@6BFOP_s~5<F6fhvW(UnL;K!r@A(LP~@D_?dxr0PEmG!Uk3
zBPbkZMOlF<pS8{*a*0r+ta3~*hX3m5cESt5n}v_X;S{`;sA6~Q0x<DS>>wUPME_(k
z4wxU-K{`aM7%O2<q<rcRmP3~0aIZ)Xt`0DbE&tE9d;?NT9j*voEVYeW2O5Uvd08$7
z{Fanq{{}Z{G9==L`QCMjs1fz7(LN4{s457g(zHN~M9S@(ES0XDoBN4h5)%F*H{FcI
zNI&Wng_sM~i-GIf1hQpDbV$DWc$3UFV@8DX5(iG%9yNUgqlPl8!hpiHgo%K0&y>EW
z(Y+&Ouja;>=;20tGh%O3n&>pi6@ZacwBYxgKV}H4WeoVz4^YUo+yViqG}o|dmv(~D
zW_fT4)Gze)>>pdBQAy}wTA4BmDT+8Sa(=_vScIMu3^_RQV!5xP3s48221uZ<qhNPz
z*KNc(aMH*Hog1f<pIxM{^d*cF!G6bHzk?%JK5krXC{DfXPI~E}vKM+q^%4PD0;6E!
zSM^%0{cnXa5{!}rZVDd{ZICHsbQFt6L;F!%g$$--iF9YFuPWQpfnRZvm|8L{>GLq6
z(16O2sGUBR$63{e;fM6&G3fjMBZL|@^0R_iz35W>KyX`f8XVMfrmM2Ysc;~v`^FfS
zH)_~jpUDGtu&-guaRv@gc63ABQ70j=NCLwF^2@Xom9;(+w8$xM@g!@CfDH!QQAiQ(
zuhE2GhS|g7bmV5;*J!*PBkjjL4~N4s&lBwZNado!W4zNmZmh)#I<bvUYvWD{gGzWV
zGJ|M~#BO50^1727Xhi9Ga^w<XC1eg7AmiPY`$#PXa4u`X?L$_0Blk92jFw*_!ceM4
zfh~!BJ5II_mXt_hR_V3f3&CB)Rx8CgsEUNXn{^>OFPVvG;Ogq2{8HhR*zChWzQHUh
zN9U<S$KAh?%mBnyUOTaVm0R3BBm8-~tklpN3^o!pT3)c-#Cj-H0ZR66cy(}R4t8I4
zb5IqO(kA%4zW+j)nER-&87ctGCMX@NRO_@VyZKI(Blq_XfUC(G9FJN(5>&k5WGvH1
z4djd12bMiGPKeGPMqi-WJP7#~e%1EArn)Nq=k{N=w+TH^w@-73!5=?ugN<YA%9dFe
z#`)|5=Omn|EU5TOBcd<Dn;$U!*-R`igjK^>D5GibiHGvZPZE|Ce_m!lHOeRZ)YpzG
zL>p?y?}N{ezd@;PRzkVuJ>P6ye5!Nl*&bk|p>anSd>Vft7e;B!cBp%o+H7#^l1irn
z;`~G4Y?*KRapNIf@X6w8S749K_DZbxDBfKOe>=sa@4IkG`-NqU!mBI4IO!2ZMpT2c
zMRE%t;((sB+Z79)vkZunjNm8C1;^EKdWhrIT#WGS@?ab+(Sk!AwES0o8=&H0fzBi*
zD#aTtX7eHtSx?H!VV|d9U#5LKm`~6~Uv&dMgJnFNyKSv$2-sy$4I;i{3%c<_>y2y@
zYH@HkY<-tBKnzLi-_@-MZ?{q|Xm{9#V<dR%Km8RTHmCY>`@Ps7!%CnX_jb!tiLdEF
zDyw9Jyty%q$J2q6Nz@_7hGRvFDEpr!nTsA-zD(K~=)&J<Jc=DdMXNo?f81|Ois$qa
zD<7%>M9^Gb(iH<HOShVSsaWMx+5*Kx1%FxYUh7{}$HG2}et>tt`_Qq);2%ThPWyb{
ziG|94&<5+Sbm*P;{YKM)=4;X3cK;Eg@nI#OHed7FiLLZhEY~-ERDK^E71G>0$k3H?
zVxg9Ul5)|}1_5_QbYAngvaI))fpCDyw6gw#`@Yc^`Qe>i!txi-Khki1760T~M>(_^
zMZBjBlMG7;0yB~TFtnr^0W{sB==$T4XWb{1HAQ%6$s$nk6s&7aWXIt>3_Z)ZH311N
zPADdD5}~fmg0CCaS`Qn!afZgqxPIueM{Tp&9Q*YMXpcMag~|I9)VX)UCJ0s}qAu7}
z(*{p<VR4Li){ZIuB|H;1w}Hp$e*R**RCLMC^L=|w55CjlxgM$UPS`|w`a%}+SWIQ&
zmWA?X6uKM5VR`JpX9=|Z{(oFVK{Ks+(_q58w~7!jh!*fx`QK>)oeX00_W?H!Z1+q9
zF1i<@u%Mq;eVnH?bO^~JR^05o*@cN}!V(O8%N#R{34(NP@P?zE_4ZiZZZ2Io4V!mh
z9sWCM#`CX<wG}q%J;eUMc6pR8BWasd>;U9>I@L6Fd3i2;;;rx;9(maO9N}i+f5S^(
z7~|kM^PiD(-u9+!;;IS}Pr|uPN}7=`K;+s;$9gxVM-&YSWBJ_r@VhUF<+Fa}HpaPU
zq<+RC!IHk-D##l(hg??PHsY6+AddA$Wm0aI_*ciX%JDlA-PVJ&Gkfb@Kt|{lCmeL(
z{YY0<%o;E)LSS#)a72FPI}#jABZ?n;98fW*{`gt=kY9mwbM2HX(tP(=ashja96Ky9
zLgAwm$x0H~3k+d8|B{#F3;0^+52#W_LQRQ&IQOiGfbOC4yd<lR-T^XNcPH;x3PSN?
z)9L7BB6S*#xRZojq!S?$*dV<%ps+(vYySJm4)HhbR@fOEz=F8SO2&&QErus%h$gpw
zT*$C?j<4;l_ngElT6NUkbGj_*_kSD*7;8^#BB|k8RB$le)qLUxK_CajVi^QuHYnG4
zv5;R#2Fx2~e{SK0Z+fSvZ7o3mUU5(iTyO;9blG1;?csN+@0{t4^}akQpm)d_3y|pD
zzq2TX+uoy$GJ@Lk^`NAPsy4SdbgCKQ;hY_Ho1$^nDyH9ujt<mL(>#Ajo&TXiN-uk!
zA+Qc86vj`!r<h2B88l8OVV7yroY&V2#pLcD?<b!hXRoh_B*Q%v?md7*{hR!-Wa-Bj
zl}21pNbnVcQdb7sT%E&Q`qLMJS|yrGgmH-xx}TEm71bUcV#Fw9|2ZV5ysb5KT^5fJ
zMjKraYL{T7{l@XqF;G5S^xQMxDMhlqSO%=hRq&Tfp-2>Xnwe-?>y?m;6IdJhDx(Fd
z_<;4!$`0ph5~vJY-j^1|&s*uU#Rgf}Yex%kt)o8;O5!5jGsVpc-I#lk4?`IB|E_%c
zRYgMM9~X5?7-0wiP0|g6uNW-v#aJF&z(m&Q(58@EXtgpc-z&?jk$B1=Drf97oiw;z
zrrTpO&Jfi<ac43fr9&4JVjIAH$H&((R<^^CPW>WfT$iB{V=7$wFBG&-5N(pD?Co`L
zq?JG+eysE~suTi2DnylwvG#>vm^?si{63ZS&o$o)9^?iht~xHoPoI56PO~DiY@niD
zy~Wm5!G*CpoYD-mmjQpRzm$>-^rtcs@Fe}#O(hrs$!!J$%Z{fd1+ro=*Y)E{SkL+G
z^6fUeAM1M3RWD1c+^yYTt4m3p?G_q5yDou0AEX<LIvqe;LWd!OMgE0tZ_pC}dd@!5
zX0xiET#pXoD`OCZA9<ZvLl4s{*Lr-E*0r;j^ptbJ1}roHQ+|0*;{$}FH#5Pwu1K5l
zR8yrmVQZ}4Ce?LKB&f?q#pMJQIxAGv657vIOSs|p>q(DR?N934t0|DQWm@d7QRLh#
z%waheS%y_Mxh${7C07}D5F+UERxAc`|9Rvi5M`|h)PX0+beiL=25LJu9}dU<FUnJY
z0@^wCwwXS*rWTN)_R@k)h04Kf%2Pt4X4P0D5?LFSy|M?|FNHUu_|dolo-=r1YyTIO
zlspJ;g-Onk5-6qLC^D)GGbgqaCH9Iuvl5eRHbs_Xw2Q%0pGEu+2tx=&&Ows*(~q3H
zMrtYfE1Q*Aa?TJ8&_$1u5v{3@Ti~>CK5#^~OiVkAx#0gGLUDbY?fi2l<?YHPj?WwJ
z;AeE?!NX-QIH(I1^Nx10JgyAvpejN@fS~u?1Am=CfemLD!hG1ssT``~0<qc_nXLB>
z``tKrrpD<a!9@(*7k%O6VcW<{qfZk(M|8gr(%ta&#M_G%aMSW*hban9Y4bB3;hh)`
zkgj$dhX?Vqtr)yWZ~v#9LaM?7m01|poJJ*c-cbEu9ZlRY?Imfgg+O2{5O8TA_Z=Uf
zApK?7-M6fz%RAo{nl$hcuw?_FAhPN=mBWlp7tOZR-=>b9Qh&X>BAVlLFUV`R#KNJ9
zdYu43c{?(aqiiibv1^`th!2g-FGAahba|qwYC}sdMqgj2WS$S+K2S6&@Zf}0U`Uqe
zPzZ-?7qXW$VlXiox5l{o$?%uZ+=k61O`M}c!imb8OtlV4R77t!=sX!|OOvG!y&~nB
zo&#m6`tM!oNiZe47AjHK#lE7z#}vFW6#KI5JvJ^=P<;ce+uJeT3-XjnbC@wVSfKx^
z9<cmI1|aDDxU*oKv$Oe7UX3liRkS|}UTzDk!Krif=)qrS-qS!1egv8+nLZ83sdI*2
zk)NNjlteVnjY_5fAvVZCCtCyaZ%h8Bvput@UklrZP{GvngB=*~iP=eUrZ9G+C0t*m
zIzEkl2G)-8Zf>zinJH$|!dkfhl+F<Rfd(0Wd|KdIK|e`sHwzy|d+2+H8^>>_ZAbI?
z<r}4xC*lQw%UIRs0V>DU?bu*)E@jmc!UshWZe7u~wBqnNSNpLL533KbD!^@35J@Ci
z^+e}Sd$Y7*_N3%t0%u=0s4ABX8c{UDkDU!S3E%YQ8s(Ri${<GSX9{^VBewVGk<&u0
zwYST)zfO)vLQb5(EVGcbvMI8QwE}{=B-5Gl>XI#wa9ye}A562+^Rmd?a#8{!vV?wf
zsLhbx{T{{AaZWuCb@*#mvFLoEB4YkP^)c4r*{Q5yYHbvZ+x?l%EK%8dv3ulETiFy(
z-qyndb(tt5K*e~stM~e)g!M_qLsk^n1YK{Myw4YOW5h_}DfUlU?iJs^%h|^)`aat{
z17Pv!v$7Lce-W4ORQ`GP1mw;?ufoUDq4u8OpL;<_-LnGo`SM?k%0N<b$pdc#<f<D(
zZM7g$@3q}JCVT}3F~!&4Ec!Ezge2xm(mXS4nzOs_iyC55R`V+h{2o9ocTxeTDvHIc
zG~uV0IDQB%Pg8oZS4K_78a&2vYI9DTwXzk}h*gJdRx!{MMty~~c>3{ghIvvx@StPF
ziwadH1<|)9j(7_}M8PIgJ!4Gmyl-VldYn1WwCN}sz+Hw}SzWw+vv=Mx`>l%{<H_N#
zCH`$a&{$r9GFeAfXp}SP<QUmEd0@@;27_>&j{!@CaadJb0MC*Xn{ckmwtz@g@rf0m
zf8@jmYgdN#WSH|9pbvcPmpjISd!ZR$M|UTmP2RXq$oX(g(3akX`GgP5&GB~RhluUt
zRH35dYvr&W>Zs*GvGvT=Nw|aq5hhSRZ|?48L?f(!TowHSFej-q{FXT+QNEd;L);tp
z!_yeb7bv>-#oE)6lS2_80!0j{DJHMHP!XQHv+xqybL;fK<Z!~S36lp1ITLCereEgv
zdbru<v62TR63aKCG$j<Av-!6-IkDrE6GFIXn*VT|`a(r<8xU4kU=Zaz(hOsy1ShjW
z(j+LV&$zb@i$r3~j;!c-rU}xlhWl%PHdLpLw(7K9TvVVr|I$<>U;+szruN*avI_u}
z&=D_Sqoy{#<|)6}cHf^t9&SIdwJB(sR&Hc$Zv>0aZt(k(a1Iye><){U!SXxS`!XRY
zm%a=4<Y4Y4)Q*NGv0YpD_;fhy|Lkcl&3N>&ebU~^9<gIXihceHvT8iSP)mcj@!I~_
z7+&AsXt#K!zC%a}Gfl|ohDv=yzK@4W9wsOqtmFtz;4BRsx`iPcPUxN|sYC{M1b&J?
zmI&XDQ%0&y*OOYEw64rZ|I`pQXMVbf=zW@NBLu2q9<{Ie!>lqv4n32#<m0rk!MhS`
zoh<3ueqUMmm}#Hl0FrBLlwWaUFfalEUJ?_1UbbC)38_Er&^E)r{IKFntt{sr=`g=e
z8}S7-_J71_j=SmPa;_9anTuI7(>!=ekg{+3!tlRi8ET!ct&(Viw2CQcNyiIUP$bvl
zGJvWMFhE1D|6+7-Out82)hI?Tgk`&~V8-YvZtCnHxu)fyjd%GF&!*rFDO2S}CF703
zkZT<QDvio+>zW^6!Wb&dIQB0IK8UmOEZM<M(jq3FOZIW~1(=(zuN#<^R3@S^<yysE
zQNieL*(q=b;52IA%!cB@r5$>T>>gk(=eRsMzI-b~Wu^A0A9QYdX>U2AtiAv9ln8Lq
z1(P-B=)Ti8v5C4@H<i`Agy8@%J&c2JrS1_;-R6u?IC{7{XdwN0Eco(UGhYk4`Ldcw
z*1-nFk0O?R)vb?E@LRt|KtL~x5bokwdg+R{HD@9mP{UZ|W9*|4utjgE@cQ(5@ZI1c
zoF4u)<=`S<o6NW~sUWTyLKa{wh>XnKQ}!f`eA&4z$Gp`=T}59MIEsxV0N#!O04UAc
A&Hw-a

literal 0
HcmV?d00001

diff --git a/artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-before-scroll.webp b/artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-before-scroll.webp
new file mode 100644
index 0000000000000000000000000000000000000000..01dfe68b18c1d68ca22e010049b8987c75f500e0
GIT binary patch
literal 36852
zcmZ^}18`++&^3Bu+qP}n$;7rNm}p|#wmq?J+qRudY~!Dq_xtYs>sH;Wu5)(PIS;yf
z^;*53y_KZI#m{2^0Ch281vLdu!ks_YD#pNBK-2&*LJ$Ce75ripuIw6?%lpSy^w-x=
z!|myNwyw3)J>RE|U6Ywth`K;R9wJPO^f7_R)OQ%NN3TPIbhA8&WBv0sLPy*;_4gP>
zccRP}V&~?Up#81VF0~KaM2JowjxV0et7C>w1f8$tj-|GMFQ0p?H;Xs3E7cc^E01@x
z5{Sp{yRAC@a-V%Kq4&$~SMSqzZlCP0&bPD+nXj)EkguyITj{SPABQip-yZ$)17D$E
zWS`S-+eM$!d>L=kmkiI{Y4RiX+sn)EpTS=|?~3m}*Lt(vDPJz1EbrSX0*C^gUvMw7
zw@5Fxchye<>mSBl(~lV+F=6z>Ul5P|D-26lWj=>r6#FEf&Cder-Ta?#Uli{tJqUL`
z=U+D;N?$Zz>hJ1TU&Xc?0^>e=Ul1?ak09@NZ$9raH(w_{HlNAeHD8CH!=D(J+s!_6
zU-Le<U$WP5A1H5M#l>G=4g#G%UthQHBHnv{zQ>$ix(UcgfUR!RneHf}*u(z+ED#SK
zc08{(S_!Gw@|()-P%ImXzX0kRt(hLTYb2!T=}cW*x85hB|68hEfB8+QP#7(jWXN!<
z+-goB;Xv|FyR+?vEh8Du`vg^IZHMDsNG7sO%6Lk`4miZ1j-Pqc$}i6E*w#+LtVrEL
zPuLa*M_?5PYow?9J*EaKEwJYt{IJRy(8p<H$sD&2!iLPk2dS)D0vPn;HlFWzYohfr
zQf%s`&HP?PcgUK3aa!ed>p23DfA+9HC#$+@J)IMX>gEi@s6Y}7>nllIE**luRlzHq
z&3Ucf_bjb%`072}<je3(Esr{Pp|*(|Ltw}WIzp0I(WS$!aW(jpZ0cuNb{RTi%OH_2
zS2|*V&;RR!yHr^_UF+R-AZGj&AL*iQ^2W=vFf9Ly(z_57G$XohDEzotBd@P0A$!uV
zWR89xRs4$V(~j<^3I(__Iw=RCXhufnD3l6E=FeX>(?ry82y#2<Ul-ifa|)E{d2tpL
zgS^^Zi!Pdqz2MigVTQkQHY2R<t5kElCXqeLUi}r?lCYampp8KVh)3B=Q4B)YtuhIH
z@-!;J4|#%c0l!X(R#8&f>zr;I@~+3aG~{;G5iqB{iPn7PD6C+21-<Te0-v{!=k#w+
z0A8@f!31?cQ9UBrAZrYQDU**{%}C{1k5p5e7SQka$I7NHn6lK|qCS;56SfTfg&M0r
z`AVyWf}(U92nG=k7-0kHow^MR+>akKDu|9y8T6do?5MQ8eEOki^OSAJC>F<9MYr^o
z5&e9n{rm0Iy?f{>OU>?=Ob;tUYSH)vh{azd#M-_bzY|TMAwT&#M2<>6nz6=uTG{)U
z_d?PsE#ok)VIm_LgeEh$2{`GGlMAPXXSsqSc2*0u>9}_vOo>a-Rl}W{wpKPU_<qOP
z@zQ&oF{8k%bboY?Cn623H%f#*2+Z{rd1f)yM?^IJbswvj=T3DZDg<pcF9Z^Q3<|?I
zx~R2LI*-m#to^*ost$@vG*Gu>Jw<g%iE7db)X#ut$TcZp16OM3ft`3}K4cgV9v<`3
zs1h}_yQY=c)z*|kJ^C!JYWfFk*?l9M@bW*)vT7%_XU3*M^+p7#KvwCVHWJVgMq`9}
zX7?@wpRvP03}OyAv6aQI2rFAV%Y7xQ1yjpLW^I*ZV9o48Jf77`g*nCb$quT?g0SB6
z;?y%n)(<7W>5(X4a>^?9)Nq8($^^P3ZU9rfe)5Io!!-saS;%0GA!i>=w`Am{*g_U<
z9C(DTGQ+-?I_ayvGVj4bH@0|qNaiuNK2?3Tcj>~PbC>P0qK&JO*zurE+Y0c*)pY@*
zDo7uBPW%9{$d#<bIO*$dPK<*dF2+HjJA@5_=jxR&TTdDw^f~dp%}J>y%%j-M9DDN!
zB@AU41&0c|J&BC2Yj)ofyQ%;cKbjC9Il^HJrO6;HQNZAGb6GM`zh1FAimnE!*i@kX
z1o{X8m&dj)Ye^REHYa30(YjqOp2%ihN8e~PqF)HE<Uoy+QuInb$%d|EPn#AYHL}Or
z9OHIk_b5w?r%m0gKT}0*^)V^?kQ`-9*b6EyM-yxc^EaNMie^-A7ge^&#fR;Nvb8No
zNbck}xhcEI`8T<Sz31q@Y`$@!TTk-QWjnT8FUhCa{+4%b5d-22TYw5D9`Fx+yPsHI
zC2HR0OtLmZ%JAw*Nv|gMSkMnD0ihBc1@6PX@-^fXrM_wp!(iAVB2`AG-;VpozRxV^
z=UrSp#0!!YTVuW?49nzk|6QuVLOzYxqT!nZY52Iu4p3=Ax~gSMUl=uuxQ7b)!Q0KO
zocb$)!PYFk*8TrA$a*9J+ZqMieu`CU>c3yUCv%iY{JTyexWQg<6yrccHLi4+K1QH(
z_Z)*>fc!VW8ihCd?34i%>+h0|9r75%ajLX9g|kGysl6)R!a<#3z6DyRp6FG#gYa#p
zt@m;!tf<%8(5}1spm_2ZzX+IJ7oDf)kN%_u1>3rlVipy7zA5sL8-=^~$&DZTHNnD)
zES~w8b|yDPvtqygWNVH5kMWR!DPdJuyZ`y4oC$#pKGM;H2tDcoBA;pN1Xh+A;^oe`
zPlG5wiBDcX^?BIe@XHw={}&dEhH&oUNdJF1k!`REqfp=$^?=o|Po(>DX{$em-YA~{
z=kxsd7t*2fChr_(*Lm~Qd8>^g3H2ZUHcIGUcZ-IRUZXZXDsh<!^0TAYK<2GfOfe{6
zTrY>&zY&;pC`0s*O@#uvgRuVdaXt-V86nBO%M|V5@-`r`k^ydxhJ(f#9E(+C|MgjN
z`>#)|Yl8o?YKG`E{Yk}=48&g`-T9fwZ3+#^RLb|19Mu-~f=<6Q&DqfB*3{x0Vij37
zvjUzARr0UU|7P?5+OKu9MupMc`|e@2e43D@b-3ua$Ya^kp!+%253v(ZY*7~&{a#Hi
zc?Qbrtnj3Oe;TX~|Lso>|JsZ=i8~hEpM;=bI}pCW6tIezn8;-Hjy315&_fBq)zyPN
z&c>wi?y#@@C*P4x6aWf|n7-tHLay#?Lf2XaT3J)Bm$}Nx(hCos)nNQ5!wv-h@R@Hc
zTcBX3UH&&%uJhJ7`4SEvo&^T)AvH@mUFuPwz%xA_PU8RTP{@CwA!j{7y$Yu}=lq+E
zw4OR7=Fjj8XStTnvMe{{-}Nn&g}|Osks<7^)ghY4EC0~K;=67>{0}h9m*xE?uWhI~
zT>bwtw6LDBLW4Rr#|mJOtd3n2Fx}(?ppXh#rR!GU%TxRt!mZ<D*!zcLM2E6~U=m!)
z{-NN{y6~aqL#h1A{Q^``KSsDIS7drKKKQ(wwCEtrV*gvr)-H^xX!ftI`zgle5pcTw
zL5+@ojm^a1{s2McHq5=~S(nG}OlZMtUe11))>QANm;G`*NptAHf6-So|KE-%dOQ!*
zSOgyS59TQw+2hQON%Lx}Wv1-Qg?`VZwh=+D;W_h*&S{r!F~ysHbZ$@&h($<Gc~y=D
zO8qSsrlK|0zXbFbSX8LpQ#f>gi|uc`$=Zm9&cR5?)x2{}kc`ZPqc~mfNu{@75+Xa1
zq{IV`ie%3c{`pYMxYhq3G}t%P!o_I+@xl~X?01WZ*;j1=|3rAh$lE{6^B3zN*8iqA
zPhDIysVp@3S6-@{DO=L-z>=P2KlRQn_S?R8x@YWQiy5^dwxPq|j0`XTGRf$XJIM`L
zm9Fclvds!Jo~iVe5U8n$$`Taqjhn~+gTb055bUm6I&c~F76+z&Og?Uxl{8T;KDrH-
z_+bmfWajZ{-rzr^TQo~eL<^dA-AVz@bk~xs8}Q<GYA6m;)O0-Ehxk8@pjLKsa<b&0
z@Yg?-FwNaS(ZgXAB{uB?KThN%(lrGHf6Vp9kRlZ4DqHVCydt-lC5-+{NjO%<!O`y|
zZ6+x%`UD(zwrxTYJ<2p1Tyn4!QZGmMTxVhkhjhs3gK?XD(e$c!&Dl&>>|WhS#8e9M
zbaj;nrTzv&N~s#ddNOe8Nn>6gi{+y5An0eD!c?Ae?Ic6_r}gTEA;@8w=$U_9SK3UV
zs*h&o>)j3Y`y}iAp$EE=<hv^SH@tB4Vx5b}6CYhZ<NtUD#DOh90lxYdhFS+RD_<tU
z;v@`qA*0hn$)yU%nz$*=Ih~&9#ySKjQeOEEcp?pa*ia3l%Hq<BNQRs~Y>r%v1aRG!
z;(rY6K=}IL5}0&=X{}(0Cn-JoHXV`zmkAU1&_rik`th%d^HX7TNIh{Bs-|5Pjz7sD
z+=St2SmRoD!c7NK+Qs<3`EF3e{3EWLx$AQs*O-)M&1rxBc6>kj`Kx!{(U2FLZQAp^
z7^ZmyshJ-tTT1$l4ga*m0abiox**T(BDT@d_+iWZaXCickw98Ah-n4=Kix**#Ib#X
ze>cgX=K|&WS7R$T26NK<3wyr<ZeAMkTSKeLQYF%ifNznqbdg1W3_vZ_cd$CLfH3&Q
zu}tCRGY>e8_WB%LD`vtEjIK-AvOPefM<;^yxk%7zpjSBak+XxWSu}?lVrRo`nyFt*
z%g-D=!$HNKkYjyO%Kj52*@ho-+J9)vt;hObEUY~si`H<qZ)l_BXaa)>wSH1LAPB`!
z*>z{xPHY{oq?SG!q*LJiFifyDs=VPLnqMs;Z;Wu0_$SX66F&TP)9b)fw;Y4h$8s9D
z*EuT&|4Gy!-A9GJgL;4qT7VDTbrRI1QgvvbG2b_aL9dS}wa1**U9rF1B=R)0somzU
zF8q5~1MI&_soLS>IcY6Rq(v)n4tn5ne@eCInf7-{b@4fN=9c~-m`l4MP8fw}8tyuX
zpcVS(!_R#YBFh}B-!GmC2jP;V1k2A-oTQu^dEPOPxPKB;OY4aoIuA`lL5=r6Dq)9<
zuevJuQC_%e-Sdn~*d{aCU9<DI-oJzL>QuiN+)?%+K~`Us!wGYvHH-J*$xk9TaC)#Y
zBxLe7{=Q>Sag8H4C(<&MR+syy9y~Z4{i*-%n*e|Bn`R;Da{o?d`biThq6IVA=8ECC
zQ1*Mg*`|Uf5EA1_5W^c6NVp@+gtpF=79Rhv3|Y*Kt%-j9<Jte(2o(I<|9Y5-A5>T}
z{5&gmHhNFWTo8+h;r4|txq);zU@OPzbd_3kgUWxT{r_ue`IDqJKT>za1+|Bg(!;5G
z(wbMch*WQ7I9u#vI|AXog-#F^*foF?XU9kB#-1aOpyKpGR~>U5Sh>73R>kZR8vfIe
z|5}y*{iGzy+8Ramq~>Q!&musDSBV)DuO~zgIE$n7DeY?cV9)p~hf}URR@2k)M1dJ<
zT)wIPzrgA>5Ys_tb$oEpHgW6@Foi#Vb#_39Bn+0_dotKd8R(-C{7zh?*s(?z`#{5g
zK}`%~Eykh$CZp#OSBvUUDIZp^-ND9ttlIbab8dh!M8Ka;ETU)Hy@3n>Gq|bf457%2
zl%@wKDtc2^^P_x;Mj;jFz}(9Z`2O&i(6jTied|nb=$06X&n*p*NH#ghTVT3CX9O3<
zr>|{PbVfNA#|_6)zj|QFWP?|jlot<D6zer<h~K|ZBA10&LyGBHzEOOrAmUtloNSFP
zkODyz30a*1e6jrNc((5sJEM1e3fIy6svOyM>&0f{&m|Ne4F5aS72}LS$51Aaama2F
zzTA`eO+&o49HbYk=a^x!JY>$wx(6EEJEBg}_72~lD{1c3hn<BiX%UaTGHZ=C-_&K4
zP6y1+Pjo2Vr<VdS*9K(GYl|LkZ2}ffc5(5I<h*p;Ofl(i4p{>#a<axTbZph-=7Med
zumLK<q+-87Vl94ui-)V;Wfr#AcS`6P5qtdBRgFqDblnZInv{9R-NwVSl_{lR%*Sly
zJ|66cpnj2%hjiO9srnsrPOjPq=t9PUJu4pvts>phE4na%VJ+R2rUIme0WrwyNP2O(
zG-pu9@aP;LNDdlp0JeKOO-dhgf82=Z4NlK$+*`H0v6O<#oJFlwd~m`?Gz>mRzPebH
zx6Xn)!z+5w)jVq!?}jb##}!wn@#xhOLp`n1&)INkH<#o?vbIztf%$W8VCfXax@e4b
z@9%_<42<EKb(r5ordH+O?V9t<=7{Psx&mY`;R$I4XtJ~`9}c=}&_Q#^5#e`EfXQ{c
zxe_m-2h5{Vr<s?E7w0E>IDZl9n;3w4faBL?wi5sVuZQ3#)yN1W)9W2&>AyXG77glL
zKF7(P?APS7vN=P2i;^)jLY5f*jW4Fvd{C=71wk{ofAQqt^Gp|Lt)qReCM)q(uSND&
z_%V}tR8865SJxul+6i`^q~G*aR1b=&@l@dB$MF%Bi36!;gq~ye46Is#>;RgYLYA}o
zk+a$Z#DoU`z=`v6WD-YZ@$-6SZ^1pkwgkeo#k6+*O2Km)Zc+C-a+&R?wpJ9p7=vTP
zSa#wavkA)5j=SgG&`O}I-#Q?1L#KL5P$CeZ#enHduKH;qzcs2k_tWHTa`q!tW|#P4
zgQsTR8~Do=4dExKSp}mYin?4;N7|U;9QDIn$h(`g<yswwaOh=_LJ*?{kzUssiPMXe
zmzL#fk$&W}gUbO8vKB8+<7gI85vqNmDL=fQL2z+@^-t63!XC2a4MdC>L$2QaDw~2r
zPLdM0)sYeRfQU9#t#u!g8Z{z83&<4GY$_zq(`232paIi`(iQjk9m%LpOhj>t1T~MK
z`r!mxd@mwky+DWsObwt7jwoPU6CyLLp(L37uFkjezT}Xc_==+mAsBWStX|i;__Ho%
z)zZBM;ooT?(ukHGAuOX(ZU7$O6Ma~%C^<=Pl)Q_B-19s&X+&w=h0tSIos)1YHRr*p
zy{tO1Jz5Le3fdI<QME|38BrbNxJ3iAUBfwPpgE(}dXh|fktRQiZaB26Uj>XC;d13t
zRkAKu!AODCa7-n5Awke7K`jp<W|IS}br#k1t?(_PXL*EY!uaEmuc2J_(6mSgt_^}K
zjIGr0FMO0=VD6A>Up*x?UJ*eH96lcpV1)PLfS>D3J?H(6QtO=(G)w^a?S_}+j!StF
zd}@}?_kd(L*KmAWwVw}F`}(h_%@bUQ2<EM@KJEzt!t}A=^1E1z`?QF;Umn&@^4S+h
zNJ;m`;6#`%k<C-IjR)7Ej3?#<V^J+#;L~t03(K^V>!g)ksJmGL?b}H>T>S<pr(#+x
zG)FhPBp0^P5g%URs_@R2YpO@xWtx~tMuBPKns=R*&F{Fe>vnn%w!zzGnG@@D>xhT&
z1%!}h@q4n^!+s8dcPok4yVy4f*<1lpu*qjd?JMV$?p*w-Wccj|nDoPE#A4!t$8mZ@
z5UkE;u%cB^a4s3#{ZNaK=kr%D6b$*v>x$eBlCLJ-)dI<;rO^*kw!_<GQ^sl2P(Qz<
zOq#YRy6i^BHQ;fKY8`ePFGd-m(|oLYb`^p(uErDty^0<Np*ITk63@%gvl!R<N1TvZ
z81Z~P#>VET>lZwE-#Q;eU0?y3AZDOnye388;;QKn_a^!K_u+|<X$UV>FT08q9J;>I
zZH^)hr;`tXi|@w6(5Be<K6}ft%gNmMrK-AQ8*ag_aA5N~3r(`{WimK9UIEie7=;y~
z<W{DQdo~omoMju9uJ5Jhs9y9gAAgZF6eT=L;ey7_x2BJ7Rpn$@059*Id+w}GKTk<r
zoQO56<&JWD7T%FTTo@(dWn=~&0+c*Q;X_!&<O@W#5VI&4vSYYsz+9W-C3Kz*Vr6te
zVQuIg`8_=|A78HQB1ikVdI@K_5-6adjDxSuYmEjY7z8hMP>Zg8xRXyIsHfuFdXj@1
z>J?XPxp6jt@m5OMT$GzsSx-Ax;shfxzK4mT^+`EE6IzO7u5431x^j+{oG)Y|djb;!
ztH8I}dn7zD%1h1#^*cy!YXG%EMcBCFr9`W1L+)JgH_-x^5;n`DMdqrKF>I3k`(<1;
zX$wdLl7WYW=z740$II`jM%uglnD@;3X*?0y3}jZa=Y|mA+EzP&q#ke_%mApI&w2u0
zkCs}ODb*^KqZxZxiq?(M(zoe0!rliagyaG&k7_sXtm)vuQg?#UDbPG{yP#CIP>Ef0
z_rH#V<cF4Ey~|t*e20^fNoNqNAVs-p+}=E_G4sG&x_eU&kqQko#CR%t)Ow+lIKcv8
z=z~dLQyuAA$3j#9n^j53ea~w6r~m?u${tqd&`$Wq!HHD&IZ&7jH+~v_|Hj4%3?fyD
zGWb$Qp6JovB4R;oM|k>8TE1Av&~hzMbV@yM$>wV+qCN+?Tb(60(nGEdL57aA*`=xU
z5|4R|nEOmEor4*6!1J^I+YusR?&Q>ocbmGf4YCe{N;{`*KUPcpXu1@6pVURAO%`_)
zR=XkyhsZILaOo^t4!}2hdLR(L4uef@44q#88yR^5`Q>dCf@GFnh-SO5v@P8!n%+fy
zL9UNDrpYX6m0?kDME#^ThD>zfB6`L3uFPEjD>S{?{4=(ZLJc^()f`6fBP#DApiV*_
zcp%Jp66U*n)yW`SK%0@}JRXJBS`hmWoLz!U8|tm&I###13v{m#zgrp218T6=fW`fS
zAqSTjJdW|9!>9CE=BW-vO?d6a280a&-%$!#52EBrm}LQZ*+LLE0&?N}Ivk*sy$B?&
zsYz%m_~g7$tlAP9xVMyVaW)NJVlVrta%y$&i%{9%5}+^SFRiQAFwRfq+(U!{RnN)8
zd_6)=oWaCfx?Dp=cmBSX-8!y24M%s6)m<QAV4tI{Q1S(b@qqkPapOmo%4J8<TzIgx
zGFZzU?Sw}kK7aFKh*3NuW+L*y=df=h8MT=2pE|Sc)s11bpdal>`khHXWU<gi1w`xH
zVALcgB|N*YSv=(wmQ;VR@V1338(Q-~MFh~Ev-n%pg!T?=3B0aVM!qNufV<?NClZxn
z>1XZO(X&@H!zF$I(kxAc=HX}+W%!9qcysqBx5|Fg&y-0n3d7d4)8A62dD*e@d$CC^
z;^G$EPsRwsyJ#oljYyx_-yb+@{UX0BS}~Fk7dKV7+_l4uACPt^Fce9rZx7K1;wr$p
zP%j<;>w2XE1*(Yq0C04mOZ<!q2O++3X82;2)PCU>Zb`_gOH&nfbJ#C%hUIU|oOvCz
z#4n)Bc<JU}EknR45`~uU67J#&zI3d7eqYEqE1*0ogyc4QnRzLVj)oR)2-T{Cb~;vt
zM-=oEF+A}tTxp`UbE(RAPxhmN+2$?4H0rnQAR9N!ntfMsE6$&2f#`fUu9R+v2{+=9
z-aoV9t~yWW^;+!ShK(}uH9H0_+3pd_N><xlD+cy`WuhR<7>ub{K;m&`&X*)nX<$VN
zcdm6RTvRct5SB{!Ofv<8)FAAPu`;ZFp9R&|z7?x4!Xo-K!<HfrWJ$V;tsWhkv77NT
z82U~z))+6hX!j-0a5e5{+Bo}gm)PaBA>BG$Q+e%zXN5Nz4W3UkJ1ZAF;ckbjGsq*!
z1O()tyWstMpdg$GW6T{vAhgEnpn5j^Ys1!@`?30_*zF|${vtWT6q<rb*#|O#>PLCv
za+vbRYfkyv6Tr~fxM+$xuZsYPk7-9^x{>i>47-rCe_5dL5W)3Vs+rANBd$sz3w!ha
z`mSra5g%14^-mC+fSq~?=kB-Nsnk8tIYF*Z{Y5EO(cSDFfn}ron3jV!j1)$ojZhEQ
z`;oI&e*BGdaC-8N>q8Y8;m%;kDLYYeG!HJvt4V$W7$?nvcOtTc9#o2XsOUto$HVE)
zBu~@Vh59X_ra?UkR;4W_r&raHeujo3cj1q1@*uOgqReCS)sI$0oe+8W<RVn%=b`mv
zlHw2<{Zkw(1(PuQHLCpx`!q5i^=9Y3*F(^U=h*XLg=}Nbl7h`?_QweU`Pp7er9FSs
zmCT;RLX*n9b+ydTl(7i56dl&YJsL|u!85n26{whABgj*aC}q3k+n~ZZvkFvUr7N&R
z(X|a$<2MT-IJ4n!gUU35lePgd$AP!nMDId6OP9EIYMwRH`41#ov}vaTf`W*{T?W-P
z=yx$M`$fD|ClQgucYqtbK;72-Pwts*KP>ac@dUN{j*h4RIgefV1e0&#T)d*c!oI{m
z@uLdmCQ5L2GIt8}Y<i+%5Xl$ilT0O8L9<0I6n^NHL-RI_fHPLBBdH*ApI>Q-(a%mq
zTH^$rmLG%jYcCb{Y!9_k*ODx=pO87jh2>fk7Yw85e_c0tmAaT^=_wjO-JWY$YHobT
ztTX?<-qzN2vR6k?2mSL*B&h^(|AnEH3nJr1LmmWp2O~{6?gt5;#Ep&2JJDTwk=k`>
z_cHbQDv7eO)uRm9_cOJ~dw47>vJMcIWh~w<mUN_(n*%@k*d*)Qdjs32n{V1p4j33W
z;eO??Ke(m~!JDF%J7YI7&NkC3?XGP5YWRZVL1qfJZR!CPw$fe#G$7-GzawYr2u9*H
zitlDrG%Yna2Umd%kUZhn6QjoEVV5?fP`;uH@8M^^YA9H`>>`D34I5HuL5ih_2F$J2
ziZpxCHY`u5-3m6gY5W%TpQ6nkXNhNgms>3i$iA+4TVu1EH+`EZO{Bj8X|-B4a-j2{
zfCGTENBb0?1IjO!4`*oF^u*uDo#}R<Er~ST-mLh!EKnwT>o^u8$XinalYAuzVnbo<
z!2mbCV8Ff!&+X?mq5`4tXka$cEBIQQTV^hW!n~J<S5`_8E*Uva!Kb<NY0HVR->1Ae
zBovf&J8CgL;Sj?f!XbAp<Pe^M)+P(5&oD~NQ8&E(j%>$6neAt<DG^`_Oz4i)D1iHR
z)R^AMS&jWf=SMVZ4kVv!bOAW9_>hx#zh>bO1iELfSb=^ugPq=8n`Ab9bv}3AC8D9*
zikm_0FsAS@^n#A7Cojx|-=o@k<Z^dI4Ydt5BQ=bMgrIn!S6%aE2WJ=j-04PNSiBgn
zo91Km?6^3;L<1|7z?H0%D$SOT1@I3+u0V7Cbm`oKp4`SnMBk|Bfm!(yX7zjvTWYrr
zU1iALqe0J5!Pd~0LV9e2eYVlHwi*VWN;woC)yL%hW~=;7wp7TZ{<NiYacYqCJHJjK
zQNwc6l7&pehCI3p2eMf#J82hUk`>O@T5bLfv&HXL1HnW)%-mx=t5zYzYBA@P5~{k<
z_jodq0uR58(&u32YRvc7eXA7XDPW_PaCPcckLv>u_ZgsQIk2RwM5S>|jLuwy7&Xs<
zE)Kq)@h!^>IRVQ48em<<dnd933xxcqI<)G`EaY<FU#m@FAHc9&7FmKZZ|a2S@rFVL
zSlm)_OXEwYI6d;I+)Si;oFjL(0y#{H3{%X@L@)kLtncfL-*N1)c$IMNAE-mBx&@IE
zYDqYWjat3{bxwjJE=<I`G|QX`V=R_q;y~?i3HsEXS!H3usg-ZOUFeOqrvbIC<3j51
zRT*Pgos^Mup3SFu=e;b;$^$CC+~<}n+ERYO#G<BS%K?qkTIHRS4F1W?#W!R^3?g_~
z{j_si!XE6Tc>`~$;f`~d-?lDhtL7J(-zS2J#+jg+OY;ZZU-X`~6RV{iWajJ88i8wS
z+pZ%qj#UIk5=YKCmg&7ODZfrioFQ_zLGPUEes&+impI;zu1hwkMjnVm=d>+&K&ELu
zjE*FEp+!Qh(KU(95G1uqb7pq&#zUd>w_!`QPnv*{+1n}ztTIye!4mj3Qr`vMD!N!2
zDapB^V&g|1+-tN%|LFg|#N2zTk7Rn@lW4?->KNeJs~Cneb5@f(v|g73$<=v%G^b)%
zAHfs^Y5+|i1vIGXEf8`%{$-aaYW2+!UdHwj@>WoeL!|mAiBcJEDcuZ8!8!sBKoQMl
z7#xtl_hTIQ#Xpqle9z?;rQX1U`5fwTz&do0YPLU;sVHQ*tr^}Zu^^i2JNZIdpw(&^
z`!lV?-GDWr0Q8qN`x`$xv?r-yH>>A-?%?l<y^!Toy|QVcem~@>Xi3*(F??iG-(;9e
z1kXyD--CYp3XDX(TG7ilLX7c0yg&H)=jF3X@^81(n~pxhQ8|%0Zr?=>W&kOG#S`#k
zOKrYM!XPb<otz#I(&TR-*1Zez@u`jx2B2$xXVii7c{;tufsv{Ra+%HeqZ?jnNs=~*
z=OaLdl%WFl+(O2aArYjKPn|fMP_v=fWy)S3r5lUs1fG4$u6*~xu<BSr!G(|p$$z>V
zY6Od)UUlHYmH^c4moj$*iraLfOwIQs=P$pxw*esoL@L@iRe}byf<_6kuG8O6F4(<7
z^XSodoS{#)CvSAD7)oE;up;bm5hanr!uHhJEh>c*3MN7N4vQ~`D7y5GyBxr;GItK5
z${F77?H8d_qaj4&Z;SD7j?AWx3DT9?Rb&&@i@h~$y|Ov<HH?>!K8u3OVL^*YYpEA#
zg>#db&t2H9bfcYzz*CwM1BL0_?hDRIeAE{Wor9kj&un`@B2Z_U#4SY}2SU}ZQawUv
zEEyue=S1Y9X=s8iPywY;(_H6Nps^b5?Rs7aB%viQ;+!29!?JN%-uEfUlpKjC#Oj~s
zSn<}Uc;W2#n@NiBbG*g?iK+$UUCIV)D%B$5cynn8289NKu?%P0Yr+VVp-lD+xEJ*Z
zo%9S09vV~Kp|bG15$-nB<?%#cerbHb!IWd_S{GXiROtMAccCxgK)ja2T5?M{TMS~1
zls_OvLiUxzk#92>J&rT=l64X7u?Y-$oAawlDE|f5Iu(W~`cOPR`v^%X<K-S$YB$fA
zy+tUQI5;on;3w9EP}XkAm^ZQj{j-)e=Y6BF%KHd>O500b(%kNubv}_8FK-_%JYIj!
zJ|lz}!61ahmtj@7ssiIU*aLiz=e}Fea!xtcz3dvhG%Pl_C_;@ZeL2(*O#`K<{SGz_
z+u|W#UZn5RU>d%j{6|duWiZOxAhPU``T0cE{*K6jV!gl)DHvu;;DK(4+=zCDIt&Of
z2X$<&R(oS+ZFloFIlB@z^HXBkOE7nF4V=SBpguhV{BK71RN!}UClEz2Q0z|H>`}F8
zVluP@8nr5D2MwxhT-dVXE6_eIR$^t}*JkY;66j8G@mPe-<ZOv<LKg1H2ht^I;^8-2
ztx}H3r)}1G#i;KV5z#?OL|WL+*<M~0wsz89wh3V?-l=BrTy<I48!_Ok>fh65r}PwV
z{nF7}h_vDCr>MSMx5$L9F+_jAKPhn?B1*PdGe!%%I}1R~oQf7B`;c^v!<6CVKo<}J
zy<7!z_3Xa%J>?G|z>gbe$L}bNXByk<^xx_A<QL64%n6%Eg9PSgyx{W7HOJ_`Dj0h%
z{n}Ft+V|4sejHSfNsN;Zt}aceu3#i(n&3Pm*-3wQ)kd#GZK5-)ik>ppW2%cuujgD>
z%MsdAv76!lj09#EtK1YvK)&8~G`^xTz317qSyd^QZ)|@)XV(wdqH{7z%1&2zS&E<1
z$$tZO#*LdmTc_>4BO<`1qzwXhf%{?aC+)QHZK^F0KG}*Fhl(u07NSCKQ&PE5cJyLX
z0vLAa5Yh%gO?OZKAr@KyqU5oGnom#LGyhg;tF|`Po0n{n=I4P*)%ase#>HD%O07ug
zm|l{O`mlg8m}tmwG9=NrJN2Qw)qq$S2@;Bd3w{>9*l91FQt`n`W=NqJ#6D$4h~-+O
zM5DO~?iG++onpi+ac6(a{>|IplIlIx9b~`##q*K*n3^u`u9WegIMOC;lhq}VV=)L(
zdw}2|nXb}S$;eZ0S9H+1O&rLr5LWv_rt=imI~tT=ix~ojhBT&h=YEQOU$Sfkv9&Ni
zVgg(X$$6vTpF&)n&D!L~CemFEoR^dp()W-%G=TYx*y;;PcDpfmmw+}YmL-f1D)ZI%
zmth+?yG(fkKQ{vlK^D%Xo#sj@vbM>;@95RH%9J?&*eJyM;Y*QF9}`N<A~B;Gu9Q-D
z?BtU177KHtFY<mnUd@@kS(japONRD3hFu*uE7^6gS7TOINJb|kVC}z5mc-W2^lgn)
zHW|baKbh*)sUsFc*h`ka=4=y=Ay0DAJHd`u=IQL9dtZlDg$x-lU;_`$^@Q%n^*3Iy
zNO0MdQ8QHel=Z0c^eqfz#E=#s_c^PpXk|ZyXe-EpU*+{&a*s85Qrv+!wOPgf<0ps{
ze_l*MTGe_o<hrh4m!OiR!97ujsLJ3u!-ycyBO{3&2xjcPvn4q$(7_H4rUIgbwH~}c
z+`>w->;fX5vhL$`D#;it?NH-LRW$7geEoP^9K<{8SsnDBg?Lert4%V{rC2Zg{IN6s
zN&wP(-(!c<0o;2sZMp_8y91RlqI<~uu`B2yqk{sSDun87D&#@VJHEZduZKM2LUMzO
zRL{PjQpz4G^_JYJnx7N$z*u!!P~RHb42RU1=Zq9AmQEIB6)^+*H7I4C3$uj}q${?=
zmrU6{PeK7ffU<*ai9QU?Dw|0;Qep86u}H{MKlA>Pw?FOGdk0(h5`@r{PfmsD@LPep
z&JR)`FP_76^uTiI;aZ3HOoI*g&Q<L0I5c6qK-Nh&CjKf*|6b{1)h?+dl_5pd%mJ((
z3nQAh*<tE2gjgDxvI--dt<cZ2XF+$AjJFdra6UoGaO2ze%%#jbo`Hdm$+f57vO;kp
zKmqX%-;Z~4r4zCOkc?z@nuv!VKszMhnw85!2X}H7@<yXHwbma~N<#ME{10C<g6fK|
zkgw}LhdZpU5#N74beMk4i~;tvJ})rHv*_u1iC>66RcEMy)QHZ|ayQQRDVHZ-sp9kP
zgCV!9*OqCk-mfU{%Iu3vDA&~1Xx38g+6woqX?#5M^GWs%RL0Rdms>lPv!oxgj+YAf
zo7v*lY0MSq(#SA@B=KmS`FaWMFd|<ao(6!ZX+<YGkP7#Cm#SIx@N96??~CMTYsNPP
z=qRBfSKVvcUvc>{3SMeONQzxR5x)YGm(BfDO?Z6-aa^cgcgogU`c~0PD7Uy87+bZF
zN!4Fqyiy;Y5e85yjPFT_3y_)62IwvvMMJ^RoifSr)O0IoHqU)OYVm6L=R8UE_rJih
z<e!-dQ*DY(l%7z&$?qZ_HK}^T;l>J-9-^xge~%qWdmLkVjcgp!O#%<rd-w`cnuIXr
z=$GoXhS!&?z{laA_&(iBgeGxfJ9rb@nCF%FAv^06;8~!z?-^^vrvzEVStyTkA=MVx
z2?aF5xxWGa1Lo|DED@tS-ZC?CsW9OCJBS}JC}X(Ha*mF&5BS3GqUkD~AJQAuep9mv
z;R5VPwpA11P`@zFP&G^tU<O`(s!XSkc)Ele{$@>pm{8dS2>JqmRby*&sCqwvr95`G
zw1aSjw$b|r{p(0fycrS2Sd4?&{P;#zF4L;bNOcRWIX0p<I>K)@L9YP-0B8WxnR7Y*
zR~=5^L-A;ih>%dk+;nonXlfsaC4Qy{?e33>6pXIw$7`c}=H2YmR7FgFpVdH3rOO};
zD-YPcD`#e*(KE|_Jk0qPCJ&<x<6Z5nNK9HUI`;g4oB?dVUiw^-8yYQ;`@Z7hAx%DM
z;Qs5WPAZPM<M29yR-c*7zResMc&4KVm)?8)`}tC4nQE8TH3Pd=H2bW`{#+#^ZOoEB
z2b=~Mf@BJfeGf2yeHQ5!gBTaAVqei4VHVxg&2Dx`R}`+3kUx*qOoT+_v*|p$T0xmJ
z&|!Zik*TW9LLPy3p*xk}W}8lUm%C}2#>x2FL<_S?pMgY<5oc60wO!vb5<m>l0x595
z*`RB*`;PQ4%^S^SgLO~9>&)7A8jw~c>+*Fx?_Gwda23vGJA)v^=DW>SljYczRce<E
zKqlzYrWEFEKec+i&nyK(Er!sf!2qAOZyQu5a4&bQoa5~}RBi9WXzr|I)xjGD3x9P7
zibf)Q_*T~%007Cd4!ueayl(XquFyEm7Zzjt`>}$+h!kx*AU%I_gADXWFX#)b1?W<5
z;+>ds-RH@Qv#|xNWw9T9gn}QQ@kNvSGCNp2Xu*0d>Zr9>tdiN_uYyEO<x`*ka3aYE
zRp8W<8_w|5O1x{2A==I=3A6&i-PAv_BAb4r1v=k3c<GKrt3>E6gX7OuZDV!078z!d
z>lTOFlgNVjHJ8B_fgYZJWHuwlJyys{>zcAY6IkGj=-5dt?}ZL<T-J>4{&JdA?SuZ9
zYxkwPGZ8=f?g$IGmg9Wy*+Lc$R;)@W!F1|5{zV5}#&bl|WkvwZ>SWPgGC6I(>NYyz
zB;w^_%AasyQ%nPvOLk~cob-!c-oz2-eoo0L6;BKH0Grub>P<x@7A#8InZ!*<!B8)1
zq)PKu1>Q?jHn?0KbZrOvlqM=yC2r$|;6+A3F61S$2VQ6q2#zr&UwQ*Yg;znzfepQU
zjccc$0f*wuG;#u2RX}cZk^j`W8?n`))8!msOhp^u=`CfneO+i+>|G);H*yNsQzyu}
z503NUA=SUL*M3E3h^(51eP$LgglwKr$+vo`5bufl2m%`J_)JKQMb3rU-Im?X&~kHe
zGGWb{C&^wSU=h8IRy4Wz2$e%G2PO|QAJ*Kfki%FpzHaBIJ%0ABY|{^#b5`h6-%+Xo
zCiu1MTJ>QwYZ%Hf(9{et1&C!JVwQ9auZSY$TFY+q&lNTff?qaA-&{G@l!$_uZYAqG
z_)4fOFVQu;Rrx@=)mNKn!oU$0<~K$1JXw)>6yjF7_2-A3*=ThE5jG>^&f156(^Yc<
z^RPlFA+?+Lc2VE%MQN`WSN6hwyHCzB>4xyWH+h=KVTqTb6*^daOx7?GGO=P%xtmMf
z<3VD_m$2mpKiH4@7NnyrsW>w$t;8$2R7FMUx=w*Com+F&f*8#T7$81RE>z}y_E!V{
zsY~ZF!myIt!0}8Ki1}6sC`|v6K%dx3%Z5mf0kq$HwcYf_g~^{VBCa`H%%e_fzuZfy
zee^{o5tqFs$XpbXf8F@n4zwm79+ePKWv42CY{y5wXAYWFtlh3|{Jr3|z^g!&J*P#e
z!@98Bgq=MvD`hHJ6*3Fn(ycTybVu|otv@0QPgB&X1!)xCF5n#P;#+pn=1FQBMX6{I
zbrM<CbptH|9g#tNWnxCpa`}PABFAyOYr&*<yYl?lH`RG}j^5j}Z3>=jhW=rBCkMGZ
zIdb%^6>0<sf08bF$sVIZ@fghYc?@bN@a8sFnW3eFVc+TymQ}tA8l0S^TmU46FMJ@i
z2>_l##J<k;I;F)Wr^j1f_G_7CKGU|I!C@Z>Pe87SePD!MaG!X>Ywby@2I|z+<Q^*o
z=ogi&Sdl*3*ZNV}DP3(<CsVs~zbJR5MWvF@>k{$FF-Un_%RKnJPaUt&@>OIgre5i<
z!8M}0j)ht_zhyKv{`ips!ZZPE+}{`P_-wC!=Esi512ducBNw}ll8OOz5zSK(w%Wjz
zpJcETB#+wIpa<AZEx~4Dz6k7HJPAYkwaKXtx;Q~j%cVQsk4a3uKrr$S{fa<Cdg$cQ
zKZH+nmgLP?teme^sBq=Bp!Ym*`<%PSnl7>4?YV{;k}4xQS%@Qo!R$G9YXiN}Thz2x
zT^mb3S@XP(%>5^a!cA5Jo)6i-WzB7)EgksLzMRGw)R9J<2oEUBS$Q?|AjE2f=B$bx
zy-vm0?Q%gcNjf4SPgE?8V@fNBGB4ff->@A*rT(T+<o^BVk$Urw2g+YFhEAG1b+zQf
z;Jk;6c~)er)qS`f_PTvPhaCr%d-?t2HQB~!_kv4Wdvdm&a9cw-f||$~J1vnFb~PQo
z3>`!kUswj(Z|{FNYJGNcq?;JNS2i9U?V9MUbyLE)=>hh6{M)byQaA1Astwsdyr9#w
z9)J###GQY_2}&9?I<EeC?WtxCjF`WT=lhs~1!w06mVw|I+jn`tT?}R>)lk%Gfo6}<
z=`0eXJf+5g&=$6GL~sPo;H4k*1$ib;1p_fp7>8?EJw5$fJ@b(aF|^e#yzV`pAtLFr
zv2f%kQdnPZ@$3jlNM*qq5c~YtJ#Yf~8bHf*&3EtcG+s3PtZL^X-F2)6U1+cf1(SP>
za(N;@g~(<kXTQ^iMtjcJMHzLDDb|6+r(3qm=;t&rE2jLqCnqecKE>?%CBNGFK%N-i
zVWHtkI4lx2Q-8EBZ|J_p=3g8-O)FnY%dt@uTtj$5;6rtl2_n2yI)heTXgz3m*rn^@
z?H|(kF8Ea>?vG@~dWj#qv1}+Tde2F{Mw*W5uo~?9@=G90(a=N|bl9-e1=6c0WvgrK
z;KlR;p3>B$mNazJ*FO2TN?yU<Au2aJy#cvM1;Tlu?AAwPgTKNSg@CjcegQXc_om8n
za;C13U@q|7$`7g62Y6aD+pBoE+pv5+Ugei9Ev(K^h88X@*i~Uyf=a=5k(EN{w-vS>
zpt5zVHY}*(3G5@j;+4p;L8qwfzM3Nx`z<Cv;P2~tri5iw_bV0q?M4|JCkvG@z1~Tm
z(c{-q;~~B+Zm3pdV>JdV3wG<%M84`CpTrZvtOF2t)Sjzy!3^@hICK{iowyX`bGm4t
zO0Q!gDbh6GHtFB`J%GVeq$&15UBrP<e>6%={<===>{6Ex;r1-m?Z5vq;d`9n#P2$#
z7L`=D;Z%>Iu2%om^O-AL!Cc^>xlV}SqO4LSDcS8qoahT6VFZlf0|0m8Y6^(ECO*G9
zXKClGeq&B@wRlE7ma5y?Vqy1odLtO@Xu_Tts0L(a!{^k0RFg|0whi&5AXqM3y6B57
z-PEQM39A*x@LP<6+2-I~lcjRgm9H*KJf}e!%}2^4d~)ILDK(*qTlUj`D~$z0^MM^%
z&3!FpB~1EN<*3s&0vE*Tc8?GgA*&A31~Sj!{tn7I`nfQsUtQ_A#HatX<s(3Nb)3O$
zp_Z|G{wA$)hVB++pNJV38P5=;oLI$LR2<k=j8O*B!?jUh%i)gzqrO)Gdk%#7JLxI`
z5dZ**L}lMu!k{RsE{4Cco8qM3o~RGXUupwlq&TS(*DwbFS@wX3X8@ptNX<qS;}rn_
zGMTRwOe1qTySRm}P)J#W`$0QkMs1r3oJ^mw+msbGZBM1a@<^sZsCWR7GhwK_spE09
z1`o*gg<SR2drBxG3<`fG?#L-(z&G`*Bu+g5MBBj(0PvXq)plgD%pN=2Jh~i_r()E?
z<7)6Z0syIs=ty&;s6N~`Pt4lb(Bo1nZP(15|K&TB{c<_D*;Rqiy?tDj0W*0TLs1YI
z!en4ISZ!c6={_dO6!h}QZU$UO$k)X76dQ`ie1b~I4Roq{GTg~BPF%$Pc1e-EJv`-)
zrUpqqbtN(fBKC9yG+f$fdbLf@NM9FWK%*j2JtG6BsqCq^kkmJi`T9JKoE_jk0lfY?
zN!nx+OeP0%DGz4w#0a6K#E_7xBCKM$MCI*%A(fI&B(A8j^ZQkfxJ-YTA&rK9Tzowg
z0n)(tA<|@yKE;9wR5ng4<rAd>SNm<fk>!dwEidSLt{aEFr}`FlAR1p(I*$o45akx-
zsa7uCYOZ}lf!TdIV56<H%QK8v1Y!qNlm03G^=WA2RMq*CVV6{T1n4qVrpx0>MUHWa
z?f%!i!1woqZ;vJDs4A4`<;y;H^c_E{g#!v%jF0_YLfB*k8A$Bo1g>H*zKcwfp_G@-
zfBwD(42K_hFSoauOm>JNvxAwcJ}QT+#xl5{bUA7Wy*1gC*d`Z#H`U#LUIJnTK&p#$
z>2w(#*M<o;nxd>jta0<Mm)0!Rv|uSfxxMl_QSv<z9TmLIzLeADLv!(C&e*&|sfX)n
z^@2pijgBHtHIt4VA2FN_!ZDD=G&YSmAfMDN%&tDM&0!(WN$gr)*T`O!%bO7OIN^UL
zG_sGSermIglwT#eBHH9>N6!5@bfzW#U<cp|Yp<US2>Wj8BnC8RX(y6Y(XA%y)RyCq
z;R+fs6%r)ifuq;}F<Z)Yv~}BiZTIDPcNgt>Bx_pJ#<>5^ahs@=c-D}m-#v-u>IYzR
z3?MR|;XqcWUl?ni@<w?|?+cb9KfNUk3-XHHg2(Pum%lD1MercJbLyh9wfdk|9m(sS
z#GBu(Aw&2BplF)_Ko?>SERu%z!QPwZqHov8YdAL7R}*sIifvq%;q(=cCIIL)<3uD(
z0M&Ykx>6gbK3~8HJ^*MU5&*!b0d`EGD02D9%?`^g7Ij^07wj~f35Mef^rKt5M9hy+
zbMjLC8-(#n19vp`ric0y-OY4$Qy(p1?mqhB_55Rb9CA~W&vJ<@2y6_u=BF!>cN~L<
zaJ3_V?BsCaw}EW;LEA9T73kE+Y2fj3WLxBf*N0vJa2j4h<0}w%slm4`Y_F0??rj70
z53`*dWP=(6ZokfTuSO%<!;{mMWRefX6vL)l29@Mnp=cdzQmIL^ltEbqYd0v4fRaf-
zW02dMrijI@kkR=p7sAJi$_=c!$_QX+yQ&m@%zY9IZ8yhxi9S(=(z4kygfp7^NX#n6
zO^LLz=kqYkqazzD0sO)`S#lEg_2A8}1L@&yC=(Td<7trl^A<{7K~J08cQ>05(D&2>
z;0-swRL2vZWU1_2cy#gY^B|&%$RXK%gax4Yx|*HgMtl)xZ-Q!X*h7jpnQ4^a+i~W8
zoTEsMsPdr*i~>Xd7W5sTk=f!+p^3rQ1FtZfMC%bEfO?(N+@a8<$^wjyabzV&=*Cdq
z1_|1G#`i)`KwV;&clgw!;lQNA9jIunGpy7;3J3P1c<rFxR6bgwV#5W8;hzGl<urlf
z4eB59zO1%1@8gzm9fr1Beifu!*xnSKnx>be%xs0|NUqnOj!Ifv01&TM=3^WJ%3w`#
zdcHURaAOK)YNe1?BDq06J5`<QI0ymc^hy`t$-=qy<R_h<QefmD7A4-`&;AtL5Wh>j
z@@@_pu_Y!>tt&qpJqYw8de_*b1Aa@?iw(%faz7>n#C7`u@E5EjvOFHVAD;JdJ^X=p
z=ZxBsp-2B5Lu~h#VjQmAHD)rg5Yq^CES_4hc3Ojff-UTzs(B{K{gRpQ<2Ju`ILt`s
z*4Eo8a!HH43!cw!UXi2I9-`|=7pqz@7+%(}MLk5<T>6nJm<&JcOf@znKO|2|*u|_T
z?N&Oxtme5+sfH4oBc@(hkR+qDoiFx&$`5>-jfRED!?0jdUW%GL|FKUnkg(s3XNn6W
z&0`B76J@$sJNk2sD{_ka?wsx8sX4N6Y+-l$VMypo2w3+P1pqu014u|k&|twlwj!Ay
zC0EKqw+`!Y7I^`H#^;4(L5~hY*bp*!F0y@aKj}*)0+4lf?F!s4i0>z(V;F!-GQ}2#
z$sf9x#dzlF5&c|K?sV>ovZf%Q0D`NsXByTZ4+p~IUoJ3GgSMkuHc~xqbwPLiTa4@;
z_zoT*%CzX`pPSCDoN8<_&1F7X2R`-T%t;nleSI7KGSu_mq5#MBZE;!F=V>j`({~7}
z7dui!9KJ~dYNyl_c!Etv9}f{zOgTH|ap}(PJTf)mFXMrqwTD$8Ly@0x4e~n}sH%4d
zdIG@?BjOE#IE4cyiV__<m7|>B%(=szu{AT}iwh3!9EwoXHobm@izv;~E!&Ynho&*S
zX<Y!~R3>{hW7lUtJ|bOip=P0P>TKsXUwsv(&C9yWsf9>>syhIQIqr_7PMJ;(=&Tze
zQA-{HYxb->!a-QpK2X_vvWa|RxWnqlYdt)GGNq9XP+OxN^!H&ZDBP=3<ftgTj5Tr6
zlOX^A-#vB!`1F%ixJBt64Sc^;!h?;e>zQ~$H-(2I7;vlrw4kXBp}RR#@m#oX8;FG~
zdZf6I8JQZ5urBkH3i<@-i7cHF&(acf&<79kpv92m)@l#BzbP}Pg*dfBhZC$^?}|SS
zOU%t+56=$y0u%E%O@StC6o@-^#7Lyp`f+>}_i(Ug9_;tL3CZ{T3P3+b=tu3J9$2hs
z(aOy3&E(0B(0>)V)MUJYv4qil_l{4?HlSKXx_Pt=Ra@9as!pB~;0eR2-APy(e+>V+
z{vn@iE)|CIs_gQ0&>bkS1eNzR110vZBaUC%2K~l!rW0$W{V?nk0YOP&WQStztM;L9
z{iut~bj4~kUg#t3q8=dYzZQt32OKH40}El!bW_1}uX-nyAgDX)S2<8u8vC11Nr}}^
z`y;MP@&5pMK!(3=;$M_ycs}(@*v!09fgSVUQ_hYKPpHjRynG2IQD%HY55&nkQw9SY
z?C<=E)h<5nP&RX;1@^Fxl7yFAF0y{#lK4oQ?g&VE(&sPDK0Kp9hYX8-un;1N_#<pV
zYL`yUYb0(3_#sJF0@&NTeXWzvo}LOB6ouvDASi-SQ?AkAmcw7z01_ae00YRUx+gF_
zbBMzh8$9ma*56xaLB()S{8KxDzyK|7sY0rObZPwezIop5pjllWN1$BCg0WpZ>~RZC
z%-r!z6LD_+bkmkcw&(_GNk=$PlzdJ~to6&be3tHP+3rIS@SJM=!+lyJrVLc%I8ifb
z0>FqjXqskp7YyWZy2?O`LdsE`N3{9x^cSL5MB_(h9&@dse5xkB7dW`Mn)FKSX=}?e
zj+N_Sks0rg3zccD10bym++h|Eu6HB5<Xi#5S;1{a9=q;yw6J7mF>!xXC6!;i6C3CY
zgzVPK4*h7Io$BjH;3?g{-6nV9+l%a%pZ)_w<@w&?7IR+T_x6-yP9c_O@An}3%HDNh
z<2iD<H;rwjS%7WcD}FNWkh9L>bNtHx!&&Y-Y3}Gss>j|KE*&1_TC38^z!g1&1-G+g
z+*w}DVx)5hQ!oS{2K>BjOZgC3>^Rf3B%#<+;_wU{1o75=AA76dEbEWAB=Jj6T%M&T
zRo&{4Gk6(znxTafReLFtpjUxkSErbGk!>c~&X4#*p=jbBtc3g$1SOCTwm0b`Q_bqd
zOnFV}IQu^tU?-@yvzW^nrg`5OMPIfXkBYHhd1VJtWd+0DfT8`f7j`FzSKu+}-l6-2
zC((Gkso}z|FRcHZ*vLi!H^t>0ANRN?J=?*Mu>@cM5ni;Q01ZXC-aBgHo3>g3eaR$R
zi~s;yzRL8mNAN@+@gN1<U}Zsh=BQ{Dq>cP24xrFwJY*-gAygXzKq+tuE#1w!9jer}
zlUz<C(~t%x$bbL=FL{O?>cJSWbmxSaaQ$>oPc^}tls_{2v?>8wb&w?*T~R;)W_#cO
z1fG#JSwrn|yB*9{XA4ln-zvp&&;SD0EgrgC&C>Q;<WL-ACGBp6Brkk?HVfI(O!e!f
zCFSvlH4-o+HDYtl`n=N+HvyqfEsmxzc)Tc}OMq(uSMAXwq3#XS&{y|(7eMh*y#jo)
zk~>t5bNc821eN>%04$1>PbxxiZy8ZXS2`pB1+cABd1LogN-p$NZHB4zz0`vC(~_*t
zx<~kCyQd_@H|+!eRfjW`L?;-a<HoCoj(9K+i-k*LfpbLw8Scrn4!a@<2KLJ&)l&Gx
zlk5on;5?u$)W?**IGMZWkSw=tTX3W2@$!xnAFQZ2Dam}>R1M72`P<gryP!XU+5jl-
z73=QY+p@_ex3}hoxTiXv_kSpfH3rWPa#)sPm(_X<nTjeYi?>C`qm_iAt@?{@q4IA^
z!D)K^RdsT*pU>*NGm+I6o7L)zKJgVcK#M8bhKb_@&Ouj#tUb$`>n90?lfY?sf$1{=
zhvYu{uZT3)lR#U9r?$j>lci0yUq3<VmTm#-Kma!1kpKV^S8CmF|1wUEd82<)GXMYu
z%=ri*k<-)iuTT#*=x#s%jJiyg>~fxZOgXkQ*HuwNe#MHkcJ0gk<3GYO&<05O1Mqdp
zw)wn1R&}V3l6p$Y_`6x{GHnGRx*sMQ%MPXNJ;P#IJ>0L=j#gyUq#k{_%m8_}$3BOs
z#FvXYnAd&Z!dz?R718g*6lY>AfdwQY*SZjjdni`812!xYQVgnI;VZhT6oy@p>U1rl
zb7Z|3Sh}DoZ~CIc8#%EL0t&3xC<KIz2!5N%el?+d$@VA!49|Q30B|QZaN&^hwXlV^
z-~cUx@Xyvc7x;d)7Rn`WrkUT=HWzITkd*Ktm>4mb^0WFSut75`i<m~Z0s_tS#F|J{
zVM;#yBBp@Wht0lv=hgcXAaos>?$tNve8<`FS%)vf4`Aahw-L^T;>y`;sRz-KD}lyn
z>O(uvbzG<`Md$S+#xu=O_KZdmXl=doh$KHLK0wbHu&&Fe2O_fC`(}0jiC&5%3FJ2C
zejX8>U}ekCeruu83AdBbnn_rF_uDsbxsH&o_ZH{0o;fk0SU!XOBY{lm4OJ8I4dJ9<
zWls8^r|q&qaqz#C$wcmcH`-8mkkw7kZ#Zm7>O9$;Ct-h}NEpI`=cPs<Y&~$USiQoT
zEwN5t&ZC`PFtazS7wZ!MEIuYogL2Y7Ut?W-gV2yw$HfEmo0Yf=bmCmO&44o&4(WUa
zRcVo7+fsefC6*i4O(2oUU%?bHXt#RW`$Cx6!laLmimcxccxsZ4$qtI4Z-cE-aX^3o
zu&Y_1aL0dxiJ4O)eS0>ePe@DjaOwZRS!81yEkM)w00ANj002srJ@&a;kwg0w?D#8?
z01I9z>NdP|-wzc)4fU|?0K4Ow?5xxL&&3>3$gxg2e%<ucg^W*yVyTg^WO_k^Hmfr{
zdF^;iP+UXNuv_*4jler^jdqK=QwoV;{v8)1Dv3(#mLzYSN^_z3Bb|u5#`XtBQemq&
zZtm0U@2`>CyYrta9y_QW1)w13OPSpo$8#XDgO~c!=9AGalC&81?ag$4vMz#O%;f6?
z-Tl)kmMe$>!eE>Z0eXut+XKlfCJaPrav>_U4Q@Tre$m7@A4_U!U><JZOhAC8-_T7q
ztx!S;rKhHR1IP4x7HU18z#FIaJ*1sxj;jS;IC2ykM4G=P?><DokPP3sZmV{*`N#ct
z?$z?M|Fl)|_+_5edcJM){=fhty=g!I6Nw!1sybNgEB62Zwc}RkPnX|WFoQiw4bJ`-
zjng~dWwvkvoN{g;Xz)S{EcOIzY@g;sm>#ZuZN3n$TUcQRKUWRH%tol@0rSNBQD}_y
zuBC3ODCm#w;T+Naluf^NkfpYwdR~eY3v(EvHZXPRU}-hvHHu}&ZA^q^U3?W%^2@)^
zekIKl_cyg#S%upk%r#TTnr5djPNDMj%@<lTFtSW_m=PNE(Sihk@=eyvnnae?{xmY<
zCHfj?*p|v_AT``(GR0#Vs)LR+pU{lkOw34QG-uP(7xDd79Ds2fe8|av(+LSYF%0kI
zCx0qra+X^!R0)suC{8dKc3H&AgH6MjbFwp`Bv6^)5JSBXsfH=ib`{1k7j^CbR~d3^
z8VNYE{%NIDdla8@g$rWf#WF~_9iH}_ThPC8{l$E!O*H8pI`{6jy2W%*9CkhMF@j+z
zIuhIy=#Q%;7bOIA!mei5H$Ql)7eXD*Pk}JVSO~Tx9eVi}abi{CtgY)IZpn~h21T_i
z@_7f5F<Z@Fzl2B1twvzg$<oobdhGakjKMz}4huxrYWEq^@+}{d8~d63Hn0KvKR~^D
zt8JlHbwt|ec>5Gx8Twp8H25DI000@D_y7lyPj?)9B3x&_cv?vbw{fWJJOB%z;zB5%
zvtl6t<OgQOx;cpl{2m$RY)Odw^>`7V?c(d_WB=pq@KVYldpJ=JBr_Ce4kJUiS94wm
zTq3Z%2Vn*_7|4;Wu|}J}La(LsUm|Xmk*rm!mbeJH5x|&@dG^FD8;}HC-_%)+k>rq`
z70`=Tb_lrN4ZOG%9757KA0P#k6_g@Eu?5hvS`Xfj->4Z5T7+F&QLT4%`(4e9_1Pp7
zd9<0k-b`&D=NdX**!ewcT3QoCqKHknS4!6US<RnG>d7n)6QZJeE$4uQ12^>j5OO!{
zN_PMU@BE0NJGX$(S9p~hD$WdGHjfL2m)Ld^xiVIQy5J(NZz}7X2Jo2XyYU5F16vN2
z!i~G6fl--2GcSh8g%`!uhbp~qFUNxskix?_*lA_!l5<&!)&d-c-|CZ9i&Hub2Xaz5
z%tO};vZ#b(536wj&VtY5)i#q)t6S)G2a;C@vd?T_Ny$x}kb;G%!jT>!`gBn~M$2I*
zId<6_FPr&}Q*;5C*eL%+)9VT)RZ$SzmnvQDOcB_@GSZ~;0;M@9TAD*egYa0${kL-J
zG<k7D@3$ZBe5l1K1VN#fG<}ele>P;ojTH@i<z=ct2E3PW0sLouRv14mF=sAWrb~s1
z$~ig%hyM@Vb6LlyQ6dPH_!fa5n$!OSJEPkblL6Sx55W~@TL)t5W$Sm~G>f-_!M9XE
zUuZGZN$-@?mioi70|r%5w^c!kgkUBwYT`N*64W4(drKUGRpPFULitAgOtgrM{}U9#
z-GyJ{Ii6FCcALln1i!EV1=1t{0pf+9Q?!iFViPh+!xq2*wYs5{*ql&eH<QyQOh?4|
zLgA^pS=o(;zalYGDn!p?W(xqhRNB~8c=@NU(*Z1FaO=MN3cwX(m&{enI~sB=j>b!Z
z;kGyo!hKseoJjX1gMAvE7m!os8rQHGWZ@_<B`ZK;5H#l#q}ks83OIkws8x*F55;e}
z6nKRjKVZ`3=9KiwkK)V~W*2GNEKjB~$Kw7yexrEXH$D!u={KIKprnX2#}UO+@dmyH
zy$8+A&DpI)#zSdr#kuDB`b9{XI%EA>Epua!D}*)Tgt#>*@A*?vbg@SEAhiNwf>k&S
zdZl+u5A3?(gY!gj6R!VTD5J8ARX!<JZ3DM1s=;6(g}&$?Ig!o(roIkTDctsUWGu@+
z5$#tQ2%+xfbi!IRw(1RDl%rh(WJb}o-5?xAYthtMb%rDV0iea|Lo(Rm$XYYwTv^ea
z@>u!UkbMLPW$-Nd62$QvhtSjN6<JcOr`t%ELEHkv{xRqtYAm!|kbqxgAoRVZiA7Il
z&Bi$r-F1xi19vG-3O=sdxFEBXte-8`+w7(*GM0JpYNNJ|Gz_mX?P3B9;I=ZM7{1v&
zAVPlt05$iK000g*AXBA%w(KG#GtN>@fCa0JAtu-^HGlvB000(J-~bt(_y7qZ1h0l%
zJ6Fx5J3s>FeP(%^8<EZ6+VGll@pTXH#`=ErW$s7p4<+$%T{Pm#9X5pQD<46k{o=?B
zw8vL>o+5U$vIh8uoQ{5P_Lyt>UY{P(j`*?D#UR=)yOHGkt&fS@vO)Gv7uZ^iOKq?W
z_l@Esg^)#6q=>ezWyh@RP}3$2w_AwQTG$8agy*C?dL6AKM%zUxkGN19Wut}vU!N#j
z>V2I*NzO(|bPNa}-~eMPQnzY6fD`SQWga_=ubh1MN+-?3-hZIPo&njR+kF0&=vzkF
zH4$RqV^W_6ajvic7O&E=zokYUH8{npZeT~c9kz+tHC*UqVjLjYc{Oo?mGiqBOAZqa
z->ld6+wL;)2euYM{r~$<Y0!#@!%#8gT)K*us2-w$gf^bMq;tkj3qx`hPPvKLP*0EC
z>k|i0b)9laE6X|DC=HC+K%ICrTG;&gX#$$uEu*v{kj!tvc@2dyeQ2!pShMFwrP{?w
z;La`+e$o={yehsh8a>u)51BK0jFpU@6d3w^z}EAp4i_8oH=BbmBlX;Fk3r9B&iM1v
z0>Zw)GT`-VGfW*S0^^^EeRF5|kM(J83IjL5g%xB&z!9f3UuW2Tk(*gbqQo2gZY&T}
z=^07;_GtR_6K<O_ID*h!^j%zniC*{NKxDdtZqUY@);$QQY>6Fyy_fT84)cV=g-|NJ
zX>*TW1VKO(9hjw6@N+K#m<seUtLGn?&2Mtp_N$&qIt4-1a@G`xZhr1h03No$&SR;A
z+lN{-X5m3mP8Vy7mXMknBRpww)XMQHt17PLznf<JV;cnmas0bCO&9<5CU<^I+A)8X
zL2MW1?$%krovlw(hY;i*(XKE60L2)%t}1H8h!r%oq@g=1i}MMqd|QE)$V79Edm~{|
zs&zL|_g_zf$J>Xg3K;}enXza0(8l+M$Jt$SzK3zh$Y2L?XG2LRT>KKbd|CVKsIM;?
znWjBx96mpAF=wh}!j8c&j3~a#)HTLCrJQS?nPczm&k1;yU0@Zt;pqW%>Xsojz&OJV
zJ7kn&%Zuu#^YB&?x|*=8R~Mr9ODhf!;40NXNXUQthj<SMz_UMCFzHzk!&_O?qmg_@
ztwvy-WVEy|L?(!n<7i%pO%W$BuR$o@WCUqmN0|T`&_DpSpOK*78l^EL9DKpU5tO7v
zw9&8+?Y$CbCckiNe0#Bxf{LRIAXayS{{!x`m;%p2;S9OjQ}v%1r)DMP@xB~o++Yb6
zVJNNvZ=TgKh|gbY07I{Hv%2O%xJdm^=`I1`^3b*@=!(?s6PLxtn*|c8aTq3HRc%2F
zv6wv@ev2m%wcCzkxT&b%t&4Q0hvNae00Mf@pw+@RPh5gj0K2&eO7sGggdJ4(9p}Y@
z?e*}3Z0h~k)w^Opsycb1jK4kyFQLOvL`F2OqyV+^bF?WwSl8BLQkZtZh#%|w@1TiH
z8^Ug`N$0*Qw%a0rvT?b2bM1>)UJ@E_b;*;lrv8-cjsW=(KDD@hXZf#U8YecRpl8V0
z0H^e8&}UkpM9`y1g<kT<D0duBHkO~N7h|whVbb58Gbf(*EtAOGoW}x1=$Jk`eQ8-T
zd-%9VQ_!3Zk?)1_8Ts*PNd8uHEhQvI!)iafTw*IUmY{6~*jOXUm{m?fL1@I#X4`lp
zT#TNVq=BiXn%{GzF19lgyDwto-tv%wOU20(0*VSKgv7*9aqO3||9Q*^P%f*)^mAF#
z`=9;WK#h}8Ty>?n);Ot7sgfh<>n61_iU!uVnCLOxbF?%qW^WX@isQkSULy7pcj4!y
zXWa=0n_PjSz1Cu-C3>?ZX&r4*<&B&rgD^n*c;Jiri^~5Kj$Vot_OSMaQABQ$YX>6d
zkOR4_6T2ltH{}yNFFvDF3KpESQAn@E%=cR7yq0jXYzlP?(F9TNwTWhuz{$w9D@}H9
z3{%iTA+|JXCyp-H;Al-Z+}!{!(o<2uU-w~<46f7E5W(7++5z=E9{-Am;FJ;D7ODw~
zlf(a`lXS2kKTl7e)3jhseY4ah3!Dg+TRfrzMBZP`+b^V1QiNisAq$C2h<Jxv5z*3C
zym!_7#u&-x`(8L+!WhnYnp((Z3HUqTx(U0*yAhpfiwT<Q6K3awt_8!ui`?!|0@sA<
z2;l!cBZG|Ksn%#Vv#=~BGvruQ%-PixAy$@_02ifik#d}3T!o4O(%cdOKgu?)Nd#8u
zxLm)?#YKWc+aEmWSZ0lW0`VxFFC4#Sqg2a{n(hyI3mnkc*-etmA&<1h@B?Yk`cZH+
zVrz;Lz9@J|9<=M2Qz5JZpYRC0GaNMv#aW$LaJzBXG3@r=T@Z#{rvRTI^+J)Z<7Pzo
zkH&2l?K8#j6PzgcFchP8XwImWY#pa~NFtDRd$}Fpw8qxKaD~5wi7;7&8etbU)hI5j
zo_^zQNi!|CwGnxOtis@>!q)(}iULPG<6FKI&`0VONc!^}2>e`LX25<3cJWAbQQ1aZ
zksE+IE>1h;*F$CQmYtK89k%XMDz0T@$g{K6fl_T9U%J#Quk3I6*VPKGU;UA0RKug@
z`TG^qIM~u;THqZ3ak?<|Pi&I_;ZM>KjqorsiDnzKd1q1M!La8psy!Vy7BdixI2tJp
z7ZdCMMhML~_~0Bq^|{e;P3{#B(Prf3H}d@G&pbORAsi8@|J%S~z(6^u7u3=wtlP3p
zr9rc~jtS9P66r2`w!<>$1J0^OYD98)mA3CJp8xv2j;?P`v3m3xnDxZlb>VxW+iQ0E
zMo1Ud#|NTD@B5($1ipe%%L64*>$@ftH`r%B_L=>7-1Kp&!o~fZ0tV?F0E!G7YVirC
zq4mXvFb;LMUQ`rz!0r`n@NH(moM9$EbtCOb*_!ks{ph3&WT{y|_v5?;9v6vt&5=|_
z8NsO)jNA{}YWUJnESyVN6#pt9;V`9@3Q6}a!vpO@@!5kGfx=2fBA^Txz<q?Mln;*9
zA!mSqN3qKe_!lxfvQePE-Bu;tcD54>+!t5eH3(?F>c#P0DR+d&CE<*!Fs>T_0J(mZ
zjr}Soryev6k$hIJ7GO?c{ZG_8=)_XU5=);+k`0~@wCsv?`!gV4bS6OLjfwl~?Rqy=
zt~l-@3sVPbb}6|Exc@A$YA<q2nxGD^(tW9r>O#_{nxq}3b6-w$x-T~QiW#U_fhe@I
zaKswfyE0)*@Y?+%I=^RcZLKH)5}UI<-%}2G4zJi5BN02e;ax+wB1uo&!cCuNpfM)~
zN^$zNV5LJA`8&vRsfwX_-dnmVqn*1epJyP05Q_r-v&8L2HN<ea*QMK_PRDV!cmA6G
zODKVwgU1WcxKdg?YZD*!iLgtx@~kwOAL<duxfV1PN?y|V=-P;<z!YzY{$<2v#V#Qu
z02)Bj^!Mc59VncN!D+iouR&q_ZeTpSwY?ZLMUpHKRVi;-ZlP)e9?%QC(N)gIlqOvx
zaVFQ^DEvIV6YOz7v=xOUV``A0v+S`DGLx32^UHlPD%K>k{SOHp_m}_+tP|?3dZbAO
zmirpvMQB?o0wbzTA0O8=FKw^=Ow4&SFnNic1|gR;-!OY)4+0irI$QF4lckEja&2JT
zYmdVu2UUaHat#WCQo>pr0nQ{KtMJ)Fg&u&DRboDjJZ%U6;r-x*MQRN(xkLYh*x37!
z000001(le)6m0iQt(&tH!WZ+C;<P~$apx|U)e&X->t^->=_cUH9CT`_e6He&L*_pr
zO@Y)DZXndrv*N$6$QDn+1_Ozk{@SsuhY}6AQFIu$J04%cZ-~ZFOCvPg1Fij<4|9sB
z1H7)nL63-5lVy7##d8Ao@YSI(=58jy1fA_gG+DEPKbj~<{HtuHlmM37e`A`kkam1n
z#0OLcX&)!OTaxt~zs1x^WP&4w%(6=)TMGw$IcdqiO6>~w!<$NP;34sx3`NbM=5iON
zL~KB#sMQ8P`S3qx=4(rXr=8D=Q+5Z<%)^PP<d1?NgVA{+EV*8bybwRM_etT?RQb!E
z)x>gJF!>ouytTJqm=0-X``VW3<;1Rha>ipG6C&xtLlrXk2-RtG7;xrk=rxbTzwAgj
z#~ihP)Mab~l*a|$&KJ06Eh=mGRcA<G(k!(rgmQgi4Xj!ihN2+RpPZU;v@ZM68C=5h
z(wvNY^etIJjHu}7EUb&Q0siNTXaE6gKCwP0P*#Cg0j!la&}Avfa-s+P;23RUY^tOc
z>RY7I6<Z{M1|L=_urWxyQ3iMVB`UY6!;fWyJ23$$c~DjpKmtj-Un5>lRnc&JwTIp@
zV|taDtV_+d9Hnk%-KR?l=j&7M2HTQbKnsA+GPQa7E$(zyi|xn$vwT4>l6G*)p(AZC
zr2VL6OY%T@i`()A5S^p?#<M%p2xE?22#NCE(BAkqHY>oEXpa8R1~OQiV5TE25<mBY
z*B33Jawf6VjBwrRIz?uyYiO)RJPVtyE9g6#rbflW1PFh8eqv^Xr_l>Ve7wEcu0JaA
z5Pl3+zrX?Vvkf9)W6aEq7f|@hoMo`8ysEb##;WsW-gOkvgi>m2LsR>3Rq{om90M7h
zUl`(5tq3$*Sbfp9Ymh;FHr6MeGgr>`am6wK0_-AmT7Uv+hjwOp3P9!>$?zE<j6*%^
zOtHKdT9}3xe<FqLO8Liz{YyH{v}@4pA&i!RuW{N5Izyz0py4WdFUiTw00T7_m)SB^
z>7F##G)G7v0V|4?|IM^IYEZI}W)1MN?H&%|J{tT?;iZk7X4qp#?fpK1katwKw)iA!
z_oskF3_r;`cJSOYs19TfH7YNHme9;85J}^)>2`A)saVS<g)e0<j`{1jLqXMUFf@IR
z1%ntVIV%w(ilTr8fO+60U*0DO010I<t}CALE%XKNkk0C0*WIx6%q+K}X3qF2VI?@H
znB~l4WFbmNLd{hfCK14DS2AoxHN&DTAsj)vqmk+@C8W!c-YiS)DQti<i#q~AS5!kO
z1xPuvR^1HQBfLEe-*v8+Oe1nzwOw|_B}<S19ZHC*M-ZR@HMNA$0D|p~BDyWerrt*0
zFuz5Kp_|Mb#BWZIu_fkFC_*+$Tyz+8^5?<W^^iMjvapX2S!U;UwCbvYujh2zgNw}%
zui*H=CH;y~v?h8BO<iKuWbe74Oaxd*#{zA4t<*uarfqEUIOtp;*JHT|(gWe1H?#4W
zCQjk>ew)18L!LP}-?kjDhdAgqZ#B_nzTIEjY-kU@*EIZn^{I|ekLjEYuyt@g1QTBd
za;E9rInbf1d2u=OXR~QdwD8u`pL)d!3;%r(0YjQ5e|Ab|5eCBHz?iz=g5~&|o5RS3
ze)FZf>P!;J?l3tEcjC||ghabGHDsjcxk1z3*?nDHuntARI6}ne6krJOH@D{%^=6{$
z|E}{WbV3Rs3_7@%H86!2MMY>Yd?L151Cj;;)Dio_?P}V8R=btjwqkTY=`|<nFdWMc
zc}IxIF368>87wus?Cf=YVLSt0+;wX3!aO7BAIVenN91NQK}xAzB+2T#j^^h3%Z8Sa
zRiO+~ZvN6Ge{yCd;`ep2TP#df5US`L9`b%4h~!&%VPrK3SZiqxKxsBYgOFAcOP%M_
z($hoW(@H-U7;+vz=a7I={9_H}>hDra*gRs^*4##LD+K)2&iRYkR@S(E93WzaYQA+!
zQ?Fb=aJi)fJTa1a>;Mq=cjbQz6fVgc|2JHgjN@3J7daTP#MQS>TJa#ivp3}$jR!`(
zxL`|E<cj8nxeJI6TEQo+tB{a|X&>woE4}}1bffM`kzkn3E&RShCf3yWXrON;>i<Gi
zk89-RJ(d150ksb-JvfpX(kbbJG2uTQ)$IYuA`sb~25REi=i^~COauaYobm<(hxVVf
z>?+S{&X$tuhoxx1FUB+7f6JxT#yg0Y_qYNc2cYF|{1e&N4(+hW&DvCOH4vOTMZ|0K
z_;}~E%Px*X>N?l6%;wJR>k9A#@#7+ALCqHA;DHHFSjLz=Y5s}UjvGmz-B}xzB}%Pp
z?6Y4fxArJU>@@KH_MEf3ibn4C^>9Vg)Q@#A@r+!ZvH&L~WqM3AkUlTnqp69o0yDt5
zkyXC%Ictv1T@8_7%mWsRJovxHtr5C2(~p+~9@V?0V;t1}eIvpe8TeXBoMwBUFDxg*
z6u0XPALR;naItE_oQ#qc9^lx<`dxUXMcR&t!iMo@@~$rAvnR3GEle@`ujCztIkoGd
z%zKMhMg2xQaiRDQf=+5Nq@g$cgVv7GUXI(vOqkCY8`46d;~)KB_d|LTcT|3srx|)s
z7U}pb4lr6W16vG$*_iO>)&gwRG@4Dr?Fi3{BUuZQg#Zw|q5f~O$V2;518kx&iaK79
zigEvtMtzguDB^pergtlNR?is+Ms_dNayA})4l=nVG|-GO+No&R!|+@MBd+*})_~E)
zi2HV`@6mjxu7JCIDZ@Pp>U8YhZ3*~{x1;Kn6hQbhyUfLVBzd??(z<REV74O>sEG72
zaro?a8u*)blXmYDfxG}JsT7=$PTYaa@`OJt86Lpi$9H(I0^Fe~kXQ`;5tP0|T^7NN
zFMavU7rmz*<YBjpu>Q|Y(f%0)-F<Y(u)7UM@<kB`_H`Z5UVIh*99O>8UX+PUs7Sjg
zWIJ%(R>QqVJ?vhevW$m}OF(|3nizmLqS;;6=1L4U5@jdV>ld{24SDSf9JwaHhxX5S
zm>kr$fnoi)eh>i)+2hS1@81*2T~g(LTCoY@r#__T=FU2y=dqRaWV!%YiHul<R8}sq
zRV5eIXwjYPu`<?Q19=F?R-cipU9liRi!8@8hy?y>9!{ptMG>~hzC*bf&SM$(dL^w$
z!o7|sa{IY!a96|rl*DfPNLDjB>TSeq^{_i+ggW!K()#w!6Bi*}8NsvDH>^a86;?BG
z(*5+%_#R6WKDO7ks?m{-KGsJ7<8i@Oe_A9b^KT)iUI4L4%iBS46}a`2*}LWd3zh%|
zEC2!l+e<!vek0M>_yuh&FPv<Ct^ILsyLdo`u5NQfXz~2=t3WJFyu1n%#k~DP`8RpJ
zDFJ&kWiKcost)Z_)p|mw!jO(Xy6sM;wV<caK&T}Df{#u0mgHwzleLWq?k`x&TI<AL
zG$QU_9FTVUX;V`w#`jKw&@c?AOSP=~;m_|jyBLcPI{l6JS+}RZEy6aAwEyAil;gd|
zmd7&+2TefQTiT*Edx3pijx0QOyOwhuU+SNV(q8Qh7tD3pR2W3)L<hPD<$JXzB=@>s
z<o%(>9Xe=a%hC0Vhq7Am&MOZzY$jYD4}4nbvs(0=MDYzfjEDHG6U^5)Ya)dq%2P=G
z8qlBztv4;V%4~v&_%wOQjY>VqjDg(6gzy?xeStt@B+2OJS9G{$bWQN{$aI}~+2?2x
zCc{*3+8wpG-mv;K03>Q<vc!);K(w+tuuyN8f--6eMP1_W`UpG}140U*_W(NGfCA|w
z1A5$o0Q{@Nc;kqEBav8l_Q8*RPaPucxP&gs=%AGu01H+Xjz~h%=pgCFI^a+DReUgo
z=qs&VULw^%X-xrj6VnIo;~s2dH7bgT02a$bP2|~qsbn3T<$eMFpj)6;tM}n|n6aJ4
z1eX+9fS@T=T<Ww>d%Ko#BA<F$oVco4g9!$WN_VNk`PAEB)6Pr}1YQ~^z-nrD+Y6xv
zWl<MJ0@0(<?KK(x-L~je2<`2iCo`F2<7;YOrM+tMkQ(yT@4sGft3TXoBUQzR?%B7Z
zg)?wU+@yn_J3}J&-FoV9=(JYAFe)J{1R6S6JM7_Nf3g+pmi&;g>VlmblX`sC)bLz`
zDm=$`QMkpO`(hIADrDZlYvgnTT-gS~3qy^?f(Z&xPl#d4P5^D_gfZ&SGclN1nE6MR
z$pvA1gkK*7YL}A(zo3@;Wd3TC%kIi8m7_EA+EeaLxLunh>d7`K)s!6pGmEA%EU`9$
zq@mFk2jj$KWlM&NcU<$F<0Ity6jCyba-MqesA2N+F4Rx8pL*)PVtc-d<(f=U>S&WJ
z#|sGSjkS4*`Bzvp4E>B%jp+t3B{8nIhHQ5r$e-5SD&&E)x!8nfQ|4s$kq2AcNO)|_
zYHFRSg-8RSDDnA)H!y%?1OoD9p&aUg?mZJK7?L=do((q2>iH=o+xacYastPAqq*s8
za(y3P<xCC;)qntR<WwkwN5CvnI*i?+l-;_mfu`!FQ}tnp(1kK<Z$Oi#3xMh@nxWg_
z1sl|1Q#{Nc!~C70;(Aa3Em;X-I7V(4sq?*Awg#qnLZo#~DJjaK$yIW}zb5$mT|y?g
zLu$?b-6d^e!S(03DGe3-<M9@cf?vB!8)TpmaGPupk!hO-WuUW0h(MyB2BjhrN@2S-
zQE<-$IqzZtHea!17w?<1OBsZ#EdoG+KpYDyJL42I&D-0Zw~DkwX4Ty3uT>K_ccy(A
zj{Kpu=yR#tCV=qH=PUc+$7)5|Ar&c2xH4e5S`yo*JCbdwZM42v8QORADh~N3WRm4;
z3q2BawqG{?FTBMPmk|M8_FCL8XlOgpZLRI>^@++|!y<-508r-mYX)F3S)!0>KiCM>
zm8i`xg72q$N~j!n%i&pI4pvnL^t3O7{d1e9qae3TPhv;z4nM6oNhT2OwGS>pen2J-
z-$?DqRd8G`+?-FJ20p<WIfXRrNuT%vsz5mWnx0W1+Bb?#=A#ia9)r$DW8`Ah`6OVt
z6VQMiQF0!)*pD^Gbdsr}!)@ZciHK`8<%2f06$M82E+$05seCyceiu^&tSp#3?crsP
zqiJLAy*e*_>~v@V0f{t((Keb{8RU8}rHf1CB=S7NA~L_Dk8vc0=@OcrL}7exH&u*9
zTQp_|R8O`VNnKiaUqfArYQDgTr;}L!Z9&(HhWD6Gxt*?E{5!t<SVuAR=IL;oR=KMN
za4<taWPCj-vCxYx_`NHl$$op9DY^d5^NdH>^C_2y{X;FlbA=>m0NzQF8gX{mVxph_
z8Oj`5uXAv{J>Eask%ZVo)G^WH({$X&_yQe(bD^3p)4GMs1P7K#iEQ=0pd(DH1gT_N
zH3pm-A0^W!RH6C+cI!I6S{Hh%@ZryB6bJXEJM@h%Dx&#PwwRaCan5lYv&(B<yxd~B
zyV?-lH%Q<oi)Q{00sm~|(Ma?s<?hAk(}J`jkh$<}eMX69@;;*yt}_)sVx+A%iK#JM
zYg!ulY!~KdiBbSr7YJf<Ni<f<{%~c!cCK;XIAl;sFo3V8mk#jOq;doWQ1oXf9l%ph
zhiG!_m;0IC0Wzw6WCV~gFUM*M@N|!V2I)E`C}L;o1Wok@!s$iGmkDaX0H%(NU_NvN
z<uz6E3@#8Kut#-B1`rO&D)V($8LY-YbODgNWKM>8H2*EQs?Yp_+?x5VvRQ5OjU@xr
z*K7mrsk2U^QrBdz^;fG1;(q1wBOK&%A$9FbP4lhhS_*LjbA*6P_tfsbO0`|=uLXMP
zu`ge!1C9UyEm)dwco^J6lBY`)3DbJaRL90R!2_Knw7TzCiVWW><DuVHqlCNwueXEN
z`B4i-=JE#!wZNGlUxQa2I=lcCL|UvvvJ0RG;Nk?yrj}exeV=KLM}l`q22}u7xCNSF
z+EFcnu@iqMG!M}kK@x$yToDj~o@ZenM{T$hToIn~nW0_Nj^sNGc2VKP1NeH2n|w6*
zIn|eR?CL-OGM82SmyFJK*1{YXcbL5=Dq<15y)}q~?0vXs1V<mM5s6!;fxhu*_&tOk
znv>=?+k@?Cq}%q&;s1f0r6bQ6SMnriY{3ax0FUV+R^QHE`ix5Rm3N7x8<N5^U?MI)
z9}vjZP-X(-CxzA76;l}3FapwB3~Du->jqOg&vwcv^+w_7%E&PDRBlF>Cru;nFKJ)o
zy^aWAk8kbxjY5CGhS`qYYnhuGOIqT$bXxe!n=TIZfLO24r>Rz34STX5RhhAAR7twk
zw1-t)b+2(F<b$%JWGGDIy1@mc9UtY2FYl;(IM-hsfTg|H5&z(on3_F)K_6)_&q=_n
zJ2ZMef$T<*ccd3g4}Ptw3_2rnptjcWaY#%E!(teOh$JdqLH3s!c<)-kb#3ruPsB2a
z!Hh=u@Bk2_Bb14JuH2UTyA$EdXuop!NfWB!UuikU(3-%?@UF<kw9)9I>n8amxyjbA
zsy<r0{YE$hrG79kc9MKcr($C~VS`6(VELW0mqmS^FeNMOSQ`KU2`7<cKmfVVn8*MC
z2Q6Urr`e=>DeN=d!|!cqb<Mw-!#J>0g*ABV__}i`v}zUnrtPOiXN4WQxf-^(k@OS!
zu9O@|J+_U_qSiECqX#gMU}f?J0FK&!b{^l3^1u<Ge7unt;i$>xO0cBCYBe{Us_+EW
zFPsqO;@p27##(^b_!~Gsjkd%~O?XmGaiY#-z&>W|q?8_jq0@q^>jI&cX}*2|<OEwT
zm?LgOjv$(-)*8lVh2qyt_iYidMJ=YWmt~+va8zc8rSa@ImTESIrI*gWuTwcpgu0r-
zrj2xYYO_XN<I}MIX0QIx6*5nKVT;^WJUMtJdamJRU8(oFJuX+LG?;W-fd#{H;$UqW
zb+p+Q{*GwEg-{UVsHK@9rJd_qxdd#jrPcd%iR=0Lbpp$qK|HVw*aYknE@6X<Bmk7g
zh}$UK?(t6u0eiHkw#@ExNsjmT3%mfCw#j*F1>g9(<e0j@Q!%9I-wC&$vmV+kC@t(7
z9S8717`v#Dhvfnz&1X5m6Ev3zq2<2wVe&_zdnCX22|+ki;zmAp6)yHZ2*UJ_!{E5O
zVhs0nYb#79CFL)0l3;Lm2@T3ZX7>^xJ$hLk@c-ABf(L`v?cgPHiP3y?sSl9I(~+xe
z47$~2mI-ngsp-1^v2Q-t<|G}_x!8Pq3+Pbb*0g)CXBm&%IYCfjIq=QNcGm`#LOc58
z*ey9!?M)>ve#la*N6N}bDov@`HB9cwtSQqIP$&b>V7b0<a@$TgGb^a+;v7?OQ@|KI
zq!k8TOorypSV{_fKL+VGC6dUaj7d)VTfBR5(r}c)<A3LF*4AuB<e)SF07BnWx2i=@
z9k0FG<ePES*o<{$r)MNuwCA4f_rW2Fr|vFhB*<z=k5pAEN<synZ#i5oXhTcPF?xDd
z+P)4X$z&4@7F&Cf*wUiE>R0p}GGLdpi~s-t00002>%bt;PQ`bshd-fBCpi&*T|p7l
z7k9t3+=K(Y8!rF``VX2g)$K@K7h)t1ZOOaP!y8Gg@S0zi>lfS-+oYpfegt_RVmb%=
zZDY;dLoCm`Ay$L5^HQS0*>}QITomy{+82#j1d^QXbp)RDW>p7+1+**K+a)eeK5IZ*
zq*KdfU{-dy!K1|OdH|L5=VAW_=QUdsozhEC#s;KcH3V5fs{jB10001jxDNVLKA$fF
z3W04`Fmm><7CFuBRP0Kot!=?2ww6iec>JhcOBm{14}rbUB!pNqld?YR3Pa|5u~pBt
zaWn(7(va_otu!rAsP0;PL!yY!i8AO~1UTuhKJ;JnW%LD(PhRhya*GwGn@zg#Z32Ij
zrUaOJV~e(IgK?}p(1nZlLZ16nrBTooGEW__Ax2pD33XHgSnk#GDr4Ne?1(asF$yEy
zi%~ioTAf;Z;*U5n#oTCD|2T&vBBXw$BPAC=Bnp)EBkQ;uo*jj!$SG(lrOYHbeo^-5
z27Q%2bC6lCKC3YX^d0VhKay#<=2tCg5*=J~p|8*`&eJIQEnHL-w76cP_Y}`jT5`)^
z>O<C!(O!<*#Y}D!g_IF)(L=Hr+9d9;Q87(6<f};RCMNeC^K-hn3!xK?55jL0pMd$d
zKBtK6a76kOGQ0(rX<Bf=)~b-YK`i0J(Wv#roF3AX4`6{E6CXb2e=G50s32>#tcB9I
zZ~3Vh>uPyYJ>&P#Cvl#i2$5PpQ52+M+6k-uKkinXn!ir_e|H#6XWdv0%D8P59X&rO
zJ2ggz^54TlH6fLrN&8mbg5aYY9PbwvsDMd4N6RoZS4A9J%Wfd5j|<n6muDpt@vL)R
zb7fN$6l6g5^eN2tD@l-szp$%h03(V-f-BNP=H~bNf+L!r;1zYgrn#x}&S%7_IHQz6
zg&uwh5Yo9+rCF<iJ2NgfFR5o5nl_VE6cROGDD%<JDY3`n8OSf(B0nLcpy6$B#n5D=
z8x^r-_F?Zn6}YwUBeq^W5bB%%BV-IUL+9bxX}XsDpP<Mh%nSF63^d?(OE#3fm3)%<
z1GWC20K1X^0000001IWIrt)mRF?~v;ya8t-0FcgK;Gz02ht+W-5cN(JrKN}1r>b?G
zGHEpdopUn7IWT~v*(!jvZrh>P5~Y^f-1Qe4#3y%X$SqR|yE_4JgoQHHHA9EiEZzw~
zA_kcGnSsCD#*5|y16%nEeVQ;YKU92!0Tf#lQ8|4vgvzNLoMNLDabHH=u#5CDh%H^n
zX=BOjJ$5CrEa|Bss1*0+qZFS^Cmv;a4QX141{xgHpDYtX@_E^NLg7hTAaR#X$ZM$O
zu?#8|cye47OM@aMQ~z-%(TJCAvOGKc@r}m9?A5OUS{J8k)lFw;b11^YNxdaT(#Dwu
zWQDv?&{8TlKT9QiG}7L^)9gR(^<?SqeP0H=zn|qQC@9Q<1`M63f@q?6<PYocO>)xM
zfb~ew`Ad49Y-=o7;R8sYo6m*ZPd^tnQp9rds;_V;R6Y;|YSf^9zGs)Ug3~$cDS$<>
zTTR6Wmaij5P3f0Rr?(<E2+-2&S4apC(Eb1b@}~^Aj4wJ3>)e7`mF_cCSaOSyJKx2>
zu+ect-b+|kzTo!R5y3e}CzwdYvVt5x+xXiz#4a*kwo6fFZFPcQycP;S!C{cGAnqG%
zaG1PAmr{z=5*?VMZ}h!J)rq-&N>N{JY><85j{i-;eOW1hvt>QtqJ5e|oihzj^MU26
zM=*5LpldZe{`>P+b>DSafb}l;;oAEVeqJZ$L)?pSxT`oB1sM-h?hiE=DL;nOyj7M8
zy;sA2(YC%bi5sK)KiJN?@)I`eUhkz4QYr#SLAqI;s|}5b0wVoCUK?jLZT{y`YMQg?
z*Z&VRk8<K(^_1ia3RJq0FX%xC%BXIc1Z>{Y8)>rYWl&0nt1JvMmm_QOA;H45*QWau
zBbIe23p8%pRlvZ7(hJ+5K~4daebR64!U+D!S|l=mY|bEhK8u&~Dod}9bc3BQAbTaj
z<{BmJItNQLljcwS?8`6W+NK-Sv~`=@oi2*@XAoCG`6PL5&CSb|5kR=aQ4O+Ut1>wQ
zjMcgkcf@YCP788wnRosM<Ay3j7#I~2b?>Dc<$K?V-UnX0iJSz(GC$$Xb$DP>(Bggi
zm@hQKxtv<mQw_fu``G^NWu`ORe(nt(IGP0OaR_laU6!_Uui%%G$}Q0{>6@2+&_`8*
zTE-LK)5DBTpB<-n103iIYqiafxlMUZi4xBwh*jknTn>->c|0j70|tIQc#pW41cFWp
zsP)x|qH`thnkoRuT~UFCX#mbW+<BqRU_7fKQ)js3E$cuX@`%)Oqnes4f<GNPVGLc`
zLGY9I;@7XspXA8Ea(A^y1+Q=1*VF$`M{Anjf@qxjn_U0Q{X`0-eNq8Njj914@7fKl
z;MCGiZO_q@hND`)o<$W&r;+K#CoGp!05q*R`*)!*k_uRaIu=k&M9@<cCyz)A>Kxkg
zw|CWU{VS;`WrL~rr5ZDBZI!ydzM`vH(jhmKmdrO3wOCyzkW6xIdDUVZz0~!{*UY`P
z&Sq&Ac7FOyN*7sY)2RR}J7vi&h4A8YQ2Vbj?JiM}ytT4;?Y*`HQyOE)1<m}5539_T
zB;ikQTfhvr0OhAL>jYP1iqPqdOv29G{%p_%c>5TGSll_Kgd;Y?G`sc+JUcm`zhqp^
z(!JFa(1&5}yFKbK8VcJv4K2l&A~KCASX~aD5Zi(VtF~PIce*s;`PRvzn(PLqSf9kd
z9rDx9_VK0^rC=90{pbLrv%c1;cT~6?toOOh#AH7P#en}?Lj;74A$(9yd|@+Kjf>;U
zPwKbEX#hNA4k<3xdxouH-CiMS&f!*BaPc?g`u9W0uk!sCPld#}q68aDX#FFQB${Dl
zev{PSfW^CUiHHEUhjKsH>?wUiWZz$IV~jCOI|!kSNbp%{xH!?KNV&UZ_#1GFGTbaf
zidBPM{)CQb+B5azugv}1lpNBG)45n~>9H{r1OBt3*f9-#3u+&|fqAT6Ei}VSDbV1G
znJFu;_Nvs;A5Cr9)UvNH5>*HH=ep~sv&K0Ud^do2BIg5L&h*#D>%hbWtv_AwLUiHb
z=X2BcorjI@))hZAay2B}9Nt5OTjmfY{|9pFlo%((3i9B$58^B9No}wLoUfa)QRM+*
zP%o<-Oa(Vg5a5#)n}H`CRa$OhX6GkGH!ueA0!#Dud^-DRkllnf(=^-m2ykI02i;io
zqR#0i0HGe_ikD8ZDrYi~rHx}$mw_QA<E}rb?Io!yZ<Q-jTsH`BLqcz(>p*cax=2zY
z6N(bh@y4?k8{=j+=4IHYx-X!dUIWSY43R3hSBbXz&>UO=(5tLo>~qBl9|Lo9!JTzL
zlqA@vkMAZEg2RqGNe+S75wc^3J$E4h!ZTrG-=iN92iflP@twq4NZXF54NSWp)3@uF
zYZwNRVsbGqcIq*#uxO={zi;H2kbmKnaJ0Wl*D^s^ABW6e5=NHczWYe;jN+GCQ)p$%
zGFbSnta;#aA)uEhqu5vDv%GY>Sg3TWnB0UK&ao$U@GV%es;IaM0oi(FMKBx^QWKlf
z9yi#Q$A2w#%!AKZNCb#30l};)Mi<C1+!Y~o9Z`#QStvEM{7Ew!R1rmCry|VvqQtHh
z_`{vsBUcO(!(e#87}n=7lVGLOUB#Mi46Eqb*d{6{(o}H7b19vTV)YC)59h^ZV#TE{
z2@P88unLxud`10`rUfxAU9&B5ov|ieI<qyYhZ||)E#SXgR~(^QtaoV+b8o>wZT*j4
zKH?3TyYu^lr)98;R)K|<y9Nc(y@R$7exl=NZNyq!Otv&i;-#=uVD#uC8|G?M%pp))
zEJ4MMWKt%?y=WO;D)cE|bE_=y$V))5{Y2n)0So0d@;xfPEFN0`-K_<HEn%ur5-#{K
zqC0#GSYZA{eSrh!8{VcV%P3ZGZ<4>}!pvCYRIeF{U0w&yY-A}|gb3kr<ru|5pu+Qr
z-zx?_PSTBX8SuA=aU2lXZNxF!jS?$+U!I2Y9qRF@x;g`~^NrkcLR&4iEoogQD&chL
zyZPe=7$pf&?RABq1r}hyp8WuX{J%K8XXU=M{7VgLnGX}2!pTeOASnW9nvF!jz{?l9
zH`nWz2OTkZJ&`G1>`+%lt!|Kgv4inRYqkojvygoN@-=@Q8h<_MaKW;$^~gu#C`y77
zb@2b+RKrasvzpu8oe<1tmd=cNVRY_bVgBcl9%Y%ml{$^9T2fPu<tix=l*&Et!`+4>
zfDQDl`AF`1f;BOU>~DcM%-b*BCF(H&z$lIy=JjIjp6292crKLHQqqtaZIH#z*Ab&P
z?Q5B<4Vl9d@Ylb!&Bfi;l>HA>fG|yQlW<@6fIaO?(3K4%$w_Yb4MH$Vn1-s8RF=xP
z^hiA?Fbk0b(<=jB>U>_j?Dp_;k}VJ=M`@Ff8>1VX6etY<=2T6cyBzq_UM|gJKKVdK
z30Pn#hN2Kup9zfjU4^(nbhX~d&48HJ>m$}WFpNCwh3m25HaoU|x8=~}c~8pYN2W1d
zZPbnG@d$Pj$_8((8`H^QT*IeA@5?uNHh*H(w&*j3H7(o3vLk}we@=^}jZ^w68SPk5
zt)&^IN+vQ}B)$^HNT1a8WKoOD8m|Dv#==7yaSb_<e}h8oFKm{30A*opGuMF=6uvH2
z^j~=gm_DNEdMMnXq7I)b;MuriNqrY$2jh?+A*~e-Tw(}AwFAIqt0$%lb}{xZLpU$<
zZljfl5W`QSU+54!(+zWD8QeD8506bq;ZX3Jx<n8+^j8lB*KZbZu;H8^FMyOhgUJ7>
z&;#c{(_~&Z>{)&J(UT59E>s_;xpc!GUOp$xjL4B1yiGVGt?W&n4h}eW8WVmMhzQ(+
z>$K?om+6BkOWz;?xYb=r23A@YFXL)7jOV-3uxK}AbEx7MjoMs5;aaBG%Y;khM3r=b
zTd`P0@QB)#qRh-4HT-@#76F>L?;^LIA<~6aLSq^$h*thYk`GBq(J4Lgu?zaS$s|CC
zlIW{)!*`)!d!QiHW5M>ypoE(m89iyww-Q|%$Ue(CTP)_j`9h`c8oqEx)e8zIrcddT
ztpU7H1{4PAXN4z|27}H=e-gyhv7gIRsPcApdM+`6Vr~H^0vtQCNh{mHmw?eHKSs?M
zEWklhooc$otevdazy1>TiOFo(cm@1lyre}1L-%eo=~}bRj9-z6eS~27M5XR|Q^r?;
z0*cOk$!qZk1v{ybpZx?e_q<g$p-u1lrI4Hq%Bp~%n#;=8mMsrVDH)le!=ftzsQ?n@
ze{3DHRaz>tX)$D!Zw?WeKGmcxz&T+<hPa98cX3lZnY#*z6o*QdwTMxyP9qScM&*l9
z#l*8|E8n8i<>ygX9_u0HNOqg%0GT}T)9(#Qck&QCGgrwh>v90QAZYo!>B36#j&L0(
zb4vbyrN8w~++D7r0s^I1^pH4?glH2w_vMMl8vXFvj=9AOAZ_|Krls3qa6C0>h*`Jm
zY`C_W(C*r7J{*^a4pQi6xR6Q!I^Ow1)_*SiqrLE*R2H-5%^@d$$(F`}sx<0MnoO%l
zU|%C}Tv^5~by^|$N^A7ioHvNt>V8WULSz>ELBl3MSDKYe^4cedqqZ&XqiQxZyFZ4v
zX>a#+nx*+CGq=~NM0yZQa)`q9_UjkK(+3iOT$|+|bnps@C7W;m9eJEU-Zk_#g?w10
zh1erIZFM6h4Dx$OX$Yk#`MYl)wsOg8gvujk;hg5t-O!%=IGfE@&!CzM`YAE}>-j}v
zawtC_Pp}WdY&f6P+DA`P8Jg{CKbGkG2xe|Fz@P7B0j~{E@;IMD(G98`&vggMQ*84=
zPwJkt7w%F5i1>XpMZzG1nJfwRXgaE+>SV``ans7g)vg{TyX~I;(q7Nn)1>#})2|#0
zB*7&{E47`!sU(R}VQp4&>~$<R0(r~mG>^wEi%bdfJM>WrSqtTZo{HEM%ej}_698%X
z_s}6C{s4YwVmS3YXKpw`I$L+p3}X^@30~}GF-A~xQ_d&1_GPH=M=itsYi@FbOD)lb
zZ=^qho_HuX8R?#(70KdY>(PU=0eQ9P!`;J9@yUIgAJ8aeQ?16IDDKbi<{9*-ziOIk
zr@0>!id2-p7}q?UkOLq$Lz==+s?>qnZK}`D?h=7QYj~zb-<o@{3t7rW`v=bJNk{%|
z&e?FVzbvYhsV-g+emK*^{W<N-&5ERRf_dg}ye-Dk)Zyg2wyHk{anTG+J}l6y>Bi)i
z@%yG^)R^KP<76O`R&y&dnbE?uc=*il7dsbBH!Uqur7w>MD)}mzJn@^6yeH@QgdJr1
zqdMb|Zw6!h=?VVV(i^R3{6W*q3t|D*$K*Bkk;ZOR(%(kBedX2>ChpKI4yIo@_mF{&
zio^Dmys25bD2n~cF{{H}xj3DqX4C;CYIDT329J00<BCUHbQh?D!Xs=6Y3^?CV28yB
z4-V(!q{ae#N=IuR_ZUqf#n6PU02Qw+SvvduAvsf&4pOxq@RbRxBM2Pac=Wm_z)T$#
zGJ(Ne+dGnd4!#0*3qhipO`>gZkQtfRu@09@sVqJIb)C>~jq#!Od4H|nssPnCbthfy
zqv=dyi>^lBKoz`SQ6|1f8+?ZkZxSK^)Q(&=4>VFoA3v6PR{eUBS)K(_m`gBS4mX}g
zJd&OWw1iPAbl^}v);C6h(6@p%ko`gLTNJR`&IDLqy$N*GxD;7qDp2D-khHy>aHAD6
zXOK;jaK~d<CDSRQ%`jvyYp;LI9|hsvY&5j%regnwTl1Bw<Jy#k4(JCKfv>DbAWzW|
zl3&m#&?NWjbb5oAt$FJq+$-<5SF`+``zdcvj>?dkv8P$aQ*S-sA!)`uxHkE_&n4C4
zd*<CrE7@dD!!ovW1a?ypK`bi;9`&*hYg>pDINtxeGM~q~k8IZDpj=GWa9S@G*CHZx
z4+mFFV@Gb@LrhiD%=|!T3C&+7i2B||Sp3{og+I>$5H*+>vXQ7#At~2%$e@?kpmkk!
zy}I9!PUVdi2Q@K6?f&@m^ZG_*QZ&WJ$NmF;&a$=EgZ4V9)(0LwR4uWSJ^=(mI(j;j
z#TUf#oYN72OYTqi;rjLH6!F_RMeHi;yEgp9S-qZ`<-EQ{K>yUgYX{~5>uCCZTn^9O
zP26keDV-HR15TGzqYnS76obKTJZjPODFo5|x+2JnOV<P>L9`Yz8}>W<HaI!2pKnOm
zwCV+7j9D5)2AeH;qTu8R7na0wnD;+)kYPknsjLPR*&U^LjJ(NLB{$vQcnPMT_AnIf
zk20t_b04+Nm(AN>-pXM=V=Svk8A^|nc@W?LOdo!7<CKU=#CXHb__8+gl$7N+3%Q_}
zsKBV9Z;N!^GNGXIQF<cH)mNqhf_IM3W?XzD_q-@HRFSa8B8OkGlVAAN5a#@A_isU_
zziGSUCxl!f7n}bMi(o}6zL+8=(!9{PqvEC+5W-i+yyD#)nEN9hJ{c){aG`R24Z?Pl
zs}IzPr<yk@*zN$Y9{4Sen?hGb5zWdoC#UA5uny=QJ9P%Cc(bud2JLZ&ZRA|uPi=7+
zqRnJN?VQ$rmROpO&L^cWqs!-JEMH9gE#?x2nk%Fd{G_6Pfw8lOjO8V6sEmqU6Dcs`
zia439H`S3>h!#0q3Fuh0^tCc}b9+j6!BFXSGPeYWk}#>n<akhr*-;ha;8m(H&zmsI
zB7fA69tZO0tfjmFEJ0XYQ8fV;mglGj>JuC$Uy5#`+>P`_as~pn_eKRS_d%p_KbD7Z
zP5XtSh_`;EPK3utv@lo>ERSlypRf|l5bM-(Vd!7^&Qn|`VmWaa0P4QXB{TjIR)--Q
z!9@>!t@=uPC87(!R8&jmu@!(R-=#F2OxW;@mLt2vbyuBm0Op{PY5=^k8Y<3#{2?MP
zJ~L`;3V3rhK_NoVocXPACQOGdW$|CQ<{6JAv7HC<he7%FP9_Av)YD<q15F0}YHJ5o
zZ#dW6+q@VN?5vDQCxO_yd-|==BuI%2lhpO<SL2?&U)|&JjM2*{AlswunK&nK1lp01
z2?NcgD^Ws}YuK9f!4DyqBjB%jQ@(x+sl{B)YLl!l{r_8a+4qa#rP`5Z57>~=ErsxP
z_-18jt|>47=8gD)*@&~0nYN&Fr4z|MnWS=9m*d<uK7gpTtASk13u|NoRCkY3@K`wy
z<_)%Gi!qIT#j2UgI?bi7*b6R?9gQtIPexwjQzoctzXsqA`+u03=J+-94WKIO35KBn
zvzb)jvtQsU2$ZECEOBEf)Z&Lw)uW%=iB;ive7mtr3{m{MIgf{_^sfn*@;xMvK4U>A
zyCX@V;JhjxVB^Ng%}36YS(mqY(<kA#0x6A;oYodM{E~uaN`g7le7jV)d^vJbj7Lc$
zcw1A*4MvFoCbo;<J)z{NR+1+%INJwHbe{Z&nndRuXhZ#&#8y%!=JgdB_<ahQ@>|T~
zg}ee&8DQLBE`$%5b(4K%MP3hEt-*>m);TSRZueQR2HEW3kkDN|=amSBdAp#s^aGFQ
zi0qGF_)Gip-8|rJ{^AODP0VIlc77d-hF`Idtg!!Xf~#WS`BB63!zti&e}3bQz|+ME
zwh;Ee&y+meDXd`)4?VxoXI|q0T@;Q%5Ptk7fb}H&^H3fNnUEz(t1d5mbM56-RuY-E
zg+x^q38U_Bsa$e%D}ZJ>^|+WZ)5P7xI;Dj=PbyHLQon3pXQ7?$5OuLtZ4dzvdRb?m
z5J)7TxZ^V38&6={n?t&0N!2WYzz)zCHKpN)#!1&j>=weReWZ}6%su1QNA`}{QRtK-
zM=z~z9H*3y2)1YkdIemio1X1c;UF-uP*_9(eOteFw3={21F1R&f5H5@GoVI)WVZOY
zgj8QSjT;dUdsB_b5fQ&KE6w!p9P;V<F9@PU`!&%Ro2%qb&dQ%2IQrw?>^Qy;LHwbR
z_D8z5FfmSw4nCG})&{2zLz|tL3Ce&E5}c6NgzQ<PZeanx2lW&*d-jOWWQf4h_sK_W
z^>p6)K`J`a<f2YWsfkpYcP+p?)}u4aI1kz#A)AZq8n3W&z7h2EsdbYZyAIS-IhfFy
zI1y{9XJwc8b2=2sDF5CJAjl+;8s=ffaMh!#J|UxCCHwDUZ%#r<>IkhUl~kubARj;m
z-=Z6rV%k4cD#v;04%^*ZXk;ZH3P|ePxzjnH<_%3wny7I_r1?fZ;BbI!H^w+KQ%)d*
zDd>?RwX0ZY#s3-b42<tS=tvU*daJat0H1zOKQl1po>Om<ySRE{l2CdBZM)uUuH&*+
z_zHT9LD4S9zxdimx+u(>6POF=l{SQD!tYAv(So>oFhcgjFEt?7(`W88%$MifF487d
zKS9?@IGS87ip1{rnMFwhkb0Zw&*4nEsSbyb6oZ)3gihe`tu(@tuwgcw5WxgF^3;2s
z`1?tR)=%uIdszMKlYX@holZVlzi)j{aoBsdLACm_U<P_7TSmRw3@GQU?%!-(8|tIL
z=`{?`6b)JS*w8;A{<t^%+JV%4iUWAeiaMm-(zqra;p<pb$Mws)#>7T{hoL6^d^oKk
z(X3oa<O}cS6(7aAOwqz@@mJpt&J66jcNq`v{^DbmK2PY;hr8D%Vm|Yp*n(qsXO0{$
z;XRjyJvjt~nWNV;khLO;jDEwmQWW*G<J@^9>!}jonQP_bH`iwLpLlGtpCwJ?L^qs6
zTl-+I`4BJ#45-cSQ4iT50Fv;JSttJgUhYxao<IS_QXWqonja~``Yttx+>Q}mDnFNM
zZ=2i)rs&S_S4!tlO`Vy<LBM*g<pstvc}+~9Gt2*E&-U%YeZtiHzhnhsqS23{@bOyV
zaWQZSTAFLGgM=89HN5|c2i!>`*Ub_9kz7%8U_bmc=|%0|9!mE4A1MR)9=oWPWYuYn
z;n3PG`CTuG_k5Y#DYMfv@E7Uc<7?dn?TxgCkmSGEuzwjzhZlpy9ev3v@Yq+Zxw{rp
zh-b-hW<w`6!)9~qSv}T`EaSvaGydIJ827%8Kv2ZwG;UrM7?vq+`;f$3<Yo|AgB0<X
zHqB?+{J0(Jw!@#-&M3WCQ0aPjkav5)ZRwa3(2_$|o`15jo2AxsgShAAI>0(*kxkmk
z=f_KIl*GX=KvV%?3CLR8wG9UmU92Yr^jTg=QYz_}+ozK&p~`)0O6dn#2byyY9YAlg
z8ip5T5L}ketL0{VyTW?$Dv0d$Ct1rO!_~xZHgjGOOB@Fe8A1)|R4Biz`hKL(lKP)>
zFPxx*b4~wk$Ssy+M-MOB4qGOw7(WoCi}lv%hI!GzlDgycs;5L>ky*XGgJHWf?jkii
z;Qg|GM*5RprWr(MzAWMXXmR~Fy;6g!L^QE^2P4{fPbcuHgn}_6m5zD+j!6jjpjH%f
zuO+NGRytopG<o^xT4~l=>?}BEfp?iwEW9>ftz6uERMk79UY1^t+hC`mM>75l!ejsd
H=#KyZW%P6w

literal 0
HcmV?d00001

diff --git a/docs/state-ownership.md b/docs/state-ownership.md
index 9c4014ccc..5c209a8ca 100644
--- a/docs/state-ownership.md
+++ b/docs/state-ownership.md
@@ -131,8 +131,9 @@ ruler commit would otherwise rerender every display consumer, and harnesses that
 interactivity. The store is scoped to one chart id on purpose. The replay chart
 (`replay-chart-0`) draws the same curve classes under the same provider, so a shared
 store would render every ruler twice and let the replay's prune pass delete rulers the
-main chart still shows; it and `GPUGraph` keep component-local state, which `ScatterGraph`
-also falls back to when no store is present.
+main chart still shows. `ScatterGraph` and the date-comparison `GPUGraph` both bind when
+their `chartId` is `chart-0` (ChartDisplay mounts exactly one of them as the primary
+chart); each falls back to component-local state when no matching store is present.
 
 `ScatterGraph` reads `state`/`setState` from the store, so the existing reducers, refs,
 and draw passes are unchanged. The one thing that moved is the axis reset:
diff --git a/packages/app/cypress/component/gpu-graph.cy.tsx b/packages/app/cypress/component/gpu-graph.cy.tsx
index f65575296..db89a4371 100644
--- a/packages/app/cypress/component/gpu-graph.cy.tsx
+++ b/packages/app/cypress/component/gpu-graph.cy.tsx
@@ -1,5 +1,11 @@
 import GPUGraph from '@/components/inference/ui/GPUGraph';
 import { InferenceContextsProvider } from '@/components/inference/InferenceContext';
+import {
+  PerfRulerStoreContext,
+  PERSISTED_PERF_RULER_CHART_ID,
+  usePerfRulerStore,
+  usePerfRulerStoreValue,
+} from '@/components/inference/perf-ruler-store';
 import type { ChartDefinition, InferenceData } from '@/components/inference/types';
 import {
   UnofficialRunContext,
@@ -18,6 +24,7 @@ import { Precision, Sequence } from '@/lib/data-mappings';
 import { overlayRooflineDasharray, overlayRunColor } from '@/lib/overlay-run-style';
 import { computeToggle } from '@/lib/toggle-set';
 import { POWER_TIMELINE_METRIC_KEY } from '@/components/inference/utils/powerTimeline';
+import { EMPTY_PERF_RULER_STATE, serializePerfRulers } from '@/lib/d3-chart/layers/perf-ruler';
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
 
 const defaultChartDef = createMockChartDefinition();
@@ -840,3 +847,80 @@ describe('GPU comparison with unofficial runs and load sweeps', () => {
     cy.get('@setMetric').should('have.been.calledWith', POWER_TIMELINE_METRIC_KEY);
   });
 });
+
+function SerializedPerfRulers() {
+  const store = usePerfRulerStore();
+  return (
+    <div data-testid="i-rulers-serialized">
+      {serializePerfRulers(store?.state ?? EMPTY_PERF_RULER_STATE)}
+    </div>
+  );
+}
+
+describe('GPUGraph run-specific Perf Ruler share links', () => {
+  const RUN_A = '2026-09-09~r27489075807';
+  const RUN_B = '2026-09-09~r27489075808';
+  const SERIES = new Set([`${RUN_A}_b200`, `${RUN_B}_b200`]);
+
+  function RunComparisonShare() {
+    const store = usePerfRulerStoreValue(PERSISTED_PERF_RULER_CHART_ID, undefined, null);
+    const rows = [RUN_A, RUN_B].flatMap((date, runIndex) =>
+      [8, 16, 32].map((conc, index) =>
+        createMockInferenceData({
+          hwKey: 'b200',
+          precision: Precision.FP8,
+          date,
+          conc,
+          x: 200 - index * 50,
+          y: 400 + runIndex * 100 + index * 20,
+          run_url: `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${date.split('~r')[1]}`,
+        }),
+      ),
+    );
+    const value = createMockInferenceContextValues({
+      selectedYAxisMetric: 'y_measuredAvgPower',
+      selectedGPUs: ['b200'],
+      selectedDates: [RUN_A, RUN_B],
+      selectedDateRange: { startDate: '', endDate: '' },
+      activeDates: SERIES,
+      selectedPrecisions: [Precision.FP8],
+      hardwareConfig: hwConfig,
+      showLineLabels: true,
+    });
+    return (
+      <PerfRulerStoreContext.Provider value={store}>
+        <InferenceContextsProvider data={value} filters={value} display={value} actions={value}>
+          <div style={{ width: 1000, height: 600 }}>
+            <GPUGraph
+              chartId={PERSISTED_PERF_RULER_CHART_ID}
+              modelLabel="DeepSeek V4"
+              data={rows}
+              xLabel="Interactivity"
+              yLabel="Power"
+              chartDefinition={createMockChartDefinition({
+                chartType: 'interactivity',
+                y_measuredAvgPower_roofline: 'lower_right',
+              })}
+            />
+          </div>
+          <SerializedPerfRulers />
+        </InferenceContextsProvider>
+      </PerfRulerStoreContext.Provider>
+    );
+  }
+
+  it('serializes run-qualified comparison rulers into i_rulers form', () => {
+    mountGpuGraph(<RunComparisonShare />);
+    cy.get('[data-testid="legend-advanced-toggle"]').click();
+    cy.get('#gpu-perf-ruler').click({ force: true });
+    cy.get(`#${PERSISTED_PERF_RULER_CHART_ID} .perf-ruler-hit`).should('have.length', 2);
+    cy.get(`#${PERSISTED_PERF_RULER_CHART_ID} .perf-ruler-hit`).eq(0).click({ force: true });
+    cy.get(`#${PERSISTED_PERF_RULER_CHART_ID} .perf-ruler-hit`).eq(1).click({ force: true });
+    cy.get(`#${PERSISTED_PERF_RULER_CHART_ID} .perf-ruler .pr-text-ratio`).should('exist');
+    cy.get('[data-testid="i-rulers-serialized"]')
+      .invoke('text')
+      .should('include', 'roofline-2026-09-09~r27489075807_b200_fp8')
+      .and('include', 'roofline-2026-09-09~r27489075808_b200_fp8')
+      .and('match', /^\d/);
+  });
+});
diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index 033125976..b828e9756 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -292,4 +292,80 @@ describe('PowerTimeline', () => {
       cy.get('text.power-trace-label').should('have.length', 1).and('have.text', 'c16');
     });
   });
+
+  it('follows dates-only range comparison (i_dstart/i_dend, no ~r runs)', () => {
+    // Range endpoints alone (empty selectedDates) must still drive per-date
+    // colours, legend toggles and end labels — the dates-only share/reload path.
+    const EARLIER_RUN_ID = '34600000002';
+    const EARLIER_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${EARLIER_RUN_ID}`;
+    const DATES = ['2026-09-01', '2026-09-09'] as const;
+    const ALL_SERIES = new Set(DATES.map((date) => `${date}_b200`));
+    cy.intercept('POST', `/api/gpu-metrics?runId=${EARLIER_RUN_ID}*`, {
+      body: {
+        runInfo: { ...response.runInfo, id: Number(EARLIER_RUN_ID), url: EARLIER_RUN_URL },
+        series: [series('b200', 16, 600)],
+      },
+    }).as('range-earlier');
+    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('range-later');
+
+    function DatesOnlyRange() {
+      const [activeDates, setActiveDates] = useState(new Set(ALL_SERIES));
+      const value = createMockInferenceContextValues({
+        selectedModel: Model.DeepSeek_V4_Pro,
+        selectedSequence: Sequence.EightK_OneK,
+        selectedYAxisMetric: 'y_measuredPowerTimeline',
+        hardwareConfig: hwConfig,
+        activeHwTypes: new Set(HW_TYPES),
+        hwTypesWithData: new Set(HW_TYPES),
+        selectedGPUs: ['b200'],
+        selectedDates: [],
+        selectedDateRange: { startDate: DATES[0], endDate: DATES[1] },
+        activeDates,
+        toggleActiveDate: (id: string) =>
+          setActiveDates((prev) => computeToggle(prev, id, ALL_SERIES)),
+      });
+      return (
+        <InferenceContextsProvider data={value} filters={value} display={value} actions={value}>
+          <div style={{ width: 1100, height: 700 }}>
+            <PowerTimeline
+              chartId="power-timeline-dates-only"
+              comparison
+              data={[
+                measuredPoint('b200', 16, 600, { date: DATES[0], run_url: EARLIER_RUN_URL }),
+                measuredPoint('b200', 16, 700, { date: DATES[1] }),
+              ]}
+              yLabel="Measured Average Power per Chip over Time (W)"
+            />
+          </div>
+        </InferenceContextsProvider>
+      );
+    }
+    mountWithProviders(
+      <PathnameContext.Provider value="/inference">
+        <DatesOnlyRange />
+      </PathnameContext.Provider>,
+      { unofficial: {} },
+    );
+    cy.wait(['@range-earlier', '@range-later']);
+
+    cy.get('[data-testid="chart-legend"] label').then(($labels) => {
+      const rows = $labels.toArray().map((label) => label.textContent?.trim());
+      expect(rows).to.include.members([...DATES]);
+      expect(rows.join(' ')).not.to.match(/#\d/u);
+    });
+    svg().within(() => {
+      cy.get('path.power-trace[data-segment="window"]').should('have.length', 2);
+      cy.get('text.power-trace-label').then(($labels) => {
+        expect($labels.toArray().map((label) => label.textContent)).to.have.members([
+          `${DATES[0]} c16`,
+          `${DATES[1]} c16`,
+        ]);
+      });
+    });
+    cy.get('[data-testid="chart-legend"] label').contains(DATES[0]).click();
+    svg().within(() => {
+      cy.get('path.power-trace[data-segment="window"]').should('have.length', 1);
+      cy.get('text.power-trace-label').should('have.text', 'c16');
+    });
+  });
 });
diff --git a/packages/app/src/components/inference/perf-ruler-store.ts b/packages/app/src/components/inference/perf-ruler-store.ts
index 98bbfd692..379fee293 100644
--- a/packages/app/src/components/inference/perf-ruler-store.ts
+++ b/packages/app/src/components/inference/perf-ruler-store.ts
@@ -26,8 +26,10 @@ import {
  * @file perf-ruler-store.ts
  * @description Provider-owned Perf Ruler state for the primary inference
  * chart, so completed rulers persist in share links (`i_rulers`). Lives
- * beside `InferenceContext` rather than inside it so `ScatterGraph` can
- * consume the store without importing the (heavily mocked) provider module.
+ * beside `InferenceContext` rather than inside it so `ScatterGraph` /
+ * date-comparison `GPUGraph` can consume the store without importing the
+ * (heavily mocked) provider module. ChartDisplay mounts exactly one of
+ * those as `chart-0`; the replay chart keeps local state on purpose.
  */
 
 /**
diff --git a/packages/app/src/components/inference/ui/GPUGraph.tsx b/packages/app/src/components/inference/ui/GPUGraph.tsx
index ce2e49416..7f9a7bec3 100644
--- a/packages/app/src/components/inference/ui/GPUGraph.tsx
+++ b/packages/app/src/components/inference/ui/GPUGraph.tsx
@@ -94,6 +94,7 @@ import {
   isMeasuredEnergyConfigKey,
   isRoleLocalMeasuredEnergyConfigKey,
 } from '@/components/inference/metric-registry';
+import { usePerfRulerStore } from '@/components/inference/perf-ruler-store';
 import {
   clampIsoX,
   clearPerfRulers,
@@ -111,6 +112,7 @@ import {
   renderPerfRulers,
   type PerfRulerEndInput,
   type PerfRulerGeometry,
+  type PerfRulerMeasurement,
   type PerfRulerRenderEntry,
   type PerfRulerState,
 } from '@/lib/d3-chart/layers/perf-ruler';
@@ -830,17 +832,32 @@ const GPUGraph = React.memo(
     // chip configs on the same date, an unofficial run, or a mix — which is
     // the point of this view: quantify the multiple between comparison series
     // at a glance. Load sweeps on the Concurrency axis have no ruler.
-    const [savedPerfRulerMode, setPerfRulerMode] = useState(false);
+    //
+    // When this instance is the primary chart (`chart-0`), rulers ride the
+    // shared PerfRulerStore so run-specific comparison measurements survive
+    // share links (`i_rulers`) and remounts — same contract as ScatterGraph.
+    const perfRulerStore = usePerfRulerStore();
+    const persistedRulers = perfRulerStore?.chartId === chartId ? perfRulerStore : undefined;
+    const [preferPerfRulerMode, setPerfRulerMode] = useState(
+      () =>
+        persistedRulers !== undefined &&
+        (persistedRulers.pending !== null || persistedRulers.state.rulers.length > 0),
+    );
     const perfRulerMode =
-      savedPerfRulerMode && !isConcurrencyAxis && (!powerEnvelopeMode || isMeasuredPowerAxis);
-    const [perfRulerState, setPerfRulerState] = useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
+      preferPerfRulerMode && !isConcurrencyAxis && (!powerEnvelopeMode || isMeasuredPowerAxis);
+    const [localPerfRulerState, setLocalPerfRulerState] =
+      useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
+    const perfRulerState = persistedRulers ? persistedRulers.state : localPerfRulerState;
+    const setPerfRulerState = persistedRulers ? persistedRulers.setState : setLocalPerfRulerState;
     // Changing the x- or y-axis metric clears every ruler: the curves are
     // redrawn in different units, so a ruler that persisted would measure a
     // ratio the user never placed. Runs before the draw pass so no stale
-    // ruler ever paints over the new curves.
+    // ruler ever paints over the new curves. Render-time adjustment is only
+    // legal for this component's own state; the store resets persisted rulers
+    // inside the provider (see usePerfRulerStoreValue).
     usePerfRulerAxisReset(
       perfRulerAxisMetricKey(chartDefinition.x_scale_field, selectedYAxisMetric),
-      setPerfRulerState,
+      setLocalPerfRulerState,
     );
     // Draw passes read mode/state through refs so toggling off clears the
     // rulers in the same pre-paint layout pass (no lingering frame).
@@ -944,12 +961,43 @@ const GPUGraph = React.memo(
     const perfRulerRef = useRef({ mode: perfRulerMode, onPointClick: handlePerfRulerPointClick });
     perfRulerRef.current = { mode: perfRulerMode, onPointClick: handlePerfRulerPointClick };
 
+    // Share-link rulers commit only once BOTH curve paths are in the DOM —
+    // same two-phase restore as ScatterGraph (see docs/state-ownership.md).
+    const persistedRulersRef = useRef(persistedRulers);
+    persistedRulersRef.current = persistedRulers;
+    const committedPendingRef = useRef<readonly PerfRulerMeasurement[] | null>(null);
+    const commitPendingPerfRulers = useCallback(
+      (zoomGroup: d3.Selection<SVGGElement, unknown, null, undefined>) => {
+        const store = persistedRulersRef.current;
+        const pending = store?.pending ?? null;
+        if (!store || !pending || !perfRulerModeRef.current) return;
+        if (committedPendingRef.current === pending) return;
+        const curveExists = (cls: string) => !zoomGroup.select(`.${CSS.escape(cls)}`).empty();
+        const resolved: PerfRulerMeasurement[] = [];
+        const remaining: PerfRulerMeasurement[] = [];
+        for (const ruler of pending) {
+          if (!curveExists(ruler.curveA) || !curveExists(ruler.curveB)) {
+            remaining.push(ruler);
+            continue;
+          }
+          const isoX = clampPerfRulerIsoXToOverlap(ruler.curveA, ruler.curveB, ruler.isoX);
+          if (isoX !== null) resolved.push({ ...ruler, isoX });
+        }
+        if (remaining.length === pending.length) return;
+        committedPendingRef.current = pending;
+        store.commitPending(resolved, remaining.length > 0 ? remaining : null);
+      },
+      [clampPerfRulerIsoXToOverlap],
+    );
+
     // Turning the toggle off clears ALL rulers and any in-progress selection
     // (the switch handler also clears synchronously; this covers programmatic
     // mode changes). `clearPerfRulers` bails out with the same reference
     // when there is nothing to clear.
     useEffect(() => {
-      if (!perfRulerMode) setPerfRulerState(clearPerfRulers);
+      if (perfRulerMode) return;
+      setPerfRulerState(clearPerfRulers);
+      persistedRulers?.discardPending();
     }, [perfRulerMode]);
 
     // Invisible widened hit strokes over every rendered roofline path make
@@ -1098,6 +1146,7 @@ const GPUGraph = React.memo(
       ) => {
         perfRulerDrawCtxRef.current = { zoomGroup, xScale, yScale, width, height };
         syncPerfRulerHitPaths(zoomGroup);
+        commitPendingPerfRulers(zoomGroup);
         const state = perfRulerStateRef.current;
         const entries: PerfRulerRenderEntry[] = [];
         if (perfRulerModeRef.current && state.rulers.length > 0) {
@@ -1148,7 +1197,7 @@ const GPUGraph = React.memo(
         );
         if (!dragHandles.empty()) dragHandles.call(perfRulerDrag);
       },
-      [syncPerfRulerHitPaths, perfRulerDrag],
+      [syncPerfRulerHitPaths, commitPendingPerfRulers, perfRulerDrag],
     );
     drawPerfRulerRef.current = drawPerfRuler;
 
@@ -1864,7 +1913,10 @@ const GPUGraph = React.memo(
                         // Clear synchronously with the mode flip so the rulers vanish
                         // in the same layout pass (the effect below also clears, for
                         // programmatic mode changes).
-                        if (!c) setPerfRulerState(clearPerfRulers);
+                        if (!c) {
+                          setPerfRulerState(clearPerfRulers);
+                          persistedRulers?.discardPending();
+                        }
                         track('gpu_timeseries_perf_ruler_toggled', { enabled: c });
                       },
                     },
@@ -1881,6 +1933,7 @@ const GPUGraph = React.memo(
                           count: perfRulerState.rulers.length,
                         });
                         setPerfRulerState(clearPerfRulers);
+                        persistedRulers?.discardPending();
                       },
                     },
                   ]
diff --git a/packages/app/src/components/inference/utils/tooltip-utils.test.ts b/packages/app/src/components/inference/utils/tooltip-utils.test.ts
index dd25ace6a..d90342a63 100644
--- a/packages/app/src/components/inference/utils/tooltip-utils.test.ts
+++ b/packages/app/src/components/inference/utils/tooltip-utils.test.ts
@@ -530,6 +530,28 @@ describe('generateTooltipContent', () => {
     expect(html).toContain('Click elsewhere to dismiss');
   });
 
+  it('caps pinned tooltip height so stacked actions stay inside the mobile viewport', () => {
+    const html = generateTooltipContent(
+      tooltipConfig({
+        isPinned: true,
+        hasTrace: true,
+        hasLog: true,
+        showPowerTelemetry: true,
+        selectedYAxisMetric: 'y_measuredAvgPower',
+        data: pt({
+          id: 42,
+          benchmark_type: 'agentic_traces',
+          power_audit: { source: 'power_validation_h100_conc8.json' },
+          run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/1',
+        }),
+      }),
+    );
+    expect(html).toContain('max-height: min(70vh, calc(100dvh - 16px))');
+    expect(html).toContain('overflow-y: auto');
+    expect(html).toContain('max-width: min(320px, calc(100vw - 16px))');
+    expect(html).toContain('data-action="view-power-trace"');
+  });
+
   it('does not show dismiss text when isPinned is false', () => {
     const html = generateTooltipContent(tooltipConfig({ isPinned: false }));
     expect(html).not.toContain('Click elsewhere to dismiss');
diff --git a/packages/app/src/components/inference/utils/tooltipUtils.ts b/packages/app/src/components/inference/utils/tooltipUtils.ts
index 254fa83d5..a4877ffe4 100644
--- a/packages/app/src/components/inference/utils/tooltipUtils.ts
+++ b/packages/app/src/components/inference/utils/tooltipUtils.ts
@@ -561,6 +561,34 @@ const pointDetailActionLink = (action: TooltipAction, href: string, label: strin
     background: var(--accent); color: var(--accent-foreground); text-align: center; text-decoration: none;
   ">${label} &rarr;</a>`;
 
+/**
+ * Outer shell for pinned/hover chart tooltips. Caps width and height to the
+ * viewport so stacked action buttons (logs / PowerX / power trace) stay
+ * reachable on narrow mobile viewports — `computeTooltipPosition` can only
+ * clamp top/left, so a taller-than-viewport shell would still overflow.
+ */
+export const tooltipShellStyle = (opts: {
+  isPinned: boolean;
+  /** Hex/CSS color; omit for the default border token. */
+  border?: string;
+}): string => {
+  const border = opts.border ?? '1px solid var(--border)';
+  return [
+    'background: var(--popover)',
+    `border: ${border}`,
+    'border-radius: 8px',
+    'padding: 12px',
+    'box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1)',
+    `user-select: ${opts.isPinned ? 'text' : 'none'}`,
+    'max-width: min(320px, calc(100vw - 16px))',
+    'max-height: min(70vh, calc(100dvh - 16px))',
+    'overflow-x: hidden',
+    'overflow-y: auto',
+    'overscroll-behavior: contain',
+    'box-sizing: border-box',
+  ].join('; ');
+};
+
 /**
  * Whether a point on the measured-power / energy scatter can jump to its
  * per-second telemetry on the Timeline display. Overlay points qualify too:
@@ -795,7 +823,7 @@ export const generateTooltipContent = (config: TooltipConfig): string => {
   const t = TOOLTIP_STRINGS[locale];
 
   return `
-    <div style="background: var(--popover); border: 1px solid var(--border); border-radius: 8px; padding: 12px; box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1); user-select: ${isPinned ? 'text' : 'none'};">
+    <div style="${tooltipShellStyle({ isPinned })}">
       ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
       <div style="color: var(--foreground); font-size: 12px; font-weight: 600; margin-bottom: 8px;">
         ${hardwareConfig[d.hwKey] ? getDisplayLabel(getPointHardwareConfig(d, hardwareConfig[d.hwKey])) : d.hwKey}
@@ -862,7 +890,7 @@ export const generateOverlayTooltipContent = (config: OverlayTooltipConfig): str
   const branch = perRow?.branch ?? overlayData.label;
 
   return `
-    <div style="background: var(--popover); border: 2px solid #dc2626; border-radius: 8px; padding: 12px; box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1); user-select: ${isPinned ? 'text' : 'none'};">
+    <div style="${tooltipShellStyle({ isPinned, border: '2px solid #dc2626' })}">
       ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
       <div style="color: #dc2626; font-size: 10px; font-weight: 700; margin-bottom: 4px; text-transform: uppercase;">
         ${t.unofficialRun}
@@ -920,7 +948,7 @@ export const generateGPUGraphTooltipContent = (config: TooltipConfig): string =>
   const t = TOOLTIP_STRINGS[locale];
 
   return `
-    <div style="background: var(--popover); border: 1px solid var(--border); border-radius: 8px; padding: 12px; box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1); user-select: ${isPinned ? 'text' : 'none'};">
+    <div style="${tooltipShellStyle({ isPinned })}">
       ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
       ${tooltipLine(t.date, `${formatTooltipDate(d.date, locale)}${d.actualDate && d.actualDate !== d.date ? ` <span style="opacity: 0.7">${t.dataFrom(formatTooltipDate(d.actualDate, locale))}</span>` : ''}`)}
       ${tooltipLine(t.chipConfig, `${hardwareConfig[d.hwKey] ? getDisplayLabel(getPointHardwareConfig(d, hardwareConfig[d.hwKey])) : d.hwKey}`)}
diff --git a/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts b/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
index c7cc0ad80..0e57efb22 100644
--- a/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
+++ b/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
@@ -917,6 +917,19 @@ describe('serializePerfRulers / parsePerfRulers', () => {
     expect(parsed.draft).toBeNull();
     expect(parsed.nextId).toBe(3);
   });
+
+  it('round-trips run-specific date-comparison curve ids that contain ~', () => {
+    // GPUGraph series ids stamp the comparison entry onto point.date, so a
+    // run-qualified selection yields `roofline-<date>~r<runId>_<hw>_<prec>`.
+    const RUN_A = 'roofline-2026-09-09~r27489075807_b200_fp8';
+    const RUN_B = 'roofline-2026-09-09~r27489075808_b200_fp8';
+    const state = complete(EMPTY_PERF_RULER_STATE, RUN_A, RUN_B, 55.25);
+    const encoded = serializePerfRulers(state);
+    expect(encoded).toBe(`55.25|${RUN_A}|${RUN_B}`);
+    expect(parsePerfRulers(encoded).rulers).toEqual([
+      { id: 1, curveA: RUN_A, curveB: RUN_B, isoX: 55.25 },
+    ]);
+  });
 });
 
 // ── pathXExtent ─────────────────────────────────────────────
diff --git a/packages/app/src/lib/d3-chart/layers/perf-ruler.ts b/packages/app/src/lib/d3-chart/layers/perf-ruler.ts
index ef13b2a1d..16c7284f3 100644
--- a/packages/app/src/lib/d3-chart/layers/perf-ruler.ts
+++ b/packages/app/src/lib/d3-chart/layers/perf-ruler.ts
@@ -331,15 +331,20 @@ const PERF_RULER_URL_FIELD_SEPARATOR = '|';
  * `roofline-path` / `overlay-roofline-path` marker classes or any other node
  * inside the zoom group — those match many paths, so a hand-edited link
  * would draw a ruler between whichever two come first in DOM order.
+ *
+ * Date-comparison curves include the comparison entry in the series id
+ * (`roofline-<date~r<runId>>_<hwKey>_<precision>`), so `~` is part of the
+ * allowed alphabet alongside the encoded-date `__<percent-encoded>` suffix.
  */
-const PERF_RULER_CURVE_ID = /^(?:overlay-)?roofline-(?!path$)[\w%.-]+$/u;
+const PERF_RULER_CURVE_ID = /^(?:overlay-)?roofline-(?!path$)[\w%.~-]+$/u;
 
 /**
  * Share-link encoding of the COMPLETED rulers (`i_rulers`). One ruler per
  * `;`, fields joined by `|`: `isoX|curveA|curveB`. Curve ids are the rendered
  * roofline path identity classes (`roofline-<hwKey>_<precision>`,
- * `overlay-roofline-<hwKey>_<precision>_run<N>`, optionally `__<encoded
- * date>`), whose alphabet is `[A-Za-z0-9_%.-]`, so neither separator can
+ * `overlay-roofline-<hwKey>_<precision>_run<N>`, date-comparison
+ * `roofline-<date[~r<runId>]>_<hwKey>_<precision>`, optionally `__<encoded
+ * date>`), whose alphabet is `[A-Za-z0-9_%.~-]`, so neither separator can
  * appear inside one; `URLSearchParams` percent-encodes both on the wire.
  * The iso-x is rounded to four significant digits to keep links short — a
  * 0.05% shift on the x metric is far below the ruler's visual resolution.

From 53c47d96f340e7e941d8679062a55811e949026a Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Mon, 28 Sep 2026 20:39:19 +0000
Subject: [PATCH 056/103] docs: link draft PR #1229 in PowerX UX packet
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：在 PowerX UX 交付包中补充草稿 PR #1229 链接与 head SHA。

Co-authored-by: Wenyao Gao <edwingao28@users.noreply.github.com>
---
 artifacts/powerx-1220-delivery/README.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/artifacts/powerx-1220-delivery/README.md b/artifacts/powerx-1220-delivery/README.md
index 2d900486c..d1a3904fe 100644
--- a/artifacts/powerx-1220-delivery/README.md
+++ b/artifacts/powerx-1220-delivery/README.md
@@ -4,11 +4,12 @@ Local reviewable packet for the three confirmed UX defects on InferenceX-app PR
 
 ## SHAs
 
-| Ref                                                   | SHA                                                  |
-| ----------------------------------------------------- | ---------------------------------------------------- |
-| Local base (#1220 head / preferred parent merge base) | `b07e1c76d6d2285a27e75bdda65a2d6276a7d1a2`           |
-| Parent #1167 (`feat/powerx-db-ingest`)                | `2c160b2e2238f926adeb3299754c714a2de2ceac`           |
-| Fix branch                                            | `cursor/fix-powerx-1220-share-timeline-tooltip-7b02` |
+| Ref                                     | SHA                                                                                                |
+| --------------------------------------- | -------------------------------------------------------------------------------------------------- |
+| Local base (#1220 head at branch point) | `b07e1c76d6d2285a27e75bdda65a2d6276a7d1a2`                                                         |
+| Parent #1167 (`feat/powerx-db-ingest`)  | `2c160b2e2238f926adeb3299754c714a2de2ceac`                                                         |
+| Fix branch head                         | `14b5bec620c643f233b560617ba576b9e57d6f3d` on `cursor/fix-powerx-1220-share-timeline-tooltip-7b02` |
+| Draft PR                                | https://github.com/SemiAnalysisAI/InferenceX-app/pull/1229 (base #1220)                            |
 
 Live API at start: #1220 `mergeable=true` / `mergeStateStatus=CLEAN` against #1167 — **no conflict work invented**.
 

From 20367a0d86cdb264c59dfaefcb8f82b96795d6a2 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 11:43:03 -0700
Subject: [PATCH 057/103] fix: key comparison sources by curve snapshot, not
 row run
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

An append-only run stitches new points onto an older run's curve. The
chart draws the stitched curve as one series, but the equal-service,
matched-concurrency and power-fit panels keyed their sources by each
row's run_url, so a stitched curve became two sources: the matched
table paired the fragments with each other, the fit panel listed two
partial fits and the equal-service panel offered three sources. Carry
curve_date and curve_workflow_run_id through rowToAggDataEntry and key
sources by that snapshot when present; rows without a snapshot keep
today's run_url and attempt key. Labels name the snapshot run. Update
the readonly-views and permanent-view docs and the API route catalog
digests for the two changed sources.

中文：append-only run 会把新点拼接到旧 run 的曲线上。图表把拼接后的曲线画成
一条，但等服务、匹配并发和功耗拟合面板按每行的 run_url 划分 source，导致拼接
曲线被拆成两个 source：匹配表把两段互相配对、拟合面板列出两条不完整拟合、
等服务面板出现三个 source。将 curve_date 与 curve_workflow_run_id 传入
rowToAggDataEntry，有快照标识时按快照划分 source，无快照的行保持原有 run_url
与 attempt 键；标签显示快照 run。同步更新只读视图文档、永久视图文档及
API 路由目录摘要。
---
 docs/dashboard-readonly-views.md              | 11 +++--
 docs/powerx-permanent-view.md                 | 11 ++---
 .../app/src/components/inference/types.ts     |  7 ++++
 .../utils/equal-service-comparison.test.ts    | 34 +++++++++++++++
 .../utils/equal-service-comparison.ts         | 42 +++++++++++++++----
 .../inference/utils/power-fit.test.ts         | 19 +++++++++
 packages/app/src/lib/api-route-catalog.ts     |  4 +-
 .../app/src/lib/benchmark-transform.test.ts   | 12 ++++++
 packages/app/src/lib/benchmark-transform.ts   |  2 +
 9 files changed, 123 insertions(+), 19 deletions(-)

diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 95b159ce8..d5d6bddd5 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -143,9 +143,14 @@ beside the equal-service comparison rather than replacing it.
 The dashboard and API share `equal-service-comparison.ts`: both consume scoped
 observed points after chart coverage/limits, before frontier and best-per-SKU
 pruning, with power-comparison clones excluded. `allPoints=true` restores clipped
-observations. Source keys retain hardware, precision, exact run, actual source
-date, recipe, topology and workload identity; changing display dates does not
-create a new measured source. Comparisons never join different sources into one
+observations. Source keys retain hardware, precision, source run, source date,
+recipe, topology and workload identity; changing display dates does not create a
+new measured source. The source run is the logical curve snapshot
+(`curve_workflow_run_id` / `curve_date`, see
+[Append-Only Curve Extensions](./data-pipeline.md#append-only-curve-extensions)), so
+points an append-only run stitched onto an older curve stay one source; rows without a
+snapshot id, such as unofficial overlays, key by their own run URL and measured date, and
+an unknown run never joins distinct rows. Comparisons never join different sources into one
 interpolation bracket. All three metrics use bounded numerical linear
 interpolation of the underlying quantities, then compute
 `100 × (comparator / baseline − 1)`. No log-axis interpolation, extrapolation,
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index b29c3270c..5eb147658 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -296,8 +296,9 @@ Figure numbers here follow the current article draft; the share-link table above
 renumbering. Below the measured chart, `ui/PowerServiceComparison.tsx` offers three opt-in
 panels, and the scatter chart adds a fourth. All read the chart's scoped observed points
 (`observedPoints`: official and `?unofficialrun=` rows, comparison clones excluded), keep one
-source per exact run and recipe (`equalServiceSourceKey`), and colour overlay sources with
-`overlayRunColor`.
+source per curve snapshot and recipe (`equalServiceSourceKey`: a stitched append-only curve is
+one source keyed by `curve_workflow_run_id`; rows without a snapshot id key by their own run),
+and colour overlay sources with `overlayRunColor`.
 
 | Figures      | Panel                                                                                                                                         | Switch (share param)                                                                                    | Helper                                                 |
 | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
@@ -317,9 +318,9 @@ source per exact run and recipe (`equalServiceSourceKey`), and colour overlay so
   not measured idle power, and R² describes only that line.
 - **Frontier** lists `globalParetoFrontier`'s own output, so the table is exactly what is
   drawn. Ties keep the first point, official before overlay.
-- **Source labels** (`getEqualServiceSources`) read hardware and date, adding precision,
-  topology, run, attempt, recipe, image or point only where two sources would otherwise look
-  the same. The opaque key stays the exact identity.
+- **Source labels** (`getEqualServiceSources`) read hardware and snapshot date, adding
+  precision, topology, snapshot run, attempt, recipe, image or point only where two sources
+  would otherwise look the same. The opaque key stays the exact identity.
 - Plots export PNG and CSV; the frontier table exports CSV only. Panel subtitles and the
   baseline → comparator pair are export-only, so a PNG names its workload and sources while
   the screen shows only the source selects. The views API returns
diff --git a/packages/app/src/components/inference/types.ts b/packages/app/src/components/inference/types.ts
index 0062297c3..904d1d9d5 100644
--- a/packages/app/src/components/inference/types.ts
+++ b/packages/app/src/components/inference/types.ts
@@ -209,6 +209,13 @@ export interface AggDataEntry {
   actualDate?: string;
   /** URL to the GitHub Actions workflow run that produced this data point. */
   run_url?: string;
+  /**
+   * Logical curve snapshot this row belongs to. An append-only run stitches new
+   * points onto an older run's curve; both keep their own `run_url` but share
+   * this snapshot identity. Undefined on legacy and unofficial rows.
+   */
+  curve_date?: string;
+  curve_workflow_run_id?: number;
   /** Benchmark scenario: `single_turn` (fixed-seq isl/osl) or `agentic_traces`. */
   benchmark_type?: string;
   /** ISL in tokens — null for agentic_traces. */
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
index 1cc0dffe6..b3b60a28c 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
@@ -162,4 +162,38 @@ describe('equal-service comparison', () => {
       'B300 (SGLang) · 2026-09-23',
     ]);
   });
+
+  it('keys a stitched append-only curve by its snapshot; rows without one keep their own run', () => {
+    // B200 TP4: run 35905882425 appended c1–c4 onto run 35843506474's c8–c128.
+    const snapshot = { curve_workflow_run_id: 35843506474, curve_date: '2026-09-20' };
+    const stitched = [
+      point({ id: 1, conc: 8, actualDate: '2026-09-20', ...snapshot }),
+      point({
+        id: 2,
+        conc: 1,
+        actualDate: '2026-09-23',
+        run_url: 'https://example.invalid/runs/35905882425/attempts/1',
+        ...snapshot,
+      }),
+    ];
+    const laterSnapshot = point({
+      id: 3,
+      actualDate: '2026-09-20',
+      curve_workflow_run_id: 35900000000,
+      curve_date: '2026-09-20',
+    });
+    const legacy = [
+      point({ id: 4, hwKey: 'b300_sglang', run_url: 'https://example.invalid/runs/7' }),
+      point({ id: 5, hwKey: 'b300_sglang', run_url: 'https://example.invalid/runs/8' }),
+    ];
+    expect(equalServiceSourceKey(stitched[0])).toBe(equalServiceSourceKey(stitched[1]));
+    expect(equalServiceSourceKey(legacy[0])).not.toBe(equalServiceSourceKey(legacy[1]));
+    const sources = getEqualServiceSources([...stitched, laterSnapshot, ...legacy]);
+    expect(sources.map((source) => source.label)).toEqual([
+      'B200 (SGLang) · 2026-09-20 · Run #35843506474',
+      'B200 (SGLang) · 2026-09-20 · Run #35900000000',
+      'B300 (SGLang) · 2026-09-23 · Run #7',
+      'B300 (SGLang) · 2026-09-23 · Run #8',
+    ]);
+  });
 });
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.ts b/packages/app/src/components/inference/utils/equal-service-comparison.ts
index a4f2fefa6..0fdf19744 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.ts
@@ -57,8 +57,25 @@ export const positiveOrNull = (value: unknown): number | null => (isPositive(val
 export const observedPoints = (points: readonly InferenceData[]) =>
   points.filter((point) => !point.hidden && !point.powerVariant);
 
-/** Concurrency is excluded; unknown run identity must never join distinct rows. */
+/**
+ * The curve snapshot a row belongs to, or null when it carries none. An
+ * append-only run stitches new points onto an older run's curve; the chart
+ * draws them as one series, so the panels treat them as one source.
+ */
+const curveSnapshotId = (point: InferenceData): number | null =>
+  point.curve_workflow_run_id ?? null;
+/** Snapshot date of a stitched curve, else the row's own measured date. */
+const sourceDate = (point: InferenceData): string =>
+  (curveSnapshotId(point) === null ? undefined : point.curve_date) ??
+  point.actualDate ??
+  point.date;
+
+/**
+ * Concurrency is excluded; unknown run identity must never join distinct rows.
+ * Rows with a curve snapshot key by that snapshot instead of their own run.
+ */
 export function equalServiceSourceKey(point: InferenceData): string {
+  const snapshot = curveSnapshotId(point);
   const attempt = 'run_attempt' in point ? point.run_attempt : null;
   return JSON.stringify([
     point.hwKey,
@@ -68,9 +85,11 @@ export function equalServiceSourceKey(point: InferenceData): string {
     point.benchmark_type ?? null,
     point.isl ?? null,
     point.osl ?? null,
-    point.actualDate ?? point.date,
-    point.run_url || `unknown-run-point-${point.id ?? JSON.stringify(point)}`,
-    attempt,
+    sourceDate(point),
+    snapshot === null
+      ? point.run_url || `unknown-run-point-${point.id ?? JSON.stringify(point)}`
+      : `curve-${snapshot}`,
+    snapshot === null ? attempt : null,
     pointTopologyKey(point),
     point.recipe_fingerprint ?? null,
     point.image ?? null,
@@ -103,8 +122,9 @@ const SOURCE_LABEL_WORDS = {
 };
 
 /**
- * Hardware and date, plus only the details that tell otherwise identical
- * sources apart, in this order; the opaque key stays the exact identity.
+ * Hardware and snapshot date, plus only the details that tell otherwise
+ * identical sources apart, in this order; the opaque key stays the exact
+ * identity. A stitched curve is named by its snapshot run, not each row's run.
  */
 function sourceLabels(points: readonly InferenceData[], locale: 'en' | 'zh'): string[] {
   const words = SOURCE_LABEL_WORDS[locale];
@@ -112,10 +132,14 @@ function sourceLabels(points: readonly InferenceData[], locale: 'en' | 'zh'): st
     (point) => point.precision.toUpperCase(),
     (point, group) => topologyLabel(pointTopologyKey(point), locale, group.map(pointTopologyKey)),
     (point) => {
-      const runId = runIdFromUrl(point.run_url);
+      const snapshot = curveSnapshotId(point);
+      const runId = snapshot === null ? runIdFromUrl(point.run_url) : String(snapshot);
       return runId ? words.run(runId) : null;
     },
-    (point) => ('run_attempt' in point ? words.attempt(point.run_attempt) : null),
+    (point) =>
+      curveSnapshotId(point) === null && 'run_attempt' in point
+        ? words.attempt(point.run_attempt)
+        : null,
     (point) =>
       point.recipe_fingerprint ? `${words.recipe} ${point.recipe_fingerprint.slice(0, 8)}` : null,
     (point) => point.image ?? null,
@@ -125,7 +149,7 @@ function sourceLabels(points: readonly InferenceData[], locale: 'en' | 'zh'): st
     const hardware = getHardwareConfig(point.hwKey);
     return [
       hardware.name === 'unknown' ? point.hwKey : getDisplayLabel(hardware),
-      point.actualDate ?? point.date,
+      sourceDate(point),
     ].join(' · ');
   });
   for (const detail of details) {
diff --git a/packages/app/src/components/inference/utils/power-fit.test.ts b/packages/app/src/components/inference/utils/power-fit.test.ts
index b4968f5c1..dc5a18b07 100644
--- a/packages/app/src/components/inference/utils/power-fit.test.ts
+++ b/packages/app/src/components/inference/utils/power-fit.test.ts
@@ -70,4 +70,23 @@ describe('buildPowerFits', () => {
     expect(fit.fit!.intercept).toBeCloseTo(307, 9);
     expect(fit.fit!.slope).toBeCloseTo(0.7, 9);
   });
+
+  it('fits a stitched append-only curve as one full ladder, not one fit per producing run', () => {
+    const snapshot = { curve_workflow_run_id: 35843506474, curve_date: '2026-09-18' };
+    const stitched = ladder([100, 200, 300, 400, 500], (x) => 300 + 0.5 * x, snapshot).map(
+      (entry, index) =>
+        index < 2
+          ? {
+              ...entry,
+              actualDate: '2026-09-23',
+              run_url:
+                'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/35905882425/attempts/1',
+            }
+          : entry,
+    );
+    const fits = buildPowerFits(stitched);
+    expect(fits.map((fit) => [fit.source.label, fit.fit?.n])).toEqual([
+      ['H200 (SGLang) · 2026-09-18', 5],
+    ]);
+  });
 });
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index dcd1a8a80..dd28e676b 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -845,7 +845,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/inference/utils/equal-service-comparison.ts',
-    sourceSha256: '9a7989e04f0228983f5f1069b8e35e221d85561bd95fdfd1ba9e4210f42bb0c1',
+    sourceSha256: '8341fe0a94e5ddefebc70938514bd7f128aa16aeb22a7aef5863f02ef383ab25',
     reviewArea: {
       en: 'Source-scoped equal-service interpolation, comparator-relative changes, endpoint provenance, prefill share projection and role points.',
       zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源、prefill 占比视图以及各角色数据点。',
@@ -877,7 +877,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/lib/benchmark-transform.ts',
-    sourceSha256: '21f1fe4d63737c74efb2251a64f79eef1b5e9c565769be9b4fb500b1fa4ecc89',
+    sourceSha256: '53fb9102b1ddd0c597b3b2a414894564d2deda3da5ea2cf0059f997b2db852c8',
     reviewArea: {
       en: 'Raw benchmark means and derived reciprocal mean-TPOT interactivity used by Dashboard and read-only views.',
       zh: '仪表板和只读视图共用的原始 benchmark 均值与 mean TPOT 倒数形式的 interactivity。',
diff --git a/packages/app/src/lib/benchmark-transform.test.ts b/packages/app/src/lib/benchmark-transform.test.ts
index 59fef0b45..c9b1ae00e 100644
--- a/packages/app/src/lib/benchmark-transform.test.ts
+++ b/packages/app/src/lib/benchmark-transform.test.ts
@@ -69,6 +69,18 @@ function makeRow(overrides: Partial<BenchmarkRow> = {}): BenchmarkRow {
 }
 
 describe('rowToAggDataEntry', () => {
+  it('carries the curve snapshot identity of append-only rows and leaves legacy rows without one', () => {
+    const stitched = rowToAggDataEntry(
+      makeRow({ curve_date: '2026-09-20', curve_workflow_run_id: 35843506474 }),
+    );
+    expect([stitched.curve_date, stitched.curve_workflow_run_id]).toEqual([
+      '2026-09-20',
+      35843506474,
+    ]);
+    const legacy = rowToAggDataEntry(makeRow());
+    expect([legacy.curve_date, legacy.curve_workflow_run_id]).toEqual([undefined, undefined]);
+  });
+
   it.each([1, undefined])(
     'labels run 35879254139 in the official/overlay legend without changing data (DB id %s)',
     (id) => {
diff --git a/packages/app/src/lib/benchmark-transform.ts b/packages/app/src/lib/benchmark-transform.ts
index ab974f8d4..3c7263a56 100644
--- a/packages/app/src/lib/benchmark-transform.ts
+++ b/packages/app/src/lib/benchmark-transform.ts
@@ -315,6 +315,8 @@ export function rowToAggDataEntry(row: BenchmarkRow): AggDataEntry {
     date: row.date,
     actualDate: (row as any).actualDate ?? row.date,
     run_url: row.run_url ?? undefined,
+    curve_date: row.curve_date,
+    curve_workflow_run_id: row.curve_workflow_run_id,
     benchmark_type: row.benchmark_type,
     isl: row.isl,
     osl: row.osl,

From fc53c6330a467d34a6104233e34f8a768ba4fbe0 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:13:13 -0700
Subject: [PATCH 058/103] chore: drop committed acceptance artifacts from the
 PowerX UX packet
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

artifacts/powerx-1220-delivery/ held the agent's local acceptance record
(README, verification report, two mock screenshots). The repository has no
artifacts/ convention and the evidence lives in the local handoff, so the
directory leaves the PR; source, tests and docs/state-ownership.md are unchanged.

中文：删除 artifacts/powerx-1220-delivery/ 目录。它只是 agent 的本地验收记录（README、验证报告和两张 mock 截图），仓库没有 artifacts/ 约定，证据保留在本地 handoff 中；源码、测试与 docs/state-ownership.md 不变。
---
 artifacts/powerx-1220-delivery/README.md      |  44 -----------
 .../VERIFICATION_REPORT.md                    |  70 ------------------
 .../mobile-tooltip-after-scroll.webp          | Bin 36586 -> 0 bytes
 .../mobile-tooltip-before-scroll.webp         | Bin 36852 -> 0 bytes
 4 files changed, 114 deletions(-)
 delete mode 100644 artifacts/powerx-1220-delivery/README.md
 delete mode 100644 artifacts/powerx-1220-delivery/VERIFICATION_REPORT.md
 delete mode 100644 artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-after-scroll.webp
 delete mode 100644 artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-before-scroll.webp

diff --git a/artifacts/powerx-1220-delivery/README.md b/artifacts/powerx-1220-delivery/README.md
deleted file mode 100644
index d1a3904fe..000000000
--- a/artifacts/powerx-1220-delivery/README.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# PowerX #1220 UX fix packet
-
-Local reviewable packet for the three confirmed UX defects on InferenceX-app PR #1220.
-
-## SHAs
-
-| Ref                                     | SHA                                                                                                |
-| --------------------------------------- | -------------------------------------------------------------------------------------------------- |
-| Local base (#1220 head at branch point) | `b07e1c76d6d2285a27e75bdda65a2d6276a7d1a2`                                                         |
-| Parent #1167 (`feat/powerx-db-ingest`)  | `2c160b2e2238f926adeb3299754c714a2de2ceac`                                                         |
-| Fix branch head                         | `14b5bec620c643f233b560617ba576b9e57d6f3d` on `cursor/fix-powerx-1220-share-timeline-tooltip-7b02` |
-| Draft PR                                | https://github.com/SemiAnalysisAI/InferenceX-app/pull/1229 (base #1220)                            |
-
-Live API at start: #1220 `mergeable=true` / `mergeStateStatus=CLEAN` against #1167 — **no conflict work invented**.
-
-## Defect status
-
-| Defect                              | Pre-fix on head                                                                                                                                        | Fix in this packet                                                                           |
-| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
-| (1) Run-specific ruler share/reload | **Reproduced** — GPUGraph kept local ruler state; `PERF_RULER_CURVE_ID` rejected `~` in `date~r<runId>` curve ids, so `i_rulers` never round-tripped   | Wire GPUGraph to `PerfRulerStore` when `chartId === chart-0`; allow `~` in curve-id alphabet |
-| (2) Dates-only comparison Timeline  | **Already clean on head** after `12de0af3` — range-only (`i_dstart`/`i_dend`, empty `i_dates`) already shares colours / per-date legend / solo toggles | Regression component test only (`follows dates-only range comparison`)                       |
-| (3) Mobile tooltip action overflow  | **Confirmed by code + demo** — shell had no max-height; taller-than-viewport pinned tooltips overflow despite position clamp                           | Shared `tooltipShellStyle` with viewport-capped max-height/width + scroll                    |
-
-## Findability boundary
-
-**Out of scope for this branch.** Footer / findability / metric-unlock work is owned by `refactor dash | powerx dash` (child of #1220). This packet does not touch nav, footer, metric unlock, or publish gates. Do not merge those changes into this branch.
-
-## Evidence
-
-- `VERIFICATION_REPORT.md` — commands, results, remaining merge blockers
-- `screenshots/mobile-tooltip-before-scroll.webp` — 390×844 pinned shell before scroll
-- `screenshots/mobile-tooltip-after-scroll.webp` — same shell after scroll; all actions reachable
-
-## Reproduce tests
-
-```bash
-export PATH="$HOME/.bun/bin:$PATH"
-cd packages/app
-bun --env-file=../../.env vitest run \
-  src/lib/d3-chart/layers/perf-ruler.test.ts \
-  src/components/inference/utils/tooltip-utils.test.ts
-bunx cypress run --component --spec \
-  'cypress/component/gpu-graph.cy.tsx,cypress/component/power-timeline.cy.tsx'
-```
diff --git a/artifacts/powerx-1220-delivery/VERIFICATION_REPORT.md b/artifacts/powerx-1220-delivery/VERIFICATION_REPORT.md
deleted file mode 100644
index 6449a051e..000000000
--- a/artifacts/powerx-1220-delivery/VERIFICATION_REPORT.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# Verification report — PowerX #1220 UX packet
-
-## Preflight
-
-- Repo: SemiAnalysisAI/InferenceX-app
-- Checked out #1220 head `b07e1c76` on `feat/powerx-article-parity`
-- Parent #1167 at `2c160b2e`; GitHub reported CLEAN/MERGEABLE
-- Sibling fix branch: `cursor/fix-powerx-1220-share-timeline-tooltip-7b02`
-
-## Reproduction notes
-
-### 1. Run-specific ruler share/reload — REPRODUCED then FIXED
-
-Production/date-comparison path (GPUGraph) enabled Perf Ruler, clicked two curves: URL never gained `i_rulers`; reload dropped rulers. Code cause:
-
-1. GPUGraph used component-local `useState` only (docs previously said this on purpose).
-2. Run-qualified curve classes are `roofline-<date>~r<runId>_<hw>_<prec>`; `PERF_RULER_CURVE_ID` was `[\w%.-]+` and dropped `~` on parse.
-
-Fix: bind GPUGraph to `PerfRulerStore` when `chartId === PERSISTED_PERF_RULER_CHART_ID` (same two-phase pending commit as ScatterGraph); expand curve-id alphabet to include `~`.
-
-### 2. Dates-only Timeline — ALREADY CLEAN on head
-
-Component test with `selectedDates: []` and `selectedDateRange: { start, end }` (the `i_dstart`/`i_dend` path) already shows two coloured traces, plain date legend labels (no `#N` run numbers), and solo toggles. No production Timeline code change in this packet; regression coverage added so the path cannot regress silently.
-
-### 3. Mobile tooltip action overflow — FIXED
-
-Pinned tooltips grow with stacked actions (logs / PowerX / power trace). `computeTooltipPosition` clamps top/left but cannot shrink content taller than the viewport. Fix: `tooltipShellStyle` applies `max-height: min(70vh, calc(100dvh - 16px))`, `max-width: min(320px, calc(100vw - 16px))`, `overflow-y: auto` on scatter / overlay / GPUGraph shells. Demo screenshots at 390×844 under `screenshots/`.
-
-## Commands run
-
-```text
-bun --env-file=../../.env vitest run \
-  src/lib/d3-chart/layers/perf-ruler.test.ts \
-  src/components/inference/utils/tooltip-utils.test.ts
-# → 173 passed
-
-bunx cypress run --component --spec \
-  'cypress/component/gpu-graph.cy.tsx,cypress/component/power-timeline.cy.tsx'
-# → 21 passed (17 gpu-graph + 4 power-timeline)
-```
-
-New / extended coverage:
-
-- `perf-ruler.test.ts` — round-trip `date~r<runId>` curve ids
-- `tooltip-utils.test.ts` — pinned shell carries viewport max-height/width
-- `gpu-graph.cy.tsx` — serializes run-qualified rulers via store into `i_rulers` form
-- `power-timeline.cy.tsx` — dates-only range comparison legend / labels / solo
-
-## Files changed (expected)
-
-- `packages/app/src/lib/d3-chart/layers/perf-ruler.ts` (+ test)
-- `packages/app/src/components/inference/ui/GPUGraph.tsx`
-- `packages/app/src/components/inference/perf-ruler-store.ts` (comment)
-- `packages/app/src/components/inference/utils/tooltipUtils.ts` (+ test)
-- `packages/app/cypress/component/gpu-graph.cy.tsx`
-- `packages/app/cypress/component/power-timeline.cy.tsx`
-- `docs/state-ownership.md`
-- `artifacts/powerx-1220-delivery/**`
-
-## Remaining merge blockers (#1167 → #1220 sequence)
-
-1. Human review + merge of parent **#1167** (`feat/powerx-db-ingest`) — preferred first candidate; this packet does not change it.
-2. Land / retarget #1220 after #1167; then run **master-gate** suites (full unit + Chrome/Firefox E2E) that feature-base CI currently skips.
-3. Findability / footer / metric-unlock child from `refactor dash | powerx dash` — separate PR on top of #1220; do not block this UX packet on that work.
-4. Production DB Timeline telemetry still returns 503 on prod (branch/preview DB has coverage) — data acceptance, not this UX packet.
-5. No GPU work; skipped remote checks are not passes.
-
-## AI / env limits
-
-- Vercel preview for #1220 requires SSO; local `DATABASE_READONLY_URL` was not available in this cloud environment (secret requested). Browser proof for Timeline/ruler used Cypress component Electron + a mobile tooltip HTML demo, not a full Next.js + Neon session.
diff --git a/artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-after-scroll.webp b/artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-after-scroll.webp
deleted file mode 100644
index d5ef5dcdd028d4972080523c37d5dc752de23942..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 36586
zcmZ^~b9AIn)GgexZEIpX6Wg|JJDJ$FZD(RTnb>wFwrzYf^LyXBzWc{rt5$cf?y9Fw
z?Xzp2UHx<`N{EW?#sC0nB7*X&@*IRqe_k&b0cQhI0l)}B000*7i_z?gn<x%my)U0n
zOWaQ1@2OhaJXpSgS+wa}x=SdVk5gC$p?2inTsU0_?*P7DPo=Er0)%P4wR@gpp+~!C
zpTc{g?{Mpvx361Ip1q6o<Mh?Heot3zIjz3uug9PLpFN*nl^CzpwVNh<MPJh&rBCJW
z=}$GEBnu#K(=T%BUn&H*K6&`ATN!%rxraShpQoN`uYSJokK-qLcL>*dTOTy;I?u7U
z1TA{IJUq8H7hhYxj(q*^^FB7o-Ge^W4_q%_I|#eJ0guV=xo<VsIXs^(Z?SLFS6j(j
zL<Fh6Y+n{14NFGnU$<XHUq-tJb-w){Wsfiq^QT)+U!(40zPTSyO9)e6ZN8&l<kukY
z%Ww4W(`r4VzI$J!Z(pZikFmEsk39oE*4}<!+@F(QLhov?vFm!pHD^7~Uq9cE9v@!y
zUiCipPP&15^1poUPrtstDz~?;%)Y)p_z-hjx4ypa@O<osN5y+Hxl5wFM)zb2jQ$_Z
z0758`>DbyRDac+k5skYi5Xr<8v3ar9&r8J#-*u%TRmCVlW4I_iu^==OUO7?4RjKKb
z%66s^*F&PBgSOE~PB@p`q=nZ9F%bDrw~WgA^~}my3+WD)y4C*0r*i#PSGt45kcr)<
z^XSyaH>M?stf#k3sS6ddUf`$x#EsM2$mV9u>pADM@O5`3zkCODEhU~XfpD6=Ir7m}
zo9Wyj!hsZrePOEe=E|#Ih=x)e_kUv0ayr_9WF*b<kiaS*o#Z1?LLXCR#@@<*FRXQP
zgl^#al?$^&=^c9VhQ9{r*)Hc+l4{a&cI5UB+D0LaQLKNlKQZb-8%X^=MCMVZF1Uvp
z0ys1mg!@qWKNFsiRh%~;P5<8$GQ1f`-GB~I^lG>ga?$22+yWu`t*OSSZ^3;id(?YY
z+<tA=@w1gRkxqhh^!ARi$kxq_zsB@)2bHn#aQSI{HJ<iJ@E2Hyh!o|b-q^mW{5BB-
z#pxF%4T<q}rEMB(Qw?}yk+`fpg%bT1{tGVq2Da>gmq{QBt78FMDp!-9Dw-3y&Q38J
z?9%m4^k%@rzA6EO(gL$S^SLFuS3j$03nXG$ARCSQs*Au()4x<uw>PKEJX8T#c6P%e
zRbbo9HYw?R6p)QmXl#;7uB`f8d3CuPf7N`GM9O{E_C9p`&Z!cein5k*kEy;mF7U1Z
zF9aA7Jkol^7OVEPX#a(8Aoy@TzuvY4_$|*W?c%Hv$1;NkT1dec;K0J!Y(iR3J|c*c
z73qmIp~su7gE9RQ<cz`xgcY(mUTvn8%mh0a5ImT}*?FqebYfW*Pr6m-kp!qhQf@s!
zI+@Cvokiyn6PRpXel{Wl{GO^C68LrllCV-cLEh0-@ce3Bc%L}2;teQB=~2Hi0!1?-
zjmO4Emu({EhC@4r{P;fEdAfR!miyR+UQh0{uXS+mduxzl>Ve+i<zzAXNf|u3Sv>Fp
zv{~lWQqwJ-q8J;y0L6md1`?lPr}EOel@cv%q|jZ-V&nQ@8b<W&r@QlpxmZ8m;jT?s
zn%X|1w43P#X@o3ym(k&hJpLn!iMc!2B;4NDGk`m`L}f&O=>|Fsf#_;mE4k1N0d>%`
zN&p_t5iKKqU-Ld&Jur#qNas~A-&0kNe|o%W;DF;E7{LFiw_mm_x>BpnR|Zl{rxHTd
zow>bK7gGyn+GW;1z>qTKl9k9GY@=d>-E;~(NP+J^;xqFZ2I`8ZEzPm!_ayE`YFv3%
zd&9sztqfDFNsYQ*f~sA#m0ycEZEo7B^ATCgIkRQZUf^2t)hH?D-Cll>!}5F^l|u)y
zCe4%*`~x1*1hGfcBb1?>%4-2;(QZ70Q6zk#&ONJxM!X@GGZnzJ?p$a-JdwjH5#5m}
z^^B@aC9d~zCIrM=4v8SO!j-5l#N8F8P|Y`vf8&(t8l7|6-SMOf-Rk$*A4nd}wx}&d
ztk;N$<xKm-YW`3T+a^kxw^c;AT84|*q}68~Md-3^{AtbIi%t(l<qNV0nNfF`TU}va
zln^BxXc3=qcDW<KT9Isp2`zAsweQsEj7TG5uw>33Mh$t)o4EX_s&RtbqEXtS(f>_$
zjq#2=>k3CVm&twJT40qVxj-YO=(z3RY2F&QS#ug(F8h+Q^-kjhwLg73Erup`O@BHY
zck1eSb6g1oI)G%>YRyY{M@Rrl6x<FUiUrSyT%c>Z!+_L2)Ari^y~_oXK}__%O8=&0
zma$|G66o*KtVrQR4$B%D%RWGQ21adScJO*15P%0iVqww7$=@Qje-by)UAMn_WP|yV
zI8@mRk3j3;H6ACFh;4&{ZIju{IEAly|K}4g&}yfyG8MV>ziZj%6UI@poo!h0uJyt8
zF8yz4DB0g>{<LG1z;9&;=Ny05XoFJ@f)y34*0j#in@;2{DH{VCn(X0ErYWbVKCDI@
zjni%YgakC#O?x{4bUg(6XP!*qDG-}Nf<I%;)5iUK>tie`hRlDkg-8EsYOYFB)kfWn
zn9%VI$Qu6wOG1zR*Y!{D+VNgGIP5kRUgJOOXZAO4)+1@+!rG7DZ9E#&4ank2$J_52
zdPopQNIIIbg#Q6#{1nIG1Ofgh-zXe#&Hqz%_&$L^1d=qj|CONPog49k%yU9PmgU*0
z@R65s`ExEi!@szoU{|lc{!g9qjl9J27pl?t$DQi)B36HiYOTo4niW82dtkXD5?J47
z*WZ}tzyklW?axXgI6`^9|J+)!|NAZ^)!?@T;Sq;0unQP`G0$C8Vm7ep5;&>XEpms2
zDL)~-OTWCII^ll_ByHJYc5?UMH8vj1CR85=YW4ntKP)wXtEWh}dZoZaA5{UbE*vf^
zDuZYb!XiNQFAWwTkJ*hzf2obaja}U(HUA&NHaPj?asD^&Y(DlJC<n0k-5Xu1WZYCG
z4$;WV|8T)06Hfbs?4Pzc-0*NP^KZLE(8|PM(r&xwr4!H|_#^e2&nLx{KF-FbbN~Os
zTc5GO1o<~|J{{s0we|3AJLr;_(E$K>aYFlP^dAgyd=~4X|7B|g)Pyf<=b%O|UBJ@%
zvyZ^RD`9a`fT#>uZXXNinPM$M7)|RgAe-9*A#b9UZ@Kg@rTJ_B;`f*0;?3`>k3ar$
zXDDlgS4gecJxh(tV-ajlS}P{4-AFOBbC$9;>W=P|zH1y`U5HB6wlUTl4elSQvcUf*
z2FA+oML6f{e`SPaUGzA79fdQb#fRTF#@qucf29Cbky)?3`~s(|D@2|Qa<74y^Tt|X
zgigHtbIBw6KZsnX|Eb3xdUQKfR73;9|AfXkcLO8KN;3w7OX|}L?s4EM<Nodq!=yiD
zZYDc>nd2S$4`=q)|Hb*Dw`@eU;vcijfX5<ELF`i&No`bBnZ7|J)OyHH3b3A>!k)o@
z0YwC#K&c$gB#!>$Lrf~cKQ_%W7VFAb$9T(s0)P7pM`Z^Y)2X)et2hL-uweCI@Qd{J
z935ZnUwRiIthxS8+8<io>`i_{{RibAHcomj3_QAZ<$rc7({$F<e5~Yg<VhT0tOh_;
zKDOVL)rbB%;7&G>t+{fH?)#fC?#&(K|1oRz8V<hX|I~(4mk`CMD1`;}`j7Qlvu3T>
zG({`Y_BH7HlO%D1#*6<pc>0CbB-W?>?Vo(+H3^a8v%Cwet3wB;dLd%{3cO56nqI9X
zs%h|mlF%6WCr6G#;0{YOMi0=*-T^IWA~*7CuKqcKWhNv)f+YSj>U*3=ok4(WX{rd9
zo?%&lE&)q0BAJ=SKlQDoq@T?&q!r4wInYb%EHMNUF+u}n{Oj9f{@EyhX{}o>J^PV=
zT9#@4yHjoS%_bY6VoURdr08WN%~Lb-XyNm(en*|}lOayy$L3RVJX<cNtIoZI!|&+l
z&SXyb=9k*6vC+~E^;l4;d9|+{QZ#dIuwVqmZ`~0TgZZlKnN|^ly~`dr2O!qdiiqT$
z%(?BA{R|mrz~{hr!sa5fXhAk%RH7)Em8`B^!B%YX{m5^_|EtHNd&N85q0LKk@?tMH
zRINX!0>6z7^e#Jb{^yikqOrZg{7R*j92CTvYm0=qWof>`qM4SzX9LpHvCak%adp#_
z(F1z0bRE_=vC0=xFt}zAgxeuJw5u(?5&x#I^$h$!2u1`vBgW@TvKS%P2ALK(jS_EQ
z509WYvxsqI7){pefPVi=>XMZZmkdwAZ`H9jUW3m(H44Y^KZK%4BhUNR=12g>pe<F)
zCI4-!HFmz}<^v4V?=MnjUVze+VtC9^^9jlS5!kc>c5D?=m}#s2%0hzbJF(_YkGHJq
zKygE!@m4R&|8|vIkNDy5LbJA{M$&(kXqe^EeHhe!t0MZH3A#pVZ_GSRXRuaIzzI|O
zomwWUau;q7Vt>=ANn!u@NjRm`S?#bVQmf5FbSVJ)lBC~-Tl?3<?`8A)9>$`Atv*BE
zSaCvf+Zl-jC%AUz0`2yQdSQ=7)-KMV{}qD9gQh={`@br&Tx&pk?)KHP&fpew9u1|^
z^FqrgNLmt1m%e9#Wyit?`rWgATiY!RN=c3rWic*50BFFAm4H3%zwMp&>1~qR*)S)=
zYt?q8vy}7S5huPXnrP@T8uzx?vVGef&klwTzr+P^@8~Mi*>2j!G^+&zCV^w#yi8Wy
zF)J|zW{(6x9UTNv{O^RMvH<}RF*fS-D9HktXiGY!_0UHN<BJ!F_@pct%AwmD{pHb{
zJMl!rxuLhsK8*%h>GQXYSTwqE7h-#kEHsgWFR!u2l$Z4nX#3kS3)K4P%een@3nQwK
z&<q$D>TN1GwEvX?x}cNu?p2a9rr8s+0#-=bk;nC@!++Ihs8n^w+_HN|o1xX%q0D#j
zT7hDn-siJ;P2)@n;_r@$W{Ve2wL;Jp$1qU&J#K;}jokhpak~nIG5YZnEUP0eCk}s;
zb4~s0&C&U~NA4e>2}(BD;N}nt2W*K_TaAcL3gZ;)1dxjN_K;+V^0j;M`D>zVF3!iN
z??O}lRoK6^fNAufi5SW>z%)c>YEH&{Zo(3GQ=BN3$M<d8PrqVe>0>?Z(oIR3{!cmo
zRic0H;$Jz)pqUdrY>PoP2J5uYC@b>Bf})ymjHXptH57jFv`rcWsOesE`9TgfJsi2P
ziBhd1Ja^_(b74q?TFgi2->~+Il-(lz_)pUQ;rO2;`uoUv0O+~vvM7=w-7sFsb1d>v
zWKH|>Fl*ve85ZEj`u<PGm8vWK;kg&eLR|(3jVnMvP^HTkN;`~w$wQC5Ru%r7AQKM)
zAFxhYZs76z*>WgW^smEXmTH4gsb@kuNm-IZ^+DH8s`jS3<w>RiW3dyZETHuvn-+Iv
z(w;Kn9NNM4+^w^1=>{OK=%nk+gBV|v0Q~aEfwS>b2OU<7b45(*hO6wk;K9n_AFpxQ
zGd&!E<%^s1<LRZ<xJ4rH((z!Gs%*?775zF7#Axl!J3IDKyGSHj`mh@duT;64S<~d)
z1fJR8W+$chIh-UW4&3c9Yp)LR06F=J)z4gaG66)UX&bD%zynN!auK&o8X>^w!4vWo
zPQ9&q(=RV2hqPNC@EJ>fB}<mfi#Bh=hd;jIs4sU=^VMs{5}@3ZXAs!1Y<r%GYTq`D
z(;Y-oAKY@VYpHoIl;^AB{W}~P{A%#HY<i5TM@FQ<o1RQkTH3$Cs|kUSaY~hESh3l>
zw*~lE-^#Toq@W4!XfleG&7ObVpUxuf!u=*dvNkuKIfHRh)>Qp4^YUF=f6FhP&ND1<
zhNBJseheE2s)dJVv8MF%BIW#(-%{DTw)EZSLgLf18j0sO3Qnz(g9E&UoWGjFyL;53
zrE{FH*E2)Obt&nOhe{exO`#^H>{~<T+0y!9<={@6mx=kk#5``Z7<OniP-Gds{2o}g
zi3$k>Cc=3{#yf$|VP_nzckY)!bZ_n^kH}OTEIqNaEou&LIC)Q}Fz)ny>?^60O#g_o
z<|}r;?G8+iBlja`F^t=1qU4+!pQNd1FBt=Bm-FW9KyS_Dnx=GbamWDG?osiG7KU7^
z({xRsbKPosQp-a78uhIV-^P^0v}d?@k!nrskm4VmK35iLyhTZvAbCEMRJkL@kurKT
zXsN-(KvEyZcvy+c^-pQW!oSIuJbs1`kte$Y0I!37_IH}P69KbfSH)mX1BcpY@K&ro
zcCK0zYcl5u*}LRf=Y*Yr8(02cAc32BC$L2bIRi2BpD>zF7kbEiM>ih>GuYZZE>NF?
zSe?7Ml2UoWHTaO7!=!{3shq?oxQd8lJeU^DplK28uFDgClJ(;K9t=t#{((JM`riRi
zVH*H|IW@j_&P}^e`D2&7S#`lP^hdbHHA;l%1<sZWwRrLEQ<2QjdLis;FyaqYucqC5
zvo;)!E?_9m?2k*%n>1gfmQpSG?8W>wEaYCh?kA$)<<~~?)?Txa>b?Et86`;wx~}EJ
zyQW%N=pDufiSa@CBqrr@+Pf_@*$wWDIk@y)MOpI$=}K|)#y){yg&HI#ZmR48%tP7f
zGcAADt_n8Efp^;uUBPc|+OPV6ZY#@lnaDbb>|Tnp%!eA!NJ5axB4N$w4dcFPDB1aq
z5B7+R-j{)1*+6!j3oWll6~Eq$)9($Od*?t0#v&e2R(?AA?DIbnR%3b=*?9O>GYE`y
zd-_IzwqHavB>Jmi*}41lzg_?QuuIyZ=w(e9x5lzl`^?U*HX%h-JBQ6V8;Wk-fL-#i
z^4h#u24^a~2gS(&k!w&RiZEhzJgaWTt&YlYy_%#}f3YGZ(6|G;tVBnrAK#x|MzYF1
zPGZe$9IAN@_F62PbXi_Vo(-`)C#!s(p-WL4qSQdUZ+(4Qp^pzcbHi$l0(*&NsE%Nn
z*__rHtOgCv_7GxgT9EDbVZyahI`2==30Z^6RNd{6HD5i;={5=Fp8T{my%Od*xMCdP
z{04nTJxO8Q3d4o$xN;PFd~FoH+#};A9NQTx&7JH+X8>1MJRpWlgI0(7uv2B@+oM0x
zb58*gbmL>%<#m~VKtd>@Yr!N<3in9GSwDyz5c*L(#E%DM*w=4o)`G;JUtpIx20w)J
zWOVx}ajW^7w&u||rAh)KTqHqX-<OhI6DtYw${W}RDkNfShr0E7!&6m!E(Pw352vld
z)8zfQbOZ{il6Mf^8rJ{SH{xr~&yHTI7Vr*dc~*3Wom!ounoh82BX7G8oFtXlCa`^(
zmx3W|BRfC2)xW;ZyfpNcSc+pZ(E|iTBR6)$sbu_;ynUX^po>|nW*hm7@u#}n_-6Ju
zFukLM6j5&lVsSfOOHp>rb7-O8gdRU556Bu_9_N4E5m$TgW4uKw4HitFA8b}9J&(#Y
z`UF-3zHyhwmNf&UBewOr^l}+{<!^KP6+C6`KdXC)rp7*P<Ff;)U<cTmSg)^|w-#>H
zwm~Y1nqfW&?jmD)XP@{K_Ob<~sYg|eI6*Jcc|WdawE%h#5qJyrHJ=hgmsi2j;M|4h
zyQf=HJJWi}T`XBVomj)*1G;(Uxu&tqHgXZ9-HHwCJL1}DzJc2}oBkE+CUrJ*9+U%h
zmYPN?kK$M;)Iw2<#*VC5XmV`;_#>tYy9tdFm7(lNLP8jZK>uc7X}urB&Uc=j#d=~2
z1<qMh-~_X17SnK~+rPmFU_J&aH;WvuctDSIy8Q=fa2r3T27IRWOGX~#64ItcPmn@C
z#)(4bOW(!w8@0kS*{oM*u+R@*r{q?L_e!}mJ-F{mKtgN}=^nDU^XjY1uaWI>Prhpz
zj|fJGQA=>~d1u-h<~YH)oA9B|=w-CL+oW?#E=7(Fok7SOB-AVz4C1g9+~)K=mB4<S
zfxiw?e&w`6LyBi*3Nj-RLoC5!?yEc|6tbgU)yq(weGs@wrbvLYx>ndE&ShIq-$iug
zd;Q|H?tRf0nWHwqg#J+L9_=s*#rptza@XbCL(mACxnC5WsG3=Gx8DlApM5x+%d3WE
z#xUFztAB?S?2qRY8*_@~#?6kj_&7l%IOM3urFAg%dy#CpV@okHN$YA?JSX%Q!8%2Z
z1iJtb*_No<Y9pZA$!Q;{M5KOrtj7|RvjOO0*Dt(4dVF6_m?xR?CO`Ixb)(^02IA|~
z!y-kjD|4vGK)RM}3W!pO>Dab_5ciJ{ob{vYF3A<0NOiOqs<n>2Z<+fb1)dpQQwi&h
zjYGh$;(7oUOuo+(`9F5%7IzqyV#3r+7E!*1?q>K&nZ`^k-3^=o>hV|rIXC!#8<}Gu
z5pr(TcG*DT>Ystd{Y01D5UGIf1`3_E9)SWib-|&q?tA}W2c_mf;ToLc)#75-69eKX
zd<wRoo_$XWJmC8}dJEaK&^+Xjz;>(YT|L>#2+hnp?t$D*l5^2O3!6|!Df5aGUUbVO
z!`Th52(HGc=H_XbPD%d7OEvi}B=@fP#A29okF+#{HM}VwAOOR4Pzu|b`}fX<BmFbJ
zyq8R|6rn&BaMV~$z#$r3l}zrk-_frgZu`7-5{C$(<_Kin^8|44P#$_*0m^34-E|ri
zCx-h-P5EUgR?lS%7J0!8I3kJq6=rteb*pYv)*->yCRmqtp?62*Q&(lw)A=i(^7bxC
zEk+PYsjx{z7HQLWebs3k1QM<p&7M7b`D@y{AlAFu;p&Q*U1ZP6E&F)Q`)@K0nT{Ij
zJiTx-lH(NuJvcmLTRl5FHf^&&=f287;O~?#P3AXSNSVdRa=$#M^%5TR9Ro(LE4XMs
z1>P9_sBXI(%q(H1_qC)*#fEW#4fvcp6+wQ)%YQRXegizG5D=lBw5r{YSW%vCieZYF
z==f^~3&zT;>;nCShe}gGmvH+zWw+h+tAXkh<m-h0xd2q@;N^@CZWO_!&)Cb*5C-Bp
z?+T))nFEn;Kqh{%%Xu<7Z>HF~E4u~GhnOdf>$IZh<=t4+racfragA7L0!-W3fej-|
z*Za&{C0&M4tKEHEVB^rlyr+~`TI*7Eshcv>&XOwFhR~X)By7PAZy42W<vPWeuFX!P
zcao_m*+14T7}w)9u=MJha5&tz@wP^3Z8sw|X?$5*Z6#svQAALR0#m;xUMklI2{ec4
zH8!h?p!|;Cww)RH*y!hIiG>ju=!jDV88Q@Y53PV6oj#7a@)BOoxL)Y~q<~&%dB&hK
z;`EI%AN|3nd!JLS-?+=jQAdo#I%g>wa`+0lz~eqM{-@jEO{>a}vMO(+Tf4l92>>Ci
zlT`oZn9?h{8XvKpWS>8ZGR_1ImqFP06sMUNmc?=@Ipt9}W&rD}wCfz7|F&-bVYg?<
z)ozLU8(n6j-288z=zYCw*YVWb`kiX_Br9gRda6+{;2+xWKY^o?WQwvTV{ZCOzF(?k
zDJaj+CE>xlNDq399mFH*6X^z*uYR@F+GkSnN#O_rTEDphsKg%Z!_54Wx!I$aTT)=7
zB)EUMopY;?&w$&v8qR>jU`tLa`#++4i~aDX-hV*zrJ^gFbZStYo8}75(Is~QihM7t
ziuZ~|UODkFaWA*#=Ct9ko4+5Nb%1ns`8gh)PRZ$2069t-`B@0YsMb>MbUpEF><jx_
zHBV)VgY+zGIv+6M<n(Ye7Z2R4T9rwhTioacYQU{h+!q8oVr`Ka;=v}=86>;3-gck|
z=5uI_Wu8=(f<{?D@b})KM~T~suGOM!_5jgw0BKlI@jzAB_F+$cFa;xOFlvCp>`{=m
z_Cd-jq^l*tTrYb}EI08UtPa9)9$^o;SeAQ4x5=&0^e>jW=P*sqU!*VvEcSYw9Z>J?
zZz2eSNVngyaie_N^}35)%bzoc-;C}=e?ttJ#pEuIT^?K*KeKD(=)4%Y(0bpPcf=4(
zz)7zGM~VXp=yi<byRJ<WP4u!N!im|Cz`R#B;7Hs!aB4-4K=C&f{K#T#NXK5wUvT>=
z6(TvK`6;A{q7;sO>@L_Bjc&BH3$Hw^$RGwa+o;lBWC<lma@!2TSYorK|8weUW##74
zU)F;5`U?JeOAUl9=qvWgeBX59dMF}~fiM*L8|*nSdOW-|EEzt{4K;dvL~o95<?k6U
z8ECzPidwbv_Wr|Hu*?yn`GwRM(mRy*kb4P1i&k<+yH7@Bivq2lKDULVw&<~S9@lx0
zFU8og@1S*kX%#!bQx3dR@ITdB{1C%g%%Hm42&6<#t)dl6cZg94L2vPXLZsjKZC}VR
zcYlh~NJA35q0Bfa5I=0Vj?gKu89GoK^mN$2G62tn+%IqMMTDHufE4InW?YrYbn`_2
zY_~++uOFV8Ov_aHgasatQ%c|_z0C9!X{!lWEXO#l_%b^^GkUK?shlRZ>r_t}W^&JH
zoi~!G?Z>gv@6;Oey>WG*eU&An?sRAM93iQEG(U&l;9hD%^ZHq6wcxnO8*O+~$SEal
zv;_}O7)PX4IX8VZXnihlom(;IxsFfl^Tnw7{;l@OI1UKCPD`CC0d5}|>-DHRW4K(?
zJl_^gbd{jUy@Vo1N82Z`5a=3!3<9K3@>Y`>{EbW;SlKD)&Z@As3;~SmGN{lzlyhm6
zaehR$7%~BN1J*EN_fT5_h8(oA(sezxV6+XxvoV7=_qC|)47qQb3X1F4U%>*pUSp13
zEZT>0yg=3#iD4vkQZ^D=3}PIR9NnqL+lq{zro{@4qfmD<kILzSc`>W!$!t47IPAhd
zYX9@+x|2#`R>i_t`uu65)T`wa58)u4d!b9;F<iiF?OVI&2jq(<?SqGpd#B0+rk`dA
z{xu>wJhOwV9`*V_JN=}8nV_mcpTE#1uj;*jML{ggQp5hy92EclGo*S@Wu-^s2G)bm
zS5}yUjL%n-bFqZa-t12+O5zj+9WrmCv{H_I`PjtAvAp3GaX+ABcB2aKug;X%X$TuB
zg&z1k3N+1n;Skh8C)Ai9<}SofGH##bYR|MyyJl);zJ%?bk_k_o@fan^SGo!2M3FJA
z>vui2QFx`Dbr4p=$H`M3kv6&3=9N=aMs#Bvv!T_IFoKWQ-63_woGCePVyqk4$aVq;
zkiH&ucW)!{!5BcKu&_|U8kHIeQw@l>8)8DzVh?^8CefmdfnZoxvlyy9llP9;h1By;
zl^FYsH$Ylm%&=>_Qm}sJL9TqWq-;numt*{EplZpJOf=vt2kUI{_SpVJ>#1FDi7e!{
zTi$_oClQcC&Tw$TGH2Fd%;e!KYa0tV=e$OP(}-xlpAn*#nQ}e}osD@(g6?;&%)q+(
zah~h;m&b)gO8eOSocNElNb~3RGAjLb)fihbBv8<5Oi<R@og1MJ&fRmP;0pBy#$*L6
zdT3BD8BS!i1Wet6AhYgHegY;;JWp*?<1i4mK$3Xjml<2x{VeH@Ej=yN`WZe6?oNE$
zp%+)LVS-TO)x0ky38<@>1nF_xH;Qo%f)x1|FoK_zUoq0t>THx}w?(6fn(X;-!=9D1
zT~r|D3*cl$oKpCHoES97omq&Zg`xDh!otl=c$f`zBy^kDRFkBLnbv$ujG-X~<Bk+6
z{sC3uz80tpQp33hH^ZSEYH(a&ALtqmau%B;1!%p;0V@N~*F_}XiU^=)4wHETBPqVb
z40Scb;3+88aJe#uQiL!^fBdHNj(%jveOurtk>IGcf-vF|>q0sedf@<aBansoBtQ^i
z?p+N7N1V3USpt@C;Ps5L!(JFEPa+=2iNx<mr}4ASp%B`6wsRYygIZVFrq_A$)C}1Z
z&*?oNlZH<zVJ*PL2NJnR7;K%o*Us6UdLu>1)hl%pa8Y8R<zeAHHp{4Ve;imauZ`6m
zV0MEq!5T;+m8m}D+2XOgp@XrXZfvJjgtI{4%c>F=${PX$hB#b?08cb`H+Yp@10i81
zLclJ!by)X{+lXb@1qjwTR1BO`F3z#xo6%vCaA#<b9c3IrEtBe@Dd)N$m^&EQZR56q
z*AQsVuGdfUW4BX_^tfQ3LPO#CU-D#0XihpMtU&8n^gsjOVB2zPAny*vZnDDhGX>$F
zW`Vk_fYQgpvhA(*WbVa(w=1>wb3H>ua1F^Uf*1~jH9?O>>uHmetw&{?ZS+km<k_7J
z$3EV;M2IPw<$)!r(!D!Hau@emRtTV@mtxBj*#R}q(K3Du3zsIv6{%+J!NJT?=q~Ta
z1ResOBULRMcjEot(q2yPkLiLpS;rmK^GdYy*mZporytDi1eHyAXWXu(gcdo*1xz}M
z!IthJsIrmOc`%;W6P1bey*MwK0nEOYZt+{l^)DVXSp^skbhpI*@7~D1s!%X6@0wU$
z3cA0b5LJnoBEKgJcn-O#R+7XcvGZ;?5{G%ezu6L}<kMqe(wDR17F30R3q49Sn=Gg2
z7aI|fu3z&5kQyM*1;vfFHiaclJwr%o_Xc$*Hsxc7rq6hJz{Ta6&y0}J2RgQA?V!4y
z<Y*POPA;ayAPU0@!IS3*;Y~h}gDB$5gRx1CF++u>{eJjAjn>k{M7Poh+<r717y@CJ
z&J4Kt%P+PY`JGm~o_Nhmay^2285w@uLMF$|tww^+X7QkrAK&wgtxRU^Ry&+_*SIoK
z+`<xro6$`P^!X>G22W?ngcDu8iQOQwTo&U(yk9Vu&HZA*k5I^ph2A)(bkXSH#cSFv
z3RG`d+KV!IVZ0w)5F_M+-}$)A#hb-SHI5ULZPkT34O=`3$+sAIP^XH_`}l07!4yjQ
z86>g$vMiiI5(-6rT!A$)=r9a9!&0wB|DfOQN)l>)HXQXFp1@tOhq&iL$HNL768POP
zndC=9V9mv-RrCbs)35zP4Udjb6-Mm<bsGWIy5pOLTK>Is5!@arkrviNB7pVTUO;$|
z?f6`WXDQ8v2Z7Zk42DSmT(@3F#Ju|&1KD2w!Qkm-$2<OtjF!+MDg1zCzPm#-iY*rl
zoQCRg`mYK+9;w@%hK94JGpgR?fm5@oOe1fc21BUf0=1v~>q`NOBJ!s^5+pCPamGIM
z{K+e=VZnXMy;@Sw#=rHoi$_F?J1wdUT1$FlJ6*jVR|WlVXlHqie}q72kOYytORa;_
zT01r5lcZ16BnW(kj4mY@uMbgbBiC~!uq~kcCT&c8ccShPBYMxaetOP>?g-K?U_9=x
zL4nTWFf<UU!ETpM%h-F`R0Jm!WYis*_#TF5#;Wtsaj3N>p3^IJxOQN{CBMVhY|5bi
z3BK0BQJ)Vfr(4kSoEbf0vXDI#zi^BEOC?lVz3Tvyr<kBk-O+m3jG{TmjKQ-x|C7t|
zPH9%%HvXhza`-Ipe&QOuj+n&g0S(+X$mcg%&DC~qlUQ;y@WH1_fU=3r?7?#)MI94U
z934lsRw1M1X4jVwCnKGp$>CTX?+L2Qcjm`}-;lD6BB-UT7(tDxo+PF9D%+RWX5}}4
z((y3}LIE%3yBk!D=Rh?kM+tgy0ZK!D9b<&!%_`BiCMG8cp%aODV{z%8`kbrY>Tm+M
z)d+TdlBLEy%FClz!i?=#kAZdqi;+bKYYTXj@ZoDxF{FwWblhg*RvZ?68(=UHzDPmi
zv;dj!HJp>>DuHiHDpg-Sd=%E6S9MIu1xybCR2-_N+?>Y+!8w_f+ykM-Yu71tG?8fA
z=-hxd>J`aKW(Y{oFIgT0yIe4QTGV%-E8}rDBt69z%Ym3zJHI5J;apiu;R{hgZb@yA
zL?C>sx%>bK3;f-lTjWJPT5OzM3_es-I}(00Y<HlhMUM&L6?58d2%XTu@odyg*09!>
zr}^9+HIdJ<vC4NiFyQI+-Yk=a*FmTGhbMsr$DqMso3VHTVy6xE8lGPmYkqI&2e@Cl
zLl1X64N>)de1=SjZz`)XfLQ*~-0Fnt!Vr~B(1O%dkcYJ)JN7x>Qox|bR^V^`o2lH1
zddy;}n0^V1CwktRVZv=w_Xv6&=WDKo0=X!wy(HBvr~Wmxa%@c&m~llVh%EHIT1e16
zG;IL%!ghG+=Tcw4KiRg$iUs<uwLhIVxPabKhV^wSwbF}9o)ZWsG;ha`;un+5ow|HL
zSa1%8B$zdOj-n?WgQ^+S*N-pZ5w|3*zz>7SR1k>P@?2}ap82AMJnD)Rfw2)+*O>|Z
zK{r>;w}toSN{f>DMN+b{H=XnHCJB+qj2^}fCOl%%B7t2PK`F`gtGHU#O9KUrb9e9H
z1_jpltIVm|z24*T`SV6mLxb`svHhivoN@k6v0$LvpX13K?g9{PV=%`DHYK1kQZH8G
zz9z7OE;}LTD3|lRN4a5{=@u-<M#UiKkq+ph+Msgc-zt1+!S#q7tXa>qmUbgvu91{?
zHA?0H^bmZWBYav)ov}?W8DwDS)^KgSHJl)GMXDT9i6n6F#*2u4>#)fmBRktR#GE@!
zdv4l+ht1@yHZ_VE?e>HS5-v1Z(YV89>;%d9c+|&5_%IOdo%N-n<k<U^%8k%uKLth`
zCmX+g8*c=S!=SD^jZ`31h}_7i#Cyk?AL7vDsrSkj4({YIR~=bX3F)}r5-lh*_pM^r
zD%qZ8aqER}VBmtOCD9mG1uLMC;OXbyspn?u4XeH3F&WOKBsVIU23zLZjPUR43*N^i
zc2$W}?_AM!%NU5LpVavRqH8v4aWfqZBM3+3^n7evOwd~!m0Hd`3tO;P7t~^JmG36z
z1`o6rTYutHBtz6mmgMctmu6a~&Z!nz<ikAh^5;KtsV0vRg$;aBTs?FYWTLSg5u7Wq
zhn2Y$)U^qziuQyvfd-dMuttcByH^Y!RdUQvo!`l!9o1jW&yxKaJ<*1YID$ry>xf0C
z-^**xN{1GiEaf)+J&1v}5j!iSkV8{2YF~qzoujnQEGagOK&{wcp|BEevqs`EX4Gee
z9SaXa(^xV(A_qbp7X72I9-MQeASM&b;Vx?e)+fMgMIyNW7dP$E$ClE=?~R_U0}<0O
z<dc~?p}mTw01oDJ{nfX@buIEhE^~W46+5H?o3cq5%P0wRc}j4H!m)ZgeL*=ukO4EN
zN0==YNOppxkfV|3t<`q;!~UEPiOp04G1}RVUM}8`+cGhEBgFMjMx@oAOKRrr#Ol33
zW%CU%WLpSxvODF1P}E-H8PMIG20+p)2Dul@DBL6LI2kD}%N9zZ2o$)nG!72tw#We{
zE2Ijun3llGo$%Lt25q0w%}P?c!MXDQxJR1U8u29nfKc*l)k|IJ87j{dPgB!%mYXCH
z?n0j3BtkS<uowAANqZo|K61&h73=JgZOhc@Kw8*J9qP|*Apju7c<*K^zbm1m#8zNT
zVZe3QxNab?lf0TbR5u7Dh;4t%t&p5%!0bJtGiyR29z#AgW3MYxo1WC&hO=TxY~98&
zq|WY&O%^FR;+&l^=yNP?Y=J1THBVC8sC*oanHr)`mwPDQT+Z3V0FP-ViMl%8`VEs_
zXr^BEmpE@$GI|>WEetdbvX0PbCfH`y(5;>@YoENZflhH-1D~G{=a+#=N~yjEc6`#5
zWBbWcEeX!X(NY|FSz~#qu&I(asH(&gDHyZVj|<mOWxR-pU>n93XJpK+6}0MWhws>Z
zx9qnBte!*MA~w;Sjge{DHs@Y?%W9dUQ|W}-h9`kCDrtXi9Em-O;AT6r|4d>Flt~48
z)eCMvuD#Ph%)?fzi+bi0Q<En`tI}(-843%fVmhSrj_`MO*+_uNI9>LeaM`R-NDQ5!
zJw-WsW0%SrPwr`*E8no7@qS(cIZnP=N>Q##mNH@4*eivcza;9L3pRjtyyBPv5L*)h
z021(0PFgFwwpEFV{z5?n-R{$B8dvGixB$Z7g^m#8Ke+)Slmf;A0K`rRSoM)pD!`r+
z-f4T}?G!R|oJlf@h~hO$zP|gt8&MxeWHoJDF|ZHcIPD|{%~*!IymS0^ezBeg&PDVG
zRXA-6Rnfg~eW=$UUPjZn0_Lx4CJs4$Q=y(vKN<eY`SsfZb~(^)Odx%TSiIEsrmv8)
zPdtzjA%ql!1NIun_6dv2*7EsjL~aN7k}P#y0i+*`P5^&gG*dK~i3F!rx0k&HmLRi6
zLE<h}Eg&ugT^*|VIxGmE*=H`F@(Vg3DFhKO_ga3g9Y~u=|GfW)LBX*tFY#^44hU;O
z3Ad?%j&7ZIpfaI8&9`q^+A{>-$@qzDpNmY2AJnRDjpbz%@ibt*WY6_2K$VGZbqvnc
zKd9z!V0C=os!npTZWt@`ICA^TlMg9&g@VtP)!IHe`nFVBmEWix96fA-g}@<q$5bnC
zl|xTt5W3fP^rRO>y>6b6MpeGcZySOGTb|Sk_(-_gIdXb0#3KjKIsqFfywB5JZneYv
zU{RMeysDm|O%}Wc*!-q?e|I%zBVsyt2em@7@|6YCg$(+kD*R$oJAxkCYdVuVLJ$Y)
zXH<P6H>MV&)q+}~Q4z+>Hil?pdH@j}(4+}U8OmlP6j*jm3ia$%&FKhDiM?MS7}@$X
zo?O^P4@J++sBR~p!#NGd+M#H`*BW?@cC=1H#S@<90V(eavh;%DV`X%C=`e=8;xTJo
zqI@YfaHQY~L~=}~rw=@CM3ib79-+a3s_ZULhkBqXIGZOQvbEhBeR@soWCI~k839~E
z5%HQ&Iru5Qf6EU#tVHP(_0aJ^#Oa(j-`Qa;%~v7uk+NKKDy2thGBvL7$*H_@&le!f
z5@lntxi7N!sQ}#PBAaz%?>YTreeM>AxO4<z7tC9qs2`tCPP2!j%VqV<)+J1YG$7Ho
zwaJWv+U8I!)!S+u$?-Xd%D06dL_Eeft<mrog)M%|FRhU8=sIP6nW`ShgcOqBnU$8V
z6uLhepV1DI_x(vkh4P-_xs0a}ua%KEi-Z!;mRm7#G3hHsTz|hNkHZm(NmPP9(?Lbb
zH{&qQ4sVN$zj9l;+;U8m1}oB2A-w&n>sI`{?AEszCQmC+sIv93blnBzX+3}cD#GCH
znK)xEr-!K&yd4Z{ijZ-Q3$(IPTR>@q+PcmYvF@W@95{Wy++|5|?-BgrBp90*irFM`
z%2hE-(~DX0!`D6}5FIflf<L!Ajd1F*V9ljd4LGHn{a!wXW3(3liV_Ba0mcCULI5pJ
zZm9(>{lIc;vXuRu!yYi<UPO)Hxy1tWfu0nveT~dH9gWY3OAy_Uht2$*JnF8=P;Vup
z1l)93wt!TQd7bg5S*Q@E%ku(h#Z6r@TqJk)WUz{$g$gdQ@{nivrShm1PH%U)tnkMz
zV{oZ+lCO;FZjEp3(hYc%ljP^np}2)mE^Cu5JDGra9>{H82t+PNM*>1|UYfB<%PuJ=
zTr%}=H4BQ@Qm`){KdnE%ImP}Q|5RR^AWcf!<P9+s(dPok)9wQlNnf?9Fw$1?@HSFL
zeQS5%q|r6ap$IB#bXDK_HVq9mpmA5^4MfwQZ15dgo&pY!AMdDDkLfkF987Y}k_`nb
zlkRMutyu+cN9sfB8d}uqxS}<019~T%AWUu(K$f+-5umqMQQlRXizTY<BIG%B@xtv?
z!j(}FaIH5}Ms7xH+pJgjMN1}Eb;$pqWu-z6w}59wlSy$Wa-lB{S=jds^&yOW>?7-K
zU>8ZLCXX)n10+yi``q^x%Yqx->|)j#*W{p$D7%fS&UC)n+$eInN|E0dWz~O3kjRp3
zsM&Fq?L;w#r$Kw+7BUea(lPH1hDoqfRj6u%O*+R_{yVQn`G6b6(Hvi`tnil3I)^?t
z4%gki4fc*7m@+$nG;k{{``0ygH4C=7s;dfOQiamiC{#5XU%!cIj*7{O{V3*4aP~&6
zLfdr~>xJu?=JyDGY**t5(4=F{RL4B2u!)#?D3X-h+eqvPl5G3XVXSj+fMqEH*1O}k
z0-)0lC+NwNa~*+vo}(C9Q%#%qiB^~Q3?Qe}OplMANV+9~U!=e0`ATM3a~Q?9-KtLS
z4z8A_ku*BD<cvIDE8Ni$$~s_eWpzafBOnl=Fg-1Kz1`mF25RL%Ro=|=eBf4=mCiOw
zt2D~XmVBaOM5R-K7{+F)D7r;};&{aby+L3`DaRvzLzNCUnM*fK(!(@qeF{%A$Vi8(
z^hyP7jC}2JR8tq$<o?c>DO5aD{C$dKHdL6rKp(?_tPkb7(!6b3oEfSaJ<2eb%CPWw
zf-wd->~&O4RzXea6Dsq%sliZ)*KqBIftAvG0S8A?3vG@zQie)udX!&zv!D%>;INFL
zq$)NI!NoGhg2uzpl)Nb0>)ngDH224OvAWnxgm7lF-VUfI(N~bwo%TBNXB3UP`ed<H
z?S@!~GaJg(&!UAt9+_hEnw#G2L4vW%&p5}mvk4{Iy7?Jr0Y9GEpnsKuEa$O+zcC;0
zf*HuvXM)uL_j%oU3IY;LkC86(wVu!X8+>)8#xqq^11U<cY{DM+wb=kH*J`3dzqoX)
z9=16gGf_)be1J2`4F@GOQ22XKJ>d^d=%~jL8=9~qv}Ug`sYctr{98J;E4ntA=T60G
zLAS@nq@;WY*{^`;6?!!$ej}X_suP@jMt%U)pa0E~007)`^+eE|hwgHv=|A@lRR&vD
zDK~GcCNR%%=1EoEmaM-yXBcrNX9QGr8JSHYYS7_x;?@j7H{`>C2=7Z!jNH(wOWFCx
zvga<$Uglym0G)%KgFIv)t0xK0!=Ehsolh_Zgti!=hUOt9f;u>M6l4$7YXG>5nHmA*
z^gc(Cet5BRYfV}?5ASVq0&#`o=AAWY9A%>!Ru;Pom`V2SYkAmE6#K=_NJ6%FEcYaG
z0duQmJ&-0EnWq^rg%oc;337o8kivJ<>D}mZ?Zs$8N+<U0hmSN{Z2<rf*d&~ihxy*#
zFq`s)fV0y8Tl%idm-%xj%r~{qWpqs|V?qF(JYZ!=ABgrOV=Bv~o}m^1_%;KUhHN5X
z*i9kaB0ywkDUKN9IgFDK_5yJOgJdOadV5aKUyzjt(DI=yu0tr2!OHppK&%X%TTeg+
z269-wr9Mah<A`0tlmS5OS(n2a`+@CbybsQ(l6NE*Fuytuv#tT?EBtq<%x9pkNx|Hq
z=CGx@$j}o^-u`_)e)%uf9`@i*As$H(rgakwF`;i*GV8_nJ4wO2nwRa*lx<kl$~~Bo
z*S!(!x?g*&soW#+*Eo7jlV}!Fz5TWh!i8#4z$l%0$*RPe{>h|}tZ~d2&L7N5At+j$
zx@!C}w%qZbvO}wscIpEwf!sto7;%o<2zaNPO9+to6hLU*$cIo>nwllg(?!%Zfgi4y
znmf@DxoQ39B<+_Nmg2ouc0G$4+l>kb_mnnCvEer#M0CC#hjoyTW#q^;PDx7qf>|f-
ziA1m8;sYAd@LQ#ujSmyd`3s+EnFLC<T0-bs#Z5N({^U*|1`kE7waksXJ*b~OlkdQ^
z-=G2Nie@-J2u@a#@~22HCPS!!Kt@VkiWtl4ke|*VmVI;EhY6o(S*^+)QrvS;|KtZ>
zmdq+QS9VLr_?>faVkk3Y4xrS)fo8z2zRF8N0-_n{j)WVw(Xe8~?srzbQ2uAX368K5
zMs)j}y9CsIc_%92nb>m)Inl`OP6A%>esNjJIBaKkAX4tGmbSfWecG*WYqT|RA(@C3
zr&S4!0_AMtBSpZXm9IX*Z+ic_T#JEI9~`yf@|dG&A<g>&JH_v$x7@2+OFMLZ#Rcre
zM}^+47qL+1{FVjZIiZ$c#;wXYdr+K<zVjH#h%M_5oM`D*Dy)EtnEen1beiH7#bzEX
z!Yf-mi{wSWcik!DFmoF`zQGUno^v(bI`~~VDwZ&b>}KoZ-<-e&hcV<UH$e(eW$<}X
z>Yo#ph)>llDUB8LvUe{Jflp!Z8$yk`3dP3@w^J>SH77JnbRrXELVzVxkP%5kF%4c+
zU2$)~G|#!JLe@hFtwjSUBWLdKTXxM$46>7i;(#@Y(wyVA0pk9M05EoTJR~A+B@tFw
z4wuZ1vy8A61`r3fDgO36fM!FhdXoe0;*?=@wm$R+qVj%vo?+rFad$p8BC9AJRFGOJ
z<tdUM;CslQA0XCDezztIXAhqvfR@~+(l&)G)tiC7r2)WbYnds~XSA?isUOo01m@1O
zX>Cegi<QUj7=UO0y01~#>^tT~<nY!!u+}GJ`(bG}(XVahX9sr@M4_gnZ!B<f+nUWE
z5a3|ET*2sSLQ92Gyx8=dqLoS%`r|wSy)8`!_|>-jQu?7+$dD%uyxD5RWET=<=dzX>
zL`d&==Hb9?p@1GT+_~2P^g63y8}O?D9`BAbFPn{isE<zUw++}xs{t^yOh=%{_v+gq
zFa=DwH#@xeghHdRYMSCIOSV3oi9{r;@9^nGN-C-msbEH70!XRaYMeOXmiv6~!!YfY
z98GCYcIhDl-JL{VJ|&o~ukQRA)ur@}rRQ5$#>JfoT~J>_XFyelnF_zh{1FFh&Bha2
zuoaHTDO@PG)N%}YHeU+Nkd((Pm(-0jK~K0srF_0OOF$^c*=H%C&Q+UVzs(Lqw&AcA
z5-BU!Yn{&wb8unv()Z0<tk*2H(@|ap*AhGtXv%=~8Sl{<CuQc+f2N>5EwQ6lJzWP{
z%Up9C5k~@<12DB(0l>=H4QzKBcsA@my^E6bK#WCRW5c=Zd;nlSAA5hdEHUe3bFRtR
zei<ND*1rd)VB${Sm5?4$EnS_;KkG4ll8~SFz1%3UkkX$Ej&RRAs3`EIv=n8h^qJ;>
z{XplBqKv8axl*QL3&y3rH|6)Q-tKU)u}f5to}dWz&)!+ke#@18&MG6Um~wujxo3Ip
zzRP`%zc+NVXwRJ5iYQi`tV|SGn-NE8F<iMP)sxYBIO2;5xFB<V`{_=4Fcf?4-66k`
z3CkXb3j+~|J5W=mu{Ko)cL_~<wf1um0n%08(I+y$-xAjxqc%r*uKa@An&^$~@CJce
z?T#Sgrx>J=G1{QeQm}t5g<9};H?d6FD@q1h!BaY7@FWHsvnBDeyPKilX@{pKK1ZvB
zgY1s<CPWNVQ2Pd>GOf{35q?i<uAO$zpitPKz>KD3_sSXUqFvdl*l7GuC}pi3t^F6)
zKVT(w5}Se7t;xIQ5*MiI3tLF5ikqNrWzPxGJ1WF(=}R~cOUrTu9w4Ek8E~H>!JsI=
zFrY){yho?l0idBR000G03ywd9&Y-LetNsl)%4()_EQnDrpsnOvZNgCAkC`L2;A?h>
zdS37|A`#FnCR--a4r-E7Jrl4GE(||@1_;BzBO;$LEU0#-so4Duiu5r4XYg+YY6J-s
z*M=g<3RCxH0-CE9*~FIEyYQk`H0?ePRfRL`<R=VBBXt6pK5B@DQOzTUoB3~Gjo_<9
zf4<bZiI5*L<)@F(2Jf6$zV6>kZQ+&m4YH)bAEhj_zLec(@OK`EWY{2}h~_XP5#I|W
z(ir%y2P(Rp+eV~O7R!aA%#BPm3@Y}(kn1j#2ooE+h$&y-rn?y{u$~F@%a8#8r>_A3
zKm{TyipyK}_Ci1Vwy8P`uvYPt<)1wmhXG(Rw0_4vR*rU*3Ib413nkK!mI|YW6&E`%
z&bYXuGT%N^3ukUr@X)m*eZk9CYrbCIp0h64wM67H$vho05+B3z@sXFv%Ymc#p^9;J
zT5Z;B>j3=R`bPM-_9YLH&AJ+St)%!eTx7Htz8^`1CPd}jYzs!8oQdy`*L+0t^s#>Q
zjvxWZXhog#xEFBau?3l{zx+#qdZ$E9+lB&O!(XMp!Qb!c|Jo$HT$F!&{r(;-YoZV7
z06ejZ3l)v&VtKfRDx9M&4$3#@gyTDtn4x{)Oy<H-na<(Uxnt}<2}=Wt-Qq`ug}{n+
z&UI5~9&mm-+)SGh>-(?@cMT5!O7HLkc>L6<d6K2ig6K8Yg&K->L5#c51h67W0$}v!
z7`zuoNL8L<A8)skAO_A}E4WAo<2g)sjV}@3Iey?h`L=;ah&t6b0;6+4QK<2A(%`qi
z;RL7BK=McyO=8kV+Fv}4Cdv6%1Ig*!%EWvhN!rUn^RS4dWjJ_mxgQ-}1^o6?-QgFV
zx4%GMalEV66r&!?mwK)3ww+{ZMjTd8%t~$=5cCc_`W;;%3yDa+z=BWT^SEf4aO?TA
zB^dvan&OBxCN~a%tY!=V2`VW6{{V47j=wyYS#I^v%f|ri8Gtx*Q;2akqKf?w00QO$
zt<v+H(V_oxrFu6c!R)P&S@>S3Zp<Q`;@QpC5U+$1p)NUO(fao`Y7Cf`nUNCvy_PJ0
zjBw+NC`-xr2?Mie#+4dZwx^%|QoA+?SR_5q{$&(S#FG8+2;kH4xW0vZ{kp3>FHKZ(
zz+eLDi;Vsf2<o`IW;y5){tabw{SLT#HUkvH+}Y&DF<wn_3yp%hiIqH1?}T94F$@Qy
zOSuIsB^jwlm$NtF65>7Py)OMYnVaE6)omgy%ftR1Hx1DTglSJwr72!wpTt$=f!H)a
zK4vsy;YkXMGo7-r1f)z^oQSCZ7+zM{qq2PO`netW6;g&BGsBvq9b%r%OMsXh`DE1y
zxLtMt02;uu000p6-gquqWCz{~dKTF<7)Ou*E@!`yF+l@+3@Bt|k1~U+H-240!B?z`
z2GTp(=7iH)Idw1KXN-QY2~UOt5Lr~M0c~(_=ZFmG6`~89y3{l#YC-N%YFNSg#fTo~
z<#WDLa>L|-6BwC{ndA@%Ty&hMiD%Kj(qtBJT(vR)a;UGjbthqsUMkM%%tba&>w^Hv
zcT;byBmX%Np`7FZ02!OO00$=@T(C5L^(qzYpR`FiR1&z{RIY#kEpiv~rwZg;Ul7a|
z={6{zzr4$lwOZaCz@s*c;@ea6&SKg-Wh^f@I&)M7+;z%3tBKqHTIUYg*s*QQkS)5I
z-FU+yb6k4pAJ+<zE?R#YLc=9MNMKLeSpX<KG!x-g4B!8aLC0!J!P)Wl<5DguEp_|N
z>bPy<-R?3!OS>nS!nI5_zuc^YC^FkVd^;bVSjYe*J-7e|*lIYh+bE|M!Mqmlusr@y
z01Kb;l%hn*yVM9j{Kxv&^wBE}LS1|)K{2@Pa;CT=N(TQ4XVE`y!WT~Fv{C6NmeZuE
z2=|*Ev)T${*>grR+UjTL_Iy%oge@e7<oU@V?#BXaAzx1vaE^lXiyr~`HV0<&O$gBy
zqFk!VO03kH&8XE*d4$-<0X-6<y@8$$G1Qe6jTi(_-hfvXz>hnS#0AqrK%)r%6_tOh
zqB?qvbL0%6lD`^5vh{7&l#~cXL&dfo`v<{bY;Q16YbVbxUPyzLiB1|hO%)X!+zHFO
zT+s3*;`Nbxp<EHZ^^klihX+V?#_Srg;m`7_P5l6#$PoD_<Sp|MoK|WL?H4m6`T$36
zyLa4igKI==^Bf3Y0`+ele83Y*NSNo72LFTm@#6dXzk`UwCk+3r9F#;>VDbr1!VI37
zcv2+kEww5Mt|e5A>SMx!tIF-&5fQhIj_wgt(ds@fEcn-ZKbI6ZEv`^48r4gPhKO8z
zgwCM)iqo4w>~*elmbZNNM`K#ivkmRe-Y<suQ`S4)SUiraf;~+)bW+&H*71xJ8^h#(
zbv;dwAS!Ubas!$HTx)h)NxdlU83|uy0gbirCd=6a7g46pHMdha4Ud}<h9y*C6sn*<
zc#I49iYWZToybW9XPu7-xaRpS0lTo_)mco?)ybildI4m$zpm0Jey~C_*5dj4lDG0a
z1ndzk-~iSIkN^NCE!DjCk7-65w8$zXhX4Q;c(&87t)80uC2U6!a@C~aaVdQz=)|ie
z)tyZdW>jY^4Ml*WEHXvI;V2><Kt6Mf&`3(3w#17+L8_QgVRaS!ymg^fBm7#Ne5?F&
zu_e=DjN&l*gByDZ(eG;Nj4|8UL=bR1I03Oi-@nFar;U0(CSvQb`VCu!=ws8L^9g#i
z_5ogkIV6E^8VRO$!C7&ZFL0S$XY9+dHOm0e7W2)VbS4M@swAiGbcYn^WC^jL>|L+(
zYSb227uB%Bih2|%!YpO4d(u$5N)6Hkl<Sr%BUe1`-fC_A8av(1jHA_)aer$nWM=u~
ziS6L>%!+6A2qS~nQq}sVO_8?Kbba{cYxaTyZ>}9$(lk0Z4;%NpNIaZ<Gzc<bxcN+r
zDiKUerGamv>7Fg$I-o9j0O=9u)m7lDNPf6Yh8B$J0B<BZ<EDhSV#AMg?_EEv^JNfW
zp#@}e@~W3F82N^jvl>=$0{L@LU7c2uawa2Fm;8x0i383<H>SrCf^k4~Pa_<s3ED$c
z4qU{K>R!_9kTI2w;f$y4)l-W-J2IEy@(c~lrTs+OW&F*}Ll6kiG;G#L)h5=@abnuK
zs+jRRrm+H1#P|pB&=7n2BCBJ(G*HR2c&WA(hk5Qeg+{+1`|3q)9dqo1b=9rZ#V~`F
zdxe+pi4u5Wa@bYU3V$vN0002Y-M|1!n1<q?CdOZHA89jFf#E#cmpt$QTF*&g0PsKN
z0MxojvT%m$nal>0W>5FHNyQ4d&2Ef^GDv5wRH+IW&O}Uu>}JFnoJxP770Nvj)o|BV
zIk2*uhdi{2KI{GkO#3~ubJ2eAYkFj?n8%6lX|87RDxls;o)51EM9bLmLQl2yN}$x}
zU<sf_+j?V(o$}X`C9Oy9p<@`fl!UB4#}Wv5n=6vqaxmMf+S!Ei0fQUwW|^Q$T;dIh
z-420nhXcT{tg_P`2f;@;C?nO2Tz_+K)SeX_5L(bd6d2pDh$x5Nbxa8?6*rh0{i!;Q
zE}pfL!1vaZw559E=NGIS9T%Lo<@2}#vO@FK3Q4oiNs~h9ZuAr(^g@Kv;15Jbh{$~X
ziswEDWy3Bu2(P^#LJ);Ps#ToB(}yeF(gWt|y{rDPSTW34#7NLw?^_}L1Vgyii1t@M
zFikd`>#GLyW7vu3$&))EQ!$<3trfSy4e5CHgQXfKW`h>zoEHKq38Z17tFk@nulPYH
z8g+KNggAcJ-JAKw4_;%?P+YG^dN5wVSMg!97FZFAl+$uQGz{n}Ep5hZzj(1H%h59v
z$4s0LI*HGIEu^!AMe_>5i9mr3X1Z1mdC^e~!@;a?yI~p*q-QCSgd~4QdpN37y&ka4
z)RB2Vn?gyM>Ga)mvqX7N&r6sJ6Q}xu3}|T5nZ4B?BD{WnCBJn%eT2f)y6`)#U;M}F
zGr6`RA8SrD9g!>z<3ESKt@GN6q|`p4a{soz$i1{OzUMOEU;qIj?Z5y&mR}vD5*?f5
zRG!Ql00Pyy8NY9Jay}f?BfftDLN(MwCgALH==48qxKd>3u_~$(zoyYqeXLS>dSIcv
zg}Ml&^-efL0OYL+|MAj@&d+Fwd=EW5@r8L%GeN6@46+!Tt}C_2XOm3@RU7dqdMe~3
z^U4p3_5MxyyP9f|8NsaT{u#4zJlbSrW&Q}~jeL0vj<}Zbq&u8L{ayKo?gIRv+0qDN
zQKPBx*_c8ubn-?8Ly1l&+X)s)IF`r<wqsQz1{)`Yke~tC!t<WbC9-w7hSU{DP=U}8
zp5WS6XE7+XK+`=j#$TL0L}=n=yY(%xtjL<+05ySR000yj=pP$nbTH&AhyV**?h1?h
z$3^XU)g?@buTFAO)W5J*C5tZDtQ3QaB=;hGEI0PaA#z)y{i^>uXCz^>CP)GznNBp&
zhV@8Bqi%R=Q0BkGL3+RBm?uUz!ecglnB}MnEf%d<vf%opz=`0ERjcJjsi=7UuYsHE
z@}kUb`pedFT%A1=B5$Vlf!uDFV0*G*lS3%e$^IeyWzd*zc9-|99dPf)EkIh>O-uav
zRs0X5_`~U~0nV;iiFN1as%?_VZ0|ong}}5Dg72-4^@L;JA6h)yMRZxVKu3hkH6y20
zz-ks`R<{6Wjg#I8v1LM?07+kmHf6+RB@4~iD4m69KWlWwrvL!V-M|12^4y?CgP7EO
zym!&>_9q*{YY+fj3$R|bc}kc!-YxhjmHPfUINW`-`TG?BhntVP6l4tCqK3fG`0Mt9
zp}YBx7T8T${~}$OiHE;8Ika0u*8l+_?Z5y&n}JJ$TH(upP=y@OyZ{BQ?rI7Rt^ug3
z4;0Kwl#K=~nYA3`G7hG$fb*HWMNM8mn={Vf>gcBWl`-fMv;RvO*Ot$UizQeeF&0HB
z<#P8lKR01;-NdoKPhZ;}`;dut01(#Ukh_0|4zq3A`$y~wx{tmvDodm3yo>!rMP8F9
zB_x^hzNQA=fu{=x_gnqBTDCD%x%zxM=}?@@Z%LPH<Qy*|rr_3PKU(fLyM+Ma^Ff7|
zyQ+nG1~Z-)aTW>4%#bW~$<Ufo`5KCz?X_1%wU)j00NyS=LzFI9OOXVEB08$w;`p@2
z!cvLp?l#blFk6Nzb-*}WKXWWik5Qb52lBod8*KenlF3q<X1fiFYax3`jZ9)rrlu{N
z#DRBnXt)Lurj({jTPBIU^?!@GXGeDqVc!3vEyhyyY1(Kj3aN>R%YsGm$@@ca%ncF9
zBRM@9R&q`@W|$o1Be~MGd%L7Ngy-=7pjxCvtTFnhAM#>`A41>JJpc+>BI^quBrA#0
zT-%~BWL^2W`Hx|vBC*DLknI!+#SrTl6zOuvhqWO@gXmZ#yV>*L3SWs%wLE)TyNs$a
z0rSbobm;Hg9wM9D`og!o`)6HNJEpIiW=l+tAQv0N7xQma?*KRyi)BCnYXZms032xO
z#XGtFT57qVr6OMd1<%i){k^4j7TWtcAwRS;Lb*hUo@s#JnjP?L2Pm*&*7vD1QN|q;
zZ>9rq7mQfkhXS;t-nyxei@fu7G4ZnjJct5kS*d*jAEg<WeH}CRaqthPw_`oPJa_PO
z1%LoEH*f$FLLTh69*JH|g2BK6-CyW4HA%1Z-tLWUj3A6I-<o(fT7FqO1Kyfh;4PNq
zv&|{y4ya8zw`E>;Z8FBRlsylgeTOwxG*fx~0Q?+MZK<qQ_TbzE3Ffj{6X*RbM^<X{
zYhnnTAU^3|5F)_xcK2wMH;;T@_8O<-@1JA!b$%8xR92gT7+Z#g!X=b-Li&#o9ue$h
z_6{cuNV1foqe6M|i~igLq#Aq%vlX$)Wv><5$y5|*{|a>(ZJt??&Mp=YE`Vx9afK~;
zm5{g-BLA<3cwFuIm>kXoxP!LUx9bJ$YkXT4xO|0LtpNKvaOd9^-V&NSD6L&OT`s3Q
zjja)l39k%Bc=D5BOh`Sdm|owv|1k2`kzCzgpZiSl(}8RLVs@pXIOBnrRA}6+jV1}B
z;xza5jK}9?apUv>r)MYB<aSX2F$)$??xQXH9%T>>E=aji%r9d3!FicU+#eq1-lje@
z24Zf;bEI=`uB?s>lf%_*x4UbtB;|W;%tf%jvRyqq9Ub~UBJii9*kkYNpo{64@~JO(
zyFxZHO$fXBGr@35N-=wg5lKSa2z9Zh<PZQc#R0jM(}aICaJZeac12|*k+|M#y7swI
z$VHXhyz~w?UbZm&U8Y>oU?b?co+N9S02a8tZ#;I6=nkiqmcF=u3L%<>!L+|*5Ue0~
zZ83Z|ojepLCVU{hy;StI(I}c*aC;BQt!k@Y%iYkj+ud|Z#rp~F#}oX|L^VI;KmaCF
zE2mo?9-FB5+q~FnQkl*(jK>)pmES#U>AOuF&WI>wPqX;0<a^a*A>d5fdso@w3tKOf
z{6@dLNG|Jh8>j|j96~e|;OhCtT64f3S-<$?e-T8)Gi=mmsl7SeWv1h(4OL3j!Wl8~
zpz<{@mn8$RE(`CR5<@M$nch)P{lAw^(IWdE4hRm|<iQQ39jg_KxiWdxFv5O`Tl&3r
zel!+84mtTKF2mJ905)t5<gx@)b^%ibYFiOk+&}p7KJUU{r>vj&8h%FUUiJb0l-Lcm
z(E$4#9m(z4A1GxY09>IIsPctL?s~%Gw$<G^ZucS$vWzPNoCzKW6ww|20i#53VU_`L
zAOc^dvZl$OD^d2O1wFx@>j!mCJ3&lY9#0R|6XZD-D8b9wS~I8Y&g*pOh%@oSh7m1c
zeO+$h$e@8!4;6rPpHbG{F=J8qT0W(fnVNX)rn6WITG8jiBZ{o0&@3+Z$5D!dL>GWp
z5ZNr66b`ii)!8FziLjfeGI`o0G`>vLujag`^<btaS?+xOv_cCP2xI4BHLfhnqJBR>
z?nG_IhHL4_(UrkD@2t+4Z~zl{gs%d^$0y3s?deut{n-~5lJG^HJvC|GDhwAv;?Vcv
zhMfQhA^bG>$nZ{~r*GNrCg7oC@n{|@jTW3>wJZpuxekUM<O`V7u*01Ub6l!Y<)PeK
zf^aOp_FsTyBbef1f9Y8gTvXG3H(_r?ZEYeCsc?qf|J#erfbNYQD=0q$M_&$IN`(O8
zBpX)LAB~s&F$pLmGX`g?aeArkTf;;o!-gJN#oR=tY`r~QolmkanQ0@I;k)?+YNQV&
zQ{VL<bDsJN&+C!vKKA||KNKp=i%Zx+#3musXMDaJ6}rf6wZPo3G<`SMjg5IWD{A3b
z<0U|^(26W&&FjlOUY;jWA!ya!3B6;R0F61Pbc9o(k>VH-@)9?ZF^V<T*hw5;A}rhh
z;>mLRl}6aS*2hyhBcyCy)w8=|ACpFgCjhz&k652rLm4t*jh=sxUfA@)p^i~)QxsJ|
zE;uH6raAE!GL+vny(>ev&5a`)5%Fd94)uOlc9#6*LDky9huxsrE0MBuGVdE%SO>5d
z@c0knf5M_r7ZMu*V*&)1VM6w{w^1-`I7~j_tyfL=vMWpVM;?WH57jo2se~^kmN{F$
z5eYUjx#!>lgUD@k;v`i0D(nvCq1tjHlguy73M=JZ+>sjGPy)|V%q*ohj;>SF@ZfSw
zzwm`rytphv0q{O<G9V~rdqvQ@#vf>=uAapfOwItEKe0AO+Q{>ZyeQ7J+yR$T{yUOs
z)k5ZQZ@R{&Qs0JhtTl7FZ;uaB_$j778mLxrJVka(Z+$L0-V5X3XKOAHT|_hL2ldbf
zi}t^xM@H3giXx)Qj8)a#L?_NIJIIiM8v*nE!5x}|8ZG87O~9J)ywCtu=MbqP%6^V`
zaS5UgSt$MlWw!8H_Bof)VoQWXN*yDy7GrfY#y~=+i-3yTPpaeo*UDDnz_eExNLM{*
zq_{NEXk-2UwO2Ec5+ZmySD-Ld3f6={y3c3!6RAL`;AQkeZgta5R*UA0mhCr=^_O#c
zogs|OA$vNTxbD2GZNbC35K6CJef%RQ@r^-DZK9oU>ScP)X>&aTh&Z54?o1{9Ez;O4
zeG$Ao30HP)sg$7+;6lzgh+!-xH+NV@>L5zY0Kg9ifx%KO)qF}tArzMprR`1(o&t%n
z5~$N+>W9@svMJvs-%BE~I#>=dGowAb;}j(9AN)WEbz}er$fm1|r~S$W^vsVc0yTKj
zLmzZAvC{9b0RuzvY#iHgiiVJKtzT)MRj4JnMzq#cdsoHZZY=1AEN)}scZY5?blnmx
zw{6h)vMg*i2ccsa`HvJ<Zyk7RRUjyE-=oHBRKfH2m`V0qHZ=F&It__qP%EAWx+HUe
z*=~H<G93aG4MDcs^UVxXzbt^*I(E&@0`;LLWu7*~|HhC{cHE5hv3J4ezSAf%!wT~J
zwEur*>2b=7nVD!-nD@cwCoUGa>>;^@G-4UV&sd1|TgwN|pKTo;mP~B!@Ap2vy1(23
zIe#pG-6fj?O+GpYbKzcyI^&!Q<D!e|_G|2^`V3O>?8ylJHY$pq?m3D=hQBJq$?$+u
zmHh%IoxL|3oX>OL<69sApojvOW%BXMT$eq~PL2HbB?%pk3{%|RnMl8D*zVKi<u+|K
z8MXI+0ZR%{4qgpPW}by(&ciyaJT{pdK=kRg-wgv^lfyw2*<(FImjA<N@Q@q+(=Gr7
zuf_GtmV6p)wwZAI$w7*$2^z}P3uxV7NYcaq_5F^q|A-0Nd;kmce%iH;BuHc@Cm`3H
z?OH664`_AO#|!Uqk&klVc0`5L4BT8Gal9=8aR-`NP}Czh*Ydn6EFDaMO7IREtOjMd
zFy)<bmm`vinw8%15xkL24yTR0^-V_S)+}t8L{@wV-YfzNrh^*f=vfs8nbyDn0001-
ztPsw`Kp7~NVzbcpjgK2^)1|fOf5rH4rN%wpXe!d*B%2HNLyy44>+fzdb&sX#F?)|J
zX<d9CP@H0H`RbS0ivDbK+?)GBv?fd!mDxkJmSt7Hy@l~)4z;6DIKWPEJa#ZRQk|Hb
zbxM$49bt*HE0sd`P&AO9hy~$6Z|UTDK~J-i8>n0i1wncBRVbUr0@BUP4MinBb(8Nm
zD;Ws;J(;&v@d@b~0LI5zFv7B@*0xT@4iS;dA+UM2_6CFBTI=Vpez$&cqo%m=kw#ZA
zEjq1Biz==Qpq0Ia4slcg+^7TRB;xxp5i!#eNNf>%-zM`<F=UkjC36HF50xhjwF6Re
z4S*bHtEoD{kwv|eC9~crSNC!&zxYNjLB8USYIcB5)>%AI5mw`{Mh|&5{9_D4vB1A&
zA0HB)QzZuRg>8Ji<ug~t@!c6$iz1IqGpU3w(2vp4L-Wu7&>E>Zh`z?cC)&CF$&uI!
zuFDkS$FMV@_-9YhT8oEg&Bu+g00C-|80k1!s@Z=~IR@jdCcy25rM_}J<VK2(4Xp*O
zr&lqvD=0+#b0@!Pml#W&1OKoOOug`|*(5>smw>RaKPc?c0@T;XFCB-o3NytQVRV1y
zkYA)ZPCAULh`J9U4U2RmV|8D(m_)1iN>IJlK<}F+eFYpf?82I2xx{|W&L-h*vg=1z
z3J?pBdy*IS6cqS>WF5469&Lxw;DW$Y@vD|Etkl}aW3LP>++wanj>|0+kzLC9uZZY$
zO78R5dCik!bca=poloG3ciis`P8PCYK1NEw)BTA(fw%Z)xcQ|XhoB!B9JDl^a9S#c
zLM)Cz%SpcbjWBm%*XA+~Tn^$Zgv8ihbv{+nCWCEklJzQFN(zeQ|CD{o5kfZ$N}(vU
z?#Zw_CIT)_?hC$!b?e1=r26N9-=ARS4Fk;o5+q6wJ_;&o6h1<?Ra5GLP%(y_`R6R_
zQo{P0&S^ZzjUZ$Q4@u&=yKGUoH2lVr9)$u(?1qSRv3O2XL*D0P3OjJiWDtge2kDNe
zeT|B)&(#q5aJmA&AOS1R2z@nJ({0UX4XvmYc$byVTDPv%%1bid3SUPOq+sOIRA%N3
zL>$WBxEyDfRNq0@6+H#{9%Y|zqH>~?284j=F)Stkoz1d>U9vL6Xu0#HuM;!>yqfum
zKw?!6qMd=JZ0||MRz69Nl$04lEw3QmW699fOKqS%X<CZP0Go&3C!VN>fyg97;LqM(
z^$YKWkQo<O8wq22ha6Tg<<vI-TrborHUMaquZF^DJ9<!afm03!*%Y3(WF?k%3>WM7
zs9NzyzXH<z;8gN{@vaMr%kqjiidt7py{89LB5T(y7BYfS(!DxFYvxbipN1uLA!vN*
zQsgX7a8Lji-i}NOQ4o~ZQ>(BDPmlD}mV4j;61{(BAupa7UwCi;mQnNsl@sL8Aaoz0
z7nW<v{QaDOcE#>xoP4Vi%u=ssX`T2mXv)B$R*?|7L-1UUuoY4E5e~ZJe-IF?$qvU^
z;30MTGO({>NaIS{8n8mQ&Hd*gzntqw%_St#boTsPp^wiQ)ah7@tbTO>3tN{F9*r;v
zhVEbh5J?o?ISbqWXC?NAyJ44v|D%hW?Orrl(cF#AukV9m?$OAST=(pzqwiJ{>jy(Y
z3V*)~`W0C;0*xp+^;GDol}87LI7VR@^j#worh|$mAbE|UUszBGhtxF1yW9QIk=~zA
zmAerAV!G^b!g)<yQtIB=_DyZv@@U&Wp;FDG1|QAl%NQI=|KA@u$sU#V(TH=zgcnRH
zm8Fy=5frnf>K;wVV@Nj->)O}~HE={GE1w6H!f-bS4OkCsMn0VEn^+#jRWC2^&Ut-V
zNl$|(xHp5xhY=%?vxw?-;a-tb0dv~z&7{IcW`D(T<TL@Nq$w>E$&$I7+PeW(KAlAu
zUbiMe5OyWbvxTjcZ0C-a-AJ2MivoVy+DS-Z;@i*<fj|>}vPlWD`qsz8=P&E96~%n0
z&i1^bEh!S6n&9cT&wbZ<GW>HUav-pl^xtTyIN@nZ0VA(`DRCAKcW7qcwTnlWmB9n}
zh|DZ&h1VJ_>j02(NGXIO;J|*$=xWNi<bO8BT}#^g_=3%tYFb>Q{t30}$l&|`A`ixk
z6;&ZaKcdm5W+mx5BD&%2dkm9->`l=x>zf19=NQsAaca9MNjm>Ki<C<fzs}_NX<mX6
zqIHf|%08lS5=}cDn*!W;DW%$Uat+E4Vf%;F-o<Xi_IoKE)FdNkMB^~tn{vg~036KV
zgL`zqOmU>_%%$lhEO*M=u<|m3Am(n>K^bumHISk)HbU1ad;W%qNfPDi{X#QYeq1TQ
z7nnA*q+X{dI3bwQxcm}1c*8dA%*%!@nAlhvgqV5~B2h3)L<;Kd>kZSIhRlF^`QBGC
zz%T1shDGRgE*O7l4DJ4)CEij!S4~PHJt9JxL9+WjdHj4dqv1oP`0q$J=2`qfEoBuT
zdGy5ynX{C?1fT_iG!1IqvuY-R-HtyRfstg4KW{FonaBa{(3jJe<AVM(E&5>-$vgaX
zb-C=PVRR@jA1;fY>!Sz6i=iVCXsvPUpt>?D8K5wK69>DwsR3Dh((}83S1Tf#;~eR~
zoaY#s@RhA`9g;4PmYZGzGK%mPDXY^CH>U{p!|h-{MvrBMpl@DX`Fk5dewB_gioC~`
zvruP=N`r(#dK%JWRM{oPL~@`Y=;fKRtRi9NIJi#1xEZP(5#iX_k%YzC_sPa$Qd19n
z40LLr+Fy8DhfaBHadqqCGchczn~;m`H(~$hna_<$!1ujY_>RMeymy?2Wwy9Mm{*_F
z;95)-zg|H0b}~#$5+Gs%bZqs<2v2|zp!e17!*^pZiZz(UFTyW52h{24^h;D1F0w~R
zC`ymK43DbL`=~kTa(P!@Xh*)jXAu!J7`dhAG+VyeY-A`=QpPq4k}<SNVr*aBm1RPs
z_Mi&{UY&GP6X%d_z<%(j3~Dfl<{(<!9(x&kW_BD&z{^g6lH??81Vey+q>TN5lklO5
z5gS;`h;vMk&&WnhBoGttWCJBI#vVV-q*Xrggq#uNz4K?*n;XuPjpJl1oRC@GXgD#e
zAc$lsBal<-3Q!V;XQ9JY%DK_EA>(uMkK_NrZB;J5)X!;)GE|)af83@SPsxrpgM6Au
zsy@IOLuMh?D|(xC(7lt%1ru+V4#u@R)ax%CI;TXDN78s|GJgdnv$LF;teR$Uy(mt~
zsy?CpUkjDekEA}H5O?<Xe|h{yo&Rq&n!va@JGs&5yLV!wb%@TPFVF<7Od+%uT%lay
zKIX)vMM|}2+iSy<ys)P+f~Asu)l*hG?vFbyhGy|h{8xh1`+EvR!F#uNcf7@;?!bw9
z9Zs2k;wn{922!q#&$?*2ZqyUd#^j1a(OA)E`x12R-{`(Ay6PJ#sXhBQL1Bx-?p7<M
zy*3g@hVlE1r`EhfOMo?noOH|4&)OX_m9owB=@JwdF`37C>~j$mQ6fTG?c5#km*iWr
z=y0YL?)?w{Q>D!ZCX1!W%m5cC01Wj000*@3@y(SLg3yp$TL#E!M5!rmw{ntkLN}A8
z-4M>5tK|>vVesz)XPG&eV)mpg>-2<pDP6mEG8;JGn@>wn<4tz?>%#-oo<@D&02272
zYC14`EvopEk;`?11wnZrC&X~xwB%$(KU`wU)YC(34PZv#5yaVb*2S4W$iJg2x?F-<
zQzK@YG}g)w*G$*u#-_7Iq&Ku!TO=c+)n9@K?NM1CdmwK7Y$Ferd2iuUzJ2kOs<-;x
z2Y%n_x`qSjfHPi0){%PG*|*FR-9&$RemnU|bS6Y<ls?U6b5dEGC=2A!>>PbF;Hw?B
z1ev&f{1aDgu#KO#-V_0!E5Q9nIp}%!@I3<@#mrfHPsX<C@?t~SF?*TLx{}#@j~pBV
zGy~1X+-Jtf1M>+KK-W-|UdXTp^3ftDuBCk^NpJV4056nDr1SyFbb-8vN#z5u2q#gF
z2Nb<*br34{1Fd9ZxEK>%3P4yPP_(OPzyo{LPApq_^lc+Le$kiIe2_;ej=E=X09>HH
z^&58X1a|n!XkkZuxwX}r=#30YR69qP-zAeuuA0S*5;$Uz#Ph|$ZowY#Q2+qB{170$
zawtx!qbl^Re_$Tmq?a>>;6^PK{sE3S=b}<;OXMv3t&0ft3HnSR-?Waxc(;%c<p2@4
zhcB#oot_`NwA`Jh=^i{w0T0ty#-C^I>>;{tB{iS)b7_DAlibj7z3&%re_Z18Sfr|e
zxk70M+M>=Li1Xz^=fC~mb_@t5E>QKxMQ6}61f~Y{;$vQyKS!%wW6y_XpOk8)C-Xk1
z(UwJ5Xu=ovpMQAmArDEs^*yUP0;^>2_<H&aJcFCNDG~J+Eu2oe$8P55dW6fC0E0lm
zFw~5ZCuzITogpTU?PlMcc|7TMc;X3I*=6qHJR5|ugR)8_P2lI6A13!*0aMK5PP17(
zJyTw1jxPye{IV%8@6!M>OAQHA99S@oZ;QGIb-C-FneIj>YRi1XI{tYC1{HC-?nmHl
z-P=$eiF5Us2rEnBMJPFxD8a06Y!KQ$>h}XMo0-~yS!Y<$V0?uupvgOXYDf!c6@Sq6
zX8{omztA#mIz<b-jwkZCS~&Ng<hg<kZ^i@TN2CEEOE!X`c|tAbt1Xbv7FkVv8j4#i
zVgmp~BFWn^;8O#Dj^7+2$`4-^TWeATn#2q(Yai(V1A<NsTvzwH>(Sq_tXd<}sa1ps
z!$v-=v9;nC=jwIz27D$ZM*Sfi84j(O>?iO-LTbGd4ic-)?Sg%mAOHn=BjB8iCdns@
zLZ`Ww=)Ld{ppf($kG$uK$k&@+g{~s{dutm)x3MMuu1RXPqL9_7WT06j>H)lZDkT;R
zX*DXAbuJW-9M#4O&KOa08*&W7FDtJlS`cZHjk*~Bs&=Fz*y>LZ)I|%Ut8m7X@K<`@
zl#%%(>$dZrY%wqJ(RIjF?Z|ky^6Kuj(!Caq9&xeabIY-rf(frF2E&n?i1W<;gxN{V
z#;_wSde~8=BNs)TGo|rc+{lxMA<&RXpWp{geJ)Ly8Inj%@n*$-1Mf5dRW*iPWqzQ)
z8jf+Zo^tz)^XlA-CQR=X%sxW^WCcJ)*CImDuM)!X0HrcZ)OU80tBT_p#2<fNlENVH
zJS15E#W7uy2ZzTmM6tWii65dnjQ)>}Sc7})GSERn6=<m2f<-1h)j(8*lI+cQ6se{~
zRf-3sf^84e^?J7q{%)mU)UuSY#Jl`(vrNfua|8f<5VaI$74QkU(Yv9@K>?BYsW6P|
zG}6eOt?S#say9)v@ypfsC#_izi!A$xa5YrDoz95yTpXBy01OvNMV|i#St-7MqT<e=
zV343T#TV{K#LV_h4+(^JbFS~!i6(}I(*pHpE$bEe*4QXZ=50MFxA2T_EuQ}GmdnJb
zxf}QH=C4EGYYri^?g32fDc-1$TDrheiv|NRt#3LO4{?J*-gRvNZkmNz^(|<b#7VL#
zEBVBi->LN<O%4c915l?pa}h)DEef8)W@Bg9RoP)mZm_avfjE6t9}nY18dD6SS#%py
z*3!yHLwS36x#IDqMq!L-$EU?6jTuVxhiAe@?QIR1)0VyAzhdULajZI_O)P>8xDmhE
z8N%8VMAJ@#O|IFyal*q^Jw1j*ae=F?df?3J?u`23J7v{5%61t77)^F+b?O29lc0-5
zJ<27W_<pDt91{x{h4Pwd)x^3fsH`MliuF&f*D!Lv1MLtYmv6hR08D<+%TX*ssd(9X
z9)A0BBy`cvknq>{R>!$zlBQ^>rSaOk6|6Be?All?!Bf-l->??0^w}H?TGBN^%@Bk3
zR#KuCA~!&tlTiqMH<RR002&TxEzD`j#tsf6edrsyv6(ug6tQYKewO_VsjBDa!-T5w
zCfs&<&AL2jdqHZ(eK*uhExu8yVf4m5QoAi&7La@dR0{4MI?uD;i_a3l`<bpbzuK6j
zPNJA1a4a>2vFbo;vxZjbebzTE)oPnn2%{kkkN_=E6Tu{-OK}xqz|ISKMhc5tsIM4%
znLh+pJf@>#0m7}N0dVP{rb!$#4e9Y{^S|{%-K!P4$fK|TtdTBV#gO535Q(4K7NaL^
zs@OXCcr9bK6EfWlg`s|lbcgsGQkGs~rjh>IOFCeUsDDs|nRQuN9`CvlPqSstGVGEO
z7;KM}s88n_2cS&ZNFZ+>+dXOjB3xo2di$v`Kny3>nbV?e&`#_}Wcaf_2N}1o9?lIv
za<pEW6Qf*^(yqAg(T*-=!(U%Qi5EQcf+IK4toLB1Od)zLG#eZpSBM;e1~bJ9+1?=1
zz_Z9kJ`u5-#*CtI{+Blx_VS&U><)|x?Pymi%(T|2xm9r{+zpiDc@bM2g;M+F)jc-$
zyVaBx8_s(-D^iGvwyN<n6rrULv<|0yGu&P}@`cG)H%ms(u(VOfUW5;4eCfQTWJrPl
z_ru+T$*@C&c;!8eIcw~bQkVr2|Hu2lzu<tyEzcS{8gA^M!ma;C5sL#lHWnoV`V#gQ
z_DEEtg$ARrqIhL$JZbpad~p|`(ayv28XpuRakZE=`m1n)I33V1l}v~iP!kziSR!G{
zL?>{a=4e=&$p5RKS8uTPc|(`aeL+iIfC5S+wcM46=Sns$6U7|9NQ%g^5LWf?CQ{(@
ze>0*?-U;ZFoB$Xbg*$6v|I?n@w30sH#DlI`5#E766O5|;do6$<5xS09hiG}*>vB%5
ze$vz(Sl=L^<PX;X001PryLA8_g!@QD<MG{n38TF4Q4jzFs!!(NKp-sVAnrfV>QFdA
z&dcCAx>y~(<|B6|<PQulvA}A3+`{Q2(UwVc4<f0&sRIyVGT_|dt@gVPpN}5ZBDC%c
z12t+O+ovG@ivQYfJ&Mr@t49J78A{LMG|7IL4{iAz9(mFqtKER9t2@G*(<t(*`8{a%
zH-wl`2gNu-{Q=b4FHAT%HR~QL%`4yk!NVl48?550v?-aWVmNX+Kw37J(+2(^kewg1
znM2T2@##Oc3BwkYI)J4x_OggGO&YY0(n!1mP1#U*Xd|$=`0ffcdEmWdg!2$RF14sC
zVU<e^HFg(a$$ed?O|jP+RU}0y@d&e0W0ay)89E&3XJl~WT8Pq~d9K#wOFEJq({1el
zC*#uiVgV9k==JGFoDK<lO0}<5!lFZxKUBzpVif3~b{fN0f-2->T9sl-^0qaH{w5mk
zV%adTxjXX+`C8~rGcd9Tr-t_M&#vzh$7s3o!Q3=r<~kNtL0Ox9=@5ro6n+3{xcTZ*
zApqZIz)rF*0EP%d8#yH?cUKou&|N&FfG@fde`$Z`y%O%52;i4_M;W^lp{;|Gqqwfq
zCNSn7Y1|SYM~k+=_Bkej_YZR=wH4L(pG~504|1G`4clOU00a}q^~OXm^n6CkGiMRx
zUFM6J#-Fu^c}Pt8{ug*){J%5NNN2S*nPnr6MfdsmORU>EMLx@uJ@}b?K72)oIRQLb
zt#bC+|0B`njDSNO<&Qk10>R^oeiWKA?$TkhoCXCZNw1@dlPAMtwsd|q+m%Fe+Dz*8
zd#=%pj}~fJy(_qvR5r56(jfCdut?X3d9~O8PP}twPW}Ud4EuN4WH1lU#;mQ{4;D0R
zocLt5Wd;;UPVmiUM7vtBo~i2yWVGFDq-MkvD^>{c{lsoOjk$H8%clxZ5EbW0LXOqz
zQ=Zhw00000000166Hb<w>aFvvn?{0f+Fxp2$vcO7=%ZMJeK>&)ViJIL!PxvaqRnYA
z7z%>ml+2!t=6HL$3*w=trEa4dYg#Nc5=jso^n&vq#A1WE3@hIs9)$Z{8;^4CFTKF|
z=BnC(329QB_<Rxf9d3vZKYOY2kkEq$Ux_zqOS!E}xJN4kq4r?4UQzWh{R$RbJ&MY5
zc5T4gI34eM0$i{JPyhe`000P1YLv50EK#fA$@9$<l5ztsXfTYJNI4z$K@s)Z>xB5X
ziF|GqqjxWgikMPP03-&|d{J)MWc~f{X`P6LINb2SaJVH<SJ4NPkM2~R)_MtH3l(@$
zA2+A}njM0hOBj`pEjLAFw}x26ANOnp-5IeE5M#G-rp78#2y6i<)*oqJ6Gv~G=*JMF
zq%#S9&6uac@WQ`-2;+_p%1~z4VFd?Et55mEJ)d~rGg_W1;-`SjM!A&i(phhalt`pU
zM#k4*6}~KNRxBT9rzso2_n4A#x?vn)VwoKn<?<u;bBcIu2W#Ia8Hq_uJ@7Hns()#H
z;c6W@<*~)ruZ+yZva)VMFSOl<|DI<)H75h!^;_aQ4j%E|av6o#;g}t_L6mDTieH3Y
zau2D~(dd?_E?s1fkWiH$co`p6o%c|4(&X~4zR-_-e9j^wXfbn3&S<xNve?BTI;2z4
zko?nip;mkGVB|1ZTC7;co^(l=ei0j#>21!unUaL&IYsY?-G4sM?T=#T)dgiu3YDfZ
zy{hl@v&)R<W;+z~pyU%6E9QX_F&E^=!&9Te;s|rL1?~319`}>dCzXY4FeVIq6W(8w
zH~Mvu_=L}G-$6Kk;C2bFIcWJ_6xeD5lqf7PFZ)0V{8Kz4(ztl;6Pn6~uNYtiAb^f>
zerkQJYI{w;`A<7edF8)^<e2>#n>+73Go=eLvB$&>WDG>_uw-#`=d}HcLX18iE{LCK
zLMY@<{v_#Fi`a$?LniYsX4;*e9^Ns+MhV2X<{}D}h(+3@Fbu4SO$++xbZ90WN$Q-n
zD`z@bl-y(kf@{=t?TgdC+*?vs;3)P4DtZltXk@T(00000000)a0t6SXMWBR!fBe*R
z>gaXd+1Z|tI^*?8_k+z`C3(B%U+sXDW9G)&@$|HtvjL?Pn^=>_cm#F%UHWqSEd9Ga
z8}SY>b!cJCQg$!b>W7mgOF0w1f~z|LUR>6}f~HtXDsA;z1^>$d^2lWET&W8o@p*=a
z@h`sSSktZ_jN6$hN~>;XmcmP%9;t`ud6X@yoVzfAL^2ytmHJFw*Q60D17IEWlrGme
z*bv!mKlDvFrrp@Tj^~BX(whzufO2eLa7M{=ev~h>F_#X%{$4)81d@jjb>VOayC1tj
zMqgPXf2KH={t1S?3b9>jxyc6#2zG5v=Id)s-nf?5R%|ug=TxHe@Iu#%mC8iKU@a7N
zhBmCcN0z1hOWwQsPQ|v65R>eGKIeljJ;{~H!|-`+oyJXC#5jbJu+;j#u{ewGo$7?E
zjz+SB0V1c|!)kmaSq^H*6#Au3{JH7E;A?#VMURuX9}ywBG>M_8U(5lclLXUb1}vS6
zB>(^eQUfVc;eL;WI%+mcS`Ja84Zs8j+gcA5-RONGP%VE1d|SS^uG1X&{@wYs=`~-!
z>Z3pGyfGeUbc!t{A7mxJ@pxr6OYr{jlNo+MNsupWI?uO;I@8>|I;?r+bmJS<wIiIJ
zT7Y{~jTZpq9NQZNjX#wE5zSS?c(6CQ=2DvkN;%eTJHkehmgq~ly|7?Vf+lsZ+?HK4
zem=J!V|A!%rX^vxDEba6s7zO7^s1vn<&W1&qVq((98gQI9dY)rzlD;QDh%u|%Wuf+
zE6;I@{mmCil;wr9`6ff$NkOiMjLmfwFU%Il64?h7^gS%&_+4P*7-3on^7tfB^PIqc
zIHATN52aoMow$B!81Zo&0jwa&3Bo%z=O&{6+s&VFa~aZhr}a$r+1=wuR~h?cdy?IU
zhi!k;_}+6-9q?ERy%nNETQm<H=v?Zfi9&(#?l8s|wQKNc6o<g2qD?dfZYx{zNwGO_
z*AsY*PL?!y|B3}4exnlJwyY6dZ52i7_83mfg_-HfqY0H?fnObZ%(4=&HOj!ujCKsA
zHS&V^r83RI&GLNLLTh1rJk_L<T|?z!Y_ttHhNM;vep5p{E}84nUrjkT2Jdd(#yu|!
z!CHg}Vi0ek3;9iuWhF5;qviub2=jOY<ih<YnrcG3+k~y3U)Xa%jYtZT@_KC^DalN)
zM|L3OxAZqo?2)UygRc`X2`6m%I6;pr{DxjGQ=nU<7~7RK!KsZu^n<m>3ltK6`Mc|E
z2O*j()~>F0zODX6K#=9yaH=wwOK@p)cKp>mz@GTfiMs)5SU0N%jwLL+a=;<$p$0=+
zhOE)C;$xm|4KtI#JR1XEPOJnL%H2HNYXdkBW_-QaxL<%LHgR+>#Z|C@^6IC9+^{#m
zW-z+<`Rh6{NgP|h1hV4bqI@>sWBw<3OBMSAp}N%(MU5RDd(oA>rLU3EZ8e^3`pv=m
zGjiSwM>x(@JJ&9SS1us9`?m<lT5U_20lr!7Mx%2Ttr`9_Q+dDuR>M^f(f}S97|Q&(
z^I^%kj{3G?q0*hf0rS9^a>?cD96nPUI!#3!fWo?opJp<u=4bWW0qlj=i5i0vo*TrI
zOp#AbERWgMQGd~=6D8;LZNBoU<j?%4n9`9C`uy&A(^nTyXL>aEV?YQuaaF|?d*{aB
zC>J`1yr!M{vSGkueGA0j_IBjYtS?hiY4areDa4v-shhg>wYDgwChPN7WD$MFKH6?j
z>6sVjV~p>2r+0h{c4*`<8V2@X)DfmqU3~8T2}2WU02YH8MIiqRpy!a;cdvg2hyQJB
zu?8wFL&`2xs>pBZ!lBOf#(qk2rhy4A-S#4qb*aDjv`a+5(vFsEU2T|L^8-&oPn{}H
z0_1kaPh(d^-9{0Qn-FSw6ay~tcO`Ych(Nn7+tepT<x<nE$zM-){IO@_)vsrDgh&7k
zIn}6lFHA&WZN%o7YnVci*Dvb9S(^8aXTPh(cMUX`j0I5IoNH;FkMfnpBvMaW9=sh;
z>B)e3N((Q)G?1gz`6<f0`tr*=4HO|w7$=(KTf4HeL_FF&xoiL$2I?d2x(F!C&hK(k
zNI}5Gq4h_c_n~vhv^PyW8jEi2NrCvzATEkKmtc}A>@;+WC(-Hm;iTQbdaAiRs5{{H
z1Z~h5VU`Uezuk~@<J>Rp6#-+5HzA332(D8jJEvGeu-QSGP6@ZH2|vykjP95(dT**I
z`no}Tyb@LOl*J#Gv>7Ejv6JRbevBM1^ni8{q5LM+MWy->ys)qip)vp7j-c;btoF0!
zNykc3Te<EwuM|v3T%P8=SJi?k4<t6RflmK+(V@<UoR3RZtqVZB{AU||>}J457v68*
z9snDPjFa7`2kJNUmUh3PJn#i9n@x#)`^sE)<9tKn2Ju=w@xWHUllBB3&*N*V{VcA!
zxo3~*G*68XpAXo{oQ$x2rfI}?`)del=KNCz$2V`()W9eX!)R%i5znwde(A|`=_4a1
zZ0Nu1@AmNgjXOM33*Ca<iCR&nQA=pOqWCw!E#dBnKx>9|=h-7P=PAAEr2ta4yKNo-
zb3*eHIkT6)Xmxf$X<aD-htgZY_NCNekYTad8z1WkClUn>Gj6Br?+QUK_sOq9$`cDg
zPuS81PoSOM^9Fz1)pAT@*{c!~a9kh`0|H{!TB?oZO70M{+DJ&`^jYig5m+2H6Fz?2
ze)LksIP<nJJ$*-XR*E;CKz+{#1peE`a5dJC7=#Lg8KH9U@~>Sx|DVVhO|{0WY-3OC
zb*uCEVd)<O?U3>3nr4+8NFeD|J5t;5qco_`1Tpi|KxMdPAf|5c!u#j>j&<~xAaJZI
zObw$0n7;8%ztxwEbhm7g9giJIvmGwfH&i(!{Q{T1^}r7)P(i{rKK|QkzgN>fexrc-
zU6KQTgn%-OE0+cq+-1%%fL8qg8VS-8en@D1|Kr0QU0zns*=5ZA4YmN3-6*O{YV<_1
z4mX`3++^P=P(ZCbXm=|LOKVwd9TP+JF#21igIQSJwaD3Cv2B<&C^t^HB?l%n)H=R`
z{~Ke{=B8C9Z}(S~YFG@6BFOP_s~5<F6fhvW(UnL;K!r@A(LP~@D_?dxr0PEmG!Uk3
zBPbkZMOlF<pS8{*a*0r+ta3~*hX3m5cESt5n}v_X;S{`;sA6~Q0x<DS>>wUPME_(k
z4wxU-K{`aM7%O2<q<rcRmP3~0aIZ)Xt`0DbE&tE9d;?NT9j*voEVYeW2O5Uvd08$7
z{Fanq{{}Z{G9==L`QCMjs1fz7(LN4{s457g(zHN~M9S@(ES0XDoBN4h5)%F*H{FcI
zNI&Wng_sM~i-GIf1hQpDbV$DWc$3UFV@8DX5(iG%9yNUgqlPl8!hpiHgo%K0&y>EW
z(Y+&Ouja;>=;20tGh%O3n&>pi6@ZacwBYxgKV}H4WeoVz4^YUo+yViqG}o|dmv(~D
zW_fT4)Gze)>>pdBQAy}wTA4BmDT+8Sa(=_vScIMu3^_RQV!5xP3s48221uZ<qhNPz
z*KNc(aMH*Hog1f<pIxM{^d*cF!G6bHzk?%JK5krXC{DfXPI~E}vKM+q^%4PD0;6E!
zSM^%0{cnXa5{!}rZVDd{ZICHsbQFt6L;F!%g$$--iF9YFuPWQpfnRZvm|8L{>GLq6
z(16O2sGUBR$63{e;fM6&G3fjMBZL|@^0R_iz35W>KyX`f8XVMfrmM2Ysc;~v`^FfS
zH)_~jpUDGtu&-guaRv@gc63ABQ70j=NCLwF^2@Xom9;(+w8$xM@g!@CfDH!QQAiQ(
zuhE2GhS|g7bmV5;*J!*PBkjjL4~N4s&lBwZNado!W4zNmZmh)#I<bvUYvWD{gGzWV
zGJ|M~#BO50^1727Xhi9Ga^w<XC1eg7AmiPY`$#PXa4u`X?L$_0Blk92jFw*_!ceM4
zfh~!BJ5II_mXt_hR_V3f3&CB)Rx8CgsEUNXn{^>OFPVvG;Ogq2{8HhR*zChWzQHUh
zN9U<S$KAh?%mBnyUOTaVm0R3BBm8-~tklpN3^o!pT3)c-#Cj-H0ZR66cy(}R4t8I4
zb5IqO(kA%4zW+j)nER-&87ctGCMX@NRO_@VyZKI(Blq_XfUC(G9FJN(5>&k5WGvH1
z4djd12bMiGPKeGPMqi-WJP7#~e%1EArn)Nq=k{N=w+TH^w@-73!5=?ugN<YA%9dFe
z#`)|5=Omn|EU5TOBcd<Dn;$U!*-R`igjK^>D5GibiHGvZPZE|Ce_m!lHOeRZ)YpzG
zL>p?y?}N{ezd@;PRzkVuJ>P6ye5!Nl*&bk|p>anSd>Vft7e;B!cBp%o+H7#^l1irn
z;`~G4Y?*KRapNIf@X6w8S749K_DZbxDBfKOe>=sa@4IkG`-NqU!mBI4IO!2ZMpT2c
zMRE%t;((sB+Z79)vkZunjNm8C1;^EKdWhrIT#WGS@?ab+(Sk!AwES0o8=&H0fzBi*
zD#aTtX7eHtSx?H!VV|d9U#5LKm`~6~Uv&dMgJnFNyKSv$2-sy$4I;i{3%c<_>y2y@
zYH@HkY<-tBKnzLi-_@-MZ?{q|Xm{9#V<dR%Km8RTHmCY>`@Ps7!%CnX_jb!tiLdEF
zDyw9Jyty%q$J2q6Nz@_7hGRvFDEpr!nTsA-zD(K~=)&J<Jc=DdMXNo?f81|Ois$qa
zD<7%>M9^Gb(iH<HOShVSsaWMx+5*Kx1%FxYUh7{}$HG2}et>tt`_Qq);2%ThPWyb{
ziG|94&<5+Sbm*P;{YKM)=4;X3cK;Eg@nI#OHed7FiLLZhEY~-ERDK^E71G>0$k3H?
zVxg9Ul5)|}1_5_QbYAngvaI))fpCDyw6gw#`@Yc^`Qe>i!txi-Khki1760T~M>(_^
zMZBjBlMG7;0yB~TFtnr^0W{sB==$T4XWb{1HAQ%6$s$nk6s&7aWXIt>3_Z)ZH311N
zPADdD5}~fmg0CCaS`Qn!afZgqxPIueM{Tp&9Q*YMXpcMag~|I9)VX)UCJ0s}qAu7}
z(*{p<VR4Li){ZIuB|H;1w}Hp$e*R**RCLMC^L=|w55CjlxgM$UPS`|w`a%}+SWIQ&
zmWA?X6uKM5VR`JpX9=|Z{(oFVK{Ks+(_q58w~7!jh!*fx`QK>)oeX00_W?H!Z1+q9
zF1i<@u%Mq;eVnH?bO^~JR^05o*@cN}!V(O8%N#R{34(NP@P?zE_4ZiZZZ2Io4V!mh
z9sWCM#`CX<wG}q%J;eUMc6pR8BWasd>;U9>I@L6Fd3i2;;;rx;9(maO9N}i+f5S^(
z7~|kM^PiD(-u9+!;;IS}Pr|uPN}7=`K;+s;$9gxVM-&YSWBJ_r@VhUF<+Fa}HpaPU
zq<+RC!IHk-D##l(hg??PHsY6+AddA$Wm0aI_*ciX%JDlA-PVJ&Gkfb@Kt|{lCmeL(
z{YY0<%o;E)LSS#)a72FPI}#jABZ?n;98fW*{`gt=kY9mwbM2HX(tP(=ashja96Ky9
zLgAwm$x0H~3k+d8|B{#F3;0^+52#W_LQRQ&IQOiGfbOC4yd<lR-T^XNcPH;x3PSN?
z)9L7BB6S*#xRZojq!S?$*dV<%ps+(vYySJm4)HhbR@fOEz=F8SO2&&QErus%h$gpw
zT*$C?j<4;l_ngElT6NUkbGj_*_kSD*7;8^#BB|k8RB$le)qLUxK_CajVi^QuHYnG4
zv5;R#2Fx2~e{SK0Z+fSvZ7o3mUU5(iTyO;9blG1;?csN+@0{t4^}akQpm)d_3y|pD
zzq2TX+uoy$GJ@Lk^`NAPsy4SdbgCKQ;hY_Ho1$^nDyH9ujt<mL(>#Ajo&TXiN-uk!
zA+Qc86vj`!r<h2B88l8OVV7yroY&V2#pLcD?<b!hXRoh_B*Q%v?md7*{hR!-Wa-Bj
zl}21pNbnVcQdb7sT%E&Q`qLMJS|yrGgmH-xx}TEm71bUcV#Fw9|2ZV5ysb5KT^5fJ
zMjKraYL{T7{l@XqF;G5S^xQMxDMhlqSO%=hRq&Tfp-2>Xnwe-?>y?m;6IdJhDx(Fd
z_<;4!$`0ph5~vJY-j^1|&s*uU#Rgf}Yex%kt)o8;O5!5jGsVpc-I#lk4?`IB|E_%c
zRYgMM9~X5?7-0wiP0|g6uNW-v#aJF&z(m&Q(58@EXtgpc-z&?jk$B1=Drf97oiw;z
zrrTpO&Jfi<ac43fr9&4JVjIAH$H&((R<^^CPW>WfT$iB{V=7$wFBG&-5N(pD?Co`L
zq?JG+eysE~suTi2DnylwvG#>vm^?si{63ZS&o$o)9^?iht~xHoPoI56PO~DiY@niD
zy~Wm5!G*CpoYD-mmjQpRzm$>-^rtcs@Fe}#O(hrs$!!J$%Z{fd1+ro=*Y)E{SkL+G
z^6fUeAM1M3RWD1c+^yYTt4m3p?G_q5yDou0AEX<LIvqe;LWd!OMgE0tZ_pC}dd@!5
zX0xiET#pXoD`OCZA9<ZvLl4s{*Lr-E*0r;j^ptbJ1}roHQ+|0*;{$}FH#5Pwu1K5l
zR8yrmVQZ}4Ce?LKB&f?q#pMJQIxAGv657vIOSs|p>q(DR?N934t0|DQWm@d7QRLh#
z%waheS%y_Mxh${7C07}D5F+UERxAc`|9Rvi5M`|h)PX0+beiL=25LJu9}dU<FUnJY
z0@^wCwwXS*rWTN)_R@k)h04Kf%2Pt4X4P0D5?LFSy|M?|FNHUu_|dolo-=r1YyTIO
zlspJ;g-Onk5-6qLC^D)GGbgqaCH9Iuvl5eRHbs_Xw2Q%0pGEu+2tx=&&Ows*(~q3H
zMrtYfE1Q*Aa?TJ8&_$1u5v{3@Ti~>CK5#^~OiVkAx#0gGLUDbY?fi2l<?YHPj?WwJ
z;AeE?!NX-QIH(I1^Nx10JgyAvpejN@fS~u?1Am=CfemLD!hG1ssT``~0<qc_nXLB>
z``tKrrpD<a!9@(*7k%O6VcW<{qfZk(M|8gr(%ta&#M_G%aMSW*hban9Y4bB3;hh)`
zkgj$dhX?Vqtr)yWZ~v#9LaM?7m01|poJJ*c-cbEu9ZlRY?Imfgg+O2{5O8TA_Z=Uf
zApK?7-M6fz%RAo{nl$hcuw?_FAhPN=mBWlp7tOZR-=>b9Qh&X>BAVlLFUV`R#KNJ9
zdYu43c{?(aqiiibv1^`th!2g-FGAahba|qwYC}sdMqgj2WS$S+K2S6&@Zf}0U`Uqe
zPzZ-?7qXW$VlXiox5l{o$?%uZ+=k61O`M}c!imb8OtlV4R77t!=sX!|OOvG!y&~nB
zo&#m6`tM!oNiZe47AjHK#lE7z#}vFW6#KI5JvJ^=P<;ce+uJeT3-XjnbC@wVSfKx^
z9<cmI1|aDDxU*oKv$Oe7UX3liRkS|}UTzDk!Krif=)qrS-qS!1egv8+nLZ83sdI*2
zk)NNjlteVnjY_5fAvVZCCtCyaZ%h8Bvput@UklrZP{GvngB=*~iP=eUrZ9G+C0t*m
zIzEkl2G)-8Zf>zinJH$|!dkfhl+F<Rfd(0Wd|KdIK|e`sHwzy|d+2+H8^>>_ZAbI?
z<r}4xC*lQw%UIRs0V>DU?bu*)E@jmc!UshWZe7u~wBqnNSNpLL533KbD!^@35J@Ci
z^+e}Sd$Y7*_N3%t0%u=0s4ABX8c{UDkDU!S3E%YQ8s(Ri${<GSX9{^VBewVGk<&u0
zwYST)zfO)vLQb5(EVGcbvMI8QwE}{=B-5Gl>XI#wa9ye}A562+^Rmd?a#8{!vV?wf
zsLhbx{T{{AaZWuCb@*#mvFLoEB4YkP^)c4r*{Q5yYHbvZ+x?l%EK%8dv3ulETiFy(
z-qyndb(tt5K*e~stM~e)g!M_qLsk^n1YK{Myw4YOW5h_}DfUlU?iJs^%h|^)`aat{
z17Pv!v$7Lce-W4ORQ`GP1mw;?ufoUDq4u8OpL;<_-LnGo`SM?k%0N<b$pdc#<f<D(
zZM7g$@3q}JCVT}3F~!&4Ec!Ezge2xm(mXS4nzOs_iyC55R`V+h{2o9ocTxeTDvHIc
zG~uV0IDQB%Pg8oZS4K_78a&2vYI9DTwXzk}h*gJdRx!{MMty~~c>3{ghIvvx@StPF
ziwadH1<|)9j(7_}M8PIgJ!4Gmyl-VldYn1WwCN}sz+Hw}SzWw+vv=Mx`>l%{<H_N#
zCH`$a&{$r9GFeAfXp}SP<QUmEd0@@;27_>&j{!@CaadJb0MC*Xn{ckmwtz@g@rf0m
zf8@jmYgdN#WSH|9pbvcPmpjISd!ZR$M|UTmP2RXq$oX(g(3akX`GgP5&GB~RhluUt
zRH35dYvr&W>Zs*GvGvT=Nw|aq5hhSRZ|?48L?f(!TowHSFej-q{FXT+QNEd;L);tp
z!_yeb7bv>-#oE)6lS2_80!0j{DJHMHP!XQHv+xqybL;fK<Z!~S36lp1ITLCereEgv
zdbru<v62TR63aKCG$j<Av-!6-IkDrE6GFIXn*VT|`a(r<8xU4kU=Zaz(hOsy1ShjW
z(j+LV&$zb@i$r3~j;!c-rU}xlhWl%PHdLpLw(7K9TvVVr|I$<>U;+szruN*avI_u}
z&=D_Sqoy{#<|)6}cHf^t9&SIdwJB(sR&Hc$Zv>0aZt(k(a1Iye><){U!SXxS`!XRY
zm%a=4<Y4Y4)Q*NGv0YpD_;fhy|Lkcl&3N>&ebU~^9<gIXihceHvT8iSP)mcj@!I~_
z7+&AsXt#K!zC%a}Gfl|ohDv=yzK@4W9wsOqtmFtz;4BRsx`iPcPUxN|sYC{M1b&J?
zmI&XDQ%0&y*OOYEw64rZ|I`pQXMVbf=zW@NBLu2q9<{Ie!>lqv4n32#<m0rk!MhS`
zoh<3ueqUMmm}#Hl0FrBLlwWaUFfalEUJ?_1UbbC)38_Er&^E)r{IKFntt{sr=`g=e
z8}S7-_J71_j=SmPa;_9anTuI7(>!=ekg{+3!tlRi8ET!ct&(Viw2CQcNyiIUP$bvl
zGJvWMFhE1D|6+7-Out82)hI?Tgk`&~V8-YvZtCnHxu)fyjd%GF&!*rFDO2S}CF703
zkZT<QDvio+>zW^6!Wb&dIQB0IK8UmOEZM<M(jq3FOZIW~1(=(zuN#<^R3@S^<yysE
zQNieL*(q=b;52IA%!cB@r5$>T>>gk(=eRsMzI-b~Wu^A0A9QYdX>U2AtiAv9ln8Lq
z1(P-B=)Ti8v5C4@H<i`Agy8@%J&c2JrS1_;-R6u?IC{7{XdwN0Eco(UGhYk4`Ldcw
z*1-nFk0O?R)vb?E@LRt|KtL~x5bokwdg+R{HD@9mP{UZ|W9*|4utjgE@cQ(5@ZI1c
zoF4u)<=`S<o6NW~sUWTyLKa{wh>XnKQ}!f`eA&4z$Gp`=T}59MIEsxV0N#!O04UAc
A&Hw-a

diff --git a/artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-before-scroll.webp b/artifacts/powerx-1220-delivery/screenshots/mobile-tooltip-before-scroll.webp
deleted file mode 100644
index 01dfe68b18c1d68ca22e010049b8987c75f500e0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 36852
zcmZ^}18`++&^3Bu+qP}n$;7rNm}p|#wmq?J+qRudY~!Dq_xtYs>sH;Wu5)(PIS;yf
z^;*53y_KZI#m{2^0Ch281vLdu!ks_YD#pNBK-2&*LJ$Ce75ripuIw6?%lpSy^w-x=
z!|myNwyw3)J>RE|U6Ywth`K;R9wJPO^f7_R)OQ%NN3TPIbhA8&WBv0sLPy*;_4gP>
zccRP}V&~?Up#81VF0~KaM2JowjxV0et7C>w1f8$tj-|GMFQ0p?H;Xs3E7cc^E01@x
z5{Sp{yRAC@a-V%Kq4&$~SMSqzZlCP0&bPD+nXj)EkguyITj{SPABQip-yZ$)17D$E
zWS`S-+eM$!d>L=kmkiI{Y4RiX+sn)EpTS=|?~3m}*Lt(vDPJz1EbrSX0*C^gUvMw7
zw@5Fxchye<>mSBl(~lV+F=6z>Ul5P|D-26lWj=>r6#FEf&Cder-Ta?#Uli{tJqUL`
z=U+D;N?$Zz>hJ1TU&Xc?0^>e=Ul1?ak09@NZ$9raH(w_{HlNAeHD8CH!=D(J+s!_6
zU-Le<U$WP5A1H5M#l>G=4g#G%UthQHBHnv{zQ>$ix(UcgfUR!RneHf}*u(z+ED#SK
zc08{(S_!Gw@|()-P%ImXzX0kRt(hLTYb2!T=}cW*x85hB|68hEfB8+QP#7(jWXN!<
z+-goB;Xv|FyR+?vEh8Du`vg^IZHMDsNG7sO%6Lk`4miZ1j-Pqc$}i6E*w#+LtVrEL
zPuLa*M_?5PYow?9J*EaKEwJYt{IJRy(8p<H$sD&2!iLPk2dS)D0vPn;HlFWzYohfr
zQf%s`&HP?PcgUK3aa!ed>p23DfA+9HC#$+@J)IMX>gEi@s6Y}7>nllIE**luRlzHq
z&3Ucf_bjb%`072}<je3(Esr{Pp|*(|Ltw}WIzp0I(WS$!aW(jpZ0cuNb{RTi%OH_2
zS2|*V&;RR!yHr^_UF+R-AZGj&AL*iQ^2W=vFf9Ly(z_57G$XohDEzotBd@P0A$!uV
zWR89xRs4$V(~j<^3I(__Iw=RCXhufnD3l6E=FeX>(?ry82y#2<Ul-ifa|)E{d2tpL
zgS^^Zi!Pdqz2MigVTQkQHY2R<t5kElCXqeLUi}r?lCYampp8KVh)3B=Q4B)YtuhIH
z@-!;J4|#%c0l!X(R#8&f>zr;I@~+3aG~{;G5iqB{iPn7PD6C+21-<Te0-v{!=k#w+
z0A8@f!31?cQ9UBrAZrYQDU**{%}C{1k5p5e7SQka$I7NHn6lK|qCS;56SfTfg&M0r
z`AVyWf}(U92nG=k7-0kHow^MR+>akKDu|9y8T6do?5MQ8eEOki^OSAJC>F<9MYr^o
z5&e9n{rm0Iy?f{>OU>?=Ob;tUYSH)vh{azd#M-_bzY|TMAwT&#M2<>6nz6=uTG{)U
z_d?PsE#ok)VIm_LgeEh$2{`GGlMAPXXSsqSc2*0u>9}_vOo>a-Rl}W{wpKPU_<qOP
z@zQ&oF{8k%bboY?Cn623H%f#*2+Z{rd1f)yM?^IJbswvj=T3DZDg<pcF9Z^Q3<|?I
zx~R2LI*-m#to^*ost$@vG*Gu>Jw<g%iE7db)X#ut$TcZp16OM3ft`3}K4cgV9v<`3
zs1h}_yQY=c)z*|kJ^C!JYWfFk*?l9M@bW*)vT7%_XU3*M^+p7#KvwCVHWJVgMq`9}
zX7?@wpRvP03}OyAv6aQI2rFAV%Y7xQ1yjpLW^I*ZV9o48Jf77`g*nCb$quT?g0SB6
z;?y%n)(<7W>5(X4a>^?9)Nq8($^^P3ZU9rfe)5Io!!-saS;%0GA!i>=w`Am{*g_U<
z9C(DTGQ+-?I_ayvGVj4bH@0|qNaiuNK2?3Tcj>~PbC>P0qK&JO*zurE+Y0c*)pY@*
zDo7uBPW%9{$d#<bIO*$dPK<*dF2+HjJA@5_=jxR&TTdDw^f~dp%}J>y%%j-M9DDN!
zB@AU41&0c|J&BC2Yj)ofyQ%;cKbjC9Il^HJrO6;HQNZAGb6GM`zh1FAimnE!*i@kX
z1o{X8m&dj)Ye^REHYa30(YjqOp2%ihN8e~PqF)HE<Uoy+QuInb$%d|EPn#AYHL}Or
z9OHIk_b5w?r%m0gKT}0*^)V^?kQ`-9*b6EyM-yxc^EaNMie^-A7ge^&#fR;Nvb8No
zNbck}xhcEI`8T<Sz31q@Y`$@!TTk-QWjnT8FUhCa{+4%b5d-22TYw5D9`Fx+yPsHI
zC2HR0OtLmZ%JAw*Nv|gMSkMnD0ihBc1@6PX@-^fXrM_wp!(iAVB2`AG-;VpozRxV^
z=UrSp#0!!YTVuW?49nzk|6QuVLOzYxqT!nZY52Iu4p3=Ax~gSMUl=uuxQ7b)!Q0KO
zocb$)!PYFk*8TrA$a*9J+ZqMieu`CU>c3yUCv%iY{JTyexWQg<6yrccHLi4+K1QH(
z_Z)*>fc!VW8ihCd?34i%>+h0|9r75%ajLX9g|kGysl6)R!a<#3z6DyRp6FG#gYa#p
zt@m;!tf<%8(5}1spm_2ZzX+IJ7oDf)kN%_u1>3rlVipy7zA5sL8-=^~$&DZTHNnD)
zES~w8b|yDPvtqygWNVH5kMWR!DPdJuyZ`y4oC$#pKGM;H2tDcoBA;pN1Xh+A;^oe`
zPlG5wiBDcX^?BIe@XHw={}&dEhH&oUNdJF1k!`REqfp=$^?=o|Po(>DX{$em-YA~{
z=kxsd7t*2fChr_(*Lm~Qd8>^g3H2ZUHcIGUcZ-IRUZXZXDsh<!^0TAYK<2GfOfe{6
zTrY>&zY&;pC`0s*O@#uvgRuVdaXt-V86nBO%M|V5@-`r`k^ydxhJ(f#9E(+C|MgjN
z`>#)|Yl8o?YKG`E{Yk}=48&g`-T9fwZ3+#^RLb|19Mu-~f=<6Q&DqfB*3{x0Vij37
zvjUzARr0UU|7P?5+OKu9MupMc`|e@2e43D@b-3ua$Ya^kp!+%253v(ZY*7~&{a#Hi
zc?Qbrtnj3Oe;TX~|Lso>|JsZ=i8~hEpM;=bI}pCW6tIezn8;-Hjy315&_fBq)zyPN
z&c>wi?y#@@C*P4x6aWf|n7-tHLay#?Lf2XaT3J)Bm$}Nx(hCos)nNQ5!wv-h@R@Hc
zTcBX3UH&&%uJhJ7`4SEvo&^T)AvH@mUFuPwz%xA_PU8RTP{@CwA!j{7y$Yu}=lq+E
zw4OR7=Fjj8XStTnvMe{{-}Nn&g}|Osks<7^)ghY4EC0~K;=67>{0}h9m*xE?uWhI~
zT>bwtw6LDBLW4Rr#|mJOtd3n2Fx}(?ppXh#rR!GU%TxRt!mZ<D*!zcLM2E6~U=m!)
z{-NN{y6~aqL#h1A{Q^``KSsDIS7drKKKQ(wwCEtrV*gvr)-H^xX!ftI`zgle5pcTw
zL5+@ojm^a1{s2McHq5=~S(nG}OlZMtUe11))>QANm;G`*NptAHf6-So|KE-%dOQ!*
zSOgyS59TQw+2hQON%Lx}Wv1-Qg?`VZwh=+D;W_h*&S{r!F~ysHbZ$@&h($<Gc~y=D
zO8qSsrlK|0zXbFbSX8LpQ#f>gi|uc`$=Zm9&cR5?)x2{}kc`ZPqc~mfNu{@75+Xa1
zq{IV`ie%3c{`pYMxYhq3G}t%P!o_I+@xl~X?01WZ*;j1=|3rAh$lE{6^B3zN*8iqA
zPhDIysVp@3S6-@{DO=L-z>=P2KlRQn_S?R8x@YWQiy5^dwxPq|j0`XTGRf$XJIM`L
zm9Fclvds!Jo~iVe5U8n$$`Taqjhn~+gTb055bUm6I&c~F76+z&Og?Uxl{8T;KDrH-
z_+bmfWajZ{-rzr^TQo~eL<^dA-AVz@bk~xs8}Q<GYA6m;)O0-Ehxk8@pjLKsa<b&0
z@Yg?-FwNaS(ZgXAB{uB?KThN%(lrGHf6Vp9kRlZ4DqHVCydt-lC5-+{NjO%<!O`y|
zZ6+x%`UD(zwrxTYJ<2p1Tyn4!QZGmMTxVhkhjhs3gK?XD(e$c!&Dl&>>|WhS#8e9M
zbaj;nrTzv&N~s#ddNOe8Nn>6gi{+y5An0eD!c?Ae?Ic6_r}gTEA;@8w=$U_9SK3UV
zs*h&o>)j3Y`y}iAp$EE=<hv^SH@tB4Vx5b}6CYhZ<NtUD#DOh90lxYdhFS+RD_<tU
z;v@`qA*0hn$)yU%nz$*=Ih~&9#ySKjQeOEEcp?pa*ia3l%Hq<BNQRs~Y>r%v1aRG!
z;(rY6K=}IL5}0&=X{}(0Cn-JoHXV`zmkAU1&_rik`th%d^HX7TNIh{Bs-|5Pjz7sD
z+=St2SmRoD!c7NK+Qs<3`EF3e{3EWLx$AQs*O-)M&1rxBc6>kj`Kx!{(U2FLZQAp^
z7^ZmyshJ-tTT1$l4ga*m0abiox**T(BDT@d_+iWZaXCickw98Ah-n4=Kix**#Ib#X
ze>cgX=K|&WS7R$T26NK<3wyr<ZeAMkTSKeLQYF%ifNznqbdg1W3_vZ_cd$CLfH3&Q
zu}tCRGY>e8_WB%LD`vtEjIK-AvOPefM<;^yxk%7zpjSBak+XxWSu}?lVrRo`nyFt*
z%g-D=!$HNKkYjyO%Kj52*@ho-+J9)vt;hObEUY~si`H<qZ)l_BXaa)>wSH1LAPB`!
z*>z{xPHY{oq?SG!q*LJiFifyDs=VPLnqMs;Z;Wu0_$SX66F&TP)9b)fw;Y4h$8s9D
z*EuT&|4Gy!-A9GJgL;4qT7VDTbrRI1QgvvbG2b_aL9dS}wa1**U9rF1B=R)0somzU
zF8q5~1MI&_soLS>IcY6Rq(v)n4tn5ne@eCInf7-{b@4fN=9c~-m`l4MP8fw}8tyuX
zpcVS(!_R#YBFh}B-!GmC2jP;V1k2A-oTQu^dEPOPxPKB;OY4aoIuA`lL5=r6Dq)9<
zuevJuQC_%e-Sdn~*d{aCU9<DI-oJzL>QuiN+)?%+K~`Us!wGYvHH-J*$xk9TaC)#Y
zBxLe7{=Q>Sag8H4C(<&MR+syy9y~Z4{i*-%n*e|Bn`R;Da{o?d`biThq6IVA=8ECC
zQ1*Mg*`|Uf5EA1_5W^c6NVp@+gtpF=79Rhv3|Y*Kt%-j9<Jte(2o(I<|9Y5-A5>T}
z{5&gmHhNFWTo8+h;r4|txq);zU@OPzbd_3kgUWxT{r_ue`IDqJKT>za1+|Bg(!;5G
z(wbMch*WQ7I9u#vI|AXog-#F^*foF?XU9kB#-1aOpyKpGR~>U5Sh>73R>kZR8vfIe
z|5}y*{iGzy+8Ramq~>Q!&musDSBV)DuO~zgIE$n7DeY?cV9)p~hf}URR@2k)M1dJ<
zT)wIPzrgA>5Ys_tb$oEpHgW6@Foi#Vb#_39Bn+0_dotKd8R(-C{7zh?*s(?z`#{5g
zK}`%~Eykh$CZp#OSBvUUDIZp^-ND9ttlIbab8dh!M8Ka;ETU)Hy@3n>Gq|bf457%2
zl%@wKDtc2^^P_x;Mj;jFz}(9Z`2O&i(6jTied|nb=$06X&n*p*NH#ghTVT3CX9O3<
zr>|{PbVfNA#|_6)zj|QFWP?|jlot<D6zer<h~K|ZBA10&LyGBHzEOOrAmUtloNSFP
zkODyz30a*1e6jrNc((5sJEM1e3fIy6svOyM>&0f{&m|Ne4F5aS72}LS$51Aaama2F
zzTA`eO+&o49HbYk=a^x!JY>$wx(6EEJEBg}_72~lD{1c3hn<BiX%UaTGHZ=C-_&K4
zP6y1+Pjo2Vr<VdS*9K(GYl|LkZ2}ffc5(5I<h*p;Ofl(i4p{>#a<axTbZph-=7Med
zumLK<q+-87Vl94ui-)V;Wfr#AcS`6P5qtdBRgFqDblnZInv{9R-NwVSl_{lR%*Sly
zJ|66cpnj2%hjiO9srnsrPOjPq=t9PUJu4pvts>phE4na%VJ+R2rUIme0WrwyNP2O(
zG-pu9@aP;LNDdlp0JeKOO-dhgf82=Z4NlK$+*`H0v6O<#oJFlwd~m`?Gz>mRzPebH
zx6Xn)!z+5w)jVq!?}jb##}!wn@#xhOLp`n1&)INkH<#o?vbIztf%$W8VCfXax@e4b
z@9%_<42<EKb(r5ordH+O?V9t<=7{Psx&mY`;R$I4XtJ~`9}c=}&_Q#^5#e`EfXQ{c
zxe_m-2h5{Vr<s?E7w0E>IDZl9n;3w4faBL?wi5sVuZQ3#)yN1W)9W2&>AyXG77glL
zKF7(P?APS7vN=P2i;^)jLY5f*jW4Fvd{C=71wk{ofAQqt^Gp|Lt)qReCM)q(uSND&
z_%V}tR8865SJxul+6i`^q~G*aR1b=&@l@dB$MF%Bi36!;gq~ye46Is#>;RgYLYA}o
zk+a$Z#DoU`z=`v6WD-YZ@$-6SZ^1pkwgkeo#k6+*O2Km)Zc+C-a+&R?wpJ9p7=vTP
zSa#wavkA)5j=SgG&`O}I-#Q?1L#KL5P$CeZ#enHduKH;qzcs2k_tWHTa`q!tW|#P4
zgQsTR8~Do=4dExKSp}mYin?4;N7|U;9QDIn$h(`g<yswwaOh=_LJ*?{kzUssiPMXe
zmzL#fk$&W}gUbO8vKB8+<7gI85vqNmDL=fQL2z+@^-t63!XC2a4MdC>L$2QaDw~2r
zPLdM0)sYeRfQU9#t#u!g8Z{z83&<4GY$_zq(`232paIi`(iQjk9m%LpOhj>t1T~MK
z`r!mxd@mwky+DWsObwt7jwoPU6CyLLp(L37uFkjezT}Xc_==+mAsBWStX|i;__Ho%
z)zZBM;ooT?(ukHGAuOX(ZU7$O6Ma~%C^<=Pl)Q_B-19s&X+&w=h0tSIos)1YHRr*p
zy{tO1Jz5Le3fdI<QME|38BrbNxJ3iAUBfwPpgE(}dXh|fktRQiZaB26Uj>XC;d13t
zRkAKu!AODCa7-n5Awke7K`jp<W|IS}br#k1t?(_PXL*EY!uaEmuc2J_(6mSgt_^}K
zjIGr0FMO0=VD6A>Up*x?UJ*eH96lcpV1)PLfS>D3J?H(6QtO=(G)w^a?S_}+j!StF
zd}@}?_kd(L*KmAWwVw}F`}(h_%@bUQ2<EM@KJEzt!t}A=^1E1z`?QF;Umn&@^4S+h
zNJ;m`;6#`%k<C-IjR)7Ej3?#<V^J+#;L~t03(K^V>!g)ksJmGL?b}H>T>S<pr(#+x
zG)FhPBp0^P5g%URs_@R2YpO@xWtx~tMuBPKns=R*&F{Fe>vnn%w!zzGnG@@D>xhT&
z1%!}h@q4n^!+s8dcPok4yVy4f*<1lpu*qjd?JMV$?p*w-Wccj|nDoPE#A4!t$8mZ@
z5UkE;u%cB^a4s3#{ZNaK=kr%D6b$*v>x$eBlCLJ-)dI<;rO^*kw!_<GQ^sl2P(Qz<
zOq#YRy6i^BHQ;fKY8`ePFGd-m(|oLYb`^p(uErDty^0<Np*ITk63@%gvl!R<N1TvZ
z81Z~P#>VET>lZwE-#Q;eU0?y3AZDOnye388;;QKn_a^!K_u+|<X$UV>FT08q9J;>I
zZH^)hr;`tXi|@w6(5Be<K6}ft%gNmMrK-AQ8*ag_aA5N~3r(`{WimK9UIEie7=;y~
z<W{DQdo~omoMju9uJ5Jhs9y9gAAgZF6eT=L;ey7_x2BJ7Rpn$@059*Id+w}GKTk<r
zoQO56<&JWD7T%FTTo@(dWn=~&0+c*Q;X_!&<O@W#5VI&4vSYYsz+9W-C3Kz*Vr6te
zVQuIg`8_=|A78HQB1ikVdI@K_5-6adjDxSuYmEjY7z8hMP>Zg8xRXyIsHfuFdXj@1
z>J?XPxp6jt@m5OMT$GzsSx-Ax;shfxzK4mT^+`EE6IzO7u5431x^j+{oG)Y|djb;!
ztH8I}dn7zD%1h1#^*cy!YXG%EMcBCFr9`W1L+)JgH_-x^5;n`DMdqrKF>I3k`(<1;
zX$wdLl7WYW=z740$II`jM%uglnD@;3X*?0y3}jZa=Y|mA+EzP&q#ke_%mApI&w2u0
zkCs}ODb*^KqZxZxiq?(M(zoe0!rliagyaG&k7_sXtm)vuQg?#UDbPG{yP#CIP>Ef0
z_rH#V<cF4Ey~|t*e20^fNoNqNAVs-p+}=E_G4sG&x_eU&kqQko#CR%t)Ow+lIKcv8
z=z~dLQyuAA$3j#9n^j53ea~w6r~m?u${tqd&`$Wq!HHD&IZ&7jH+~v_|Hj4%3?fyD
zGWb$Qp6JovB4R;oM|k>8TE1Av&~hzMbV@yM$>wV+qCN+?Tb(60(nGEdL57aA*`=xU
z5|4R|nEOmEor4*6!1J^I+YusR?&Q>ocbmGf4YCe{N;{`*KUPcpXu1@6pVURAO%`_)
zR=XkyhsZILaOo^t4!}2hdLR(L4uef@44q#88yR^5`Q>dCf@GFnh-SO5v@P8!n%+fy
zL9UNDrpYX6m0?kDME#^ThD>zfB6`L3uFPEjD>S{?{4=(ZLJc^()f`6fBP#DApiV*_
zcp%Jp66U*n)yW`SK%0@}JRXJBS`hmWoLz!U8|tm&I###13v{m#zgrp218T6=fW`fS
zAqSTjJdW|9!>9CE=BW-vO?d6a280a&-%$!#52EBrm}LQZ*+LLE0&?N}Ivk*sy$B?&
zsYz%m_~g7$tlAP9xVMyVaW)NJVlVrta%y$&i%{9%5}+^SFRiQAFwRfq+(U!{RnN)8
zd_6)=oWaCfx?Dp=cmBSX-8!y24M%s6)m<QAV4tI{Q1S(b@qqkPapOmo%4J8<TzIgx
zGFZzU?Sw}kK7aFKh*3NuW+L*y=df=h8MT=2pE|Sc)s11bpdal>`khHXWU<gi1w`xH
zVALcgB|N*YSv=(wmQ;VR@V1338(Q-~MFh~Ev-n%pg!T?=3B0aVM!qNufV<?NClZxn
z>1XZO(X&@H!zF$I(kxAc=HX}+W%!9qcysqBx5|Fg&y-0n3d7d4)8A62dD*e@d$CC^
z;^G$EPsRwsyJ#oljYyx_-yb+@{UX0BS}~Fk7dKV7+_l4uACPt^Fce9rZx7K1;wr$p
zP%j<;>w2XE1*(Yq0C04mOZ<!q2O++3X82;2)PCU>Zb`_gOH&nfbJ#C%hUIU|oOvCz
z#4n)Bc<JU}EknR45`~uU67J#&zI3d7eqYEqE1*0ogyc4QnRzLVj)oR)2-T{Cb~;vt
zM-=oEF+A}tTxp`UbE(RAPxhmN+2$?4H0rnQAR9N!ntfMsE6$&2f#`fUu9R+v2{+=9
z-aoV9t~yWW^;+!ShK(}uH9H0_+3pd_N><xlD+cy`WuhR<7>ub{K;m&`&X*)nX<$VN
zcdm6RTvRct5SB{!Ofv<8)FAAPu`;ZFp9R&|z7?x4!Xo-K!<HfrWJ$V;tsWhkv77NT
z82U~z))+6hX!j-0a5e5{+Bo}gm)PaBA>BG$Q+e%zXN5Nz4W3UkJ1ZAF;ckbjGsq*!
z1O()tyWstMpdg$GW6T{vAhgEnpn5j^Ys1!@`?30_*zF|${vtWT6q<rb*#|O#>PLCv
za+vbRYfkyv6Tr~fxM+$xuZsYPk7-9^x{>i>47-rCe_5dL5W)3Vs+rANBd$sz3w!ha
z`mSra5g%14^-mC+fSq~?=kB-Nsnk8tIYF*Z{Y5EO(cSDFfn}ron3jV!j1)$ojZhEQ
z`;oI&e*BGdaC-8N>q8Y8;m%;kDLYYeG!HJvt4V$W7$?nvcOtTc9#o2XsOUto$HVE)
zBu~@Vh59X_ra?UkR;4W_r&raHeujo3cj1q1@*uOgqReCS)sI$0oe+8W<RVn%=b`mv
zlHw2<{Zkw(1(PuQHLCpx`!q5i^=9Y3*F(^U=h*XLg=}Nbl7h`?_QweU`Pp7er9FSs
zmCT;RLX*n9b+ydTl(7i56dl&YJsL|u!85n26{whABgj*aC}q3k+n~ZZvkFvUr7N&R
z(X|a$<2MT-IJ4n!gUU35lePgd$AP!nMDId6OP9EIYMwRH`41#ov}vaTf`W*{T?W-P
z=yx$M`$fD|ClQgucYqtbK;72-Pwts*KP>ac@dUN{j*h4RIgefV1e0&#T)d*c!oI{m
z@uLdmCQ5L2GIt8}Y<i+%5Xl$ilT0O8L9<0I6n^NHL-RI_fHPLBBdH*ApI>Q-(a%mq
zTH^$rmLG%jYcCb{Y!9_k*ODx=pO87jh2>fk7Yw85e_c0tmAaT^=_wjO-JWY$YHobT
ztTX?<-qzN2vR6k?2mSL*B&h^(|AnEH3nJr1LmmWp2O~{6?gt5;#Ep&2JJDTwk=k`>
z_cHbQDv7eO)uRm9_cOJ~dw47>vJMcIWh~w<mUN_(n*%@k*d*)Qdjs32n{V1p4j33W
z;eO??Ke(m~!JDF%J7YI7&NkC3?XGP5YWRZVL1qfJZR!CPw$fe#G$7-GzawYr2u9*H
zitlDrG%Yna2Umd%kUZhn6QjoEVV5?fP`;uH@8M^^YA9H`>>`D34I5HuL5ih_2F$J2
ziZpxCHY`u5-3m6gY5W%TpQ6nkXNhNgms>3i$iA+4TVu1EH+`EZO{Bj8X|-B4a-j2{
zfCGTENBb0?1IjO!4`*oF^u*uDo#}R<Er~ST-mLh!EKnwT>o^u8$XinalYAuzVnbo<
z!2mbCV8Ff!&+X?mq5`4tXka$cEBIQQTV^hW!n~J<S5`_8E*Uva!Kb<NY0HVR->1Ae
zBovf&J8CgL;Sj?f!XbAp<Pe^M)+P(5&oD~NQ8&E(j%>$6neAt<DG^`_Oz4i)D1iHR
z)R^AMS&jWf=SMVZ4kVv!bOAW9_>hx#zh>bO1iELfSb=^ugPq=8n`Ab9bv}3AC8D9*
zikm_0FsAS@^n#A7Cojx|-=o@k<Z^dI4Ydt5BQ=bMgrIn!S6%aE2WJ=j-04PNSiBgn
zo91Km?6^3;L<1|7z?H0%D$SOT1@I3+u0V7Cbm`oKp4`SnMBk|Bfm!(yX7zjvTWYrr
zU1iALqe0J5!Pd~0LV9e2eYVlHwi*VWN;woC)yL%hW~=;7wp7TZ{<NiYacYqCJHJjK
zQNwc6l7&pehCI3p2eMf#J82hUk`>O@T5bLfv&HXL1HnW)%-mx=t5zYzYBA@P5~{k<
z_jodq0uR58(&u32YRvc7eXA7XDPW_PaCPcckLv>u_ZgsQIk2RwM5S>|jLuwy7&Xs<
zE)Kq)@h!^>IRVQ48em<<dnd933xxcqI<)G`EaY<FU#m@FAHc9&7FmKZZ|a2S@rFVL
zSlm)_OXEwYI6d;I+)Si;oFjL(0y#{H3{%X@L@)kLtncfL-*N1)c$IMNAE-mBx&@IE
zYDqYWjat3{bxwjJE=<I`G|QX`V=R_q;y~?i3HsEXS!H3usg-ZOUFeOqrvbIC<3j51
zRT*Pgos^Mup3SFu=e;b;$^$CC+~<}n+ERYO#G<BS%K?qkTIHRS4F1W?#W!R^3?g_~
z{j_si!XE6Tc>`~$;f`~d-?lDhtL7J(-zS2J#+jg+OY;ZZU-X`~6RV{iWajJ88i8wS
z+pZ%qj#UIk5=YKCmg&7ODZfrioFQ_zLGPUEes&+impI;zu1hwkMjnVm=d>+&K&ELu
zjE*FEp+!Qh(KU(95G1uqb7pq&#zUd>w_!`QPnv*{+1n}ztTIye!4mj3Qr`vMD!N!2
zDapB^V&g|1+-tN%|LFg|#N2zTk7Rn@lW4?->KNeJs~Cneb5@f(v|g73$<=v%G^b)%
zAHfs^Y5+|i1vIGXEf8`%{$-aaYW2+!UdHwj@>WoeL!|mAiBcJEDcuZ8!8!sBKoQMl
z7#xtl_hTIQ#Xpqle9z?;rQX1U`5fwTz&do0YPLU;sVHQ*tr^}Zu^^i2JNZIdpw(&^
z`!lV?-GDWr0Q8qN`x`$xv?r-yH>>A-?%?l<y^!Toy|QVcem~@>Xi3*(F??iG-(;9e
z1kXyD--CYp3XDX(TG7ilLX7c0yg&H)=jF3X@^81(n~pxhQ8|%0Zr?=>W&kOG#S`#k
zOKrYM!XPb<otz#I(&TR-*1Zez@u`jx2B2$xXVii7c{;tufsv{Ra+%HeqZ?jnNs=~*
z=OaLdl%WFl+(O2aArYjKPn|fMP_v=fWy)S3r5lUs1fG4$u6*~xu<BSr!G(|p$$z>V
zY6Od)UUlHYmH^c4moj$*iraLfOwIQs=P$pxw*esoL@L@iRe}byf<_6kuG8O6F4(<7
z^XSodoS{#)CvSAD7)oE;up;bm5hanr!uHhJEh>c*3MN7N4vQ~`D7y5GyBxr;GItK5
z${F77?H8d_qaj4&Z;SD7j?AWx3DT9?Rb&&@i@h~$y|Ov<HH?>!K8u3OVL^*YYpEA#
zg>#db&t2H9bfcYzz*CwM1BL0_?hDRIeAE{Wor9kj&un`@B2Z_U#4SY}2SU}ZQawUv
zEEyue=S1Y9X=s8iPywY;(_H6Nps^b5?Rs7aB%viQ;+!29!?JN%-uEfUlpKjC#Oj~s
zSn<}Uc;W2#n@NiBbG*g?iK+$UUCIV)D%B$5cynn8289NKu?%P0Yr+VVp-lD+xEJ*Z
zo%9S09vV~Kp|bG15$-nB<?%#cerbHb!IWd_S{GXiROtMAccCxgK)ja2T5?M{TMS~1
zls_OvLiUxzk#92>J&rT=l64X7u?Y-$oAawlDE|f5Iu(W~`cOPR`v^%X<K-S$YB$fA
zy+tUQI5;on;3w9EP}XkAm^ZQj{j-)e=Y6BF%KHd>O500b(%kNubv}_8FK-_%JYIj!
zJ|lz}!61ahmtj@7ssiIU*aLiz=e}Fea!xtcz3dvhG%Pl_C_;@ZeL2(*O#`K<{SGz_
z+u|W#UZn5RU>d%j{6|duWiZOxAhPU``T0cE{*K6jV!gl)DHvu;;DK(4+=zCDIt&Of
z2X$<&R(oS+ZFloFIlB@z^HXBkOE7nF4V=SBpguhV{BK71RN!}UClEz2Q0z|H>`}F8
zVluP@8nr5D2MwxhT-dVXE6_eIR$^t}*JkY;66j8G@mPe-<ZOv<LKg1H2ht^I;^8-2
ztx}H3r)}1G#i;KV5z#?OL|WL+*<M~0wsz89wh3V?-l=BrTy<I48!_Ok>fh65r}PwV
z{nF7}h_vDCr>MSMx5$L9F+_jAKPhn?B1*PdGe!%%I}1R~oQf7B`;c^v!<6CVKo<}J
zy<7!z_3Xa%J>?G|z>gbe$L}bNXByk<^xx_A<QL64%n6%Eg9PSgyx{W7HOJ_`Dj0h%
z{n}Ft+V|4sejHSfNsN;Zt}aceu3#i(n&3Pm*-3wQ)kd#GZK5-)ik>ppW2%cuujgD>
z%MsdAv76!lj09#EtK1YvK)&8~G`^xTz317qSyd^QZ)|@)XV(wdqH{7z%1&2zS&E<1
z$$tZO#*LdmTc_>4BO<`1qzwXhf%{?aC+)QHZK^F0KG}*Fhl(u07NSCKQ&PE5cJyLX
z0vLAa5Yh%gO?OZKAr@KyqU5oGnom#LGyhg;tF|`Po0n{n=I4P*)%ase#>HD%O07ug
zm|l{O`mlg8m}tmwG9=NrJN2Qw)qq$S2@;Bd3w{>9*l91FQt`n`W=NqJ#6D$4h~-+O
zM5DO~?iG++onpi+ac6(a{>|IplIlIx9b~`##q*K*n3^u`u9WegIMOC;lhq}VV=)L(
zdw}2|nXb}S$;eZ0S9H+1O&rLr5LWv_rt=imI~tT=ix~ojhBT&h=YEQOU$Sfkv9&Ni
zVgg(X$$6vTpF&)n&D!L~CemFEoR^dp()W-%G=TYx*y;;PcDpfmmw+}YmL-f1D)ZI%
zmth+?yG(fkKQ{vlK^D%Xo#sj@vbM>;@95RH%9J?&*eJyM;Y*QF9}`N<A~B;Gu9Q-D
z?BtU177KHtFY<mnUd@@kS(japONRD3hFu*uE7^6gS7TOINJb|kVC}z5mc-W2^lgn)
zHW|baKbh*)sUsFc*h`ka=4=y=Ay0DAJHd`u=IQL9dtZlDg$x-lU;_`$^@Q%n^*3Iy
zNO0MdQ8QHel=Z0c^eqfz#E=#s_c^PpXk|ZyXe-EpU*+{&a*s85Qrv+!wOPgf<0ps{
ze_l*MTGe_o<hrh4m!OiR!97ujsLJ3u!-ycyBO{3&2xjcPvn4q$(7_H4rUIgbwH~}c
z+`>w->;fX5vhL$`D#;it?NH-LRW$7geEoP^9K<{8SsnDBg?Lert4%V{rC2Zg{IN6s
zN&wP(-(!c<0o;2sZMp_8y91RlqI<~uu`B2yqk{sSDun87D&#@VJHEZduZKM2LUMzO
zRL{PjQpz4G^_JYJnx7N$z*u!!P~RHb42RU1=Zq9AmQEIB6)^+*H7I4C3$uj}q${?=
zmrU6{PeK7ffU<*ai9QU?Dw|0;Qep86u}H{MKlA>Pw?FOGdk0(h5`@r{PfmsD@LPep
z&JR)`FP_76^uTiI;aZ3HOoI*g&Q<L0I5c6qK-Nh&CjKf*|6b{1)h?+dl_5pd%mJ((
z3nQAh*<tE2gjgDxvI--dt<cZ2XF+$AjJFdra6UoGaO2ze%%#jbo`Hdm$+f57vO;kp
zKmqX%-;Z~4r4zCOkc?z@nuv!VKszMhnw85!2X}H7@<yXHwbma~N<#ME{10C<g6fK|
zkgw}LhdZpU5#N74beMk4i~;tvJ})rHv*_u1iC>66RcEMy)QHZ|ayQQRDVHZ-sp9kP
zgCV!9*OqCk-mfU{%Iu3vDA&~1Xx38g+6woqX?#5M^GWs%RL0Rdms>lPv!oxgj+YAf
zo7v*lY0MSq(#SA@B=KmS`FaWMFd|<ao(6!ZX+<YGkP7#Cm#SIx@N96??~CMTYsNPP
z=qRBfSKVvcUvc>{3SMeONQzxR5x)YGm(BfDO?Z6-aa^cgcgogU`c~0PD7Uy87+bZF
zN!4Fqyiy;Y5e85yjPFT_3y_)62IwvvMMJ^RoifSr)O0IoHqU)OYVm6L=R8UE_rJih
z<e!-dQ*DY(l%7z&$?qZ_HK}^T;l>J-9-^xge~%qWdmLkVjcgp!O#%<rd-w`cnuIXr
z=$GoXhS!&?z{laA_&(iBgeGxfJ9rb@nCF%FAv^06;8~!z?-^^vrvzEVStyTkA=MVx
z2?aF5xxWGa1Lo|DED@tS-ZC?CsW9OCJBS}JC}X(Ha*mF&5BS3GqUkD~AJQAuep9mv
z;R5VPwpA11P`@zFP&G^tU<O`(s!XSkc)Ele{$@>pm{8dS2>JqmRby*&sCqwvr95`G
zw1aSjw$b|r{p(0fycrS2Sd4?&{P;#zF4L;bNOcRWIX0p<I>K)@L9YP-0B8WxnR7Y*
zR~=5^L-A;ih>%dk+;nonXlfsaC4Qy{?e33>6pXIw$7`c}=H2YmR7FgFpVdH3rOO};
zD-YPcD`#e*(KE|_Jk0qPCJ&<x<6Z5nNK9HUI`;g4oB?dVUiw^-8yYQ;`@Z7hAx%DM
z;Qs5WPAZPM<M29yR-c*7zResMc&4KVm)?8)`}tC4nQE8TH3Pd=H2bW`{#+#^ZOoEB
z2b=~Mf@BJfeGf2yeHQ5!gBTaAVqei4VHVxg&2Dx`R}`+3kUx*qOoT+_v*|p$T0xmJ
z&|!Zik*TW9LLPy3p*xk}W}8lUm%C}2#>x2FL<_S?pMgY<5oc60wO!vb5<m>l0x595
z*`RB*`;PQ4%^S^SgLO~9>&)7A8jw~c>+*Fx?_Gwda23vGJA)v^=DW>SljYczRce<E
zKqlzYrWEFEKec+i&nyK(Er!sf!2qAOZyQu5a4&bQoa5~}RBi9WXzr|I)xjGD3x9P7
zibf)Q_*T~%007Cd4!ueayl(XquFyEm7Zzjt`>}$+h!kx*AU%I_gADXWFX#)b1?W<5
z;+>ds-RH@Qv#|xNWw9T9gn}QQ@kNvSGCNp2Xu*0d>Zr9>tdiN_uYyEO<x`*ka3aYE
zRp8W<8_w|5O1x{2A==I=3A6&i-PAv_BAb4r1v=k3c<GKrt3>E6gX7OuZDV!078z!d
z>lTOFlgNVjHJ8B_fgYZJWHuwlJyys{>zcAY6IkGj=-5dt?}ZL<T-J>4{&JdA?SuZ9
zYxkwPGZ8=f?g$IGmg9Wy*+Lc$R;)@W!F1|5{zV5}#&bl|WkvwZ>SWPgGC6I(>NYyz
zB;w^_%AasyQ%nPvOLk~cob-!c-oz2-eoo0L6;BKH0Grub>P<x@7A#8InZ!*<!B8)1
zq)PKu1>Q?jHn?0KbZrOvlqM=yC2r$|;6+A3F61S$2VQ6q2#zr&UwQ*Yg;znzfepQU
zjccc$0f*wuG;#u2RX}cZk^j`W8?n`))8!msOhp^u=`CfneO+i+>|G);H*yNsQzyu}
z503NUA=SUL*M3E3h^(51eP$LgglwKr$+vo`5bufl2m%`J_)JKQMb3rU-Im?X&~kHe
zGGWb{C&^wSU=h8IRy4Wz2$e%G2PO|QAJ*Kfki%FpzHaBIJ%0ABY|{^#b5`h6-%+Xo
zCiu1MTJ>QwYZ%Hf(9{et1&C!JVwQ9auZSY$TFY+q&lNTff?qaA-&{G@l!$_uZYAqG
z_)4fOFVQu;Rrx@=)mNKn!oU$0<~K$1JXw)>6yjF7_2-A3*=ThE5jG>^&f156(^Yc<
z^RPlFA+?+Lc2VE%MQN`WSN6hwyHCzB>4xyWH+h=KVTqTb6*^daOx7?GGO=P%xtmMf
z<3VD_m$2mpKiH4@7NnyrsW>w$t;8$2R7FMUx=w*Com+F&f*8#T7$81RE>z}y_E!V{
zsY~ZF!myIt!0}8Ki1}6sC`|v6K%dx3%Z5mf0kq$HwcYf_g~^{VBCa`H%%e_fzuZfy
zee^{o5tqFs$XpbXf8F@n4zwm79+ePKWv42CY{y5wXAYWFtlh3|{Jr3|z^g!&J*P#e
z!@98Bgq=MvD`hHJ6*3Fn(ycTybVu|otv@0QPgB&X1!)xCF5n#P;#+pn=1FQBMX6{I
zbrM<CbptH|9g#tNWnxCpa`}PABFAyOYr&*<yYl?lH`RG}j^5j}Z3>=jhW=rBCkMGZ
zIdb%^6>0<sf08bF$sVIZ@fghYc?@bN@a8sFnW3eFVc+TymQ}tA8l0S^TmU46FMJ@i
z2>_l##J<k;I;F)Wr^j1f_G_7CKGU|I!C@Z>Pe87SePD!MaG!X>Ywby@2I|z+<Q^*o
z=ogi&Sdl*3*ZNV}DP3(<CsVs~zbJR5MWvF@>k{$FF-Un_%RKnJPaUt&@>OIgre5i<
z!8M}0j)ht_zhyKv{`ips!ZZPE+}{`P_-wC!=Esi512ducBNw}ll8OOz5zSK(w%Wjz
zpJcETB#+wIpa<AZEx~4Dz6k7HJPAYkwaKXtx;Q~j%cVQsk4a3uKrr$S{fa<Cdg$cQ
zKZH+nmgLP?teme^sBq=Bp!Ym*`<%PSnl7>4?YV{;k}4xQS%@Qo!R$G9YXiN}Thz2x
zT^mb3S@XP(%>5^a!cA5Jo)6i-WzB7)EgksLzMRGw)R9J<2oEUBS$Q?|AjE2f=B$bx
zy-vm0?Q%gcNjf4SPgE?8V@fNBGB4ff->@A*rT(T+<o^BVk$Urw2g+YFhEAG1b+zQf
z;Jk;6c~)er)qS`f_PTvPhaCr%d-?t2HQB~!_kv4Wdvdm&a9cw-f||$~J1vnFb~PQo
z3>`!kUswj(Z|{FNYJGNcq?;JNS2i9U?V9MUbyLE)=>hh6{M)byQaA1Astwsdyr9#w
z9)J###GQY_2}&9?I<EeC?WtxCjF`WT=lhs~1!w06mVw|I+jn`tT?}R>)lk%Gfo6}<
z=`0eXJf+5g&=$6GL~sPo;H4k*1$ib;1p_fp7>8?EJw5$fJ@b(aF|^e#yzV`pAtLFr
zv2f%kQdnPZ@$3jlNM*qq5c~YtJ#Yf~8bHf*&3EtcG+s3PtZL^X-F2)6U1+cf1(SP>
za(N;@g~(<kXTQ^iMtjcJMHzLDDb|6+r(3qm=;t&rE2jLqCnqecKE>?%CBNGFK%N-i
zVWHtkI4lx2Q-8EBZ|J_p=3g8-O)FnY%dt@uTtj$5;6rtl2_n2yI)heTXgz3m*rn^@
z?H|(kF8Ea>?vG@~dWj#qv1}+Tde2F{Mw*W5uo~?9@=G90(a=N|bl9-e1=6c0WvgrK
z;KlR;p3>B$mNazJ*FO2TN?yU<Au2aJy#cvM1;Tlu?AAwPgTKNSg@CjcegQXc_om8n
za;C13U@q|7$`7g62Y6aD+pBoE+pv5+Ugei9Ev(K^h88X@*i~Uyf=a=5k(EN{w-vS>
zpt5zVHY}*(3G5@j;+4p;L8qwfzM3Nx`z<Cv;P2~tri5iw_bV0q?M4|JCkvG@z1~Tm
z(c{-q;~~B+Zm3pdV>JdV3wG<%M84`CpTrZvtOF2t)Sjzy!3^@hICK{iowyX`bGm4t
zO0Q!gDbh6GHtFB`J%GVeq$&15UBrP<e>6%={<===>{6Ex;r1-m?Z5vq;d`9n#P2$#
z7L`=D;Z%>Iu2%om^O-AL!Cc^>xlV}SqO4LSDcS8qoahT6VFZlf0|0m8Y6^(ECO*G9
zXKClGeq&B@wRlE7ma5y?Vqy1odLtO@Xu_Tts0L(a!{^k0RFg|0whi&5AXqM3y6B57
z-PEQM39A*x@LP<6+2-I~lcjRgm9H*KJf}e!%}2^4d~)ILDK(*qTlUj`D~$z0^MM^%
z&3!FpB~1EN<*3s&0vE*Tc8?GgA*&A31~Sj!{tn7I`nfQsUtQ_A#HatX<s(3Nb)3O$
zp_Z|G{wA$)hVB++pNJV38P5=;oLI$LR2<k=j8O*B!?jUh%i)gzqrO)Gdk%#7JLxI`
z5dZ**L}lMu!k{RsE{4Cco8qM3o~RGXUupwlq&TS(*DwbFS@wX3X8@ptNX<qS;}rn_
zGMTRwOe1qTySRm}P)J#W`$0QkMs1r3oJ^mw+msbGZBM1a@<^sZsCWR7GhwK_spE09
z1`o*gg<SR2drBxG3<`fG?#L-(z&G`*Bu+g5MBBj(0PvXq)plgD%pN=2Jh~i_r()E?
z<7)6Z0syIs=ty&;s6N~`Pt4lb(Bo1nZP(15|K&TB{c<_D*;Rqiy?tDj0W*0TLs1YI
z!en4ISZ!c6={_dO6!h}QZU$UO$k)X76dQ`ie1b~I4Roq{GTg~BPF%$Pc1e-EJv`-)
zrUpqqbtN(fBKC9yG+f$fdbLf@NM9FWK%*j2JtG6BsqCq^kkmJi`T9JKoE_jk0lfY?
zN!nx+OeP0%DGz4w#0a6K#E_7xBCKM$MCI*%A(fI&B(A8j^ZQkfxJ-YTA&rK9Tzowg
z0n)(tA<|@yKE;9wR5ng4<rAd>SNm<fk>!dwEidSLt{aEFr}`FlAR1p(I*$o45akx-
zsa7uCYOZ}lf!TdIV56<H%QK8v1Y!qNlm03G^=WA2RMq*CVV6{T1n4qVrpx0>MUHWa
z?f%!i!1woqZ;vJDs4A4`<;y;H^c_E{g#!v%jF0_YLfB*k8A$Bo1g>H*zKcwfp_G@-
zfBwD(42K_hFSoauOm>JNvxAwcJ}QT+#xl5{bUA7Wy*1gC*d`Z#H`U#LUIJnTK&p#$
z>2w(#*M<o;nxd>jta0<Mm)0!Rv|uSfxxMl_QSv<z9TmLIzLeADLv!(C&e*&|sfX)n
z^@2pijgBHtHIt4VA2FN_!ZDD=G&YSmAfMDN%&tDM&0!(WN$gr)*T`O!%bO7OIN^UL
zG_sGSermIglwT#eBHH9>N6!5@bfzW#U<cp|Yp<US2>Wj8BnC8RX(y6Y(XA%y)RyCq
z;R+fs6%r)ifuq;}F<Z)Yv~}BiZTIDPcNgt>Bx_pJ#<>5^ahs@=c-D}m-#v-u>IYzR
z3?MR|;XqcWUl?ni@<w?|?+cb9KfNUk3-XHHg2(Pum%lD1MercJbLyh9wfdk|9m(sS
z#GBu(Aw&2BplF)_Ko?>SERu%z!QPwZqHov8YdAL7R}*sIifvq%;q(=cCIIL)<3uD(
z0M&Ykx>6gbK3~8HJ^*MU5&*!b0d`EGD02D9%?`^g7Ij^07wj~f35Mef^rKt5M9hy+
zbMjLC8-(#n19vp`ric0y-OY4$Qy(p1?mqhB_55Rb9CA~W&vJ<@2y6_u=BF!>cN~L<
zaJ3_V?BsCaw}EW;LEA9T73kE+Y2fj3WLxBf*N0vJa2j4h<0}w%slm4`Y_F0??rj70
z53`*dWP=(6ZokfTuSO%<!;{mMWRefX6vL)l29@Mnp=cdzQmIL^ltEbqYd0v4fRaf-
zW02dMrijI@kkR=p7sAJi$_=c!$_QX+yQ&m@%zY9IZ8yhxi9S(=(z4kygfp7^NX#n6
zO^LLz=kqYkqazzD0sO)`S#lEg_2A8}1L@&yC=(Td<7trl^A<{7K~J08cQ>05(D&2>
z;0-swRL2vZWU1_2cy#gY^B|&%$RXK%gax4Yx|*HgMtl)xZ-Q!X*h7jpnQ4^a+i~W8
zoTEsMsPdr*i~>Xd7W5sTk=f!+p^3rQ1FtZfMC%bEfO?(N+@a8<$^wjyabzV&=*Cdq
z1_|1G#`i)`KwV;&clgw!;lQNA9jIunGpy7;3J3P1c<rFxR6bgwV#5W8;hzGl<urlf
z4eB59zO1%1@8gzm9fr1Beifu!*xnSKnx>be%xs0|NUqnOj!Ifv01&TM=3^WJ%3w`#
zdcHURaAOK)YNe1?BDq06J5`<QI0ymc^hy`t$-=qy<R_h<QefmD7A4-`&;AtL5Wh>j
z@@@_pu_Y!>tt&qpJqYw8de_*b1Aa@?iw(%faz7>n#C7`u@E5EjvOFHVAD;JdJ^X=p
z=ZxBsp-2B5Lu~h#VjQmAHD)rg5Yq^CES_4hc3Ojff-UTzs(B{K{gRpQ<2Ju`ILt`s
z*4Eo8a!HH43!cw!UXi2I9-`|=7pqz@7+%(}MLk5<T>6nJm<&JcOf@znKO|2|*u|_T
z?N&Oxtme5+sfH4oBc@(hkR+qDoiFx&$`5>-jfRED!?0jdUW%GL|FKUnkg(s3XNn6W
z&0`B76J@$sJNk2sD{_ka?wsx8sX4N6Y+-l$VMypo2w3+P1pqu014u|k&|twlwj!Ay
zC0EKqw+`!Y7I^`H#^;4(L5~hY*bp*!F0y@aKj}*)0+4lf?F!s4i0>z(V;F!-GQ}2#
z$sf9x#dzlF5&c|K?sV>ovZf%Q0D`NsXByTZ4+p~IUoJ3GgSMkuHc~xqbwPLiTa4@;
z_zoT*%CzX`pPSCDoN8<_&1F7X2R`-T%t;nleSI7KGSu_mq5#MBZE;!F=V>j`({~7}
z7dui!9KJ~dYNyl_c!Etv9}f{zOgTH|ap}(PJTf)mFXMrqwTD$8Ly@0x4e~n}sH%4d
zdIG@?BjOE#IE4cyiV__<m7|>B%(=szu{AT}iwh3!9EwoXHobm@izv;~E!&Ynho&*S
zX<Y!~R3>{hW7lUtJ|bOip=P0P>TKsXUwsv(&C9yWsf9>>syhIQIqr_7PMJ;(=&Tze
zQA-{HYxb->!a-QpK2X_vvWa|RxWnqlYdt)GGNq9XP+OxN^!H&ZDBP=3<ftgTj5Tr6
zlOX^A-#vB!`1F%ixJBt64Sc^;!h?;e>zQ~$H-(2I7;vlrw4kXBp}RR#@m#oX8;FG~
zdZf6I8JQZ5urBkH3i<@-i7cHF&(acf&<79kpv92m)@l#BzbP}Pg*dfBhZC$^?}|SS
zOU%t+56=$y0u%E%O@StC6o@-^#7Lyp`f+>}_i(Ug9_;tL3CZ{T3P3+b=tu3J9$2hs
z(aOy3&E(0B(0>)V)MUJYv4qil_l{4?HlSKXx_Pt=Ra@9as!pB~;0eR2-APy(e+>V+
z{vn@iE)|CIs_gQ0&>bkS1eNzR110vZBaUC%2K~l!rW0$W{V?nk0YOP&WQStztM;L9
z{iut~bj4~kUg#t3q8=dYzZQt32OKH40}El!bW_1}uX-nyAgDX)S2<8u8vC11Nr}}^
z`y;MP@&5pMK!(3=;$M_ycs}(@*v!09fgSVUQ_hYKPpHjRynG2IQD%HY55&nkQw9SY
z?C<=E)h<5nP&RX;1@^Fxl7yFAF0y{#lK4oQ?g&VE(&sPDK0Kp9hYX8-un;1N_#<pV
zYL`yUYb0(3_#sJF0@&NTeXWzvo}LOB6ouvDASi-SQ?AkAmcw7z01_ae00YRUx+gF_
zbBMzh8$9ma*56xaLB()S{8KxDzyK|7sY0rObZPwezIop5pjllWN1$BCg0WpZ>~RZC
z%-r!z6LD_+bkmkcw&(_GNk=$PlzdJ~to6&be3tHP+3rIS@SJM=!+lyJrVLc%I8ifb
z0>FqjXqskp7YyWZy2?O`LdsE`N3{9x^cSL5MB_(h9&@dse5xkB7dW`Mn)FKSX=}?e
zj+N_Sks0rg3zccD10bym++h|Eu6HB5<Xi#5S;1{a9=q;yw6J7mF>!xXC6!;i6C3CY
zgzVPK4*h7Io$BjH;3?g{-6nV9+l%a%pZ)_w<@w&?7IR+T_x6-yP9c_O@An}3%HDNh
z<2iD<H;rwjS%7WcD}FNWkh9L>bNtHx!&&Y-Y3}Gss>j|KE*&1_TC38^z!g1&1-G+g
z+*w}DVx)5hQ!oS{2K>BjOZgC3>^Rf3B%#<+;_wU{1o75=AA76dEbEWAB=Jj6T%M&T
zRo&{4Gk6(znxTafReLFtpjUxkSErbGk!>c~&X4#*p=jbBtc3g$1SOCTwm0b`Q_bqd
zOnFV}IQu^tU?-@yvzW^nrg`5OMPIfXkBYHhd1VJtWd+0DfT8`f7j`FzSKu+}-l6-2
zC((Gkso}z|FRcHZ*vLi!H^t>0ANRN?J=?*Mu>@cM5ni;Q01ZXC-aBgHo3>g3eaR$R
zi~s;yzRL8mNAN@+@gN1<U}Zsh=BQ{Dq>cP24xrFwJY*-gAygXzKq+tuE#1w!9jer}
zlUz<C(~t%x$bbL=FL{O?>cJSWbmxSaaQ$>oPc^}tls_{2v?>8wb&w?*T~R;)W_#cO
z1fG#JSwrn|yB*9{XA4ln-zvp&&;SD0EgrgC&C>Q;<WL-ACGBp6Brkk?HVfI(O!e!f
zCFSvlH4-o+HDYtl`n=N+HvyqfEsmxzc)Tc}OMq(uSMAXwq3#XS&{y|(7eMh*y#jo)
zk~>t5bNc821eN>%04$1>PbxxiZy8ZXS2`pB1+cABd1LogN-p$NZHB4zz0`vC(~_*t
zx<~kCyQd_@H|+!eRfjW`L?;-a<HoCoj(9K+i-k*LfpbLw8Scrn4!a@<2KLJ&)l&Gx
zlk5on;5?u$)W?**IGMZWkSw=tTX3W2@$!xnAFQZ2Dam}>R1M72`P<gryP!XU+5jl-
z73=QY+p@_ex3}hoxTiXv_kSpfH3rWPa#)sPm(_X<nTjeYi?>C`qm_iAt@?{@q4IA^
z!D)K^RdsT*pU>*NGm+I6o7L)zKJgVcK#M8bhKb_@&Ouj#tUb$`>n90?lfY?sf$1{=
zhvYu{uZT3)lR#U9r?$j>lci0yUq3<VmTm#-Kma!1kpKV^S8CmF|1wUEd82<)GXMYu
z%=ri*k<-)iuTT#*=x#s%jJiyg>~fxZOgXkQ*HuwNe#MHkcJ0gk<3GYO&<05O1Mqdp
zw)wn1R&}V3l6p$Y_`6x{GHnGRx*sMQ%MPXNJ;P#IJ>0L=j#gyUq#k{_%m8_}$3BOs
z#FvXYnAd&Z!dz?R718g*6lY>AfdwQY*SZjjdni`812!xYQVgnI;VZhT6oy@p>U1rl
zb7Z|3Sh}DoZ~CIc8#%EL0t&3xC<KIz2!5N%el?+d$@VA!49|Q30B|QZaN&^hwXlV^
z-~cUx@Xyvc7x;d)7Rn`WrkUT=HWzITkd*Ktm>4mb^0WFSut75`i<m~Z0s_tS#F|J{
zVM;#yBBp@Wht0lv=hgcXAaos>?$tNve8<`FS%)vf4`Aahw-L^T;>y`;sRz-KD}lyn
z>O(uvbzG<`Md$S+#xu=O_KZdmXl=doh$KHLK0wbHu&&Fe2O_fC`(}0jiC&5%3FJ2C
zejX8>U}ekCeruu83AdBbnn_rF_uDsbxsH&o_ZH{0o;fk0SU!XOBY{lm4OJ8I4dJ9<
zWls8^r|q&qaqz#C$wcmcH`-8mkkw7kZ#Zm7>O9$;Ct-h}NEpI`=cPs<Y&~$USiQoT
zEwN5t&ZC`PFtazS7wZ!MEIuYogL2Y7Ut?W-gV2yw$HfEmo0Yf=bmCmO&44o&4(WUa
zRcVo7+fsefC6*i4O(2oUU%?bHXt#RW`$Cx6!laLmimcxccxsZ4$qtI4Z-cE-aX^3o
zu&Y_1aL0dxiJ4O)eS0>ePe@DjaOwZRS!81yEkM)w00ANj002srJ@&a;kwg0w?D#8?
z01I9z>NdP|-wzc)4fU|?0K4Ow?5xxL&&3>3$gxg2e%<ucg^W*yVyTg^WO_k^Hmfr{
zdF^;iP+UXNuv_*4jler^jdqK=QwoV;{v8)1Dv3(#mLzYSN^_z3Bb|u5#`XtBQemq&
zZtm0U@2`>CyYrta9y_QW1)w13OPSpo$8#XDgO~c!=9AGalC&81?ag$4vMz#O%;f6?
z-Tl)kmMe$>!eE>Z0eXut+XKlfCJaPrav>_U4Q@Tre$m7@A4_U!U><JZOhAC8-_T7q
ztx!S;rKhHR1IP4x7HU18z#FIaJ*1sxj;jS;IC2ykM4G=P?><DokPP3sZmV{*`N#ct
z?$z?M|Fl)|_+_5edcJM){=fhty=g!I6Nw!1sybNgEB62Zwc}RkPnX|WFoQiw4bJ`-
zjng~dWwvkvoN{g;Xz)S{EcOIzY@g;sm>#ZuZN3n$TUcQRKUWRH%tol@0rSNBQD}_y
zuBC3ODCm#w;T+Naluf^NkfpYwdR~eY3v(EvHZXPRU}-hvHHu}&ZA^q^U3?W%^2@)^
zekIKl_cyg#S%upk%r#TTnr5djPNDMj%@<lTFtSW_m=PNE(Sihk@=eyvnnae?{xmY<
zCHfj?*p|v_AT``(GR0#Vs)LR+pU{lkOw34QG-uP(7xDd79Ds2fe8|av(+LSYF%0kI
zCx0qra+X^!R0)suC{8dKc3H&AgH6MjbFwp`Bv6^)5JSBXsfH=ib`{1k7j^CbR~d3^
z8VNYE{%NIDdla8@g$rWf#WF~_9iH}_ThPC8{l$E!O*H8pI`{6jy2W%*9CkhMF@j+z
zIuhIy=#Q%;7bOIA!mei5H$Ql)7eXD*Pk}JVSO~Tx9eVi}abi{CtgY)IZpn~h21T_i
z@_7f5F<Z@Fzl2B1twvzg$<oobdhGakjKMz}4huxrYWEq^@+}{d8~d63Hn0KvKR~^D
zt8JlHbwt|ec>5Gx8Twp8H25DI000@D_y7lyPj?)9B3x&_cv?vbw{fWJJOB%z;zB5%
zvtl6t<OgQOx;cpl{2m$RY)Odw^>`7V?c(d_WB=pq@KVYldpJ=JBr_Ce4kJUiS94wm
zTq3Z%2Vn*_7|4;Wu|}J}La(LsUm|Xmk*rm!mbeJH5x|&@dG^FD8;}HC-_%)+k>rq`
z70`=Tb_lrN4ZOG%9757KA0P#k6_g@Eu?5hvS`Xfj->4Z5T7+F&QLT4%`(4e9_1Pp7
zd9<0k-b`&D=NdX**!ewcT3QoCqKHknS4!6US<RnG>d7n)6QZJeE$4uQ12^>j5OO!{
zN_PMU@BE0NJGX$(S9p~hD$WdGHjfL2m)Ld^xiVIQy5J(NZz}7X2Jo2XyYU5F16vN2
z!i~G6fl--2GcSh8g%`!uhbp~qFUNxskix?_*lA_!l5<&!)&d-c-|CZ9i&Hub2Xaz5
z%tO};vZ#b(536wj&VtY5)i#q)t6S)G2a;C@vd?T_Ny$x}kb;G%!jT>!`gBn~M$2I*
zId<6_FPr&}Q*;5C*eL%+)9VT)RZ$SzmnvQDOcB_@GSZ~;0;M@9TAD*egYa0${kL-J
zG<k7D@3$ZBe5l1K1VN#fG<}ele>P;ojTH@i<z=ct2E3PW0sLouRv14mF=sAWrb~s1
z$~ig%hyM@Vb6LlyQ6dPH_!fa5n$!OSJEPkblL6Sx55W~@TL)t5W$Sm~G>f-_!M9XE
zUuZGZN$-@?mioi70|r%5w^c!kgkUBwYT`N*64W4(drKUGRpPFULitAgOtgrM{}U9#
z-GyJ{Ii6FCcALln1i!EV1=1t{0pf+9Q?!iFViPh+!xq2*wYs5{*ql&eH<QyQOh?4|
zLgA^pS=o(;zalYGDn!p?W(xqhRNB~8c=@NU(*Z1FaO=MN3cwX(m&{enI~sB=j>b!Z
z;kGyo!hKseoJjX1gMAvE7m!os8rQHGWZ@_<B`ZK;5H#l#q}ks83OIkws8x*F55;e}
z6nKRjKVZ`3=9KiwkK)V~W*2GNEKjB~$Kw7yexrEXH$D!u={KIKprnX2#}UO+@dmyH
zy$8+A&DpI)#zSdr#kuDB`b9{XI%EA>Epua!D}*)Tgt#>*@A*?vbg@SEAhiNwf>k&S
zdZl+u5A3?(gY!gj6R!VTD5J8ARX!<JZ3DM1s=;6(g}&$?Ig!o(roIkTDctsUWGu@+
z5$#tQ2%+xfbi!IRw(1RDl%rh(WJb}o-5?xAYthtMb%rDV0iea|Lo(Rm$XYYwTv^ea
z@>u!UkbMLPW$-Nd62$QvhtSjN6<JcOr`t%ELEHkv{xRqtYAm!|kbqxgAoRVZiA7Il
z&Bi$r-F1xi19vG-3O=sdxFEBXte-8`+w7(*GM0JpYNNJ|Gz_mX?P3B9;I=ZM7{1v&
zAVPlt05$iK000g*AXBA%w(KG#GtN>@fCa0JAtu-^HGlvB000(J-~bt(_y7qZ1h0l%
zJ6Fx5J3s>FeP(%^8<EZ6+VGll@pTXH#`=ErW$s7p4<+$%T{Pm#9X5pQD<46k{o=?B
zw8vL>o+5U$vIh8uoQ{5P_Lyt>UY{P(j`*?D#UR=)yOHGkt&fS@vO)Gv7uZ^iOKq?W
z_l@Esg^)#6q=>ezWyh@RP}3$2w_AwQTG$8agy*C?dL6AKM%zUxkGN19Wut}vU!N#j
z>V2I*NzO(|bPNa}-~eMPQnzY6fD`SQWga_=ubh1MN+-?3-hZIPo&njR+kF0&=vzkF
zH4$RqV^W_6ajvic7O&E=zokYUH8{npZeT~c9kz+tHC*UqVjLjYc{Oo?mGiqBOAZqa
z->ld6+wL;)2euYM{r~$<Y0!#@!%#8gT)K*us2-w$gf^bMq;tkj3qx`hPPvKLP*0EC
z>k|i0b)9laE6X|DC=HC+K%ICrTG;&gX#$$uEu*v{kj!tvc@2dyeQ2!pShMFwrP{?w
z;La`+e$o={yehsh8a>u)51BK0jFpU@6d3w^z}EAp4i_8oH=BbmBlX;Fk3r9B&iM1v
z0>Zw)GT`-VGfW*S0^^^EeRF5|kM(J83IjL5g%xB&z!9f3UuW2Tk(*gbqQo2gZY&T}
z=^07;_GtR_6K<O_ID*h!^j%zniC*{NKxDdtZqUY@);$QQY>6Fyy_fT84)cV=g-|NJ
zX>*TW1VKO(9hjw6@N+K#m<seUtLGn?&2Mtp_N$&qIt4-1a@G`xZhr1h03No$&SR;A
z+lN{-X5m3mP8Vy7mXMknBRpww)XMQHt17PLznf<JV;cnmas0bCO&9<5CU<^I+A)8X
zL2MW1?$%krovlw(hY;i*(XKE60L2)%t}1H8h!r%oq@g=1i}MMqd|QE)$V79Edm~{|
zs&zL|_g_zf$J>Xg3K;}enXza0(8l+M$Jt$SzK3zh$Y2L?XG2LRT>KKbd|CVKsIM;?
znWjBx96mpAF=wh}!j8c&j3~a#)HTLCrJQS?nPczm&k1;yU0@Zt;pqW%>Xsojz&OJV
zJ7kn&%Zuu#^YB&?x|*=8R~Mr9ODhf!;40NXNXUQthj<SMz_UMCFzHzk!&_O?qmg_@
ztwvy-WVEy|L?(!n<7i%pO%W$BuR$o@WCUqmN0|T`&_DpSpOK*78l^EL9DKpU5tO7v
zw9&8+?Y$CbCckiNe0#Bxf{LRIAXayS{{!x`m;%p2;S9OjQ}v%1r)DMP@xB~o++Yb6
zVJNNvZ=TgKh|gbY07I{Hv%2O%xJdm^=`I1`^3b*@=!(?s6PLxtn*|c8aTq3HRc%2F
zv6wv@ev2m%wcCzkxT&b%t&4Q0hvNae00Mf@pw+@RPh5gj0K2&eO7sGggdJ4(9p}Y@
z?e*}3Z0h~k)w^Opsycb1jK4kyFQLOvL`F2OqyV+^bF?WwSl8BLQkZtZh#%|w@1TiH
z8^Ug`N$0*Qw%a0rvT?b2bM1>)UJ@E_b;*;lrv8-cjsW=(KDD@hXZf#U8YecRpl8V0
z0H^e8&}UkpM9`y1g<kT<D0duBHkO~N7h|whVbb58Gbf(*EtAOGoW}x1=$Jk`eQ8-T
zd-%9VQ_!3Zk?)1_8Ts*PNd8uHEhQvI!)iafTw*IUmY{6~*jOXUm{m?fL1@I#X4`lp
zT#TNVq=BiXn%{GzF19lgyDwto-tv%wOU20(0*VSKgv7*9aqO3||9Q*^P%f*)^mAF#
z`=9;WK#h}8Ty>?n);Ot7sgfh<>n61_iU!uVnCLOxbF?%qW^WX@isQkSULy7pcj4!y
zXWa=0n_PjSz1Cu-C3>?ZX&r4*<&B&rgD^n*c;Jiri^~5Kj$Vot_OSMaQABQ$YX>6d
zkOR4_6T2ltH{}yNFFvDF3KpESQAn@E%=cR7yq0jXYzlP?(F9TNwTWhuz{$w9D@}H9
z3{%iTA+|JXCyp-H;Al-Z+}!{!(o<2uU-w~<46f7E5W(7++5z=E9{-Am;FJ;D7ODw~
zlf(a`lXS2kKTl7e)3jhseY4ah3!Dg+TRfrzMBZP`+b^V1QiNisAq$C2h<Jxv5z*3C
zym!_7#u&-x`(8L+!WhnYnp((Z3HUqTx(U0*yAhpfiwT<Q6K3awt_8!ui`?!|0@sA<
z2;l!cBZG|Ksn%#Vv#=~BGvruQ%-PixAy$@_02ifik#d}3T!o4O(%cdOKgu?)Nd#8u
zxLm)?#YKWc+aEmWSZ0lW0`VxFFC4#Sqg2a{n(hyI3mnkc*-etmA&<1h@B?Yk`cZH+
zVrz;Lz9@J|9<=M2Qz5JZpYRC0GaNMv#aW$LaJzBXG3@r=T@Z#{rvRTI^+J)Z<7Pzo
zkH&2l?K8#j6PzgcFchP8XwImWY#pa~NFtDRd$}Fpw8qxKaD~5wi7;7&8etbU)hI5j
zo_^zQNi!|CwGnxOtis@>!q)(}iULPG<6FKI&`0VONc!^}2>e`LX25<3cJWAbQQ1aZ
zksE+IE>1h;*F$CQmYtK89k%XMDz0T@$g{K6fl_T9U%J#Quk3I6*VPKGU;UA0RKug@
z`TG^qIM~u;THqZ3ak?<|Pi&I_;ZM>KjqorsiDnzKd1q1M!La8psy!Vy7BdixI2tJp
z7ZdCMMhML~_~0Bq^|{e;P3{#B(Prf3H}d@G&pbORAsi8@|J%S~z(6^u7u3=wtlP3p
zr9rc~jtS9P66r2`w!<>$1J0^OYD98)mA3CJp8xv2j;?P`v3m3xnDxZlb>VxW+iQ0E
zMo1Ud#|NTD@B5($1ipe%%L64*>$@ftH`r%B_L=>7-1Kp&!o~fZ0tV?F0E!G7YVirC
zq4mXvFb;LMUQ`rz!0r`n@NH(moM9$EbtCOb*_!ks{ph3&WT{y|_v5?;9v6vt&5=|_
z8NsO)jNA{}YWUJnESyVN6#pt9;V`9@3Q6}a!vpO@@!5kGfx=2fBA^Txz<q?Mln;*9
zA!mSqN3qKe_!lxfvQePE-Bu;tcD54>+!t5eH3(?F>c#P0DR+d&CE<*!Fs>T_0J(mZ
zjr}Soryev6k$hIJ7GO?c{ZG_8=)_XU5=);+k`0~@wCsv?`!gV4bS6OLjfwl~?Rqy=
zt~l-@3sVPbb}6|Exc@A$YA<q2nxGD^(tW9r>O#_{nxq}3b6-w$x-T~QiW#U_fhe@I
zaKswfyE0)*@Y?+%I=^RcZLKH)5}UI<-%}2G4zJi5BN02e;ax+wB1uo&!cCuNpfM)~
zN^$zNV5LJA`8&vRsfwX_-dnmVqn*1epJyP05Q_r-v&8L2HN<ea*QMK_PRDV!cmA6G
zODKVwgU1WcxKdg?YZD*!iLgtx@~kwOAL<duxfV1PN?y|V=-P;<z!YzY{$<2v#V#Qu
z02)Bj^!Mc59VncN!D+iouR&q_ZeTpSwY?ZLMUpHKRVi;-ZlP)e9?%QC(N)gIlqOvx
zaVFQ^DEvIV6YOz7v=xOUV``A0v+S`DGLx32^UHlPD%K>k{SOHp_m}_+tP|?3dZbAO
zmirpvMQB?o0wbzTA0O8=FKw^=Ow4&SFnNic1|gR;-!OY)4+0irI$QF4lckEja&2JT
zYmdVu2UUaHat#WCQo>pr0nQ{KtMJ)Fg&u&DRboDjJZ%U6;r-x*MQRN(xkLYh*x37!
z000001(le)6m0iQt(&tH!WZ+C;<P~$apx|U)e&X->t^->=_cUH9CT`_e6He&L*_pr
zO@Y)DZXndrv*N$6$QDn+1_Ozk{@SsuhY}6AQFIu$J04%cZ-~ZFOCvPg1Fij<4|9sB
z1H7)nL63-5lVy7##d8Ao@YSI(=58jy1fA_gG+DEPKbj~<{HtuHlmM37e`A`kkam1n
z#0OLcX&)!OTaxt~zs1x^WP&4w%(6=)TMGw$IcdqiO6>~w!<$NP;34sx3`NbM=5iON
zL~KB#sMQ8P`S3qx=4(rXr=8D=Q+5Z<%)^PP<d1?NgVA{+EV*8bybwRM_etT?RQb!E
z)x>gJF!>ouytTJqm=0-X``VW3<;1Rha>ipG6C&xtLlrXk2-RtG7;xrk=rxbTzwAgj
z#~ihP)Mab~l*a|$&KJ06Eh=mGRcA<G(k!(rgmQgi4Xj!ihN2+RpPZU;v@ZM68C=5h
z(wvNY^etIJjHu}7EUb&Q0siNTXaE6gKCwP0P*#Cg0j!la&}Avfa-s+P;23RUY^tOc
z>RY7I6<Z{M1|L=_urWxyQ3iMVB`UY6!;fWyJ23$$c~DjpKmtj-Un5>lRnc&JwTIp@
zV|taDtV_+d9Hnk%-KR?l=j&7M2HTQbKnsA+GPQa7E$(zyi|xn$vwT4>l6G*)p(AZC
zr2VL6OY%T@i`()A5S^p?#<M%p2xE?22#NCE(BAkqHY>oEXpa8R1~OQiV5TE25<mBY
z*B33Jawf6VjBwrRIz?uyYiO)RJPVtyE9g6#rbflW1PFh8eqv^Xr_l>Ve7wEcu0JaA
z5Pl3+zrX?Vvkf9)W6aEq7f|@hoMo`8ysEb##;WsW-gOkvgi>m2LsR>3Rq{om90M7h
zUl`(5tq3$*Sbfp9Ymh;FHr6MeGgr>`am6wK0_-AmT7Uv+hjwOp3P9!>$?zE<j6*%^
zOtHKdT9}3xe<FqLO8Liz{YyH{v}@4pA&i!RuW{N5Izyz0py4WdFUiTw00T7_m)SB^
z>7F##G)G7v0V|4?|IM^IYEZI}W)1MN?H&%|J{tT?;iZk7X4qp#?fpK1katwKw)iA!
z_oskF3_r;`cJSOYs19TfH7YNHme9;85J}^)>2`A)saVS<g)e0<j`{1jLqXMUFf@IR
z1%ntVIV%w(ilTr8fO+60U*0DO010I<t}CALE%XKNkk0C0*WIx6%q+K}X3qF2VI?@H
znB~l4WFbmNLd{hfCK14DS2AoxHN&DTAsj)vqmk+@C8W!c-YiS)DQti<i#q~AS5!kO
z1xPuvR^1HQBfLEe-*v8+Oe1nzwOw|_B}<S19ZHC*M-ZR@HMNA$0D|p~BDyWerrt*0
zFuz5Kp_|Mb#BWZIu_fkFC_*+$Tyz+8^5?<W^^iMjvapX2S!U;UwCbvYujh2zgNw}%
zui*H=CH;y~v?h8BO<iKuWbe74Oaxd*#{zA4t<*uarfqEUIOtp;*JHT|(gWe1H?#4W
zCQjk>ew)18L!LP}-?kjDhdAgqZ#B_nzTIEjY-kU@*EIZn^{I|ekLjEYuyt@g1QTBd
za;E9rInbf1d2u=OXR~QdwD8u`pL)d!3;%r(0YjQ5e|Ab|5eCBHz?iz=g5~&|o5RS3
ze)FZf>P!;J?l3tEcjC||ghabGHDsjcxk1z3*?nDHuntARI6}ne6krJOH@D{%^=6{$
z|E}{WbV3Rs3_7@%H86!2MMY>Yd?L151Cj;;)Dio_?P}V8R=btjwqkTY=`|<nFdWMc
zc}IxIF368>87wus?Cf=YVLSt0+;wX3!aO7BAIVenN91NQK}xAzB+2T#j^^h3%Z8Sa
zRiO+~ZvN6Ge{yCd;`ep2TP#df5US`L9`b%4h~!&%VPrK3SZiqxKxsBYgOFAcOP%M_
z($hoW(@H-U7;+vz=a7I={9_H}>hDra*gRs^*4##LD+K)2&iRYkR@S(E93WzaYQA+!
zQ?Fb=aJi)fJTa1a>;Mq=cjbQz6fVgc|2JHgjN@3J7daTP#MQS>TJa#ivp3}$jR!`(
zxL`|E<cj8nxeJI6TEQo+tB{a|X&>woE4}}1bffM`kzkn3E&RShCf3yWXrON;>i<Gi
zk89-RJ(d150ksb-JvfpX(kbbJG2uTQ)$IYuA`sb~25REi=i^~COauaYobm<(hxVVf
z>?+S{&X$tuhoxx1FUB+7f6JxT#yg0Y_qYNc2cYF|{1e&N4(+hW&DvCOH4vOTMZ|0K
z_;}~E%Px*X>N?l6%;wJR>k9A#@#7+ALCqHA;DHHFSjLz=Y5s}UjvGmz-B}xzB}%Pp
z?6Y4fxArJU>@@KH_MEf3ibn4C^>9Vg)Q@#A@r+!ZvH&L~WqM3AkUlTnqp69o0yDt5
zkyXC%Ictv1T@8_7%mWsRJovxHtr5C2(~p+~9@V?0V;t1}eIvpe8TeXBoMwBUFDxg*
z6u0XPALR;naItE_oQ#qc9^lx<`dxUXMcR&t!iMo@@~$rAvnR3GEle@`ujCztIkoGd
z%zKMhMg2xQaiRDQf=+5Nq@g$cgVv7GUXI(vOqkCY8`46d;~)KB_d|LTcT|3srx|)s
z7U}pb4lr6W16vG$*_iO>)&gwRG@4Dr?Fi3{BUuZQg#Zw|q5f~O$V2;518kx&iaK79
zigEvtMtzguDB^pergtlNR?is+Ms_dNayA})4l=nVG|-GO+No&R!|+@MBd+*})_~E)
zi2HV`@6mjxu7JCIDZ@Pp>U8YhZ3*~{x1;Kn6hQbhyUfLVBzd??(z<REV74O>sEG72
zaro?a8u*)blXmYDfxG}JsT7=$PTYaa@`OJt86Lpi$9H(I0^Fe~kXQ`;5tP0|T^7NN
zFMavU7rmz*<YBjpu>Q|Y(f%0)-F<Y(u)7UM@<kB`_H`Z5UVIh*99O>8UX+PUs7Sjg
zWIJ%(R>QqVJ?vhevW$m}OF(|3nizmLqS;;6=1L4U5@jdV>ld{24SDSf9JwaHhxX5S
zm>kr$fnoi)eh>i)+2hS1@81*2T~g(LTCoY@r#__T=FU2y=dqRaWV!%YiHul<R8}sq
zRV5eIXwjYPu`<?Q19=F?R-cipU9liRi!8@8hy?y>9!{ptMG>~hzC*bf&SM$(dL^w$
z!o7|sa{IY!a96|rl*DfPNLDjB>TSeq^{_i+ggW!K()#w!6Bi*}8NsvDH>^a86;?BG
z(*5+%_#R6WKDO7ks?m{-KGsJ7<8i@Oe_A9b^KT)iUI4L4%iBS46}a`2*}LWd3zh%|
zEC2!l+e<!vek0M>_yuh&FPv<Ct^ILsyLdo`u5NQfXz~2=t3WJFyu1n%#k~DP`8RpJ
zDFJ&kWiKcost)Z_)p|mw!jO(Xy6sM;wV<caK&T}Df{#u0mgHwzleLWq?k`x&TI<AL
zG$QU_9FTVUX;V`w#`jKw&@c?AOSP=~;m_|jyBLcPI{l6JS+}RZEy6aAwEyAil;gd|
zmd7&+2TefQTiT*Edx3pijx0QOyOwhuU+SNV(q8Qh7tD3pR2W3)L<hPD<$JXzB=@>s
z<o%(>9Xe=a%hC0Vhq7Am&MOZzY$jYD4}4nbvs(0=MDYzfjEDHG6U^5)Ya)dq%2P=G
z8qlBztv4;V%4~v&_%wOQjY>VqjDg(6gzy?xeStt@B+2OJS9G{$bWQN{$aI}~+2?2x
zCc{*3+8wpG-mv;K03>Q<vc!);K(w+tuuyN8f--6eMP1_W`UpG}140U*_W(NGfCA|w
z1A5$o0Q{@Nc;kqEBav8l_Q8*RPaPucxP&gs=%AGu01H+Xjz~h%=pgCFI^a+DReUgo
z=qs&VULw^%X-xrj6VnIo;~s2dH7bgT02a$bP2|~qsbn3T<$eMFpj)6;tM}n|n6aJ4
z1eX+9fS@T=T<Ww>d%Ko#BA<F$oVco4g9!$WN_VNk`PAEB)6Pr}1YQ~^z-nrD+Y6xv
zWl<MJ0@0(<?KK(x-L~je2<`2iCo`F2<7;YOrM+tMkQ(yT@4sGft3TXoBUQzR?%B7Z
zg)?wU+@yn_J3}J&-FoV9=(JYAFe)J{1R6S6JM7_Nf3g+pmi&;g>VlmblX`sC)bLz`
zDm=$`QMkpO`(hIADrDZlYvgnTT-gS~3qy^?f(Z&xPl#d4P5^D_gfZ&SGclN1nE6MR
z$pvA1gkK*7YL}A(zo3@;Wd3TC%kIi8m7_EA+EeaLxLunh>d7`K)s!6pGmEA%EU`9$
zq@mFk2jj$KWlM&NcU<$F<0Ity6jCyba-MqesA2N+F4Rx8pL*)PVtc-d<(f=U>S&WJ
z#|sGSjkS4*`Bzvp4E>B%jp+t3B{8nIhHQ5r$e-5SD&&E)x!8nfQ|4s$kq2AcNO)|_
zYHFRSg-8RSDDnA)H!y%?1OoD9p&aUg?mZJK7?L=do((q2>iH=o+xacYastPAqq*s8
za(y3P<xCC;)qntR<WwkwN5CvnI*i?+l-;_mfu`!FQ}tnp(1kK<Z$Oi#3xMh@nxWg_
z1sl|1Q#{Nc!~C70;(Aa3Em;X-I7V(4sq?*Awg#qnLZo#~DJjaK$yIW}zb5$mT|y?g
zLu$?b-6d^e!S(03DGe3-<M9@cf?vB!8)TpmaGPupk!hO-WuUW0h(MyB2BjhrN@2S-
zQE<-$IqzZtHea!17w?<1OBsZ#EdoG+KpYDyJL42I&D-0Zw~DkwX4Ty3uT>K_ccy(A
zj{Kpu=yR#tCV=qH=PUc+$7)5|Ar&c2xH4e5S`yo*JCbdwZM42v8QORADh~N3WRm4;
z3q2BawqG{?FTBMPmk|M8_FCL8XlOgpZLRI>^@++|!y<-508r-mYX)F3S)!0>KiCM>
zm8i`xg72q$N~j!n%i&pI4pvnL^t3O7{d1e9qae3TPhv;z4nM6oNhT2OwGS>pen2J-
z-$?DqRd8G`+?-FJ20p<WIfXRrNuT%vsz5mWnx0W1+Bb?#=A#ia9)r$DW8`Ah`6OVt
z6VQMiQF0!)*pD^Gbdsr}!)@ZciHK`8<%2f06$M82E+$05seCyceiu^&tSp#3?crsP
zqiJLAy*e*_>~v@V0f{t((Keb{8RU8}rHf1CB=S7NA~L_Dk8vc0=@OcrL}7exH&u*9
zTQp_|R8O`VNnKiaUqfArYQDgTr;}L!Z9&(HhWD6Gxt*?E{5!t<SVuAR=IL;oR=KMN
za4<taWPCj-vCxYx_`NHl$$op9DY^d5^NdH>^C_2y{X;FlbA=>m0NzQF8gX{mVxph_
z8Oj`5uXAv{J>Eask%ZVo)G^WH({$X&_yQe(bD^3p)4GMs1P7K#iEQ=0pd(DH1gT_N
zH3pm-A0^W!RH6C+cI!I6S{Hh%@ZryB6bJXEJM@h%Dx&#PwwRaCan5lYv&(B<yxd~B
zyV?-lH%Q<oi)Q{00sm~|(Ma?s<?hAk(}J`jkh$<}eMX69@;;*yt}_)sVx+A%iK#JM
zYg!ulY!~KdiBbSr7YJf<Ni<f<{%~c!cCK;XIAl;sFo3V8mk#jOq;doWQ1oXf9l%ph
zhiG!_m;0IC0Wzw6WCV~gFUM*M@N|!V2I)E`C}L;o1Wok@!s$iGmkDaX0H%(NU_NvN
z<uz6E3@#8Kut#-B1`rO&D)V($8LY-YbODgNWKM>8H2*EQs?Yp_+?x5VvRQ5OjU@xr
z*K7mrsk2U^QrBdz^;fG1;(q1wBOK&%A$9FbP4lhhS_*LjbA*6P_tfsbO0`|=uLXMP
zu`ge!1C9UyEm)dwco^J6lBY`)3DbJaRL90R!2_Knw7TzCiVWW><DuVHqlCNwueXEN
z`B4i-=JE#!wZNGlUxQa2I=lcCL|UvvvJ0RG;Nk?yrj}exeV=KLM}l`q22}u7xCNSF
z+EFcnu@iqMG!M}kK@x$yToDj~o@ZenM{T$hToIn~nW0_Nj^sNGc2VKP1NeH2n|w6*
zIn|eR?CL-OGM82SmyFJK*1{YXcbL5=Dq<15y)}q~?0vXs1V<mM5s6!;fxhu*_&tOk
znv>=?+k@?Cq}%q&;s1f0r6bQ6SMnriY{3ax0FUV+R^QHE`ix5Rm3N7x8<N5^U?MI)
z9}vjZP-X(-CxzA76;l}3FapwB3~Du->jqOg&vwcv^+w_7%E&PDRBlF>Cru;nFKJ)o
zy^aWAk8kbxjY5CGhS`qYYnhuGOIqT$bXxe!n=TIZfLO24r>Rz34STX5RhhAAR7twk
zw1-t)b+2(F<b$%JWGGDIy1@mc9UtY2FYl;(IM-hsfTg|H5&z(on3_F)K_6)_&q=_n
zJ2ZMef$T<*ccd3g4}Ptw3_2rnptjcWaY#%E!(teOh$JdqLH3s!c<)-kb#3ruPsB2a
z!Hh=u@Bk2_Bb14JuH2UTyA$EdXuop!NfWB!UuikU(3-%?@UF<kw9)9I>n8amxyjbA
zsy<r0{YE$hrG79kc9MKcr($C~VS`6(VELW0mqmS^FeNMOSQ`KU2`7<cKmfVVn8*MC
z2Q6Urr`e=>DeN=d!|!cqb<Mw-!#J>0g*ABV__}i`v}zUnrtPOiXN4WQxf-^(k@OS!
zu9O@|J+_U_qSiECqX#gMU}f?J0FK&!b{^l3^1u<Ge7unt;i$>xO0cBCYBe{Us_+EW
zFPsqO;@p27##(^b_!~Gsjkd%~O?XmGaiY#-z&>W|q?8_jq0@q^>jI&cX}*2|<OEwT
zm?LgOjv$(-)*8lVh2qyt_iYidMJ=YWmt~+va8zc8rSa@ImTESIrI*gWuTwcpgu0r-
zrj2xYYO_XN<I}MIX0QIx6*5nKVT;^WJUMtJdamJRU8(oFJuX+LG?;W-fd#{H;$UqW
zb+p+Q{*GwEg-{UVsHK@9rJd_qxdd#jrPcd%iR=0Lbpp$qK|HVw*aYknE@6X<Bmk7g
zh}$UK?(t6u0eiHkw#@ExNsjmT3%mfCw#j*F1>g9(<e0j@Q!%9I-wC&$vmV+kC@t(7
z9S8717`v#Dhvfnz&1X5m6Ev3zq2<2wVe&_zdnCX22|+ki;zmAp6)yHZ2*UJ_!{E5O
zVhs0nYb#79CFL)0l3;Lm2@T3ZX7>^xJ$hLk@c-ABf(L`v?cgPHiP3y?sSl9I(~+xe
z47$~2mI-ngsp-1^v2Q-t<|G}_x!8Pq3+Pbb*0g)CXBm&%IYCfjIq=QNcGm`#LOc58
z*ey9!?M)>ve#la*N6N}bDov@`HB9cwtSQqIP$&b>V7b0<a@$TgGb^a+;v7?OQ@|KI
zq!k8TOorypSV{_fKL+VGC6dUaj7d)VTfBR5(r}c)<A3LF*4AuB<e)SF07BnWx2i=@
z9k0FG<ePES*o<{$r)MNuwCA4f_rW2Fr|vFhB*<z=k5pAEN<synZ#i5oXhTcPF?xDd
z+P)4X$z&4@7F&Cf*wUiE>R0p}GGLdpi~s-t00002>%bt;PQ`bshd-fBCpi&*T|p7l
z7k9t3+=K(Y8!rF``VX2g)$K@K7h)t1ZOOaP!y8Gg@S0zi>lfS-+oYpfegt_RVmb%=
zZDY;dLoCm`Ay$L5^HQS0*>}QITomy{+82#j1d^QXbp)RDW>p7+1+**K+a)eeK5IZ*
zq*KdfU{-dy!K1|OdH|L5=VAW_=QUdsozhEC#s;KcH3V5fs{jB10001jxDNVLKA$fF
z3W04`Fmm><7CFuBRP0Kot!=?2ww6iec>JhcOBm{14}rbUB!pNqld?YR3Pa|5u~pBt
zaWn(7(va_otu!rAsP0;PL!yY!i8AO~1UTuhKJ;JnW%LD(PhRhya*GwGn@zg#Z32Ij
zrUaOJV~e(IgK?}p(1nZlLZ16nrBTooGEW__Ax2pD33XHgSnk#GDr4Ne?1(asF$yEy
zi%~ioTAf;Z;*U5n#oTCD|2T&vBBXw$BPAC=Bnp)EBkQ;uo*jj!$SG(lrOYHbeo^-5
z27Q%2bC6lCKC3YX^d0VhKay#<=2tCg5*=J~p|8*`&eJIQEnHL-w76cP_Y}`jT5`)^
z>O<C!(O!<*#Y}D!g_IF)(L=Hr+9d9;Q87(6<f};RCMNeC^K-hn3!xK?55jL0pMd$d
zKBtK6a76kOGQ0(rX<Bf=)~b-YK`i0J(Wv#roF3AX4`6{E6CXb2e=G50s32>#tcB9I
zZ~3Vh>uPyYJ>&P#Cvl#i2$5PpQ52+M+6k-uKkinXn!ir_e|H#6XWdv0%D8P59X&rO
zJ2ggz^54TlH6fLrN&8mbg5aYY9PbwvsDMd4N6RoZS4A9J%Wfd5j|<n6muDpt@vL)R
zb7fN$6l6g5^eN2tD@l-szp$%h03(V-f-BNP=H~bNf+L!r;1zYgrn#x}&S%7_IHQz6
zg&uwh5Yo9+rCF<iJ2NgfFR5o5nl_VE6cROGDD%<JDY3`n8OSf(B0nLcpy6$B#n5D=
z8x^r-_F?Zn6}YwUBeq^W5bB%%BV-IUL+9bxX}XsDpP<Mh%nSF63^d?(OE#3fm3)%<
z1GWC20K1X^0000001IWIrt)mRF?~v;ya8t-0FcgK;Gz02ht+W-5cN(JrKN}1r>b?G
zGHEpdopUn7IWT~v*(!jvZrh>P5~Y^f-1Qe4#3y%X$SqR|yE_4JgoQHHHA9EiEZzw~
zA_kcGnSsCD#*5|y16%nEeVQ;YKU92!0Tf#lQ8|4vgvzNLoMNLDabHH=u#5CDh%H^n
zX=BOjJ$5CrEa|Bss1*0+qZFS^Cmv;a4QX141{xgHpDYtX@_E^NLg7hTAaR#X$ZM$O
zu?#8|cye47OM@aMQ~z-%(TJCAvOGKc@r}m9?A5OUS{J8k)lFw;b11^YNxdaT(#Dwu
zWQDv?&{8TlKT9QiG}7L^)9gR(^<?SqeP0H=zn|qQC@9Q<1`M63f@q?6<PYocO>)xM
zfb~ew`Ad49Y-=o7;R8sYo6m*ZPd^tnQp9rds;_V;R6Y;|YSf^9zGs)Ug3~$cDS$<>
zTTR6Wmaij5P3f0Rr?(<E2+-2&S4apC(Eb1b@}~^Aj4wJ3>)e7`mF_cCSaOSyJKx2>
zu+ect-b+|kzTo!R5y3e}CzwdYvVt5x+xXiz#4a*kwo6fFZFPcQycP;S!C{cGAnqG%
zaG1PAmr{z=5*?VMZ}h!J)rq-&N>N{JY><85j{i-;eOW1hvt>QtqJ5e|oihzj^MU26
zM=*5LpldZe{`>P+b>DSafb}l;;oAEVeqJZ$L)?pSxT`oB1sM-h?hiE=DL;nOyj7M8
zy;sA2(YC%bi5sK)KiJN?@)I`eUhkz4QYr#SLAqI;s|}5b0wVoCUK?jLZT{y`YMQg?
z*Z&VRk8<K(^_1ia3RJq0FX%xC%BXIc1Z>{Y8)>rYWl&0nt1JvMmm_QOA;H45*QWau
zBbIe23p8%pRlvZ7(hJ+5K~4daebR64!U+D!S|l=mY|bEhK8u&~Dod}9bc3BQAbTaj
z<{BmJItNQLljcwS?8`6W+NK-Sv~`=@oi2*@XAoCG`6PL5&CSb|5kR=aQ4O+Ut1>wQ
zjMcgkcf@YCP788wnRosM<Ay3j7#I~2b?>Dc<$K?V-UnX0iJSz(GC$$Xb$DP>(Bggi
zm@hQKxtv<mQw_fu``G^NWu`ORe(nt(IGP0OaR_laU6!_Uui%%G$}Q0{>6@2+&_`8*
zTE-LK)5DBTpB<-n103iIYqiafxlMUZi4xBwh*jknTn>->c|0j70|tIQc#pW41cFWp
zsP)x|qH`thnkoRuT~UFCX#mbW+<BqRU_7fKQ)js3E$cuX@`%)Oqnes4f<GNPVGLc`
zLGY9I;@7XspXA8Ea(A^y1+Q=1*VF$`M{Anjf@qxjn_U0Q{X`0-eNq8Njj914@7fKl
z;MCGiZO_q@hND`)o<$W&r;+K#CoGp!05q*R`*)!*k_uRaIu=k&M9@<cCyz)A>Kxkg
zw|CWU{VS;`WrL~rr5ZDBZI!ydzM`vH(jhmKmdrO3wOCyzkW6xIdDUVZz0~!{*UY`P
z&Sq&Ac7FOyN*7sY)2RR}J7vi&h4A8YQ2Vbj?JiM}ytT4;?Y*`HQyOE)1<m}5539_T
zB;ikQTfhvr0OhAL>jYP1iqPqdOv29G{%p_%c>5TGSll_Kgd;Y?G`sc+JUcm`zhqp^
z(!JFa(1&5}yFKbK8VcJv4K2l&A~KCASX~aD5Zi(VtF~PIce*s;`PRvzn(PLqSf9kd
z9rDx9_VK0^rC=90{pbLrv%c1;cT~6?toOOh#AH7P#en}?Lj;74A$(9yd|@+Kjf>;U
zPwKbEX#hNA4k<3xdxouH-CiMS&f!*BaPc?g`u9W0uk!sCPld#}q68aDX#FFQB${Dl
zev{PSfW^CUiHHEUhjKsH>?wUiWZz$IV~jCOI|!kSNbp%{xH!?KNV&UZ_#1GFGTbaf
zidBPM{)CQb+B5azugv}1lpNBG)45n~>9H{r1OBt3*f9-#3u+&|fqAT6Ei}VSDbV1G
znJFu;_Nvs;A5Cr9)UvNH5>*HH=ep~sv&K0Ud^do2BIg5L&h*#D>%hbWtv_AwLUiHb
z=X2BcorjI@))hZAay2B}9Nt5OTjmfY{|9pFlo%((3i9B$58^B9No}wLoUfa)QRM+*
zP%o<-Oa(Vg5a5#)n}H`CRa$OhX6GkGH!ueA0!#Dud^-DRkllnf(=^-m2ykI02i;io
zqR#0i0HGe_ikD8ZDrYi~rHx}$mw_QA<E}rb?Io!yZ<Q-jTsH`BLqcz(>p*cax=2zY
z6N(bh@y4?k8{=j+=4IHYx-X!dUIWSY43R3hSBbXz&>UO=(5tLo>~qBl9|Lo9!JTzL
zlqA@vkMAZEg2RqGNe+S75wc^3J$E4h!ZTrG-=iN92iflP@twq4NZXF54NSWp)3@uF
zYZwNRVsbGqcIq*#uxO={zi;H2kbmKnaJ0Wl*D^s^ABW6e5=NHczWYe;jN+GCQ)p$%
zGFbSnta;#aA)uEhqu5vDv%GY>Sg3TWnB0UK&ao$U@GV%es;IaM0oi(FMKBx^QWKlf
z9yi#Q$A2w#%!AKZNCb#30l};)Mi<C1+!Y~o9Z`#QStvEM{7Ew!R1rmCry|VvqQtHh
z_`{vsBUcO(!(e#87}n=7lVGLOUB#Mi46Eqb*d{6{(o}H7b19vTV)YC)59h^ZV#TE{
z2@P88unLxud`10`rUfxAU9&B5ov|ieI<qyYhZ||)E#SXgR~(^QtaoV+b8o>wZT*j4
zKH?3TyYu^lr)98;R)K|<y9Nc(y@R$7exl=NZNyq!Otv&i;-#=uVD#uC8|G?M%pp))
zEJ4MMWKt%?y=WO;D)cE|bE_=y$V))5{Y2n)0So0d@;xfPEFN0`-K_<HEn%ur5-#{K
zqC0#GSYZA{eSrh!8{VcV%P3ZGZ<4>}!pvCYRIeF{U0w&yY-A}|gb3kr<ru|5pu+Qr
z-zx?_PSTBX8SuA=aU2lXZNxF!jS?$+U!I2Y9qRF@x;g`~^NrkcLR&4iEoogQD&chL
zyZPe=7$pf&?RABq1r}hyp8WuX{J%K8XXU=M{7VgLnGX}2!pTeOASnW9nvF!jz{?l9
zH`nWz2OTkZJ&`G1>`+%lt!|Kgv4inRYqkojvygoN@-=@Q8h<_MaKW;$^~gu#C`y77
zb@2b+RKrasvzpu8oe<1tmd=cNVRY_bVgBcl9%Y%ml{$^9T2fPu<tix=l*&Et!`+4>
zfDQDl`AF`1f;BOU>~DcM%-b*BCF(H&z$lIy=JjIjp6292crKLHQqqtaZIH#z*Ab&P
z?Q5B<4Vl9d@Ylb!&Bfi;l>HA>fG|yQlW<@6fIaO?(3K4%$w_Yb4MH$Vn1-s8RF=xP
z^hiA?Fbk0b(<=jB>U>_j?Dp_;k}VJ=M`@Ff8>1VX6etY<=2T6cyBzq_UM|gJKKVdK
z30Pn#hN2Kup9zfjU4^(nbhX~d&48HJ>m$}WFpNCwh3m25HaoU|x8=~}c~8pYN2W1d
zZPbnG@d$Pj$_8((8`H^QT*IeA@5?uNHh*H(w&*j3H7(o3vLk}we@=^}jZ^w68SPk5
zt)&^IN+vQ}B)$^HNT1a8WKoOD8m|Dv#==7yaSb_<e}h8oFKm{30A*opGuMF=6uvH2
z^j~=gm_DNEdMMnXq7I)b;MuriNqrY$2jh?+A*~e-Tw(}AwFAIqt0$%lb}{xZLpU$<
zZljfl5W`QSU+54!(+zWD8QeD8506bq;ZX3Jx<n8+^j8lB*KZbZu;H8^FMyOhgUJ7>
z&;#c{(_~&Z>{)&J(UT59E>s_;xpc!GUOp$xjL4B1yiGVGt?W&n4h}eW8WVmMhzQ(+
z>$K?om+6BkOWz;?xYb=r23A@YFXL)7jOV-3uxK}AbEx7MjoMs5;aaBG%Y;khM3r=b
zTd`P0@QB)#qRh-4HT-@#76F>L?;^LIA<~6aLSq^$h*thYk`GBq(J4Lgu?zaS$s|CC
zlIW{)!*`)!d!QiHW5M>ypoE(m89iyww-Q|%$Ue(CTP)_j`9h`c8oqEx)e8zIrcddT
ztpU7H1{4PAXN4z|27}H=e-gyhv7gIRsPcApdM+`6Vr~H^0vtQCNh{mHmw?eHKSs?M
zEWklhooc$otevdazy1>TiOFo(cm@1lyre}1L-%eo=~}bRj9-z6eS~27M5XR|Q^r?;
z0*cOk$!qZk1v{ybpZx?e_q<g$p-u1lrI4Hq%Bp~%n#;=8mMsrVDH)le!=ftzsQ?n@
ze{3DHRaz>tX)$D!Zw?WeKGmcxz&T+<hPa98cX3lZnY#*z6o*QdwTMxyP9qScM&*l9
z#l*8|E8n8i<>ygX9_u0HNOqg%0GT}T)9(#Qck&QCGgrwh>v90QAZYo!>B36#j&L0(
zb4vbyrN8w~++D7r0s^I1^pH4?glH2w_vMMl8vXFvj=9AOAZ_|Krls3qa6C0>h*`Jm
zY`C_W(C*r7J{*^a4pQi6xR6Q!I^Ow1)_*SiqrLE*R2H-5%^@d$$(F`}sx<0MnoO%l
zU|%C}Tv^5~by^|$N^A7ioHvNt>V8WULSz>ELBl3MSDKYe^4cedqqZ&XqiQxZyFZ4v
zX>a#+nx*+CGq=~NM0yZQa)`q9_UjkK(+3iOT$|+|bnps@C7W;m9eJEU-Zk_#g?w10
zh1erIZFM6h4Dx$OX$Yk#`MYl)wsOg8gvujk;hg5t-O!%=IGfE@&!CzM`YAE}>-j}v
zawtC_Pp}WdY&f6P+DA`P8Jg{CKbGkG2xe|Fz@P7B0j~{E@;IMD(G98`&vggMQ*84=
zPwJkt7w%F5i1>XpMZzG1nJfwRXgaE+>SV``ans7g)vg{TyX~I;(q7Nn)1>#})2|#0
zB*7&{E47`!sU(R}VQp4&>~$<R0(r~mG>^wEi%bdfJM>WrSqtTZo{HEM%ej}_698%X
z_s}6C{s4YwVmS3YXKpw`I$L+p3}X^@30~}GF-A~xQ_d&1_GPH=M=itsYi@FbOD)lb
zZ=^qho_HuX8R?#(70KdY>(PU=0eQ9P!`;J9@yUIgAJ8aeQ?16IDDKbi<{9*-ziOIk
zr@0>!id2-p7}q?UkOLq$Lz==+s?>qnZK}`D?h=7QYj~zb-<o@{3t7rW`v=bJNk{%|
z&e?FVzbvYhsV-g+emK*^{W<N-&5ERRf_dg}ye-Dk)Zyg2wyHk{anTG+J}l6y>Bi)i
z@%yG^)R^KP<76O`R&y&dnbE?uc=*il7dsbBH!Uqur7w>MD)}mzJn@^6yeH@QgdJr1
zqdMb|Zw6!h=?VVV(i^R3{6W*q3t|D*$K*Bkk;ZOR(%(kBedX2>ChpKI4yIo@_mF{&
zio^Dmys25bD2n~cF{{H}xj3DqX4C;CYIDT329J00<BCUHbQh?D!Xs=6Y3^?CV28yB
z4-V(!q{ae#N=IuR_ZUqf#n6PU02Qw+SvvduAvsf&4pOxq@RbRxBM2Pac=Wm_z)T$#
zGJ(Ne+dGnd4!#0*3qhipO`>gZkQtfRu@09@sVqJIb)C>~jq#!Od4H|nssPnCbthfy
zqv=dyi>^lBKoz`SQ6|1f8+?ZkZxSK^)Q(&=4>VFoA3v6PR{eUBS)K(_m`gBS4mX}g
zJd&OWw1iPAbl^}v);C6h(6@p%ko`gLTNJR`&IDLqy$N*GxD;7qDp2D-khHy>aHAD6
zXOK;jaK~d<CDSRQ%`jvyYp;LI9|hsvY&5j%regnwTl1Bw<Jy#k4(JCKfv>DbAWzW|
zl3&m#&?NWjbb5oAt$FJq+$-<5SF`+``zdcvj>?dkv8P$aQ*S-sA!)`uxHkE_&n4C4
zd*<CrE7@dD!!ovW1a?ypK`bi;9`&*hYg>pDINtxeGM~q~k8IZDpj=GWa9S@G*CHZx
z4+mFFV@Gb@LrhiD%=|!T3C&+7i2B||Sp3{og+I>$5H*+>vXQ7#At~2%$e@?kpmkk!
zy}I9!PUVdi2Q@K6?f&@m^ZG_*QZ&WJ$NmF;&a$=EgZ4V9)(0LwR4uWSJ^=(mI(j;j
z#TUf#oYN72OYTqi;rjLH6!F_RMeHi;yEgp9S-qZ`<-EQ{K>yUgYX{~5>uCCZTn^9O
zP26keDV-HR15TGzqYnS76obKTJZjPODFo5|x+2JnOV<P>L9`Yz8}>W<HaI!2pKnOm
zwCV+7j9D5)2AeH;qTu8R7na0wnD;+)kYPknsjLPR*&U^LjJ(NLB{$vQcnPMT_AnIf
zk20t_b04+Nm(AN>-pXM=V=Svk8A^|nc@W?LOdo!7<CKU=#CXHb__8+gl$7N+3%Q_}
zsKBV9Z;N!^GNGXIQF<cH)mNqhf_IM3W?XzD_q-@HRFSa8B8OkGlVAAN5a#@A_isU_
zziGSUCxl!f7n}bMi(o}6zL+8=(!9{PqvEC+5W-i+yyD#)nEN9hJ{c){aG`R24Z?Pl
zs}IzPr<yk@*zN$Y9{4Sen?hGb5zWdoC#UA5uny=QJ9P%Cc(bud2JLZ&ZRA|uPi=7+
zqRnJN?VQ$rmROpO&L^cWqs!-JEMH9gE#?x2nk%Fd{G_6Pfw8lOjO8V6sEmqU6Dcs`
zia439H`S3>h!#0q3Fuh0^tCc}b9+j6!BFXSGPeYWk}#>n<akhr*-;ha;8m(H&zmsI
zB7fA69tZO0tfjmFEJ0XYQ8fV;mglGj>JuC$Uy5#`+>P`_as~pn_eKRS_d%p_KbD7Z
zP5XtSh_`;EPK3utv@lo>ERSlypRf|l5bM-(Vd!7^&Qn|`VmWaa0P4QXB{TjIR)--Q
z!9@>!t@=uPC87(!R8&jmu@!(R-=#F2OxW;@mLt2vbyuBm0Op{PY5=^k8Y<3#{2?MP
zJ~L`;3V3rhK_NoVocXPACQOGdW$|CQ<{6JAv7HC<he7%FP9_Av)YD<q15F0}YHJ5o
zZ#dW6+q@VN?5vDQCxO_yd-|==BuI%2lhpO<SL2?&U)|&JjM2*{AlswunK&nK1lp01
z2?NcgD^Ws}YuK9f!4DyqBjB%jQ@(x+sl{B)YLl!l{r_8a+4qa#rP`5Z57>~=ErsxP
z_-18jt|>47=8gD)*@&~0nYN&Fr4z|MnWS=9m*d<uK7gpTtASk13u|NoRCkY3@K`wy
z<_)%Gi!qIT#j2UgI?bi7*b6R?9gQtIPexwjQzoctzXsqA`+u03=J+-94WKIO35KBn
zvzb)jvtQsU2$ZECEOBEf)Z&Lw)uW%=iB;ive7mtr3{m{MIgf{_^sfn*@;xMvK4U>A
zyCX@V;JhjxVB^Ng%}36YS(mqY(<kA#0x6A;oYodM{E~uaN`g7le7jV)d^vJbj7Lc$
zcw1A*4MvFoCbo;<J)z{NR+1+%INJwHbe{Z&nndRuXhZ#&#8y%!=JgdB_<ahQ@>|T~
zg}ee&8DQLBE`$%5b(4K%MP3hEt-*>m);TSRZueQR2HEW3kkDN|=amSBdAp#s^aGFQ
zi0qGF_)Gip-8|rJ{^AODP0VIlc77d-hF`Idtg!!Xf~#WS`BB63!zti&e}3bQz|+ME
zwh;Ee&y+meDXd`)4?VxoXI|q0T@;Q%5Ptk7fb}H&^H3fNnUEz(t1d5mbM56-RuY-E
zg+x^q38U_Bsa$e%D}ZJ>^|+WZ)5P7xI;Dj=PbyHLQon3pXQ7?$5OuLtZ4dzvdRb?m
z5J)7TxZ^V38&6={n?t&0N!2WYzz)zCHKpN)#!1&j>=weReWZ}6%su1QNA`}{QRtK-
zM=z~z9H*3y2)1YkdIemio1X1c;UF-uP*_9(eOteFw3={21F1R&f5H5@GoVI)WVZOY
zgj8QSjT;dUdsB_b5fQ&KE6w!p9P;V<F9@PU`!&%Ro2%qb&dQ%2IQrw?>^Qy;LHwbR
z_D8z5FfmSw4nCG})&{2zLz|tL3Ce&E5}c6NgzQ<PZeanx2lW&*d-jOWWQf4h_sK_W
z^>p6)K`J`a<f2YWsfkpYcP+p?)}u4aI1kz#A)AZq8n3W&z7h2EsdbYZyAIS-IhfFy
zI1y{9XJwc8b2=2sDF5CJAjl+;8s=ffaMh!#J|UxCCHwDUZ%#r<>IkhUl~kubARj;m
z-=Z6rV%k4cD#v;04%^*ZXk;ZH3P|ePxzjnH<_%3wny7I_r1?fZ;BbI!H^w+KQ%)d*
zDd>?RwX0ZY#s3-b42<tS=tvU*daJat0H1zOKQl1po>Om<ySRE{l2CdBZM)uUuH&*+
z_zHT9LD4S9zxdimx+u(>6POF=l{SQD!tYAv(So>oFhcgjFEt?7(`W88%$MifF487d
zKS9?@IGS87ip1{rnMFwhkb0Zw&*4nEsSbyb6oZ)3gihe`tu(@tuwgcw5WxgF^3;2s
z`1?tR)=%uIdszMKlYX@holZVlzi)j{aoBsdLACm_U<P_7TSmRw3@GQU?%!-(8|tIL
z=`{?`6b)JS*w8;A{<t^%+JV%4iUWAeiaMm-(zqra;p<pb$Mws)#>7T{hoL6^d^oKk
z(X3oa<O}cS6(7aAOwqz@@mJpt&J66jcNq`v{^DbmK2PY;hr8D%Vm|Yp*n(qsXO0{$
z;XRjyJvjt~nWNV;khLO;jDEwmQWW*G<J@^9>!}jonQP_bH`iwLpLlGtpCwJ?L^qs6
zTl-+I`4BJ#45-cSQ4iT50Fv;JSttJgUhYxao<IS_QXWqonja~``Yttx+>Q}mDnFNM
zZ=2i)rs&S_S4!tlO`Vy<LBM*g<pstvc}+~9Gt2*E&-U%YeZtiHzhnhsqS23{@bOyV
zaWQZSTAFLGgM=89HN5|c2i!>`*Ub_9kz7%8U_bmc=|%0|9!mE4A1MR)9=oWPWYuYn
z;n3PG`CTuG_k5Y#DYMfv@E7Uc<7?dn?TxgCkmSGEuzwjzhZlpy9ev3v@Yq+Zxw{rp
zh-b-hW<w`6!)9~qSv}T`EaSvaGydIJ827%8Kv2ZwG;UrM7?vq+`;f$3<Yo|AgB0<X
zHqB?+{J0(Jw!@#-&M3WCQ0aPjkav5)ZRwa3(2_$|o`15jo2AxsgShAAI>0(*kxkmk
z=f_KIl*GX=KvV%?3CLR8wG9UmU92Yr^jTg=QYz_}+ozK&p~`)0O6dn#2byyY9YAlg
z8ip5T5L}ketL0{VyTW?$Dv0d$Ct1rO!_~xZHgjGOOB@Fe8A1)|R4Biz`hKL(lKP)>
zFPxx*b4~wk$Ssy+M-MOB4qGOw7(WoCi}lv%hI!GzlDgycs;5L>ky*XGgJHWf?jkii
z;Qg|GM*5RprWr(MzAWMXXmR~Fy;6g!L^QE^2P4{fPbcuHgn}_6m5zD+j!6jjpjH%f
zuO+NGRytopG<o^xT4~l=>?}BEfp?iwEW9>ftz6uERMk79UY1^t+hC`mM>75l!ejsd
H=#KyZW%P6w


From a87ee3e7cb508a051af9eceec8073cd8532b478d Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 059/103] chore: add PowerX admin scripts and dependencies
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Register the migrate, verify and telemetry backfill admin scripts and pull in the
PGlite and Blob fixture dependencies the new DB and API tests use.

中文：注册 migrate、verify 与遥测 backfill 管理脚本，并引入新 DB/API 测试所需的 PGlite 与 Blob fixture 依赖。
---
 bun.lock                  | 1 +
 package.json              | 1 +
 packages/app/package.json | 1 +
 packages/db/package.json  | 1 +
 4 files changed, 4 insertions(+)

diff --git a/bun.lock b/bun.lock
index 29d749498..ea567a09d 100644
--- a/bun.lock
+++ b/bun.lock
@@ -69,6 +69,7 @@
       },
       "devDependencies": {
         "@bahmutov/cypress-esbuild-preprocessor": "^2.2.8",
+        "@electric-sql/pglite": "^0.5.8",
         "@mdx-js/mdx": "^3.1.1",
         "@tailwindcss/postcss": "^4.3.3",
         "@types/adm-zip": "^0.5.8",
diff --git a/package.json b/package.json
index ba63caaca..0849c661e 100644
--- a/package.json
+++ b/package.json
@@ -44,6 +44,7 @@
     "admin:db:migrate:collectivex": "bun run --cwd packages/db db:migrate:collectivex",
     "admin:db:apply-overrides": "bun run --cwd packages/db db:apply-overrides",
     "admin:db:backfill-full-response-interactivity": "bun run --cwd packages/db db:backfill-full-response-interactivity",
+    "admin:db:backfill-gpu-metrics": "bun run --cwd packages/db db:backfill-gpu-metrics",
     "admin:db:backfill-server-log-files": "bun run --cwd packages/db db:backfill-server-log-files",
     "admin:db:reset": "bun run --cwd packages/db db:reset",
     "admin:db:verify": "bun run --cwd packages/db db:verify",
diff --git a/packages/app/package.json b/packages/app/package.json
index 3ee80be32..dbc291ffe 100644
--- a/packages/app/package.json
+++ b/packages/app/package.json
@@ -83,6 +83,7 @@
   },
   "devDependencies": {
     "@bahmutov/cypress-esbuild-preprocessor": "^2.2.8",
+    "@electric-sql/pglite": "^0.5.8",
     "@mdx-js/mdx": "^3.1.1",
     "@tailwindcss/postcss": "^4.3.3",
     "@types/adm-zip": "^0.5.8",
diff --git a/packages/db/package.json b/packages/db/package.json
index ba2589286..4ef2fe986 100644
--- a/packages/db/package.json
+++ b/packages/db/package.json
@@ -27,6 +27,7 @@
     "db:backfill-atom-kv-capacity": "bun --env-file=../../.env src/backfill-atom-kv-capacity.ts",
     "db:backfill-chart-series": "bun --env-file=../../.env src/backfill-chart-series.ts",
     "db:backfill-dataset-stats": "bun --env-file=../../.env src/backfill-dataset-stats.ts",
+    "db:backfill-gpu-metrics": "bun --env-file=../../.env src/backfill-gpu-metrics.ts",
     "db:backfill-full-response-interactivity": "bun --env-file=../../.env src/backfill-full-response-interactivity.ts",
     "db:backfill-request-timeline": "bun --env-file=../../.env src/backfill-request-timeline.ts",
     "db:backfill-runtime-metadata": "bun --env-file=../../.env src/backfill-runtime-metadata.ts",

From 8332be98d14d8aad6011cf42a79934d06787a422 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 060/103] feat(db): add telemetry schema and stats version
 column
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Migration 016 stores one series per (run, artifact, CSV) with full-resolution samples,
per-GPU statistics and benchmark point links; 017 adds stats_version so digests can be
upgraded without rescanning samples. verify-db and the shared table constants cover the new tables.

中文：迁移 016 按 (run, artifact, CSV) 存储序列、全分辨率样本、每 GPU 统计及 benchmark 点链接；017 增加 stats_version 以便升级摘要而无需重扫样本。verify-db 与共享表名常量覆盖新表。
---
 packages/constants/src/tables.ts              |  4 +
 packages/db/migrations/016_gpu_metrics.sql    | 99 +++++++++++++++++++
 .../017_gpu_metric_stats_version.sql          |  3 +
 packages/db/src/lib/gpu-metric-stats.ts       | 61 ++++++++++++
 packages/db/src/verify-db.ts                  |  3 +
 5 files changed, 170 insertions(+)
 create mode 100644 packages/db/migrations/016_gpu_metrics.sql
 create mode 100644 packages/db/migrations/017_gpu_metric_stats_version.sql
 create mode 100644 packages/db/src/lib/gpu-metric-stats.ts

diff --git a/packages/constants/src/tables.ts b/packages/constants/src/tables.ts
index 684f310bc..d1bcd6a0b 100644
--- a/packages/constants/src/tables.ts
+++ b/packages/constants/src/tables.ts
@@ -5,6 +5,10 @@ export const TABLE_NAMES = {
   agenticTraceReplay: 'agentic_trace_replay',
   benchmarkResults: 'benchmark_results',
   serverLogs: 'server_logs',
+  gpuMetricSeries: 'gpu_metric_series',
+  gpuMetricSamples: 'gpu_metric_samples',
+  gpuMetricGpuStats: 'gpu_metric_gpu_stats',
+  benchmarkResultGpuMetrics: 'benchmark_result_gpu_metrics',
   runStats: 'run_stats',
   evalResults: 'eval_results',
   evalSamples: 'eval_samples',
diff --git a/packages/db/migrations/016_gpu_metrics.sql b/packages/db/migrations/016_gpu_metrics.sql
new file mode 100644
index 000000000..8c3f52ac5
--- /dev/null
+++ b/packages/db/migrations/016_gpu_metrics.sql
@@ -0,0 +1,99 @@
+-- PowerX telemetry digest.
+--
+-- The producer samples nvidia-smi / amd-smi once per second for the lifetime
+-- of every benchmark job and uploads the CSV as a `gpu_metrics_<suffix>`
+-- artifact next to `bmk_<suffix>`. Until now the app downloaded and parsed
+-- those artifacts from GitHub on every page view, and lost them entirely once
+-- GitHub's 90-day artifact retention expired. These tables move that work to
+-- ingest time: raw samples are kept at full resolution, per-GPU summary
+-- statistics are digested once, and each benchmark point is linked to the
+-- series that was recorded while it ran.
+
+create table gpu_metric_series (
+  id              bigserial   primary key,
+  workflow_run_id bigint      not null references workflow_runs(id) on delete cascade,
+  -- Full GitHub artifact name, including the runner-pool/attempt suffix.
+  artifact_name   text        not null,
+  -- Artifact name with the gpu_metrics_ prefix removed; pairs with bmk_<key>.
+  config_key      text        not null,
+  -- CSV path relative to the extracted artifact root (multinode uploads can
+  -- carry one CSV per serving node).
+  file_name       text        not null,
+  vendor          text        not null,
+  csv_sha256      text        not null,
+  sample_interval_s real,
+  sample_count    integer     not null,
+  gpu_count       smallint    not null,
+  started_at      timestamptz not null,
+  ended_at        timestamptz not null,
+  -- Parsed sidecars: gpu_metrics_context.json, gpu_metrics_identity.*,
+  -- gpu_metrics_energy_{start,end}.csv. Kept verbatim for provenance.
+  sidecars        jsonb       not null default '{}'::jsonb,
+  ingested_at     timestamptz not null default now(),
+
+  constraint gpu_metric_series_vendor_known check (vendor in ('nvidia', 'amd')),
+  constraint gpu_metric_series_artifact_nonempty check (artifact_name <> ''),
+  constraint gpu_metric_series_file_nonempty check (file_name <> ''),
+  constraint gpu_metric_series_sample_count_non_neg check (sample_count >= 0),
+  constraint gpu_metric_series_gpu_count_non_neg check (gpu_count >= 0),
+  constraint gpu_metric_series_window_ordered check (ended_at >= started_at),
+  constraint gpu_metric_series_unique unique (workflow_run_id, artifact_name, file_name)
+);
+
+create index gpu_metric_series_run_idx on gpu_metric_series (workflow_run_id);
+
+-- One row per (GPU, sample). Vendor-specific columns stay null when the
+-- collector does not report them. `real` keeps the row narrow; the source
+-- telemetry has at most three significant decimals.
+create table gpu_metric_samples (
+  series_id       bigint      not null references gpu_metric_series(id) on delete cascade,
+  gpu_index       smallint    not null,
+  sampled_at      timestamptz not null,
+  power_w         real,
+  temperature_c   real,
+  sm_clock_mhz    real,
+  mem_clock_mhz   real,
+  gpu_util_pct    real,
+  mem_util_pct    real,
+  edge_temp_c     real,
+  mem_temp_c      real,
+  gfx_voltage_mv  real,
+  soc_voltage_mv  real,
+  mem_voltage_mv  real,
+  fclk_mhz        real,
+  socclk_mhz      real,
+  mm_activity_pct real,
+
+  primary key (series_id, gpu_index, sampled_at)
+);
+
+-- Ingest-time digest so readers never rescan samples for summary cards.
+create table gpu_metric_gpu_stats (
+  series_id     bigint   not null references gpu_metric_series(id) on delete cascade,
+  gpu_index     smallint not null,
+  metric        text     not null,
+  sample_count  integer  not null,
+  min_value     real     not null,
+  max_value     real     not null,
+  mean_value    real     not null,
+  median_value  real     not null,
+  p95_value     real     not null,
+  p99_value     real     not null,
+  stddev_value  real     not null,
+
+  constraint gpu_metric_gpu_stats_metric_nonempty check (metric <> ''),
+  constraint gpu_metric_gpu_stats_sample_count_positive check (sample_count > 0),
+  primary key (series_id, gpu_index, metric)
+);
+
+-- Benchmark point ↔ telemetry series. A point can reference several series
+-- when a multinode artifact ships one CSV per node.
+create table benchmark_result_gpu_metrics (
+  benchmark_result_id bigint not null references benchmark_results(id) on delete cascade,
+  series_id           bigint not null references gpu_metric_series(id) on delete cascade,
+
+  primary key (benchmark_result_id, series_id)
+);
+
+create index benchmark_result_gpu_metrics_series_idx
+  on benchmark_result_gpu_metrics (series_id);
diff --git a/packages/db/migrations/017_gpu_metric_stats_version.sql b/packages/db/migrations/017_gpu_metric_stats_version.sql
new file mode 100644
index 000000000..68f7104b3
--- /dev/null
+++ b/packages/db/migrations/017_gpu_metric_stats_version.sql
@@ -0,0 +1,3 @@
+-- Zero means unversioned, not computed by the current algorithm.
+ALTER TABLE gpu_metric_series
+  ADD COLUMN IF NOT EXISTS stats_version integer NOT NULL DEFAULT 0;
diff --git a/packages/db/src/lib/gpu-metric-stats.ts b/packages/db/src/lib/gpu-metric-stats.ts
new file mode 100644
index 000000000..63bd4ec2a
--- /dev/null
+++ b/packages/db/src/lib/gpu-metric-stats.ts
@@ -0,0 +1,61 @@
+import {
+  computeGpuMetricStats,
+  type GpuMetricSample,
+  type GpuMetricStats,
+} from '../etl/gpu-metrics-csv';
+
+/** Bump whenever full-record digest definitions change. Independent of serving-window metrics. */
+export const GPU_STATS_VERSION = 1;
+
+export const STAT_METRIC_COLUMN = {
+  powerW: 'power_w',
+  temperatureC: 'temperature_c',
+  smClockMhz: 'sm_clock_mhz',
+  memClockMhz: 'mem_clock_mhz',
+  gpuUtilPct: 'gpu_util_pct',
+  memUtilPct: 'mem_util_pct',
+  edgeTempC: 'edge_temp_c',
+  memTempC: 'mem_temp_c',
+  gfxVoltageMv: 'gfx_voltage_mv',
+  socVoltageMv: 'soc_voltage_mv',
+  memVoltageMv: 'mem_voltage_mv',
+  fclkMhz: 'fclk_mhz',
+  socclkMhz: 'socclk_mhz',
+  mmActivityPct: 'mm_activity_pct',
+} as const satisfies Record<GpuMetricStats['metric'], string>;
+
+/** Stored metric names use the column spelling so SQL readers need no mapping. */
+export function statMetricColumn(metric: GpuMetricStats['metric']): string {
+  return STAT_METRIC_COLUMN[metric];
+}
+
+export type StoredGpuMetricSample = {
+  gpu_index: number;
+  sampled_at: string | Date;
+} & Record<(typeof STAT_METRIC_COLUMN)[keyof typeof STAT_METRIC_COLUMN], number | null>;
+
+/** Preserve nulls: chart adapters intentionally zero-fill power, digest inputs must not. */
+export function computeStoredGpuMetricStats(
+  rows: readonly StoredGpuMetricSample[],
+): GpuMetricStats[] {
+  return computeGpuMetricStats(
+    rows.map((row): GpuMetricSample => ({
+      timestampMs: new Date(row.sampled_at).getTime(),
+      gpuIndex: Number(row.gpu_index),
+      powerW: row.power_w,
+      temperatureC: row.temperature_c,
+      smClockMhz: row.sm_clock_mhz,
+      memClockMhz: row.mem_clock_mhz,
+      gpuUtilPct: row.gpu_util_pct,
+      memUtilPct: row.mem_util_pct,
+      edgeTempC: row.edge_temp_c,
+      memTempC: row.mem_temp_c,
+      gfxVoltageMv: row.gfx_voltage_mv,
+      socVoltageMv: row.soc_voltage_mv,
+      memVoltageMv: row.mem_voltage_mv,
+      fclkMhz: row.fclk_mhz,
+      socclkMhz: row.socclk_mhz,
+      mmActivityPct: row.mm_activity_pct,
+    })),
+  );
+}
diff --git a/packages/db/src/verify-db.ts b/packages/db/src/verify-db.ts
index 1f4d51edd..3ab8f805c 100644
--- a/packages/db/src/verify-db.ts
+++ b/packages/db/src/verify-db.ts
@@ -50,6 +50,9 @@ async function verify(): Promise<void> {
     TABLE_NAMES.evalResults,
     TABLE_NAMES.evalSamples,
     TABLE_NAMES.changelogEntries,
+    TABLE_NAMES.gpuMetricSeries,
+    TABLE_NAMES.gpuMetricSamples,
+    TABLE_NAMES.benchmarkResultGpuMetrics,
   ];
   for (const t of tables) {
     const [{ n }] = await sql`select count(*)::int as n from ${sql(t)}`;

From c7d683f38f47638ad10a91b7641397b747ec0a93 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 061/103] feat(etl): digest gpu_metrics and power_audit
 artifacts at ingest
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Parse NVIDIA/AMD CSVs and multinode power_audit bundles into series, samples and
statistics, replace a changed series atomically under a row lock, and count telemetry
failures separately so they never fail the benchmark ingest.

中文：在 ingest 时把 NVIDIA/AMD CSV 与多节点 power_audit 包解析为序列、样本和统计，在行锁内原子替换变更的序列，遥测失败单独计数、不影响 benchmark 入库。
---
 docs/fixtures/powerx-reingest/README.md       |  34 ++
 docs/fixtures/powerx-reingest/nvidia.csv      |  25 +
 packages/db/src/etl/benchmark-mapper.ts       |   2 +-
 packages/db/src/etl/gpu-metrics-artifacts.ts  | 275 +++++++++++
 packages/db/src/etl/gpu-metrics-csv.test.ts   |  84 ++++
 packages/db/src/etl/gpu-metrics-csv.ts        | 385 +++++++++++++++
 .../db/src/etl/gpu-metrics-ingest.test.ts     | 416 ++++++++++++++++
 packages/db/src/etl/gpu-metrics-ingest.ts     | 451 ++++++++++++++++++
 packages/db/src/etl/ingest-summary.ts         |   1 +
 .../db/src/etl/multinode-power-samples.ts     | 114 +++++
 .../db/src/etl/power-audit-recovery.test.ts   |  61 +++
 packages/db/src/etl/power-audit-recovery.ts   |  42 ++
 .../src/etl/power-audit-validations.test.ts   |  67 +++
 .../db/src/etl/power-audit-validations.ts     | 125 +++++
 packages/db/src/etl/skip-tracker.test.ts      |   1 +
 packages/db/src/etl/skip-tracker.ts           |  33 ++
 packages/db/src/ingest-ci-run.test.ts         |  42 ++
 packages/db/src/ingest-ci-run.ts              | 184 ++++++-
 packages/db/src/ingest-gcs-backup.ts          |  10 +-
 packages/db/src/lib/artifact-retry.ts         |  13 +
 packages/db/src/lib/github-artifacts.test.ts  |   1 -
 packages/db/src/lib/github-artifacts.ts       |  46 +-
 packages/db/src/prepare-ci-artifacts.ts       |  11 +
 23 files changed, 2398 insertions(+), 25 deletions(-)
 create mode 100644 docs/fixtures/powerx-reingest/README.md
 create mode 100644 docs/fixtures/powerx-reingest/nvidia.csv
 create mode 100644 packages/db/src/etl/gpu-metrics-artifacts.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-csv.test.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-csv.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-ingest.test.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-ingest.ts
 create mode 100644 packages/db/src/etl/multinode-power-samples.ts
 create mode 100644 packages/db/src/etl/power-audit-recovery.test.ts
 create mode 100644 packages/db/src/etl/power-audit-recovery.ts
 create mode 100644 packages/db/src/etl/power-audit-validations.test.ts
 create mode 100644 packages/db/src/etl/power-audit-validations.ts

diff --git a/docs/fixtures/powerx-reingest/README.md b/docs/fixtures/powerx-reingest/README.md
new file mode 100644
index 000000000..6df4caba2
--- /dev/null
+++ b/docs/fixtures/powerx-reingest/README.md
@@ -0,0 +1,34 @@
+# Retained telemetry for re-ingest recovery
+
+`nvidia.csv` contains unchanged readings from the public InferenceX B200/Qwen3.5
+run [34175132645, attempt 1](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645/attempts/1).
+Tests read these committed bytes; no artifact download is required.
+
+Retain original line 1 and lines 2898–2921, joined with LF and a final LF: three
+consecutive samples of all eight GPUs, 24 rows / 1,901 bytes. Headers, units,
+timestamps and values are unchanged. The CSV contains no hostnames or UUIDs, so
+no identity anonymization was needed. The original collector version and timezone
+are unknown.
+
+The UTC context, collector labels, identity sidecars, local benchmark rows and
+repair offsets used by tests are **constructed test inputs**. They do not describe
+a correction to the original run. No original energy/quality claim is attached to
+this cropped fragment. It proves retained-format parsing and recovery through the
+consumer, not GPU collection reliability or serving-window qualification.
+
+Fixed checks come directly from the retained rows: GPU 0 has
+`380.42, 336.61, 337.18 W`; with the explicit UTC test context the range is
+`2026-09-08T07:20:19.279Z`–`2026-09-08T07:20:21.279Z`. Its sample mean is
+`351.4033333333333 W`. Production parsers/statistics functions must not generate
+test expectations.
+
+Run the recovery check from `packages/app`:
+
+```sh
+bun node_modules/vitest/vitest.mjs run src/app/api/v1/gpu-metrics-point/route.test.ts
+```
+
+The test uses PGlite, the production parser/ingest/query/cache/point handler, and
+the real Blob SDK with a local HTTP transport. It checks live revisions for
+successful and missing responses, then refreshes a missing point, shared links and
+timezone/identity repairs without purging.
diff --git a/docs/fixtures/powerx-reingest/nvidia.csv b/docs/fixtures/powerx-reingest/nvidia.csv
new file mode 100644
index 000000000..62113072c
--- /dev/null
+++ b/docs/fixtures/powerx-reingest/nvidia.csv
@@ -0,0 +1,25 @@
+timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]
+2026/09/08 07:20:19.279, 0, 380.42 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 1, 392.58 W, 43, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 2, 375.45 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 3, 384.71 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 4, 379.91 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 5, 388.18 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 6, 374.34 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 7, 379.36 W, 41, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 0, 336.61 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 1, 346.06 W, 43, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 2, 333.34 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 3, 344.15 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 4, 337.25 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 5, 342.84 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 6, 335.00 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 7, 335.78 W, 41, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 0, 337.18 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 1, 345.05 W, 43, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 2, 340.15 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 3, 344.63 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 4, 337.94 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 5, 342.85 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 6, 334.88 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 7, 336.11 W, 41, 1965 MHz, 3996 MHz, 100 %, 9 %
diff --git a/packages/db/src/etl/benchmark-mapper.ts b/packages/db/src/etl/benchmark-mapper.ts
index 060b39412..d63a4a49a 100644
--- a/packages/db/src/etl/benchmark-mapper.ts
+++ b/packages/db/src/etl/benchmark-mapper.ts
@@ -148,7 +148,7 @@ export interface PowerAudit {
   max_sample_gap_s?: number;
   producer_sha?: string | null;
   exporter_image_sha256?: string | null;
-  /** Relative path within the source run artifact bundle. */
+  /** Validation filename; nested AgentX documents use a canonical filename alias. */
   source?: string;
   /** Producer device identifiers; not necessarily physical UUIDs on older traces. */
   observed_gpu_ids?: string[];
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.ts b/packages/db/src/etl/gpu-metrics-artifacts.ts
new file mode 100644
index 000000000..d101976e4
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-artifacts.ts
@@ -0,0 +1,275 @@
+/**
+ * Filesystem discovery for `gpu_metrics_<suffix>` artifacts.
+ *
+ * Layout uploaded by the producer (`benchmark-tmpl.yml` "Upload GPU metrics"):
+ *   gpu_metrics.csv                         fixed-sequence jobs
+ *   results/gpu_metrics.csv                 AgentX jobs (per-concurrency)
+ *   results/gpu_metrics*.csv                multinode staging, one CSV per node
+ *   gpu_metrics*_context.json               collector context (timestamp zone …)
+ *   gpu_metrics_identity.{json,csv}         SKU / UUID / driver per GPU
+ *   gpu_metrics_energy_{start,end}.csv      amd-smi energy counters
+ *
+ * Multinode jobs (`benchmark-multinode-tmpl.yml`) upload no `gpu_metrics_`
+ * artifact; their telemetry travels inside `power_audit_<suffix>`:
+ *   LOGS/power/samples.csv                  deployment-wide DCGM power, one row per (host, GPU, s)
+ *   LOGS/power/manifest.json                producer, source metric, cadence
+ * Single-node jobs upload a `power_audit_` bundle too, so it only stands in
+ * for a point when no `gpu_metrics_<suffix>` sibling exists.
+ *
+ * `eval_gpu_metrics_<suffix>` (eval-only jobs) is deliberately ignored: those
+ * jobs produce no benchmark point to attach the telemetry to.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+
+import { isMultinodePowerSamplesPath } from './multinode-power-samples.js';
+import {
+  isPowerAuditValidationEntry,
+  normalizePowerAuditValidations,
+} from './power-audit-validations.js';
+
+export const GPU_METRICS_ARTIFACT_PREFIX = 'gpu_metrics_';
+export const POWER_AUDIT_ARTIFACT_PREFIX = 'power_audit_';
+
+export interface GpuMetricsArtifact {
+  artifactName: string;
+  artifactDir: string;
+}
+
+export interface GpuMetricsCsvFile {
+  /** POSIX-style path relative to the artifact root. */
+  fileName: string;
+  path: string;
+}
+
+export interface GpuMetricsSidecars {
+  context: Record<string, unknown> | null;
+  /** Audit documents keyed by canonical source; nested documents retain original path/hash. */
+  validations?: Record<string, Record<string, unknown>>;
+  /** Expected stored files and deduplicated row counts from this one artifact. */
+  seriesInventory?: { fileName: string; sampleCount: number }[];
+  /** Bundle manifest when the preferred CSV has its own collector context. */
+  powerManifest?: Record<string, unknown> | null;
+  identity: unknown | null;
+  energyStart: Record<string, number> | null;
+  energyEnd: Record<string, number> | null;
+}
+
+/** Return the shared suffix that pairs a telemetry artifact with bmk[_agentic]_<suffix>. */
+export function gpuMetricsArtifactSuffix(artifactName: string): string | null {
+  for (const prefix of [GPU_METRICS_ARTIFACT_PREFIX, POWER_AUDIT_ARTIFACT_PREFIX]) {
+    if (artifactName.startsWith(prefix)) return artifactName.slice(prefix.length);
+  }
+  return null;
+}
+
+/** The nvidia-smi/amd-smi CSV carries clocks, utilization and temperature; the power bundle only power. */
+export function isPowerAuditArtifact(artifactName: string): boolean {
+  return artifactName.startsWith(POWER_AUDIT_ARTIFACT_PREFIX);
+}
+
+function isGpuMetricsCsvName(fileName: string): boolean {
+  const lower = fileName.toLowerCase();
+  if (!lower.startsWith('gpu_metrics') || !lower.endsWith('.csv')) return false;
+  // Sidecars share the prefix but are not time series.
+  return !lower.includes('_identity') && !lower.includes('_energy_');
+}
+
+/** Recursively list every telemetry CSV under an extracted artifact root. */
+export function listGpuMetricsCsvFiles(root: string): GpuMetricsCsvFile[] {
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return [];
+  const files: GpuMetricsCsvFile[] = [];
+  const visit = (directory: string): void => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const pathname = path.join(directory, entry.name);
+      if (entry.isDirectory()) visit(pathname);
+      else if (entry.isFile() && isGpuMetricsCsvName(entry.name)) {
+        files.push({
+          fileName: path.relative(root, pathname).split(path.sep).join('/'),
+          path: pathname,
+        });
+      }
+    }
+  };
+  visit(root);
+  return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
+}
+
+/** Every multinode power CSV under an extracted `power_audit_` root. */
+export function listMultinodePowerSampleFiles(root: string): GpuMetricsCsvFile[] {
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return [];
+  const files: GpuMetricsCsvFile[] = [];
+  const visit = (directory: string): void => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const pathname = path.join(directory, entry.name);
+      if (entry.isDirectory()) visit(pathname);
+      else if (entry.isFile()) {
+        const fileName = path.relative(root, pathname).split(path.sep).join('/');
+        if (isMultinodePowerSamplesPath(fileName)) files.push({ fileName, path: pathname });
+      }
+    }
+  };
+  visit(root);
+  return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
+}
+
+/** The producer manifest next to `samples.csv`; null when absent or malformed. */
+export function readMultinodePowerManifest(samplesPath: string): Record<string, unknown> | null {
+  const parsed = readJsonIfPresent(path.join(path.dirname(samplesPath), 'manifest.json'));
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+    ? (parsed as Record<string, unknown>)
+    : null;
+}
+
+/** Preserve window boundaries and role overrides before GitHub artifact expiry. */
+export function readPowerAuditValidations(
+  root: string,
+  artifactName = path.basename(root),
+): Record<string, Record<string, unknown>> {
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return {};
+  const files = new Map<string, string>();
+  const read = (name: string) => {
+    const file = path.join(root, name);
+    if (isPowerAuditValidationEntry(name) && fs.existsSync(file) && fs.statSync(file).isFile()) {
+      files.set(name, fs.readFileSync(file, 'utf8'));
+    }
+  };
+  for (const name of fs.readdirSync(root).sort()) {
+    read(name);
+  }
+  const agentic = path.join(root, 'LOGS', 'agentic');
+  if (fs.existsSync(agentic) && fs.statSync(agentic).isDirectory()) {
+    for (const entry of fs.readdirSync(agentic, { withFileTypes: true })) {
+      const match = /^conc_(?<concurrency>[1-9]\d*)$/u.exec(entry.name);
+      if (!entry.isDirectory() || !match) continue;
+      read(`LOGS/agentic/${entry.name}/power_validation.json`);
+      read(`LOGS/power/windows/agentic_power_concurrency_${match.groups!.concurrency}.json`);
+    }
+  }
+  const validations = normalizePowerAuditValidations(artifactName, files);
+  for (const validation of validations.values()) {
+    if (typeof validation.validation_path !== 'string') continue;
+    const original = files.get(validation.validation_path);
+    if (original !== undefined)
+      validation.validation_sha256 = createHash('sha256').update(original).digest('hex');
+  }
+  return Object.fromEntries(validations);
+}
+
+function readJsonIfPresent(pathname: string): unknown | null {
+  if (!fs.existsSync(pathname)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(pathname, 'utf8')) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+/** `gpu,total_energy_consumption` two-column CSV → { "<gpu>": joules }. */
+export function parseEnergyCsv(text: string): Record<string, number> | null {
+  const lines = text
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  if (lines.length <= 1) return null;
+  const out: Record<string, number> = {};
+  for (const line of lines.slice(1)) {
+    const [gpu, value] = line.split(',');
+    const parsed = Number.parseFloat(value ?? '');
+    if (gpu !== undefined && gpu !== '' && Number.isFinite(parsed)) out[gpu.trim()] = parsed;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+
+/** Identity CSV (nvidia-smi) → array of column objects; JSON identity passes through. */
+function readIdentity(csvDir: string): unknown | null {
+  const json = readJsonIfPresent(path.join(csvDir, 'gpu_metrics_identity.json'));
+  if (json !== null) return json;
+  const csvPath = path.join(csvDir, 'gpu_metrics_identity.csv');
+  if (!fs.existsSync(csvPath)) return null;
+  const lines = fs
+    .readFileSync(csvPath, 'utf8')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  if (lines.length <= 1) return null;
+  const header = lines[0]!.split(',').map((h) => h.trim());
+  return lines.slice(1).map((line) => {
+    const cells = line.split(',').map((c) => c.trim());
+    return Object.fromEntries(header.map((key, i) => [key, cells[i] ?? '']));
+  });
+}
+
+/**
+ * Sidecars live next to the CSV they describe. The context file is either
+ * `gpu_metrics_context.json` or `<result>_gpu_metrics_context.json`.
+ */
+export function readGpuMetricsSidecars(csvPath: string): GpuMetricsSidecars {
+  const dir = path.dirname(csvPath);
+  let context: Record<string, unknown> | null = null;
+  // Match live ZIP reads even when filesystem/central-directory orders differ.
+  const contextFiles = fs
+    .readdirSync(dir)
+    .filter(
+      (entry) => entry.toLowerCase().endsWith('_context.json') && entry.includes('gpu_metrics'),
+    )
+    .sort();
+  for (const entry of contextFiles) {
+    const parsed = readJsonIfPresent(path.join(dir, entry));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      context = parsed as Record<string, unknown>;
+      break;
+    }
+  }
+  const energyStartPath = path.join(dir, 'gpu_metrics_energy_start.csv');
+  const energyEndPath = path.join(dir, 'gpu_metrics_energy_end.csv');
+  return {
+    context,
+    identity: readIdentity(dir),
+    energyStart: fs.existsSync(energyStartPath)
+      ? parseEnergyCsv(fs.readFileSync(energyStartPath, 'utf8'))
+      : null,
+    energyEnd: fs.existsSync(energyEndPath)
+      ? parseEnergyCsv(fs.readFileSync(energyEndPath, 'utf8'))
+      : null,
+  };
+}
+
+/**
+ * Collector clock offset in minutes east of UTC, from the context sidecar.
+ * The producer writes `{"timestamp_timezone":"UTC"}`; anything else that is
+ * not a fixed `±HH:MM` offset is treated as UTC because nvidia-smi timestamps
+ * carry no zone of their own.
+ */
+export function contextUtcOffsetMinutes(context: Record<string, unknown> | null): number {
+  const zone = context?.timestamp_timezone;
+  if (typeof zone !== 'string') return 0;
+  const match = /^(?<sign>[+-])(?<h>\d{2}):?(?<m>\d{2})$/u.exec(zone.trim());
+  if (!match?.groups) return 0;
+  const minutes = Number(match.groups.h) * 60 + Number(match.groups.m);
+  return match.groups.sign === '-' ? -minutes : minutes;
+}
+
+/**
+ * Index every extracted telemetry artifact by its shared suffix. A
+ * `gpu_metrics_` upload wins over the `power_audit_` bundle for the same
+ * suffix; the bundle only fills in for multinode jobs that have no other.
+ */
+export function discoverGpuMetricsArtifacts(artifactsDir: string): Map<string, GpuMetricsArtifact> {
+  const discovered = new Map<string, GpuMetricsArtifact>();
+  if (!fs.existsSync(artifactsDir)) return discovered;
+  const names = fs
+    .readdirSync(artifactsDir)
+    .filter((artifactName) => fs.statSync(path.join(artifactsDir, artifactName)).isDirectory());
+  for (const preferred of [false, true]) {
+    for (const artifactName of names) {
+      if (isPowerAuditArtifact(artifactName) !== preferred) continue;
+      const suffix = gpuMetricsArtifactSuffix(artifactName);
+      if (!suffix || discovered.has(suffix)) continue;
+      discovered.set(suffix, { artifactName, artifactDir: path.join(artifactsDir, artifactName) });
+    }
+  }
+  return discovered;
+}
diff --git a/packages/db/src/etl/gpu-metrics-csv.test.ts b/packages/db/src/etl/gpu-metrics-csv.test.ts
new file mode 100644
index 000000000..be0425149
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-csv.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+
+import { computeGpuMetricStats, parseGpuMetricsCsv } from './gpu-metrics-csv.js';
+
+const NVIDIA_CSV = [
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+  '2026/09/11 04:19:41.982, 0, 187.80 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:41.986, 1, 190.96 W, 39, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:42.990, 0, 912.10 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+  '2026/09/11 04:19:42.994, 1, [N/A], 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+  '2026/09/11 04:19:43.990, 0, 930.00 W, 63, 1965 MHz, 3996 MHz, 99 %, 75 %',
+].join('\n');
+
+const AMD_HEADER =
+  'timestamp,gpu,gfx_activity,umc_activity,mm_activity,socket_power,gfx_voltage,soc_voltage,mem_voltage,gfx_0_clk,mem_0_clk,fclk_0_clk,socclk_0_clk,edge,hotspot,mem';
+
+const AMD_CSV = [
+  AMD_HEADER,
+  `1789515524,0,0,0,N/A,288,N/A,N/A,N/A,2402,2000,1250,39,N/A,44,24`,
+  `1789515525,0,95,80,N/A,1180,850,900,1250,2100,2000,1250,39,55,78,60`,
+  `1789515524,1,0,0,N/A,290,N/A,N/A,N/A,2402,2000,1250,39,40,45,25`,
+].join('\r\n');
+
+describe('parseGpuMetricsCsv — NVIDIA', () => {
+  it('parses unit-suffixed cells into UTC epoch samples and drops rows without power', () => {
+    const parsed = parseGpuMetricsCsv(NVIDIA_CSV);
+    expect(parsed?.vendor).toBe('nvidia');
+    expect(parsed?.samples).toHaveLength(4);
+    const first = parsed!.samples[0]!;
+    expect(first.timestampMs).toBe(Date.UTC(2026, 8, 11, 4, 19, 41, 982));
+    expect(first.gpuIndex).toBe(0);
+    expect(first.powerW).toBe(187.8);
+    expect(first.temperatureC).toBe(33);
+    expect(first.smClockMhz).toBe(120);
+    expect(first.memClockMhz).toBe(3996);
+    expect(first.gpuUtilPct).toBe(0);
+    expect(first.memUtilPct).toBe(0);
+    expect(first.edgeTempC).toBeNull();
+    // The `[N/A]` power row for GPU 1 is not a usable sample.
+    expect(parsed!.samples.filter((s) => s.gpuIndex === 1)).toHaveLength(1);
+  });
+});
+
+describe('parseGpuMetricsCsv — AMD', () => {
+  it('maps the amd-smi subset, preferring hotspot over edge temperature', () => {
+    const parsed = parseGpuMetricsCsv(AMD_CSV);
+    expect(parsed?.vendor).toBe('amd');
+    expect(parsed?.samples).toHaveLength(3);
+    const idle = parsed!.samples[0]!;
+    expect(idle.timestampMs).toBe(1789515524000);
+    expect(idle.powerW).toBe(288);
+    expect(idle.temperatureC).toBe(44);
+    expect(idle.edgeTempC).toBeNull();
+    expect(idle.memTempC).toBe(24);
+    expect(idle.gfxVoltageMv).toBeNull();
+    const busy = parsed!.samples[1]!;
+    expect(busy.gpuUtilPct).toBe(95);
+    expect(busy.memUtilPct).toBe(80);
+    expect(busy.gfxVoltageMv).toBe(850);
+    expect(busy.fclkMhz).toBe(1250);
+    expect(busy.socclkMhz).toBe(39);
+    expect(busy.edgeTempC).toBe(55);
+    expect(busy.temperatureC).toBe(78);
+  });
+});
+
+describe('computeGpuMetricStats', () => {
+  it('digests every non-null metric per GPU with interpolated percentiles', () => {
+    const parsed = parseGpuMetricsCsv(NVIDIA_CSV)!;
+    const stats = computeGpuMetricStats(parsed.samples);
+    const gpu0Power = stats.find((s) => s.gpuIndex === 0 && s.metric === 'powerW')!;
+    expect(gpu0Power.count).toBe(3);
+    expect(gpu0Power.min).toBe(187.8);
+    expect(gpu0Power.max).toBe(930);
+    expect(gpu0Power.mean).toBeCloseTo((187.8 + 912.1 + 930) / 3, 6);
+    expect(gpu0Power.median).toBe(912.1);
+    expect(gpu0Power.p95).toBeCloseTo(912.1 + (930 - 912.1) * 0.9, 6);
+    expect(gpu0Power.p99).toBeCloseTo(912.1 + (930 - 912.1) * 0.98, 6);
+    expect(gpu0Power.stddev).toBeGreaterThan(0);
+    // AMD-only columns never appear for an NVIDIA series.
+    expect(stats.some((s) => s.metric === 'edgeTempC')).toBe(false);
+    expect(stats.filter((s) => s.gpuIndex === 1 && s.metric === 'powerW')[0]!.count).toBe(1);
+  });
+});
diff --git a/packages/db/src/etl/gpu-metrics-csv.ts b/packages/db/src/etl/gpu-metrics-csv.ts
new file mode 100644
index 000000000..35ec33e57
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-csv.ts
@@ -0,0 +1,385 @@
+/**
+ * Parser and digest for the producer's `gpu_metrics.csv` telemetry.
+ *
+ * The InferenceX runner samples `nvidia-smi --query-gpu=…` or `amd-smi metric
+ * --csv` once per second for the lifetime of a benchmark job. This module is
+ * pure (no I/O) so the CI ingest, the historical backfill, and the app's
+ * GitHub fallback path all normalize the two vendor formats identically.
+ */
+
+export type GpuMetricsVendor = 'nvidia' | 'amd';
+
+export interface GpuMetricSample {
+  /** Sample instant in epoch milliseconds (UTC). */
+  timestampMs: number;
+  gpuIndex: number;
+  powerW: number | null;
+  temperatureC: number | null;
+  smClockMhz: number | null;
+  memClockMhz: number | null;
+  gpuUtilPct: number | null;
+  memUtilPct: number | null;
+  edgeTempC: number | null;
+  memTempC: number | null;
+  gfxVoltageMv: number | null;
+  socVoltageMv: number | null;
+  memVoltageMv: number | null;
+  fclkMhz: number | null;
+  socclkMhz: number | null;
+  mmActivityPct: number | null;
+}
+
+export interface ParsedGpuMetricsCsv {
+  vendor: GpuMetricsVendor;
+  samples: GpuMetricSample[];
+}
+
+/** Sample columns that participate in the per-GPU statistics digest. */
+export const GPU_METRIC_STAT_KEYS = [
+  'powerW',
+  'temperatureC',
+  'smClockMhz',
+  'memClockMhz',
+  'gpuUtilPct',
+  'memUtilPct',
+  'edgeTempC',
+  'memTempC',
+  'gfxVoltageMv',
+  'socVoltageMv',
+  'memVoltageMv',
+  'fclkMhz',
+  'socclkMhz',
+  'mmActivityPct',
+] as const;
+
+export type GpuMetricStatKey = (typeof GPU_METRIC_STAT_KEYS)[number];
+
+export interface GpuMetricStats {
+  gpuIndex: number;
+  metric: GpuMetricStatKey;
+  count: number;
+  min: number;
+  max: number;
+  mean: number;
+  median: number;
+  p95: number;
+  p99: number;
+  stddev: number;
+}
+
+export function splitCsvLine(line: string): string[] {
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+  for (const char of line) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === ',' && !inQuotes) {
+      result.push(current.trim());
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+
+function buildColumnMap(headerLine: string): Map<string, number> {
+  const headers = splitCsvLine(headerLine);
+  const map = new Map<string, number>();
+  for (let i = 0; i < headers.length; i++) map.set(headers[i]!.toLowerCase(), i);
+  return map;
+}
+
+/** `N/A`, empty, and unparseable cells become null; unit suffixes are ignored. */
+export function parseMetricCell(value: string | undefined): number | null {
+  if (value === undefined) return null;
+  const trimmed = value.trim();
+  if (trimmed === '' || trimmed === 'N/A' || trimmed === '[N/A]') return null;
+  const parsed = Number.parseFloat(trimmed);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+const NVIDIA_TIMESTAMP_RE =
+  /^(?<y>\d{4})\/(?<mo>\d{2})\/(?<d>\d{2}) (?<h>\d{2}):(?<mi>\d{2}):(?<s>\d{2})(?:\.(?<ms>\d{1,3}))?$/u;
+
+/**
+ * nvidia-smi prints `YYYY/MM/DD HH:MM:SS.mmm` in the collector's local zone.
+ * The producer runs its collectors with TZ=UTC; callers can pass a different
+ * fixed offset (minutes east of UTC) when a context sidecar says otherwise.
+ */
+export function parseNvidiaTimestamp(raw: string, offsetMinutes = 0): number | null {
+  const match = NVIDIA_TIMESTAMP_RE.exec(raw.trim());
+  if (!match?.groups) return null;
+  const { y, mo, d, h, mi, s, ms } = match.groups;
+  const millis = ms ? Number(ms.padEnd(3, '0')) : 0;
+  const utc = Date.UTC(
+    Number(y),
+    Number(mo) - 1,
+    Number(d),
+    Number(h),
+    Number(mi),
+    Number(s),
+    millis,
+  );
+  return utc - offsetMinutes * 60_000;
+}
+
+/** amd-smi prints Unix epoch seconds; accept fractional and millisecond forms. */
+export function parseAmdTimestamp(raw: string): number | null {
+  const trimmed = raw.trim();
+  if (/^\d+(?:\.\d+)?$/u.test(trimmed)) {
+    const numeric = Number.parseFloat(trimmed);
+    if (numeric > 1e12) return Math.round(numeric); // already milliseconds
+    if (numeric > 1e9) return Math.round(numeric * 1000);
+    return null;
+  }
+  const iso = Date.parse(trimmed);
+  return Number.isFinite(iso) ? iso : null;
+}
+
+function emptySample(timestampMs: number, gpuIndex: number): GpuMetricSample {
+  return {
+    timestampMs,
+    gpuIndex,
+    powerW: null,
+    temperatureC: null,
+    smClockMhz: null,
+    memClockMhz: null,
+    gpuUtilPct: null,
+    memUtilPct: null,
+    edgeTempC: null,
+    memTempC: null,
+    gfxVoltageMv: null,
+    socVoltageMv: null,
+    memVoltageMv: null,
+    fclkMhz: null,
+    socclkMhz: null,
+    mmActivityPct: null,
+  };
+}
+
+/**
+ * Columns: timestamp, index, power.draw [W], temperature.gpu,
+ * clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%],
+ * utilization.memory [%]. Header order is fixed by NVIDIA_GPU_MONITOR_QUERY in
+ * the producer, but we still resolve by name so a reordered query keeps working.
+ */
+function parseNvidiaCsv(lines: readonly string[], offsetMinutes: number): GpuMetricSample[] {
+  const header = splitCsvLine(lines[0]!).map((h) => h.toLowerCase().replace(/\s*\[.*\]$/u, ''));
+  const col = (name: string) => header.indexOf(name);
+  const iTimestamp = col('timestamp');
+  const iIndex = col('index');
+  const iPower = col('power.draw');
+  const iTemp = col('temperature.gpu');
+  const iSm = col('clocks.current.sm');
+  const iMem = col('clocks.current.memory');
+  const iUtil = col('utilization.gpu');
+  const iMemUtil = col('utilization.memory');
+  if (iTimestamp < 0 || iIndex < 0 || iPower < 0) return [];
+
+  const samples: GpuMetricSample[] = [];
+  for (let i = 1; i < lines.length; i++) {
+    const cols = splitCsvLine(lines[i]!);
+    if (cols.length <= Math.max(iTimestamp, iIndex, iPower)) continue;
+    const timestampMs = parseNvidiaTimestamp(cols[iTimestamp]!, offsetMinutes);
+    const gpuIndex = Number.parseInt(cols[iIndex]!, 10);
+    if (timestampMs === null || !Number.isInteger(gpuIndex) || gpuIndex < 0) continue;
+    const sample = emptySample(timestampMs, gpuIndex);
+    sample.powerW = parseMetricCell(cols[iPower]);
+    if (sample.powerW === null) continue;
+    sample.temperatureC = iTemp >= 0 ? parseMetricCell(cols[iTemp]) : null;
+    sample.smClockMhz = iSm >= 0 ? parseMetricCell(cols[iSm]) : null;
+    sample.memClockMhz = iMem >= 0 ? parseMetricCell(cols[iMem]) : null;
+    sample.gpuUtilPct = iUtil >= 0 ? parseMetricCell(cols[iUtil]) : null;
+    sample.memUtilPct = iMemUtil >= 0 ? parseMetricCell(cols[iMemUtil]) : null;
+    samples.push(sample);
+  }
+  return samples;
+}
+
+/**
+ * amd-smi `metric --csv` is a wide table. The consumed subset mirrors the
+ * dashboard: socket_power, gfx_activity, umc_activity, mm_activity, the first
+ * gfx/mem/fclk/socclk clock domains, hotspot/edge/mem temperatures and the
+ * three voltage rails.
+ */
+function parseAmdCsv(lines: readonly string[]): GpuMetricSample[] {
+  const colMap = buildColumnMap(lines[0]!);
+  const col = (name: string) => colMap.get(name) ?? -1;
+  const iTimestamp = col('timestamp');
+  const iGpu = col('gpu');
+  const iPower = col('socket_power');
+  const iGfxActivity = col('gfx_activity');
+  const iUmcActivity = col('umc_activity');
+  const iGfxClk = col('gfx_0_clk');
+  const iMemClk = col('mem_0_clk');
+  const iHotspot = col('hotspot');
+  const iEdge = col('edge');
+  const iMemTemp = col('mem');
+  const iGfxVoltage = col('gfx_voltage');
+  const iSocVoltage = col('soc_voltage');
+  const iMemVoltage = col('mem_voltage');
+  const iFclk = col('fclk_0_clk');
+  const iSocClk = col('socclk_0_clk');
+  const iMmActivity = col('mm_activity');
+  if (iTimestamp < 0 || iGpu < 0 || iPower < 0) return [];
+
+  const samples: GpuMetricSample[] = [];
+  for (let i = 1; i < lines.length; i++) {
+    const cols = splitCsvLine(lines[i]!);
+    if (cols.length <= Math.max(iTimestamp, iGpu, iPower)) continue;
+    const timestampMs = parseAmdTimestamp(cols[iTimestamp]!);
+    const gpuIndex = Number.parseInt(cols[iGpu]!, 10);
+    if (timestampMs === null || !Number.isInteger(gpuIndex) || gpuIndex < 0) continue;
+    const sample = emptySample(timestampMs, gpuIndex);
+    sample.powerW = parseMetricCell(cols[iPower]);
+    if (sample.powerW === null) continue;
+    const hotspot = iHotspot >= 0 ? parseMetricCell(cols[iHotspot]) : null;
+    const edge = iEdge >= 0 ? parseMetricCell(cols[iEdge]) : null;
+    sample.temperatureC = hotspot ?? edge;
+    sample.edgeTempC = edge;
+    sample.memTempC = iMemTemp >= 0 ? parseMetricCell(cols[iMemTemp]) : null;
+    sample.smClockMhz = iGfxClk >= 0 ? parseMetricCell(cols[iGfxClk]) : null;
+    sample.memClockMhz = iMemClk >= 0 ? parseMetricCell(cols[iMemClk]) : null;
+    sample.gpuUtilPct = iGfxActivity >= 0 ? parseMetricCell(cols[iGfxActivity]) : null;
+    sample.memUtilPct = iUmcActivity >= 0 ? parseMetricCell(cols[iUmcActivity]) : null;
+    sample.gfxVoltageMv = iGfxVoltage >= 0 ? parseMetricCell(cols[iGfxVoltage]) : null;
+    sample.socVoltageMv = iSocVoltage >= 0 ? parseMetricCell(cols[iSocVoltage]) : null;
+    sample.memVoltageMv = iMemVoltage >= 0 ? parseMetricCell(cols[iMemVoltage]) : null;
+    sample.fclkMhz = iFclk >= 0 ? parseMetricCell(cols[iFclk]) : null;
+    sample.socclkMhz = iSocClk >= 0 ? parseMetricCell(cols[iSocClk]) : null;
+    sample.mmActivityPct = iMmActivity >= 0 ? parseMetricCell(cols[iMmActivity]) : null;
+    samples.push(sample);
+  }
+  return samples;
+}
+
+export interface ParseGpuMetricsOptions {
+  /** Fixed offset of the NVIDIA collector clock, minutes east of UTC. */
+  nvidiaUtcOffsetMinutes?: number;
+}
+
+/**
+ * Parse one gpu_metrics CSV, auto-detecting the vendor from the header.
+ * Samples are returned in file order; callers sort per GPU as needed.
+ */
+export function parseGpuMetricsCsv(
+  csvText: string,
+  options: ParseGpuMetricsOptions = {},
+): ParsedGpuMetricsCsv | null {
+  const lines = csvText
+    .split('\n')
+    .map((line) => line.replace(/\r$/u, ''))
+    .filter((line) => line.trim().length > 0);
+  if (lines.length <= 1) return null;
+  const headerLower = lines[0]!.toLowerCase();
+  if (headerLower.includes('socket_power') || headerLower.includes('gfx_activity')) {
+    return { vendor: 'amd', samples: parseAmdCsv(lines) };
+  }
+  if (headerLower.includes('power.draw')) {
+    return {
+      vendor: 'nvidia',
+      samples: parseNvidiaCsv(lines, options.nvidiaUtcOffsetMinutes ?? 0),
+    };
+  }
+  return null;
+}
+
+function percentile(sorted: readonly number[], p: number): number {
+  const idx = (p / 100) * (sorted.length - 1);
+  const lo = Math.floor(idx);
+  const hi = Math.ceil(idx);
+  if (lo === hi) return sorted[lo]!;
+  return sorted[lo]! + (sorted[hi]! - sorted[lo]!) * (idx - lo);
+}
+
+/** Per-GPU, per-metric summary over every non-null sample. */
+export function computeGpuMetricStats(samples: readonly GpuMetricSample[]): GpuMetricStats[] {
+  const groups = new Map<
+    string,
+    { gpuIndex: number; metric: GpuMetricStatKey; values: number[] }
+  >();
+  for (const sample of samples) {
+    for (const metric of GPU_METRIC_STAT_KEYS) {
+      const value = sample[metric];
+      if (value === null) continue;
+      const key = `${sample.gpuIndex}|${metric}`;
+      let group = groups.get(key);
+      if (!group) {
+        group = { gpuIndex: sample.gpuIndex, metric, values: [] };
+        groups.set(key, group);
+      }
+      group.values.push(value);
+    }
+  }
+
+  const stats: GpuMetricStats[] = [];
+  for (const group of groups.values()) {
+    const sorted = group.values.toSorted((a, b) => a - b);
+    const mean = sorted.reduce((acc, v) => acc + v, 0) / sorted.length;
+    const variance = sorted.reduce((acc, v) => acc + (v - mean) ** 2, 0) / sorted.length;
+    stats.push({
+      gpuIndex: group.gpuIndex,
+      metric: group.metric,
+      count: sorted.length,
+      min: sorted[0]!,
+      max: sorted.at(-1)!,
+      mean,
+      median: percentile(sorted, 50),
+      p95: percentile(sorted, 95),
+      p99: percentile(sorted, 99),
+      stddev: Math.sqrt(variance),
+    });
+  }
+  return stats.toSorted((a, b) => a.gpuIndex - b.gpuIndex || a.metric.localeCompare(b.metric));
+}
+
+export interface GpuMetricSeriesSummary {
+  sampleCount: number;
+  gpuCount: number;
+  startedAtMs: number;
+  endedAtMs: number;
+  /** Median gap between consecutive samples of one GPU, in seconds. */
+  sampleIntervalS: number | null;
+}
+
+/** Window and cadence facts stored on the series row. */
+export function summarizeGpuMetricSamples(
+  samples: readonly GpuMetricSample[],
+): GpuMetricSeriesSummary | null {
+  if (samples.length === 0) return null;
+  let startedAtMs = Number.POSITIVE_INFINITY;
+  let endedAtMs = Number.NEGATIVE_INFINITY;
+  const byGpu = new Map<number, number[]>();
+  for (const sample of samples) {
+    if (sample.timestampMs < startedAtMs) startedAtMs = sample.timestampMs;
+    if (sample.timestampMs > endedAtMs) endedAtMs = sample.timestampMs;
+    const bucket = byGpu.get(sample.gpuIndex);
+    if (bucket) bucket.push(sample.timestampMs);
+    else byGpu.set(sample.gpuIndex, [sample.timestampMs]);
+  }
+  const gaps: number[] = [];
+  for (const timestamps of byGpu.values()) {
+    const sorted = timestamps.toSorted((a, b) => a - b);
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i]! - sorted[i - 1]!;
+      if (gap > 0) gaps.push(gap);
+    }
+  }
+  const sampleIntervalS =
+    gaps.length > 0
+      ? percentile(
+          gaps.toSorted((a, b) => a - b),
+          50,
+        ) / 1000
+      : null;
+  return {
+    sampleCount: samples.length,
+    gpuCount: byGpu.size,
+    startedAtMs,
+    endedAtMs,
+    sampleIntervalS,
+  };
+}
diff --git a/packages/db/src/etl/gpu-metrics-ingest.test.ts b/packages/db/src/etl/gpu-metrics-ingest.test.ts
new file mode 100644
index 000000000..92d1506ba
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-ingest.test.ts
@@ -0,0 +1,416 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  ingestGpuMetricsArtifact,
+  prepareGpuMetricsArtifact,
+  refreshGpuMetricStats,
+} from './gpu-metrics-ingest';
+
+import { findOutdatedGpuMetricSeries } from '../lib/gpu-metrics-backfill';
+import { GPU_STATS_VERSION } from '../lib/gpu-metric-stats';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+let sql: Sql;
+const roots: string[] = [];
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, {
+    json: JSON.stringify,
+    array: (value: unknown) => value,
+  });
+}
+
+async function storedSeries(seriesId: number) {
+  return {
+    metadata: await sql`select * from gpu_metric_series where id = ${seriesId}`,
+    samples: await sql`select * from gpu_metric_samples where series_id = ${seriesId}
+      order by sampled_at, gpu_index`,
+    stats: await sql`select * from gpu_metric_gpu_stats where series_id = ${seriesId}
+      order by gpu_index, metric`,
+    links: await sql`select * from benchmark_result_gpu_metrics where series_id = ${seriesId}
+      order by benchmark_result_id`,
+  };
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  sql = Object.assign(queryClient(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(queryClient(tx) as unknown as Sql)),
+  }) as unknown as Sql;
+}, 20_000);
+
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+    VALUES (1, 34557177019, 1, 'Run Sweep', 'completed', 'success', '2026-09-11', '2026-09-11');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 4, 4, 4, 4);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+           (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}');`);
+});
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+afterAll(async () => {
+  await db?.close();
+});
+
+const NVIDIA_CSV = [
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+  '2026/09/11 04:19:41.982, 0, 187.80 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:41.986, 1, 190.96 W, 39, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:42.990, 0, 912.10 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+  // Duplicate flush of the last sample, as emitted when the monitor stops.
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+].join('\n');
+
+function writeArtifact(csv: string, contextZone = 'UTC') {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-ingest-'));
+  roots.push(root);
+  const artifactName = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+  const artifactDir = path.join(root, artifactName);
+  fs.mkdirSync(artifactDir);
+  fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_context.json'),
+    JSON.stringify({ timestamp_timezone: contextZone }),
+  );
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_identity.csv'),
+    'index, uuid, name\n0, GPU-a, NVIDIA B200\n1, GPU-b, NVIDIA B200\n',
+  );
+  return { artifactName, artifactDir };
+}
+
+// Multinode bundle: two hosts × two GPUs × two scrapes, host-local indices.
+const MULTINODE_POWER_CSV = [
+  'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+  '1,1789194365.292,4,host-b,0,GPU-b0,401.5',
+  '1,1789194365.292,4,host-a,0,GPU-a0,186.656',
+  '1,1789194365.292,4,host-a,1,GPU-a1,190.1',
+  '1,1789194366.292,5,host-a,0,GPU-a0,700.25',
+  '1,1789194366.292,5,host-a,1,GPU-a1,702.0',
+  '1,1789194366.292,5,host-b,0,GPU-b0,650.0',
+  '1,1789194366.292,5,host-b,1,GPU-b1,655.0',
+  '1,1789194366.292,5,host-a,0,GPU-a0,999.0',
+].join('\n');
+const MULTINODE_MANIFEST = {
+  schema_version: 1,
+  producer: 'srt-slurm.dcgm-power',
+  source_metric: 'DCGM_FI_DEV_POWER_USAGE',
+  sample_interval_seconds: 1,
+};
+
+function writePowerAuditArtifact() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-ingest-'));
+  roots.push(root);
+  const artifactName = 'power_audit_kimik3_conc8_fp4_dynamo-vllm_b200-slurm_0';
+  const artifactDir = path.join(root, artifactName);
+  fs.mkdirSync(path.join(artifactDir, 'LOGS', 'power'), { recursive: true });
+  fs.writeFileSync(path.join(artifactDir, 'LOGS', 'power', 'samples.csv'), MULTINODE_POWER_CSV);
+  fs.writeFileSync(
+    path.join(artifactDir, 'LOGS', 'power', 'manifest.json'),
+    JSON.stringify(MULTINODE_MANIFEST),
+  );
+  fs.writeFileSync(path.join(artifactDir, 'agg_kimik3_conc8.json'), '{}');
+  return { artifactName, artifactDir };
+}
+
+describe('prepareGpuMetricsArtifact', () => {
+  it('falls back to the multinode power bundle, one power-only series per host', () => {
+    const prepared = prepareGpuMetricsArtifact(writePowerAuditArtifact());
+    expect(prepared.map((series) => series.fileName)).toEqual([
+      'LOGS/power/samples.csv#host-a',
+      'LOGS/power/samples.csv#host-b',
+    ]);
+    const [hostA, hostB] = prepared;
+    expect(hostA!.vendor).toBe('nvidia');
+    expect(hostA!.gpuCount).toBe(2);
+    expect(hostA!.samples).toHaveLength(4);
+    expect(hostA!.startedAtMs).toBe(1789194365292);
+    expect(hostA!.endedAtMs).toBe(1789194366292);
+    expect(hostA!.sampleIntervalS).toBe(1);
+    // One deployment-wide CSV: both host series share its hash.
+    expect(hostB!.csvSha256).toBe(hostA!.csvSha256);
+    // Only power was scraped; no zero-filled clock/temperature/utilization digests.
+    expect(new Set(hostA!.stats.map((s) => s.metric))).toEqual(new Set(['powerW']));
+    expect(hostA!.stats.find((s) => s.gpuIndex === 1)?.max).toBe(702);
+    expect(hostA!.sidecars.context).toEqual(MULTINODE_MANIFEST);
+    expect(hostA!.sidecars.identity).toEqual([
+      { hostname: 'host-a', gpu_index: 0, gpu_uuid: 'GPU-a0' },
+      { hostname: 'host-a', gpu_index: 1, gpu_uuid: 'GPU-a1' },
+    ]);
+    expect(hostA!.sidecars.energyStart).toBeNull();
+  });
+});
+
+describe('ingestGpuMetricsArtifact', () => {
+  it('refuses a partial artifact when a discovered host CSV has only a header', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const missingHostFile = path.join(artifact.artifactDir, 'host-b', 'gpu_metrics.csv');
+    fs.mkdirSync(path.dirname(missingHostFile));
+    fs.writeFileSync(missingHostFile, NVIDIA_CSV.split('\n')[0]!);
+    await expect(
+      ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact,
+        benchmarkResultIds: [10],
+      }),
+    ).rejects.toThrow('host-b/gpu_metrics.csv');
+    const before = await sql`select count(*)::int as n from gpu_metric_series`;
+    expect(before).toEqual([{ n: 0 }]);
+    fs.writeFileSync(missingHostFile, NVIDIA_CSV);
+    const recovered = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(recovered.seriesIds).toHaveLength(2);
+    expect(recovered.samplesInserted).toBe(8);
+    const replay = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(replay.samplesInserted).toBe(0);
+  });
+
+  it('stores series, samples, digest, and point links; reruns are no-ops', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 10],
+    });
+    expect(first.seriesIds).toHaveLength(1);
+    expect(first.samplesInserted).toBe(4);
+    expect(first.seriesSkipped).toBe(0);
+
+    const [series] = await sql<
+      {
+        artifact_name: string;
+        config_key: string;
+        vendor: string;
+        sample_count: number;
+        gpu_count: number;
+        started_at: Date;
+        ended_at: Date;
+        sample_interval_s: number | null;
+      }[]
+    >`select artifact_name, config_key, vendor, sample_count, gpu_count, started_at, ended_at,
+        sample_interval_s from gpu_metric_series`;
+    expect(series!.artifact_name).toBe(artifact.artifactName);
+    expect(series!.config_key).toBe('dsr1_8k1k_fp4_sglang_conc32_b200-x_0');
+    expect(series!.vendor).toBe('nvidia');
+    expect(series!.sample_count).toBe(4);
+    expect(series!.gpu_count).toBe(2);
+    expect(new Date(series!.started_at).toISOString()).toBe('2026-09-11T04:19:41.982Z');
+    expect(new Date(series!.ended_at).toISOString()).toBe('2026-09-11T04:19:42.994Z');
+    expect(series!.sample_interval_s).toBeCloseTo(1.008, 3);
+
+    const samples = await sql<{ gpu_index: number; power_w: number; sampled_at: Date }[]>`
+      select gpu_index, power_w, sampled_at from gpu_metric_samples order by sampled_at, gpu_index`;
+    expect(samples.map((s) => [s.gpu_index, s.power_w])).toEqual([
+      [0, 187.8],
+      [1, 190.96],
+      [0, 912.1],
+      [1, 905.3],
+    ]);
+
+    const stats = await sql<
+      { gpu_index: number; metric: string; sample_count: number; max_value: number }[]
+    >`
+      select gpu_index, metric, sample_count, max_value from gpu_metric_gpu_stats
+      where metric = 'power_w' order by gpu_index`;
+    expect(stats).toEqual([
+      { gpu_index: 0, metric: 'power_w', sample_count: 2, max_value: 912.1 },
+      { gpu_index: 1, metric: 'power_w', sample_count: 2, max_value: 905.3 },
+    ]);
+
+    const links = await sql<{ benchmark_result_id: number }[]>`
+      select benchmark_result_id from benchmark_result_gpu_metrics order by 1`;
+    expect(links.map((l) => Number(l.benchmark_result_id))).toEqual([10]);
+
+    const rerun = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 11],
+    });
+    expect(rerun.seriesIds).toEqual(first.seriesIds);
+    expect(rerun.samplesInserted).toBe(0);
+    expect(rerun.seriesSkipped).toBe(1);
+    const relinked = await sql<{ benchmark_result_id: number }[]>`
+      select benchmark_result_id from benchmark_result_gpu_metrics order by 1`;
+    expect(relinked.map((l) => Number(l.benchmark_result_id))).toEqual([10, 11]);
+    const [count] = await sql<{ n: number }[]>`select count(*)::int as n from gpu_metric_samples`;
+    expect(count!.n).toBe(4);
+  });
+
+  it('rolls back a replacement when point linking fails and retries without losing existing links', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    const seriesId = first.seriesIds[0]!;
+    const before = await storedSeries(seriesId);
+    fs.writeFileSync(
+      path.join(artifact.artifactDir, 'gpu_metrics.csv'),
+      `${NVIDIA_CSV}\n2026/09/11 04:19:43.990, 0, 950.00 W, 65, 1965 MHz, 3996 MHz, 99 %, 75 %`,
+    );
+    fs.writeFileSync(
+      path.join(artifact.artifactDir, 'gpu_metrics_context.json'),
+      JSON.stringify({ timestamp_timezone: '+02:00' }),
+    );
+
+    // Point links are written last, after replacement metadata, samples and stats.
+    await expect(
+      ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact,
+        benchmarkResultIds: [11, 999],
+      }),
+    ).rejects.toMatchObject({ code: '23503' });
+    expect(await storedSeries(seriesId)).toEqual(before);
+
+    const recovered = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [11],
+    });
+    expect(recovered).toEqual({
+      metadataUpdatedBenchmarkResultIds: [],
+      seriesIds: [seriesId],
+      samplesInserted: 5,
+      seriesSkipped: 0,
+    });
+    const after = await storedSeries(seriesId);
+    expect(after.metadata).toMatchObject([
+      { sample_count: 5, sidecars: { context: { timestamp_timezone: '+02:00' } } },
+    ]);
+    expect(after.metadata[0]!.csv_sha256).not.toBe(before.metadata[0]!.csv_sha256);
+    expect(after.samples).toHaveLength(5);
+    expect(new Date(after.samples[0]!.sampled_at).toISOString()).toBe('2026-09-11T02:19:41.982Z');
+    expect(
+      after.stats.find((row) => row.gpu_index === 0 && row.metric === 'power_w'),
+    ).toMatchObject({
+      sample_count: 3,
+      max_value: 950,
+    });
+    expect(after.links.map((row) => Number(row.benchmark_result_id))).toEqual([10, 11]);
+  });
+});
+
+describe('versioned full-record digests', () => {
+  it('upgrades unchanged input without rewriting samples or links, then becomes a no-op', async () => {
+    const input = {
+      workflowRunId: 1,
+      artifact: writeArtifact(NVIDIA_CSV),
+      benchmarkResultIds: [10, 11],
+    };
+    const first = await ingestGpuMetricsArtifact(sql, input);
+    const id = first.seriesIds[0]!;
+    const original = await storedSeries(id);
+    await sql`update gpu_metric_series set stats_version = 0 where id = ${id}`;
+    await sql`update gpu_metric_gpu_stats set mean_value = -1 where series_id = ${id}`;
+    const updated = await ingestGpuMetricsArtifact(sql, input);
+    expect(updated).toMatchObject({ samplesInserted: 0, seriesSkipped: 0 });
+    expect(await storedSeries(id)).toEqual(original);
+    expect(await ingestGpuMetricsArtifact(sql, input)).toMatchObject({
+      samplesInserted: 0,
+      seriesSkipped: 1,
+    });
+  });
+
+  it('backfills both retained hosts without artifacts; preserves null metrics, links and unrelated series', async () => {
+    const artifact = writePowerAuditArtifact();
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 11],
+    });
+    const unrelated = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NVIDIA_CSV),
+      benchmarkResultIds: [10],
+    });
+    const untouched = await storedSeries(unrelated.seriesIds[0]!);
+    const originals = await Promise.all(first.seriesIds.map(storedSeries));
+    await sql`update gpu_metric_series set stats_version = 0 where id = any(${sql.array(first.seriesIds)}::bigint[])`;
+    await sql`update gpu_metric_gpu_stats set mean_value = -1 where series_id = any(${sql.array(first.seriesIds)}::bigint[])`;
+    fs.rmSync(artifact.artifactDir, { recursive: true });
+    // No default retention cutoff: old runs remain repairable.
+    await sql`update workflow_runs set date = '2020-01-01' where id = 1`;
+    const targets = await findOutdatedGpuMetricSeries(
+      sql,
+      { run: null, attempt: null, artifact: null, fromRun: null, since: null },
+      null,
+    );
+    expect(targets.map((row) => Number(row.id))).toEqual(first.seriesIds);
+    expect(
+      await findOutdatedGpuMetricSeries(
+        sql,
+        { run: 34557177019, attempt: 2, artifact: null, fromRun: null, since: null },
+        null,
+      ),
+    ).toEqual([]);
+    for (const [index, id] of first.seriesIds.entries()) {
+      expect(await refreshGpuMetricStats(sql, id)).toBe(true);
+      expect(await storedSeries(id)).toEqual(originals[index]);
+      expect(await refreshGpuMetricStats(sql, id)).toBe(false);
+    }
+    expect(await storedSeries(unrelated.seriesIds[0]!)).toEqual(untouched);
+  });
+
+  it('rolls back a failed digest replacement and permits retry; refuses incomplete samples', async () => {
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NVIDIA_CSV),
+      benchmarkResultIds: [10],
+    });
+    const id = first.seriesIds[0]!;
+    await sql`update gpu_metric_series set stats_version = 0 where id = ${id}`;
+    await sql`update gpu_metric_gpu_stats set mean_value = -1 where series_id = ${id}`;
+    const before = await storedSeries(id);
+    await db.exec(
+      'ALTER TABLE gpu_metric_gpu_stats ADD CONSTRAINT reject_stats CHECK (mean_value < 0)',
+    );
+    await expect(refreshGpuMetricStats(sql, id)).rejects.toMatchObject({ code: '23514' });
+    expect(await storedSeries(id)).toEqual(before);
+    await db.exec('ALTER TABLE gpu_metric_gpu_stats DROP CONSTRAINT reject_stats');
+    expect(await refreshGpuMetricStats(sql, id)).toBe(true);
+    const recovered = await storedSeries(id);
+    expect(recovered.metadata[0]?.stats_version).toBe(GPU_STATS_VERSION);
+    await sql`update gpu_metric_series set stats_version = 0 where id = ${id}`;
+    await sql`delete from gpu_metric_samples where series_id = ${id} and gpu_index = 0`;
+    const incomplete = await storedSeries(id);
+    await expect(refreshGpuMetricStats(sql, id)).rejects.toThrow('missing samples');
+    expect(await storedSeries(id)).toEqual(incomplete);
+  });
+});
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
new file mode 100644
index 000000000..a00fe9872
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -0,0 +1,451 @@
+/**
+ * Persist one gpu_metrics artifact: series metadata, full-resolution samples,
+ * the per-GPU statistics digest, and links to the benchmark points it covers.
+ *
+ * Idempotency: a series is identified by (workflow run, artifact name, CSV
+ * path). Re-ingesting an identical CSV, sidecars and sample count only refreshes
+ * the point links when the statistics version is current; a source change
+ * replaces samples and digest atomically.
+ */
+
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+
+import type postgres from 'postgres';
+
+import {
+  GPU_STATS_VERSION,
+  statMetricColumn,
+  computeStoredGpuMetricStats,
+  type StoredGpuMetricSample,
+} from '../lib/gpu-metric-stats.js';
+
+export { statMetricColumn } from '../lib/gpu-metric-stats.js';
+
+import type { Sql } from './db-utils.js';
+
+/** Either a pooled client or the transaction handle passed to `sql.begin` callbacks. */
+type TxLike = Sql | postgres.TransactionSql;
+import {
+  computeGpuMetricStats,
+  parseGpuMetricsCsv,
+  summarizeGpuMetricSamples,
+  type GpuMetricSample,
+  type GpuMetricStats,
+  type GpuMetricsVendor,
+} from './gpu-metrics-csv.js';
+import {
+  contextUtcOffsetMinutes,
+  gpuMetricsArtifactSuffix,
+  listGpuMetricsCsvFiles,
+  listMultinodePowerSampleFiles,
+  readGpuMetricsSidecars,
+  readMultinodePowerManifest,
+  readPowerAuditValidations,
+  type GpuMetricsArtifact,
+  type GpuMetricsSidecars,
+} from './gpu-metrics-artifacts.js';
+import { multinodePowerVendor, parseMultinodePowerSamples } from './multinode-power-samples.js';
+import { recoveredPowerAudit } from './power-audit-validations.js';
+
+/** Samples are streamed to Postgres in unnest batches of this many rows. */
+const SAMPLE_BATCH_SIZE = 5000;
+
+function uniqueSamples(samples: readonly GpuMetricSample[]): GpuMetricSample[] {
+  const seen = new Set<string>();
+  return samples.filter((sample) => {
+    const key = `${sample.gpuIndex}:${sample.timestampMs}`;
+    if (seen.has(key)) return false;
+    // Keep the first row, matching INSERT ... ON CONFLICT DO NOTHING.
+    seen.add(key);
+    return true;
+  });
+}
+
+export interface PreparedGpuMetricSeries {
+  fileName: string;
+  vendor: GpuMetricsVendor;
+  csvSha256: string;
+  samples: GpuMetricSample[];
+  stats: GpuMetricStats[];
+  sampleIntervalS: number | null;
+  gpuCount: number;
+  startedAtMs: number;
+  endedAtMs: number;
+  sidecars: GpuMetricsSidecars;
+}
+
+export interface GpuMetricsIngestResult {
+  seriesIds: number[];
+  samplesInserted: number;
+  seriesSkipped: number;
+  metadataUpdatedBenchmarkResultIds: number[];
+}
+
+/**
+ * One series per host from the multinode power bundle. The deployment-wide
+ * CSV is hashed once, so every host series of one upload shares its source sha.
+ * The `#<hostname>` fragment keeps the
+ * (run, artifact, file) identity unique per host.
+ */
+function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
+  const prepared: PreparedGpuMetricSeries[] = [];
+  const validations = readPowerAuditValidations(artifact.artifactDir, artifact.artifactName);
+  for (const file of listMultinodePowerSampleFiles(artifact.artifactDir)) {
+    const csvText = fs.readFileSync(file.path, 'utf8');
+    const hosts = parseMultinodePowerSamples(csvText);
+    if (!hosts) continue;
+    const manifest = readMultinodePowerManifest(file.path);
+    const vendor = multinodePowerVendor(manifest);
+    const csvSha256 = createHash('sha256').update(csvText).digest('hex');
+    for (const host of hosts) {
+      const samples = uniqueSamples(host.samples);
+      const summary = summarizeGpuMetricSamples(samples);
+      if (!summary) continue;
+      prepared.push({
+        fileName: `${file.fileName}#${host.hostname}`,
+        vendor,
+        csvSha256,
+        samples,
+        stats: computeGpuMetricStats(samples),
+        sampleIntervalS: summary.sampleIntervalS,
+        gpuCount: summary.gpuCount,
+        startedAtMs: summary.startedAtMs,
+        endedAtMs: summary.endedAtMs,
+        sidecars: {
+          context: manifest,
+          validations,
+          identity: Object.entries(host.gpuUuids).map(([index, uuid]) => ({
+            hostname: host.hostname,
+            gpu_index: Number(index),
+            gpu_uuid: uuid,
+          })),
+          energyStart: null,
+          energyEnd: null,
+        },
+      });
+    }
+  }
+  return prepared;
+}
+
+/**
+ * Parse every CSV in an extracted artifact; refuse a partly readable CSV set.
+ * Without usable nvidia-smi/amd-smi CSVs, fall back to the multinode power bundle.
+ */
+export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
+  const prepared: PreparedGpuMetricSeries[] = [];
+  const unreadable: string[] = [];
+  for (const file of listGpuMetricsCsvFiles(artifact.artifactDir)) {
+    const csvText = fs.readFileSync(file.path, 'utf8');
+    const sidecars = readGpuMetricsSidecars(file.path);
+    if (artifact.artifactName.startsWith('power_audit_')) {
+      sidecars.validations = readPowerAuditValidations(artifact.artifactDir, artifact.artifactName);
+      const bundleFile = listMultinodePowerSampleFiles(artifact.artifactDir)[0];
+      sidecars.powerManifest = bundleFile ? readMultinodePowerManifest(bundleFile.path) : null;
+    }
+    const parsed = parseGpuMetricsCsv(csvText, {
+      nvidiaUtcOffsetMinutes: contextUtcOffsetMinutes(sidecars.context),
+    });
+    if (!parsed) {
+      unreadable.push(file.fileName);
+      continue;
+    }
+    const samples = uniqueSamples(parsed.samples);
+    const summary = summarizeGpuMetricSamples(samples);
+    if (!summary) {
+      unreadable.push(file.fileName);
+      continue;
+    }
+    prepared.push({
+      fileName: file.fileName,
+      vendor: parsed.vendor,
+      csvSha256: createHash('sha256').update(csvText).digest('hex'),
+      samples,
+      stats: computeGpuMetricStats(samples),
+      sampleIntervalS: summary.sampleIntervalS,
+      gpuCount: summary.gpuCount,
+      startedAtMs: summary.startedAtMs,
+      endedAtMs: summary.endedAtMs,
+      sidecars,
+    });
+  }
+  if (prepared.length > 0 && unreadable.length > 0) {
+    throw new Error(
+      `Incomplete telemetry artifact ${artifact.artifactName}: unreadable CSVs ${unreadable.join(', ')}`,
+    );
+  }
+  const series = prepared.length > 0 ? prepared : prepareMultinodePowerSeries(artifact);
+  const seriesInventory = series.map((entry) => ({
+    fileName: entry.fileName,
+    sampleCount: entry.samples.length,
+  }));
+  for (const entry of series) entry.sidecars.seriesInventory = seriesInventory;
+  return series;
+}
+
+async function insertSampleBatch(
+  tx: TxLike,
+  seriesId: number,
+  batch: readonly GpuMetricSample[],
+): Promise<number> {
+  const inserted = await tx<{ n: number }[]>`
+    with ins as (
+      insert into gpu_metric_samples (
+        series_id, gpu_index, sampled_at,
+        power_w, temperature_c, sm_clock_mhz, mem_clock_mhz, gpu_util_pct, mem_util_pct,
+        edge_temp_c, mem_temp_c, gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv,
+        fclk_mhz, socclk_mhz, mm_activity_pct
+      )
+      select
+        ${seriesId},
+        unnest(${tx.array(batch.map((s) => s.gpuIndex))}::smallint[]),
+        to_timestamp(unnest(${tx.array(batch.map((s) => s.timestampMs / 1000))}::double precision[])),
+        unnest(${tx.array(batch.map((s) => s.powerW))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.temperatureC))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.smClockMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memClockMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.gpuUtilPct))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memUtilPct))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.edgeTempC))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memTempC))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.gfxVoltageMv))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.socVoltageMv))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memVoltageMv))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.fclkMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.socclkMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.mmActivityPct))}::real[])
+      -- nvidia-smi occasionally repeats the final sample when the monitor is
+      -- stopped and flushed; the primary key makes that a no-op.
+      on conflict (series_id, gpu_index, sampled_at) do nothing
+      returning 1
+    )
+    select count(*)::int as n from ins
+  `;
+  return Number(inserted[0]?.n ?? 0);
+}
+
+async function insertStats(
+  tx: TxLike,
+  seriesId: number,
+  stats: readonly GpuMetricStats[],
+): Promise<void> {
+  if (stats.length === 0) return;
+  await tx`
+    insert into gpu_metric_gpu_stats (
+      series_id, gpu_index, metric, sample_count,
+      min_value, max_value, mean_value, median_value, p95_value, p99_value, stddev_value
+    )
+    select
+      ${seriesId},
+      unnest(${tx.array(stats.map((s) => s.gpuIndex))}::smallint[]),
+      unnest(${tx.array(stats.map((s) => statMetricColumn(s.metric)))}::text[]),
+      unnest(${tx.array(stats.map((s) => s.count))}::int[]),
+      unnest(${tx.array(stats.map((s) => s.min))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.max))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.mean))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.median))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.p95))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.p99))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.stddev))}::real[])
+  `;
+}
+
+/**
+ * Upsert one prepared series and link it to `benchmarkResultIds`. Returns the
+ * series id and how many sample rows were written (0 when the CSV, sidecars,
+ * and unique sample count are unchanged).
+ */
+export function upsertGpuMetricSeries(
+  sql: Sql,
+  input: {
+    workflowRunId: number;
+    artifactName: string;
+    series: PreparedGpuMetricSeries;
+    benchmarkResultIds: readonly number[];
+  },
+): Promise<{
+  seriesId: number;
+  samplesInserted: number;
+  replaced: boolean;
+  statsUpdated: boolean;
+}> {
+  const { workflowRunId, artifactName, series, benchmarkResultIds } = input;
+  const configKey = gpuMetricsArtifactSuffix(artifactName) ?? artifactName;
+  const sidecarsJson = JSON.stringify(series.sidecars);
+
+  return sql.begin(async (tx) => {
+    const existing = await tx<
+      {
+        id: number;
+        csv_sha256: string;
+        sample_count: number;
+        stats_version: number;
+        sidecars_match: boolean;
+      }[]
+    >`
+      select id, csv_sha256, sample_count, stats_version, sidecars = ${sidecarsJson}::jsonb as sidecars_match
+      from gpu_metric_series
+      where workflow_run_id = ${workflowRunId}
+        and artifact_name = ${artifactName}
+        and file_name = ${series.fileName}
+      for update
+    `;
+
+    let seriesId: number;
+    let needsSamples = true;
+    let replaced = false;
+    if (existing.length > 0) {
+      seriesId = Number(existing[0]!.id);
+      // Count also detects legacy digests computed before duplicate removal.
+      if (
+        existing[0]!.csv_sha256 === series.csvSha256 &&
+        existing[0]!.sidecars_match &&
+        existing[0]!.sample_count === series.samples.length
+      ) {
+        needsSamples = false;
+      } else {
+        replaced = true;
+        await tx`delete from gpu_metric_samples where series_id = ${seriesId}`;
+        await tx`delete from gpu_metric_gpu_stats where series_id = ${seriesId}`;
+        await tx`
+          update gpu_metric_series set
+            vendor = ${series.vendor},
+            csv_sha256 = ${series.csvSha256},
+            sample_interval_s = ${series.sampleIntervalS},
+            sample_count = ${series.samples.length},
+            gpu_count = ${series.gpuCount},
+            started_at = to_timestamp(${series.startedAtMs / 1000}::double precision),
+            ended_at = to_timestamp(${series.endedAtMs / 1000}::double precision),
+            sidecars = ${sidecarsJson}::jsonb,
+            ingested_at = now()
+          where id = ${seriesId}
+        `;
+      }
+    } else {
+      const [row] = await tx<{ id: number }[]>`
+        insert into gpu_metric_series (
+          workflow_run_id, artifact_name, config_key, file_name, vendor, csv_sha256,
+          sample_interval_s, sample_count, gpu_count, started_at, ended_at, sidecars
+        ) values (
+          ${workflowRunId}, ${artifactName}, ${configKey}, ${series.fileName},
+          ${series.vendor}, ${series.csvSha256}, ${series.sampleIntervalS},
+          ${series.samples.length}, ${series.gpuCount},
+          to_timestamp(${series.startedAtMs / 1000}::double precision),
+          to_timestamp(${series.endedAtMs / 1000}::double precision),
+          ${sidecarsJson}::jsonb
+        )
+        returning id
+      `;
+      seriesId = Number(row!.id);
+    }
+
+    let samplesInserted = 0;
+    if (needsSamples) {
+      for (let offset = 0; offset < series.samples.length; offset += SAMPLE_BATCH_SIZE) {
+        samplesInserted += await insertSampleBatch(
+          tx,
+          seriesId,
+          series.samples.slice(offset, offset + SAMPLE_BATCH_SIZE),
+        );
+      }
+    }
+    const statsUpdated = needsSamples || existing[0]?.stats_version !== GPU_STATS_VERSION;
+    if (statsUpdated) {
+      if (!needsSamples) await tx`delete from gpu_metric_gpu_stats where series_id = ${seriesId}`;
+      await insertStats(tx, seriesId, series.stats);
+      await tx`update gpu_metric_series set stats_version = ${GPU_STATS_VERSION} where id = ${seriesId}`;
+    }
+
+    if (benchmarkResultIds.length > 0) {
+      await tx`
+        insert into benchmark_result_gpu_metrics (benchmark_result_id, series_id)
+        select unnest(${tx.array([...new Set(benchmarkResultIds)])}::bigint[]), ${seriesId}
+        on conflict do nothing
+      `;
+    }
+
+    return { seriesId, samplesInserted, replaced, statsUpdated };
+  });
+}
+
+export function refreshGpuMetricStats(sql: Sql, seriesId: number): Promise<boolean> {
+  return sql.begin(async (tx) => {
+    const [series] = await tx<{ sample_count: number; stats_version: number }[]>`
+      select sample_count, stats_version from gpu_metric_series where id = ${seriesId} for update
+    `;
+    if (!series) throw new Error(`Unknown telemetry series ${seriesId}`);
+    if (series.stats_version === GPU_STATS_VERSION) return false;
+    const samples = await tx<StoredGpuMetricSample[]>`
+      select * from gpu_metric_samples where series_id = ${seriesId} order by sampled_at, gpu_index
+    `;
+    if (samples.length !== Number(series.sample_count)) {
+      throw new Error(
+        `Telemetry series ${seriesId} has missing samples; re-ingest its source artifact`,
+      );
+    }
+    const stats = computeStoredGpuMetricStats(samples);
+    await tx`delete from gpu_metric_gpu_stats where series_id = ${seriesId}`;
+    await insertStats(tx, seriesId, stats);
+    await tx`update gpu_metric_series set stats_version = ${GPU_STATS_VERSION} where id = ${seriesId}`;
+    return true;
+  });
+}
+
+/** Read, digest, and persist every CSV of one artifact for one set of points. */
+export async function ingestGpuMetricsArtifact(
+  sql: Sql,
+  input: {
+    workflowRunId: number;
+    artifact: GpuMetricsArtifact;
+    benchmarkResultIds: readonly number[];
+  },
+): Promise<GpuMetricsIngestResult> {
+  const prepared = prepareGpuMetricsArtifact(input.artifact);
+  const result: GpuMetricsIngestResult = {
+    seriesIds: [],
+    samplesInserted: 0,
+    seriesSkipped: 0,
+    metadataUpdatedBenchmarkResultIds: [],
+  };
+  for (const series of prepared) {
+    const upserted = await upsertGpuMetricSeries(sql, {
+      workflowRunId: input.workflowRunId,
+      artifactName: input.artifact.artifactName,
+      series,
+      benchmarkResultIds: input.benchmarkResultIds,
+    });
+    result.seriesIds.push(upserted.seriesId);
+    result.samplesInserted += upserted.samplesInserted;
+    if (upserted.samplesInserted === 0 && !upserted.replaced && !upserted.statsUpdated)
+      result.seriesSkipped++;
+  }
+  // The caller has resolved this artifact's exact benchmark identities. Recover
+  // only a unique AgentX point within that explicit set, after every host is
+  // stored/linked. This also repairs metadata when all samples were a no-op.
+  const validations = prepared[0]?.sidecars.validations ?? {};
+  const audits = Object.entries(validations)
+    .map(([source, validation]) => ({
+      audit: recoveredPowerAudit(source, validation),
+      conc: (validation.selected_window as Record<string, unknown> | undefined)?.concurrency,
+    }))
+    .filter((entry) => entry.audit !== null);
+  for (const { audit, conc } of audits) {
+    if (typeof conc !== 'number' || !Number.isSafeInteger(conc) || conc <= 0) continue;
+    if (audits.filter((entry) => entry.conc === conc).length !== 1) continue;
+    const updated = await sql<{ id: number }[]>`
+      with candidates as (
+        select id from benchmark_results
+        where workflow_run_id = ${input.workflowRunId}
+          and id = any(${sql.array([...new Set(input.benchmarkResultIds)])}::bigint[])
+          and benchmark_type = 'agentic_traces' and conc = ${conc}
+      )
+      update benchmark_results set power_audit = ${sql.json(audit)}::jsonb
+      where id in (select id from candidates)
+        and (select count(*) from candidates) = 1 and power_audit is null
+      returning id
+    `;
+    result.metadataUpdatedBenchmarkResultIds.push(...updated.map((row) => Number(row.id)));
+  }
+  return result;
+}
diff --git a/packages/db/src/etl/ingest-summary.ts b/packages/db/src/etl/ingest-summary.ts
index 16806cc47..684d7a1f5 100644
--- a/packages/db/src/etl/ingest-summary.ts
+++ b/packages/db/src/etl/ingest-summary.ts
@@ -38,6 +38,7 @@ export function printIngestSummaryFooter(
     ['unmapped hw', skips.unmappedHw],
     ['bad/empty zip', skips.badZip],
     ['DB errors', skips.dbError],
+    ['telemetry errors (non-fatal)', skips.telemetryError],
   );
 
   const nonzeroSkipLines = skipLines.filter(([, count]) => count > 0);
diff --git a/packages/db/src/etl/multinode-power-samples.ts b/packages/db/src/etl/multinode-power-samples.ts
new file mode 100644
index 000000000..9c711c4de
--- /dev/null
+++ b/packages/db/src/etl/multinode-power-samples.ts
@@ -0,0 +1,114 @@
+/**
+ * Parser for the multinode power producer's `LOGS/power/samples.csv`.
+ *
+ * `benchmark-multinode-tmpl.yml` uploads no `gpu_metrics_` artifact; its
+ * telemetry travels inside `power_audit_<suffix>` as one CSV for the whole
+ * deployment, written by `srt-slurm.dcgm-power` (DCGM scraped on every host
+ * once per second):
+ *
+ *   schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w
+ *
+ * Only power is scraped, so every other `GpuMetricSample` field stays null and
+ * the digest carries `powerW` alone. Rows are regrouped per host so each host
+ * becomes its own series, the shape the reader already uses for multinode
+ * staging ("one CSV per node"). Pure module: no I/O.
+ */
+
+import { splitCsvLine, type GpuMetricSample, type GpuMetricsVendor } from './gpu-metrics-csv.js';
+
+export interface MultinodePowerHost {
+  hostname: string;
+  /** Host-local GPU indices, as DCGM reports them. */
+  samples: GpuMetricSample[];
+  /** gpu_index → gpu_uuid for the identity sidecar. */
+  gpuUuids: Record<number, string>;
+}
+
+const REQUIRED_COLUMNS = ['timestamp_unix', 'hostname', 'gpu_index', 'power_w'] as const;
+
+/** `samples.csv` under `LOGS/` is the producer's only time-series file. */
+export function isMultinodePowerSamplesPath(relativePath: string): boolean {
+  const posix = relativePath.split('\\').join('/');
+  return /^LOGS\/(?:[^/]+\/)*samples\.csv$/u.test(posix);
+}
+
+function powerOnlySample(timestampMs: number, gpuIndex: number, powerW: number): GpuMetricSample {
+  return {
+    timestampMs,
+    gpuIndex,
+    powerW,
+    temperatureC: null,
+    smClockMhz: null,
+    memClockMhz: null,
+    gpuUtilPct: null,
+    memUtilPct: null,
+    edgeTempC: null,
+    memTempC: null,
+    gfxVoltageMv: null,
+    socVoltageMv: null,
+    memVoltageMv: null,
+    fclkMhz: null,
+    socclkMhz: null,
+    mmActivityPct: null,
+  };
+}
+
+/**
+ * Group the deployment-wide CSV by host. Returns null when the header is not
+ * the multinode power schema; malformed rows are skipped. Hosts sort by name
+ * so series order is stable across re-ingests.
+ */
+export function parseMultinodePowerSamples(csvText: string): MultinodePowerHost[] | null {
+  const lines = csvText
+    .split('\n')
+    .map((line) => line.replace(/\r$/u, ''))
+    .filter((line) => line.trim().length > 0);
+  if (lines.length <= 1) return null;
+  const header = splitCsvLine(lines[0]!).map((cell) => cell.trim().toLowerCase());
+  const column = new Map(header.map((name, index) => [name, index] as const));
+  if (REQUIRED_COLUMNS.some((name) => !column.has(name))) return null;
+  const at = (cells: string[], name: string): string | undefined => cells[column.get(name)!];
+
+  const hosts = new Map<string, MultinodePowerHost>();
+  for (const line of lines.slice(1)) {
+    const cells = splitCsvLine(line).map((cell) => cell.trim());
+    const hostname = at(cells, 'hostname');
+    const seconds = Number.parseFloat(at(cells, 'timestamp_unix') ?? '');
+    const gpuIndex = Number.parseInt(at(cells, 'gpu_index') ?? '', 10);
+    const powerW = Number.parseFloat(at(cells, 'power_w') ?? '');
+    if (
+      !hostname ||
+      !Number.isFinite(seconds) ||
+      !Number.isSafeInteger(gpuIndex) ||
+      gpuIndex < 0 ||
+      !Number.isFinite(powerW)
+    ) {
+      continue;
+    }
+    let host = hosts.get(hostname);
+    if (!host) {
+      host = { hostname, samples: [], gpuUuids: {} };
+      hosts.set(hostname, host);
+    }
+    host.samples.push(powerOnlySample(Math.round(seconds * 1000), gpuIndex, powerW));
+    const uuid = at(cells, 'gpu_uuid');
+    if (uuid && !(gpuIndex in host.gpuUuids)) host.gpuUuids[gpuIndex] = uuid;
+  }
+  if (hosts.size === 0) return null;
+  return [...hosts.values()].toSorted((a, b) => a.hostname.localeCompare(b.hostname));
+}
+
+/**
+ * The producer manifest names its source metric; DCGM means NVIDIA. Anything
+ * naming AMD tooling maps to 'amd', and an absent manifest defaults to NVIDIA
+ * because only the DCGM producer writes this layout today.
+ */
+export function multinodePowerVendor(manifest: Record<string, unknown> | null): GpuMetricsVendor {
+  const source = [manifest?.source_metric, manifest?.producer]
+    .filter((value): value is string => typeof value === 'string')
+    .join(' ')
+    .toLowerCase();
+  // `amd-smi`, `rocm_smi`: the tool name may continue with `-` or `_`.
+  if (/\b(?:amd|rocm)/u.test(source)) return 'amd';
+  return 'nvidia';
+}
diff --git a/packages/db/src/etl/power-audit-recovery.test.ts b/packages/db/src/etl/power-audit-recovery.test.ts
new file mode 100644
index 000000000..f90d1a0ae
--- /dev/null
+++ b/packages/db/src/etl/power-audit-recovery.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+
+import type { BenchmarkPersistenceInput } from './benchmark-ingest.js';
+import { createBenchmarkPowerAuditRecovery } from './power-audit-recovery.js';
+
+const resultFile = 'kimik3_recipe-a_conc48.json';
+const source = `power_validation_${resultFile}`;
+const validation = {
+  power_valid: true,
+  validation_path: 'LOGS/agentic/conc_48/power_validation.json',
+  result_file: resultFile,
+  selected_window: {
+    concurrency: 48,
+    start_time_unix: 1000,
+    end_time_unix: 1100,
+    result_path: 'agentic/conc_48/agentic_power_concurrency_48.json',
+    window_file: 'windows/agentic_power_concurrency_48.json',
+  },
+};
+const evidence = { resultFile, validations: { [source]: validation } };
+const expectedAudit = { source, window_start_unix: 1000, window_end_unix: 1100 };
+
+function point(overrides: Partial<BenchmarkPersistenceInput> = {}): BenchmarkPersistenceInput {
+  return {
+    configId: 1,
+    benchmarkType: 'agentic_traces',
+    isl: null,
+    osl: null,
+    conc: 48,
+    offloadMode: 'on',
+    image: 'image',
+    recipeFingerprint: 'recipe-a',
+    metrics: { power_valid: 1, avg_power_w: 234.5, mean_ttft: 0.2 },
+    workers: [{ role: 'agg', worker_idx: 0, num_gpus: 8, avg_power_w: 234.5 }],
+    ...overrides,
+  };
+}
+
+describe('CI benchmark audit recovery', () => {
+  it('retains exact provenance with aggregate after sibling and preserves benchmark values', () => {
+    const recover = createBenchmarkPowerAuditRecovery();
+    const original = point();
+    let latest = original;
+    for (const isPaired of [true, false]) {
+      latest = recover(original, isPaired ? evidence : undefined);
+      expect(latest.metrics).toBe(original.metrics);
+      expect(latest.workers).toBe(original.workers);
+      expect({ ...latest, powerAudit: undefined }).toEqual({ ...original, powerAudit: undefined });
+    }
+    expect(latest.powerAudit).toEqual(expectedAudit);
+    expect(original.powerAudit).toBeUndefined();
+  });
+
+  it('does not reuse the same run/concurrency audit for a point with another offload mode', () => {
+    const recover = createBenchmarkPowerAuditRecovery();
+    recover(point(), evidence);
+    const other = point({ offloadMode: 'off' });
+    expect(recover(other)).toBe(other);
+    expect(other.powerAudit).toBeUndefined();
+  });
+});
diff --git a/packages/db/src/etl/power-audit-recovery.ts b/packages/db/src/etl/power-audit-recovery.ts
new file mode 100644
index 000000000..808be3ef7
--- /dev/null
+++ b/packages/db/src/etl/power-audit-recovery.ts
@@ -0,0 +1,42 @@
+import { benchmarkPointIngestKey, type BenchmarkPersistenceInput } from './benchmark-ingest.js';
+import type { PowerAudit } from './benchmark-mapper.js';
+import { recoveredPowerAudit } from './power-audit-validations.js';
+
+export interface BenchmarkPowerAuditEvidence {
+  resultFile: string;
+  validations: Record<string, Record<string, unknown>>;
+}
+
+/** One run's exact sibling evidence also applies to its later aggregate copies. */
+export function createBenchmarkPowerAuditRecovery() {
+  const recovered = new Map<string, PowerAudit>();
+  return <T extends BenchmarkPersistenceInput>(
+    row: T,
+    evidence?: BenchmarkPowerAuditEvidence,
+  ): T => {
+    if (row.benchmarkType !== 'agentic_traces' || row.powerAudit !== undefined) return row;
+    const key = benchmarkPointIngestKey(row);
+    if (evidence) {
+      const matches = Object.entries(evidence.validations).filter(([, validation]) => {
+        const window = validation.selected_window;
+        if (
+          validation.result_file !== evidence.resultFile ||
+          !window ||
+          typeof window !== 'object' ||
+          Array.isArray(window) ||
+          !('concurrency' in window) ||
+          window.concurrency !== row.conc
+        )
+          return false;
+        return true;
+      });
+      // Ambiguous/missing evidence must not establish new provenance.
+      if (matches.length !== 1) return row;
+      const audit = recoveredPowerAudit(...matches[0]);
+      if (!audit) return row;
+      recovered.set(key, audit);
+    }
+    const audit = recovered.get(key);
+    return audit ? { ...row, powerAudit: audit } : row;
+  };
+}
diff --git a/packages/db/src/etl/power-audit-validations.test.ts b/packages/db/src/etl/power-audit-validations.test.ts
new file mode 100644
index 000000000..426073200
--- /dev/null
+++ b/packages/db/src/etl/power-audit-validations.test.ts
@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+
+import { normalizePowerAuditValidations } from './power-audit-validations.js';
+
+const ARTIFACT = 'power_audit_kimik3_agentx_fp4';
+const RESULT = 'kimik3_agentx_fp4_conc48.json';
+const SOURCE = 'power_validation_kimik3_agentx_fp4_conc48.json';
+const VALIDATION = 'LOGS/agentic/conc_48/power_validation.json';
+const WINDOW = 'LOGS/power/windows/agentic_power_concurrency_48.json';
+const RESULT_PATH = 'agentic/conc_48/agentic_power_concurrency_48.json';
+const START = 1789940129.369988;
+const END = 1789943769.371839;
+
+function fixture() {
+  const selected: Record<string, unknown> = {
+    window_file: 'windows/agentic_power_concurrency_48.json',
+    result_path: RESULT_PATH,
+    benchmark_type: 'custom',
+    concurrency: 48,
+    start_time_unix: START,
+    end_time_unix: END,
+    duration: END - START,
+  };
+  const validation: Record<string, unknown> = {
+    power_valid: true,
+    selected_window: selected,
+    per_gpu_role: { 'host-a/GPU-a': 'prefill', 'host-b/GPU-b': 'decode' },
+    validation_errors: [],
+  };
+  const result: Record<string, unknown> = { conc: 48, power_valid: 1 };
+  const window: Record<string, unknown> = {
+    schema_version: 1,
+    concurrency: 48,
+    result_path: RESULT_PATH,
+    benchmark_start_time_unix: START,
+    benchmark_end_time_unix: END,
+    status: 'completed',
+  };
+  const files = () =>
+    new Map([
+      [VALIDATION, JSON.stringify(validation)],
+      [RESULT, JSON.stringify(result)],
+      [WINDOW, JSON.stringify(window)],
+    ]);
+  return { selected, validation, result, window, files };
+}
+
+describe('normalizePowerAuditValidations', () => {
+  it('aliases an exactly matched nested document without changing its window, roles or verdict', () => {
+    const input = fixture();
+    const files = input.files();
+    const retained = [...files];
+    expect(normalizePowerAuditValidations(ARTIFACT, files)).toEqual(
+      new Map([
+        [SOURCE, { ...input.validation, validation_path: VALIDATION, result_file: RESULT }],
+      ]),
+    );
+    expect([...files]).toEqual(retained);
+    expect(input.validation).not.toHaveProperty('validation_path');
+  });
+
+  it('rejects mismatched window.benchmark_start_time_unix', () => {
+    const input = fixture();
+    input.window.benchmark_start_time_unix = START + 1;
+    expect(normalizePowerAuditValidations(ARTIFACT, input.files()).size).toBe(0);
+  });
+});
diff --git a/packages/db/src/etl/power-audit-validations.ts b/packages/db/src/etl/power-audit-validations.ts
new file mode 100644
index 000000000..179c2abf1
--- /dev/null
+++ b/packages/db/src/etl/power-audit-validations.ts
@@ -0,0 +1,125 @@
+/** Pure normalization of legacy and retained AgentX power-audit documents. */
+const LEGACY_VALIDATION = /^power_validation_[^/]+\.json$/u;
+const AGENTX_VALIDATION = /^LOGS\/agentic\/conc_(?<concurrency>[1-9]\d*)\/power_validation\.json$/u;
+const AGENTX_WINDOW = /^LOGS\/power\/windows\/agentic_power_concurrency_[1-9]\d*\.json$/u;
+const RESULT_FILE = /^(?<stem>[^/]+)_conc(?<concurrency>[1-9]\d*)\.json$/u;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function parseObject(text: string | undefined): Record<string, unknown> | null {
+  if (text === undefined) return null;
+  try {
+    const value: unknown = JSON.parse(text);
+    return isRecord(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function hasWindowTimes(value: unknown): value is Record<string, unknown> & {
+  start_time_unix: number;
+  end_time_unix: number;
+} {
+  return (
+    isRecord(value) &&
+    typeof value.start_time_unix === 'number' &&
+    Number.isFinite(value.start_time_unix) &&
+    value.start_time_unix > 0 &&
+    typeof value.end_time_unix === 'number' &&
+    Number.isFinite(value.end_time_unix) &&
+    value.end_time_unix > value.start_time_unix
+  );
+}
+
+/** Only documents needed to identify a validation and its recorded result/window. */
+export function isPowerAuditValidationEntry(name: string): boolean {
+  return (
+    LEGACY_VALIDATION.test(name) ||
+    AGENTX_VALIDATION.test(name) ||
+    AGENTX_WINDOW.test(name) ||
+    RESULT_FILE.test(name)
+  );
+}
+
+/**
+ * Legacy top-level documents keep their names and contents. A nested AgentX
+ * document gains a canonical alias only when its result and retained window
+ * agree; path annotations retain the original document's provenance.
+ */
+export function normalizePowerAuditValidations(
+  artifactName: string,
+  files: ReadonlyMap<string, string>,
+): Map<string, Record<string, unknown>> {
+  const validations = new Map<string, Record<string, unknown>>();
+  for (const [name, text] of files) {
+    if (!LEGACY_VALIDATION.test(name)) continue;
+    const validation = parseObject(text);
+    if (validation) validations.set(name, validation);
+  }
+  const artifactStem = /^power_audit_(?<stem>[^/]+)$/u.exec(artifactName)?.groups?.stem;
+  if (!artifactStem) return validations;
+
+  for (const [validationPath, text] of files) {
+    const match = AGENTX_VALIDATION.exec(validationPath);
+    if (!match?.groups) continue;
+    const concurrency = Number(match.groups.concurrency);
+    if (!Number.isSafeInteger(concurrency)) continue;
+    const resultFile = `${artifactStem}_conc${concurrency}.json`;
+    const source = `power_validation_${resultFile.slice(0, -5)}.json`;
+    if (validations.has(source)) continue;
+    const validation = parseObject(text);
+    const result = parseObject(files.get(resultFile));
+    const selected = validation?.selected_window;
+    const resultPath = `agentic/conc_${concurrency}/agentic_power_concurrency_${concurrency}.json`;
+    const windowFile = `windows/agentic_power_concurrency_${concurrency}.json`;
+    const window = parseObject(files.get(`LOGS/power/${windowFile}`));
+    if (
+      !validation ||
+      result?.conc !== concurrency ||
+      !hasWindowTimes(selected) ||
+      selected.concurrency !== concurrency ||
+      selected.result_path !== resultPath ||
+      selected.window_file !== windowFile ||
+      window?.concurrency !== concurrency ||
+      window.result_path !== resultPath ||
+      window.benchmark_start_time_unix !== selected.start_time_unix ||
+      window.benchmark_end_time_unix !== selected.end_time_unix
+    )
+      continue;
+    validations.set(source, {
+      ...validation,
+      validation_path: validationPath,
+      result_file: resultFile,
+    });
+  }
+  return validations;
+}
+
+/** Recover source/window metadata only from a normalized nested validation. */
+export function recoveredPowerAudit(
+  source: string,
+  validation: Record<string, unknown>,
+): { source: string; window_start_unix: number; window_end_unix: number } | null {
+  const path = validation.validation_path;
+  const result = validation.result_file;
+  if (typeof path !== 'string' || typeof result !== 'string') return null;
+  const nested = AGENTX_VALIDATION.exec(path)?.groups;
+  const file = RESULT_FILE.exec(result)?.groups;
+  const selected = validation.selected_window;
+  if (
+    !nested ||
+    !file ||
+    nested.concurrency !== file.concurrency ||
+    source !== `power_validation_${result.slice(0, -5)}.json` ||
+    !hasWindowTimes(selected) ||
+    selected.concurrency !== Number(nested.concurrency)
+  )
+    return null;
+  return {
+    source,
+    window_start_unix: selected.start_time_unix,
+    window_end_unix: selected.end_time_unix,
+  };
+}
diff --git a/packages/db/src/etl/skip-tracker.test.ts b/packages/db/src/etl/skip-tracker.test.ts
index e407db3a3..1851b0417 100644
--- a/packages/db/src/etl/skip-tracker.test.ts
+++ b/packages/db/src/etl/skip-tracker.test.ts
@@ -9,6 +9,7 @@ describe('createSkipTracker', () => {
     expect(tracker.skips.unmappedHw).toBe(0);
     expect(tracker.skips.noIslOsl).toBe(0);
     expect(tracker.skips.dbError).toBe(0);
+    expect(tracker.skips.telemetryError).toBe(0);
     expect(tracker.skips.traceReplayMissing).toBe(0);
   });
 
diff --git a/packages/db/src/etl/skip-tracker.ts b/packages/db/src/etl/skip-tracker.ts
index 5d485bf22..055a92b46 100644
--- a/packages/db/src/etl/skip-tracker.ts
+++ b/packages/db/src/etl/skip-tracker.ts
@@ -10,6 +10,15 @@ export interface Skips {
   noIslOsl: number;
   failedRun: number;
   dbError: number;
+  /**
+   * PowerX telemetry digest failures, counted apart from `dbError` because they
+   * are not fatal. The benchmark rows land either way; only the per-point
+   * telemetry tab is affected, and the artifact can be re-digested later by
+   * `admin:db:backfill-gpu-metrics`. Folding these into `dbError` would let one
+   * malformed `gpu_metrics_*` CSV turn the whole production ingest red, through
+   * the publication manifest that verify-power-publication treats as fatal.
+   */
+  telemetryError: number;
   /** Agentic point whose sibling `agentic_<suffix>` artifact had no trace_replay files. */
   traceReplayMissing: number;
 }
@@ -35,6 +44,15 @@ export interface SkipTracker {
    * @param err - The caught error.
    */
   recordDbError: (context: string, err: Error) => void;
+  /**
+   * Record a non-fatal PowerX telemetry digest failure. Same printing and
+   * suppression as `recordDbError`, but increments `skips.telemetryError` so the
+   * ingest is not failed by it.
+   *
+   * @param context - Human-readable label for where the error occurred.
+   * @param err - The caught error.
+   */
+  recordTelemetryError: (context: string, err: Error) => void;
   /**
    * Capture a point-in-time snapshot of the current skip counters and
    * unmapped-name sets. Used together with `diff()` to report per-artifact drops.
@@ -76,12 +94,14 @@ export function createSkipTracker(): SkipTracker {
     noIslOsl: 0,
     failedRun: 0,
     dbError: 0,
+    telemetryError: 0,
     traceReplayMissing: 0,
   };
   const unmappedModels = new Set<string>();
   const unmappedHws = new Set<string>();
   const unmappedPrecisions = new Set<string>();
   let dbErrorsPrinted = 0;
+  let telemetryErrorsPrinted = 0;
 
   return {
     skips,
@@ -100,6 +120,19 @@ export function createSkipTracker(): SkipTracker {
       }
     },
 
+    recordTelemetryError(context: string, err: Error): void {
+      skips.telemetryError++;
+      if (telemetryErrorsPrinted < MAX_DB_ERRORS) {
+        console.error(`  [TELEMETRY] ${context}: ${err.message}`);
+        telemetryErrorsPrinted++;
+        if (telemetryErrorsPrinted === MAX_DB_ERRORS) {
+          console.error(
+            '  [TELEMETRY] further telemetry errors suppressed; count included in summary',
+          );
+        }
+      }
+    },
+
     snapshot(): SkipSnapshot {
       return {
         model: skips.unmappedModel,
diff --git a/packages/db/src/ingest-ci-run.test.ts b/packages/db/src/ingest-ci-run.test.ts
index d3ad330b4..520028343 100644
--- a/packages/db/src/ingest-ci-run.test.ts
+++ b/packages/db/src/ingest-ci-run.test.ts
@@ -5,6 +5,47 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { describe, expect, it } from 'vitest';
 
+describe('explicit download attempt identity', () => {
+  it('rejects a download whose GitHub attempt differs from the requested one', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'attempt-ingest-'));
+    const manifestPath = path.join(dir, 'power-publication.json');
+    try {
+      fs.writeFileSync(
+        path.join(dir, 'gh'),
+        '#!/bin/sh\ncase "$*" in\n*--paginate*) exit 0 ;;\n*--jq*) printf "2\\n" ;;\n*) exit 3 ;;\nesac\n',
+        { mode: 0o755 },
+      );
+      const result = spawnSync(
+        'bun',
+        [
+          fileURLToPath(new URL('ingest-ci-run.ts', import.meta.url)),
+          '--download',
+          'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/25199291771/attempts/1',
+        ],
+        {
+          cwd: dir,
+          env: {
+            PATH: `${dir}${path.delimiter}${process.env.PATH}`,
+            TMPDIR: dir,
+            NODE_ENV: 'test',
+            DATABASE_WRITE_URL: 'postgres://unused:unused@127.0.0.1:1/unused',
+            GITHUB_TOKEN: 'unused',
+            POWER_PUBLICATION_MANIFEST: manifestPath,
+          },
+          encoding: 'utf8',
+          timeout: 10_000,
+        },
+      );
+      expect(result.error).toBeUndefined();
+      expect(result.status, result.stderr).toBe(1);
+      expect(result.stderr).toContain('GitHub attempt 2 differs from requested 1');
+      expect(fs.existsSync(manifestPath)).toBe(false);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
 describe('purged CI ingestion', () => {
   it.each([
     { runId: 20286769842, runAttempt: 1, reused: false },
@@ -53,6 +94,7 @@ describe('purged CI ingestion', () => {
           runAttempt,
           points: [],
           ingestErrors: [],
+          telemetryWarnings: [],
         });
       } finally {
         fs.rmSync(dir, { recursive: true, force: true });
diff --git a/packages/db/src/ingest-ci-run.ts b/packages/db/src/ingest-ci-run.ts
index a27225bc9..351233bf9 100644
--- a/packages/db/src/ingest-ci-run.ts
+++ b/packages/db/src/ingest-ci-run.ts
@@ -27,6 +27,8 @@ import { createHash } from 'node:crypto';
 import {
   powerPublicationPoint,
   publicationIdentity,
+  benchmarkPublicationIdentity,
+  stablePowerPointIdentity,
   type PowerPublicationPoint,
 } from './etl/power-publication';
 import os from 'os';
@@ -60,6 +62,7 @@ import {
   readReusedIngestMetadata,
 } from './etl/reused-ingest-metadata';
 import { mapBenchmarkRow, type BenchmarkParams } from './etl/benchmark-mapper';
+import { preflightRequiredPowerCurves } from './etl/required-power-curve';
 import {
   assertRequiredPowerPointsRetained,
   verifyRequiredPowerArtifacts,
@@ -78,6 +81,13 @@ import {
 import { AsyncSemaphore } from './etl/async-semaphore';
 import { discoverTraceReplayArtifacts } from './etl/trace-artifact-discovery';
 import { discoverServerLogArtifacts, readServerLogArtifact } from './etl/server-log-artifacts';
+import {
+  discoverGpuMetricsArtifacts,
+  readPowerAuditValidations,
+} from './etl/gpu-metrics-artifacts';
+import { createBenchmarkPowerAuditRecovery } from './etl/power-audit-recovery';
+import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest';
+import { readTelemetryReceipt, type TelemetryObservation } from './etl/telemetry-receipt';
 import { datasetSlugFromBenchmarkRow } from './etl/dataset-provenance';
 import { mapAggEvalRow, mapEvalRow } from './etl/eval-mapper';
 import { ingestEvalRow } from './etl/eval-ingest';
@@ -96,6 +106,9 @@ import {
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 const powerPublicationPoints = new Map<string, PowerPublicationPoint>();
 const powerPublicationErrors: string[] = [];
+const telemetryObservations = new Map<string, TelemetryObservation>();
+let telemetryExpectationsUnknown = false;
+let checkTelemetry = false;
 const tracker = createSkipTracker();
 const isDownloadMode = process.argv[2] === '--download';
 
@@ -151,6 +164,15 @@ if (isDownloadMode) {
     input.match(/^https:\/\/github\.com\/(?<repo>[^/]+\/[^/]+)\/actions\/runs\/\d+/u)?.[1] ??
     DEFAULT_REPO;
 
+  runAttemptNum = fetchRunAttempt(REPO, runIdStr);
+  const requestedAttempt = input.match(/\/attempts\/(?<attempt>\d+)/u)?.groups?.attempt;
+  if (requestedAttempt && Number(requestedAttempt) !== runAttemptNum) {
+    throw new Error(
+      `GitHub attempt ${runAttemptNum} differs from requested ${requestedAttempt}; ` +
+        'use retained artifacts and exact source metadata for historical-attempt ingestion',
+    );
+  }
+
   // Download artifacts
   tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ingest-'));
   artifactsDir = tempDir;
@@ -194,8 +216,6 @@ if (isDownloadMode) {
   }
 
   console.log(`\n  Downloaded ${byLogical.size} artifact(s)`);
-
-  runAttemptNum = fetchRunAttempt(REPO, runIdStr);
 } else {
   // CI mode — read from env vars
   for (const key of [
@@ -286,6 +306,7 @@ async function main(): Promise<void> {
   }
 
   validateRunBackfills();
+  checkTelemetry = true;
   const configCache = createConfigCache(sql);
   const { getOrCreateConfig, preloadConfigs } = configCache;
   const { fetchGithubRun, getOrCreateWorkflowRun } = createWorkflowRunServices(sql, GITHUB_TOKEN, [
@@ -333,11 +354,15 @@ async function main(): Promise<void> {
     }
   }
 
-  const requiredPowerPoints = verifyRequiredPowerArtifacts(artifactsDir, {
-    runId,
-    runAttempt: runAttemptNum,
-    headSha: ghInfo?.headSha ?? null,
-  });
+  const requiredPowerPoints = verifyRequiredPowerArtifacts(
+    artifactsDir,
+    {
+      runId,
+      runAttempt: runAttemptNum,
+      headSha: ghInfo?.headSha ?? null,
+    },
+    process.env.INGEST_REQUIRE_POWER === 'true',
+  );
   if (requiredPowerPoints.length > 0)
     console.log(`  Required power: ${requiredPowerPoints.length} source benchmark points verified`);
 
@@ -409,6 +434,18 @@ async function main(): Promise<void> {
   if (evalsOnly && requiredPowerPoints.length > 0)
     throw new Error('Required power: benchmark scope cannot be published as an evals-only run');
 
+  if (requiredPowerPoints.length > 0)
+    await preflightRequiredPowerCurves(
+      sql,
+      artifactsDir,
+      {
+        runId,
+        runAttempt: runAttemptNum,
+        headSha: ghInfo?.headSha ?? null,
+      },
+      { date, runStartedAt: workflowGhInfo?.runStartedAt ?? null, appendOnly },
+    );
+
   const workflowRunId = await getOrCreateWorkflowRun({
     githubRunId: runId,
     runAttempt: runAttemptNum,
@@ -452,6 +489,8 @@ async function main(): Promise<void> {
   let totalSampleFiles = 0;
   let totalChangelogs = 0;
   let totalTraceReplayLinked = 0;
+  let totalGpuMetricSeries = 0;
+  let totalGpuMetricSamples = 0;
   const datasetSlugs = new Set<string>();
   // Dataset slugs referenced by this run's agentic rows but absent from the
   // `datasets` table — timeline→dataset deep links 404 until they're ingested.
@@ -484,6 +523,14 @@ async function main(): Promise<void> {
     if (serverLogArtifacts.size > 0) {
       console.log(`  Found ${serverLogArtifacts.size} server log artifact(s)`);
     }
+    // PowerX telemetry: `gpu_metrics_<key>` is uploaded next to `bmk_<key>` by
+    // every single-node job; multinode jobs carry it inside `power_audit_<key>`
+    // instead (see migration 016). Digested here so the dashboard never
+    // re-downloads GitHub artifacts and keeps the series past retention.
+    const gpuMetricsArtifacts = discoverGpuMetricsArtifacts(artifactsDir);
+    if (gpuMetricsArtifacts.size > 0) {
+      console.log(`  Found ${gpuMetricsArtifacts.size} telemetry artifact(s)`);
+    }
 
     // Sibling aiperf artifacts: each `bmk_agentic_<suffix>` is paired with an
     // `agentic_<suffix>` dir holding `profile_export.jsonl` and
@@ -508,6 +555,7 @@ async function main(): Promise<void> {
 
     const allBmkFiles = [...bmkFiles, ...allBmkDirs.flatMap((d) => findJsonFiles(d))];
     const seenPointIdentities = new Map<string, string>();
+    const recoverPowerAudit = createBenchmarkPowerAuditRecovery();
     console.log(`  Found ${allBmkFiles.length} benchmark JSON file(s)`);
 
     for (const [fileIndex, file] of allBmkFiles.entries()) {
@@ -519,6 +567,7 @@ async function main(): Promise<void> {
       );
       const data = readJson(file);
       if (!data) {
+        telemetryExpectationsUnknown = true;
         powerPublicationErrors.push(`Unreadable benchmark JSON: ${relativeFile}`);
         console.log(`    skipped unreadable JSON (${elapsed(fileStart)})`);
         continue;
@@ -535,16 +584,26 @@ async function main(): Promise<void> {
         if (datasetSlug) datasetSlugs.add(datasetSlug);
       }
 
+      let fileExpectationsUnknown = false;
       const rows = rawRows
-        .filter((r) => typeof r === 'object' && r !== null)
+        .filter((r) => {
+          const isRow = typeof r === 'object' && r !== null;
+          if (!isRow) fileExpectationsUnknown = true;
+          return isRow;
+        })
         .map((r) => {
+          const failedRuns = tracker.skips.failedRun;
           const mapped = mapBenchmarkRow(r, tracker, undefined, runIdStr);
+          // Known failed benchmarks are intentionally excluded; unmappable rows
+          // leave an unknown number of successful attachment expectations.
+          if (!mapped && tracker.skips.failedRun === failedRuns) fileExpectationsUnknown = true;
           if (!mapped && Number(r.isl) === 8192 && Number(r.osl) === 1024) {
             powerPublicationErrors.push(`Unmapped or failed 8K/1K result: ${relativeFile}`);
           }
           return mapped;
         })
         .filter((r): r is NonNullable<typeof r> => r !== null);
+      if (fileExpectationsUnknown) telemetryExpectationsUnknown = true;
 
       console.log(`    mapped rows: ${rows.length}`);
       if (rows.length === 0) {
@@ -553,11 +612,34 @@ async function main(): Promise<void> {
       }
 
       const toInsert = [];
+      const parentDir = path.basename(path.dirname(file));
+      const configKey = parentDir.replace(/^bmk_/u, '');
+      const suffix = stripBmkAndAgenticPrefix(parentDir);
+      const gpuMetricsArtifact =
+        gpuMetricsArtifacts.get(configKey) ?? gpuMetricsArtifacts.get(suffix);
+      let auditEvidence;
+      if (parentDir.startsWith('bmk_agentic_') && gpuMetricsArtifact) {
+        try {
+          auditEvidence = {
+            resultFile: path.basename(file),
+            validations: readPowerAuditValidations(
+              gpuMetricsArtifact.artifactDir,
+              gpuMetricsArtifact.artifactName,
+            ),
+          };
+        } catch (error) {
+          tracker.recordTelemetryError(
+            `power audit for ${configKey}`,
+            error instanceof Error ? error : new Error(String(error)),
+          );
+        }
+      }
       for (const row of rows) {
         let configId: number;
         try {
           configId = await getOrCreateConfig(row.config);
         } catch (error: any) {
+          telemetryExpectationsUnknown = true;
           tracker.recordDbError(`config for ${path.basename(file)}`, error);
           continue;
         }
@@ -594,14 +676,32 @@ async function main(): Promise<void> {
               `config ${configId}, conc ${row.conc}`,
           );
         }
+        // Attach exact retained validation metadata before both the receipt and
+        // the upsert. A later aggregate copy must not null this run's recovery.
+        const point = recoverPowerAudit(applied.point, auditEvidence);
         const publication = powerPublicationPoint(
-          applied.point,
+          point,
           `https://github.com/${REPO}/actions/runs/${runIdNum}/attempts/${runAttemptNum}`,
           { path: relativeFile, sha256: artifactSha256 },
         );
         if (publication)
           powerPublicationPoints.set(publicationIdentity(publication.identity), publication);
-        toInsert.push(applied.point);
+        toInsert.push(point);
+        const identity = benchmarkPublicationIdentity(point);
+        const key = stablePowerPointIdentity(identity);
+        // Aggregate copies may arrive before/after their per-job sibling. Only
+        // the latter establishes whether that exact telemetry artifact exists.
+        if (parentDir.startsWith('bmk_') || !telemetryObservations.has(key)) {
+          telemetryObservations.set(key, {
+            identity,
+            artifactNames: gpuMetricsArtifact
+              ? [gpuMetricsArtifact.artifactName]
+              : parentDir.startsWith('bmk_')
+                ? [`gpu_metrics_${suffix}`, `power_audit_${suffix}`]
+                : [],
+            produced: parentDir.startsWith('bmk_') ? Boolean(gpuMetricsArtifact) : null,
+          });
+        }
       }
       console.log(`    rows with resolved configs: ${toInsert.length}`);
 
@@ -637,14 +737,12 @@ async function main(): Promise<void> {
             });
           }
 
-          const parentDir = path.basename(path.dirname(file));
           if (parentDir.startsWith('bmk_') && insertedIds.length > 0) {
             // Single-turn artifacts are `bmk_<key>` paired with
             // `server_logs_<key>`. Agentic artifacts are `bmk_agentic_<key>`
             // but the server log is still `server_logs_<key>` (no `agentic_`
             // prefix), so fall back to the fully-stripped suffix — otherwise
             // agentic rows never get their server log (and KV-pool size) linked.
-            const configKey = parentDir.replace(/^bmk_/u, '');
             const logArtifact =
               serverLogArtifacts.get(configKey) ??
               serverLogArtifacts.get(stripBmkAndAgenticPrefix(parentDir));
@@ -665,13 +763,48 @@ async function main(): Promise<void> {
                 tracker.recordDbError(`server_logs for ${configKey}`, error);
               }
             }
+            // Same pairing rule as server logs: `gpu_metrics_<key>` carries no
+            // `agentic_` prefix, so agentic points fall back to the bare suffix.
+            if (gpuMetricsArtifact) {
+              try {
+                const gpuMetricsStart = Date.now();
+                const ingested = await ingestGpuMetricsArtifact(sql, {
+                  workflowRunId,
+                  artifact: gpuMetricsArtifact,
+                  benchmarkResultIds: insertedIds,
+                });
+                if (ingested.seriesIds.length === 0)
+                  throw new Error(
+                    `No parseable telemetry series in ${gpuMetricsArtifact.artifactName}`,
+                  );
+                totalGpuMetricSeries += ingested.seriesIds.length;
+                totalGpuMetricSamples += ingested.samplesInserted;
+                console.log(
+                  `    gpu_metrics ${ingested.seriesIds.length} series, ` +
+                    `+${ingested.samplesInserted} sample(s), ` +
+                    `${ingested.seriesSkipped} unchanged (${elapsed(gpuMetricsStart)})`,
+                );
+              } catch (error: any) {
+                // Non-fatal on purpose: this point's benchmark rows are already
+                // committed and only its telemetry tab is affected, and
+                // `admin:db:backfill-gpu-metrics --run <id>` can re-digest the
+                // artifact later. Recording it as a DB error instead would reach
+                // the publication manifest and fail the whole production ingest.
+                tracker.recordTelemetryError(`gpu_metrics for ${configKey}`, error);
+                for (const row of toInsert) {
+                  const point = telemetryObservations.get(
+                    stablePowerPointIdentity(benchmarkPublicationIdentity(row)),
+                  );
+                  if (point) point.error = error instanceof Error ? error.message : String(error);
+                }
+              }
+            }
           }
 
           // Trace-replay sibling lookup for agentic points only. The aiperf
           // harness emits `agentic_<suffix>/trace_replay/...` next to the
           // `bmk_agentic_<suffix>` artifact we just ingested.
           if (parentDir.startsWith('bmk_agentic_') && insertedIds.length > 0) {
-            const suffix = stripBmkAndAgenticPrefix(parentDir);
             const concMatch = path.basename(file).match(/_conc(?<conc>\d+)\.json$/u);
             const trace =
               (concMatch?.groups?.conc
@@ -1042,9 +1175,24 @@ main()
     console.error('ingest-ci-run failed:', error);
     process.exitCode = 1;
   })
-  .finally(() => {
-    const publicationPath = process.env.POWER_PUBLICATION_MANIFEST;
+  .finally(async () => {
+    const publicationPath =
+      process.env.POWER_PUBLICATION_MANIFEST ??
+      `power-publication-${runIdNum}-attempt-${runAttemptNum}.json`;
     if (publicationPath) {
+      const telemetry = checkTelemetry
+        ? await readTelemetryReceipt(
+            sql,
+            { runId: runIdNum, runAttempt: runAttemptNum },
+            [...telemetryObservations.values()],
+            {
+              expectedSource:
+                !telemetryExpectationsUnknown && telemetryObservations.size > 0
+                  ? 'benchmark_artifacts'
+                  : 'unknown',
+            },
+          )
+        : undefined;
       fs.writeFileSync(
         publicationPath,
         `${JSON.stringify(
@@ -1057,11 +1205,17 @@ main()
               ...powerPublicationErrors,
               ...(tracker.skips.dbError ? [`${tracker.skips.dbError} database ingest errors`] : []),
             ],
+            // Reported but not fatal — see Skips.telemetryError.
+            telemetryWarnings: tracker.skips.telemetryError
+              ? [`${tracker.skips.telemetryError} gpu_metrics digest errors`]
+              : [],
+            ...(telemetry ? { telemetry } : {}),
           },
           null,
           2,
         )}\n`,
       );
+      console.log(`  PowerX ingest receipt: ${publicationPath}`);
     }
     if (tempDir) {
       try {
diff --git a/packages/db/src/ingest-gcs-backup.ts b/packages/db/src/ingest-gcs-backup.ts
index 709fdc9c3..b9cb76b59 100644
--- a/packages/db/src/ingest-gcs-backup.ts
+++ b/packages/db/src/ingest-gcs-backup.ts
@@ -104,8 +104,12 @@ interface WorkflowMapResult {
   changelogs: { baseRef: string; headRef: string; entries: ChangelogEntry[] }[];
   /** True when the changelog declares evals-only — benchmark/stats data is dropped. */
   evalsOnly: boolean;
-  /** Skip counts from mapping phase (dbError is tracked separately in phase 2). */
-  localSkips: Omit<Skips, 'dbError'>;
+  /**
+   * Skip counts from the mapping phase. `dbError` is tracked separately in phase 2,
+   * and `telemetryError` never applies here: the GCS backup path ingests no
+   * `gpu_metrics_*` artifacts.
+   */
+  localSkips: Omit<Skips, 'dbError' | 'telemetryError'>;
   localUnmappedModels: Set<string>;
   localUnmappedHws: Set<string>;
   /** Pre-formatted [WARN] lines to print at the start of phase 2 for this dir. */
@@ -121,7 +125,7 @@ interface WriteResult {
   evalSamples: number;
   changelogs: number;
   warnings: string[];
-  localSkips: Omit<Skips, 'dbError'>;
+  localSkips: Omit<Skips, 'dbError' | 'telemetryError'>;
   localUnmappedModels: string[];
   localUnmappedHws: string[];
 }
diff --git a/packages/db/src/lib/artifact-retry.ts b/packages/db/src/lib/artifact-retry.ts
index e145aa04d..4044dc35b 100644
--- a/packages/db/src/lib/artifact-retry.ts
+++ b/packages/db/src/lib/artifact-retry.ts
@@ -1,5 +1,17 @@
 const DEFAULT_RETRY_DELAYS_MS = [5_000, 15_000, 30_000, 60_000, 120_000] as const;
 
+/**
+ * Marks a failure no retry can fix (the run or artifact is gone, not
+ * unreachable). `retryArtifactOperation` rethrows it immediately instead of
+ * burning the full backoff schedule on it.
+ */
+export class NonRetryableArtifactError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'NonRetryableArtifactError';
+  }
+}
+
 interface ArtifactRetryOptions {
   delaysMs?: readonly number[];
   wait?: (delayMs: number) => Promise<void>;
@@ -26,6 +38,7 @@ export async function retryArtifactOperation<T>(
     try {
       return await operation();
     } catch (error) {
+      if (error instanceof NonRetryableArtifactError) throw error;
       lastError = error;
       if (attempt >= delaysMs.length) break;
       const delayMs = delaysMs[attempt];
diff --git a/packages/db/src/lib/github-artifacts.test.ts b/packages/db/src/lib/github-artifacts.test.ts
index 571643a5e..e612d5c1b 100644
--- a/packages/db/src/lib/github-artifacts.test.ts
+++ b/packages/db/src/lib/github-artifacts.test.ts
@@ -1,5 +1,4 @@
 import { describe, expect, it } from 'vitest';
-
 import { RUNNER_SUFFIX_RE, dedupeArtifactsByLogicalName } from './github-artifacts.js';
 
 const art = (name: string, created_at: string) => ({
diff --git a/packages/db/src/lib/github-artifacts.ts b/packages/db/src/lib/github-artifacts.ts
index 67827855e..c95957755 100644
--- a/packages/db/src/lib/github-artifacts.ts
+++ b/packages/db/src/lib/github-artifacts.ts
@@ -8,6 +8,8 @@ import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { NonRetryableArtifactError } from './artifact-retry.js';
+
 export interface ArtifactMeta {
   id?: number;
   name: string;
@@ -32,12 +34,46 @@ export interface ArtifactMeta {
  */
 export const RUNNER_SUFFIX_RE = /_[a-zA-Z][a-zA-Z0-9.-]*_\d+$/u;
 
-/** List a workflow run's artifacts via `gh api` (paginated). Malformed lines are skipped. */
+/**
+ * GitHub no longer has the run (deleted, or purged past retention), so its
+ * artifact listing 404s. Distinct from expired artifacts, which still list
+ * with `expired: true`.
+ */
+export class WorkflowRunNotFoundError extends NonRetryableArtifactError {
+  readonly repo: string;
+  readonly runId: string;
+
+  constructor(repo: string, runId: string) {
+    super(`GitHub has no run ${runId} in ${repo} (HTTP 404)`);
+    this.name = 'WorkflowRunNotFoundError';
+    this.repo = repo;
+    this.runId = runId;
+  }
+}
+
+/** `gh api` reports the HTTP status in its stderr (`gh: Not Found (HTTP 404)`). */
+export function isGithubNotFoundError(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) return false;
+  const { stderr, message } = error as { stderr?: unknown; message?: unknown };
+  const text = [stderr, message].filter((part) => typeof part === 'string').join('\n');
+  return /\(HTTP 404\)/u.test(text);
+}
+
+/**
+ * List a workflow run's artifacts via `gh api` (paginated). Malformed lines
+ * are skipped; a 404 surfaces as `WorkflowRunNotFoundError`.
+ */
 export function listRunArtifacts(repo: string, runId: string): ArtifactMeta[] {
-  const json = execSync(
-    `gh api "repos/${repo}/actions/runs/${runId}/artifacts" --paginate --jq '.artifacts[]'`,
-    { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 },
-  );
+  let json: string;
+  try {
+    json = execSync(
+      `gh api "repos/${repo}/actions/runs/${runId}/artifacts" --paginate --jq '.artifacts[]'`,
+      { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 },
+    );
+  } catch (error) {
+    if (isGithubNotFoundError(error)) throw new WorkflowRunNotFoundError(repo, runId);
+    throw error;
+  }
   const out: ArtifactMeta[] = [];
   for (const line of json.trim().split('\n')) {
     if (!line) continue;
diff --git a/packages/db/src/prepare-ci-artifacts.ts b/packages/db/src/prepare-ci-artifacts.ts
index fbf834d70..f0c35780e 100644
--- a/packages/db/src/prepare-ci-artifacts.ts
+++ b/packages/db/src/prepare-ci-artifacts.ts
@@ -6,6 +6,7 @@ import path from 'node:path';
 
 import { buildArtifactPlan } from './lib/ci-artifact-preparation.js';
 import { downloadArtifact, listRunArtifacts, type ArtifactMeta } from './lib/github-artifacts.js';
+import { verifyRequiredPowerArtifacts } from './etl/required-power-publication.js';
 
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 
@@ -148,6 +149,16 @@ function main(): void {
     console.log(`Downloading artifact: ${artifact.name}`);
     downloadWithRetries(artifact, artifactsPath);
   }
+  // This command precedes migrations: malformed required input must not reach any DB write.
+  verifyRequiredPowerArtifacts(
+    artifactsPath,
+    {
+      runId: Number(sourceRunId),
+      runAttempt: sourceMetadata.run_attempt ?? 1,
+      headSha: sourceMetadata.head_sha ?? null,
+    },
+    process.env.INGEST_REQUIRE_POWER === 'true',
+  );
   if (plan.reused) {
     writeReuseMetadata(artifactsPath, sourceRunId, mergeRunId, sourceMetadata, mergeMetadata);
   }

From c4ea4f259abe20090cde12e36159b45bd541305a Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 062/103] feat(etl): publication receipts and required-power
 verification
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Write a per-run telemetry receipt (expected, produced, stored, API-readable points),
widen required-power publication to 1K/1K, and verify sweep manifests, point evidence
and curve preservation before a run is treated as published.

中文：为每个 run 写遥测回执（预期/产出/入库/API 可读点），required-power 发布范围扩展到 1K/1K，并在视为已发布前校验 sweep manifest、点证据与曲线保留。
---
 docs/fixtures/powerx-manifest-v2/README.md    | 101 ++++
 .../artifacts/agentic_golden/gpu_metrics.csv  |   3 +
 .../agentic_golden/gpu_metrics_identity.csv   |   2 +
 .../artifacts/agentic_golden/power_node.txt   |   1 +
 .../agentic_golden/power_validation.json      |  21 +
 .../artifacts/bmk_agentic_golden/agg.json     |  25 +
 .../changelog_metadata.json                   |   4 +
 .../sweep_manifest.json                       |  98 ++++
 .../required-power-agentic-matrix.json        |  50 --
 packages/db/src/etl/power-publication.test.ts |   8 +-
 packages/db/src/etl/power-publication.ts      |  76 ++-
 .../src/etl/required-power-curve-db.test.ts   |  89 +++
 .../db/src/etl/required-power-curve.test.ts   | 107 ++++
 packages/db/src/etl/required-power-curve.ts   | 287 ++++++++++
 .../etl/required-power-publication.test.ts    | 464 ++++++----------
 .../db/src/etl/required-power-publication.ts  | 520 +++++++++++++++++-
 packages/db/src/etl/telemetry-receipt.test.ts | 274 +++++++++
 packages/db/src/etl/telemetry-receipt.ts      | 461 ++++++++++++++++
 .../db/src/preflight-power-publication.ts     |  36 ++
 packages/db/src/verify-power-publication.ts   |  29 +-
 20 files changed, 2293 insertions(+), 363 deletions(-)
 create mode 100644 docs/fixtures/powerx-manifest-v2/README.md
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json
 delete mode 100644 packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json
 create mode 100644 packages/db/src/etl/required-power-curve-db.test.ts
 create mode 100644 packages/db/src/etl/required-power-curve.test.ts
 create mode 100644 packages/db/src/etl/required-power-curve.ts
 create mode 100644 packages/db/src/etl/telemetry-receipt.test.ts
 create mode 100644 packages/db/src/etl/telemetry-receipt.ts
 create mode 100644 packages/db/src/preflight-power-publication.ts

diff --git a/docs/fixtures/powerx-manifest-v2/README.md b/docs/fixtures/powerx-manifest-v2/README.md
new file mode 100644
index 000000000..0075b4a13
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/README.md
@@ -0,0 +1,101 @@
+# PowerX source manifest v2
+
+This small, synthetic one-GPU AgentX bundle is copied byte-for-byte between
+InferenceX and InferenceX-app. It tests the file contract. It is **not** a GPU
+capture, hardware qualification or publication receipt.
+
+`artifacts/required-power-sweep-manifest/sweep_manifest.json` is the source
+manifest. Evidence paths are relative to `artifacts/`, include their GitHub
+artifact directory, and have SHA-256 hashes of the exact retained bytes.
+
+## Contract
+
+- `schema-version: 2` versions publication independently of measurement-row
+  `power_metric_schema_version: 2`. Unsupported or unversioned required bundles
+  fail closed; legacy optional bundles remain optional.
+- `run-id`, `run-attempt`, and `head` name the tested source. A later rerun may
+  retain successful earlier-attempt evidence from the same run and head. The
+  consumer compares these fields with GitHub source metadata, including on reuse.
+- `matrix` retains the ordinary planner declaration. Every required,
+  non-evaluation matrix point must occur exactly once in `points`.
+- `config_key` is the matrix entry's `exp-name`. `identity` binds model, hardware,
+  framework, precision, recipe fingerprint, workload/sequence and concurrency.
+  AgentX uses `agentic_traces` with null `isl`/`osl`; fixed sequence uses
+  `single_turn`. Full recipe details remain in the matrix and hashed aggregate.
+- `topology` declares aggregate versus P/D, single versus multi-node and physical
+  GPU counts. `devices` binds actual nodes and GPU UUIDs to aggregate, prefill or
+  decode roles with positive per-device energy. Both P/D roles are mandatory for
+  disaggregated deployments. A local GPU index alone is insufficient.
+- `measurement_window` contains finite Unix-second boundaries, with end after
+  start. The evidence must describe the same window.
+- `artifacts` contains confined relative paths, exact hashes and
+  `validation_state: "valid"`. Missing files, path escapes, invalid verdicts,
+  mismatched identities and invalid power reject required publication. Missing
+  and invalid values remain distinct from numeric zero. Required energy and
+  derived power must be strictly positive; measured zero fails that gate.
+
+## Publication intent
+
+Normal manifests emit `publication: {"mode":"incremental","replacement_scope":[]}`.
+Incremental means **no authorized loss**; it does not change existing whole-curve
+selection or automatically enable append-only. A complete refresh can pass by
+retaining all stable point identities. Recipe/image fingerprint changes may need
+a reviewed exact replacement.
+
+`mode: "replacement"` permits only explicit entries containing:
+
+- `curve_scope`: the canonical logical curve JSON identity;
+- `previous_snapshot_workflow_run_id`: the exact database snapshot superseded;
+- `removed_point_identities`: the exact set of lost stable identities.
+
+No wildcard, stale snapshot or broader permission is implied. The producer's
+ordinary path emits no destructive authorization. Authoring authorization needs
+explicitly reviewed replacement intent and current snapshot evidence.
+
+AgentX scope groups model/hardware/framework/precision/workload; AGG/P/D,
+parallelism, offload and recipe variants are points in that curve. Fixed-sequence
+scopes retain existing spec/disagg/offload boundaries. The consumer models latest
+attempts, whole snapshots and same-image append-only inheritance before its first
+publication write. Row counts or a stale materialized view cannot establish safety.
+
+## Remaining publication boundary
+
+Artifact validation runs before workflow migrations. Curve preflight runs before
+workflow/config/benchmark upserts. It is a pure preflight, not an atomic commit:
+concurrent writers and failures after the first write can still cause partial
+publication. Follow-up work must stage the complete run, recheck the base-table
+curve under a target-database publication lock, then atomically promote metadata
+and benchmark rows. Sidecar preparation belongs outside that transaction.
+Post-write DB/API checks remain necessary; exact-run equality alone does not prove
+latest-curve visibility.
+
+## Read-only fixture check in InferenceX-app
+
+From the repository root:
+
+```sh
+bun packages/db/src/preflight-power-publication.ts \
+  docs/fixtures/powerx-manifest-v2/artifacts 123 1 \
+  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+```
+
+This opens no database connection, dispatches no work and writes no files. It
+validates artifacts only; focused curve tests model previous published state.
+
+## 中文说明
+
+此目录是一份最小的合成 AgentX 样例，两个仓库保留完全相同的文件字节，
+用于测试 producer 与 consumer 的契约；它不是实机采集或生产发布证据。
+
+manifest schema v2 记录来源 run、attempt、测试 SHA、完整 matrix、逐点身份、
+测量窗口、实际 node/GPU UUID/角色及产物哈希。必需功耗路径拒绝缺失、损坏、
+不兼容或能量非正的证据；P/D 必须同时覆盖 prefill 和 decode。历史可选功耗
+路径保留兼容行为。数值 0 不会被改写为“缺失”，但不能通过正能量门槛。
+
+默认 incremental 只表示没有授权丢点，不会改变数据库整条曲线替换的语义。
+有意替换必须精确指定旧快照及全部移除点，不能使用通配或过期授权。AgentX
+的 AGG、P/D、offload 和配方属于同一条逻辑曲线，校验时必须一起比较。
+
+产物校验先于 migration；曲线校验先于发布数据写入。当前实现不是原子发布，
+仍需后续 staging、发布锁和事务性 promote 来处理并发及中途写入失败。
+DB/API 写后校验仍保留，exactRun 校验不能单独证明 latest 曲线完整可见。
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv
new file mode 100644
index 000000000..d39b2974a
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv
@@ -0,0 +1,3 @@
+timestamp, index, power.draw [W]
+2023/11/14 22:13:20.000, 0, 500
+2023/11/14 22:13:22.000, 0, 500
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv
new file mode 100644
index 000000000..139b5a261
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv
@@ -0,0 +1,2 @@
+index, uuid, pci.bus_id, name, driver_version
+0, GPU-golden, 00000000:01:00.0, NVIDIA H100, 000.00
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt
new file mode 100644
index 000000000..fb271d435
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt
@@ -0,0 +1 @@
+golden-node
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json
new file mode 100644
index 000000000..42d164cb2
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json
@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "power_valid": true,
+  "reasons": [],
+  "benchmark_window": {
+    "start_time_unix": 1700000000,
+    "end_time_unix": 1700000002
+  },
+  "expected_gpu_count": 1,
+  "observed_gpu_count": 1,
+  "observed_gpu_ids": ["0"],
+  "per_gpu_energy_j": {
+    "0": 1000
+  },
+  "metrics": {
+    "avg_power_w": 500,
+    "avg_total_gpu_power_w": 500,
+    "total_gpu_energy_j": 1000,
+    "joules_per_output_token": 2
+  }
+}
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json b/docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json
new file mode 100644
index 000000000..98df7c14b
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json
@@ -0,0 +1,25 @@
+{
+  "infmax_model_prefix": "qwen3.5",
+  "hw": "h100",
+  "framework": "sglang",
+  "precision": "fp8",
+  "recipe_fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "scenario_type": "agentic-coding",
+  "conc": 1,
+  "users": 1,
+  "tp": 1,
+  "ep": 1,
+  "dp_attention": false,
+  "disagg": false,
+  "is_multinode": false,
+  "num_gpus": 1,
+  "image": "example/serving:golden",
+  "power_valid": 1,
+  "power_metric_schema_version": 2,
+  "avg_power_w": 500,
+  "avg_total_gpu_power_w": 500,
+  "total_gpu_energy_j": 1000,
+  "joules_per_output_token": 2,
+  "output_tput_per_gpu": 250,
+  "median_intvty": 50
+}
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json b/docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json
new file mode 100644
index 000000000..af53bb83d
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json
@@ -0,0 +1,4 @@
+{
+  "require-power": true,
+  "entries": []
+}
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json b/docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json
new file mode 100644
index 000000000..f51df0546
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json
@@ -0,0 +1,98 @@
+{
+  "schema-version": 2,
+  "head": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "run-id": 123,
+  "run-attempt": 1,
+  "full-sweep": false,
+  "matrix": {
+    "single_node": {
+      "agentic": [
+        {
+          "exp-name": "golden",
+          "model-prefix": "qwen3.5",
+          "model": "Qwen/Qwen3.5",
+          "runner": "h100",
+          "framework": "sglang",
+          "precision": "fp8",
+          "recipe-fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "conc": [1],
+          "require-power": true,
+          "scenario-type": "agentic-coding",
+          "disagg": false,
+          "num-gpus": 1,
+          "tp": 1,
+          "ep": 1,
+          "image": "example/serving:golden"
+        }
+      ]
+    },
+    "multi_node": {}
+  },
+  "publication": {
+    "mode": "incremental",
+    "replacement_scope": []
+  },
+  "points": [
+    {
+      "config_key": "golden",
+      "identity": {
+        "model": "qwen3.5",
+        "hardware": "h100",
+        "framework": "sglang",
+        "precision": "fp8",
+        "recipe_fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "benchmark_type": "agentic_traces",
+        "isl": null,
+        "osl": null,
+        "concurrency": 1
+      },
+      "topology": {
+        "disagg": false,
+        "is_multinode": false,
+        "num_gpus": 1,
+        "tp": 1,
+        "ep": 1,
+        "dp_attention": false
+      },
+      "measurement_window": {
+        "start_time_unix": 1700000000,
+        "end_time_unix": 1700000002
+      },
+      "devices": [
+        {
+          "node": "golden-node",
+          "gpu_uuid": "GPU-golden",
+          "role": "aggregate",
+          "energy_j": 1000
+        }
+      ],
+      "artifacts": [
+        {
+          "path": "agentic_golden/gpu_metrics.csv",
+          "sha256": "f42dee832f8d837142be9d4dc5fbbf8462c02846f06e66edfce659b8b20943db",
+          "validation_state": "valid"
+        },
+        {
+          "path": "agentic_golden/gpu_metrics_identity.csv",
+          "sha256": "a4364a0d4050078b9cba24c7e695fbed658fabb1d48e61a3da8f61b8ec873627",
+          "validation_state": "valid"
+        },
+        {
+          "path": "agentic_golden/power_node.txt",
+          "sha256": "114aa18bee3688c0e6040020ad0230472645541372b88a54253116fd9c2148e6",
+          "validation_state": "valid"
+        },
+        {
+          "path": "agentic_golden/power_validation.json",
+          "sha256": "c00687e7239fd172aa15f60c8d967294a0fa623984d0eaeeb5222424b6335d94",
+          "validation_state": "valid"
+        },
+        {
+          "path": "bmk_agentic_golden/agg.json",
+          "sha256": "56e3377ae12402eec61e25e2f9a0480ab228048a29d32c35cb8d438d50ea2faa",
+          "validation_state": "valid"
+        }
+      ]
+    }
+  ]
+}
diff --git a/packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json b/packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json
deleted file mode 100644
index 4d17ed15a..000000000
--- a/packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json
+++ /dev/null
@@ -1,50 +0,0 @@
-{
-  "single_node": {},
-  "multi_node": {
-    "agentic": [
-      {
-        "image": "vllm/vllm-openai:nightly-dev-x86_64-cu13.0.1-728d3ad",
-        "model": "moonshotai/Kimi-K3",
-        "model-prefix": "kimik3",
-        "precision": "fp4",
-        "framework": "dynamo-vllm",
-        "spec-decoding": "mtp",
-        "runner": "cluster:b200-nscale",
-        "require-power": true,
-        "node-count": 2,
-        "prefill": {
-          "num-worker": 1,
-          "tp": 8,
-          "pp": 2,
-          "dcp-size": 8,
-          "pcp-size": 1,
-          "ep": 1,
-          "dp-attn": false,
-          "additional-settings": [
-            "CONFIG_FILE=recipes/vllm/kimi-k3/agentic/agg-b200-tp8pp2-mooncake-c1-agentic.yaml",
-            "SYNTHETIC_ACCEPTANCE=true",
-            "SYNTHETIC_ACCEPTANCE_LENGTH=3.84"
-          ]
-        },
-        "decode": {
-          "num-worker": 0,
-          "tp": 8,
-          "pp": 2,
-          "dcp-size": 8,
-          "pcp-size": 1,
-          "ep": 1,
-          "dp-attn": false,
-          "additional-settings": []
-        },
-        "conc": [1],
-        "kv-offloading": "none",
-        "total-cpu-dram-gb": 0,
-        "duration": 3600,
-        "exp-name": "kimik3_p1x8_d0x8_conc1",
-        "disagg": false,
-        "scenario-type": "agentic-coding",
-        "recipe-fingerprint": "ebb89391c58441525072eeffe36b6a6f6f52445116c68c99c017f06d662b972e"
-      }
-    ]
-  }
-}
diff --git a/packages/db/src/etl/power-publication.test.ts b/packages/db/src/etl/power-publication.test.ts
index f223a07a4..b31ce0f98 100644
--- a/packages/db/src/etl/power-publication.test.ts
+++ b/packages/db/src/etl/power-publication.test.ts
@@ -37,7 +37,7 @@ function expected(overrides = {}) {
     'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/123/attempts/2',
     { path: 'bmk_qwen3.5/results.json', sha256: 'abc' },
   );
-  if (!point) throw new Error('Fixture must be 8K/1K');
+  if (!point) throw new Error('Fixture must belong to a supported PowerX workload');
   return point;
 }
 function actual(point = expected()): PublishedPowerRow {
@@ -51,6 +51,12 @@ function actual(point = expected()): PublishedPowerRow {
 }
 
 describe('PowerX publication', () => {
+  it('keeps required 1K/1K measurements in the publication receipt', () => {
+    const point = expected({ isl: 1024, joules_per_output_token: 2.5 });
+    expect(point.identity).toMatchObject({ benchmark_type: 'single_turn', isl: 1024, osl: 1024 });
+    expect(verifyPowerPublication([point], [actual(point)], 'database')).toEqual([]);
+    expect(verifyPowerPublication([point], [], 'public API')[0]).toContain('found 0');
+  });
   it('verifies AgentX source identity, nullable sequences, energy and audit through DB/API', () => {
     const point = expected({
       scenario_type: 'agentic-coding',
diff --git a/packages/db/src/etl/power-publication.ts b/packages/db/src/etl/power-publication.ts
index d2ed10c14..d4a0ba17c 100644
--- a/packages/db/src/etl/power-publication.ts
+++ b/packages/db/src/etl/power-publication.ts
@@ -1,6 +1,7 @@
 import { isDeepStrictEqual } from 'node:util';
 import { MEASURED_POWER_METRIC_KEYS } from '@semianalysisai/inferencex-constants';
 import type { BenchmarkParams } from './benchmark-mapper';
+import type { TelemetryReceipt } from './telemetry-receipt';
 
 const CONFIG_FIELDS = {
   hardware: 'hardware',
@@ -46,26 +47,67 @@ export interface PowerPublicationManifest {
   runId: number;
   runAttempt: number;
   points: PowerPublicationPoint[];
+  /** Fatal: verify-power-publication exits non-zero when this is non-empty. */
   ingestErrors?: string[];
+  /**
+   * Non-fatal: PowerX telemetry digest failures. Surfaced in the verification
+   * receipt so they stay visible, but they never fail the ingest — the benchmark
+   * rows landed, and the artifact can be re-digested by the backfill.
+   */
+  telemetryWarnings?: string[];
+  /** Attachment completeness, separate from benchmark/power publication validity. */
+  telemetry?: TelemetryReceipt;
+  /** Durable refresh responsibility when telemetry recovery fills benchmark metadata. */
+  benchmarkRefresh?: {
+    status: 'pending' | 'complete' | 'failed';
+    benchmarkResultIds: number[];
+    /** Expected enrichment comes from retained validation, never a DB snapshot. */
+    auditUpdates?: {
+      benchmarkResultId: number;
+      identity: Record<string, unknown>;
+      /** Original mapped identity when the existing historical offload resolver used a fallback. */
+      sourceIdentity?: Record<string, unknown>;
+      powerAudit: { source: string; window_start_unix: number; window_end_unix: number };
+    }[];
+    endpoint?: string;
+    checkedAt?: string;
+    error?: string;
+  };
+}
+/**
+ * The errors that fail an ingest. `telemetryWarnings` is deliberately not among
+ * them: a gpu_metrics digest failure costs one point's PowerX tab, while the
+ * benchmark rows it accompanies are already committed and the artifact can be
+ * re-digested by `admin:db:backfill-gpu-metrics`. Folding it in would let one
+ * malformed CSV turn a whole production ingest red.
+ */
+export function fatalPublicationErrors(
+  manifest: Pick<PowerPublicationManifest, 'ingestErrors' | 'telemetryWarnings'>,
+  verificationErrors: readonly string[],
+): string[] {
+  return [...(manifest.ingestErrors ?? []), ...verificationErrors];
 }
+
 export interface PublishedPowerRow extends Record<string, unknown> {
   metrics: Record<string, number>;
 }
 
+export function stablePowerPointIdentity(row: Record<string, unknown>): string {
+  return JSON.stringify(
+    IDENTITY_FIELDS.filter((key) => key !== 'image' && key !== 'run_url').map(
+      (key) => row[key] ?? null,
+    ),
+  );
+}
+
 export function publicationIdentity(row: Record<string, unknown>): string {
   return JSON.stringify(IDENTITY_FIELDS.map((key) => row[key] ?? null));
 }
 
-export function powerPublicationPoint(
+export function benchmarkPublicationIdentity(
   row: BenchmarkParams,
-  runUrl: string,
-  artifact: PowerPublicationPoint['artifact'],
-): PowerPublicationPoint | null {
-  if (
-    row.benchmarkType !== 'agentic_traces' &&
-    (row.benchmarkType !== 'single_turn' || row.isl !== 8192 || row.osl !== 1024)
-  )
-    return null;
+  runUrl = '',
+): Record<string, unknown> {
   const identity: Record<string, unknown> = Object.fromEntries(
     Object.entries(CONFIG_FIELDS).map(([source, target]) => [
       target,
@@ -82,6 +124,22 @@ export function powerPublicationPoint(
     image: row.image,
     run_url: runUrl,
   });
+  return identity;
+}
+
+export function powerPublicationPoint(
+  row: BenchmarkParams,
+  runUrl: string,
+  artifact: PowerPublicationPoint['artifact'],
+): PowerPublicationPoint | null {
+  if (
+    row.benchmarkType !== 'agentic_traces' &&
+    (row.benchmarkType !== 'single_turn' ||
+      (row.isl !== 1024 && row.isl !== 8192) ||
+      row.osl !== 1024)
+  )
+    return null;
+  const identity = benchmarkPublicationIdentity(row, runUrl);
   return {
     identity,
     metrics: Object.fromEntries(
diff --git a/packages/db/src/etl/required-power-curve-db.test.ts b/packages/db/src/etl/required-power-curve-db.test.ts
new file mode 100644
index 000000000..7ffcbfb06
--- /dev/null
+++ b/packages/db/src/etl/required-power-curve-db.test.ts
@@ -0,0 +1,89 @@
+import { PGlite } from '@electric-sql/pglite';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { beforeAll, beforeEach, afterAll, describe, it, expect } from 'vitest';
+import type { DbClient } from '../connection';
+import { preflightRequiredPowerCurves } from './required-power-curve';
+import { getLatestBenchmarks } from '../queries/benchmarks';
+let db: PGlite;
+const sql: DbClient = async (strings, ...values) => {
+  const query = strings.reduce((text, part, index) => text + (index ? `$${index}` : '') + part, '');
+  const result = await db.query<Record<string, unknown>>(query, values);
+  return result.rows;
+};
+const golden = path.resolve(
+  import.meta.dirname,
+  '../../../../docs/fixtures/powerx-manifest-v2/artifacts',
+);
+const source = { runId: 123, runAttempt: 1, headSha: 'b'.repeat(40) };
+const options = { date: '2026-09-16', runStartedAt: '2026-09-16T00:00:00Z', appendOnly: false };
+beforeAll(async () => {
+  db = await PGlite.create();
+  const dir = new URL('../../migrations/', import.meta.url);
+  for (const file of fs
+    .readdirSync(dir)
+    .filter((name) => name.endsWith('.sql'))
+    .sort())
+    await db.exec(fs.readFileSync(new URL(file, dir), 'utf8'));
+}, 20000);
+afterAll(async () => {
+  await db?.close();
+});
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, prefill_ep, decode_tp, decode_ep, num_prefill_gpu, num_decode_gpu)
+      VALUES (1, 'qwen3.5', 'h100', 'sglang', 'fp8', 'none', false, 1,1,1,1,1,1);
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, date, created_at, run_started_at)
+      VALUES (1, 111, 1, 'previous', '2026-09-15', '2026-09-15T00:00:00Z', '2026-09-15T00:00:00Z');`);
+});
+async function addPoint(conc: number, image = 'example/serving:golden') {
+  await sql`INSERT INTO benchmark_results (config_id, workflow_run_id, date, benchmark_type, isl, osl, conc, offload_mode, recipe_fingerprint, image, metrics)
+    VALUES (1,1,'2026-09-15','agentic_traces',NULL,NULL,${conc},'off',${'a'.repeat(64)},${image},'{}')`;
+}
+describe('read-only required-power DB preflight', () => {
+  it('rejects partial refresh from base tables before any write, even with a stale latest view', async () => {
+    await addPoint(1);
+    await addPoint(64);
+    const before = await sql`SELECT count(*)::int AS n FROM benchmark_results`;
+    await expect(preflightRequiredPowerCurves(sql, golden, source, options)).rejects.toThrow(
+      'shrink',
+    );
+    expect(await sql`SELECT count(*)::int AS n FROM benchmark_results`).toEqual(before);
+    expect(await sql`SELECT count(*)::int AS n FROM workflow_runs`).toEqual([{ n: 1 }]);
+    const published = await getLatestBenchmarks(sql, 'qwen3.5', '9999-12-31');
+    expect(published.map((row) => row.conc)).toEqual([1, 64]);
+  });
+  it('detects retry removal from a scope omitted entirely by incoming artifacts', async () => {
+    await sql`UPDATE workflow_runs SET github_run_id=123`;
+    await sql`UPDATE configs SET hardware='h200'`;
+    await addPoint(64);
+    await expect(
+      preflightRequiredPowerCurves(sql, golden, { ...source, runAttempt: 2 }, options),
+    ).rejects.toThrow('shrink');
+    expect(await sql`SELECT count(*)::int AS n FROM workflow_runs`).toEqual([{ n: 1 }]);
+  });
+  it('protects optional fixed workloads outside the power receipt whitelist', async () => {
+    await sql`INSERT INTO benchmark_results (config_id,workflow_run_id,date,benchmark_type,isl,osl,conc,offload_mode,recipe_fingerprint,image,metrics)
+      VALUES (1,1,'2026-09-15','single_turn',4096,1024,1,'off',${'c'.repeat(64)},'example/serving:golden','{}'),
+      (1,1,'2026-09-15','single_turn',4096,1024,8,'off',${'c'.repeat(64)},'example/serving:golden','{}')`;
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-optional-'));
+    try {
+      fs.cpSync(golden, dir, { recursive: true });
+      fs.mkdirSync(path.join(dir, 'results_optional'));
+      const row = JSON.parse(
+        fs.readFileSync(path.join(golden, 'bmk_agentic_golden/agg.json'), 'utf8'),
+      );
+      delete row.scenario_type;
+      delete row.users;
+      Object.assign(row, { isl: 4096, osl: 1024, recipe_fingerprint: 'c'.repeat(64) });
+      fs.writeFileSync(path.join(dir, 'results_optional/extra.json'), JSON.stringify(row));
+      await expect(preflightRequiredPowerCurves(sql, dir, source, options)).rejects.toThrow(
+        'shrink',
+      );
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/packages/db/src/etl/required-power-curve.test.ts b/packages/db/src/etl/required-power-curve.test.ts
new file mode 100644
index 000000000..8dafa5033
--- /dev/null
+++ b/packages/db/src/etl/required-power-curve.test.ts
@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest';
+import {
+  assertCurvePreserved,
+  publishedCurve,
+  type CurvePoint,
+  type CurvePublication,
+} from './required-power-curve';
+import { powerPublicationPoint, stablePowerPointIdentity } from './power-publication';
+import { verifyRequiredPowerArtifacts } from './required-power-publication';
+import path from 'node:path';
+const golden = path.resolve(
+  import.meta.dirname,
+  '../../../../docs/fixtures/powerx-manifest-v2/artifacts',
+);
+const benchmark = verifyRequiredPowerArtifacts(golden, {
+  runId: 123,
+  runAttempt: 1,
+  headSha: 'b'.repeat(40),
+})[0];
+const identity = powerPublicationPoint(benchmark, '', { path: '', sha256: '' })!.identity;
+const policy: CurvePublication = { mode: 'incremental', replacement_scope: [] };
+function point(run: number, conc: number, extra: Partial<CurvePoint> = {}): CurvePoint {
+  return {
+    identity: { ...identity, conc },
+    image: 'same-image',
+    workflowRunId: run,
+    githubRunId: run,
+    runAttempt: 1,
+    date: `2026-09-${run.toString().padStart(2, '0')}`,
+    runStartedAt: null,
+    appendOnly: false,
+    ...extra,
+  };
+}
+describe('pure projected publication curve', () => {
+  it('rejects the old partial-sweep regression without altering input rows', () => {
+    const old = [
+      point(1, 1),
+      point(1, 16),
+      point(1, 64, {
+        identity: { ...identity, conc: 64, disagg: true, recipe_fingerprint: 'split-recipe' },
+      }),
+    ];
+    const proposed = [...old, point(2, 1)];
+    expect(() => assertCurvePreserved(old, proposed, policy)).toThrow('shrink');
+    expect([...publishedCurve(old).values()][0]).toHaveLength(3);
+  });
+  it('does not inherit append-only history with an incompatible image', () => {
+    const old = [point(1, 1), point(1, 16)];
+    expect(() =>
+      assertCurvePreserved(
+        old,
+        [...old, point(2, 32, { appendOnly: true, image: 'new-image' })],
+        policy,
+      ),
+    ).toThrow('shrink');
+  });
+  it('inherits only an uninterrupted same-image append-only chain', () => {
+    const old = [point(1, 1), point(1, 16), point(2, 32, { appendOnly: true })];
+    expect([...publishedCurve(old).values()][0].map((row) => row.identity.conc)).toEqual([
+      32, 1, 16,
+    ]);
+    expect(() =>
+      assertCurvePreserved(old, [...old, point(3, 64, { appendOnly: true })], policy),
+    ).not.toThrow();
+    expect(() => assertCurvePreserved(old, [...old, point(3, 64)], policy)).toThrow('shrink');
+  });
+  it('permits only the exact removed identities of the observed snapshot', () => {
+    const old = [point(1, 1), point(1, 16)];
+    const proposed = [...old, point(2, 1)];
+    const replacement: CurvePublication = {
+      mode: 'replacement',
+      replacement_scope: [
+        {
+          curve_scope: [...publishedCurve(old).keys()][0],
+          previous_snapshot_workflow_run_id: 1,
+          removed_point_identities: [stablePowerPointIdentity(old[1].identity)],
+        },
+      ],
+    };
+    expect(() => assertCurvePreserved(old, proposed, replacement)).not.toThrow();
+    for (const altered of [
+      { ...replacement.replacement_scope[0], previous_snapshot_workflow_run_id: 99 },
+      { ...replacement.replacement_scope[0], removed_point_identities: ['*'] },
+      { ...replacement.replacement_scope[0], curve_scope: '*' },
+    ])
+      expect(() =>
+        assertCurvePreserved(old, proposed, { mode: 'replacement', replacement_scope: [altered] }),
+      ).toThrow('shrink');
+  });
+  it('treats topology and offload as point identity inside one AgentX curve', () => {
+    const old = [point(1, 1)];
+    for (const altered of [
+      { prefill_tp: 2 },
+      { offload_mode: 'on' },
+      { recipe_fingerprint: 'other-recipe' },
+    ]) {
+      expect(() =>
+        assertCurvePreserved(
+          old,
+          [...old, point(2, 1, { identity: { ...identity, ...altered } })],
+          policy,
+        ),
+      ).toThrow('shrink');
+    }
+  });
+});
diff --git a/packages/db/src/etl/required-power-curve.ts b/packages/db/src/etl/required-power-curve.ts
new file mode 100644
index 000000000..1b2cdfbfa
--- /dev/null
+++ b/packages/db/src/etl/required-power-curve.ts
@@ -0,0 +1,287 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  benchmarkCurveScope,
+  type BenchmarkCurveInput,
+} from '@semianalysisai/inferencex-constants';
+import type { DbClient } from '../connection';
+import type { Sql } from './db-utils';
+import { REQUIRED_POWER_MANIFEST } from '../lib/ci-artifact-preparation';
+import { mapBenchmarkRow, type BenchmarkParams } from './benchmark-mapper';
+import { configCacheKey, type ConfigParams } from './config-cache';
+import { benchmarkPublicationIdentity, stablePowerPointIdentity } from './power-publication';
+import {
+  assertRequiredPowerPointsRetained,
+  verifyRequiredPowerArtifacts,
+  type RequiredPowerSource,
+} from './required-power-publication';
+import {
+  applyBenchmarkPointBackfill,
+  isBenchmarkPointPurged,
+  recordBackfilledPointIdentity,
+} from './run-overrides';
+import { createSkipTracker } from './skip-tracker';
+
+export interface CurvePoint {
+  identity: Record<string, unknown>;
+  image: string | null;
+  workflowRunId: number;
+  githubRunId: number;
+  runAttempt: number;
+  date: string;
+  runStartedAt: string | null;
+  appendOnly: boolean;
+}
+export interface CurveReplacement {
+  curve_scope: string;
+  previous_snapshot_workflow_run_id: number;
+  removed_point_identities: string[];
+}
+export interface CurvePublication {
+  mode: 'incremental' | 'replacement';
+  replacement_scope: CurveReplacement[];
+}
+
+function scope(point: CurvePoint): string {
+  return benchmarkCurveScope(point.identity as unknown as BenchmarkCurveInput);
+}
+
+/** Mirrors migration 014: latest attempt, scope-level snapshots and same-image append chains. */
+export function publishedCurve(points: readonly CurvePoint[]): Map<string, CurvePoint[]> {
+  const latestAttempts = new Map<number, number>();
+  for (const point of points)
+    latestAttempts.set(
+      point.githubRunId,
+      Math.max(latestAttempts.get(point.githubRunId) ?? 0, point.runAttempt),
+    );
+  const scopes = new Map<string, Map<string, CurvePoint[]>>();
+  for (const point of points) {
+    if (point.runAttempt !== latestAttempts.get(point.githubRunId)) continue;
+    const key = scope(point);
+    const runs = scopes.get(key) ?? new Map<string, CurvePoint[]>();
+    const runDate = JSON.stringify([point.workflowRunId, point.date]);
+    runs.set(runDate, [...(runs.get(runDate) ?? []), point]);
+    scopes.set(key, runs);
+  }
+  const result = new Map<string, CurvePoint[]>();
+  for (const [key, runs] of scopes) {
+    const ranked = [...runs.values()].sort(
+      (a, b) =>
+        b[0].date.localeCompare(a[0].date) ||
+        (b[0].runStartedAt ? Date.parse(b[0].runStartedAt) : -Infinity) -
+          (a[0].runStartedAt ? Date.parse(a[0].runStartedAt) : -Infinity) ||
+        b[0].workflowRunId - a[0].workflowRunId,
+    );
+    const rootImage = ranked[0][0].image;
+    const uniformImage = (rows: CurvePoint[]) =>
+      rootImage !== null && rows.every((row) => row.image === rootImage);
+    const selected = new Map<string, CurvePoint>();
+    for (let index = 0; index < ranked.length; index++) {
+      const current = ranked[index];
+      // SQL groups run/date for ranking, then joins every point in that run/scope.
+      for (const point of [...runs.values()]
+        .flat()
+        .filter((candidate) => candidate.workflowRunId === current[0].workflowRunId)) {
+        const id = stablePowerPointIdentity(point.identity);
+        if (!selected.has(id)) selected.set(id, point);
+      }
+      if (
+        !current[0].appendOnly ||
+        !uniformImage(current) ||
+        !ranked[index + 1] ||
+        !uniformImage(ranked[index + 1])
+      )
+        break;
+    }
+    result.set(key, [...selected.values()]);
+  }
+  return result;
+}
+
+function canonical(entries: CurveReplacement[]): string {
+  return JSON.stringify(
+    entries
+      .map((entry) => {
+        if (
+          typeof entry.curve_scope !== 'string' ||
+          !Number.isSafeInteger(entry.previous_snapshot_workflow_run_id) ||
+          !Array.isArray(entry.removed_point_identities) ||
+          entry.removed_point_identities.some((id) => typeof id !== 'string')
+        )
+          throw new Error('Required power: invalid exact replacement scope');
+        return { ...entry, removed_point_identities: [...entry.removed_point_identities].sort() };
+      })
+      .sort((a, b) => a.curve_scope.localeCompare(b.curve_scope)),
+  );
+}
+
+/** Exact lost identities bind any destructive authorization to one observed snapshot. */
+export function assertCurvePreserved(
+  existing: readonly CurvePoint[],
+  proposed: readonly CurvePoint[],
+  publication: CurvePublication,
+): void {
+  if (
+    !publication ||
+    !['incremental', 'replacement'].includes(publication.mode) ||
+    !Array.isArray(publication.replacement_scope)
+  )
+    throw new Error('Required power: invalid curve publication policy');
+  const before = publishedCurve(existing);
+  const after = publishedCurve(proposed);
+  const losses: CurveReplacement[] = [];
+  for (const [key, oldPoints] of before) {
+    const next = new Set(
+      (after.get(key) ?? []).map((point) => stablePowerPointIdentity(point.identity)),
+    );
+    const removed = oldPoints
+      .map((point) => stablePowerPointIdentity(point.identity))
+      .filter((identity) => !next.has(identity))
+      .sort();
+    if (removed.length > 0)
+      losses.push({
+        curve_scope: key,
+        previous_snapshot_workflow_run_id: oldPoints[0].workflowRunId,
+        removed_point_identities: removed,
+      });
+  }
+  if (publication.mode === 'incremental' && publication.replacement_scope.length > 0)
+    throw new Error('Required power: incremental publication cannot authorize replacement');
+  if (
+    (losses.length > 0 && publication.mode !== 'replacement') ||
+    canonical(losses) !== canonical(publication.replacement_scope)
+  )
+    throw new Error(
+      `Required power: publication would shrink the existing curve; exact replacement_scope required: ${JSON.stringify(losses)}`,
+    );
+}
+
+/** Read-only preflight; no config/workflow upsert, migration, or materialized-view refresh. */
+export async function preflightRequiredPowerCurves(
+  sql: DbClient | Sql,
+  root: string,
+  source: RequiredPowerSource,
+  options: { date: string; runStartedAt: string | null; appendOnly: boolean },
+): Promise<void> {
+  const required = verifyRequiredPowerArtifacts(root, source);
+  if (required.length === 0) return;
+  const manifest = JSON.parse(
+    fs.readFileSync(path.join(root, REQUIRED_POWER_MANIFEST, 'sweep_manifest.json'), 'utf8'),
+  );
+  const configs = await sql`SELECT * FROM configs`;
+  const configIds = new Map(
+    configs.map((row) => [
+      configCacheKey({
+        hardware: row.hardware,
+        framework: row.framework,
+        model: row.model,
+        precision: row.precision,
+        specMethod: row.spec_method,
+        disagg: row.disagg,
+        isMultinode: row.is_multinode,
+        prefillTp: row.prefill_tp,
+        prefillEp: row.prefill_ep,
+        prefillDpAttn: row.prefill_dp_attention,
+        prefillNumWorkers: row.prefill_num_workers,
+        decodeTp: row.decode_tp,
+        decodeEp: row.decode_ep,
+        decodeDpAttn: row.decode_dp_attention,
+        decodeNumWorkers: row.decode_num_workers,
+        numPrefillGpu: row.num_prefill_gpu,
+        numDecodeGpu: row.num_decode_gpu,
+      } as ConfigParams),
+      Number(row.id),
+    ]),
+  );
+  const incoming = new Map<string, BenchmarkParams>();
+  const backfilled = new Map<string, string>();
+  for (const name of fs.readdirSync(root)) {
+    if (
+      (!name.startsWith('bmk_') && !name.startsWith('results_')) ||
+      !fs.statSync(path.join(root, name)).isDirectory()
+    )
+      continue;
+    for (const file of fs
+      .readdirSync(path.join(root, name))
+      .filter((candidateName) => candidateName.endsWith('.json'))) {
+      const data = JSON.parse(fs.readFileSync(path.join(root, name, file), 'utf8'));
+      for (const raw of Array.isArray(data) ? data : [data]) {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
+        const mapped = mapBenchmarkRow(raw, createSkipTracker(), undefined, source.runId);
+        if (!mapped) continue;
+        // A config not present yet cannot match a config-id-scoped purge/backfill.
+        const point = { ...mapped, configId: configIds.get(configCacheKey(mapped.config)) ?? -1 };
+        if (isBenchmarkPointPurged(source.runId, source.runAttempt, point)) continue;
+        const applied = applyBenchmarkPointBackfill(source.runId, source.runAttempt, point);
+        recordBackfilledPointIdentity(backfilled, applied.sourceIdentity, applied.desiredIdentity);
+        incoming.set(
+          stablePowerPointIdentity(benchmarkPublicationIdentity(applied.point)),
+          applied.point,
+        );
+      }
+    }
+  }
+  assertRequiredPowerPointsRetained(required, [...incoming.values()]);
+  const models = [...new Set([...incoming.values()].map((point) => point.config.model))];
+  const rows = await sql`
+    SELECT c.*, br.benchmark_type, br.isl, br.osl, br.conc, br.offload_mode,
+      br.recipe_fingerprint, br.image, br.date::text AS point_date,
+      wr.id AS workflow_run_id, wr.github_run_id, wr.run_attempt,
+      wr.run_started_at::text, wr.append_only
+    FROM benchmark_results br
+    JOIN configs c ON c.id = br.config_id
+    JOIN latest_workflow_runs wr ON wr.id = br.workflow_run_id
+    WHERE br.error IS NULL AND (c.model = ANY(${models}) OR wr.github_run_id = ${source.runId})`;
+  const stored = rows.map((row): CurvePoint => ({
+    identity: row,
+    image: row.image as string | null,
+    workflowRunId: Number(row.workflow_run_id),
+    githubRunId: Number(row.github_run_id),
+    runAttempt: Number(row.run_attempt),
+    date: String(row.point_date),
+    runStartedAt: row.run_started_at as string | null,
+    appendOnly: Boolean(row.append_only),
+  }));
+  const attempts =
+    await sql`SELECT id, run_attempt FROM workflow_runs WHERE github_run_id = ${source.runId}`;
+  const sameAttempt = attempts.find((row) => Number(row.run_attempt) === source.runAttempt);
+  // New serial IDs sort after stored IDs. A concurrent ingest is outside this pure preflight boundary.
+  const workflowRunId = sameAttempt ? Number(sameAttempt.id) : Number.MAX_SAFE_INTEGER;
+  const newPoints = [...incoming.values()].map((point): CurvePoint => ({
+    identity: benchmarkPublicationIdentity(point),
+    image: point.image,
+    workflowRunId,
+    githubRunId: source.runId,
+    runAttempt: source.runAttempt,
+    date:
+      stored.find(
+        (existing) =>
+          existing.workflowRunId === workflowRunId &&
+          stablePowerPointIdentity(existing.identity) ===
+            stablePowerPointIdentity(benchmarkPublicationIdentity(point)),
+      )?.date ?? options.date,
+    runStartedAt: options.runStartedAt,
+    appendOnly: options.appendOnly,
+  }));
+  const touched = new Set(
+    [...newPoints, ...stored.filter((point) => point.githubRunId === source.runId)].map(scope),
+  );
+  const existing = stored.filter((point) => touched.has(scope(point)));
+  const maxAttempt = Math.max(source.runAttempt, ...attempts.map((row) => Number(row.run_attempt)));
+  const changedIds = new Set(newPoints.map((point) => stablePowerPointIdentity(point.identity)));
+  const proposed = existing
+    .filter(
+      (point) =>
+        point.githubRunId !== source.runId ||
+        (point.runAttempt === maxAttempt &&
+          (source.runAttempt !== maxAttempt ||
+            !changedIds.has(stablePowerPointIdentity(point.identity)))),
+    )
+    .map((point) =>
+      point.githubRunId === source.runId && point.runAttempt === source.runAttempt
+        ? { ...point, runStartedAt: options.runStartedAt, appendOnly: options.appendOnly }
+        : point,
+    );
+  if (source.runAttempt === maxAttempt) proposed.push(...newPoints);
+  assertCurvePreserved(existing, proposed, manifest.publication);
+}
diff --git a/packages/db/src/etl/required-power-publication.test.ts b/packages/db/src/etl/required-power-publication.test.ts
index b51b8e526..ec1822234 100644
--- a/packages/db/src/etl/required-power-publication.test.ts
+++ b/packages/db/src/etl/required-power-publication.test.ts
@@ -1,314 +1,200 @@
+import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
-import agenticMatrix from './__fixtures__/required-power-agentic-matrix.json';
 import {
   assertRequiredPowerPointsRetained,
   verifyRequiredPowerArtifacts,
-  verifyRequiredPowerPublication,
 } from './required-power-publication';
-import {
-  isBenchmarkPointPurged,
-  PURGED_BENCHMARK_POINTS,
-  type PurgedBenchmarkPoint,
-} from './run-overrides';
 
-// Ordinary planner output for Qwen3.5/H100 8K1K; fingerprints include the full recipe.
-const fingerprint = 'fa0645b4dec181eafda7472c891e90d9a5bf7bad7ee764aa0fdcc41ff841adf1';
-const source = { runId: 123, runAttempt: 2, headSha: 'abc123' };
-const required = {
-  'recipe-fingerprint': fingerprint,
-  conc: 1,
-  isl: 8192,
-  osl: 1024,
-  'require-power': true,
-};
-const row = {
-  infmax_model_prefix: 'qwen3.5',
-  hw: 'h100',
-  framework: 'sglang',
-  precision: 'fp8',
-  recipe_fingerprint: fingerprint,
-  conc: 1,
-  isl: 8192,
-  osl: 1024,
-  tp: 8,
-  ep: 1,
-  power_valid: 1,
-  power_metric_schema_version: 2,
-  avg_power_w: 500,
-  avg_total_gpu_power_w: 4000,
-  total_gpu_energy_j: 8000,
-  joules_per_output_token: 2,
-};
-const manifest = (entries = [required]) => ({
-  head: source.headSha,
-  'run-id': source.runId,
-  'run-attempt': source.runAttempt,
-  // full-sweep is a Klaud policy field: fail-fast runs may legitimately set it false.
-  'full-sweep': false,
-  matrix: {
-    single_node: { '8k1k': entries },
-    multi_node: {},
-    evals: [{ ...required, 'eval-only': true }],
-  },
-});
-const artifacts = (rows: unknown[] = [row]) => [{ path: 'bmk_qwen/agg.json', rows }];
+const golden = path.resolve(
+  import.meta.dirname,
+  '../../../../docs/fixtures/powerx-manifest-v2/artifacts',
+);
+const source = { runId: 123, runAttempt: 1, headSha: 'b'.repeat(40) };
 const dirs: string[] = [];
+function fixture() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-contract-'));
+  dirs.push(dir);
+  fs.cpSync(golden, dir, { recursive: true });
+  return dir;
+}
+function json(dir: string, file: string): any {
+  return JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+}
+function write(dir: string, file: string, value: unknown) {
+  fs.writeFileSync(path.join(dir, file), JSON.stringify(value));
+}
+const manifestPath = 'required-power-sweep-manifest/sweep_manifest.json';
+const benchmarkPath = 'bmk_agentic_golden/agg.json';
+const auditPath = 'agentic_golden/power_validation.json';
+function changeManifest(dir: string, edit: (manifest: any) => void) {
+  const manifest = json(dir, manifestPath);
+  edit(manifest);
+  write(dir, manifestPath, manifest);
+}
+function changeArtifact(dir: string, file: string, edit: (value: any) => void) {
+  const value = json(dir, file);
+  edit(value);
+  write(dir, file, value);
+  changeManifest(dir, (manifest) => {
+    for (const point of manifest.points)
+      for (const artifact of point.artifacts)
+        if (artifact.path === file)
+          artifact.sha256 = createHash('sha256')
+            .update(fs.readFileSync(path.join(dir, file)))
+            .digest('hex');
+  });
+}
+function multinodeFixture() {
+  const dir = fixture();
+  const extras: Record<string, unknown> = {
+    'power_audit_golden/power/samples.csv':
+      'timestamp_unix,hostname,gpu_uuid,power_w\n1700000000,prefill,GPU-p,200\n',
+    'power_audit_golden/power/manifest.json': { status: 'complete', publication_valid: true },
+    'power_audit_golden/power/windows/point.json': {
+      benchmark_start_time_unix: 1700000000,
+      benchmark_end_time_unix: 1700000002,
+    },
+  };
+  for (const [file, value] of Object.entries(extras)) {
+    fs.mkdirSync(path.dirname(path.join(dir, file)), { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, file),
+      typeof value === 'string' ? value : JSON.stringify(value),
+    );
+  }
+  changeArtifact(dir, benchmarkPath, (row) =>
+    Object.assign(row, {
+      disagg: true,
+      is_multinode: true,
+      num_gpus: 2,
+      num_prefill_gpu: 1,
+      num_decode_gpu: 1,
+      prefill_gpu_energy_j: 400,
+      decode_gpu_energy_j: 600,
+      prefill_joules_per_input_token: 1,
+      decode_joules_per_output_token: 1,
+    }),
+  );
+  changeArtifact(dir, auditPath, (audit) =>
+    Object.assign(audit, {
+      expected_gpu_count: 2,
+      observed_gpu_count: 2,
+      per_gpu_energy_j: { 'prefill/GPU-p': 400, 'decode/GPU-d': 600 },
+      per_gpu_role: { 'prefill/GPU-p': 'prefill', 'decode/GPU-d': 'decode' },
+    }),
+  );
+  changeManifest(dir, (manifest) => {
+    const entry = manifest.matrix.single_node.agentic[0];
+    Object.assign(entry, { disagg: true, 'num-gpus': 2, 'node-count': 2 });
+    manifest.matrix = { single_node: {}, multi_node: { agentic: [entry] } };
+    const point = manifest.points[0];
+    Object.assign(point.topology, {
+      disagg: true,
+      is_multinode: true,
+      num_gpus: 2,
+      num_prefill_gpu: 1,
+      num_decode_gpu: 1,
+    });
+    point.devices = [
+      { node: 'prefill', gpu_uuid: 'GPU-p', role: 'prefill', energy_j: 400 },
+      { node: 'decode', gpu_uuid: 'GPU-d', role: 'decode', energy_j: 600 },
+    ];
+    for (const file of Object.keys(extras))
+      point.artifacts.push({
+        path: file,
+        sha256: createHash('sha256')
+          .update(fs.readFileSync(path.join(dir, file)))
+          .digest('hex'),
+        validation_state: 'valid',
+      });
+  });
+  return dir;
+}
 afterEach(() => {
   for (const dir of dirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
 });
 
-describe('required power publication preflight', () => {
-  it('matches the canonical AgentX users value instead of a conflicting raw conc', () => {
-    const scope = {
-      ...manifest(),
-      matrix: { single_node: { agentic: [required] }, multi_node: {} },
-    };
-    const conflicting = { ...row, scenario_type: 'agentic-coding', conc: 1, users: 2 };
-    expect(() => verifyRequiredPowerPublication(scope, artifacts([conflicting]), source)).toThrow(
-      'missing benchmark point',
-    );
-    expect(
-      verifyRequiredPowerPublication(
-        scope,
-        artifacts([{ ...conflicting, conc: 2, users: 1 }]),
-        source,
-      ),
-    ).toHaveLength(1);
+describe('required power publication contract', () => {
+  it('fails missing required manifests even when changelog metadata is also missing', () => {
+    const dir = fixture();
+    fs.rmSync(path.join(dir, 'required-power-sweep-manifest'), { recursive: true });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('sweep manifest missing');
+    fs.rmSync(path.join(dir, 'changelog-metadata'), { recursive: true });
+    expect(() => verifyRequiredPowerArtifacts(dir, source, true)).toThrow('sweep manifest missing');
+    expect(verifyRequiredPowerArtifacts(dir, source)).toEqual([]);
   });
-
-  it('accepts exact ordinary source points, including fail-fast manifests and identical aggregate copies', () => {
-    expect(
-      verifyRequiredPowerPublication(
-        manifest(),
-        [...artifacts(), { path: 'results_bmk/agg_bmk.json', rows: [{ ...row }] }],
-        source,
-      ),
-    ).toHaveLength(1);
+  it('rejects hash mismatches and explicit invalid evidence', () => {
+    const dir = fixture();
+    fs.appendFileSync(path.join(dir, 'agentic_golden/gpu_metrics.csv'), '\n');
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('hash');
+    const invalid = fixture();
+    changeManifest(invalid, (manifest) => {
+      manifest.points[0].artifacts[0].validation_state = 'invalid';
+    });
+    expect(() => verifyRequiredPowerArtifacts(invalid, source)).toThrow('validation');
   });
-
-  it('fails required coverage after a point purge even when an optional point is retained', () => {
-    const requiredPoints = verifyRequiredPowerPublication(manifest(), artifacts(), source);
-    const candidates = [requiredPoints[0], { ...requiredPoints[0], conc: 2 }];
-    const purged: PurgedBenchmarkPoint = {
-      githubRunId: source.runId,
-      runAttempt: source.runAttempt,
-      configId: 999999,
-      benchmarkType: 'single_turn',
-      isl: 8192,
-      osl: 1024,
-      conc: 1,
-      offloadMode: 'off',
-      recipeFingerprint: fingerprint,
-    };
-    const registry = PURGED_BENCHMARK_POINTS as PurgedBenchmarkPoint[];
-    registry.push(purged);
-    try {
-      const retained = candidates.filter(
-        (point) =>
-          !isBenchmarkPointPurged(source.runId, source.runAttempt, {
-            ...point,
-            configId: purged.configId,
-          }),
-      );
-      expect(retained.map((point) => point.conc)).toEqual([2]);
-      expect(() => assertRequiredPowerPointsRetained(requiredPoints, retained)).toThrow(
-        'missing benchmark point after ingest',
-      );
-      expect(isBenchmarkPointPurged(source.runId, source.runAttempt, purged)).toBe(true);
-      expect(() => assertRequiredPowerPointsRetained([], retained)).not.toThrow();
-    } finally {
-      registry.splice(registry.indexOf(purged), 1);
-    }
-  });
-
-  it('accepts retained aggregate copies but cannot replace a filtered required point with another identity', () => {
-    const requiredPoints = verifyRequiredPowerPublication(manifest(), artifacts(), source);
-    expect(() =>
-      assertRequiredPowerPointsRetained(requiredPoints, [
-        requiredPoints[0],
-        { ...requiredPoints[0] },
-      ]),
-    ).not.toThrow();
-    expect(() =>
-      assertRequiredPowerPointsRetained(requiredPoints, [
-        { ...requiredPoints[0], recipeFingerprint: 'other-recipe' },
-      ]),
-    ).toThrow('missing benchmark point after ingest');
-  });
-
-  it('fails before ingestion when any declared concurrency, fingerprint or scenario is missing', () => {
-    for (const candidate of [
-      [],
-      [{ ...row, conc: 2 }],
-      [{ ...row, recipe_fingerprint: '' }],
-      [{ ...row, isl: 1024 }],
-    ]) {
-      expect(() =>
-        verifyRequiredPowerPublication(manifest(), artifacts(candidate), source),
-      ).toThrow('missing benchmark point');
-    }
-  });
-
-  it('does not retroactively require optional matrix points or legacy results', () => {
-    const scope = manifest([required, { ...required, conc: 2, 'require-power': false }]);
-    expect(
-      verifyRequiredPowerPublication(scope, artifacts([row, { conc: 2, power_valid: 0 }]), source),
-    ).toHaveLength(1);
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'required-power-'));
-    dirs.push(dir);
-    expect(verifyRequiredPowerArtifacts(dir, { ...source, headSha: null })).toHaveLength(0);
+  it('rejects a measured zero energy', () => {
+    const dir = fixture();
+    changeArtifact(dir, benchmarkPath, (rows) => {
+      rows.total_gpu_energy_j = 0;
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow(
+      'total_gpu_energy_j must be finite and positive',
+    );
   });
-
-  it.each([
-    { power_valid: 0 },
-    { power_valid: '1' },
-    { power_metric_schema_version: '2' },
-    { avg_power_w: 0 },
-    { avg_total_gpu_power_w: -1 },
-    { total_gpu_energy_j: NaN },
-    { joules_per_output_token: Infinity },
-    { joules_per_output_token: undefined },
-    { benchmark_outcome: { status: 'failed' } },
-  ])('rejects invalid required measurements: %j', (change) => {
-    expect(() =>
-      verifyRequiredPowerPublication(manifest(), artifacts([{ ...row, ...change }]), source),
-    ).toThrow('Required power:');
+  it('does not replace canonical AgentX users with a conflicting raw conc', () => {
+    const dir = fixture();
+    changeArtifact(dir, benchmarkPath, (rows) => {
+      rows.conc = 1;
+      rows.users = 2;
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing benchmark point');
   });
-
-  it('rejects conflicting copies and duplicate rows inside either source or aggregate file', () => {
-    expect(() =>
-      verifyRequiredPowerPublication(
-        manifest(),
-        [...artifacts(), { path: 'results_bmk/agg.json', rows: [{ ...row, avg_power_w: 501 }] }],
-        source,
-      ),
-    ).toThrow('conflicting');
-    expect(() => verifyRequiredPowerPublication(manifest(), artifacts([row, row]), source)).toThrow(
-      'duplicate',
+  it('requires both prefill and decode physical evidence and matching role energy', () => {
+    const dir = multinodeFixture();
+    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
+    changeManifest(dir, (manifest) => {
+      manifest.points[0].devices.pop();
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing physical GPU');
+    const mismatched = multinodeFixture();
+    changeArtifact(mismatched, benchmarkPath, (row) => {
+      row.prefill_gpu_energy_j = 100;
+    });
+    expect(() => verifyRequiredPowerArtifacts(mismatched, source)).toThrow(
+      'prefill energy differs',
     );
-    expect(() =>
-      verifyRequiredPowerPublication(
-        manifest(),
-        [...artifacts(), { path: 'results_bmk/agg.json', rows: [row, row] }],
-        source,
-      ),
-    ).toThrow('duplicate');
   });
-
-  it('rejects stale source run, attempt or head, an empty scope, and duplicate planned points', () => {
-    for (const changed of [
-      { runId: 999 },
-      { runAttempt: 1 },
-      { headSha: 'stale' },
-      { headSha: null },
-    ])
-      expect(() =>
-        verifyRequiredPowerPublication(manifest(), artifacts(), { ...source, ...changed }),
-      ).toThrow('manifest source');
-    expect(() => verifyRequiredPowerPublication(manifest([]), [], source)).toThrow('no required');
-    expect(() =>
-      verifyRequiredPowerPublication(manifest([required, required]), artifacts(), source),
-    ).toThrow('duplicate matrix');
+  it('rejects invalid sidecar verdict and device energy disagreement despite valid hashes', () => {
+    const dir = fixture();
+    changeArtifact(dir, auditPath, (audit) => {
+      audit.power_valid = false;
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('invalid audit');
+    const other = fixture();
+    changeManifest(other, (manifest) => {
+      manifest.points[0].devices[0].energy_j = 2;
+    });
+    expect(() => verifyRequiredPowerArtifacts(other, source)).toThrow('differs from audit');
   });
-
-  it('reuses the declared scope from a successful earlier attempt of the same run and head', () => {
-    expect(
-      verifyRequiredPowerPublication({ ...manifest(), 'run-attempt': 1 }, artifacts(), source),
-    ).toHaveLength(1);
-  });
-
-  it('expands real ordinary AgentX planner concurrency arrays and fixed-sequence batches', () => {
-    // First B200 recipe from the ordinary Kimi K3 required-power planner, 2026-09-13.
-    const entry = agenticMatrix.multi_node.agentic[0];
-    expect(
-      verifyRequiredPowerPublication(
-        { ...manifest(), matrix: agenticMatrix },
-        artifacts([
-          {
-            ...row,
-            infmax_model_prefix: 'kimik3',
-            hw: 'b200',
-            framework: 'dynamo-vllm',
-            precision: 'fp4',
-            recipe_fingerprint: entry['recipe-fingerprint'],
-            conc: entry.conc[0],
-            scenario_type: 'agentic-coding',
-          },
-        ]),
-        source,
-      ),
-    ).toHaveLength(1);
-    const fixedMatrix = {
-      single_node: {},
-      multi_node: { '8k1k': [{ ...required, conc: [1, 2, 4] }] },
-    };
-    expect(
-      verifyRequiredPowerPublication(
-        { ...manifest(), matrix: fixedMatrix },
-        artifacts([1, 2, 4].map((conc) => ({ ...row, conc }))),
-        source,
-      ),
-    ).toHaveLength(3);
-    expect(() =>
-      verifyRequiredPowerPublication({ ...manifest(), matrix: fixedMatrix }, artifacts(), source),
-    ).toThrow('missing benchmark');
+  it('accepts identical aggregate copies but rejects conflicting duplicate rows', () => {
+    const dir = fixture();
+    fs.mkdirSync(path.join(dir, 'results_bmk'));
+    fs.copyFileSync(path.join(dir, benchmarkPath), path.join(dir, 'results_bmk/agg.json'));
+    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
+    const rows = json(dir, benchmarkPath);
+    rows.avg_power_w = 501;
+    write(dir, 'results_bmk/agg.json', rows);
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('conflicting');
   });
-
-  it('accepts AgentX and requires both energy roles only for a declared disaggregated recipe', () => {
-    const scope = manifest();
-    const agentic = { ...required, 'scenario-type': 'agentic-coding', disagg: true };
-    const agenticManifest = {
-      ...scope,
-      matrix: { single_node: {}, multi_node: { agentic: [agentic] } },
-    };
-    const split = {
-      ...row,
-      isl: undefined,
-      osl: undefined,
-      scenario_type: 'agentic-coding',
-      disagg: true,
-      prefill_gpu_energy_j: 3000,
-      decode_gpu_energy_j: 5000,
-      prefill_joules_per_input_token: 1,
-      decode_joules_per_output_token: 1.25,
-    };
-    expect(
-      verifyRequiredPowerPublication(agenticManifest, artifacts([split]), source),
-    ).toHaveLength(1);
+  it('retains every required identity after local purges and backfills', () => {
+    const required = verifyRequiredPowerArtifacts(golden, source);
     expect(() =>
-      verifyRequiredPowerPublication(
-        agenticManifest,
-        artifacts([{ ...split, decode_gpu_energy_j: undefined }]),
-        source,
-      ),
-    ).toThrow('decode_gpu_energy_j');
-    const aggregate = {
-      ...agenticManifest,
-      matrix: { single_node: {}, multi_node: { agentic: [{ ...agentic, disagg: false }] } },
-    };
-    expect(
-      verifyRequiredPowerPublication(
-        aggregate,
-        artifacts([{ ...row, scenario_type: 'agentic-coding' }]),
-        source,
-      ),
-    ).toHaveLength(1);
-  });
-
-  it('reads the producer artifact and checks all rows before the ingest entry point writes', () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'required-power-'));
-    dirs.push(dir);
-    fs.mkdirSync(path.join(dir, 'required-power-sweep-manifest'));
-    fs.writeFileSync(
-      path.join(dir, 'required-power-sweep-manifest', 'sweep_manifest.json'),
-      JSON.stringify(manifest()),
-    );
-    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing benchmark');
-    fs.mkdirSync(path.join(dir, 'bmk_qwen'));
-    fs.writeFileSync(path.join(dir, 'bmk_qwen', 'agg.json'), JSON.stringify(row));
-    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
+      assertRequiredPowerPointsRetained(required, [{ ...required[0], conc: 2 }]),
+    ).toThrow('missing benchmark point');
+    expect(() => assertRequiredPowerPointsRetained(required, required)).not.toThrow();
   });
 });
diff --git a/packages/db/src/etl/required-power-publication.ts b/packages/db/src/etl/required-power-publication.ts
index 170b3e926..d8f995b8a 100644
--- a/packages/db/src/etl/required-power-publication.ts
+++ b/packages/db/src/etl/required-power-publication.ts
@@ -1,9 +1,11 @@
 import fs from 'node:fs';
+import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { mapBenchmarkRow, type BenchmarkParams } from './benchmark-mapper';
 import { createSkipTracker } from './skip-tracker';
-import { REQUIRED_POWER_MANIFEST } from '../lib/ci-artifact-preparation';
+import { configCacheKey } from './config-cache';
+import { CHANGELOG_ARTIFACT_NAME, REQUIRED_POWER_MANIFEST } from '../lib/ci-artifact-preparation';
 
 type JsonRow = Record<string, unknown>;
 export interface RequiredPowerSource {
@@ -14,6 +16,7 @@ export interface RequiredPowerSource {
 export interface BenchmarkArtifactRows {
   path: string;
   rows: unknown[];
+  contents?: Buffer | string;
 }
 
 function object(value: unknown, label: string): JsonRow {
@@ -45,11 +48,24 @@ export function assertRequiredPowerPointsRetained(
   required: readonly BenchmarkParams[],
   retained: readonly BenchmarkParams[],
 ): void {
-  const present = new Set(retained.map(mappedIdentity));
+  const retainedIdentity = (row: BenchmarkParams) =>
+    JSON.stringify([configCacheKey(row.config), row.offloadMode, mappedIdentity(row)]);
+  const present = new Map(retained.map((row) => [retainedIdentity(row), row]));
   for (const row of required) {
-    const key = mappedIdentity(row);
+    const key = retainedIdentity(row);
     if (!present.has(key))
       throw new Error(`Required power: missing benchmark point after ingest ${key}`);
+    const actual = present.get(key)!;
+    for (const field of [
+      'power_valid',
+      'power_metric_schema_version',
+      'avg_power_w',
+      'avg_total_gpu_power_w',
+      'total_gpu_energy_j',
+      'joules_per_output_token',
+    ])
+      if (actual.metrics[field] !== row.metrics[field])
+        throw new Error(`Required power: ${field} changed before ingest for ${key}`);
   }
 }
 
@@ -60,20 +76,52 @@ export function verifyRequiredPowerPublication(
   source: RequiredPowerSource,
 ): BenchmarkParams[] {
   const manifest = object(manifestValue, 'sweep manifest');
+  if (manifest['schema-version'] !== 2)
+    throw new Error('Required power: incompatible manifest schema-version (expected 2)');
+  const publication = object(manifest.publication, 'publication policy');
+  if (
+    !['incremental', 'replacement'].includes(String(publication.mode)) ||
+    !Array.isArray(publication.replacement_scope) ||
+    (publication.mode === 'incremental' && publication.replacement_scope.length > 0)
+  )
+    throw new Error('Required power: invalid publication policy');
+  const replacementScopes = new Set<string>();
+  for (const value of publication.replacement_scope) {
+    const replacement = object(value, 'exact replacement scope');
+    if (
+      typeof replacement.curve_scope !== 'string' ||
+      !replacement.curve_scope ||
+      replacementScopes.has(replacement.curve_scope) ||
+      !Number.isSafeInteger(replacement.previous_snapshot_workflow_run_id) ||
+      Number(replacement.previous_snapshot_workflow_run_id) <= 0 ||
+      !Array.isArray(replacement.removed_point_identities) ||
+      replacement.removed_point_identities.length === 0 ||
+      replacement.removed_point_identities.some((id) => typeof id !== 'string' || !id) ||
+      new Set(replacement.removed_point_identities).size !==
+        replacement.removed_point_identities.length
+    )
+      throw new Error('Required power: invalid exact replacement scope');
+    replacementScopes.add(replacement.curve_scope);
+  }
   const declaredAttempt = manifest['run-attempt'];
   if (
     manifest['run-id'] !== source.runId ||
+    !Number.isSafeInteger(source.runId) ||
+    source.runId <= 0 ||
+    !Number.isSafeInteger(source.runAttempt) ||
+    source.runAttempt <= 0 ||
     typeof declaredAttempt !== 'number' ||
     !Number.isSafeInteger(declaredAttempt) ||
     declaredAttempt <= 0 ||
     declaredAttempt > source.runAttempt ||
     !source.headSha ||
+    !/^[a-f0-9]{40}$/u.test(source.headSha) ||
     manifest.head !== source.headSha
   )
     throw new Error('Required power: manifest source run, attempt or head does not match');
 
   const matrix = object(manifest.matrix, 'sweep matrix');
-  const expected = new Map<string, boolean>();
+  const expected = new Map<string, JsonRow>();
   for (const topology of ['single_node', 'multi_node']) {
     const buckets = object(matrix[topology], topology);
     for (const [scenario, entries] of Object.entries(buckets)) {
@@ -99,7 +147,7 @@ export function verifyRequiredPowerPublication(
             osl,
           );
           if (expected.has(key)) throw new Error(`Required power: duplicate matrix point ${key}`);
-          expected.set(key, row.disagg === true);
+          expected.set(key, { ...row, matrixTopology: topology });
         }
       }
     }
@@ -140,7 +188,7 @@ export function verifyRequiredPowerPublication(
         'total_gpu_energy_j',
         'joules_per_output_token',
       ];
-      if (expected.get(key))
+      if (expected.get(key)?.disagg === true)
         fields.push(
           'prefill_gpu_energy_j',
           'decode_gpu_energy_j',
@@ -158,6 +206,7 @@ export function verifyRequiredPowerPublication(
   for (const key of expected.keys()) {
     if (!seen.has(key)) throw new Error(`Required power: missing benchmark point ${key}`);
   }
+  verifyPointEvidence(manifest, expected, seen, artifacts);
   return [...seen.values()].map(({ point }) => point);
 }
 
@@ -165,9 +214,21 @@ export function verifyRequiredPowerPublication(
 export function verifyRequiredPowerArtifacts(
   root: string,
   source: RequiredPowerSource,
+  required = false,
 ): BenchmarkParams[] {
   const manifestDir = path.join(root, REQUIRED_POWER_MANIFEST);
-  if (!fs.existsSync(manifestDir)) return [];
+  if (!fs.existsSync(manifestDir)) {
+    if (required) throw new Error('Required power: sweep manifest missing for required dispatch');
+    const metadataDir = path.join(root, CHANGELOG_ARTIFACT_NAME);
+    if (fs.existsSync(metadataDir)) {
+      for (const name of fs.readdirSync(metadataDir).filter((file) => file.endsWith('.json'))) {
+        const metadata = JSON.parse(fs.readFileSync(path.join(metadataDir, name), 'utf8'));
+        if (metadata?.['require-power'] === true)
+          throw new Error('Required power: sweep manifest missing for required changelog scope');
+      }
+    }
+    return [];
+  }
   const manifest = JSON.parse(
     fs.readFileSync(path.join(manifestDir, 'sweep_manifest.json'), 'utf8'),
   );
@@ -178,8 +239,28 @@ export function verifyRequiredPowerArtifacts(
     if (!fs.statSync(dir).isDirectory()) continue;
     for (const file of fs.readdirSync(dir)) {
       if (!file.endsWith('.json')) continue;
-      const data = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
-      artifacts.push({ path: path.join(name, file), rows: Array.isArray(data) ? data : [data] });
+      const contents = fs.readFileSync(path.join(dir, file));
+      const data = JSON.parse(contents.toString('utf8'));
+      artifacts.push({
+        path: path.join(name, file),
+        rows: Array.isArray(data) ? data : [data],
+        contents,
+      });
+    }
+  }
+  for (const pointValue of Array.isArray(manifest.points) ? manifest.points : []) {
+    const point = object(pointValue, 'point');
+    if (!Array.isArray(point.artifacts)) throw new Error('Required power: missing point artifacts');
+    for (const value of point.artifacts) {
+      const artifact = object(value, 'artifact');
+      const relative = safeArtifactPath(artifact.path);
+      const file = path.join(root, relative);
+      if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+        throw new Error(`Required power: missing required artifact ${relative}`);
+      if (!fs.realpathSync(file).startsWith(`${fs.realpathSync(root)}${path.sep}`))
+        throw new Error(`Required power: artifact escapes bundle ${relative}`);
+      if (!artifacts.some((item) => item.path === relative))
+        artifacts.push({ path: relative, rows: [], contents: fs.readFileSync(file) });
     }
   }
   const points = verifyRequiredPowerPublication(manifest, artifacts, source);
@@ -189,3 +270,424 @@ export function verifyRequiredPowerArtifacts(
   );
   return points;
 }
+
+function digest(artifact: BenchmarkArtifactRows): string {
+  return createHash('sha256').update(artifact.contents!).digest('hex');
+}
+
+function safeArtifactPath(value: unknown): string {
+  if (
+    typeof value !== 'string' ||
+    !value ||
+    value.includes('\\') ||
+    path.posix.isAbsolute(value) ||
+    value.split('/').some((part) => !part || part === '.' || part === '..')
+  )
+    throw new Error('Required power: invalid artifact path');
+  return value;
+}
+
+function positive(value: unknown, label: string): number {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+    throw new Error(`Required power: ${label} must be finite and positive`);
+  return value;
+}
+
+function nonempty(value: unknown, label: string): string {
+  if (typeof value !== 'string' || !value.trim())
+    throw new Error(`Required power: missing ${label}`);
+  return value;
+}
+
+function verifyPointEvidence(
+  manifest: JsonRow,
+  expected: Map<string, JsonRow>,
+  seen: Map<string, { row: JsonRow; path: string; point: BenchmarkParams }>,
+  artifacts: readonly BenchmarkArtifactRows[],
+): void {
+  if (!Array.isArray(manifest.points) || manifest.points.length !== expected.size)
+    throw new Error('Required power: point manifest does not cover the exact required matrix');
+  const verified = new Set<string>();
+  const files = new Map(artifacts.map((artifact) => [artifact.path, artifact]));
+  for (const declaredValue of manifest.points) {
+    const declared = object(declaredValue, 'point');
+    const id = object(declared.identity, 'point identity');
+    const key = identity(
+      id.recipe_fingerprint,
+      id.concurrency,
+      String(id.benchmark_type),
+      id.isl,
+      id.osl,
+    );
+    const matched = seen.get(key);
+    const matrix = expected.get(key);
+    if (!matched || !matrix || verified.has(key))
+      throw new Error(`Required power: unexpected or duplicate manifest point ${key}`);
+    verified.add(key);
+    if (nonempty(declared.config_key, 'config_key') !== matrix['exp-name'])
+      throw new Error(`Required power: config_key differs from required matrix for ${key}`);
+    const { row, point } = matched;
+    for (const [field, rawField] of [
+      ['model', 'infmax_model_prefix'],
+      ['hardware', 'hw'],
+      ['framework', 'framework'],
+      ['precision', 'precision'],
+    ]) {
+      if (
+        nonempty(id[field], field) !==
+        (row[rawField] ?? (field === 'model' ? row.model : undefined))
+      )
+        throw new Error(`Required power: ${field} identity differs from benchmark for ${key}`);
+    }
+    for (const [field, matrixField] of [
+      ['model', 'model-prefix'],
+      ['hardware', 'runner'],
+      ['framework', 'framework'],
+      ['precision', 'precision'],
+    ]) {
+      if (id[field] !== matrix[matrixField])
+        throw new Error(
+          `Required power: ${field} identity differs from required matrix for ${key}`,
+        );
+    }
+    const topology = object(declared.topology, 'point topology');
+    if (
+      topology.disagg !== point.config.disagg ||
+      topology.is_multinode !== point.config.isMultinode ||
+      topology.disagg !== (matrix.disagg === true) ||
+      topology.is_multinode !== (matrix.matrixTopology === 'multi_node')
+    )
+      throw new Error(`Required power: topology differs from benchmark or matrix for ${key}`);
+    const rawGpuCount =
+      row.num_gpus ??
+      (topology.is_multinode
+        ? Number(row.num_prefill_gpu) + Number(row.num_decode_gpu)
+        : Number(row.tp) * Number(row.pp ?? 1) * Number(row.pcp_size ?? 1));
+    if (topology.num_gpus !== rawGpuCount)
+      throw new Error(`Required power: num_gpus topology differs from benchmark for ${key}`);
+    const topologyFields = [
+      'num_prefill_gpu',
+      'num_decode_gpu',
+      'tp',
+      'ep',
+      'dp_attention',
+      'prefill_tp',
+      'prefill_ep',
+      'prefill_num_workers',
+      'decode_tp',
+      'decode_ep',
+      'decode_num_workers',
+      'pp',
+      'pcp_size',
+      'dcp_size',
+      'prefill_pp',
+      'decode_pp',
+      'prefill_pcp_size',
+      'decode_pcp_size',
+      'prefill_dcp_size',
+      'decode_dcp_size',
+      'prefill_dp_attention',
+      'decode_dp_attention',
+    ];
+    for (const field of topologyFields) {
+      if (topology[field] !== row[field])
+        throw new Error(`Required power: ${field} topology differs from benchmark for ${key}`);
+      const role = field.startsWith('prefill_')
+        ? 'prefill'
+        : field.startsWith('decode_')
+          ? 'decode'
+          : null;
+      const roleField = role ? field.slice(role.length + 1) : field;
+      const matrixField =
+        roleField === 'num_workers'
+          ? 'num-worker'
+          : roleField === 'dp_attention'
+            ? 'dp-attn'
+            : roleField.replaceAll('_', '-');
+      let planned = role
+        ? matrix[role]
+          ? object(matrix[role], `${role} matrix`)[matrixField]
+          : matrix[field.replaceAll('_', '-')]
+        : matrix[matrixField];
+      if (
+        role === 'decode' &&
+        matrix.decode &&
+        object(matrix.decode, 'decode matrix')['num-worker'] === 0 &&
+        ['tp', 'ep', 'pp', 'pcp_size', 'dcp_size'].includes(roleField)
+      )
+        planned = ['tp', 'ep'].includes(roleField) ? 0 : 1;
+      let actual =
+        topology[field] ??
+        (['pp', 'pcp_size', 'dcp_size'].includes(roleField)
+          ? 1
+          : roleField === 'dp_attention'
+            ? false
+            : undefined);
+      if (roleField === 'dp_attention' && typeof actual === 'string') actual = actual === 'true';
+      const normalizedPlanned =
+        roleField === 'dp_attention' && typeof planned === 'string' ? planned === 'true' : planned;
+      if (planned !== undefined && actual !== normalizedPlanned)
+        throw new Error(
+          `Required power: ${field} topology differs from required matrix for ${key}`,
+        );
+    }
+    let plannedGpuCount = matrix['num-gpus'];
+    if (matrix.prefill && matrix.decode) {
+      plannedGpuCount = 0;
+      for (const role of ['prefill', 'decode']) {
+        const planned = object(matrix[role], `${role} matrix`);
+        const count =
+          Number(planned.tp) *
+          Number(planned.pp ?? 1) *
+          Number(planned['pcp-size'] ?? 1) *
+          Number(planned['num-worker']);
+        if (count !== topology[`num_${role}_gpu`])
+          throw new Error(
+            `Required power: ${role} GPU count differs from required matrix for ${key}`,
+          );
+        plannedGpuCount = Number(plannedGpuCount) + count;
+      }
+    } else if (plannedGpuCount === undefined && matrix.tp !== undefined) {
+      plannedGpuCount =
+        Number(matrix.tp) * Number(matrix.pp ?? 1) * Number(matrix['pcp-size'] ?? 1);
+    }
+    if (plannedGpuCount !== undefined && plannedGpuCount !== topology.num_gpus)
+      throw new Error(`Required power: physical GPU count differs from required matrix for ${key}`);
+    const expectedCount = positive(topology.num_gpus, 'topology num_gpus');
+    if (!Number.isSafeInteger(expectedCount))
+      throw new Error('Required power: invalid physical GPU count');
+    const window = object(declared.measurement_window, 'measurement window');
+    const start = positive(window.start_time_unix, 'window start');
+    const end = positive(window.end_time_unix, 'window end');
+    if (end <= start) throw new Error('Required power: invalid measurement window boundaries');
+    if (!Array.isArray(declared.artifacts) || declared.artifacts.length === 0)
+      throw new Error('Required power: missing required artifacts');
+    const evidence = new Map<string, BenchmarkArtifactRows>();
+    for (const value of declared.artifacts) {
+      const artifact = object(value, 'required artifact');
+      const relative = safeArtifactPath(artifact.path);
+      if (evidence.has(relative))
+        throw new Error(`Required power: duplicate required artifact ${relative}`);
+      const file = files.get(relative);
+      if (!file || file.contents === undefined || file.contents.length === 0)
+        throw new Error(`Required power: missing required artifact ${relative}`);
+      if (
+        artifact.validation_state !== 'valid' ||
+        typeof artifact.sha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(artifact.sha256) ||
+        createHash('sha256').update(file.contents).digest('hex') !== artifact.sha256
+      )
+        throw new Error(`Required power: invalid artifact validation or hash ${relative}`);
+      evidence.set(relative, file);
+    }
+    if (
+      ![...evidence.values()].some((file) =>
+        file.rows.some((candidate) => isDeepStrictEqual(candidate, row)),
+      )
+    )
+      throw new Error(`Required power: benchmark artifact is not hash-bound for ${key}`);
+    const byName = (name: string): BenchmarkArtifactRows => {
+      const matches = [...evidence.values()].filter(
+        (file) => path.posix.basename(file.path) === name,
+      );
+      if (matches.length !== 1)
+        throw new Error(`Required power: expected one required ${name} artifact`);
+      return matches[0];
+    };
+    const sidecars = [...evidence.values()].filter((file) =>
+      /^power_validation.*\.json$/u.test(path.posix.basename(file.path)),
+    );
+    if (sidecars.length !== 1)
+      throw new Error('Required power: expected one required power validation artifact');
+    const audit = object(JSON.parse(sidecars[0].contents!.toString()), 'power validation');
+    const auditWindow = object(audit.benchmark_window, 'audit benchmark window');
+    if (
+      audit.power_valid !== true ||
+      auditWindow.start_time_unix !== start ||
+      auditWindow.end_time_unix !== end ||
+      audit.expected_gpu_count !== expectedCount ||
+      audit.observed_gpu_count !== expectedCount
+    )
+      throw new Error(
+        `Required power: invalid audit verdict, window or physical GPU coverage for ${key}`,
+      );
+    if (topology.is_multinode && audit.telemetry_kind === 'native_multinode_smi') {
+      if (!Array.isArray(audit.nodes) || audit.nodes.length === 0)
+        throw new Error('Required power: missing native node receipts');
+      const traces = [...evidence.values()].filter(
+        (file) => path.posix.basename(file.path) === 'gpu_metrics.csv',
+      );
+      if (traces.length !== audit.nodes.length)
+        throw new Error('Required power: missing native node telemetry');
+      for (const file of traces) {
+        const directory = path.posix.dirname(file.path);
+        const manifestFile = evidence.get(`${directory}/manifest.json`);
+        if (!manifestFile) throw new Error('Required power: missing native node manifest');
+        const nodeManifest = object(
+          JSON.parse(manifestFile.contents!.toString()),
+          'native node manifest',
+        );
+        if (nodeManifest.lifecycle !== 'complete' || nodeManifest.collector_exit_code !== 0)
+          throw new Error('Required power: invalid native node collection');
+        const receipt = (audit.nodes as JsonRow[]).find((node) => node.node === nodeManifest.node);
+        if (
+          !receipt ||
+          receipt.manifest_sha256 !== digest(manifestFile) ||
+          receipt.telemetry_sha256 !== digest(file)
+        )
+          throw new Error('Required power: native node receipt differs from evidence');
+        for (const hash of [receipt.identity_sha256, receipt.identity_end_sha256])
+          if (
+            ![...evidence.values()].some(
+              (item) => path.posix.dirname(item.path) === directory && digest(item) === hash,
+            )
+          )
+            throw new Error('Required power: missing native physical identity evidence');
+      }
+    } else if (topology.is_multinode) {
+      byName('samples.csv');
+      byName('manifest.json');
+      if (
+        ![...evidence.keys()].some((file) => file.includes('/windows/') && file.endsWith('.json'))
+      )
+        throw new Error('Required power: missing central measurement window artifact');
+    } else byName('gpu_metrics.csv');
+    const energies = object(audit.per_gpu_energy_j, 'audit device energy');
+    let auditDevices: JsonRow[];
+    if (audit.per_gpu_role === undefined) {
+      const nodeFiles = [...evidence.values()].filter((file) =>
+        ['power_node.txt', 'gpu_metrics_node.txt'].includes(path.posix.basename(file.path)),
+      );
+      if (nodeFiles.length !== 1)
+        throw new Error('Required power: expected one node identity artifact');
+      const node = nodeFiles[0].contents!.toString().trim();
+      const identityFiles = [...evidence.values()].filter((file) =>
+        /^(?:gpu_metrics_identity\.csv|gpu_metrics_devices\.json)$/u.test(
+          path.posix.basename(file.path),
+        ),
+      );
+      if (identityFiles.length !== 1)
+        throw new Error('Required power: expected one physical GPU identity artifact');
+      const uuidRows: [string, string][] = [];
+      if (identityFiles[0].path.endsWith('.csv')) {
+        const lines = identityFiles[0].contents!.toString().trim().split(/\r?\n/u);
+        const columns = lines
+          .shift()!
+          .split(',')
+          .map((part) => part.trim().replaceAll('"', '').toLowerCase());
+        const indexColumn = columns.indexOf('index');
+        const uuidColumn = columns.indexOf('uuid');
+        if (indexColumn === -1 || uuidColumn === -1)
+          throw new Error('Required power: invalid physical GPU identity CSV');
+        for (const line of lines) {
+          const fields = line.split(',').map((part) => part.trim().replaceAll('"', ''));
+          uuidRows.push([fields[indexColumn], fields[uuidColumn]]);
+        }
+      } else {
+        const visit = (value: unknown): void => {
+          if (Array.isArray(value)) value.forEach(visit);
+          else if (value && typeof value === 'object') {
+            const deviceRow = Object.fromEntries(
+              Object.entries(value).map(([field, item]) => [field.toLowerCase(), item]),
+            );
+            if ('gpu' in deviceRow && 'uuid' in deviceRow)
+              uuidRows.push([String(deviceRow.gpu), String(deviceRow.uuid)]);
+            else Object.values(value).forEach(visit);
+          }
+        };
+        visit(JSON.parse(identityFiles[0].contents!.toString()));
+      }
+      if (
+        uuidRows.length === 0 ||
+        uuidRows.some(
+          ([index, uuid]) =>
+            !/^\d+$/u.test(index) || !uuid || ['n/a', 'none', 'null'].includes(uuid.toLowerCase()),
+        ) ||
+        new Set(uuidRows.map(([index]) => index)).size !== uuidRows.length ||
+        new Set(uuidRows.map(([, uuid]) => uuid)).size !== uuidRows.length
+      )
+        throw new Error('Required power: invalid or duplicate physical GPU identity');
+      const uuids = new Map(uuidRows);
+      auditDevices = Object.entries(energies).map(([index, energy]) => ({
+        node,
+        gpu_uuid: uuids.get(index),
+        role: 'aggregate',
+        energy_j: energy,
+      }));
+    } else {
+      const roles = object(audit.per_gpu_role, 'audit device roles');
+      const nativeNodes = new Map<string, string>();
+      if (audit.telemetry_kind === 'native_multinode_smi')
+        for (const value of audit.nodes as unknown[]) {
+          const receipt = object(value, 'native node receipt');
+          for (const uuid of Object.values(
+            object(receipt.physical_gpu_ids, 'native GPU identities'),
+          )) {
+            const uuidValue = nonempty(uuid, 'native GPU UUID');
+            if (nativeNodes.has(uuidValue))
+              throw new Error('Required power: duplicate native GPU identity');
+            nativeNodes.set(uuidValue, nonempty(receipt.node, 'native node'));
+          }
+        }
+      auditDevices = Object.entries(energies).map(([device, energy]) => {
+        const slash = device.lastIndexOf('/');
+        return {
+          node: nativeNodes.get(device) ?? device.slice(0, slash),
+          gpu_uuid: nativeNodes.has(device) ? device : device.slice(slash + 1),
+          role: roles[device] === 'agg' ? 'aggregate' : roles[device],
+          energy_j: energy,
+        };
+      });
+    }
+    if (
+      !Array.isArray(declared.devices) ||
+      declared.devices.length !== expectedCount ||
+      auditDevices.length !== expectedCount
+    )
+      throw new Error(`Required power: missing physical GPU evidence for ${key}`);
+    const devices = new Set<string>();
+    const roles = new Map<string, number>();
+    let totalEnergy = 0;
+    const roleEnergy = new Map<string, number>();
+    const nodes = new Set<string>();
+    for (const value of declared.devices) {
+      const device = object(value, 'physical GPU');
+      const node = nonempty(device.node, 'GPU node');
+      nodes.add(node);
+      const uuid = nonempty(device.gpu_uuid, 'physical GPU UUID');
+      if (['n/a', 'none', 'null'].includes(uuid.toLowerCase()) || devices.has(uuid))
+        throw new Error('Required power: duplicate or invalid physical GPU UUID');
+      devices.add(uuid);
+      if (!['aggregate', 'prefill', 'decode'].includes(String(device.role)))
+        throw new Error('Required power: invalid physical GPU role');
+      roles.set(String(device.role), (roles.get(String(device.role)) ?? 0) + 1);
+      const energy = positive(device.energy_j, 'device energy_j');
+      totalEnergy += energy;
+      roleEnergy.set(String(device.role), (roleEnergy.get(String(device.role)) ?? 0) + energy);
+      if (!auditDevices.some((actual) => isDeepStrictEqual(actual, device)))
+        throw new Error(`Required power: physical GPU evidence differs from audit for ${key}`);
+    }
+    if (nodes.size !== (matrix['node-count'] ?? 1))
+      throw new Error(
+        `Required power: participating node count differs from required matrix for ${key}`,
+      );
+    if (topology.disagg) {
+      if (
+        roles.get('prefill') !== positive(topology.num_prefill_gpu, 'prefill GPU count') ||
+        roles.get('decode') !== positive(topology.num_decode_gpu, 'decode GPU count') ||
+        roles.has('aggregate')
+      )
+        throw new Error(`Required power: missing prefill or decode evidence for ${key}`);
+      for (const role of ['prefill', 'decode']) {
+        const energy = positive(row[`${role}_gpu_energy_j`], `${role} energy`);
+        if (Math.abs((roleEnergy.get(role) ?? 0) - energy) > Math.max(0.01, energy * 1e-4))
+          throw new Error(`Required power: ${role} energy differs from device evidence for ${key}`);
+      }
+    } else if (roles.get('aggregate') !== expectedCount) {
+      throw new Error(`Required power: invalid aggregate GPU roles for ${key}`);
+    }
+    const energy = positive(row.total_gpu_energy_j, 'total_gpu_energy_j');
+    if (Math.abs(totalEnergy - energy) > Math.max(0.01, energy * 1e-4))
+      throw new Error(`Required power: total GPU energy differs from device evidence for ${key}`);
+  }
+}
diff --git a/packages/db/src/etl/telemetry-receipt.test.ts b/packages/db/src/etl/telemetry-receipt.test.ts
new file mode 100644
index 000000000..1fba454e7
--- /dev/null
+++ b/packages/db/src/etl/telemetry-receipt.test.ts
@@ -0,0 +1,274 @@
+import { readFileSync } from 'node:fs';
+import { PGlite } from '@electric-sql/pglite';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { Sql } from './db-utils';
+import { stablePowerPointIdentity } from './power-publication';
+
+import {
+  readTelemetryReceipt,
+  summarizeTelemetryReceipt,
+  telemetryArtifactsForAttempt,
+  verifyTelemetryApi,
+  type TelemetryReceipt,
+} from './telemetry-receipt';
+
+describe('telemetry attachment receipts', () => {
+  it('isolates the source attempt before selecting or downloading artifact pairs', () => {
+    const old = {
+      name: 'gpu_metrics_old',
+      created_at: '2026-09-20T00:00:00Z',
+      archive_download_url: 'old',
+    };
+    const current = {
+      name: 'gpu_metrics_new',
+      created_at: '2026-09-21T01:00:00Z',
+      archive_download_url: 'new',
+    };
+    const source = { run_attempt: 2, run_started_at: '2026-09-21T00:00:00Z' };
+    expect(telemetryArtifactsForAttempt([old, current], source, 2)).toEqual([current]);
+    expect(() => telemetryArtifactsForAttempt([old, current], source, 1)).toThrow('mixed-attempt');
+    expect(() => telemetryArtifactsForAttempt([current], { run_attempt: 2 }, 2)).toThrow(
+      'start time',
+    );
+  });
+});
+
+const run = { runId: 123, runAttempt: 2 };
+const artifactName = 'gpu_metrics_shared';
+
+function receiptFixture(): TelemetryReceipt {
+  const series = [{ id: 1, artifactName, fileName: 'gpu_metrics.csv', sampleCount: 2 }];
+  return {
+    version: 1,
+    ...run,
+    checkedAt: '2026-09-21T00:00:00Z',
+    expectedSource: 'benchmark_artifacts',
+    plannedPointCount: null,
+    counts: {} as TelemetryReceipt['counts'],
+    points: [10, 11].map((id) => ({
+      key: String(id),
+      identity: { conc: id },
+      benchmarkResultId: id,
+      artifactNames: [artifactName],
+      produced: true,
+      series,
+      storage: { status: 'complete', expectedSeries: series },
+      linkedSeriesIds: [1],
+      api: { status: 'readable' },
+      reasons: [],
+      recovery: { ...run, artifactNames: [artifactName] },
+    })),
+  };
+}
+
+describe('telemetry completeness accounting', () => {
+  it('counts shared storage once while retaining both independently linked points', () => {
+    const { counts } = summarizeTelemetryReceipt(receiptFixture());
+    expect(counts).toMatchObject({
+      expectedPoints: 2,
+      producedPoints: 2,
+      producedArtifacts: 1,
+      storedPoints: 2,
+      linkedPoints: 2,
+      storedSeries: 1,
+      storedSamples: 2,
+      apiCompletePoints: 2,
+    });
+  });
+
+  it.each([
+    { expectedSource: 'unknown' as const },
+    {
+      expectationErrors: [
+        { benchmarkArtifact: 'bmk_missing', artifactNames: [], error: 'unreadable' },
+      ],
+    },
+  ])('keeps an unknown expectation denominator with %j', (unknown) => {
+    const result = summarizeTelemetryReceipt({ ...receiptFixture(), ...unknown });
+    expect(result.counts).toMatchObject({
+      expectedPoints: null,
+      storedPoints: 2,
+      storedSamples: 2,
+    });
+  });
+
+  it.each([
+    { databaseError: 'database unavailable' },
+    { recoveryError: 'corrective ingest failed' },
+  ])('does not promote readable old data to complete while %j', (failure) => {
+    const result = summarizeTelemetryReceipt({ ...receiptFixture(), ...failure });
+    expect(result.counts.apiReadablePoints).toBe(2);
+    expect(result.counts.apiCompletePoints).toBe(0);
+    expect(result.counts.storedSamples).toBe('databaseError' in failure ? null : 2);
+  });
+
+  it('does not count unlinked or failed corrected points as API-complete', () => {
+    const receipt = receiptFixture();
+    receipt.points[0]!.linkedSeriesIds = [];
+    receipt.points[1]!.error = 'correction failed';
+    expect(summarizeTelemetryReceipt(receipt).counts).toMatchObject({
+      storedPoints: 2,
+      linkedPoints: 1,
+      apiReadablePoints: 2,
+      apiCompletePoints: 0,
+    });
+  });
+});
+
+describe('telemetry API verification', () => {
+  it.each([
+    ['matching data', 200, 10, 2, 2, true],
+    ['missing endpoint', 404, 10, 2, 2, false],
+    ['unavailable endpoint', 503, 10, 2, 2, false],
+    ['different point', 200, 11, 2, 2, false],
+    ['different sample count', 200, 10, 3, 2, false],
+    ['truncated data', 200, 10, 2, 1, false],
+  ] as const)('%s', async (_name, status, id, sampleCount, dataCount, readable) => {
+    const receipt = receiptFixture();
+    receipt.points = [receipt.points[0]!];
+    receipt.points[0]!.api = { status: 'unknown' };
+    const fetcher = vi.fn<typeof fetch>().mockResolvedValue(
+      Response.json(
+        {
+          benchmarkResultId: id,
+          series: [
+            { id: 1, sampleCount, data: Array.from({ length: dataCount }, () => ({ power: 100 })) },
+          ],
+        },
+        { status },
+      ),
+    );
+    const result = await verifyTelemetryApi(receipt, 'https://example.test', { fetch: fetcher });
+    expect(String(fetcher.mock.calls[0]![0])).toBe(
+      'https://example.test/api/v1/gpu-metrics-point?id=10',
+    );
+    expect(result.points[0]!.api.status).toBe(readable ? 'readable' : 'failed');
+    expect(result.counts.apiCompletePoints).toBe(readable ? 1 : 0);
+    if (!readable) expect(result.points[0]!.api.error).toBeTruthy();
+  });
+
+  it('requires the complete stored series set and skips points without database identities', async () => {
+    const receipt = receiptFixture();
+    receipt.points[1]!.benchmarkResultId = null;
+    receipt.points[1]!.api = { status: 'unknown' };
+    const fetcher = vi
+      .fn<typeof fetch>()
+      .mockResolvedValue(Response.json({ benchmarkResultId: 10, series: [] }));
+    const result = await verifyTelemetryApi(receipt, 'https://example.test', { fetch: fetcher });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+    expect(result.points[0]!.api.error).toContain('series set differs');
+    expect(result.points[1]!.api.status).toBe('unknown');
+    expect(result.counts.apiCompletePoints).toBe(0);
+  });
+});
+
+describe('persisted telemetry receipts', () => {
+  let db: PGlite;
+  let sql: Sql;
+  beforeAll(async () => {
+    db = await PGlite.create();
+    for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+      await db.exec(readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+    }
+    await db.exec(
+      "ALTER TABLE benchmark_results ADD COLUMN offload_mode text DEFAULT 'off'; ALTER TABLE benchmark_results ADD COLUMN recipe_fingerprint text",
+    );
+    sql = (async (strings: TemplateStringsArray, ...values: unknown[]) => {
+      const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+      const result = await db.query(query, values);
+      return result.rows;
+    }) as unknown as Sql;
+  }, 20_000);
+  afterAll(async () => {
+    await db?.close();
+  });
+  beforeEach(async () => {
+    await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+      INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
+      VALUES (1, 123, 2, 'Sweep', '2026-09-21', '2026-09-21');
+      INSERT INTO configs (id, model, hardware, framework, precision, spec_method, prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+      VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', 1, 1, 1, 1);
+      INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+      VALUES (10, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 1, '{}'),
+        (11, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 2, '{}');
+      INSERT INTO gpu_metric_series (id, workflow_run_id, artifact_name, config_key, file_name, vendor, csv_sha256, sample_count, gpu_count, started_at, ended_at)
+      VALUES (1, 1, 'gpu_metrics_shared', 'shared', 'gpu_metrics.csv', 'nvidia', 'source', 2, 1, '2026-09-21T00:00:00Z', '2026-09-21T00:00:01Z');
+      INSERT INTO gpu_metric_samples (series_id, gpu_index, sampled_at, power_w)
+      VALUES (1, 0, '2026-09-21T00:00:00Z', 100), (1, 0, '2026-09-21T00:00:01Z', 200);
+      INSERT INTO benchmark_result_gpu_metrics VALUES (10, 1), (11, 1);`);
+  });
+
+  async function inventory(value: unknown) {
+    await db.query('UPDATE gpu_metric_series SET sidecars = $1::jsonb', [JSON.stringify(value)]);
+  }
+  const completeInventory = { seriesInventory: [{ fileName: 'gpu_metrics.csv', sampleCount: 2 }] };
+
+  it.each([false, true])(
+    'reads complete JSONB inventory (encoded=%s) and preserves unrelated targeted state',
+    async (encoded) => {
+      await inventory(encoded ? JSON.stringify(completeInventory) : completeInventory);
+      const original = await readTelemetryReceipt(sql, run, []);
+      expect(original.counts).toMatchObject({
+        expectedPoints: 2,
+        storedPoints: 2,
+        linkedPoints: 2,
+        storedSeries: 1,
+        storedSamples: 2,
+        apiCompletePoints: 0,
+      });
+      original.points[1]!.api = { status: 'readable' };
+      const first = original.points[0]!;
+      const repaired = await readTelemetryReceipt(
+        sql,
+        run,
+        [{ identity: first.identity, artifactNames: [artifactName], produced: true }],
+        { previous: original, targeted: true },
+      );
+      expect(
+        repaired.points.find((point) => point.key === stablePowerPointIdentity(first.identity))!.api
+          .status,
+      ).toBe('unknown');
+      expect(repaired.points[1]).toEqual(original.points[1]);
+    },
+  );
+
+  it('keeps missing inventory unknown and missing host storage incomplete', async () => {
+    await inventory('{invalid json');
+    const unknown = await readTelemetryReceipt(sql, run, []);
+    expect(unknown.databaseError).toBeUndefined();
+    expect(unknown.counts).toMatchObject({
+      storedPoints: 0,
+      storageUnknownPoints: 2,
+      storedSamples: 2,
+    });
+    await inventory({
+      seriesInventory: [
+        ...completeInventory.seriesInventory,
+        { fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
+      ],
+    });
+    const incomplete = await readTelemetryReceipt(sql, run, []);
+    expect(incomplete.points[0]!.storage.status).toBe('incomplete');
+    expect(incomplete.points[0]!.reasons).toContain('series_coverage_incomplete');
+    expect(incomplete.counts.storedPoints).toBe(0);
+  });
+
+  it('reports failed SQL as unknown storage rather than a successful empty receipt', async () => {
+    await db.exec('ALTER TABLE gpu_metric_series RENAME TO unavailable_gpu_metric_series');
+    try {
+      const result = await readTelemetryReceipt(sql, run, []);
+      expect(result.databaseError).toContain('gpu_metric_series');
+      expect(result.counts).toMatchObject({
+        expectedPoints: null,
+        storedPoints: null,
+        linkedPoints: null,
+        storedSeries: null,
+        storedSamples: null,
+        apiCompletePoints: 0,
+      });
+    } finally {
+      await db.exec('ALTER TABLE unavailable_gpu_metric_series RENAME TO gpu_metric_series');
+    }
+  });
+});
diff --git a/packages/db/src/etl/telemetry-receipt.ts b/packages/db/src/etl/telemetry-receipt.ts
new file mode 100644
index 000000000..16b8b019b
--- /dev/null
+++ b/packages/db/src/etl/telemetry-receipt.ts
@@ -0,0 +1,461 @@
+import type { Sql } from './db-utils';
+import type { ArtifactMeta, RunMeta } from '../lib/github-artifacts';
+import { stablePowerPointIdentity } from './power-publication';
+import { gpuMetricsArtifactSuffix } from './gpu-metrics-artifacts';
+
+export interface TelemetryObservation {
+  identity: Record<string, unknown>;
+  /** Exact selected artifact names, or both allowed sibling names when absent. */
+  artifactNames: string[];
+  produced: boolean | null;
+  error?: string;
+}
+
+interface TelemetrySeriesCoverage {
+  artifactName: string;
+  fileName: string;
+  sampleCount: number;
+}
+
+export interface TelemetryPointReceipt extends TelemetryObservation {
+  key: string;
+  benchmarkResultId: number | null;
+  series: (TelemetrySeriesCoverage & { id: number })[];
+  storage: {
+    status: 'complete' | 'incomplete' | 'unknown';
+    /** Null means the original artifact inventory was not retained. */
+    expectedSeries: TelemetrySeriesCoverage[] | null;
+  };
+  linkedSeriesIds: number[];
+  api: {
+    status: 'unknown' | 'readable' | 'failed';
+    checkedAt?: string;
+    url?: string;
+    error?: string;
+  };
+  reasons: string[];
+  recovery: { runId: number; runAttempt: number; artifactNames: string[] };
+}
+
+export interface TelemetryReceipt {
+  version: 1;
+  runId: number;
+  runAttempt: number;
+  checkedAt: string;
+  /** This is attachment coverage for known benchmark points, not a full-sweep verdict. */
+  expectedSource: 'benchmark_artifacts' | 'database_benchmarks' | 'unknown';
+  /** No complete independent planned matrix is available to this attachment reader. */
+  plannedPointCount: null;
+  databaseError?: string;
+  recoveryError?: string;
+  /** Missing on older receipts or when the failed recovery covered the whole run. */
+  recoveryArtifactNames?: string[];
+  /** The sibling is known, but a download/parse failure prevents identifying its points. */
+  expectationErrors?: { benchmarkArtifact: string; artifactNames: string[]; error: string }[];
+  points: TelemetryPointReceipt[];
+  counts: {
+    expectedPoints: number | null;
+    producedPoints: number;
+    productionUnknownPoints: number;
+    storedPoints: number | null;
+    linkedPoints: number | null;
+    storageUnknownPoints: number;
+    /** Actual successful HTTP reads, including readable but incomplete artifacts. */
+    apiReadablePoints: number;
+    /** Readable, fully stored/linked points with no outstanding corrective-ingest failure. */
+    apiCompletePoints: number;
+    apiUnknownPoints: number;
+    producedArtifacts: number;
+    storedSeries: number | null;
+    storedSamples: number | null;
+  };
+}
+
+interface StoredPoint extends Record<string, unknown> {
+  id: number;
+}
+
+interface StoredSeries {
+  id: number;
+  artifact_name: string;
+  file_name: string;
+  sidecars: unknown;
+  sample_count: number;
+  benchmark_result_ids: number[];
+}
+
+function isInventoryEntry(value: unknown): value is { fileName: string; sampleCount: number } {
+  if (value === null || typeof value !== 'object') return false;
+  const entry = value as Record<string, unknown>;
+  return (
+    typeof entry.fileName === 'string' &&
+    typeof entry.sampleCount === 'number' &&
+    Number.isSafeInteger(entry.sampleCount) &&
+    entry.sampleCount >= 0
+  );
+}
+
+/** JSONB may contain an encoded object; unavailable inventories remain unknown. */
+function storedSeriesInventory(sidecars: unknown): unknown {
+  if (typeof sidecars === 'string') {
+    try {
+      sidecars = JSON.parse(sidecars) as unknown;
+    } catch {
+      return undefined;
+    }
+  }
+  return sidecars !== null && typeof sidecars === 'object' && !Array.isArray(sidecars)
+    ? (sidecars as { seriesInventory?: unknown }).seriesInventory
+    : undefined;
+}
+
+function seriesCoverageKey(artifact: string, file: string): string {
+  return JSON.stringify([artifact, file]);
+}
+
+function seriesCoverage(
+  series: readonly StoredSeries[],
+  reasons: string[],
+): TelemetryPointReceipt['storage'] {
+  if (series.length === 0) return { status: 'incomplete', expectedSeries: null };
+  const expected = new Map<string, TelemetrySeriesCoverage>();
+  const inventories = new Map<string, string>();
+  let unknown = false;
+  for (const entry of series) {
+    const inventory = storedSeriesInventory(entry.sidecars);
+    if (!Array.isArray(inventory) || inventory.length === 0 || !inventory.every(isInventoryEntry)) {
+      unknown = true;
+      continue;
+    }
+    const signature = JSON.stringify(
+      inventory.toSorted((a, b) => a.fileName.localeCompare(b.fileName)),
+    );
+    const previous = inventories.get(entry.artifact_name);
+    if (previous && previous !== signature) unknown = true;
+    inventories.set(entry.artifact_name, signature);
+    if (!inventory.some((item) => item.fileName === entry.file_name)) unknown = true;
+    for (const item of inventory) {
+      expected.set(seriesCoverageKey(entry.artifact_name, item.fileName), {
+        artifactName: entry.artifact_name,
+        ...item,
+      });
+    }
+  }
+  const actual = new Map(
+    series.map((entry) => [seriesCoverageKey(entry.artifact_name, entry.file_name), entry]),
+  );
+  const missing = [...expected].some(([name]) => !actual.has(name));
+  const wrongSamples = [...expected].some(([name, entry]) => {
+    const stored = actual.get(name);
+    return stored !== undefined && Number(stored.sample_count) !== entry.sampleCount;
+  });
+  if (missing) reasons.push('series_coverage_incomplete');
+  if (wrongSamples) reasons.push('sample_coverage_incomplete');
+  if (unknown) reasons.push('series_inventory_unknown');
+  return {
+    status:
+      missing || wrongSamples || series.some((entry) => Number(entry.sample_count) === 0)
+        ? 'incomplete'
+        : unknown
+          ? 'unknown'
+          : 'complete',
+    expectedSeries: expected.size > 0 ? [...expected.values()] : null,
+  };
+}
+
+/** GitHub's run-wide listing also retains artifacts from earlier attempts. */
+export function telemetryArtifactsForAttempt(
+  artifacts: readonly ArtifactMeta[],
+  source: Pick<RunMeta, 'run_attempt' | 'run_started_at'>,
+  targetAttempt: number,
+): ArtifactMeta[] {
+  if (source.run_attempt !== targetAttempt)
+    throw new Error(
+      `GitHub attempt ${source.run_attempt} differs from target ${targetAttempt}; refusing mixed-attempt telemetry recovery`,
+    );
+  const start = Date.parse(source.run_started_at ?? '');
+  if (!Number.isFinite(start))
+    throw new Error('Cannot isolate telemetry artifacts without attempt start time');
+  return artifacts.filter((artifact) => Date.parse(artifact.created_at) >= start);
+}
+
+/** Count identities, artifacts, series and samples separately; shared series count once. */
+export function summarizeTelemetryReceipt(receipt: TelemetryReceipt): TelemetryReceipt {
+  const points = receipt.points;
+  const series = new Map(points.flatMap((point) => point.series.map((s) => [s.id, s] as const)));
+  const complete = points.filter((point) => point.storage?.status === 'complete');
+  const linked = complete.filter((point) =>
+    point.series.every((s) => point.linkedSeriesIds.includes(s.id)),
+  );
+  receipt.counts = {
+    expectedPoints:
+      receipt.expectedSource === 'unknown' || receipt.expectationErrors?.length
+        ? null
+        : points.length,
+    producedPoints: points.filter((p) => p.produced === true).length,
+    productionUnknownPoints: points.filter((p) => p.produced === null).length,
+    storedPoints: receipt.databaseError ? null : complete.length,
+    linkedPoints: receipt.databaseError ? null : linked.length,
+    storageUnknownPoints: points.filter(
+      (point) => !point.storage || point.storage.status === 'unknown',
+    ).length,
+    apiReadablePoints: points.filter((p) => p.api.status === 'readable').length,
+    apiCompletePoints:
+      receipt.databaseError || receipt.recoveryError
+        ? 0
+        : linked.filter((point) => point.api.status === 'readable' && !point.error).length,
+    apiUnknownPoints: points.filter((p) => p.api.status === 'unknown').length,
+    producedArtifacts: new Set(
+      points.filter((p) => p.produced === true).flatMap((p) => p.artifactNames),
+    ).size,
+    storedSeries: receipt.databaseError ? null : series.size,
+    storedSamples: receipt.databaseError
+      ? null
+      : [...series.values()].reduce((sum, s) => sum + s.sampleCount, 0),
+  };
+  return receipt;
+}
+
+/** Absent observations name alternative siblings, not two required uploads. */
+function coversArtifactScope(
+  current: TelemetryObservation,
+  previous: TelemetryObservation,
+): boolean {
+  return (
+    previous.artifactNames.length > 0 &&
+    previous.artifactNames.every(
+      (name) =>
+        current.artifactNames.includes(name) ||
+        (previous.produced === false &&
+          gpuMetricsArtifactSuffix(name) !== null &&
+          current.artifactNames.some(
+            (candidate) => gpuMetricsArtifactSuffix(candidate) === gpuMetricsArtifactSuffix(name),
+          )),
+    )
+  );
+}
+
+/** Read actual persistence/link state, preserving unrelated points on targeted recovery. */
+export async function readTelemetryReceipt(
+  sql: Sql,
+  run: { runId: number; runAttempt: number },
+  observations: readonly TelemetryObservation[],
+  options: {
+    expectedSource?: TelemetryReceipt['expectedSource'];
+    previous?: TelemetryReceipt;
+    targeted?: boolean;
+    /** Mapped identity -> persisted ID, only from the historical resolver's unique fallback. */
+    uniqueFallbacks?: ReadonlyMap<string, number>;
+  } = {},
+): Promise<TelemetryReceipt> {
+  const previous = options.previous;
+  if (previous && (previous.runId !== run.runId || previous.runAttempt !== run.runAttempt))
+    throw new Error('Telemetry receipt run/attempt does not match the recovery target');
+  const receipt: TelemetryReceipt = {
+    version: 1,
+    ...run,
+    checkedAt: new Date().toISOString(),
+    expectedSource: options.expectedSource ?? previous?.expectedSource ?? 'database_benchmarks',
+    plannedPointCount: null,
+    points: [],
+    counts: {} as TelemetryReceipt['counts'],
+  };
+  let rows: StoredPoint[] = [];
+  let series: StoredSeries[] = [];
+  try {
+    rows = await sql<StoredPoint[]>`
+      select c.*, br.id, br.benchmark_type, br.isl, br.osl, br.conc,
+        br.offload_mode, br.recipe_fingerprint
+      from benchmark_results br
+      join configs c on c.id = br.config_id
+      join workflow_runs wr on wr.id = br.workflow_run_id
+      where wr.github_run_id = ${run.runId} and wr.run_attempt = ${run.runAttempt}
+      order by br.id
+    `;
+    series = await sql<StoredSeries[]>`
+      select s.id, s.artifact_name, s.file_name, s.sidecars,
+        (select count(*)::int from gpu_metric_samples x where x.series_id = s.id) as sample_count,
+        coalesce((select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
+          from benchmark_result_gpu_metrics l
+          join benchmark_results br on br.id = l.benchmark_result_id
+          where l.series_id = s.id and br.workflow_run_id = s.workflow_run_id), '{}') as benchmark_result_ids
+      from gpu_metric_series s join workflow_runs wr on wr.id = s.workflow_run_id
+      where wr.github_run_id = ${run.runId} and wr.run_attempt = ${run.runAttempt}
+      order by s.id
+    `;
+  } catch (error) {
+    receipt.databaseError = error instanceof Error ? error.message : String(error);
+    if (observations.length === 0 && !previous) receipt.expectedSource = 'unknown';
+  }
+  const stored = new Map(rows.map((row) => [stablePowerPointIdentity(row), row]));
+  const storedById = new Map(rows.map((row) => [Number(row.id), row]));
+  const prior = new Map(previous?.points.map((point) => [point.key, point]));
+  const observed = new Map(
+    observations.map((point) => [stablePowerPointIdentity(point.identity), point]),
+  );
+  for (const [key, id] of options.uniqueFallbacks ?? []) {
+    const observation = observed.get(key);
+    const row = storedById.get(id);
+    if (receipt.databaseError || !observation || !row || stored.has(key)) continue;
+    // The resolver allows historical offload drift only; keep every other dimension exact.
+    const identity = { ...observation.identity, offload_mode: row.offload_mode };
+    const canonicalKey = stablePowerPointIdentity(identity);
+    if (canonicalKey !== stablePowerPointIdentity(row)) continue;
+    const collision = observed.get(canonicalKey);
+    const priorCanonical = prior.get(canonicalKey);
+    if (
+      (priorCanonical &&
+        (priorCanonical.artifactNames.length > 0 || priorCanonical.error) &&
+        !coversArtifactScope(observation, priorCanonical)) ||
+      (collision &&
+        (collision.produced !== observation.produced ||
+          collision.error !== observation.error ||
+          collision.artifactNames.length !== observation.artifactNames.length ||
+          collision.artifactNames.some((name) => !observation.artifactNames.includes(name))))
+    ) {
+      receipt.expectedSource = 'unknown';
+      continue;
+    }
+    observed.delete(key);
+    observed.set(canonicalKey, { ...observation, identity });
+    const old = prior.get(key);
+    if (old?.benchmarkResultId === null && coversArtifactScope(observation, old)) prior.delete(key);
+  }
+  const resolvedObservations = [...observed.values()];
+  const pendingRecoveryArtifacts = previous?.recoveryArtifactNames?.filter(
+    (name) =>
+      !resolvedObservations.some(
+        (point) => point.produced === true && !point.error && point.artifactNames.includes(name),
+      ),
+  );
+  const successfulKeys = new Set(
+    resolvedObservations
+      .filter((point) => point.produced === true && !point.error)
+      .map((point) => stablePowerPointIdentity(point.identity)),
+  );
+  const recoveryUnresolved = previous?.recoveryArtifactNames?.length
+    ? pendingRecoveryArtifacts?.length
+    : options.targeted ||
+      resolvedObservations.length === 0 ||
+      successfulKeys.size !== resolvedObservations.length ||
+      [...prior.values()].some((point) => !successfulKeys.has(point.key));
+  Object.assign(receipt, {
+    ...(previous?.recoveryError && recoveryUnresolved
+      ? {
+          recoveryError: previous.recoveryError,
+          ...(pendingRecoveryArtifacts ? { recoveryArtifactNames: pendingRecoveryArtifacts } : {}),
+        }
+      : {}),
+    ...(previous?.expectationErrors
+      ? {
+          expectationErrors: previous.expectationErrors.filter(
+            (error) =>
+              !resolvedObservations.some((point) =>
+                point.artifactNames.some((name) => error.artifactNames.includes(name)),
+              ),
+          ),
+        }
+      : {}),
+  });
+  const keys = new Set([...prior.keys(), ...stored.keys(), ...observed.keys()]);
+  for (const key of keys) {
+    const old = prior.get(key);
+    if (options.targeted && old && !observed.has(key)) {
+      receipt.points.push(old);
+      continue;
+    }
+    const row = stored.get(key);
+    const benchmarkResultId = row ? Number(row.id) : null;
+    const linked = series.filter((s) =>
+      s.benchmark_result_ids.map(Number).includes(benchmarkResultId!),
+    );
+    const observation = observed.get(key) ??
+      old ?? {
+        identity: row!,
+        artifactNames: [...new Set(linked.map((s) => s.artifact_name))],
+        produced: linked.length > 0 ? true : null,
+      };
+    const matching = series.filter((s) => observation.artifactNames.includes(s.artifact_name));
+    const reasons: string[] = [];
+    if (observation.produced === false) reasons.push('artifact_missing');
+    if (observation.produced === null) reasons.push('artifact_pair_unknown');
+    if (observation.error) reasons.push('ingest_failed');
+    if (receipt.databaseError) reasons.push('database_check_failed');
+    else {
+      if (benchmarkResultId === null) reasons.push('benchmark_not_stored');
+      if (matching.length === 0) reasons.push('series_not_stored');
+      else if (matching.some((s) => Number(s.sample_count) === 0)) reasons.push('samples_missing');
+      if (matching.some((s) => !linked.includes(s))) reasons.push('point_link_missing');
+    }
+    const storage: TelemetryPointReceipt['storage'] = receipt.databaseError
+      ? { status: 'unknown', expectedSeries: null }
+      : seriesCoverage(matching, reasons);
+    receipt.points.push({
+      identity: observation.identity,
+      artifactNames: observation.artifactNames,
+      produced: observation.produced,
+      ...(observation.error ? { error: observation.error } : {}),
+      key,
+      benchmarkResultId,
+      series: matching.map((s) => ({
+        id: Number(s.id),
+        artifactName: s.artifact_name,
+        fileName: s.file_name,
+        sampleCount: Number(s.sample_count),
+      })),
+      storage,
+      linkedSeriesIds: linked.filter((s) => matching.includes(s)).map((s) => Number(s.id)),
+      api: { status: 'unknown' },
+      reasons,
+      recovery: { ...run, artifactNames: observation.artifactNames },
+    });
+  }
+  receipt.points.sort((a, b) => a.key.localeCompare(b.key));
+  return summarizeTelemetryReceipt(receipt);
+}
+
+/** Only an actual HTTP read advances API status; DB-queryable is not API-readable. */
+export async function verifyTelemetryApi(
+  receipt: TelemetryReceipt,
+  origin: string,
+  options: { fetch?: typeof fetch; headers?: HeadersInit } = {},
+): Promise<TelemetryReceipt> {
+  for (const point of receipt.points) {
+    if (point.benchmarkResultId === null) continue;
+    const url = new URL('/api/v1/gpu-metrics-point', origin);
+    url.searchParams.set('id', String(point.benchmarkResultId));
+    const checkedAt = new Date().toISOString();
+    try {
+      const response = await (options.fetch ?? fetch)(url, {
+        headers: options.headers,
+        signal: AbortSignal.timeout(30_000),
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const payload = await response.json();
+      if (payload?.benchmarkResultId !== point.benchmarkResultId || !Array.isArray(payload.series))
+        throw new Error('Point API returned a different identity or invalid series');
+      if (point.series.length === 0 || payload.series.length !== point.series.length)
+        throw new Error('Point API series set differs from stored telemetry');
+      for (const stored of point.series) {
+        const actual = payload.series.find((s: { id: number }) => s.id === stored.id);
+        if (
+          !actual ||
+          stored.sampleCount === 0 ||
+          actual.sampleCount !== stored.sampleCount ||
+          !Array.isArray(actual.data) ||
+          actual.data.length !== stored.sampleCount
+        )
+          throw new Error(`Point API series ${stored.id} sample count differs from storage`);
+      }
+      point.api = { status: 'readable', checkedAt, url: url.toString() };
+    } catch (error) {
+      point.api = {
+        status: 'failed',
+        checkedAt,
+        url: url.toString(),
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+  return summarizeTelemetryReceipt(receipt);
+}
diff --git a/packages/db/src/preflight-power-publication.ts b/packages/db/src/preflight-power-publication.ts
new file mode 100644
index 000000000..031c07170
--- /dev/null
+++ b/packages/db/src/preflight-power-publication.ts
@@ -0,0 +1,36 @@
+import { verifyRequiredPowerArtifacts } from './etl/required-power-publication';
+
+// Deliberately artifact-only: this entry point opens no DB connection and writes no files.
+const [root, runId, runAttempt, headSha, option] = process.argv.slice(2);
+if (
+  !root ||
+  !runId ||
+  !runAttempt ||
+  !/^\d+$/u.test(runId) ||
+  !/^\d+$/u.test(runAttempt) ||
+  !Number.isSafeInteger(Number(runId)) ||
+  !Number.isSafeInteger(Number(runAttempt)) ||
+  Number(runId) <= 0 ||
+  Number(runAttempt) <= 0 ||
+  !headSha ||
+  !/^[a-f0-9]{40}$/u.test(headSha) ||
+  (option !== undefined && option !== '--optional-power') ||
+  process.argv.length > 7
+)
+  throw new Error(
+    'Usage: preflight-power-publication.ts <artifacts-dir> <source-run-id> <attempt> <head-sha> [--optional-power]',
+  );
+
+const points = verifyRequiredPowerArtifacts(
+  root,
+  { runId: Number(runId), runAttempt: Number(runAttempt), headSha },
+  option !== '--optional-power',
+);
+console.log(
+  JSON.stringify({
+    status: 'validated_artifacts',
+    requiredPoints: points.length,
+    databaseWrites: 0,
+    curvePreservation: 'not_checked_requires_published_state',
+  }),
+);
diff --git a/packages/db/src/verify-power-publication.ts b/packages/db/src/verify-power-publication.ts
index 84bf86723..41038b292 100644
--- a/packages/db/src/verify-power-publication.ts
+++ b/packages/db/src/verify-power-publication.ts
@@ -1,7 +1,9 @@
 import fs from 'node:fs';
 import { DB_MODEL_TO_DISPLAY } from '@semianalysisai/inferencex-constants';
 import { createAdminSql } from './etl/db-utils';
+import { verifyTelemetryApi } from './etl/telemetry-receipt';
 import {
+  fatalPublicationErrors,
   verifyPowerPublication,
   type PowerPublicationManifest,
   type PublishedPowerRow,
@@ -33,12 +35,12 @@ try {
     join workflow_runs wr on wr.id = br.workflow_run_id
     where wr.github_run_id = ${manifest.runId} and wr.run_attempt = ${manifest.runAttempt}
       and (br.benchmark_type = 'agentic_traces' or
-        (br.benchmark_type = 'single_turn' and br.isl = 8192 and br.osl = 1024))
+        (br.benchmark_type = 'single_turn' and br.isl in (1024, 8192) and br.osl = 1024))
   `;
-  const errors = [
-    ...(manifest.ingestErrors ?? []),
-    ...verifyPowerPublication(manifest.points, rows as unknown as PublishedPowerRow[], 'database'),
-  ];
+  const errors = fatalPublicationErrors(
+    manifest,
+    verifyPowerPublication(manifest.points, rows as unknown as PublishedPowerRow[], 'database'),
+  );
   const publicRows: PublishedPowerRow[] = [];
   const models = [
     ...new Set(manifest.points.map((point) => DB_MODEL_TO_DISPLAY[String(point.identity.model)])),
@@ -70,6 +72,19 @@ try {
     publicRows.push(...body);
   }
   errors.push(...verifyPowerPublication(manifest.points, publicRows, 'public API'));
+  if (manifest.telemetry) {
+    if (
+      manifest.telemetry.runId !== manifest.runId ||
+      manifest.telemetry.runAttempt !== manifest.runAttempt
+    )
+      throw new Error('Telemetry receipt belongs to a different run/attempt');
+    manifest.telemetry = await verifyTelemetryApi(manifest.telemetry, origin, {
+      headers: process.env.CACHE_PROTECTION_BYPASS_SECRET
+        ? { 'x-vercel-protection-bypass': process.env.CACHE_PROTECTION_BYPASS_SECRET }
+        : undefined,
+    });
+    fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+  }
   const counts = { strict: 0, invalid: 0, other: 0 };
   for (const point of manifest.points) {
     if (point.metrics.power_valid === 1 && point.metrics.power_metric_schema_version === 2)
@@ -86,6 +101,10 @@ try {
     status:
       errors.length > 0 ? 'failed' : manifest.points.length > 0 ? 'matched' : 'no_power_points',
     errors,
+    // Kept out of `errors` on purpose: a telemetry digest failure costs one
+    // point's PowerX tab, not its benchmark data, so it must not fail the ingest.
+    telemetryWarnings: manifest.telemetryWarnings ?? [],
+    ...(manifest.telemetry ? { telemetry: manifest.telemetry } : {}),
   };
   fs.writeFileSync(`${manifestPath}.verification.json`, `${JSON.stringify(receipt, null, 2)}\n`);
   console.log(JSON.stringify(receipt, null, 2));

From 422ef50764cec26f05f9b403ff869ce434c37405 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 063/103] feat(db): telemetry backfill CLI, purge accounting
 and benchmark refresh
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Backfill historical runs from GitHub artifacts before retention expires, skipping
purged points; purge telemetry alongside run overrides with explicit counts; refresh
recovered power_audit fields and invalidate the cache after a backfill.

中文：在 artifact 过期前从 GitHub 回填历史 run 并跳过已清理点；run overrides 清理时同步删除遥测并显式计数；回填后刷新恢复的 power_audit 字段并失效缓存。
---
 packages/db/src/apply-overrides.ts            |  28 +-
 packages/db/src/backfill-gpu-metrics.ts       | 675 ++++++++++++++++++
 packages/db/src/backfill-server-log-files.ts  | 113 +--
 .../db/src/lib/backfill-benchmark-refresh.ts  | 224 ++++++
 packages/db/src/lib/backfill-runner.ts        |  25 +
 .../src/lib/benchmark-result-lookup.test.ts   | 164 +++++
 .../db/src/lib/benchmark-result-lookup.ts     | 153 ++++
 .../db/src/lib/gpu-metrics-backfill.test.ts   |  50 ++
 packages/db/src/lib/gpu-metrics-backfill.ts   | 134 ++++
 packages/db/src/lib/telemetry-purge.ts        | 100 +++
 10 files changed, 1570 insertions(+), 96 deletions(-)
 create mode 100644 packages/db/src/backfill-gpu-metrics.ts
 create mode 100644 packages/db/src/lib/backfill-benchmark-refresh.ts
 create mode 100644 packages/db/src/lib/benchmark-result-lookup.test.ts
 create mode 100644 packages/db/src/lib/benchmark-result-lookup.ts
 create mode 100644 packages/db/src/lib/gpu-metrics-backfill.test.ts
 create mode 100644 packages/db/src/lib/gpu-metrics-backfill.ts
 create mode 100644 packages/db/src/lib/telemetry-purge.ts

diff --git a/packages/db/src/apply-overrides.ts b/packages/db/src/apply-overrides.ts
index 6ac41680b..62188b705 100644
--- a/packages/db/src/apply-overrides.ts
+++ b/packages/db/src/apply-overrides.ts
@@ -26,6 +26,13 @@ import { type Sql, createAdminSql, refreshLatestBenchmarks } from './etl/db-util
 import { jsonbParam } from './lib/backfill-runner.js';
 import { planBenchmarkPointBackfill } from './lib/benchmark-point-backfill.js';
 import { selectRunOverrides } from './lib/run-override-selection.js';
+import {
+  type TelemetryPurgeCounts,
+  countRunTelemetry,
+  deleteRunTelemetry,
+  describeTelemetry,
+  unlinkPointTelemetry,
+} from './lib/telemetry-purge.js';
 import {
   type BenchmarkPointBackfill,
   type ChangelogBackfill,
@@ -315,6 +322,7 @@ interface PurgeTarget {
   stats: number;
   evals: number;
   changelogs: number;
+  telemetry: TelemetryPurgeCounts;
 }
 
 /**
@@ -358,17 +366,21 @@ async function previewPurge(
     );
   }
 
-  const [[bmk], [stats], [evals], [changelogs], [logs]] = await Promise.all([
+  const [[bmk], [stats], [evals], [changelogs], [logs], telemetry] = await Promise.all([
     sql`SELECT count(*)::int AS n FROM benchmark_results WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(*)::int AS n FROM run_stats WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(*)::int AS n FROM eval_results WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(*)::int AS n FROM changelog_entries WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(DISTINCT server_log_id)::int AS n FROM benchmark_results WHERE workflow_run_id = ANY(${wrIds}) AND server_log_id IS NOT NULL`,
+    countRunTelemetry(sql, wrIds),
   ]);
 
   console.log(
     `    ${bmk.n} benchmarks, ${logs.n} server_logs, ${stats.n} run_stats, ${evals.n} evals, ${changelogs.n} changelogs`,
   );
+  // Surfaced separately: past GitHub's 90-day artifact retention these samples
+  // are the only copy, so the operator should see them before confirming.
+  if (telemetry.series > 0) console.log(`    ${describeTelemetry(telemetry)}`);
 
   return {
     githubRunId,
@@ -378,6 +390,7 @@ async function previewPurge(
     stats: stats.n,
     evals: evals.n,
     changelogs: changelogs.n,
+    telemetry,
   };
 }
 
@@ -404,6 +417,14 @@ async function purgeBenchmarkResults(tx: Sql, resultIds: number[]): Promise<void
     WHERE id = ANY(${resultIds}) AND trace_replay_id IS NOT NULL
   `;
 
+  // Drop the point→series links explicitly rather than through the cascade on
+  // benchmark_results, so the transcript records it. The series itself stays: it
+  // belongs to the workflow_run, which survives a point purge, and
+  // /api/gpu-metrics?runId= reads series by run rather than through these links.
+  const unlinked = await unlinkPointTelemetry(tx, resultIds);
+  if (unlinked > 0)
+    console.log(`    unlinked ${unlinked} gpu_metric_series link(s); series kept with the run.`);
+
   await tx`DELETE FROM benchmark_results WHERE id = ANY(${resultIds})`;
 
   const sIds = logRows.map((r) => r.id as number);
@@ -493,6 +514,11 @@ async function purge(wrIds: number[]): Promise<void> {
     await tx`DELETE FROM eval_results WHERE workflow_run_id = ANY(${wrIds})`;
     await tx`DELETE FROM changelog_entries WHERE workflow_run_id = ANY(${wrIds})`;
 
+    // Telemetry too. The workflow_runs delete below would cascade it away anyway,
+    // but silently; deleting it here reports the cost of an irreversible loss.
+    const telemetry = await deleteRunTelemetry(tx, wrIds);
+    if (telemetry.series > 0) console.log(`    deleted ${describeTelemetry(telemetry)}.`);
+
     // Parent last (target the specific workflow_runs rows so partial purges
     // leave sibling attempts of the same github_run_id intact)
     await tx`DELETE FROM workflow_runs WHERE id = ANY(${wrIds})`;
diff --git a/packages/db/src/backfill-gpu-metrics.ts b/packages/db/src/backfill-gpu-metrics.ts
new file mode 100644
index 000000000..cb898f0d8
--- /dev/null
+++ b/packages/db/src/backfill-gpu-metrics.ts
@@ -0,0 +1,675 @@
+/**
+ * Backfill PowerX telemetry (`gpu_metrics_<suffix>` artifacts) into the
+ * migration-016 tables for runs that were ingested before the CI path
+ * digested them.
+ *
+ * GitHub keeps run artifacts for 90 days and the GCS mirror only covers
+ * scheduled/push runs on main, so the reachable history is bounded by GitHub
+ * retention; runs GitHub has since deleted are reported and skipped. Each
+ * gpu_metrics artifact is paired with its exact `bmk_<suffix>`
+ * (or `bmk_agentic_<suffix>`) sibling, the raw rows are mapped through the
+ * production mapper, and the series is linked to those persisted points.
+ *
+ * Usage:
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --run 34557177019 --yes
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --all --yes
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --all --since 2026-08-01 --dry-run
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --all --force --limit 20 --yes
+ *
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --stats-only --all --dry-run
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --stats-only --run 34557177019 --yes
+ *
+ * --stats-only upgrades outdated digests from DB samples without GitHub access.
+ * It includes all retained attempts and dates unless explicitly filtered.
+ *
+ * Runs that already have at least one stored series are skipped unless
+ * --force is passed. --parallel N (default 4) bounds concurrent artifact
+ * downloads within one run.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { hasNoSslFlag } from './cli-utils.js';
+import { AsyncSemaphore } from './etl/async-semaphore.js';
+import { createAdminSql } from './etl/db-utils.js';
+import { ingestGpuMetricsArtifact, refreshGpuMetricStats } from './etl/gpu-metrics-ingest.js';
+import { readPowerAuditValidations } from './etl/gpu-metrics-artifacts.js';
+import { recoveredPowerAudit } from './etl/power-audit-validations.js';
+import {
+  benchmarkPublicationIdentity,
+  stablePowerPointIdentity,
+  type PowerPublicationManifest,
+} from './etl/power-publication.js';
+import {
+  readTelemetryReceipt,
+  summarizeTelemetryReceipt,
+  telemetryArtifactsForAttempt,
+  type TelemetryObservation,
+  type TelemetryReceipt,
+} from './etl/telemetry-receipt.js';
+import { retryArtifactOperation } from './lib/artifact-retry.js';
+import {
+  checkpointBenchmarkRefresh,
+  refreshBackfillBenchmarks,
+  type BenchmarkAuditUpdate,
+} from './lib/backfill-benchmark-refresh.js';
+import {
+  confirmProceed,
+  listBackfillRunArtifacts,
+  parseLimitForceFlags,
+  runBackfillMain,
+} from './lib/backfill-runner.js';
+import {
+  filterPurgedBenchmarkRows,
+  findBenchmarkResultIds,
+  readMappedBenchmarkRows,
+} from './lib/benchmark-result-lookup.js';
+import { downloadArtifact, fetchRunMeta } from './lib/github-artifacts.js';
+import {
+  pairGpuMetricsArtifacts,
+  findOutdatedGpuMetricSeries,
+  collectMissingTelemetryExpectations,
+  type GpuMetricsArtifactPair,
+} from './lib/gpu-metrics-backfill.js';
+import { repositoryFromRunUrl } from './lib/runtime-metadata-artifacts.js';
+
+const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
+const GITHUB_RETENTION_DAYS = 90;
+const sql = createAdminSql({ noSsl: hasNoSslFlag(), max: 4, onnotice: () => {} });
+
+interface CandidateRun {
+  id: number;
+  github_run_id: number;
+  run_attempt: number;
+  html_url: string | null;
+  date: string;
+  series_count: number;
+}
+
+interface BackfillFlags {
+  all: boolean;
+  dryRun: boolean;
+  run: number | null;
+  fromRun: number | null;
+  since: string | null;
+  parallel: number;
+  attempt: number | null;
+  artifact: string | null;
+  receipt: string | null;
+  refreshCacheOnly: boolean;
+  statsOnly: boolean;
+}
+
+function positiveIntFlag(flag: string): number | null {
+  const index = process.argv.indexOf(flag);
+  if (index === -1) return null;
+  const raw = process.argv[index + 1];
+  if (!raw || !/^\d+$/u.test(raw) || Number(raw) <= 0) {
+    throw new Error(`${flag} requires a positive integer`);
+  }
+  return Number(raw);
+}
+
+function stringFlag(flag: string): string | null {
+  const index = process.argv.indexOf(flag);
+  if (index === -1) return null;
+  const value = process.argv[index + 1];
+  if (!value || value.startsWith('--')) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+function parseFlags(): BackfillFlags {
+  const sinceIndex = process.argv.indexOf('--since');
+  const since = sinceIndex === -1 ? null : (process.argv[sinceIndex + 1] ?? null);
+  if (sinceIndex !== -1 && (!since || !/^\d{4}-\d{2}-\d{2}$/u.test(since))) {
+    throw new Error('--since requires a YYYY-MM-DD date');
+  }
+  return {
+    all: process.argv.includes('--all'),
+    dryRun: process.argv.includes('--dry-run'),
+    run: positiveIntFlag('--run'),
+    fromRun: positiveIntFlag('--from-run'),
+    since,
+    parallel: positiveIntFlag('--parallel') ?? 4,
+    attempt: positiveIntFlag('--attempt'),
+    artifact: stringFlag('--artifact'),
+    receipt: stringFlag('--receipt'),
+    refreshCacheOnly: process.argv.includes('--refresh-cache-only'),
+    statsOnly: process.argv.includes('--stats-only'),
+  };
+}
+
+function isWithinGithubRetention(date: string): boolean {
+  const ageMs = Date.now() - new Date(date).getTime();
+  return ageMs <= GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+}
+
+async function loadCandidateRuns(
+  flags: BackfillFlags,
+  limit: number | null,
+  force: boolean,
+): Promise<CandidateRun[]> {
+  const cutoff = new Date(Date.now() - GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000)
+    .toISOString()
+    .slice(0, 10);
+  const since = flags.since ?? cutoff;
+  const rows = await sql<CandidateRun[]>`
+    select wr.id, wr.github_run_id, wr.run_attempt, wr.html_url, wr.date::text as date,
+      (select count(*)::int from gpu_metric_series s where s.workflow_run_id = wr.id) as series_count
+    from workflow_runs wr
+    where exists (select 1 from benchmark_results br where br.workflow_run_id = wr.id)
+      and (${flags.run}::bigint is null or wr.github_run_id = ${flags.run})
+      and (${flags.fromRun}::bigint is null or wr.github_run_id >= ${flags.fromRun})
+      and (${flags.run}::bigint is not null or wr.date >= ${since}::date)
+      and ((${flags.attempt}::integer is not null and wr.run_attempt = ${flags.attempt}) or
+        (${flags.attempt}::integer is null and not exists (
+          select 1 from workflow_runs newer where newer.github_run_id = wr.github_run_id
+            and newer.run_attempt > wr.run_attempt)))
+    order by wr.date desc, wr.github_run_id desc
+  `;
+  const candidates = rows
+    .map((row) => ({
+      ...row,
+      id: Number(row.id),
+      github_run_id: Number(row.github_run_id),
+      series_count: Number(row.series_count),
+    }))
+    .filter((row) => force || flags.run !== null || row.series_count === 0);
+  return limit === null ? candidates : candidates.slice(0, limit);
+}
+
+type PairOutcome =
+  | {
+      kind: 'ingested';
+      seriesCount: number;
+      samplesInserted: number;
+      pointsLinked: number;
+      expectationsUnknown: boolean;
+      metadataUpdatedBenchmarkResultIds: number[];
+    }
+  | { kind: 'unmatched' }
+  | { kind: 'failed' };
+
+/** Download one gpu_metrics/bmk pair, resolve its points, and persist the series. */
+async function processPair(
+  run: CandidateRun,
+  pair: GpuMetricsArtifactPair,
+  tempDir: string,
+  observations: Map<string, TelemetryObservation>,
+  expectationErrors: NonNullable<TelemetryReceipt['expectationErrors']>,
+  uniqueFallbacks: Map<string, number>,
+  checkpointMetadata: (updates: BenchmarkAuditUpdate[]) => Promise<void>,
+): Promise<PairOutcome> {
+  let benchmarkDir: string | null = null;
+  let gpuMetricsDir: string | null = null;
+  const pointKeys: string[] = [];
+  let expectationsUnknown = false;
+  try {
+    benchmarkDir = await retryArtifactOperation(`downloading ${pair.benchmarks.name}`, () =>
+      downloadArtifact(pair.benchmarks, tempDir),
+    );
+    const mappedRows = await filterPurgedBenchmarkRows(
+      sql,
+      run,
+      readMappedBenchmarkRows(benchmarkDir, (error) => {
+        expectationsUnknown = true;
+        expectationErrors.push({
+          benchmarkArtifact: pair.benchmarks.name,
+          artifactNames: [pair.gpuMetrics.name],
+          error,
+        });
+      }),
+    );
+    for (const row of mappedRows) {
+      const identity = benchmarkPublicationIdentity(row);
+      const key = stablePowerPointIdentity(identity);
+      pointKeys.push(key);
+      observations.set(key, { identity, artifactNames: [pair.gpuMetrics.name], produced: true });
+    }
+    const matchedIds: number[] = [];
+    const mappedPoints: { ids: number[]; identity: Record<string, unknown> }[] = [];
+    for (const row of mappedRows) {
+      const ids = await findBenchmarkResultIds(sql, run, [row], (id) =>
+        uniqueFallbacks.set(stablePowerPointIdentity(benchmarkPublicationIdentity(row)), id),
+      );
+      if (ids.length === 0) throw new Error(`${pair.gpuMetrics.name}: no matching benchmark rows`);
+      matchedIds.push(...ids);
+      if (row.benchmarkType === 'agentic_traces')
+        mappedPoints.push({ ids, identity: benchmarkPublicationIdentity(row) });
+    }
+    const resultIds = [...new Set(matchedIds)];
+    if (resultIds.length === 0) {
+      if (expectationsUnknown) return { kind: 'failed' };
+      console.warn(`  [WARN] ${pair.gpuMetrics.name}: no matching benchmark rows`);
+      return { kind: 'unmatched' };
+    }
+    gpuMetricsDir = await retryArtifactOperation(`downloading ${pair.gpuMetrics.name}`, () =>
+      downloadArtifact(pair.gpuMetrics, tempDir),
+    );
+    const validations = Object.entries(
+      readPowerAuditValidations(gpuMetricsDir, pair.gpuMetrics.name),
+    )
+      .map(([source, validation]) => ({
+        powerAudit: recoveredPowerAudit(source, validation),
+        conc: (validation.selected_window as Record<string, unknown> | undefined)?.concurrency,
+      }))
+      .filter((validation) => validation.powerAudit !== null);
+    const auditUpdates: BenchmarkAuditUpdate[] = [];
+    for (const point of mappedPoints) {
+      const candidates = validations.filter(
+        (validation) => validation.conc === point.identity.conc,
+      );
+      if (candidates.length !== 1) continue;
+      const powerAudit = candidates[0]!.powerAudit;
+      if (powerAudit)
+        auditUpdates.push(
+          ...point.ids.map((benchmarkResultId) => ({
+            benchmarkResultId,
+            identity: point.identity,
+            powerAudit,
+          })),
+        );
+    }
+    await checkpointMetadata(auditUpdates);
+    const ingested = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: run.id,
+      artifact: { artifactName: pair.gpuMetrics.name, artifactDir: gpuMetricsDir },
+      benchmarkResultIds: resultIds,
+    });
+    if (ingested.seriesIds.length === 0) {
+      throw new Error(`${pair.gpuMetrics.name}: no parseable gpu_metrics CSV`);
+    }
+    return {
+      kind: 'ingested',
+      seriesCount: ingested.seriesIds.length,
+      samplesInserted: ingested.samplesInserted,
+      pointsLinked: resultIds.length,
+      expectationsUnknown,
+      metadataUpdatedBenchmarkResultIds: ingested.metadataUpdatedBenchmarkResultIds,
+    };
+  } catch (error) {
+    if (pointKeys.length === 0)
+      expectationErrors.push({
+        benchmarkArtifact: pair.benchmarks.name,
+        artifactNames: [pair.gpuMetrics.name],
+        error: error instanceof Error ? error.message : String(error),
+      });
+    for (const key of pointKeys) {
+      const observation = observations.get(key)!;
+      observation.error = error instanceof Error ? error.message : String(error);
+    }
+    console.error(`  ✗ run ${run.github_run_id} artifact ${pair.gpuMetrics.name}:`, error);
+    return { kind: 'failed' };
+  } finally {
+    if (benchmarkDir) fs.rmSync(benchmarkDir, { recursive: true, force: true });
+    if (gpuMetricsDir) fs.rmSync(gpuMetricsDir, { recursive: true, force: true });
+  }
+}
+
+async function main(): Promise<void> {
+  const flags = parseFlags();
+  const { limit, force } = parseLimitForceFlags();
+  if (!flags.all && flags.run === null) {
+    throw new Error('Pass --run <github run id> or --all');
+  }
+  if ((flags.attempt !== null || flags.artifact || flags.receipt) && flags.run === null)
+    throw new Error('--attempt, --artifact and --receipt require --run');
+  if (
+    flags.refreshCacheOnly &&
+    (!flags.run || !flags.receipt || flags.artifact || flags.all || flags.dryRun)
+  )
+    throw new Error(
+      '--refresh-cache-only requires --run and --receipt, without --all, --artifact or --dry-run',
+    );
+  if (flags.refreshCacheOnly && !fs.existsSync(flags.receipt!))
+    throw new Error('--refresh-cache-only requires an existing receipt');
+
+  if (flags.statsOnly) {
+    if (flags.refreshCacheOnly || flags.receipt || force)
+      throw new Error(
+        '--stats-only cannot be combined with --refresh-cache-only, --receipt or --force',
+      );
+    const series = await findOutdatedGpuMetricSeries(sql, flags, limit);
+    console.log(`${series.length} outdated digest(s); --limit counts series in --stats-only mode`);
+    if (flags.dryRun) {
+      console.table(series);
+      return;
+    }
+    if (
+      series.length === 0 ||
+      !(await confirmProceed('Recompute only these stored telemetry digests?'))
+    )
+      return;
+    for (const row of series) {
+      try {
+        const updated = await refreshGpuMetricStats(sql, Number(row.id));
+        console.log(
+          `series ${row.id} run ${row.github_run_id} attempt ${row.run_attempt}: ${updated ? 'updated' : 'current'}`,
+        );
+      } catch (error) {
+        process.exitCode = 1;
+        console.error(
+          `series ${row.id} failed; retry --stats-only --run ${row.github_run_id} --attempt ${row.run_attempt} --artifact ${row.artifact_name} --yes`,
+          error,
+        );
+      }
+    }
+    return;
+  }
+
+  console.log('=== backfill-gpu-metrics ===');
+  const runs = await loadCandidateRuns(flags, limit, force);
+  const staleRuns = runs.filter((run) => !isWithinGithubRetention(run.date)).length;
+  const staleNote =
+    staleRuns > 0
+      ? ` (${staleRuns} older than GitHub's ${GITHUB_RETENTION_DAYS}-day retention)`
+      : '';
+  console.log(`  ${runs.length} candidate run(s)${staleNote}`);
+  if (runs.length === 0) {
+    if (flags.attempt !== null || flags.artifact || flags.receipt)
+      throw new Error(
+        `No persisted benchmark target for run ${flags.run} attempt ${flags.attempt ?? 'latest'}`,
+      );
+    console.log('\n  Nothing to do.');
+    return;
+  }
+
+  if (flags.dryRun) {
+    let pairedRuns = 0;
+    let pairs = 0;
+    let goneRuns = 0;
+    let failedRuns = 0;
+    for (const run of runs) {
+      try {
+        const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
+        const artifacts = await listBackfillRunArtifacts(repository, run.github_run_id);
+        if (artifacts === null) {
+          goneRuns++;
+          console.log(`  run ${run.github_run_id} (${run.date}): gone from GitHub`);
+          continue;
+        }
+        const runPairs = pairGpuMetricsArtifacts(
+          telemetryArtifactsForAttempt(
+            artifacts,
+            fetchRunMeta(repository, String(run.github_run_id)),
+            run.run_attempt,
+          ),
+        ).filter((pair) => !flags.artifact || pair.gpuMetrics.name === flags.artifact);
+        if (runPairs.length > 0) pairedRuns++;
+        pairs += runPairs.length;
+        console.log(`  run ${run.github_run_id} (${run.date}): ${runPairs.length} pair(s)`);
+      } catch (error) {
+        if (flags.run !== null) throw error;
+        failedRuns++;
+        console.error(
+          `  run ${run.github_run_id} (${run.date}): ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+    console.log(
+      `\n=== dry run: ${runs.length} run(s), ${pairedRuns} with pairs, ${pairs} pair(s), ` +
+        `${goneRuns} gone from GitHub, ${failedRuns} failed ===`,
+    );
+    if (failedRuns > 0) process.exitCode = 1;
+    return;
+  }
+
+  if (
+    !(await confirmProceed(
+      flags.refreshCacheOnly
+        ? 'Only the recorded benchmark metadata cache will be refreshed.'
+        : `${runs.length} workflow run(s) will be checked for gpu_metrics.`,
+    ))
+  ) {
+    return;
+  }
+
+  let artifactsProcessed = 0;
+  let seriesStored = 0;
+  let samplesStored = 0;
+  let pointsLinked = 0;
+  let unmatchedArtifacts = 0;
+  let artifactFailures = 0;
+  let runFailures = 0;
+  let missingRuns = 0;
+  let goneRuns = 0;
+
+  for (const [runIndex, run] of runs.entries()) {
+    const runId = run.github_run_id;
+    const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
+    const runStart = Date.now();
+    const receiptPath =
+      flags.receipt ?? `power-publication-${runId}-attempt-${run.run_attempt}.json`;
+    const manifest: PowerPublicationManifest = fs.existsSync(receiptPath)
+      ? JSON.parse(fs.readFileSync(receiptPath, 'utf8'))
+      : { version: 1, runId, runAttempt: run.run_attempt, points: [] };
+    if (
+      manifest.version !== 1 ||
+      manifest.runId !== runId ||
+      manifest.runAttempt !== run.run_attempt ||
+      !Array.isArray(manifest.points) ||
+      (manifest.telemetry &&
+        (manifest.telemetry.runId !== runId || manifest.telemetry.runAttempt !== run.run_attempt))
+    )
+      throw new Error('Publication receipt run/attempt does not match the recovery target');
+    const saveReceipt = () => {
+      fs.mkdirSync(path.dirname(path.resolve(receiptPath)), { recursive: true });
+      const temporary = `${receiptPath}.tmp`;
+      fs.writeFileSync(temporary, `${JSON.stringify(manifest, null, 2)}\n`, { flush: true });
+      fs.renameSync(temporary, receiptPath);
+    };
+    const refresh = async () => {
+      try {
+        await refreshBackfillBenchmarks(sql, manifest, saveReceipt);
+      } catch (error) {
+        process.exitCode = 1;
+        console.error(
+          `  Benchmark metadata refresh failed; retry --refresh-cache-only --run ${runId} --attempt ${run.run_attempt} --receipt ${receiptPath} --yes`,
+          error,
+        );
+      }
+    };
+    if (flags.refreshCacheOnly) {
+      await refresh();
+      continue;
+    }
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `gpu-metrics-backfill-${runId}-`));
+    const checkpointMetadata = async (updates: BenchmarkAuditUpdate[]) => {
+      if (updates.length === 0) return;
+      const candidates = await sql<{ id: number; offload_mode: string }[]>`
+        select br.id, br.offload_mode from benchmark_results br
+        where br.workflow_run_id = ${run.id}
+          and br.id = any(${sql.array(updates.map((update) => update.benchmarkResultId))}::bigint[])
+          and br.benchmark_type = 'agentic_traces' and br.power_audit is null
+      `;
+      checkpointBenchmarkRefresh(
+        manifest,
+        candidates.map((row) => Number(row.id)),
+        saveReceipt,
+        candidates.map((row) => {
+          const update = updates.find((entry) => entry.benchmarkResultId === Number(row.id))!;
+          return {
+            ...update,
+            sourceIdentity: update.identity,
+            identity: { ...update.identity, offload_mode: row.offload_mode },
+          };
+        }),
+      );
+    };
+    const observations = new Map<string, TelemetryObservation>();
+    const uniqueFallbacks = new Map<string, number>();
+    let recoveryError: string | undefined;
+    let expectationErrors: TelemetryReceipt['expectationErrors'];
+    try {
+      const listedArtifacts = await listBackfillRunArtifacts(repository, runId);
+      if (listedArtifacts === null) {
+        goneRuns++;
+        runFailures++;
+        recoveryError = `Run ${runId} attempt ${run.run_attempt} is gone from GitHub`;
+        console.log(
+          `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt}: gone from GitHub`,
+        );
+        continue;
+      }
+      const artifacts = telemetryArtifactsForAttempt(
+        listedArtifacts,
+        fetchRunMeta(repository, String(runId)),
+        run.run_attempt,
+      );
+      const allPairs = pairGpuMetricsArtifacts(artifacts);
+      const pairs = allPairs.filter(
+        (pair) => !flags.artifact || pair.gpuMetrics.name === flags.artifact,
+      );
+      // Expectations come from benchmark siblings even when no telemetry was
+      // uploaded. Counting only the successful pairs would hide missing points.
+      const missing = await collectMissingTelemetryExpectations(
+        artifacts,
+        allPairs,
+        flags.artifact,
+        async (artifact, onUnmapped) => {
+          let directory: string | null = null;
+          try {
+            directory = await retryArtifactOperation(`downloading ${artifact.name}`, () =>
+              downloadArtifact(artifact, tempDir),
+            );
+            const rows = await filterPurgedBenchmarkRows(
+              sql,
+              run,
+              readMappedBenchmarkRows(directory, onUnmapped),
+            );
+            for (const row of rows)
+              await findBenchmarkResultIds(sql, run, [row], (id) =>
+                uniqueFallbacks.set(
+                  stablePowerPointIdentity(benchmarkPublicationIdentity(row)),
+                  id,
+                ),
+              );
+            return rows;
+          } finally {
+            if (directory) fs.rmSync(directory, { recursive: true, force: true });
+          }
+        },
+      );
+      for (const observation of missing.observations)
+        observations.set(stablePowerPointIdentity(observation.identity), observation);
+      expectationErrors = missing.errors;
+      artifactFailures += new Set(missing.errors.map((error) => error.benchmarkArtifact)).size;
+      if (pairs.length === 0) {
+        if (flags.artifact) {
+          artifactFailures++;
+          recoveryError = `No retained telemetry pair for ${flags.artifact}`;
+        }
+        missingRuns++;
+        console.log(
+          `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt}: no retained gpu_metrics pairs`,
+        );
+        continue;
+      }
+
+      const limiter = new AsyncSemaphore(flags.parallel);
+      const outcomes = await Promise.all(
+        pairs.map((pair) =>
+          limiter.run(() =>
+            processPair(
+              run,
+              pair,
+              tempDir,
+              observations,
+              missing.errors,
+              uniqueFallbacks,
+              checkpointMetadata,
+            ),
+          ),
+        ),
+      );
+      let runSeries = 0;
+      let runSamples = 0;
+      for (const outcome of outcomes) {
+        switch (outcome.kind) {
+          case 'ingested': {
+            artifactsProcessed++;
+            if (outcome.expectationsUnknown) artifactFailures++;
+            runSeries += outcome.seriesCount;
+            runSamples += outcome.samplesInserted;
+            pointsLinked += outcome.pointsLinked;
+            checkpointBenchmarkRefresh(
+              manifest,
+              outcome.metadataUpdatedBenchmarkResultIds,
+              saveReceipt,
+            );
+            break;
+          }
+          case 'unmatched': {
+            unmatchedArtifacts++;
+            break;
+          }
+          case 'failed': {
+            artifactFailures++;
+            break;
+          }
+        }
+      }
+      seriesStored += runSeries;
+      samplesStored += runSamples;
+      console.log(
+        `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt} (${run.date}): ` +
+          `${pairs.length} pair(s), ${runSeries} series, +${runSamples} samples ` +
+          `(${((Date.now() - runStart) / 1000).toFixed(1)}s)`,
+      );
+    } catch (error) {
+      runFailures++;
+      recoveryError = error instanceof Error ? error.message : String(error);
+      console.error(`  ✗ run ${runId}:`, error);
+    } finally {
+      manifest.telemetry = await readTelemetryReceipt(
+        sql,
+        { runId, runAttempt: run.run_attempt },
+        [...observations.values()],
+        { previous: manifest.telemetry, targeted: Boolean(flags.artifact), uniqueFallbacks },
+      );
+      if (recoveryError) {
+        const priorError = manifest.telemetry.recoveryError;
+        const priorScope = manifest.telemetry.recoveryArtifactNames;
+        manifest.telemetry.recoveryError = [
+          ...new Set([priorError, recoveryError].filter(Boolean).join('\n').split('\n')),
+        ].join('\n');
+        if (flags.artifact && (!priorError || priorScope))
+          manifest.telemetry.recoveryArtifactNames = [
+            ...new Set([...(priorScope ?? []), flags.artifact]),
+          ];
+        else delete manifest.telemetry.recoveryArtifactNames;
+      }
+      if (expectationErrors) {
+        const failedBenchmarks = new Set(expectationErrors.map((error) => error.benchmarkArtifact));
+        manifest.telemetry.expectationErrors = [
+          ...(manifest.telemetry.expectationErrors ?? []).filter(
+            (error) => !failedBenchmarks.has(error.benchmarkArtifact),
+          ),
+          ...expectationErrors,
+        ];
+      }
+      summarizeTelemetryReceipt(manifest.telemetry);
+      saveReceipt();
+      if (manifest.benchmarkRefresh && manifest.benchmarkRefresh.status !== 'complete')
+        await refresh();
+      console.log(`  PowerX ingest receipt: ${receiptPath}`);
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+
+  console.log(
+    `\n=== backfill complete: ${artifactsProcessed} artifact(s), ${seriesStored} series, ` +
+      `${samplesStored} sample(s), ${pointsLinked} point link(s), ` +
+      `${unmatchedArtifacts} unmatched artifact(s), ` +
+      `${missingRuns} run(s) without pairs, ${goneRuns} run(s) gone from GitHub, ` +
+      `${artifactFailures} failed artifact(s), ${runFailures} failed run(s) ===`,
+  );
+  console.log(
+    '  Point telemetry reads use the stored revision; API verification is recorded separately.',
+  );
+  if (artifactFailures > 0 || runFailures > 0) process.exitCode = 1;
+}
+
+runBackfillMain('backfill-gpu-metrics', sql, main);
diff --git a/packages/db/src/backfill-server-log-files.ts b/packages/db/src/backfill-server-log-files.ts
index 8047e0db5..46c0d05be 100644
--- a/packages/db/src/backfill-server-log-files.ts
+++ b/packages/db/src/backfill-server-log-files.ts
@@ -19,24 +19,25 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { hasNoSslFlag } from './cli-utils.js';
-import { mapBenchmarkRow, type BenchmarkParams } from './etl/benchmark-mapper.js';
 import { insertServerLogFilePaths } from './etl/benchmark-ingest.js';
 import { createAdminSql } from './etl/db-utils.js';
 import { listServerLogFilePaths, serverLogArtifactRoot } from './etl/server-log-artifacts.js';
-import { createSkipTracker } from './etl/skip-tracker.js';
-import { downloadArtifact, listRunArtifacts } from './lib/github-artifacts.js';
+import { downloadArtifact } from './lib/github-artifacts.js';
 import {
   downloadGcsArtifact,
   listGcsServerLogArtifacts,
   type GcsArtifactMeta,
 } from './lib/gcs-artifacts.js';
-import { confirmProceed, parseLimitForceFlags, runBackfillMain } from './lib/backfill-runner.js';
+import {
+  confirmProceed,
+  listBackfillRunArtifacts,
+  parseLimitForceFlags,
+  runBackfillMain,
+} from './lib/backfill-runner.js';
 import { retryArtifactOperation } from './lib/artifact-retry.js';
+import { findBenchmarkResultIds, readMappedBenchmarkRows } from './lib/benchmark-result-lookup.js';
 import { repositoryFromRunUrl } from './lib/runtime-metadata-artifacts.js';
-import {
-  pairServerLogArtifacts,
-  resolveServerLogResultCandidates,
-} from './lib/server-log-backfill.js';
+import { pairServerLogArtifacts } from './lib/server-log-backfill.js';
 
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 const RETENTION_DAYS = 90;
@@ -94,86 +95,6 @@ function parseBackfillFlags(): BackfillFlags {
   };
 }
 
-function findJsonFiles(root: string): string[] {
-  const files: string[] = [];
-  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
-    const pathname = path.join(root, entry.name);
-    if (entry.isDirectory()) files.push(...findJsonFiles(pathname));
-    else if (entry.isFile() && entry.name.endsWith('.json')) files.push(pathname);
-  }
-  return files.toSorted();
-}
-
-function readMappedRows(root: string): BenchmarkParams[] {
-  const tracker = createSkipTracker();
-  const rows: BenchmarkParams[] = [];
-  for (const file of findJsonFiles(root)) {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as unknown;
-    const rawRows = Array.isArray(parsed) ? parsed : [parsed];
-    for (const raw of rawRows) {
-      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
-      const mapped = mapBenchmarkRow(raw as Record<string, unknown>, tracker);
-      if (mapped) rows.push(mapped);
-    }
-  }
-  return rows;
-}
-
-async function findBenchmarkResultIds(
-  run: CandidateRun,
-  rows: readonly BenchmarkParams[],
-): Promise<number[]> {
-  const ids = new Set<number>();
-  for (const row of rows) {
-    const c = row.config;
-    const candidates = await sql<{ id: number; offload_mode: string }[]>`
-      select br.id, br.offload_mode
-      from benchmark_results br
-      join workflow_runs wr on wr.id = br.workflow_run_id
-      join configs cfg on cfg.id = br.config_id
-      where wr.github_run_id = ${run.github_run_id}
-        and wr.run_attempt = ${run.run_attempt}
-        and cfg.hardware = ${c.hardware}
-        and cfg.framework = ${c.framework}
-        and cfg.model = ${c.model}
-        and cfg.precision = ${c.precision}
-        and cfg.spec_method = ${c.specMethod}
-        and cfg.disagg = ${c.disagg}
-        and cfg.is_multinode = ${c.isMultinode}
-        and cfg.prefill_tp = ${c.prefillTp}
-        and cfg.prefill_ep = ${c.prefillEp}
-        and cfg.prefill_dp_attention = ${c.prefillDpAttn}
-        and cfg.prefill_num_workers = ${c.prefillNumWorkers}
-        and cfg.decode_tp = ${c.decodeTp}
-        and cfg.decode_ep = ${c.decodeEp}
-        and cfg.decode_dp_attention = ${c.decodeDpAttn}
-        and cfg.decode_num_workers = ${c.decodeNumWorkers}
-        and cfg.num_prefill_gpu = ${c.numPrefillGpu}
-        and cfg.num_decode_gpu = ${c.numDecodeGpu}
-        and br.benchmark_type = ${row.benchmarkType}
-        and br.isl is not distinct from ${row.isl}
-        and br.osl is not distinct from ${row.osl}
-        and br.conc = ${row.conc}
-        and br.recipe_fingerprint is not distinct from ${row.recipeFingerprint}
-    `;
-    const resolution = resolveServerLogResultCandidates(
-      candidates.map((candidate) => ({
-        id: Number(candidate.id),
-        offloadMode: candidate.offload_mode,
-      })),
-      row.offloadMode,
-    );
-    if (resolution.usedUniqueFallback) {
-      console.warn(
-        `  [WARN] benchmark result ${resolution.ids[0]} uses a historical offload label; ` +
-          `matched uniquely without offload_mode`,
-      );
-    }
-    for (const id of resolution.ids) ids.add(id);
-  }
-  return [...ids];
-}
-
 async function resultLogsAreComplete(resultIds: readonly number[]): Promise<boolean> {
   if (resultIds.length === 0) return false;
   const [row] = await sql<{ complete: boolean }[]>`
@@ -281,11 +202,8 @@ async function main(): Promise<void> {
         flags.source !== 'gcs' &&
         (flags.source === 'github' || isWithinGithubRetention(run.date))
       ) {
-        const artifacts = await retryArtifactOperation(
-          `listing GitHub artifacts for run ${runId}`,
-          () => listRunArtifacts(repository, String(runId)),
-        );
-        pairs = pairServerLogArtifacts(artifacts.filter((artifact) => !artifact.expired));
+        const artifacts = await listBackfillRunArtifacts(repository, runId);
+        pairs = pairServerLogArtifacts((artifacts ?? []).filter((artifact) => !artifact.expired));
         if (pairs.length > 0) {
           source = 'github';
           githubRuns++;
@@ -311,8 +229,13 @@ async function main(): Promise<void> {
               : await retryArtifactOperation(`downloading ${pair.benchmarks.name}`, () =>
                   downloadArtifact(pair.benchmarks, tempDir),
                 );
-          const mappedRows = readMappedRows(benchmarkDir);
-          const resultIds = await findBenchmarkResultIds(run, mappedRows);
+          const mappedRows = readMappedBenchmarkRows(benchmarkDir);
+          const resultIds = await findBenchmarkResultIds(sql, run, mappedRows, (id) =>
+            console.warn(
+              `  [WARN] benchmark result ${id} uses a historical offload label; ` +
+                `matched uniquely without offload_mode`,
+            ),
+          );
           if (resultIds.length === 0) {
             unmatchedArtifacts++;
             console.warn(`  [WARN] ${pair.serverLogs.name}: no matching benchmark rows`);
diff --git a/packages/db/src/lib/backfill-benchmark-refresh.ts b/packages/db/src/lib/backfill-benchmark-refresh.ts
new file mode 100644
index 000000000..15d2d60f6
--- /dev/null
+++ b/packages/db/src/lib/backfill-benchmark-refresh.ts
@@ -0,0 +1,224 @@
+import { isDeepStrictEqual } from 'node:util';
+import { DB_MODEL_TO_DISPLAY } from '@semianalysisai/inferencex-constants';
+import { refreshLatestBenchmarks, type Sql } from '../etl/db-utils.js';
+import {
+  stablePowerPointIdentity,
+  type PowerPublicationManifest,
+} from '../etl/power-publication.js';
+
+export type BenchmarkAuditUpdate = NonNullable<
+  NonNullable<PowerPublicationManifest['benchmarkRefresh']>['auditUpdates']
+>[number];
+
+function refreshTarget(manifest: PowerPublicationManifest) {
+  const raw = process.env.CACHE_INVALIDATE_URL;
+  if (!raw) throw new Error('CACHE_INVALIDATE_URL is required for benchmark metadata refresh');
+  const endpoint = new URL(raw);
+  if (
+    !['http:', 'https:'].includes(endpoint.protocol) ||
+    endpoint.pathname !== '/api/v1/invalidate' ||
+    endpoint.search ||
+    endpoint.hash ||
+    endpoint.username ||
+    endpoint.password
+  )
+    throw new Error(
+      'CACHE_INVALIDATE_URL must name /api/v1/invalidate without credentials or query',
+    );
+  const previous = manifest.benchmarkRefresh?.endpoint;
+  if (previous && previous !== endpoint.href)
+    throw new Error('Benchmark refresh receipt target differs from CACHE_INVALIDATE_URL');
+  const secret = process.env.CACHE_INVALIDATE_SECRET || process.env.INVALIDATE_SECRET;
+  if (!secret) throw new Error('CACHE_INVALIDATE_SECRET or INVALIDATE_SECRET is required');
+  return {
+    endpoint,
+    headers: {
+      Authorization: `Bearer ${secret}`,
+      ...(process.env.CACHE_PROTECTION_BYPASS_SECRET
+        ? { 'x-vercel-protection-bypass': process.env.CACHE_PROTECTION_BYPASS_SECRET }
+        : {}),
+    },
+  };
+}
+
+/** Persist possible writes before ingest, including a crash before UPDATE returns its IDs. */
+export function checkpointBenchmarkRefresh(
+  manifest: PowerPublicationManifest,
+  ids: number[],
+  save: () => void,
+  auditUpdates: BenchmarkAuditUpdate[] = [],
+): void {
+  if (ids.length === 0) return;
+  const previous = manifest.benchmarkRefresh;
+  manifest.benchmarkRefresh = {
+    status: 'pending',
+    benchmarkResultIds: [
+      ...new Set([
+        ...(previous?.status === 'complete' ? [] : (previous?.benchmarkResultIds ?? [])),
+        ...ids,
+      ]),
+    ],
+    auditUpdates: [...(previous?.auditUpdates ?? [])],
+    ...(previous?.endpoint ? { endpoint: previous.endpoint } : {}),
+  };
+  for (const update of auditUpdates) {
+    const existing = manifest.benchmarkRefresh.auditUpdates!.find(
+      (value) => value.benchmarkResultId === update.benchmarkResultId,
+    );
+    if (
+      existing &&
+      (!isDeepStrictEqual(existing.powerAudit, update.powerAudit) ||
+        stablePowerPointIdentity(existing.identity) !== stablePowerPointIdentity(update.identity))
+    )
+      throw new Error('Conflicting retained audit evidence for benchmark refresh');
+    if (!existing) manifest.benchmarkRefresh.auditUpdates!.push(update);
+  }
+  save();
+  try {
+    manifest.benchmarkRefresh.endpoint = refreshTarget(manifest).endpoint.href;
+  } catch (error) {
+    manifest.benchmarkRefresh.status = 'failed';
+    manifest.benchmarkRefresh.error = error instanceof Error ? error.message : String(error);
+    throw error;
+  } finally {
+    save();
+  }
+}
+
+/** Retry only the materialized view/cache/API phase; never download or rewrite samples. */
+export async function refreshBackfillBenchmarks(
+  sql: Sql,
+  manifest: PowerPublicationManifest,
+  save: () => void,
+): Promise<void> {
+  const receipt = manifest.benchmarkRefresh;
+  if (!receipt) throw new Error('Receipt has no benchmark metadata refresh responsibility');
+  receipt.status = 'pending';
+  receipt.checkedAt = new Date().toISOString();
+  delete receipt.error;
+  save();
+  let phase = 'validate target';
+  try {
+    const { endpoint, headers } = refreshTarget(manifest);
+    receipt.endpoint = endpoint.href;
+    save();
+    const ids = receipt.benchmarkResultIds;
+    if (
+      !Array.isArray(ids) ||
+      ids.some((id) => !Number.isSafeInteger(id) || id <= 0) ||
+      new Set(ids).size !== ids.length
+    )
+      throw new Error('Invalid benchmarkResultIds in refresh receipt');
+    const rows = await sql<
+      (Record<string, unknown> & { id: number; model: string; power_audit: unknown })[]
+    >`
+      select c.*, br.id, br.benchmark_type, br.isl, br.osl, br.conc, br.offload_mode,
+        br.recipe_fingerprint, br.power_audit from benchmark_results br
+      join configs c on c.id = br.config_id
+      join workflow_runs wr on wr.id = br.workflow_run_id
+      where wr.github_run_id = ${manifest.runId} and wr.run_attempt = ${manifest.runAttempt}
+        and br.id = any(${sql.array(ids)}::bigint[])
+    `;
+    if (rows.length !== ids.length)
+      throw new Error('Refresh receipt IDs do not belong to its run/attempt');
+    const changed = rows;
+    for (const row of changed) {
+      const audit = row.power_audit;
+      if (audit === null)
+        throw new Error(
+          `Benchmark ${row.id} power_audit is NULL; targeted artifact re-ingest is required before cache refresh`,
+        );
+      if (
+        !audit ||
+        typeof audit !== 'object' ||
+        Array.isArray(audit) ||
+        !('source' in audit) ||
+        typeof audit.source !== 'string' ||
+        !audit.source.trim()
+      )
+        throw new Error(`Benchmark ${row.id} power_audit must be an object with a nonempty source`);
+      const updates =
+        receipt.auditUpdates?.filter((update) => update.benchmarkResultId === Number(row.id)) ?? [];
+      if (updates.length !== 1 || !isDeepStrictEqual(updates[0]!.powerAudit, audit))
+        throw new Error(`Benchmark ${row.id} power_audit differs from retained source evidence`);
+      const update = updates[0]!;
+      if (stablePowerPointIdentity(update.identity) !== stablePowerPointIdentity(row))
+        throw new Error(`Benchmark ${row.id} identity differs from retained source mapping`);
+      const identities = new Set(
+        [update.identity, update.sourceIdentity ?? update.identity].map(stablePowerPointIdentity),
+      );
+      const points = manifest.points.filter((point) =>
+        identities.has(stablePowerPointIdentity(point.identity)),
+      );
+      if (points.length > 1)
+        throw new Error(`Ambiguous publication identity for benchmark ${row.id}`);
+      if (
+        points.length === 1 &&
+        (points[0]!.power_audit === null || points[0]!.power_audit === undefined)
+      )
+        points[0]!.power_audit = update.powerAudit;
+    }
+    save();
+    if (changed.length > 0) {
+      phase = 'refresh latest_benchmarks';
+      await refreshLatestBenchmarks(sql);
+      phase = 'invalidate cache';
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers,
+        redirect: 'error',
+        signal: AbortSignal.timeout(30_000),
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const result = await response.json();
+      if (
+        result?.invalidated !== true ||
+        !Number.isSafeInteger(result.blobsDeleted) ||
+        result.blobsDeleted < 0
+      )
+        throw new Error('Invalid cache invalidation response');
+      phase = 'verify benchmark API';
+      for (const model of new Set(changed.map((row) => row.model))) {
+        const displayModel = DB_MODEL_TO_DISPLAY[model];
+        if (!displayModel) throw new Error(`Unmapped public model: ${model}`);
+        const url = new URL('/api/v1/benchmarks', endpoint);
+        url.search = new URLSearchParams({
+          model: displayModel,
+          runId: String(manifest.runId),
+          exactRun: 'true',
+        }).toString();
+        const api = await fetch(url, {
+          headers: process.env.CACHE_PROTECTION_BYPASS_SECRET
+            ? { 'x-vercel-protection-bypass': process.env.CACHE_PROTECTION_BYPASS_SECRET }
+            : undefined,
+          redirect: 'error',
+          signal: AbortSignal.timeout(30_000),
+        });
+        if (!api.ok) throw new Error(`HTTP ${api.status}`);
+        const body: unknown = await api.json();
+        if (!Array.isArray(body)) throw new Error('Invalid benchmark API response');
+        for (const row of changed.filter((entry) => entry.model === model)) {
+          const matches = body.filter((candidate) => {
+            const raw = candidate?.id;
+            const id =
+              typeof raw === 'number'
+                ? raw
+                : typeof raw === 'string' && /^[1-9]\d*$/u.test(raw)
+                  ? Number(raw)
+                  : NaN;
+            return Number.isSafeInteger(id) && id > 0 && id === Number(row.id);
+          });
+          if (matches.length !== 1 || !isDeepStrictEqual(matches[0].power_audit, row.power_audit))
+            throw new Error(`Benchmark ${row.id} power_audit differs from database`);
+        }
+      }
+    }
+    receipt.status = 'complete';
+  } catch (error) {
+    receipt.status = 'failed';
+    receipt.error = `${phase}: ${error instanceof Error ? error.message : String(error)}`;
+    throw new Error(receipt.error, { cause: error });
+  } finally {
+    save();
+  }
+}
diff --git a/packages/db/src/lib/backfill-runner.ts b/packages/db/src/lib/backfill-runner.ts
index 876e559b2..2051e493d 100644
--- a/packages/db/src/lib/backfill-runner.ts
+++ b/packages/db/src/lib/backfill-runner.ts
@@ -8,6 +8,12 @@
 
 import { confirm, hasYesFlag } from '../cli-utils.js';
 import type { Sql } from '../etl/db-utils.js';
+import { retryArtifactOperation } from './artifact-retry.js';
+import {
+  WorkflowRunNotFoundError,
+  listRunArtifacts,
+  type ArtifactMeta,
+} from './github-artifacts.js';
 
 export interface LimitForceFlags {
   limit: number | null;
@@ -165,6 +171,25 @@ export async function runCandidateIdBackfill(
  * class instances/prototypes so postgres.js serializes plain data only —
  * matches what the inline ingest path stores.
  */
+/**
+ * List a candidate run's GitHub artifacts with transient-failure retry.
+ * Returns `null` when GitHub no longer has the run at all, so a sweep over
+ * months of history reports the gap and moves on instead of aborting.
+ */
+export async function listBackfillRunArtifacts(
+  repository: string,
+  runId: number,
+): Promise<ArtifactMeta[] | null> {
+  try {
+    return await retryArtifactOperation(`listing GitHub artifacts for run ${runId}`, () =>
+      listRunArtifacts(repository, String(runId)),
+    );
+  } catch (error) {
+    if (error instanceof WorkflowRunNotFoundError) return null;
+    throw error;
+  }
+}
+
 export function jsonbParam(sql: Sql, value: unknown): ReturnType<Sql['json']> {
   return sql.json(structuredClone(value) as unknown as Parameters<typeof sql.json>[0]);
 }
diff --git a/packages/db/src/lib/benchmark-result-lookup.test.ts b/packages/db/src/lib/benchmark-result-lookup.test.ts
new file mode 100644
index 000000000..15478e635
--- /dev/null
+++ b/packages/db/src/lib/benchmark-result-lookup.test.ts
@@ -0,0 +1,164 @@
+import fs from 'node:fs';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import { mapBenchmarkRow, type BenchmarkParams } from '../etl/benchmark-mapper';
+import { createSkipTracker } from '../etl/skip-tracker';
+import { filterPurgedBenchmarkRows, findBenchmarkResultIds } from './benchmark-result-lookup';
+import { collectMissingTelemetryExpectations } from './gpu-metrics-backfill';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+let sql: Sql;
+const roots: string[] = [];
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, { json: JSON.stringify, array: (value: unknown) => value });
+}
+
+const GITHUB_RUN_ID = 34557177019;
+const RUN = { github_run_id: GITHUB_RUN_ID, run_attempt: 2 };
+
+/** Raw `bmk_` JSON as the runner emits it for a fixed-sequence sweep. */
+function rawRow(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    infmax_model_prefix: 'dsr1',
+    hw: 'b200-nv',
+    framework: 'sglang',
+    precision: 'fp4',
+    isl: 8192,
+    osl: 1024,
+    conc: 32,
+    tp: 8,
+    ep: 1,
+    dp_attention: false,
+    tput_per_gpu: 1234.5,
+    ...overrides,
+  };
+}
+
+function mapped(raw: Record<string, unknown>): BenchmarkParams {
+  const row = mapBenchmarkRow(raw, createSkipTracker());
+  if (!row) throw new Error('fixture did not map');
+  return row;
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  const dir = new URL('../../migrations/', import.meta.url);
+  for (const name of fs.readdirSync(dir).toSorted()) {
+    if (name.endsWith('.sql')) await db.exec(fs.readFileSync(new URL(name, dir), 'utf8'));
+  }
+  sql = queryClient(db) as unknown as Sql;
+}, 30_000);
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+afterAll(async () => {
+  await db?.close();
+});
+
+/**
+ * Config 1 matches the fixture rows; config 2 differs only in decode_tp. Attempt 1
+ * of the same GitHub run holds a point that must never be matched from attempt 2.
+ */
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
+    VALUES (1, ${GITHUB_RUN_ID}, 1, 'Run Sweep', '2026-09-11T04:00:00Z', '2026-09-11'),
+           (2, ${GITHUB_RUN_ID}, 2, 'Run Sweep', '2026-09-11T06:00:00Z', '2026-09-11');
+
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      is_multinode, prefill_tp, prefill_ep, prefill_dp_attention, prefill_num_workers,
+      decode_tp, decode_ep, decode_dp_attention, decode_num_workers,
+      num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, false, 8, 1, false, 0,
+              8, 1, false, 0, 8, 8),
+           (2, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, false, 8, 1, false, 0,
+              4, 1, false, 0, 8, 8),
+           (3, 'dsv4', 'b200', 'vllm', 'fp4', 'none', false, false, 1, 1, false, 0,
+              1, 1, false, 0, 1, 1);
+
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+      isl, osl, conc, offload_mode, metrics)
+    VALUES (20, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'off', '{}'),
+           (21, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, 'off', '{}'),
+           (22, 2, 2, 'single_turn', '2026-09-11', 8192, 1024, 32, 'off', '{}'),
+           (23, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'off', '{}'),
+           (24, 2, 3, 'agentic_traces', '2026-09-11', null, null, 72, 'off', '{}');`);
+});
+
+describe('findBenchmarkResultIds', () => {
+  it('prefers the offload-exact point and reports no unique fallback', async () => {
+    await db.exec(`INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type,
+      date, isl, osl, conc, offload_mode, metrics)
+      VALUES (25, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'on', '{}');`);
+    const fallbacks: number[] = [];
+    const ids = await findBenchmarkResultIds(sql, RUN, [mapped(rawRow())], (id) =>
+      fallbacks.push(id),
+    );
+    expect(ids).toEqual([20]);
+    expect(fallbacks).toEqual([]);
+  });
+});
+
+it('excludes exact purges from mixed artifacts and missing-artifact expectations', async () => {
+  await db.exec(`UPDATE benchmark_results SET config_id = 1 WHERE id = 24;
+    UPDATE configs SET id = 744 WHERE id = 3;
+    UPDATE workflow_runs SET github_run_id = 30730541420, run_attempt = 1 WHERE id = 2;
+    UPDATE benchmark_results SET config_id = 744, conc = 1, offload_mode = 'on' WHERE id = 24;`);
+  const run = { github_run_id: 30730541420, run_attempt: 1 };
+  const point: BenchmarkParams = {
+    ...mapped(rawRow({ infmax_model_prefix: 'dsv4', framework: 'vllm', tp: 1 })),
+    benchmarkType: 'agentic_traces',
+    isl: null,
+    osl: null,
+    offloadMode: 'on',
+    recipeFingerprint: null,
+  };
+  const purged = { ...point, conc: 32 };
+  const surviving = { ...point, conc: 1 };
+  const rows = await filterPurgedBenchmarkRows(sql, run, [purged, surviving]);
+  expect(rows).toEqual([surviving]);
+  expect(await findBenchmarkResultIds(sql, run, rows)).toEqual([24]);
+  expect(await filterPurgedBenchmarkRows(sql, run, [purged])).toEqual([]);
+  expect(await filterPurgedBenchmarkRows(sql, { ...run, run_attempt: 2 }, [purged])).toEqual([
+    purged,
+  ]);
+  expect(
+    await filterPurgedBenchmarkRows(sql, run, [{ ...purged, recipeFingerprint: 'new' }]),
+  ).toHaveLength(1);
+  expect(
+    await filterPurgedBenchmarkRows(sql, run, [{ ...purged, offloadMode: 'off' }]),
+  ).toHaveLength(1);
+  expect(
+    await filterPurgedBenchmarkRows(sql, run, [
+      { ...purged, config: { ...point.config, decodeTp: 4 } },
+    ]),
+  ).toHaveLength(1);
+  const missing = await collectMissingTelemetryExpectations(
+    [
+      {
+        id: 1,
+        name: 'bmk_agentic_retained',
+        expired: false,
+        created_at: '2026-09-11T00:00:00Z',
+        archive_download_url: 'https://example.test/1',
+      },
+    ],
+    [],
+    null,
+    () => filterPurgedBenchmarkRows(sql, run, [purged, surviving]),
+  );
+  expect(missing.observations.map((entry) => entry.identity.conc)).toEqual([1]);
+  expect(missing.errors).toEqual([]);
+});
diff --git a/packages/db/src/lib/benchmark-result-lookup.ts b/packages/db/src/lib/benchmark-result-lookup.ts
new file mode 100644
index 000000000..f94128f4f
--- /dev/null
+++ b/packages/db/src/lib/benchmark-result-lookup.ts
@@ -0,0 +1,153 @@
+/**
+ * Resolve persisted `benchmark_results` ids for raw artifact rows that were
+ * mapped through the production mapper. Shared by the sidecar backfills
+ * (server logs, gpu_metrics) so every historical attachment uses the same
+ * natural-key match as the CI ingest path.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { mapBenchmarkRow, type BenchmarkParams } from '../etl/benchmark-mapper.js';
+import { createSkipTracker } from '../etl/skip-tracker.js';
+import type { Sql } from '../etl/db-utils.js';
+import { configCacheKey } from '../etl/config-cache.js';
+import { isBenchmarkPointPurged, PURGED_BENCHMARK_POINTS } from '../etl/run-overrides.js';
+import { resolveServerLogResultCandidates } from './server-log-backfill.js';
+
+export interface BenchmarkRunSelector {
+  github_run_id: number;
+  run_attempt: number;
+}
+
+/** Purged points must not become missing-result errors or receipt expectations. */
+export async function filterPurgedBenchmarkRows(
+  sql: Sql,
+  run: BenchmarkRunSelector,
+  rows: readonly BenchmarkParams[],
+): Promise<BenchmarkParams[]> {
+  const configIds = PURGED_BENCHMARK_POINTS.filter(
+    (point) => point.githubRunId === run.github_run_id && point.runAttempt === run.run_attempt,
+  ).map((point) => point.configId);
+  if (configIds.length === 0) return [...rows];
+
+  const configs = new Map<string, number | null>();
+  const retained: BenchmarkParams[] = [];
+  for (const row of rows) {
+    const c = row.config;
+    const key = configCacheKey(c);
+    if (!configs.has(key)) {
+      const [config] = await sql<{ id: number }[]>`
+        select id from configs cfg
+        where cfg.id = any(${configIds}::integer[])
+          and cfg.hardware = ${c.hardware} and cfg.framework = ${c.framework}
+          and cfg.model = ${c.model} and cfg.precision = ${c.precision}
+          and cfg.spec_method = ${c.specMethod} and cfg.disagg = ${c.disagg}
+          and cfg.is_multinode = ${c.isMultinode}
+          and cfg.prefill_tp = ${c.prefillTp} and cfg.prefill_ep = ${c.prefillEp}
+          and cfg.prefill_dp_attention = ${c.prefillDpAttn}
+          and cfg.prefill_num_workers = ${c.prefillNumWorkers}
+          and cfg.decode_tp = ${c.decodeTp} and cfg.decode_ep = ${c.decodeEp}
+          and cfg.decode_dp_attention = ${c.decodeDpAttn}
+          and cfg.decode_num_workers = ${c.decodeNumWorkers}
+          and cfg.num_prefill_gpu = ${c.numPrefillGpu}
+          and cfg.num_decode_gpu = ${c.numDecodeGpu}
+      `;
+      configs.set(key, config ? Number(config.id) : null);
+    }
+    const configId = configs.get(key)!;
+    if (
+      configId === null ||
+      !isBenchmarkPointPurged(run.github_run_id, run.run_attempt, { ...row, configId })
+    )
+      retained.push(row);
+  }
+  return retained;
+}
+
+export async function findBenchmarkResultIds(
+  sql: Sql,
+  run: BenchmarkRunSelector,
+  rows: readonly BenchmarkParams[],
+  onUniqueFallback: (id: number) => void = () => {},
+): Promise<number[]> {
+  const ids = new Set<number>();
+  for (const row of rows) {
+    const c = row.config;
+    const candidates = await sql<{ id: number; offload_mode: string }[]>`
+      select br.id, br.offload_mode
+      from benchmark_results br
+      join workflow_runs wr on wr.id = br.workflow_run_id
+      join configs cfg on cfg.id = br.config_id
+      where wr.github_run_id = ${run.github_run_id}
+        and wr.run_attempt = ${run.run_attempt}
+        and cfg.hardware = ${c.hardware}
+        and cfg.framework = ${c.framework}
+        and cfg.model = ${c.model}
+        and cfg.precision = ${c.precision}
+        and cfg.spec_method = ${c.specMethod}
+        and cfg.disagg = ${c.disagg}
+        and cfg.is_multinode = ${c.isMultinode}
+        and cfg.prefill_tp = ${c.prefillTp}
+        and cfg.prefill_ep = ${c.prefillEp}
+        and cfg.prefill_dp_attention = ${c.prefillDpAttn}
+        and cfg.prefill_num_workers = ${c.prefillNumWorkers}
+        and cfg.decode_tp = ${c.decodeTp}
+        and cfg.decode_ep = ${c.decodeEp}
+        and cfg.decode_dp_attention = ${c.decodeDpAttn}
+        and cfg.decode_num_workers = ${c.decodeNumWorkers}
+        and cfg.num_prefill_gpu = ${c.numPrefillGpu}
+        and cfg.num_decode_gpu = ${c.numDecodeGpu}
+        and br.benchmark_type = ${row.benchmarkType}
+        and br.isl is not distinct from ${row.isl}
+        and br.osl is not distinct from ${row.osl}
+        and br.conc = ${row.conc}
+        and br.recipe_fingerprint is not distinct from ${row.recipeFingerprint}
+    `;
+    const resolution = resolveServerLogResultCandidates(
+      candidates.map((candidate) => ({
+        id: Number(candidate.id),
+        offloadMode: candidate.offload_mode,
+      })),
+      row.offloadMode,
+    );
+    if (resolution.usedUniqueFallback) onUniqueFallback(resolution.ids[0]!);
+    for (const id of resolution.ids) ids.add(id);
+  }
+  return [...ids];
+}
+
+function findJsonFiles(root: string): string[] {
+  const files: string[] = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const pathname = path.join(root, entry.name);
+    if (entry.isDirectory()) files.push(...findJsonFiles(pathname));
+    else if (entry.isFile() && entry.name.endsWith('.json')) files.push(pathname);
+  }
+  return files.toSorted();
+}
+
+/** Map known successful rows; report unidentifiable rows separately from known failures. */
+export function readMappedBenchmarkRows(
+  root: string,
+  onUnmapped: (error: string) => void = () => {},
+): BenchmarkParams[] {
+  const tracker = createSkipTracker();
+  const rows: BenchmarkParams[] = [];
+  for (const file of findJsonFiles(root)) {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as unknown;
+    const rawRows = Array.isArray(parsed) ? parsed : [parsed];
+    for (const [index, raw] of rawRows.entries()) {
+      const error = `Unmappable benchmark row: ${path.relative(root, file)} row ${index + 1}`;
+      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        onUnmapped(error);
+        continue;
+      }
+      const failedRuns = tracker.skips.failedRun;
+      const mapped = mapBenchmarkRow(raw as Record<string, unknown>, tracker);
+      if (mapped) rows.push(mapped);
+      else if (tracker.skips.failedRun === failedRuns) onUnmapped(error);
+    }
+  }
+  return rows;
+}
diff --git a/packages/db/src/lib/gpu-metrics-backfill.test.ts b/packages/db/src/lib/gpu-metrics-backfill.test.ts
new file mode 100644
index 000000000..bb9607ca7
--- /dev/null
+++ b/packages/db/src/lib/gpu-metrics-backfill.test.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import type { ArtifactMeta } from './github-artifacts.js';
+import { pairGpuMetricsArtifacts } from './gpu-metrics-backfill.js';
+
+const meta = (
+  name: string,
+  id: number,
+  created_at = '2026-09-11T00:00:00Z',
+  expired = false,
+): ArtifactMeta => ({
+  id,
+  name,
+  created_at,
+  expired,
+  archive_download_url: `https://example.test/${id}`,
+});
+
+describe('pairGpuMetricsArtifacts', () => {
+  it('lets a power_audit bundle stand in only when its suffix has no gpu_metrics upload', () => {
+    // The bundle is listed before its gpu_metrics sibling on purpose: input
+    // order alone must not decide the winner.
+    const pairs = pairGpuMetricsArtifacts([
+      meta('power_audit_cfg-mn_b200-slurm_0', 1),
+      meta('bmk_cfg-mn_b200-slurm_0', 2),
+      meta('power_audit_cfg-sn_h200-cw_0', 4),
+      meta('gpu_metrics_cfg-sn_h200-cw_0', 3),
+      meta('bmk_cfg-sn_h200-cw_0', 5),
+      meta('power_audit_orphan_b200-slurm_0', 6),
+    ]);
+    expect(pairs.map((pair) => [pair.gpuMetrics.name, pair.benchmarks.name])).toEqual([
+      ['gpu_metrics_cfg-sn_h200-cw_0', 'bmk_cfg-sn_h200-cw_0'],
+      ['power_audit_cfg-mn_b200-slurm_0', 'bmk_cfg-mn_b200-slurm_0'],
+    ]);
+  });
+
+  it('keeps only the newest retry per logical benchmark and drops expired uploads', () => {
+    const pairs = pairGpuMetricsArtifacts([
+      meta('gpu_metrics_cfg-a_h200-cw_0', 1, '2026-09-11T00:00:00Z'),
+      meta('bmk_cfg-a_h200-cw_0', 2, '2026-09-11T00:00:00Z'),
+      meta('gpu_metrics_cfg-a_h200-dgxc-slurm_1', 3, '2026-09-11T02:00:00Z'),
+      meta('bmk_cfg-a_h200-dgxc-slurm_1', 4, '2026-09-11T02:00:00Z'),
+      meta('gpu_metrics_cfg-c_h200-cw_0', 5, '2026-09-11T03:00:00Z', true),
+      meta('bmk_cfg-c_h200-cw_0', 6, '2026-09-11T03:00:00Z'),
+    ]);
+    expect(pairs.map((pair) => pair.gpuMetrics.name)).toEqual([
+      'gpu_metrics_cfg-a_h200-dgxc-slurm_1',
+    ]);
+  });
+});
diff --git a/packages/db/src/lib/gpu-metrics-backfill.ts b/packages/db/src/lib/gpu-metrics-backfill.ts
new file mode 100644
index 000000000..d1600e2d3
--- /dev/null
+++ b/packages/db/src/lib/gpu-metrics-backfill.ts
@@ -0,0 +1,134 @@
+import type { Sql } from '../etl/db-utils.js';
+import { GPU_STATS_VERSION } from './gpu-metric-stats.js';
+
+/** Pairing rules for the historical gpu_metrics backfill. */
+
+import { gpuMetricsArtifactSuffix, isPowerAuditArtifact } from '../etl/gpu-metrics-artifacts.js';
+import type { BenchmarkParams } from '../etl/benchmark-mapper.js';
+import { benchmarkPublicationIdentity } from '../etl/power-publication.js';
+import type { TelemetryObservation, TelemetryReceipt } from '../etl/telemetry-receipt.js';
+import {
+  dedupeArtifactsByLogicalName,
+  RUNNER_SUFFIX_RE,
+  type ArtifactMeta,
+} from './github-artifacts.js';
+
+export interface GpuMetricsArtifactPair {
+  /** `gpu_metrics_<suffix>`, or the `power_audit_<suffix>` bundle when a multinode job uploaded no other. */
+  gpuMetrics: ArtifactMeta;
+  benchmarks: ArtifactMeta;
+}
+
+function isNewerArtifact(candidate: ArtifactMeta, existing: ArtifactMeta): boolean {
+  return (
+    candidate.created_at > existing.created_at ||
+    (candidate.created_at === existing.created_at && (candidate.id ?? 0) > (existing.id ?? 0))
+  );
+}
+
+/**
+ * Pair every unexpired telemetry artifact with its exact bmk sibling. Retried
+ * jobs upload on different runners, so the newest artifact per logical
+ * (runner-suffix-stripped) benchmark name wins, matching CI ingest. A
+ * `power_audit_` bundle pairs only when its suffix has no `gpu_metrics_`
+ * upload, the same preference `discoverGpuMetricsArtifacts` applies.
+ */
+export function pairGpuMetricsArtifacts(
+  artifacts: readonly ArtifactMeta[],
+): GpuMetricsArtifactPair[] {
+  const byName = new Map<string, ArtifactMeta>();
+  for (const artifact of artifacts) {
+    if (artifact.expired) continue;
+    const existing = byName.get(artifact.name);
+    if (!existing || isNewerArtifact(artifact, existing)) byName.set(artifact.name, artifact);
+  }
+  const gpuMetricsSuffixes = new Set<string>();
+  for (const name of byName.keys()) {
+    const suffix = gpuMetricsArtifactSuffix(name);
+    if (suffix && !isPowerAuditArtifact(name)) gpuMetricsSuffixes.add(suffix);
+  }
+  const byLogicalBenchmark = new Map<string, GpuMetricsArtifactPair>();
+  for (const gpuMetrics of byName.values()) {
+    const suffix = gpuMetricsArtifactSuffix(gpuMetrics.name);
+    if (!suffix) continue;
+    if (isPowerAuditArtifact(gpuMetrics.name) && gpuMetricsSuffixes.has(suffix)) continue;
+    const benchmarks = byName.get(`bmk_agentic_${suffix}`) ?? byName.get(`bmk_${suffix}`);
+    if (!benchmarks) continue;
+    const logicalName = benchmarks.name.replace(RUNNER_SUFFIX_RE, '');
+    const existing = byLogicalBenchmark.get(logicalName);
+    if (!existing || isNewerArtifact(benchmarks, existing.benchmarks)) {
+      byLogicalBenchmark.set(logicalName, { gpuMetrics, benchmarks });
+    }
+  }
+  return [...byLogicalBenchmark.values()].toSorted((a, b) =>
+    a.gpuMetrics.name.localeCompare(b.gpuMetrics.name),
+  );
+}
+
+/** A corrupt unrelated benchmark sibling must not prevent valid pairs from being repaired. */
+export async function collectMissingTelemetryExpectations(
+  artifacts: readonly ArtifactMeta[],
+  pairs: readonly GpuMetricsArtifactPair[],
+  selectedArtifact: string | null,
+  readRows: (
+    artifact: ArtifactMeta,
+    onUnmapped: (error: string) => void,
+  ) => Promise<readonly BenchmarkParams[]>,
+): Promise<{
+  observations: TelemetryObservation[];
+  errors: NonNullable<TelemetryReceipt['expectationErrors']>;
+}> {
+  const paired = new Set(pairs.map((pair) => pair.benchmarks.name));
+  const observations: TelemetryObservation[] = [];
+  const errors: NonNullable<TelemetryReceipt['expectationErrors']> = [];
+  for (const artifact of dedupeArtifactsByLogicalName(artifacts).values()) {
+    if (!artifact.name.startsWith('bmk_') || paired.has(artifact.name)) continue;
+    const suffix = artifact.name.replace(/^bmk_(?:agentic_)?/u, '');
+    const artifactNames = [`gpu_metrics_${suffix}`, `power_audit_${suffix}`];
+    if (selectedArtifact && !artifactNames.includes(selectedArtifact)) continue;
+    const recordError = (error: string) => {
+      errors.push({ benchmarkArtifact: artifact.name, artifactNames, error });
+    };
+    if (artifact.expired) {
+      recordError('Benchmark artifact expired; point identities unavailable');
+      continue;
+    }
+    try {
+      for (const row of await readRows(artifact, recordError))
+        observations.push({
+          identity: benchmarkPublicationIdentity(row),
+          artifactNames,
+          produced: false,
+        });
+    } catch (error) {
+      recordError(error instanceof Error ? error.message : String(error));
+    }
+  }
+  return { observations, errors };
+}
+
+/** Stored samples outlive artifacts, including superseded attempts. */
+export function findOutdatedGpuMetricSeries(
+  sql: Sql,
+  flags: {
+    run: number | null;
+    attempt: number | null;
+    artifact: string | null;
+    fromRun: number | null;
+    since: string | null;
+  },
+  limit: number | null,
+) {
+  return sql`
+    select s.id, wr.github_run_id, wr.run_attempt, s.artifact_name, s.file_name
+    from gpu_metric_series s join workflow_runs wr on wr.id = s.workflow_run_id
+    where s.stats_version <> ${GPU_STATS_VERSION}
+      and (${flags.run}::bigint is null or wr.github_run_id = ${flags.run})
+      and (${flags.attempt}::integer is null or wr.run_attempt = ${flags.attempt})
+      and (${flags.artifact}::text is null or s.artifact_name = ${flags.artifact})
+      and (${flags.fromRun}::bigint is null or wr.github_run_id >= ${flags.fromRun})
+      and (${flags.since}::date is null or wr.date >= ${flags.since}::date)
+    order by wr.github_run_id, wr.run_attempt, s.id
+    limit ${limit}::integer
+  `;
+}
diff --git a/packages/db/src/lib/telemetry-purge.ts b/packages/db/src/lib/telemetry-purge.ts
new file mode 100644
index 000000000..13b2b76dd
--- /dev/null
+++ b/packages/db/src/lib/telemetry-purge.ts
@@ -0,0 +1,100 @@
+/**
+ * Explicit deletion of PowerX telemetry during a purge.
+ *
+ * Migration 016 declares `on delete cascade` from `gpu_metric_series.workflow_run_id`
+ * to `workflow_runs` and from `benchmark_result_gpu_metrics.benchmark_result_id` to
+ * `benchmark_results`, so a purge already removed telemetry — silently, with no count
+ * in the preview and no line in the log. That is the wrong default for this data:
+ * past GitHub's 90-day artifact retention the stored samples are the only copy, which
+ * is the reason migration 016 exists at all. These helpers make the deletion explicit
+ * so the operator sees the cost before confirming and again in the transcript.
+ *
+ * The two levels differ on purpose:
+ *   - A whole-run purge owns the series and deletes them (`deleteRunTelemetry`).
+ *   - A point purge only drops the point→series links (`unlinkPointTelemetry`). The
+ *     series stays attached to its workflow_run because `/api/gpu-metrics?runId=`
+ *     reads series by run, not through the links, and other points of the same run
+ *     may still reference it.
+ */
+
+import type { Sql } from '../etl/db-utils.js';
+
+export interface TelemetryPurgeCounts {
+  /** Rows in `gpu_metric_series`. */
+  series: number;
+  /** Sum of `gpu_metric_series.sample_count` across those series. */
+  samples: number;
+}
+
+export const NO_TELEMETRY: TelemetryPurgeCounts = { series: 0, samples: 0 };
+
+/** `count`/`sum` come back as strings over the wire; `sum` is null on an empty set. */
+function toCounts(row: { n: unknown; samples: unknown } | undefined): TelemetryPurgeCounts {
+  if (!row) return NO_TELEMETRY;
+  return { series: Number(row.n ?? 0), samples: Number(row.samples ?? 0) };
+}
+
+/**
+ * Telemetry a whole-run purge would destroy. Read-only, for the preview line.
+ * Sums the stored `sample_count` instead of counting `gpu_metric_samples` so the
+ * preview stays cheap against a table holding tens of millions of rows.
+ */
+export async function countRunTelemetry(
+  sql: Sql,
+  workflowRunIds: readonly number[],
+): Promise<TelemetryPurgeCounts> {
+  if (workflowRunIds.length === 0) return NO_TELEMETRY;
+  const [row] = await sql`
+    SELECT count(*)::int AS n, coalesce(sum(sample_count), 0)::bigint AS samples
+    FROM gpu_metric_series
+    WHERE workflow_run_id = ANY(${[...workflowRunIds]})
+  `;
+  return toCounts(row as { n: unknown; samples: unknown } | undefined);
+}
+
+/**
+ * Delete the telemetry owned by these workflow_runs and report what went, so the
+ * caller can log it. Samples and per-GPU stats follow by cascade from the series.
+ * Call this before deleting the `workflow_runs` rows themselves.
+ */
+export async function deleteRunTelemetry(
+  sql: Sql,
+  workflowRunIds: readonly number[],
+): Promise<TelemetryPurgeCounts> {
+  if (workflowRunIds.length === 0) return NO_TELEMETRY;
+  const [row] = await sql`
+    WITH deleted AS (
+      DELETE FROM gpu_metric_series
+      WHERE workflow_run_id = ANY(${[...workflowRunIds]})
+      RETURNING sample_count
+    )
+    SELECT count(*)::int AS n, coalesce(sum(sample_count), 0)::bigint AS samples FROM deleted
+  `;
+  return toCounts(row as { n: unknown; samples: unknown } | undefined);
+}
+
+/**
+ * Drop the point→series links for purged benchmark points and report how many went.
+ * Deliberately leaves `gpu_metric_series` in place: it belongs to the workflow_run,
+ * which is not being purged here.
+ */
+export async function unlinkPointTelemetry(
+  sql: Sql,
+  benchmarkResultIds: readonly number[],
+): Promise<number> {
+  if (benchmarkResultIds.length === 0) return 0;
+  const [row] = await sql`
+    WITH deleted AS (
+      DELETE FROM benchmark_result_gpu_metrics
+      WHERE benchmark_result_id = ANY(${[...benchmarkResultIds]})
+      RETURNING series_id
+    )
+    SELECT count(*)::int AS n FROM deleted
+  `;
+  return Number((row as { n: unknown } | undefined)?.n ?? 0);
+}
+
+/** One-line summary for preview and transcript output. */
+export function describeTelemetry(counts: TelemetryPurgeCounts): string {
+  return `${counts.series} gpu_metric_series (${counts.samples.toLocaleString('en-US')} samples)`;
+}

From 6651f840e4dbf153383c9189ca24a96571d00a51 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 064/103] feat(db): telemetry read queries with snapshot checks
 and paged samples
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Read a run or point with prefix/source/host scoping pushed into SQL, page samples in
50k-row keyset pages under the Neon HTTP cap, re-check the series version after loading
so a concurrent re-ingest is retried, and expose a revision hash for the point cache.

中文：按 prefix/source/host 在 SQL 侧限定读取范围，样本以 5 万行 keyset 分页控制在 Neon HTTP 上限内，读取后复核序列版本以重试并发重入库，并为 point 缓存暴露 revision 哈希。
---
 .../db/src/queries/gpu-metrics-revision.ts    |  27 +
 .../src/queries/gpu-metrics-timeline.test.ts  | 288 ++++++++++
 .../gpu-metrics.reingest-consistency.test.ts  | 236 ++++++++
 packages/db/src/queries/gpu-metrics.test.ts   | 321 +++++++++++
 packages/db/src/queries/gpu-metrics.ts        | 515 ++++++++++++++++++
 5 files changed, 1387 insertions(+)
 create mode 100644 packages/db/src/queries/gpu-metrics-revision.ts
 create mode 100644 packages/db/src/queries/gpu-metrics-timeline.test.ts
 create mode 100644 packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
 create mode 100644 packages/db/src/queries/gpu-metrics.test.ts
 create mode 100644 packages/db/src/queries/gpu-metrics.ts

diff --git a/packages/db/src/queries/gpu-metrics-revision.ts b/packages/db/src/queries/gpu-metrics-revision.ts
new file mode 100644
index 000000000..fb7364b38
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics-revision.ts
@@ -0,0 +1,27 @@
+import { GPU_STATS_VERSION } from '../lib/gpu-metric-stats';
+
+import type { DbClient } from '../connection';
+
+/** Re-ingest and shared-link changes must bypass older point payloads. */
+export async function getGpuMetricsPointRevision(
+  sql: DbClient,
+  benchmarkResultId: number,
+): Promise<string | null> {
+  const [row] = await sql`
+    select md5(jsonb_agg(jsonb_build_array(
+      s.id, s.ingested_at, s.csv_sha256, s.sample_count, s.sidecars,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0),
+      (
+        select jsonb_agg(jsonb_build_array(l.benchmark_result_id, b.power_audit)
+          order by l.benchmark_result_id)
+        from benchmark_result_gpu_metrics l
+        join benchmark_results b on b.id = l.benchmark_result_id
+        where l.series_id = s.id
+      )
+    ) order by s.id)::text) as revision
+    from benchmark_result_gpu_metrics link
+    join gpu_metric_series s on s.id = link.series_id
+    where link.benchmark_result_id = ${benchmarkResultId}
+  `;
+  return typeof row?.revision === 'string' ? `${GPU_STATS_VERSION}:${row.revision}` : null;
+}
diff --git a/packages/db/src/queries/gpu-metrics-timeline.test.ts b/packages/db/src/queries/gpu-metrics-timeline.test.ts
new file mode 100644
index 000000000..2283453ce
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics-timeline.test.ts
@@ -0,0 +1,288 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import { cutPowerAuditBundle } from '../../../app/src/components/gpu-power/power-audit-bundle';
+import { storedPowerSeries } from '../../../app/src/components/gpu-power/stored-power-series';
+import type { DbClient } from '../connection';
+import { ingestGpuMetricsArtifact } from '../etl/gpu-metrics-ingest';
+import { getGpuMetricsForPoint, getGpuMetricsForRun } from './gpu-metrics';
+
+let db: PGlite;
+let sql: postgres.Sql;
+let readSql: DbClient;
+let root: string;
+const RUN = 34557177019;
+const NAME = 'power_audit_qwen3.5_8k1k_fp8_dynamo-sglang_b200-slurm_0';
+const SOURCE = 'power_validation_qwen3.5_8k1k_fp8_dynamo-sglang_b200-slurm_0_conc32.json';
+const START = 1789194365;
+const CSV = [
+  'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+  `1,${START - 61},0,host-a,0,GPU-a0,1`, // outside the existing 60 s pad
+  `1,${START - 60},1,host-a,0,GPU-a0,0`, // genuine zero must survive
+  `1,${START + 0.1},2,host-b,0,GPU-b0,450`,
+  `1,${START + 0.1},2,host-a,0,GPU-a0,300`,
+  `1,${START + 0.1},2,host-a,0,GPU-a0,300`, // identical duplicate flush
+  `1,${START + 0.1},2,host-a,0,GPU-a0,999`, // conflicting duplicate: first wins
+  `1,${START + 0.8},3,host-a,0,GPU-a0,500`, // same second: mean 400 W
+  `1,${START + 1.1},4,host-a,0,GPU-a0,550`, // host-b dropout: null bucket
+  `1,${START + 61},5,host-b,0,GPU-b0,90`, // inclusive padded boundary
+  `1,${START + 62},6,host-b,0,GPU-b0,1`,
+].join('\n');
+const MANIFEST = {
+  producer: 'srt-slurm.dcgm-power',
+  expected_devices: [
+    { hostname: 'host-a', gpu_index: 0, assignments: [{ worker_role: 'prefill' }] },
+    { hostname: 'host-b', gpu_index: 0, assignments: [{ worker_role: 'decode' }] },
+  ],
+};
+const VALIDATION = {
+  selected_window: { start_time_unix: START, end_time_unix: START + 1 },
+  benchmark_window: { start_time_unix: START - 100, end_time_unix: START + 100 },
+};
+
+function stamp(seconds: number): string {
+  return new Date((seconds + 7200) * 1000)
+    .toISOString()
+    .replaceAll('-', '/')
+    .replace('T', ' ')
+    .replace('Z', '');
+}
+
+function client(database: Pick<PGlite, 'query'>) {
+  return Object.assign(
+    async (strings: TemplateStringsArray, ...values: unknown[]) => {
+      const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+      const result = await database.query<Record<string, unknown>>(query, values);
+      return result.rows;
+    },
+    { json: JSON.stringify, array: (value: unknown) => value },
+  );
+}
+
+function writeArtifact(name: string, files: ReadonlyMap<string, string>) {
+  const artifactDir = path.join(root, name);
+  for (const [file, contents] of files) {
+    const pathname = path.join(artifactDir, file);
+    fs.mkdirSync(path.dirname(pathname), { recursive: true });
+    fs.writeFileSync(pathname, contents);
+  }
+  return { artifactName: name, artifactDir };
+}
+
+function bundle(validation: Record<string, unknown> = VALIDATION) {
+  return new Map([
+    ['LOGS/power/samples.csv', CSV],
+    ['LOGS/power/manifest.json', JSON.stringify(MANIFEST)],
+    [SOURCE, JSON.stringify(validation)],
+  ]);
+}
+
+function agentxBundle() {
+  const files = bundle();
+  files.delete(SOURCE);
+  const resultPath = 'agentic/conc_32/agentic_power_concurrency_32.json';
+  files.set(`${NAME.slice('power_audit_'.length)}_conc32.json`, JSON.stringify({ conc: 32 }));
+  files.set(
+    'LOGS/agentic/conc_32/power_validation.json',
+    JSON.stringify({
+      ...VALIDATION,
+      power_valid: false,
+      selected_window: {
+        ...VALIDATION.selected_window,
+        concurrency: 32,
+        result_path: resultPath,
+        window_file: 'windows/agentic_power_concurrency_32.json',
+      },
+    }),
+  );
+  files.set(
+    'LOGS/power/windows/agentic_power_concurrency_32.json',
+    JSON.stringify({
+      concurrency: 32,
+      result_path: resultPath,
+      benchmark_start_time_unix: START,
+      benchmark_end_time_unix: START + 1,
+    }),
+  );
+  return files;
+}
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-timeline-'));
+  db = await PGlite.create();
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  await db.exec('ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb');
+  readSql = client(db);
+  sql = Object.assign(client(db), {
+    begin: (fn: (tx: postgres.Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(client(tx) as unknown as postgres.Sql)),
+  }) as unknown as postgres.Sql;
+}, 20_000);
+
+afterAll(async () => {
+  await db?.close();
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, created_at, date)
+      VALUES (1, ${RUN}, 1, 'Run Sweep', 'completed', '2026-09-12', '2026-09-12');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+      VALUES (1, 'qwen3.5', 'b200', 'sglang', 'fp8', 'none', false, 1, 1, 1, 1);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+      isl, osl, conc, metrics)
+      VALUES (10, 1, 1, 'single_turn', '2026-09-12', 8192, 1024, 32, '{}'),
+             (11, 1, 1, 'single_turn', '2026-09-12', 8192, 1024, 64, '{}');`);
+});
+
+describe('artifact → ingest → stored Timeline', () => {
+  it.each(['explicit', 'wrong-run', 'wrong-id', 'wrong-conc', 'ambiguous'])(
+    'does not infer or overwrite point provenance for %s identity',
+    async (scenario) => {
+      await db.exec("UPDATE benchmark_results SET benchmark_type = 'agentic_traces'");
+      if (scenario === 'explicit')
+        await db.exec(
+          `UPDATE benchmark_results SET power_audit = '{"source":"existing.json"}' WHERE id = 10`,
+        );
+      if (scenario === 'wrong-run') {
+        await db.exec(`INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, created_at, date)
+          VALUES (2, 1, 1, 'Other run', 'completed', '2026-09-12', '2026-09-12');
+          UPDATE benchmark_results SET workflow_run_id = 2 WHERE id = 10`);
+      }
+      if (scenario === 'wrong-conc')
+        await db.exec('UPDATE benchmark_results SET conc = 31 WHERE id = 10');
+      if (scenario === 'ambiguous')
+        await db.exec('UPDATE benchmark_results SET conc = 32, isl = 1 WHERE id = 11');
+      const before = await db.query('SELECT id, power_audit FROM benchmark_results ORDER BY id');
+      await ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact: writeArtifact(NAME, agentxBundle()),
+        benchmarkResultIds: scenario === 'wrong-id' ? [11] : [10, 11],
+      });
+      const after = await db.query('SELECT id, power_audit FROM benchmark_results ORDER BY id');
+      expect(after.rows).toEqual(before.rows);
+    },
+  );
+
+  it('matches artifact windows, host/GPU identity, deduplicated mean watts and gaps for a multinode bundle', async () => {
+    const files = bundle();
+    const artifact = writeArtifact(NAME, files);
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 11],
+    });
+    // Remove the actual artifact before querying: only the DB survives.
+    fs.rmSync(artifact.artifactDir, { recursive: true });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    const actual = storedPowerSeries(stored!.series);
+    expect(actual).toEqual(cutPowerAuditBundle(NAME, files));
+    expect(actual[0]).toMatchObject({
+      artifact: NAME,
+      source: SOURCE,
+      startMs: (START - 60) * 1000,
+      t: [0, 60, 61, 121],
+      power: [
+        [0, 400, 550, null],
+        [null, 450, null, 90],
+      ],
+      devices: [
+        { id: 'host-a/GPU-a0', role: 'prefill' },
+        { id: 'host-b/GPU-b0', role: 'decode' },
+      ],
+    });
+    const point = await getGpuMetricsForPoint(readSql, 10);
+    expect(point!.series.map((series) => series.benchmarkResultIds)).toEqual([
+      [10, 11],
+      [10, 11],
+    ]);
+    expect(storedPowerSeries(point!.series)).toEqual(actual);
+  });
+
+  it('retains selected-window precedence and validation role overrides across ingestion', async () => {
+    const files = bundle({
+      ...VALIDATION,
+      per_gpu_role: { 'host-a/GPU-a0': 'decode', 'host-b/GPU-b0': 'prefill' },
+    });
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NAME, files),
+      benchmarkResultIds: [10],
+    });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    const actual = storedPowerSeries(stored!.series);
+    expect(actual).toEqual(cutPowerAuditBundle(NAME, files));
+    expect(actual[0].devices?.[0]).toEqual({ id: 'host-b/GPU-b0', role: 'prefill' });
+  });
+
+  it('keeps SMI telemetry embedded in a power_audit bundle readable with the same source/window cuts', async () => {
+    const files = bundle();
+    files.set(
+      'gpu_metrics.csv',
+      [
+        'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+        `${stamp(START - 61)}, 0, 1 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+        `${stamp(START)}, 0, 300 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+        `${stamp(START)}, 1, 500 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+        `${stamp(START + 1)}, 0, 700 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+      ].join('\n'),
+    );
+    files.set('gpu_metrics_identity.csv', 'index, uuid\n0, GPU-a\n1, GPU-b');
+    files.set(
+      'benchmark_gpu_metrics_context.json',
+      JSON.stringify({ timestamp_timezone: '+02:00' }),
+    );
+    const artifact = writeArtifact(NAME, files);
+    await ingestGpuMetricsArtifact(sql, { workflowRunId: 1, artifact, benchmarkResultIds: [10] });
+    fs.rmSync(artifact.artifactDir, { recursive: true });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    expect(stored!.series).toHaveLength(1);
+    expect(stored!.series[0].fileName).toBe('gpu_metrics.csv');
+    const actual = storedPowerSeries(stored!.series);
+    expect(actual).toEqual(cutPowerAuditBundle(NAME, files));
+    expect(actual).toMatchObject([
+      {
+        source: SOURCE,
+        startMs: START * 1000,
+        gpus: [0, 1],
+        power: [
+          [300, 700],
+          [500, null],
+        ],
+        devices: [{ id: '0' }, { id: '1' }],
+      },
+    ]);
+  });
+
+  it('rejects incomplete per-host commits using the artifact inventory and legacy manifest', async () => {
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NAME, bundle()),
+      benchmarkResultIds: [10],
+    });
+    await sql`DELETE FROM gpu_metric_series WHERE file_name = 'LOGS/power/samples.csv#host-b'`;
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    expect(stored!.series).toHaveLength(1);
+    expect(() => storedPowerSeries(stored!.series)).toThrow(
+      'stored file/sample coverage is incomplete',
+    );
+    await sql`UPDATE gpu_metric_series SET sidecars = sidecars - 'seriesInventory'`;
+    const legacy = await getGpuMetricsForRun(readSql, RUN);
+    expect(() => storedPowerSeries(legacy!.series)).toThrow(
+      'expected device host-b GPU 0 is not stored',
+    );
+  });
+});
diff --git a/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts b/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
new file mode 100644
index 000000000..7cba11008
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
@@ -0,0 +1,236 @@
+/**
+ * Re-ingest consistency of the PowerX telemetry read path.
+ *
+ * Property under test: a reader of one benchmark point never observes samples
+ * and per-GPU statistics that come from different versions of the same series.
+ *
+ * `upsertGpuMetricSeries` replaces samples and stats inside one `sql.begin`
+ * transaction, so the write side is atomic. `getGpuMetricsForPoint` ->
+ * `loadSeriesDetails`, however, issues separate autocommit statements (series
+ * rows, then `gpu_metric_gpu_stats`, then `gpu_metric_samples`). In production
+ * the DbClient is either neon() HTTP (one implicit transaction per call) or a
+ * postgres.js pool used without a transaction, so a re-ingest can commit between
+ * the stats and the samples statement. The reader re-checks the series version
+ * key afterwards and restarts the read when it moved.
+ *
+ * PGlite is single-connection, so the interleaving is simulated at statement
+ * granularity: after the stats statement returns, a full re-ingest transaction
+ * runs and commits before the samples statement executes. Under READ COMMITTED
+ * this is observationally identical to a second connection committing between
+ * the two autocommit statements.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import type { DbClient } from '../connection';
+import { ingestGpuMetricsArtifact, refreshGpuMetricStats } from '../etl/gpu-metrics-ingest';
+import { getGpuMetricsForPoint, type GpuMetricSeries } from './gpu-metrics';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+/** Writer handle: the ingest code calls `sql.begin`, `sql.array`, `sql.json`. */
+let sql: Sql;
+/** Reader handle: plain autocommit statements, as the app's DbClient issues them. */
+let reader: DbClient;
+const roots: string[] = [];
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query<Record<string, unknown>>(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, {
+    json: JSON.stringify,
+    array: (value: unknown) => value,
+  });
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  // The point reader aggregates benchmark_results.power_audit (migration 015).
+  await db.exec('ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb');
+  sql = Object.assign(queryClient(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(queryClient(tx) as unknown as Sql)),
+  }) as unknown as Sql;
+  reader = queryClient(db) as DbClient;
+}, 20_000);
+
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+    VALUES (1, 34557177019, 1, 'Run Sweep', 'completed', 'success', '2026-09-11', '2026-09-11');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 4, 4, 4, 4);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+           (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}');`);
+});
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+afterAll(async () => {
+  await db?.close();
+});
+
+/** Version 1: 2 GPUs x 2 distinct timestamps (+ duplicate flush row) = 4 unique samples. */
+const NVIDIA_CSV_V1 = [
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+  '2026/09/11 04:19:41.982, 0, 187.80 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:41.986, 1, 190.96 W, 39, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:42.990, 0, 912.10 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+  // Duplicate flush of the last sample, as emitted when the monitor stops.
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+].join('\n');
+
+/**
+ * Version 1 + `extraScrapes` further scrapes per GPU, each at a distinct
+ * timestamp, so every version has a distinct CSV digest and sample count.
+ */
+function csvVersion(extraScrapes: number): string {
+  const lines = [NVIDIA_CSV_V1];
+  for (let i = 0; i < extraScrapes; i += 1) {
+    const second = String(43 + i).padStart(2, '0');
+    lines.push(
+      `2026/09/11 04:19:${second}.990, 0, 700.00 W, 60, 1900 MHz, 3996 MHz, 90 %, 70 %`,
+      `2026/09/11 04:19:${second}.994, 1, 702.50 W, 61, 1900 MHz, 3996 MHz, 91 %, 71 %`,
+    );
+  }
+  return lines.join('\n');
+}
+
+/** Version 2: the same artifact re-uploaded with one more scrape per GPU = 6 unique samples. */
+const NVIDIA_CSV_V2 = csvVersion(1);
+
+const V1_UNIQUE_SAMPLES = 4;
+const V2_UNIQUE_SAMPLES = 6;
+
+function writeArtifact(csv: string, contextZone = 'UTC') {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-reingest-'));
+  roots.push(root);
+  const artifactName = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+  const artifactDir = path.join(root, artifactName);
+  fs.mkdirSync(artifactDir);
+  fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_context.json'),
+    JSON.stringify({ timestamp_timezone: contextZone }),
+  );
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_identity.csv'),
+    'index, uuid, name\n0, GPU-a, NVIDIA B200\n1, GPU-b, NVIDIA B200\n',
+  );
+  return { artifactName, artifactDir };
+}
+
+function ingest(csv: string) {
+  return ingestGpuMetricsArtifact(sql, {
+    workflowRunId: 1,
+    artifact: writeArtifact(csv),
+    benchmarkResultIds: [10],
+  });
+}
+
+interface InterleavedReader {
+  client: DbClient;
+  /** How many times the reader issued its first statement (the point's series rows). */
+  seriesReads: () => number;
+}
+
+/**
+ * A DbClient that forwards every statement to `base`, but after each
+ * `gpu_metric_gpu_stats` statement has returned (and before the caller gets
+ * the rows back), runs `between(statsReadIndex)` to completion. With a
+ * committed re-ingest in `between`, this is the schedule: reader(series),
+ * reader(stats), WRITER COMMITS, reader(samples), reader(version check).
+ */
+function interleaveAfterStats(
+  base: DbClient,
+  between: (statsReadIndex: number) => Promise<unknown>,
+): InterleavedReader {
+  let statsReads = 0;
+  let seriesReads = 0;
+  const client: DbClient = async (strings, ...values) => {
+    const text = strings.join('');
+    if (/from benchmark_result_gpu_metrics link/.test(text)) seriesReads += 1;
+    const rows = await base(strings, ...values);
+    if (/from gpu_metric_gpu_stats/.test(text)) {
+      statsReads += 1;
+      await between(statsReads);
+    }
+    return rows;
+  };
+  return { client, seriesReads: () => seriesReads };
+}
+
+/**
+ * The consistency property: every statistic row was computed over exactly the
+ * sample rows returned in the same payload, and the series header agrees.
+ */
+function expectCoherent(series: GpuMetricSeries) {
+  for (const stat of series.stats) {
+    const rowsForGpu = series.data.filter((row) => row.index === stat.gpuIndex).length;
+    expect(stat.count, `stats.count for gpu ${stat.gpuIndex}/${stat.metric}`).toBe(rowsForGpu);
+  }
+  expect(series.sampleCount, 'series.sampleCount vs data.length').toBe(series.data.length);
+}
+
+describe('getGpuMetricsForPoint under telemetry re-ingest', () => {
+  it('a re-ingest committed between the stats and samples statements yields one version', async () => {
+    const first = await ingest(NVIDIA_CSV_V1);
+    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
+
+    let reingest: Awaited<ReturnType<typeof ingest>> | undefined;
+    const interleaved = interleaveAfterStats(reader, async (statsReadIndex) => {
+      if (statsReadIndex === 1) reingest = await ingest(NVIDIA_CSV_V2);
+    });
+
+    const payload = await getGpuMetricsForPoint(interleaved.client, 10);
+
+    // The writer really did replace the series inside its own transaction.
+    expect(reingest?.samplesInserted).toBe(V2_UNIQUE_SAMPLES);
+    expect(reingest?.seriesIds).toEqual(first.seriesIds);
+    expect(payload?.series).toHaveLength(1);
+    // The version key moved, so the reader restarted from the series statement.
+    expect(interleaved.seriesReads()).toBe(2);
+
+    for (const series of payload!.series) {
+      expect(series.sampleCount).toBe(V2_UNIQUE_SAMPLES);
+      expect(series.data).toHaveLength(V2_UNIQUE_SAMPLES);
+      for (const stat of series.stats) expect(stat.count).toBe(V2_UNIQUE_SAMPLES / 2);
+      expectCoherent(series);
+    }
+  });
+});
+
+it('retries when only the digest version changes between statements', async () => {
+  const first = await ingest(NVIDIA_CSV_V1);
+  await sql`update gpu_metric_series set stats_version = 0`;
+  await sql`update gpu_metric_gpu_stats set mean_value = -1`;
+  const interleaved = interleaveAfterStats(reader, async (index) => {
+    if (index === 1) await refreshGpuMetricStats(sql, first.seriesIds[0]!);
+  });
+  const payload = await getGpuMetricsForPoint(interleaved.client, 10);
+  expect(interleaved.seriesReads()).toBe(2);
+  expect(
+    payload?.series[0]?.stats.find((s) => s.gpuIndex === 0 && s.metric === 'power_w')?.mean,
+  ).toBeCloseTo(549.95, 3);
+});
diff --git a/packages/db/src/queries/gpu-metrics.test.ts b/packages/db/src/queries/gpu-metrics.test.ts
new file mode 100644
index 000000000..54745f11a
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics.test.ts
@@ -0,0 +1,321 @@
+import fs from 'node:fs';
+
+import { PGlite } from '@electric-sql/pglite';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import type { DbClient } from '../connection';
+import { getGpuMetricsForPoint, getGpuMetricsForRun, SAMPLE_PAGE_SIZE } from './gpu-metrics';
+
+let db: PGlite;
+const sql: DbClient = async (strings, ...values) => {
+  const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+  const result = await db.query<Record<string, unknown>>(query, values);
+  return result.rows;
+};
+
+const WITH_SERIES = 34557177019;
+const RETRIED = 34557177021;
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  await db.exec('ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb');
+}, 20_000);
+
+afterAll(async () => {
+  await db?.close();
+});
+
+/**
+ * Run 1 holds a two-node artifact (one CSV per serving node) whose first CSV is
+ * shared by points 10 and 11; runs 3 and 4 are two attempts of one GitHub run.
+ * Point 12 is deliberately left unlinked.
+ */
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion,
+      head_branch, head_sha, html_url, created_at, date)
+    VALUES (1, ${WITH_SERIES}, 1, 'Run Sweep', 'completed', 'success', 'main', 'abc123',
+        'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${WITH_SERIES}',
+        '2026-09-11T04:19:00Z', '2026-09-11'),
+      (3, ${RETRIED}, 1, 'Run Sweep', 'completed', 'failure', null, null, null,
+        '2026-09-13T04:19:00Z', '2026-09-13'),
+      (4, ${RETRIED}, 2, 'Run Sweep', 'completed', 'success', null, null, null,
+        '2026-09-13T06:19:00Z', '2026-09-13');
+
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      is_multinode, prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, true, 8, 8, 8, 8);
+
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+      isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+           (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}'),
+           (12, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 128, '{}');
+
+    INSERT INTO gpu_metric_series (id, workflow_run_id, artifact_name, config_key, file_name,
+      vendor, csv_sha256, sample_interval_s, sample_count, gpu_count, started_at, ended_at,
+      sidecars)
+    VALUES (100, 1, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'node0/gpu_metrics.csv', 'nvidia', 'sha-node0',
+        1, 3, 2, '2026-09-11T04:19:41Z', '2026-09-11T04:19:43Z',
+        '{"context": {"timestamp_timezone": "UTC"}}'),
+      (101, 1, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'node1/gpu_metrics.csv', 'nvidia', 'sha-node1',
+        1, 1, 1, '2026-09-11T04:19:41Z', '2026-09-11T04:19:42Z', '{}'),
+      (102, 4, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_1',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_1', 'gpu_metrics.csv', 'amd', 'sha-attempt2',
+        null, 1, 1, '2026-09-13T06:20:00Z', '2026-09-13T06:20:01Z', '{}'),
+      (103, 3, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'gpu_metrics.csv', 'nvidia', 'sha-attempt1',
+        null, 1, 1, '2026-09-13T04:20:00Z', '2026-09-13T04:20:01Z', '{}');
+
+    INSERT INTO benchmark_result_gpu_metrics (benchmark_result_id, series_id)
+    VALUES (10, 100), (11, 100), (10, 101);
+
+    INSERT INTO gpu_metric_gpu_stats (series_id, gpu_index, metric, sample_count,
+      min_value, max_value, mean_value, median_value, p95_value, p99_value, stddev_value)
+    VALUES (100, 0, 'powerW', 2, 187.5, 912.25, 549.875, 549.875, 912.25, 912.25, 362.375),
+           (100, 1, 'powerW', 1, 190.5, 190.5, 190.5, 190.5, 190.5, 190.5, 0),
+           (101, 0, 'powerW', 1, 500.5, 500.5, 500.5, 500.5, 500.5, 500.5, 0),
+           (102, 0, 'powerW', 1, 700.5, 700.5, 700.5, 700.5, 700.5, 700.5, 0),
+           (103, 0, 'powerW', 1, 100.5, 100.5, 100.5, 100.5, 100.5, 100.5, 0);
+
+    INSERT INTO gpu_metric_samples (series_id, gpu_index, sampled_at, power_w, temperature_c,
+      sm_clock_mhz, mem_clock_mhz, gpu_util_pct, mem_util_pct, edge_temp_c, mem_temp_c,
+      gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv, fclk_mhz, socclk_mhz, mm_activity_pct)
+    VALUES (100, 0, '2026-09-11T04:19:41Z', 187.5, 33, 120, 3996, 0, 0,
+              35.5, 40.5, 750, 800, 1350, 1940, 1100, 12.5),
+           (100, 1, '2026-09-11T04:19:41Z', 190.5, 39, 120, 3996, 0, 0,
+              null, null, null, null, null, null, null, null),
+           -- Collector dropout: the row exists but every metric column is null.
+           (100, 0, '2026-09-11T04:19:42Z', null, null, null, null, null, null,
+              null, null, null, null, null, null, null, null),
+           (101, 0, '2026-09-11T04:19:41Z', 500.5, 50, 1965, 3996, 98, 74,
+              null, null, null, null, null, null, null, null),
+           (102, 0, '2026-09-13T06:20:00Z', 700.5, 60, 1965, 3996, 99, 80,
+              null, null, null, null, null, null, null, null),
+           (103, 0, '2026-09-13T04:20:00Z', 100.5, 20, 120, 3996, 0, 0,
+              null, null, null, null, null, null, null, null);`);
+});
+
+describe('getGpuMetricsForRun', () => {
+  it('returns the run header, every series, its per-GPU stats, and its samples', async () => {
+    const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
+
+    expect(payload?.workflowRun).toEqual({
+      id: 1,
+      githubRunId: WITH_SERIES,
+      runAttempt: 1,
+      name: 'Run Sweep',
+      date: '2026-09-11',
+      htmlUrl: `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${WITH_SERIES}`,
+      headBranch: 'main',
+      headSha: 'abc123',
+      conclusion: 'success',
+      status: 'completed',
+      createdAt: '2026-09-11T04:19:00.000Z',
+    });
+
+    expect(payload?.series.map((series) => series.fileName)).toEqual([
+      'node0/gpu_metrics.csv',
+      'node1/gpu_metrics.csv',
+    ]);
+
+    const [node0, node1] = payload!.series;
+    expect(node0).toMatchObject({
+      id: 100,
+      artifactName: 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+      configKey: 'dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 3,
+      gpuCount: 2,
+      startedAt: '2026-09-11T04:19:41.000Z',
+      endedAt: '2026-09-11T04:19:43.000Z',
+      sidecars: { context: { timestamp_timezone: 'UTC' } },
+      benchmarkResultIds: [10, 11],
+    });
+    // Pre-migration (unversioned) digests are recomputed read-only; null is not zero.
+    expect(node0?.stats.filter((stat) => stat.metric === 'power_w')).toEqual([
+      {
+        gpuIndex: 0,
+        metric: 'power_w',
+        count: 1,
+        min: 187.5,
+        max: 187.5,
+        mean: 187.5,
+        median: 187.5,
+        p95: 187.5,
+        p99: 187.5,
+        stddev: 0,
+      },
+      {
+        gpuIndex: 1,
+        metric: 'power_w',
+        count: 1,
+        min: 190.5,
+        max: 190.5,
+        mean: 190.5,
+        median: 190.5,
+        p95: 190.5,
+        p99: 190.5,
+        stddev: 0,
+      },
+    ]);
+    expect(node0?.stats).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ gpuIndex: 0, metric: 'edge_temp_c', mean: 35.5, count: 1 }),
+        expect.objectContaining({ gpuIndex: 0, metric: 'gpu_util_pct', mean: 0, count: 1 }),
+        expect.objectContaining({ gpuIndex: 0, metric: 'mem_voltage_mv', mean: 1350, count: 1 }),
+      ]),
+    );
+    expect(node0?.data.map((sample) => [sample.timestamp, sample.index, sample.power])).toEqual([
+      ['2026-09-11T04:19:41.000Z', 0, 187.5],
+      ['2026-09-11T04:19:41.000Z', 1, 190.5],
+      ['2026-09-11T04:19:42.000Z', 0, 0],
+    ]);
+    expect(node0?.data[0]).toEqual({
+      timestamp: '2026-09-11T04:19:41.000Z',
+      index: 0,
+      power: 187.5,
+      temperature: 33,
+      smClock: 120,
+      memClock: 3996,
+      gpuUtil: 0,
+      memUtil: 0,
+      edgeTemp: 35.5,
+      memTemp: 40.5,
+      gfxVoltage: 750,
+      socVoltage: 800,
+      memVoltage: 1350,
+      fclk: 1940,
+      socClk: 1100,
+      mmActivity: 12.5,
+    });
+    expect(node1?.benchmarkResultIds).toEqual([10]);
+  });
+
+  it('reads the latest attempt of a rerun GitHub run id, not the first', async () => {
+    const payload = await getGpuMetricsForRun(sql, RETRIED);
+    expect(payload?.workflowRun).toMatchObject({ id: 4, runAttempt: 2, conclusion: 'success' });
+    expect(payload?.series.map((series) => ({ id: series.id, vendor: series.vendor }))).toEqual([
+      { id: 102, vendor: 'amd' },
+    ]);
+  });
+
+  it('reports a dropped sample as zero power with every other metric absent', async () => {
+    const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
+    const dropped = payload?.series[0]?.data.at(-1);
+    // Power keeps the `?? 0` default (a null power reading is indistinguishable
+    // from a genuine 0 W reading once it reaches the chart); the other metrics
+    // stay absent so a power-only collector never shows up as 0 °C / 0 MHz / 0 %.
+    expect(dropped).toEqual({
+      timestamp: '2026-09-11T04:19:42.000Z',
+      index: 0,
+      power: 0,
+      temperature: undefined,
+      smClock: undefined,
+      memClock: undefined,
+      gpuUtil: undefined,
+      memUtil: undefined,
+      edgeTemp: undefined,
+      memTemp: undefined,
+      gfxVoltage: undefined,
+      socVoltage: undefined,
+      memVoltage: undefined,
+      fclk: undefined,
+      socClk: undefined,
+      mmActivity: undefined,
+    });
+    // Absent rather than zeroed, so consumers can tell "not collected" from
+    // "collected as zero" for everything except power.
+    expect(Object.hasOwn(dropped!, 'edgeTemp')).toBe(true);
+    expect(dropped?.edgeTemp).toBeUndefined();
+  });
+});
+
+it('keeps healthy hosts readable when an unversioned sibling has incomplete samples', async () => {
+  await sql`update gpu_metric_series set sample_count = 4 where id = 100`;
+  const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
+  expect(payload?.series[0]?.stats).toEqual([]);
+  expect(payload?.series[0]?.data).toHaveLength(3);
+  expect(payload?.series[1]?.stats).toEqual(
+    expect.arrayContaining([expect.objectContaining({ metric: 'power_w', mean: 500.5, count: 1 })]),
+  );
+});
+
+it('scopes prefix and source reads in SQL, including containing power-audit bundles', async () => {
+  await db.exec(`INSERT INTO gpu_metric_series
+    (id, workflow_run_id, artifact_name, config_key, file_name, vendor, csv_sha256,
+      sample_count, gpu_count, started_at, ended_at)
+    VALUES (110, 1, 'power_audit_dsr1_8k1k_fp4_sglang', 'bundle', 'samples.csv', 'nvidia', 'bundle',
+      0, 1, now(), now()),
+      (111, 1, 'gpu_metrics_dsr1X8k1k_fp4_sglang_conc32_b200-x_0', 'other', 'gpu_metrics.csv', 'nvidia', 'other',
+      0, 1, now(), now());`);
+  const sampleIds: unknown[] = [];
+  const observed: DbClient = (strings, ...values) => {
+    if (strings.join('').includes('from gpu_metric_samples')) sampleIds.push(values[0]);
+    return sql(strings, ...values);
+  };
+  const payload = await getGpuMetricsForRun(observed, WITH_SERIES, {
+    prefix: 'dsr1_8k1k_fp4_sglang_conc32',
+    sourceResults: ['dsr1_8k1k_fp4_sglang_conc32_b200-x_0'],
+  });
+  expect(payload?.series.map((series) => series.id)).toEqual([100, 101, 110]);
+  expect(sampleIds).toEqual([[100, 101, 110]]);
+  expect(await getGpuMetricsForRun(sql, WITH_SERIES, { sourceResults: ['missing'] })).toBeNull();
+});
+
+it('reads only the selected view host while retaining every exact explorer label', async () => {
+  const prefix = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+  const names = [`${prefix}/node0/gpu_metrics.csv`, `${prefix}/node1/gpu_metrics.csv`];
+  const sampleIds: unknown[] = [];
+  const observed: DbClient = (strings, ...values) => {
+    if (strings.join('').includes('from gpu_metric_samples')) sampleIds.push(values[0]);
+    return sql(strings, ...values);
+  };
+  const selected = await getGpuMetricsForRun(observed, WITH_SERIES, { artifact: names[1] });
+  expect(selected?.artifactNames).toEqual(names);
+  expect(selected?.series.map((series) => series.id)).toEqual([101]);
+  expect(sampleIds).toEqual([[101]]);
+  const first = await getGpuMetricsForRun(sql, WITH_SERIES, { artifact: null });
+  expect(first?.series[0]?.id).toBe(100);
+  const missing = await getGpuMetricsForRun(observed, WITH_SERIES, { artifact: 'not-an-artifact' });
+  expect(missing).toMatchObject({ artifactNames: names, series: [] });
+  expect(sampleIds).toHaveLength(1);
+});
+
+it('pages a single large series without dropping microseconds and retries changes between pages', async () => {
+  await db.exec(`DELETE FROM gpu_metric_samples WHERE series_id = 100;
+    INSERT INTO gpu_metric_samples (series_id, gpu_index, sampled_at, power_w)
+    SELECT 100, 0, '2026-09-11T04:19:41Z'::timestamptz + n * interval '1 microsecond', n
+    FROM generate_series(1, ${SAMPLE_PAGE_SIZE + 2}) n;
+    UPDATE gpu_metric_series SET sample_count = ${SAMPLE_PAGE_SIZE + 2} WHERE id = 100;`);
+  let pages = 0;
+  const observed: DbClient = async (strings, ...values) => {
+    const rows = await sql(strings, ...values);
+    if (strings.join('').includes('from gpu_metric_samples')) {
+      // Model the bounded HTTP transport; the old whole-series query fails here.
+      expect(rows.length).toBeLessThanOrEqual(SAMPLE_PAGE_SIZE);
+      pages++;
+      if (pages === 1) {
+        await db.exec(`UPDATE gpu_metric_samples SET power_w = power_w + 20000 WHERE series_id = 100;
+          UPDATE gpu_metric_series SET ingested_at = ingested_at + interval '1 second' WHERE id = 100;`);
+      }
+    }
+    return rows;
+  };
+  const payload = await getGpuMetricsForPoint(observed, 11);
+  expect(pages).toBe(4);
+  const data = payload!.series[0]!.data;
+  expect(data).toHaveLength(SAMPLE_PAGE_SIZE + 2);
+  expect(data.map((row) => row.power)).toEqual(
+    Array.from({ length: SAMPLE_PAGE_SIZE + 2 }, (_, i) => i + 20001),
+  );
+  expect(payload!.series[0]!.stats.find((stat) => stat.metric === 'power_w')?.count).toBe(
+    SAMPLE_PAGE_SIZE + 2,
+  );
+});
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
new file mode 100644
index 000000000..cc4767cb6
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -0,0 +1,515 @@
+/**
+ * Read side of the PowerX telemetry digest (migration 016).
+ *
+ * Two entry points: everything recorded during one GitHub Actions run (the
+ * PowerX explorer keyed by run ID), and the series linked to one benchmark
+ * point (the per-point detail tab). Samples are returned as flat rows with
+ * ISO timestamps so the existing D3 charts consume them unchanged.
+ */
+
+import {
+  GPU_STATS_VERSION,
+  computeStoredGpuMetricStats,
+  statMetricColumn,
+  type StoredGpuMetricSample,
+} from '../lib/gpu-metric-stats';
+
+import type { DbClient } from '../connection.js';
+
+export interface GpuMetricSampleRow {
+  timestamp: string;
+  index: number;
+  power: number;
+  /**
+   * Absent when the collector did not sample the metric (the multinode DCGM
+   * power bundle scrapes power only), so readers can tell "not collected"
+   * from a genuine zero reading.
+   */
+  temperature?: number;
+  smClock?: number;
+  memClock?: number;
+  gpuUtil?: number;
+  memUtil?: number;
+  edgeTemp?: number;
+  memTemp?: number;
+  gfxVoltage?: number;
+  socVoltage?: number;
+  memVoltage?: number;
+  fclk?: number;
+  socClk?: number;
+  mmActivity?: number;
+}
+
+export interface GpuMetricStatRow {
+  gpuIndex: number;
+  metric: string;
+  count: number;
+  min: number;
+  max: number;
+  mean: number;
+  median: number;
+  p95: number;
+  p99: number;
+  stddev: number;
+}
+
+export interface GpuMetricSeries {
+  id: number;
+  artifactName: string;
+  configKey: string;
+  fileName: string;
+  vendor: string;
+  sampleIntervalS: number | null;
+  sampleCount: number;
+  gpuCount: number;
+  startedAt: string;
+  endedAt: string;
+  sidecars: Record<string, unknown>;
+  benchmarkResultIds: number[];
+  /** Existing benchmark provenance can recover windows from older ingests. */
+  powerAudits?: Record<string, unknown>[];
+  stats: GpuMetricStatRow[];
+  data: GpuMetricSampleRow[];
+}
+
+export interface GpuMetricsRunPayload {
+  workflowRun: {
+    id: number;
+    githubRunId: number;
+    runAttempt: number;
+    name: string;
+    date: string;
+    htmlUrl: string | null;
+    headBranch: string | null;
+    headSha: string | null;
+    conclusion: string | null;
+    status: string | null;
+    createdAt: string | null;
+  };
+  series: GpuMetricSeries[];
+  /** Complete explorer labels when only one view artifact's samples were requested. */
+  artifactNames?: string[];
+}
+
+export interface GpuMetricsRunSelection {
+  prefix?: string | null;
+  sourceResults?: readonly string[] | null;
+  /** Undefined reads all matching artifacts; null selects the first explorer artifact. */
+  artifact?: string | null;
+}
+
+// One sample row serializes to roughly 0.5 KB over the Neon HTTP driver (17 numeric
+// columns plus keys and an ISO timestamp), so 50k rows stay near 25 MB, well below the
+// 64 MiB response cap, while a 1.25M-sample run needs ~25 sequential pages, not 125.
+export const SAMPLE_PAGE_SIZE = 50_000;
+
+interface RawSeriesRow {
+  id: number | string;
+  workflow_run_id: number | string;
+  artifact_name: string;
+  config_key: string;
+  file_name: string;
+  vendor: string;
+  sample_interval_s: number | null;
+  sample_count: number;
+  gpu_count: number;
+  started_at: string | Date;
+  ended_at: string | Date;
+  sidecars: Record<string, unknown> | string;
+  benchmark_result_ids: (number | string)[] | null;
+  power_audits: Record<string, unknown>[] | null;
+  csv_sha256: string;
+  ingested_at: string | Date;
+  stats_version: number;
+}
+
+/** The columns `upsertGpuMetricSeries` rewrites whenever it replaces a series. */
+interface RawSeriesVersionRow {
+  id: number | string;
+  csv_sha256: string;
+  sample_count: number;
+  ingested_at: string | Date;
+  stats_version: number;
+}
+
+interface RawStatRow {
+  series_id: number | string;
+  gpu_index: number;
+  metric: string;
+  sample_count: number;
+  min_value: number;
+  max_value: number;
+  mean_value: number;
+  median_value: number;
+  p95_value: number;
+  p99_value: number;
+  stddev_value: number;
+}
+
+interface RawSampleRow extends StoredGpuMetricSample {
+  series_id: number | string;
+}
+
+const isoString = (value: string | Date): string =>
+  value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+
+const optional = (value: number | null): number | undefined => (value === null ? undefined : value);
+
+/**
+ * Thrown by the point/run readers when a series was replaced while its parts
+ * were being read; the caller restarts the whole read (links may have changed).
+ */
+export class TelemetrySnapshotChangedError extends Error {
+  constructor(seriesIds: readonly number[]) {
+    super(`gpu_metric_series ${seriesIds.join(', ')} changed while being read`);
+    this.name = 'TelemetrySnapshotChangedError';
+  }
+}
+
+const MAX_SNAPSHOT_ATTEMPTS = 3;
+
+const seriesVersionKey = (row: RawSeriesVersionRow): string =>
+  `${Number(row.id)}:${row.csv_sha256}:${Number(row.sample_count)}:${isoString(row.ingested_at)}:${row.stats_version}`;
+
+async function withConsistentSnapshot<T>(read: () => Promise<T>): Promise<T> {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return await read();
+    } catch (error) {
+      if (!(error instanceof TelemetrySnapshotChangedError) || attempt >= MAX_SNAPSHOT_ATTEMPTS) {
+        throw error;
+      }
+    }
+  }
+}
+
+function toSampleRow(raw: RawSampleRow): GpuMetricSampleRow {
+  return {
+    timestamp: isoString(raw.sampled_at),
+    index: Number(raw.gpu_index),
+    power: raw.power_w ?? 0,
+    temperature: optional(raw.temperature_c),
+    smClock: optional(raw.sm_clock_mhz),
+    memClock: optional(raw.mem_clock_mhz),
+    gpuUtil: optional(raw.gpu_util_pct),
+    memUtil: optional(raw.mem_util_pct),
+    edgeTemp: optional(raw.edge_temp_c),
+    memTemp: optional(raw.mem_temp_c),
+    gfxVoltage: optional(raw.gfx_voltage_mv),
+    socVoltage: optional(raw.soc_voltage_mv),
+    memVoltage: optional(raw.mem_voltage_mv),
+    fclk: optional(raw.fclk_mhz),
+    socClk: optional(raw.socclk_mhz),
+    mmActivity: optional(raw.mm_activity_pct),
+  };
+}
+
+function toStatRow(raw: RawStatRow): GpuMetricStatRow {
+  return {
+    gpuIndex: Number(raw.gpu_index),
+    metric: raw.metric,
+    count: Number(raw.sample_count),
+    min: raw.min_value,
+    max: raw.max_value,
+    mean: raw.mean_value,
+    median: raw.median_value,
+    p95: raw.p95_value,
+    p99: raw.p99_value,
+    stddev: raw.stddev_value,
+  };
+}
+
+async function loadSeriesDetails(
+  sql: DbClient,
+  seriesRows: readonly RawSeriesRow[],
+): Promise<GpuMetricSeries[]> {
+  if (seriesRows.length === 0) return [];
+  const ids = seriesRows.map((row) => Number(row.id));
+
+  const statRows = (await sql`
+    select series_id, gpu_index, metric, sample_count, min_value, max_value, mean_value,
+      median_value, p95_value, p99_value, stddev_value
+    from gpu_metric_gpu_stats
+    where series_id = any(${ids}::bigint[])
+    order by series_id, gpu_index, metric
+  `) as unknown as RawStatRow[];
+
+  const sampleRows: RawSampleRow[] = [];
+  let cursor: RawSampleRow | undefined;
+  for (;;) {
+    const page = (await sql`
+      select series_id, gpu_index,
+        to_char(sampled_at at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"') as sampled_at,
+        power_w, temperature_c, sm_clock_mhz, mem_clock_mhz, gpu_util_pct, mem_util_pct,
+        edge_temp_c, mem_temp_c, gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv,
+        fclk_mhz, socclk_mhz, mm_activity_pct
+      from gpu_metric_samples
+      where series_id = any(${ids}::bigint[])
+        and (${cursor?.series_id ?? null}::bigint is null or
+          (series_id, gpu_index, sampled_at) >
+          (${cursor?.series_id ?? null}::bigint, ${cursor?.gpu_index ?? null}::smallint,
+            ${cursor?.sampled_at ?? null}::timestamptz))
+      order by series_id, gpu_index, gpu_metric_samples.sampled_at
+      limit ${SAMPLE_PAGE_SIZE}
+    `) as unknown as RawSampleRow[];
+    sampleRows.push(...page);
+    if (page.length < SAMPLE_PAGE_SIZE) break;
+    // Keep PostgreSQL's microseconds: a JS Date cursor would repeat or omit boundary rows.
+    cursor = page.at(-1)!;
+  }
+  // The primary-key pages group by GPU; retain the public time-then-GPU ordering.
+  sampleRows.sort(
+    (a, b) =>
+      Number(a.series_id) - Number(b.series_id) ||
+      String(a.sampled_at).localeCompare(String(b.sampled_at)) ||
+      Number(a.gpu_index) - Number(b.gpu_index),
+  );
+
+  // The series, stats and sample pages use separate autocommit queries (the DbClient
+  // has no transaction), so a re-ingest can commit between them. The writer
+  // replaces samples, stats and the series row in one transaction and stamps
+  // `ingested_at`; digest-only upgrades change `stats_version`. An unchanged
+  // key after the sample read proves both belong to the same series version.
+  const versionRows = (await sql`
+    select id, csv_sha256, sample_count, ingested_at,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0) as stats_version
+    from gpu_metric_series s
+    where id = any(${ids}::bigint[])
+  `) as unknown as RawSeriesVersionRow[];
+  const versionKeys = new Set(versionRows.map(seriesVersionKey));
+  if (
+    versionRows.length !== seriesRows.length ||
+    !seriesRows.every((row) => versionKeys.has(seriesVersionKey(row)))
+  ) {
+    throw new TelemetrySnapshotChangedError(ids);
+  }
+
+  const statsBySeries = new Map<number, GpuMetricStatRow[]>();
+  for (const raw of statRows) {
+    const key = Number(raw.series_id);
+    const bucket = statsBySeries.get(key);
+    if (bucket) bucket.push(toStatRow(raw));
+    else statsBySeries.set(key, [toStatRow(raw)]);
+  }
+  const staleIds = new Set(
+    seriesRows
+      .filter((row) => row.stats_version !== GPU_STATS_VERSION)
+      .map((row) => Number(row.id)),
+  );
+  const staleSamples = new Map<number, RawSampleRow[]>();
+  for (const sample of sampleRows) {
+    const id = Number(sample.series_id);
+    if (!staleIds.has(id)) continue;
+    const rows = staleSamples.get(id) ?? [];
+    rows.push(sample);
+    staleSamples.set(id, rows);
+  }
+  for (const row of seriesRows) {
+    const id = Number(row.id);
+    if (!staleIds.has(id)) continue;
+    const samples = staleSamples.get(id) ?? [];
+    if (samples.length !== Number(row.sample_count)) {
+      // Keep samples available to the existing source-gap recovery path, but
+      // never present a partial-population digest as full-record statistics.
+      statsBySeries.set(id, []);
+      continue;
+    }
+    statsBySeries.set(
+      id,
+      computeStoredGpuMetricStats(samples).map((stat) => ({
+        ...stat,
+        metric: statMetricColumn(stat.metric),
+      })),
+    );
+  }
+  const samplesBySeries = new Map<number, GpuMetricSampleRow[]>();
+  for (const raw of sampleRows) {
+    const key = Number(raw.series_id);
+    const bucket = samplesBySeries.get(key);
+    if (bucket) bucket.push(toSampleRow(raw));
+    else samplesBySeries.set(key, [toSampleRow(raw)]);
+  }
+
+  return seriesRows.map((row) => {
+    const id = Number(row.id);
+    return {
+      id,
+      artifactName: row.artifact_name,
+      configKey: row.config_key,
+      fileName: row.file_name,
+      vendor: row.vendor,
+      sampleIntervalS: row.sample_interval_s,
+      sampleCount: Number(row.sample_count),
+      gpuCount: Number(row.gpu_count),
+      startedAt: isoString(row.started_at),
+      endedAt: isoString(row.ended_at),
+      sidecars:
+        typeof row.sidecars === 'string'
+          ? (JSON.parse(row.sidecars) as Record<string, unknown>)
+          : row.sidecars,
+      benchmarkResultIds: (row.benchmark_result_ids ?? []).map(Number),
+      powerAudits: row.power_audits ?? [],
+      stats: statsBySeries.get(id) ?? [],
+      data: samplesBySeries.get(id) ?? [],
+    };
+  });
+}
+
+/**
+ * Stored telemetry for one GitHub Actions run (latest attempt), optionally scoped
+ * before reading samples. View selection also returns the full artifact-name inventory.
+ * Returns null when the run is unknown or has no stored series, so callers can
+ * fall back to the live GitHub artifacts for in-flight runs.
+ */
+export function getGpuMetricsForRun(
+  sql: DbClient,
+  githubRunId: number,
+  selection: GpuMetricsRunSelection = {},
+): Promise<GpuMetricsRunPayload | null> {
+  return withConsistentSnapshot(() => readGpuMetricsForRun(sql, githubRunId, selection));
+}
+
+async function readGpuMetricsForRun(
+  sql: DbClient,
+  githubRunId: number,
+  selection: GpuMetricsRunSelection,
+): Promise<GpuMetricsRunPayload | null> {
+  const runRows = (await sql`
+    select id, github_run_id, run_attempt, name, date, html_url, head_branch, head_sha,
+      conclusion, status, created_at
+    from workflow_runs
+    where github_run_id = ${githubRunId}
+    order by run_attempt desc
+    limit 1
+  `) as unknown as {
+    id: number | string;
+    github_run_id: number | string;
+    run_attempt: number;
+    name: string;
+    date: string | Date;
+    html_url: string | null;
+    head_branch: string | null;
+    head_sha: string | null;
+    conclusion: string | null;
+    status: string | null;
+    created_at: string | Date | null;
+  }[];
+  const run = runRows[0];
+  if (!run) return null;
+
+  let artifactNames: string[] | undefined;
+  let selectedIds: number[] | null = null;
+  if (selection.artifact !== undefined) {
+    const inventory = (await sql`
+      select id,
+        case when count(*) over (partition by artifact_name) > 1
+          then artifact_name || '/' || file_name else artifact_name end as name
+      from gpu_metric_series
+      where workflow_run_id = ${Number(run.id)}
+      order by artifact_name, file_name
+    `) as { id: number | string; name: string }[];
+    if (inventory.length === 0) return null;
+    artifactNames = inventory.map((entry) => entry.name);
+    const selected = selection.artifact ?? artifactNames[0];
+    selectedIds = inventory
+      .filter((entry) => entry.name === selected)
+      .map((entry) => Number(entry.id));
+  }
+  const prefix = selection.prefix ?? null;
+  const sources = selection.sourceResults ?? null;
+
+  const seriesRows = (await sql`
+    select s.id, s.workflow_run_id, s.artifact_name, s.config_key, s.file_name, s.vendor,
+      s.sample_interval_s, s.sample_count, s.gpu_count, s.started_at, s.ended_at, s.sidecars,
+      s.csv_sha256, s.ingested_at,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0) as stats_version,
+      (
+        select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
+        from benchmark_result_gpu_metrics l where l.series_id = s.id
+      ) as benchmark_result_ids,
+      (
+        select jsonb_agg(br.power_audit order by br.id)
+        from benchmark_result_gpu_metrics l
+        join benchmark_results br on br.id = l.benchmark_result_id
+        where l.series_id = s.id and br.power_audit is not null
+      ) as power_audits
+    from gpu_metric_series s
+    where s.workflow_run_id = ${Number(run.id)}
+      and (${selectedIds}::bigint[] is null or s.id = any(${selectedIds}::bigint[]))
+      and (${prefix}::text is null or starts_with(s.artifact_name, 'gpu_metrics_' || ${prefix})
+        or (starts_with(s.artifact_name, 'power_audit_') and
+          (starts_with(s.artifact_name, 'power_audit_' || ${prefix})
+            or starts_with('power_audit_' || ${prefix}, s.artifact_name))))
+      and (${sources}::text[] is null or exists (
+        select 1 from unnest(${sources}::text[]) as requested(result)
+        where s.artifact_name = 'gpu_metrics_' || requested.result
+          or (starts_with(s.artifact_name, 'power_audit_') and
+            (starts_with(s.artifact_name, 'power_audit_' || requested.result)
+              or starts_with('power_audit_' || requested.result, s.artifact_name)))
+      ))
+    order by s.artifact_name, s.file_name
+  `) as unknown as RawSeriesRow[];
+  if (seriesRows.length === 0 && artifactNames === undefined) return null;
+
+  return {
+    workflowRun: {
+      id: Number(run.id),
+      githubRunId: Number(run.github_run_id),
+      runAttempt: Number(run.run_attempt),
+      name: run.name,
+      date: isoString(run.date).slice(0, 10),
+      htmlUrl: run.html_url,
+      headBranch: run.head_branch,
+      headSha: run.head_sha,
+      conclusion: run.conclusion,
+      status: run.status,
+      createdAt: run.created_at ? isoString(run.created_at) : null,
+    },
+    series: await loadSeriesDetails(sql, seriesRows),
+    ...(artifactNames === undefined ? {} : { artifactNames }),
+  };
+}
+
+export interface GpuMetricsPointPayload {
+  benchmarkResultId: number;
+  series: GpuMetricSeries[];
+}
+
+/** Series linked to one benchmark point, with samples. Null when none is linked. */
+export function getGpuMetricsForPoint(
+  sql: DbClient,
+  benchmarkResultId: number,
+): Promise<GpuMetricsPointPayload | null> {
+  return withConsistentSnapshot(() => readGpuMetricsForPoint(sql, benchmarkResultId));
+}
+
+async function readGpuMetricsForPoint(
+  sql: DbClient,
+  benchmarkResultId: number,
+): Promise<GpuMetricsPointPayload | null> {
+  const seriesRows = (await sql`
+    select s.id, s.workflow_run_id, s.artifact_name, s.config_key, s.file_name, s.vendor,
+      s.sample_interval_s, s.sample_count, s.gpu_count, s.started_at, s.ended_at, s.sidecars,
+      s.csv_sha256, s.ingested_at,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0) as stats_version,
+      (
+        select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
+        from benchmark_result_gpu_metrics l where l.series_id = s.id
+      ) as benchmark_result_ids,
+      (
+        select jsonb_agg(br.power_audit order by br.id)
+        from benchmark_result_gpu_metrics l
+        join benchmark_results br on br.id = l.benchmark_result_id
+        where l.series_id = s.id and br.power_audit is not null
+      ) as power_audits
+    from benchmark_result_gpu_metrics link
+    join gpu_metric_series s on s.id = link.series_id
+    where link.benchmark_result_id = ${benchmarkResultId}
+    order by s.artifact_name, s.file_name
+  `) as unknown as RawSeriesRow[];
+  if (seriesRows.length === 0) return null;
+  return {
+    benchmarkResultId,
+    series: await loadSeriesDetails(sql, seriesRows),
+  };
+}

From 1ba550d498b7aa389af2f32230e6ea7a252afc87 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 065/103] feat(ui): power boundary metrics, comparison overlays
 and role energy
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add gated power-boundary y-axis metrics (GPU-measured, GPU-provisioned, utility
provisioned, utility modeled), the i_pcompare boundary/role comparison overlays with
per-series line labels, reconstructed prefill/decode energy, and CSV/table plumbing;
overlay runs follow the same paths.

中文：新增门控的功耗边界 y 轴指标（GPU 实测、GPU 配给、市电配给、市电建模）、i_pcompare 边界/角色对比叠加与逐序列线标签、重建的 prefill/decode 能耗及 CSV/表格贯通；非正式 run 叠加走同一路径。
---
 docs/index.md                                 |   1 +
 .../component/inference-chart-controls.cy.tsx |   6 +-
 .../cypress/component/power-compare.cy.tsx    | 154 +++++
 .../cypress/component/scatter-graph.cy.tsx    |  19 +-
 packages/app/cypress/support/mock-data.ts     |   2 +
 .../src/components/calculator/profit-power.ts |   8 +-
 .../components/inference/InferenceContext.tsx |  42 +-
 .../inference/axis-metric-explanations.ts     | 110 +++
 .../inference/hooks/useChartData.ts           |  13 +-
 .../inference/measured-metric-config.test.ts  |  37 +-
 .../inference/measured-metric-config.ts       |  87 ++-
 .../inference/metric-registry.test.ts         |  11 +-
 .../components/inference/metric-registry.ts   | 105 ++-
 .../app/src/components/inference/types.ts     |  63 ++
 .../components/inference/ui/ChartControls.tsx |  11 +-
 .../components/inference/ui/ChartDisplay.tsx  |  84 ++-
 .../src/components/inference/ui/GPUGraph.tsx  |  62 +-
 .../inference/ui/InferenceTable.test.ts       |  55 +-
 .../inference/ui/InferenceTable.tsx           |  28 +-
 .../inference/ui/MeasuredMetricControls.tsx   | 138 +++-
 .../inference/ui/PowerMetricAvailability.tsx  | 161 ++++-
 .../ui/ScatterGraph.test-harness.tsx          |  19 +
 .../components/inference/ui/ScatterGraph.tsx  | 635 +++++++++++++++---
 .../inference/ui/inference-table-sort.ts      |   4 +-
 .../inference/ui/line-label-layer.test.ts     |   7 +-
 .../inference/ui/line-label-layer.ts          | 113 +++-
 .../ui/line-label-visibility.test.ts          |  20 +
 .../inference/ui/line-label-visibility.ts     |  14 +-
 .../app/src/components/inference/utils.ts     |  22 +-
 .../inference/utils/best-series-per-sku.ts    |   4 +-
 .../inference/utils/point-identity.ts         |  38 ++
 .../inference/utils/power-compare.ts          | 326 +++++++++
 .../inference/utils/powerCurves.test.ts       |   8 +-
 .../components/inference/utils/powerCurves.ts |  40 +-
 .../inference/utils/role-energy.test.ts       |  26 +
 .../components/inference/utils/role-energy.ts |  64 ++
 .../utils/tooltip-utils.power-trace.test.ts   |  94 +++
 .../inference/utils/tooltipUtils.ts           | 194 +++++-
 packages/app/src/lib/chart-utils.test.ts      | 138 ++--
 packages/app/src/lib/chart-utils.ts           |  41 +-
 .../app/src/lib/csv-export-helpers.test.ts    |  37 +
 packages/app/src/lib/csv-export-helpers.ts    |  14 +-
 packages/app/src/lib/inference-labels.ts      |  42 ++
 .../app/src/lib/modeled-system-power.test.ts  |  83 +++
 packages/app/src/lib/modeled-system-power.ts  |  40 +-
 packages/app/src/lib/power-basis.test.ts      |  73 ++
 packages/app/src/lib/power-basis.ts           | 211 ++++++
 packages/app/src/lib/url-state.ts             |  28 +
 48 files changed, 3249 insertions(+), 283 deletions(-)
 create mode 100644 packages/app/cypress/component/power-compare.cy.tsx
 create mode 100644 packages/app/src/components/inference/utils/power-compare.ts
 create mode 100644 packages/app/src/components/inference/utils/role-energy.test.ts
 create mode 100644 packages/app/src/components/inference/utils/role-energy.ts
 create mode 100644 packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
 create mode 100644 packages/app/src/lib/power-basis.test.ts
 create mode 100644 packages/app/src/lib/power-basis.ts

diff --git a/docs/index.md b/docs/index.md
index c67e877ae..2e6c0224a 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -9,6 +9,7 @@ Design rationale and non-obvious conventions. See [CLAUDE.md](../CLAUDE.md) for
 
 - [API Skill Examples](./inferencex-api-examples.md) — Install the public skill, query benchmarks, export measured PowerX data, and explain empty results
 - [PowerX System Power](./powerx-system-power.md) — Pinned chassis model, measured-input guards, assumptions, and reproducible article exports
+- [PowerX Permanent View](./powerx-permanent-view.md) — Power boundaries as gated Measured Energy metrics, `i_metric`/`i_rulers` share links, missing-value states
 - [PowerX Persistence and Recovery](./powerx-persistence-recovery.md) — Telemetry receipts, migration prerequisites, and targeted repair
 - [API Skill Releases](./inferencex-skills-release.md) — Prepare an immutable package, verify clean installations and agent exports, and publish through the package-specific workflow
 - [API Skill Discovery](./inferencex-skills-discovery.md) — Accept or reject implicit skill discovery in fresh Codex and Claude Code projects
diff --git a/packages/app/cypress/component/inference-chart-controls.cy.tsx b/packages/app/cypress/component/inference-chart-controls.cy.tsx
index ded6bd9ba..4445d303b 100644
--- a/packages/app/cypress/component/inference-chart-controls.cy.tsx
+++ b/packages/app/cypress/component/inference-chart-controls.cy.tsx
@@ -469,8 +469,10 @@ describe('Inference ChartControls grouped measured metrics', () => {
       cy.get(`input[aria-label="${searchLabel}"]`).type(group);
       cy.get('[data-select-option][data-value^="y_measured"]').should(($options) => {
         const values = [...$options].map((option) => option.dataset.value);
-        expect(values).to.have.length(13);
-        expect(new Set(values).size).to.equal(13);
+        // Thirteen measured axes plus the Timeline display of measured power.
+        expect(values).to.have.length(14);
+        expect(new Set(values).size).to.equal(14);
+        expect(values).to.include('y_measuredPowerTimeline');
       });
       cy.get(`input[aria-label="${searchLabel}"]`).clear().type(power);
       cy.get('[data-select-option]')
diff --git a/packages/app/cypress/component/power-compare.cy.tsx b/packages/app/cypress/component/power-compare.cy.tsx
new file mode 100644
index 000000000..e1d3917a0
--- /dev/null
+++ b/packages/app/cypress/component/power-compare.cy.tsx
@@ -0,0 +1,154 @@
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+
+import ScatterGraph from '@/components/inference/ui/ScatterGraph';
+import type { InferenceData } from '@/components/inference/types';
+import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
+import { Precision } from '@/lib/data-mappings';
+import { overlayRunColor } from '@/lib/overlay-run-style';
+
+import {
+  createMockChartDefinition,
+  createMockHardwareConfig,
+  createMockInferenceData,
+} from '../support/mock-data';
+import { mountWithProviders } from '../support/test-utils';
+
+// Power comparison series (`i_pcompare`) on `?unofficialrun=` overlays: role
+// clones draw in the overlay run colour with the role dash, and their legend
+// rows toggle them.
+
+const OVERLAY_RUN_ID = 31415926535;
+const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
+const hwConfig = createMockHardwareConfig();
+const chartDefinition = createMockChartDefinition({
+  chartType: 'interactivity',
+  y_measuredAvgPower: 'measuredAvgPower.y',
+  y_measuredAvgPower_roofline: 'lower_left',
+});
+
+const metric = (y: number) => ({ y, roof: false });
+
+/**
+ * Three measured points with both roles available. Power falls as x rises so
+ * every point sits on the upper power envelope the chart draws for watt axes.
+ */
+function measuredCurve(hwKey: string, run_url?: string): InferenceData[] {
+  return [
+    [8, 700, 840, 500],
+    [16, 600, 820, 450],
+    [32, 500, 800, 400],
+  ].map(([x, measured, prefill, decode]) =>
+    createMockInferenceData({
+      hwKey,
+      x,
+      conc: x,
+      y: measured,
+      precision: Precision.FP4,
+      run_url,
+      disagg: true,
+      measuredAvgPower: metric(measured),
+      measuredPrefillAvgPower: metric(prefill),
+      measuredDecodeAvgPower: metric(decode),
+    }),
+  );
+}
+
+function mountCompare(data: InferenceData[], overlay: InferenceData[]) {
+  mountWithProviders(
+    <PathnameContext.Provider value="/inference">
+      <div style={{ width: 1000, height: 640 }}>
+        <ScatterGraph
+          chartId="power-compare-test"
+          modelLabel="DeepSeek V4 Pro"
+          data={data}
+          xLabel="Interactivity (tok/s/user)"
+          yLabel="Measured Power per Chip (W)"
+          chartDefinition={chartDefinition}
+          overlayData={{
+            data: overlay,
+            hardwareConfig: hwConfig,
+            label: 'powerx-compare',
+            runUrl: OVERLAY_RUN_URL,
+          }}
+        />
+      </div>
+    </PathnameContext.Provider>,
+    {
+      inference: {
+        selectedYAxisMetric: 'y_measuredAvgPower',
+        hardwareConfig: hwConfig,
+        activeHwTypes: new Set(['b200', 'h100']),
+        hwTypesWithData: new Set(['b200', 'h100']),
+        selectedPrecisions: [Precision.FP4],
+        hideNonOptimal: false,
+        showLineLabels: false,
+      },
+      unofficial: {
+        isUnofficialRun: true,
+        activeOverlayHwTypes: new Set(['h100']),
+        allOverlayHwTypes: new Set(['h100']),
+        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [String(OVERLAY_RUN_ID)]: 0 },
+        unofficialRunInfos: [
+          {
+            id: OVERLAY_RUN_ID,
+            name: 'powerx-compare',
+            branch: 'powerx-compare',
+            sha: 'abc000',
+            createdAt: '2026-09-01T00:00:00Z',
+            url: OVERLAY_RUN_URL,
+            conclusion: 'success',
+            status: 'completed',
+            isNonMainBranch: true,
+          },
+        ],
+      },
+    },
+  );
+}
+
+const svg = '#power-compare-test svg';
+const legend = '#power-compare-test [data-testid="chart-legend"]';
+
+describe('ScatterGraph power comparison series', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message.includes('ResizeObserver loop')) return false;
+    });
+  });
+
+  it('draws role siblings for ?unofficialrun= overlays in the run colour with the role dash', () => {
+    const official = expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles');
+    const overlay = expandPowerCompareSeries(
+      measuredCurve('h100', OVERLAY_RUN_URL),
+      'y_measuredAvgPower',
+      'roles',
+    );
+    mountCompare(official, overlay);
+
+    cy.get(`${svg} .roofline-path[data-power-variant="prefill"]`).should(
+      'have.attr',
+      'stroke-dasharray',
+      '7 3',
+    );
+    cy.get(`${svg} .unofficial-overlay-pt`).should('have.length', 9);
+    cy.get(`${svg} .overlay-roofline-path[data-power-variant="decode"]`)
+      .should('have.length', 1)
+      .and('have.attr', 'stroke', overlayRunColor(0))
+      .and('have.attr', 'stroke-dasharray', '2 3');
+    cy.get(`${svg} .overlay-roofline-path:not([data-power-variant])`).should('have.length', 1);
+    cy.get(legend).within(() => {
+      cy.contains('All GPUs').should('exist');
+      cy.contains('Prefill GPUs').should('exist');
+      cy.contains('Decode GPUs').click();
+    });
+    cy.get(`${svg} .overlay-roofline-path[data-power-variant="decode"]`).should(
+      'have.css',
+      'opacity',
+      '0',
+    );
+    cy.get(`${svg} .unofficial-overlay-pt`).then(($points) => {
+      const hidden = [...$points].filter((point) => getComputedStyle(point).opacity === '0');
+      expect(hidden).to.have.length(3);
+    });
+  });
+});
diff --git a/packages/app/cypress/component/scatter-graph.cy.tsx b/packages/app/cypress/component/scatter-graph.cy.tsx
index 0f157fea1..fac02fad5 100644
--- a/packages/app/cypress/component/scatter-graph.cy.tsx
+++ b/packages/app/cypress/component/scatter-graph.cy.tsx
@@ -925,14 +925,19 @@ describe('ScatterGraph', () => {
     cy.get('#test-scatter-overlay-labels svg .line-label')
       .filter('[data-line-key]:not([data-line-key^="overlay-"])')
       .should('have.length.greaterThan', 0);
-    // The exact branch that crashed the production page remains visible in the
-    // overlay line label and legend after ScatterGraph's render-time updates.
-    cy.get('#test-scatter-overlay-labels svg .line-label[data-line-key^="overlay-"]')
-      .find('text')
-      .should('contain.text', runBranch);
+    // The pill names the hardware behind the ✕ marker, parsed like an official
+    // pill; the long branch that crashed the production page stays in the legend.
+    cy.get('#test-scatter-overlay-labels svg .line-label[data-line-key^="overlay-"] .ll-text')
+      .should('have.text', '✕ B200 (TRTLLM)')
+      .and('not.contain.text', runBranch);
     cy.get(
       '#test-scatter-overlay-labels svg .line-label[data-line-key^="overlay-"] .ll-gpu',
-    ).should('not.exist');
+    ).should('have.text', 'B200');
+    // b200_trt is active only in the overlay legend (official rows: h100), so
+    // the overlay pill must stay visible after the filter-sync effect.
+    cy.get('#test-scatter-overlay-labels svg .line-label[data-line-key^="overlay-"]')
+      .should('have.attr', 'data-visible', '1')
+      .and('have.css', 'opacity', '1');
     cy.get('#test-scatter-overlay-labels [data-testid="chart-legend"]').should(
       'contain.text',
       runBranch,
@@ -1094,7 +1099,7 @@ describe('ScatterGraph', () => {
     cy.get('#test-scatter-singleton-overlay-label svg .line-label[data-line-key^="overlay-"]')
       .should('have.length', 1)
       .find('text')
-      .should('contain.text', 'tileRT');
+      .should('have.text', '✕ B200 (TRTLLM)');
 
     cy.get('#test-scatter-singleton-overlay-label svg').then(($svg) => {
       const svg = $svg[0];
diff --git a/packages/app/cypress/support/mock-data.ts b/packages/app/cypress/support/mock-data.ts
index 413f38fab..733d04e49 100644
--- a/packages/app/cypress/support/mock-data.ts
+++ b/packages/app/cypress/support/mock-data.ts
@@ -232,6 +232,8 @@ export function createMockInferenceContextValues(
     setSelectedXAxisMode: namedStub('setSelectedXAxisMode'),
     scaleType: 'auto',
     setScaleType: namedStub('setScaleType'),
+    powerCompare: 'none' as const,
+    setPowerCompare: namedStub('setPowerCompare'),
     quickFilters: { vendors: [], frameworks: [], deployment: [], spec: [], power: [] },
     availableQuickFilters: { vendors: [], frameworks: [], deployment: [], spec: [], power: [] },
     setQuickFilterVendors: namedStub('setQuickFilterVendors'),
diff --git a/packages/app/src/components/calculator/profit-power.ts b/packages/app/src/components/calculator/profit-power.ts
index 089abb453..1c6bc2a1b 100644
--- a/packages/app/src/components/calculator/profit-power.ts
+++ b/packages/app/src/components/calculator/profit-power.ts
@@ -40,8 +40,12 @@ function planningPower(point: GPUDataPoint): PlanningPower {
       }
     }
   }
-  // Full-chassis planning requires whole replicas to fit on one eight-GPU host.
-  if (estimate.topologyBasis !== 'single-node' || 8 % estimate.gpuCount !== 0)
+  // Partial allocations must tile one host; fully measured multi-host estimates
+  // retain their validated worker-hosts or uniform-hosts topology.
+  if (
+    estimate.chassisBasis === 'extrapolated' &&
+    (estimate.topologyBasis !== 'single-node' || 8 % estimate.gpuCount !== 0)
+  )
     return { reason: 'unsupported-power-topology' };
   return {
     kwPerGpu: (estimate.deploymentFacilityWatts / estimate.gpuCount / 1000) * 1.1,
diff --git a/packages/app/src/components/inference/InferenceContext.tsx b/packages/app/src/components/inference/InferenceContext.tsx
index 036f22700..206c9fd47 100644
--- a/packages/app/src/components/inference/InferenceContext.tsx
+++ b/packages/app/src/components/inference/InferenceContext.tsx
@@ -37,6 +37,7 @@ import type {
   InferenceDataContextType,
   InferenceDisplayContextType,
   InferenceFiltersContextType,
+  PowerCompare,
   TokenRevenuePriceSource,
 } from '@/components/inference/types';
 import { resolveMetricConfigKey } from '@/components/inference/metric-registry';
@@ -56,6 +57,14 @@ import {
   useUrlStateSync,
 } from '@/hooks/useChartContext';
 import { useUrlState } from '@/hooks/useUrlState';
+import { serializePerfRulers } from '@/lib/d3-chart/layers/perf-ruler';
+import { parsePowerCompare } from '@/components/inference/utils/power-compare';
+import {
+  PERSISTED_PERF_RULER_CHART_ID,
+  PerfRulerStoreContext,
+  persistedPerfRulerAxisKey,
+  usePerfRulerStoreValue,
+} from '@/components/inference/perf-ruler-store';
 import { useParetoHighlightToggle } from './hooks/useParetoHighlightToggle';
 import { useOpenRouterPricing } from '@/hooks/api/use-openrouter-pricing';
 import { DEFAULT_Y_AXIS_METRIC } from '@/lib/url-state';
@@ -483,6 +492,12 @@ export function InferenceProvider({
   const [scaleType, setScaleType] = useState<'auto' | 'linear' | 'log'>(
     () => (getUrlParam('i_scale') as 'auto' | 'linear' | 'log') || 'auto',
   );
+  // Comparison series on a gated power metric (`i_pcompare`). Kept while the
+  // metric changes: a key without a common axis simply yields no siblings, and
+  // the Measured controls say so, so a link's intent survives a detour.
+  const [powerCompare, setPowerCompare] = useState<PowerCompare>(() =>
+    parsePowerCompare(getUrlParam('i_pcompare')),
+  );
 
   // ── Quick filters (vendor / framework / deployment / mtp-stp / power tier) ──
   // Coarse pre-filters applied to the point set. Empty = no constraint.
@@ -770,6 +785,7 @@ export function InferenceProvider({
       !isUnofficialRun &&
       !hasExplicitRunSelection &&
       selectedRunDateRev === 0,
+    powerCompare,
   );
 
   // For GPU comparison date picker — use shared availability data from global filters
@@ -1035,6 +1051,21 @@ export function InferenceProvider({
   const refreshing = !availabilityError && chartDataRefreshing;
   const error = availabilityError || workflowError || chartDataError;
 
+  // ── Perf rulers (persisted chart) ────────────────────────────────────────
+  // The axis identity follows the graph ChartDisplay renders as `chart-0`
+  // (picked by x mode, like `bestHwTypes` below), so an x-mode switch that
+  // swaps the rendered chart or its x units clears the rulers the same way
+  // the chart's own `usePerfRulerAxisReset` does for local state.
+  const perfRulerStore = usePerfRulerStoreValue(
+    PERSISTED_PERF_RULER_CHART_ID,
+    getUrlParam('i_rulers'),
+    persistedPerfRulerAxisKey(graphs, selectedXAxisMode, selectedYAxisMetric),
+  );
+  const iRulersStr = useMemo(
+    () => serializePerfRulers(perfRulerStore.state),
+    [perfRulerStore.state],
+  );
+
   // ── Toggle sets ───────────────────────────────────────────────────────────
 
   const {
@@ -1603,6 +1634,8 @@ export function InferenceProvider({
       i_disagg: quickFilterDeployment.join(','),
       i_spec: quickFilterSpec.join(','),
       i_power: quickFilterPower.join(','),
+      i_rulers: iRulersStr,
+      i_pcompare: powerCompare === 'none' ? '' : powerCompare,
     },
     [
       selectedYAxisMetric,
@@ -1634,6 +1667,8 @@ export function InferenceProvider({
       quickFilterDeployment,
       quickFilterSpec,
       quickFilterPower,
+      iRulersStr,
+      powerCompare,
     ],
   );
 
@@ -1849,6 +1884,7 @@ export function InferenceProvider({
       selectedE2eXAxisMetric,
       selectedXAxisMode,
       scaleType,
+      powerCompare,
       isLegendExpanded,
       hideNonOptimal,
       showAllMeasurements,
@@ -1874,6 +1910,7 @@ export function InferenceProvider({
       selectedE2eXAxisMetric,
       selectedXAxisMode,
       scaleType,
+      powerCompare,
       isLegendExpanded,
       hideNonOptimal,
       showAllMeasurements,
@@ -1908,6 +1945,7 @@ export function InferenceProvider({
     setSelectedXAxisMetric,
     setSelectedXAxisMode: handleSetXAxisMode,
     setScaleType,
+    setPowerCompare,
     setQuickFilterVendors,
     setQuickFilterFrameworks,
     setQuickFilterDeployment,
@@ -1944,7 +1982,9 @@ export function InferenceProvider({
         display={displayValue}
         actions={actionsValue}
       >
-        {children}
+        <PerfRulerStoreContext.Provider value={perfRulerStore}>
+          {children}
+        </PerfRulerStoreContext.Provider>
       </InferenceContextsProvider>
       <EngineComparisonConflictToast
         detail={engineGuardLifted ? null : engineConflict}
diff --git a/packages/app/src/components/inference/axis-metric-explanations.ts b/packages/app/src/components/inference/axis-metric-explanations.ts
index 220703207..5ce643e70 100644
--- a/packages/app/src/components/inference/axis-metric-explanations.ts
+++ b/packages/app/src/components/inference/axis-metric-explanations.ts
@@ -431,6 +431,116 @@ export const METRIC_EXPLANATIONS: Record<MetricKey, MetricExplanation> = {
       zh: '% TDP = 每芯片实测平均功耗（W）÷ 额定 TDP（W）× 100',
     },
   },
+  measuredPowerTimeline: {
+    description: {
+      en:
+        `The per-second accelerator power samples behind each measured average, drawn over ` +
+        `the whole benchmark job (server start, warmup, and the validated measurement window, ` +
+        `which is emphasized). One trace per config, mean of its GPUs by default; the rated TDP ` +
+        `is a dashed reference per hardware. Configs whose telemetry artifact is missing are ` +
+        `listed under the chart rather than estimated.${MEASURED_TIER_NOTE_EN}`,
+      zh:
+        `每个实测平均值背后的逐秒加速器功耗采样，覆盖整个基准测试任务（服务启动、warmup ` +
+        `以及被突出显示的有效测量窗口）。每个配置一条曲线，默认取其 GPU 的平均值；` +
+        `每种硬件的额定 TDP 以虚线作为参考。缺少遥测产物的配置会列在图表下方，而不会用估算值代替。${
+          MEASURED_TIER_NOTE_ZH
+        }`,
+    },
+    formula: {
+      en: 'W(t) = mean over GPUs of the sampled power draw in each one-second bucket',
+      zh: 'W(t) = 每个一秒时间桶内各 GPU 功耗采样值的平均',
+    },
+  },
+  gpuProvisionedWatts: {
+    description: {
+      en:
+        'Rated accelerator TDP from the hardware registry, shown as a flat per-chip value so ' +
+        'measured power can be read against the GPU-only provisioning boundary. It does not ' +
+        'depend on the run.',
+      zh:
+        '取硬件注册表中的加速器额定 TDP，以每芯片恒定值显示，用于对照 GPU 侧的额定供电边界与实测功耗。' +
+        '该值与具体运行无关。',
+    },
+    formula: {
+      en: 'W/GPU = rated TDP (W)',
+      zh: 'W/GPU = 额定 TDP（W）',
+    },
+  },
+  gpuProvisionedJPerOutputToken: {
+    description: {
+      en:
+        'Energy per output token if every allocated accelerator drew exactly its rated TDP for ' +
+        'the whole run. Disaggregated deployments count prefill and decode GPUs together, so ' +
+        'this is the GPU-only provisioning boundary the measured J/token can be compared against.',
+      zh:
+        '假设所有已分配加速器在整个运行中恒以额定 TDP 耗电时的每输出 token 能耗。' +
+        '分离式部署将 prefill 与 decode GPU 一并计入，因此它是可与实测 J/token 对照的 GPU 侧额定边界。',
+    },
+    formula: {
+      en: 'J/tok = rated TDP (W) × allocated GPUs ÷ total output tokens per second',
+      zh: 'J/tok = 额定 TDP（W）× 已分配 GPU 数 ÷ 总输出 token 吞吐（tok/s）',
+    },
+  },
+  utilityProvisionedWatts: {
+    description: {
+      en:
+        'All-in provisioned power per chip from the hardware registry: the utility-side capacity ' +
+        'a data center reserves for one accelerator including host, networking, cooling and ' +
+        'power-conversion overheads. It is a flat value independent of the run.',
+      zh:
+        '取硬件注册表中的每芯片全电源配置功耗：数据中心为单张加速器预留的电源侧容量，' +
+        '包含主机、网络、散热与电源转换开销。该值为恒定值，与运行无关。',
+    },
+    formula: {
+      en: 'W/GPU = all-in provisioned power per GPU (kW) × 1000',
+      zh: 'W/GPU = 每 GPU 全电源配置功耗（kW）× 1000',
+    },
+  },
+  utilityProvisionedJPerOutputToken: {
+    description: {
+      en:
+        'Energy per output token at the all-in provisioned power boundary, normalized by every ' +
+        'allocated accelerator. It differs from the public All-in Provisioned J per Output Token ' +
+        'metric only for disaggregated runs, where that metric normalizes by decode GPUs alone.',
+      zh:
+        '在全电源配置边界下的每输出 token 能耗，按全部已分配加速器归一。' +
+        '仅在分离式运行中与公开的 All-in Provisioned J per Output Token 指标不同，后者只按 decode GPU 归一。',
+    },
+    formula: {
+      en: 'J/tok = all-in provisioned power per GPU (W) × allocated GPUs ÷ total output tokens per second',
+      zh: 'J/tok = 每 GPU 全电源配置功耗（W）× 已分配 GPU 数 ÷ 总输出 token 吞吐（tok/s）',
+    },
+  },
+  utilityModeledWatts: {
+    description: {
+      en:
+        'Modeled facility power per allocated accelerator: measured GPU power is scaled to chassis ' +
+        'AC by the system power model and then multiplied once by PUE. Only hardware with a known ' +
+        'eight-GPU chassis profile on 8k1k runs is supported; NVL72 systems show no value.',
+      zh:
+        '每已分配加速器的数据中心建模功耗：先由系统功耗模型将 GPU 实测功耗换算为机箱交流功耗，再乘以一次 PUE。' +
+        '仅支持在 8k1k 运行中具有已知八卡机箱模型的硬件；NVL72 系统不显示数值。',
+    },
+    formula: {
+      en: 'W/GPU = modeled chassis AC power (W) × PUE ÷ allocated GPUs',
+      zh: 'W/GPU = 机箱交流建模功耗（W）× PUE ÷ 已分配 GPU 数',
+    },
+  },
+  utilityModeledJPerOutputToken: {
+    description: {
+      en:
+        'Measured energy per output token scaled to the modeled facility boundary, so its ratio to ' +
+        'measured GPU energy equals the ratio of modeled facility power to measured GPU power. ' +
+        'Missing where the system power model or validated measured power is unavailable.',
+      zh:
+        '将实测每输出 token 能耗按建模的数据中心边界缩放，其与 GPU 实测能耗之比等于数据中心建模功耗与 GPU 实测功耗之比。' +
+        '系统功耗模型或通过验证的实测功耗缺失时不显示。',
+    },
+    formula: {
+      en: 'J/tok = measured J per output token × modeled facility W per GPU ÷ measured W per GPU',
+      zh: 'J/tok = 实测每输出 token 能耗 × 每 GPU 数据中心建模功耗（W）÷ 每 GPU 实测功耗（W）',
+    },
+  },
 };
 
 /**
diff --git a/packages/app/src/components/inference/hooks/useChartData.ts b/packages/app/src/components/inference/hooks/useChartData.ts
index 9f6498b5a..791b14be6 100644
--- a/packages/app/src/components/inference/hooks/useChartData.ts
+++ b/packages/app/src/components/inference/hooks/useChartData.ts
@@ -27,12 +27,14 @@ import type {
   ChartDefinition,
   HardwareConfig,
   InferenceData,
+  PowerCompare,
   RenderableGraph,
   TokenRevenuePriceSource,
   TokenRevenuePricing,
   YAxisMetricKey,
 } from '@/components/inference/types';
 import { partitionChartDataByLimits } from '@/components/inference/utils';
+import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
 import { parseComparisonEntry } from '@/components/inference/utils/comparisonEntry';
 import {
   computeAvailableQuickFilters,
@@ -116,6 +118,8 @@ export function useChartData(
   tcoBasis: TcoBasis = DEFAULT_TCO_BASIS,
   /** Opt-in from the inference page only; explicit date/run/history views opt out. */
   allowDefaultRunPreference = false,
+  /** Sibling boundary / role series appended to a gated power metric (`i_pcompare`). */
+  powerCompare: PowerCompare = 'none',
 ) {
   // When the selected date is the latest available, use '' (empty string) to match
   // the initial no-date query key, reusing the eagerly-fetched benchmarks from the
@@ -538,8 +542,14 @@ export function useChartData(
         );
         const hasMetric = metricData.length > 0;
         const isTtftX = typeof xAxisField === 'string' && xAxisField.endsWith('_ttft');
+        // Comparison clones are appended after the remap so they share the
+        // base point's x and differ only in y and `powerVariant`.
         const mappedData = hasMetric
-          ? metricData.map((d) => remapInferencePoint(d, metricKey, xAxisField))
+          ? expandPowerCompareSeries(
+              metricData.map((d) => remapInferencePoint(d, metricKey, xAxisField)),
+              selectedYAxisMetric,
+              powerCompare,
+            )
           : [];
 
         const isAgentic = selectedSequence === Sequence.AgenticTraces;
@@ -576,6 +586,7 @@ export function useChartData(
     compareGpuPair,
     selectedPercentile,
     quickFilters,
+    powerCompare,
   ]);
 
   // Points that pass every scope filter but NOT the y-metric coverage filter.
diff --git a/packages/app/src/components/inference/measured-metric-config.test.ts b/packages/app/src/components/inference/measured-metric-config.test.ts
index 47c356f22..41276d400 100644
--- a/packages/app/src/components/inference/measured-metric-config.test.ts
+++ b/packages/app/src/components/inference/measured-metric-config.test.ts
@@ -1,6 +1,10 @@
 import { describe, expect, it } from 'vitest';
 
-import { MEASURED_ENERGY_METRIC_CONFIG_KEYS, METRIC_CONFIG_KEYS } from './metric-registry';
+import {
+  MEASURED_ENERGY_METRIC_CONFIG_KEYS,
+  METRIC_CONFIG_KEYS,
+  POWER_BASIS_METRIC_CONFIG_KEYS,
+} from './metric-registry';
 import {
   changeMeasuredMetricConfig,
   getMeasuredMetricConfig,
@@ -8,20 +12,27 @@ import {
 } from './measured-metric-config';
 
 describe('measured metric configuration', () => {
-  it.each(MEASURED_ENERGY_METRIC_CONFIG_KEYS)(
-    'round-trips the existing share-link metric %s',
-    (key) => {
-      const config = getMeasuredMetricConfig(key);
-      expect(config).toBeDefined();
-      expect(changeMeasuredMetricConfig(key, {})).toBe(key);
-      expect(changeMeasuredMetricConfig('y_tpPerGpu', config!)).toBe(key);
-    },
-  );
+  it.each([
+    'y_measuredAvgPower',
+    'y_measuredPowerTimeline',
+    'y_measuredJPerOutputToken',
+    'y_measuredWhPerSuccessfulQuery',
+  ] as const)('round-trips the existing share-link metric %s', (key) => {
+    const config = getMeasuredMetricConfig(key);
+    expect(config).toBeDefined();
+    expect(changeMeasuredMetricConfig(key, {})).toBe(key);
+    expect(changeMeasuredMetricConfig('y_tpPerGpu', config!)).toBe(key);
+  });
 
   it('does not group unrelated metrics or unknown persisted values', () => {
     const grouped = METRIC_CONFIG_KEYS.filter((key) => getMeasuredMetricConfig(key));
-    expect(grouped).toHaveLength(13);
-    expect(new Set(grouped)).toEqual(new Set(MEASURED_ENERGY_METRIC_CONFIG_KEYS));
+    expect(grouped).toHaveLength(20);
+    expect(new Set(grouped)).toEqual(
+      new Set([...MEASURED_ENERGY_METRIC_CONFIG_KEYS, ...POWER_BASIS_METRIC_CONFIG_KEYS]),
+    );
+    for (const key of MEASURED_ENERGY_METRIC_CONFIG_KEYS) {
+      expect(getMeasuredMetricConfig(key)?.basis, key).toBe('gpu-measured');
+    }
     expect(getMeasuredMetricConfig('y_modeledChassisPowerPerGpu')).toBeUndefined();
     expect(getMeasuredMetricConfig('y_removedMetric')).toBeUndefined();
     expect(getMeasuredMetricConfig('')).toBeUndefined();
@@ -42,6 +53,7 @@ describe('measured metric configuration', () => {
   it('keeps fleet percentiles, role averages and TDP normalization distinct', () => {
     expect(getMeasuredMetricConfig('y_measuredP90Power')).toEqual({
       family: 'power',
+      basis: 'gpu-measured',
       scope: 'all',
       statistic: 'p90',
       display: 'watts',
@@ -78,6 +90,7 @@ describe('measured metric configuration', () => {
     );
     expect(getMeasuredMetricConfig('y_measuredPrefillJPerInputToken')).toEqual({
       family: 'energy',
+      basis: 'gpu-measured',
       scope: 'prefill',
       denominator: 'input',
       unit: 'joules',
diff --git a/packages/app/src/components/inference/measured-metric-config.ts b/packages/app/src/components/inference/measured-metric-config.ts
index 555fbef2e..ff28546be 100644
--- a/packages/app/src/components/inference/measured-metric-config.ts
+++ b/packages/app/src/components/inference/measured-metric-config.ts
@@ -1,17 +1,27 @@
+import type { PowerBasis } from '@/lib/power-basis';
 import type { MetricConfigKey } from './metric-registry';
 
 export type MeasuredMetricFamily = 'power' | 'energy';
 type MeasuredScope = 'all' | 'prefill' | 'decode';
+/**
+ * How whole-deployment average power is shown: per-chip watts, percent of
+ * TDP, or the per-second telemetry trace behind the average (`timeline`, which
+ * ChartDisplay renders with `PowerTimeline` instead of the scatter chart).
+ */
+export type MeasuredPowerDisplay = 'watts' | 'tdp' | 'timeline';
 
 export type MeasuredMetricConfig =
   | {
       family: 'power';
+      /** Power boundary the key plots; only `gpu-measured` publishes the other dimensions. */
+      basis: PowerBasis;
       scope: MeasuredScope;
       statistic: 'average' | 'p75' | 'p90';
-      display: 'watts' | 'tdp';
+      display: MeasuredPowerDisplay;
     }
   | {
       family: 'energy';
+      basis: PowerBasis;
       scope: MeasuredScope;
       denominator: 'input' | 'output' | 'total' | 'query';
       unit: 'joules' | 'wattHours';
@@ -19,9 +29,10 @@ export type MeasuredMetricConfig =
 
 export type MeasuredMetricConfigChange = Partial<{
   family: MeasuredMetricFamily;
+  basis: PowerBasis;
   scope: MeasuredScope;
   statistic: 'average' | 'p75' | 'p90';
-  display: 'watts' | 'tdp';
+  display: MeasuredPowerDisplay;
   denominator: 'input' | 'output' | 'total' | 'query';
   unit: 'joules' | 'wattHours';
 }>;
@@ -31,51 +42,78 @@ export const MEASURED_METRIC_DEFAULTS = {
   energy: 'y_measuredJPerOutputToken',
 } as const satisfies Record<MeasuredMetricFamily, MetricConfigKey>;
 
+const measured = { basis: 'gpu-measured' } as const;
+
 // Presentation settings resolve to existing metrics; they do not own chart state.
 const MEASURED_METRIC_CONFIGS: readonly (readonly [MetricConfigKey, MeasuredMetricConfig])[] = [
-  ['y_measuredAvgPower', { family: 'power', scope: 'all', statistic: 'average', display: 'watts' }],
-  ['y_measuredP75Power', { family: 'power', scope: 'all', statistic: 'p75', display: 'watts' }],
-  ['y_measuredP90Power', { family: 'power', scope: 'all', statistic: 'p90', display: 'watts' }],
+  [
+    'y_measuredAvgPower',
+    { family: 'power', ...measured, scope: 'all', statistic: 'average', display: 'watts' },
+  ],
+  [
+    'y_measuredP75Power',
+    { family: 'power', ...measured, scope: 'all', statistic: 'p75', display: 'watts' },
+  ],
+  [
+    'y_measuredP90Power',
+    { family: 'power', ...measured, scope: 'all', statistic: 'p90', display: 'watts' },
+  ],
   [
     'y_measuredPrefillAvgPower',
-    { family: 'power', scope: 'prefill', statistic: 'average', display: 'watts' },
+    { family: 'power', ...measured, scope: 'prefill', statistic: 'average', display: 'watts' },
   ],
   [
     'y_measuredDecodeAvgPower',
-    { family: 'power', scope: 'decode', statistic: 'average', display: 'watts' },
+    { family: 'power', ...measured, scope: 'decode', statistic: 'average', display: 'watts' },
   ],
   [
     'y_measuredPowerPercentTdp',
-    { family: 'power', scope: 'all', statistic: 'average', display: 'tdp' },
+    { family: 'power', ...measured, scope: 'all', statistic: 'average', display: 'tdp' },
+  ],
+  [
+    'y_measuredPowerTimeline',
+    { family: 'power', ...measured, scope: 'all', statistic: 'average', display: 'timeline' },
   ],
   [
     'y_measuredJPerInputToken',
-    { family: 'energy', scope: 'all', denominator: 'input', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'all', denominator: 'input', unit: 'joules' },
   ],
   [
     'y_measuredJPerOutputToken',
-    { family: 'energy', scope: 'all', denominator: 'output', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'all', denominator: 'output', unit: 'joules' },
   ],
   [
     'y_measuredJPerTotalToken',
-    { family: 'energy', scope: 'all', denominator: 'total', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'all', denominator: 'total', unit: 'joules' },
   ],
   [
     'y_measuredPrefillJPerInputToken',
-    { family: 'energy', scope: 'prefill', denominator: 'input', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'prefill', denominator: 'input', unit: 'joules' },
   ],
   [
     'y_measuredDecodeJPerOutputToken',
-    { family: 'energy', scope: 'decode', denominator: 'output', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'decode', denominator: 'output', unit: 'joules' },
   ],
   [
     'y_measuredJPerSuccessfulQuery',
-    { family: 'energy', scope: 'all', denominator: 'query', unit: 'joules' },
+    { family: 'energy', ...measured, scope: 'all', denominator: 'query', unit: 'joules' },
   ],
   [
     'y_measuredWhPerSuccessfulQuery',
-    { family: 'energy', scope: 'all', denominator: 'query', unit: 'wattHours' },
+    { family: 'energy', ...measured, scope: 'all', denominator: 'query', unit: 'wattHours' },
   ],
+  // Derived boundaries publish one canonical combination per family: whole
+  // deployment, average watts, joules per output token (lib/power-basis.ts).
+  ...(
+    [
+      ['gpu-provisioned', 'y_gpuProvisionedWatts', 'y_gpuProvisionedJPerOutputToken'],
+      ['utility-provisioned', 'y_utilityProvisionedWatts', 'y_utilityProvisionedJPerOutputToken'],
+      ['utility-modeled', 'y_utilityModeledWatts', 'y_utilityModeledJPerOutputToken'],
+    ] as const satisfies readonly (readonly [PowerBasis, MetricConfigKey, MetricConfigKey])[]
+  ).flatMap(([basis, watts, energy]): (readonly [MetricConfigKey, MeasuredMetricConfig])[] => [
+    [watts, { family: 'power', basis, scope: 'all', statistic: 'average', display: 'watts' }],
+    [energy, { family: 'energy', basis, scope: 'all', denominator: 'output', unit: 'joules' }],
+  ]),
 ];
 
 export function getMeasuredMetricConfig(metric: string): MeasuredMetricConfig | undefined {
@@ -83,6 +121,8 @@ export function getMeasuredMetricConfig(metric: string): MeasuredMetricConfig |
   return config ? { ...config } : undefined;
 }
 
+const OTHER_DIMENSIONS = ['scope', 'statistic', 'display', 'denominator', 'unit'] as const;
+
 export function changeMeasuredMetricConfig(
   metric: string,
   change: MeasuredMetricConfigChange,
@@ -93,6 +133,21 @@ export function changeMeasuredMetricConfig(
     current?.family === family
       ? current
       : getMeasuredMetricConfig(MEASURED_METRIC_DEFAULTS[family])!;
+  // Choosing a derived boundary snaps the other dimensions to its canonical
+  // combination. Changing any of those dimensions while on a derived boundary
+  // returns to GPU-measured telemetry, the only basis that publishes variants,
+  // so every control change lands on a real key. A family switch keeps the
+  // boundary: the metric key is what carries it.
+  const changesOtherDimension = OTHER_DIMENSIONS.some((key) => change[key] !== undefined);
+  const basis =
+    change.basis ?? (changesOtherDimension ? 'gpu-measured' : (current ?? config).basis);
+  if (basis !== 'gpu-measured') {
+    return (
+      MEASURED_METRIC_CONFIGS.find(
+        ([, candidate]) => candidate.family === family && candidate.basis === basis,
+      )?.[0] ?? MEASURED_METRIC_DEFAULTS[family]
+    );
+  }
   let scope = change.scope ?? config.scope;
 
   if (config.family === 'power') {
@@ -103,6 +158,7 @@ export function changeMeasuredMetricConfig(
       MEASURED_METRIC_CONFIGS.find(
         ([, candidate]) =>
           candidate.family === 'power' &&
+          candidate.basis === 'gpu-measured' &&
           candidate.scope === scope &&
           candidate.statistic === statistic &&
           candidate.display === display,
@@ -123,6 +179,7 @@ export function changeMeasuredMetricConfig(
     MEASURED_METRIC_CONFIGS.find(
       ([, candidate]) =>
         candidate.family === 'energy' &&
+        candidate.basis === 'gpu-measured' &&
         candidate.scope === scope &&
         candidate.denominator === denominator &&
         candidate.unit === unit,
diff --git a/packages/app/src/components/inference/metric-registry.test.ts b/packages/app/src/components/inference/metric-registry.test.ts
index 28045728e..db4011826 100644
--- a/packages/app/src/components/inference/metric-registry.test.ts
+++ b/packages/app/src/components/inference/metric-registry.test.ts
@@ -19,6 +19,7 @@ import {
   metricCostTier,
   metricForCostTier,
   metricOptionTitle,
+  POWER_BASIS_METRIC_CONFIG_KEYS,
   resolveMetricConfigKey,
   tokenMetricTypeForConfigKey,
 } from './metric-registry';
@@ -39,6 +40,10 @@ describe('metric registry', () => {
     expect(e2e.y_costh_roofline).toBe('lower_left');
     expect(interactivity.y_measuredPowerPercentTdp_roofline).toBe('lower_right');
     expect(e2e.y_measuredPowerPercentTdp_roofline).toBe('lower_left');
+    for (const key of POWER_BASIS_METRIC_CONFIG_KEYS) {
+      expect(interactivity[`${key}_roofline`], key).toBe('lower_right');
+      expect(e2e[`${key}_roofline`], key).toBe('lower_left');
+    }
   });
 
   it('preserves metric-specific x overrides and bilingual labels', () => {
@@ -210,7 +215,11 @@ describe('metric registry', () => {
     );
 
     const measuredGroup = METRIC_CONTROL_GROUPS.find((group) => group.label === 'Measured Energy');
-    expect(measuredGroup?.metrics).toBe(MEASURED_ENERGY_METRIC_CONFIG_KEYS);
+    expect(measuredGroup?.gated).toBe(true);
+    expect(measuredGroup?.metrics).toEqual([
+      ...MEASURED_ENERGY_METRIC_CONFIG_KEYS,
+      ...POWER_BASIS_METRIC_CONFIG_KEYS,
+    ]);
   });
 
   it('classifies measured-energy config keys', () => {
diff --git a/packages/app/src/components/inference/metric-registry.ts b/packages/app/src/components/inference/metric-registry.ts
index ccba918b1..9687c561d 100644
--- a/packages/app/src/components/inference/metric-registry.ts
+++ b/packages/app/src/components/inference/metric-registry.ts
@@ -386,6 +386,80 @@ export const METRIC_REGISTRY = {
     titleZh: '实测平均功耗占 TDP 百分比',
     polarity: 'lower',
   },
+  // The per-second telemetry behind `measuredAvgPower`. The field aliases the
+  // same average so the table view, availability panel, and share links keep
+  // working; ChartDisplay swaps the scatter chart for `PowerTimeline`, which
+  // fetches each point's `gpu_metrics_*` artifact and draws the trace. The
+  // label leads with "Measured Average Power", like the %TDP display, so a
+  // "Measured Power" search still finds only the family option.
+  measuredPowerTimeline: {
+    field: 'measuredPowerTimeline.y',
+    label: 'Measured Average Power per Chip over Time (W)',
+    labelZh: '每芯片实测平均功耗时间线（W）',
+    title: 'Measured Average Power per Chip over Time',
+    titleZh: '每芯片实测平均功耗时间线',
+    polarity: 'lower',
+  },
+  // Power boundaries beyond GPU-measured telemetry (`lib/power-basis.ts`).
+  // Each boundary publishes W per allocated GPU and J per output token; the
+  // Boundary select in the Measured controls resolves to these keys, so the
+  // metric key alone carries the boundary in share links. Keys deliberately
+  // lack the `measured` prefix: they are spec constants or model output, not
+  // telemetry, so the telemetry-only decorations must not treat them as such.
+  gpuProvisionedWatts: {
+    field: 'gpuProvisionedWatts.y',
+    label: 'GPU Provisioned Power per Chip (TDP, W)',
+    labelZh: '每芯片 GPU 额定功耗（TDP，W）',
+    title: 'GPU Provisioned Power per Chip (TDP)',
+    titleZh: '每芯片 GPU 额定功耗（TDP）',
+    polarity: 'lower',
+  },
+  gpuProvisionedJPerOutputToken: {
+    field: 'gpuProvisionedJPerOutputToken.y',
+    label: 'GPU Provisioned J per Output Token (TDP, J/tok)',
+    labelZh: '每输出 token GPU 额定能耗（TDP，J/tok）',
+    title: 'GPU Provisioned Joules per Output Token (TDP)',
+    titleZh: '每输出 token GPU 额定焦耳能耗（TDP）',
+    polarity: 'lower',
+  },
+  utilityProvisionedWatts: {
+    field: 'utilityProvisionedWatts.y',
+    label: 'Utility Provisioned Power per Chip (all-in, W)',
+    labelZh: '每芯片全电源配置功耗（all-in，W）',
+    title: 'Utility Provisioned Power per Chip (all-in)',
+    titleZh: '每芯片全电源配置功耗（all-in）',
+    polarity: 'lower',
+  },
+  // Unlike the ungated `jOutput`, which divides by output tokens per decode
+  // GPU, this normalizes by every allocated GPU (prefill + decode).
+  utilityProvisionedJPerOutputToken: {
+    field: 'utilityProvisionedJPerOutputToken.y',
+    label: 'Utility Provisioned J per Output Token, all GPUs (all-in, J/tok)',
+    labelZh: '每输出 token 全电源配置能耗，按全部 GPU 归一（all-in，J/tok）',
+    title: 'Utility Provisioned Joules per Output Token, all GPUs (all-in)',
+    titleZh: '每输出 token 全电源配置焦耳能耗，按全部 GPU 归一（all-in）',
+    polarity: 'lower',
+  },
+  // zh vocabulary shared with the Boundary select, its help text and the chart
+  // caption: B3 “全电源配置” (as the ungated jOutput/jTotal already say for
+  // all-in), B4 “数据中心建模” (measured GPU power carried through the chassis
+  // model to the utility meter).
+  utilityModeledWatts: {
+    field: 'utilityModeledWatts.y',
+    label: 'Utility Modeled Power per Chip (PUE, W)',
+    labelZh: '每芯片数据中心建模功耗（含 PUE，W）',
+    title: 'Utility Modeled Power per Chip (PUE)',
+    titleZh: '每芯片数据中心建模功耗（含 PUE）',
+    polarity: 'lower',
+  },
+  utilityModeledJPerOutputToken: {
+    field: 'utilityModeledJPerOutputToken.y',
+    label: 'Utility Modeled J per Output Token (PUE, J/tok)',
+    labelZh: '每输出 token 数据中心建模能耗（含 PUE，J/tok）',
+    title: 'Utility Modeled Joules per Output Token (PUE)',
+    titleZh: '每输出 token 数据中心建模焦耳能耗（含 PUE）',
+    polarity: 'lower',
+  },
 } as const satisfies Record<string, MetricDefinition>;
 
 export type MetricKey = keyof typeof METRIC_REGISTRY;
@@ -597,6 +671,7 @@ export const MEASURED_ENERGY_METRIC_CONFIG_KEYS = [
   'y_measuredJPerSuccessfulQuery',
   'y_measuredWhPerSuccessfulQuery',
   'y_measuredPowerPercentTdp',
+  'y_measuredPowerTimeline',
 ] as const satisfies readonly MetricConfigKey[];
 
 const MEASURED_ENERGY_METRIC_CONFIG_KEY_SET: ReadonlySet<string> = new Set(
@@ -618,6 +693,31 @@ export function isRoleLocalMeasuredEnergyConfigKey(configKey: string): boolean {
   return ROLE_LOCAL_MEASURED_ENERGY_METRIC_CONFIG_KEY_SET.has(configKey);
 }
 
+/**
+ * The derived power-boundary y-axes (GPU provisioned, utility provisioned,
+ * utility modeled) that share the gated Measured Energy group and its
+ * Boundary select. They are kept out of `MEASURED_ENERGY_METRIC_CONFIG_KEYS`
+ * on purpose: spec constants and model output carry no telemetry tier, so the
+ * legacy-power ring, tier tooltip line, and footer key do not apply to them.
+ */
+export const POWER_BASIS_METRIC_CONFIG_KEYS = [
+  'y_gpuProvisionedWatts',
+  'y_gpuProvisionedJPerOutputToken',
+  'y_utilityProvisionedWatts',
+  'y_utilityProvisionedJPerOutputToken',
+  'y_utilityModeledWatts',
+  'y_utilityModeledJPerOutputToken',
+] as const satisfies readonly MetricConfigKey[];
+
+const POWER_BASIS_METRIC_CONFIG_KEY_SET: ReadonlySet<string> = new Set(
+  POWER_BASIS_METRIC_CONFIG_KEYS,
+);
+
+/** Whether a y-axis config key plots a derived power boundary (B2–B4). */
+export function isPowerBasisConfigKey(configKey: string): boolean {
+  return POWER_BASIS_METRIC_CONFIG_KEY_SET.has(configKey);
+}
+
 export const MODELED_SYSTEM_POWER_METRIC_CONFIG_KEY = 'y_modeledChassisPowerPerGpu';
 
 /** Whether a y-axis config key plots the modeled chassis AC power metric. */
@@ -671,10 +771,13 @@ export const METRIC_CONTROL_GROUPS: readonly MetricControlGroup[] = [
   // Runner power telemetry and the chassis model built on it are still being
   // validated, so both groups stay behind the ↑↑↓↓ feature gate until the
   // measurements are stable enough to publish.
+  // The derived boundaries ride along so the same gate and the same
+  // shared-URL exception (a gated metric selected by `i_metric` still renders
+  // while locked) apply to them.
   {
     label: 'Measured Energy',
     labelZh: '实测能耗',
-    metrics: MEASURED_ENERGY_METRIC_CONFIG_KEYS,
+    metrics: [...MEASURED_ENERGY_METRIC_CONFIG_KEYS, ...POWER_BASIS_METRIC_CONFIG_KEYS],
     gated: true,
   },
   {
diff --git a/packages/app/src/components/inference/types.ts b/packages/app/src/components/inference/types.ts
index c9f9e6c96..cebfb7336 100644
--- a/packages/app/src/components/inference/types.ts
+++ b/packages/app/src/components/inference/types.ts
@@ -6,6 +6,7 @@ import type { Model, Sequence } from '@/lib/data-mappings';
 import type { PowerTier } from '@/lib/power-tier';
 import type { SystemPowerEstimate } from '@/lib/modeled-system-power';
 import type { MetricKey } from './metric-registry';
+import type { PowerBasis } from '@/lib/power-basis';
 
 export type { WorkerPower };
 
@@ -347,8 +348,67 @@ export interface InferenceData extends Partial<Omit<AggDataEntry, AggDataConflic
   measuredJPerSuccessfulQuery?: { y: number; roof: boolean };
   measuredWhPerSuccessfulQuery?: { y: number; roof: boolean };
   measuredPowerPercentTdp?: { y: number; roof: boolean };
+  /** Alias of `measuredAvgPower` selecting the per-second telemetry timeline view. */
+  measuredPowerTimeline?: { y: number; roof: boolean };
+  /**
+   * Prefill pool energy per OUTPUT token for disaggregated rows:
+   * `prefill_joules_per_input_token` × (J/out ÷ J/in), i.e. carried onto the
+   * output-token axis by the served input:output ratio so it adds to
+   * `measuredDecodeJPerOutputToken` (utils/role-energy.ts, PowerX Figure 7).
+   */
+  reconstructedPrefillJPerOutputToken?: { y: number; roof: boolean };
+  /**
+   * Set on the clones a power comparison (`i_pcompare`) appends to the chart:
+   * which boundary or worker role this point's `y` came from. Base points of
+   * the selected metric never carry it (utils/power-compare.ts).
+   */
+  powerVariant?: PowerVariant;
+
+  // Power boundaries beyond the GPU-measured telemetry above (B1). Each pair is
+  // W per allocated GPU plus J per successful output token, normalized by every
+  // allocated GPU (prefill + decode for disaggregation). Emitted only when the
+  // value is finite and positive; see lib/power-basis.ts and
+  // docs/data-transforms.md "Power boundaries".
+  /** B2 W/GPU: HW_REGISTRY tdp. */
+  gpuProvisionedWatts?: { y: number; roof: boolean };
+  /** B2 J/out: tdp × N_alloc ÷ total output tok/s. */
+  gpuProvisionedJPerOutputToken?: { y: number; roof: boolean };
+  /** B3 W/GPU: HW_REGISTRY all-in power (kW × 1000). */
+  utilityProvisionedWatts?: { y: number; roof: boolean };
+  /**
+   * B3 J/out: all-in W × N_alloc ÷ total output tok/s. Unlike `jOutput`, which
+   * divides one decode GPU's all-in W by that GPU's output, this counts every
+   * allocated GPU, so it is (P + D) / D × `jOutput` on disaggregated rows.
+   */
+  utilityProvisionedJPerOutputToken?: { y: number; roof: boolean };
+  /** B4 W/GPU: modeled deployment facility watts (chassis AC × PUE, applied once) ÷ measured GPUs. */
+  utilityModeledWatts?: { y: number; roof: boolean };
+  /** B4 J/out: B1 `joules_per_output_token` × (B4 W ÷ B1 W); inherits B1's token denominator. */
+  utilityModeledJPerOutputToken?: { y: number; roof: boolean };
 }
 
+/**
+ * Sibling series the gated power charts can overlay on the selected metric:
+ * every boundary (PowerX Figures 2/3) or every worker role (Figures 6/7).
+ * Rides on the `i_pcompare` URL parameter; `none` draws the metric alone.
+ */
+export type PowerCompare = 'none' | 'boundaries' | 'roles';
+/** Worker-pool scope of a measured figure. */
+export type PowerRole = 'all' | 'prefill' | 'decode';
+/** Identity of one comparison series: a boundary or a role. */
+export type PowerVariant = { kind: 'basis'; id: PowerBasis } | { kind: 'role'; id: PowerRole };
+
+/** InferenceData keys carrying the B2–B4 power-boundary readings. */
+export type PowerBasisFieldKey =
+  | 'gpuProvisionedWatts'
+  | 'gpuProvisionedJPerOutputToken'
+  | 'utilityProvisionedWatts'
+  | 'utilityProvisionedJPerOutputToken'
+  | 'utilityModeledWatts'
+  | 'utilityModeledJPerOutputToken';
+
+export type { PowerBasis } from '@/lib/power-basis';
+
 /** Why a chart-ready point was intentionally excluded from the visible plot. */
 export type ChartClipReason = 'cost' | 'latency';
 
@@ -654,6 +714,8 @@ export interface InferenceDisplayContextType {
   selectedE2eXAxisMetric: string | null;
   selectedXAxisMode: 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity';
   scaleType: 'auto' | 'linear' | 'log';
+  /** Comparison series overlaid on a gated power metric (`i_pcompare`). */
+  powerCompare: PowerCompare;
   isLegendExpanded: boolean;
   hideNonOptimal: boolean;
   showAllMeasurements: boolean;
@@ -697,6 +759,7 @@ export interface InferenceActionsContextType {
     mode: 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity',
   ) => void;
   setScaleType: (type: 'auto' | 'linear' | 'log') => void;
+  setPowerCompare: (mode: PowerCompare) => void;
   setQuickFilterVendors: (vendors: string[]) => void;
   setQuickFilterFrameworks: (frameworks: string[]) => void;
   setQuickFilterDeployment: (modes: DeploymentMode[]) => void;
diff --git a/packages/app/src/components/inference/ui/ChartControls.tsx b/packages/app/src/components/inference/ui/ChartControls.tsx
index 203275706..726a6918c 100644
--- a/packages/app/src/components/inference/ui/ChartControls.tsx
+++ b/packages/app/src/components/inference/ui/ChartControls.tsx
@@ -61,6 +61,7 @@ import { MetricExplanation } from './MetricExplanation';
 import { PowerMetricAvailability } from './PowerMetricAvailability';
 import { MeasuredMetricControls } from './MeasuredMetricControls';
 import {
+  changeMeasuredMetricConfig,
   getMeasuredMetricConfig,
   MEASURED_METRIC_DEFAULTS,
   type MeasuredMetricFamily,
@@ -230,6 +231,7 @@ export default function ChartControls({
     selectedXAxisMetric,
     selectedXAxisMode,
     scaleType,
+    powerCompare,
   } = useInferenceDisplay();
   const {
     setSelectedModel,
@@ -242,6 +244,7 @@ export default function ChartControls({
     setSelectedDateRange,
     setSelectedXAxisMetric,
     setScaleType,
+    setPowerCompare,
   } = useInferenceActions();
 
   // Y-axis options come from the canonical registry and need no API data.
@@ -335,10 +338,14 @@ export default function ChartControls({
         if (!config) return [option];
         if (seen.has(config.family)) return [];
         seen.add(config.family);
+        // Keep the selected boundary (and other dimensions) when hopping between
+        // the power and energy families; fall back to the family default otherwise.
         const value =
           selectedConfig?.family === config.family
             ? selectedYAxisMetric
-            : MEASURED_METRIC_DEFAULTS[config.family];
+            : selectedConfig
+              ? changeMeasuredMetricConfig(selectedYAxisMetric, { family: config.family })
+              : MEASURED_METRIC_DEFAULTS[config.family];
         return [
           {
             value,
@@ -571,6 +578,8 @@ export default function ChartControls({
                   <MeasuredMetricControls
                     metric={selectedYAxisMetric}
                     onChange={handleYAxisMetricChange}
+                    compare={powerCompare}
+                    onCompareChange={setPowerCompare}
                   />
                   <div className="col-span-full">
                     <PowerMetricAvailability
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index f23dacd94..7bb22f900 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -14,6 +14,9 @@ import chartDefinitions, {
   type MetricKey,
 } from '@/components/inference/metric-registry';
 import { metricRowLabel } from '@/components/inference/axis-metric-explanations';
+import { getMeasuredMetricConfig } from '@/components/inference/measured-metric-config';
+import { AIR_COOLED_SYSTEM_PUE } from '@/lib/modeled-system-power';
+import { SYSTEM_POWER_MODEL_REVISION } from '@/lib/system-power-model';
 import {
   applyTokenRevenuePricing,
   cachedInputPricePerMillion,
@@ -46,6 +49,7 @@ import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
 import { bestSeriesPerSku } from '@/components/inference/utils/best-series-per-sku';
 import InferenceTable from '@/components/inference/ui/InferenceTable';
 import ScatterGraph from '@/components/inference/ui/ScatterGraph';
+import PowerTimeline from '@/components/inference/ui/PowerTimeline';
 import { Card } from '@/components/ui/card';
 import { ChartButtons } from '@/components/ui/chart-buttons';
 import { ShareButton } from '@/components/ui/share-button';
@@ -140,6 +144,17 @@ const STRINGS = {
       'No benchmark data matches the current model, scenario, and filter selection. Adjust the filters above to see results.',
     noSystemPowerData:
       'No system-power estimates are available for this selection. Choose 8K / 1K with validated GPU telemetry, supported hardware, and known eight-GPU chassis placement. Measured GPU power remains available separately where telemetry exists.',
+    noUtilityModeledData:
+      'No utility modeled values are available for this selection. The utility modeled boundary needs 8K / 1K, validated GPU telemetry, and hardware covered by the chassis power model (not NVL72 systems). Choose another boundary to keep the points.',
+    // Boundary disclosures for the derived power axes (lib/power-basis.ts).
+    // Formulas in words; constants named so a screenshot records its method.
+    powerBasisAssumptions: {
+      'gpu-provisioned':
+        'GPU provisioned boundary · Watts are the rated TDP per GPU from the hardware registry, so the power curve is flat per hardware. Joules per output token = TDP × allocated GPUs ÷ whole-deployment output tok/s; disaggregated configurations count prefill and decode GPUs together. Hardware without a published TDP is omitted.',
+      'utility-provisioned':
+        'Utility provisioned boundary · Watts are the all-in provisioned utility power per GPU from the hardware registry (SemiAnalysis Datacenter Industry Model), so the power curve is flat per hardware. Joules per output token = all-in W × allocated GPUs ÷ whole-deployment output tok/s; disaggregated configurations count prefill and decode GPUs together, unlike the ungated All-in Provisioned J per Output Token, which divides per decode GPU.',
+      'utility-modeled': `Utility modeled boundary · Measured GPU power carried through the modeled chassis (CPU, DRAM, platform, PSU losses) to the utility meter: modeled chassis AC × PUE ${AIR_COOLED_SYSTEM_PUE} (air-cooled, applied once), divided by the measured GPUs; joules per output token scale measured joules by the same ratio. Chassis power model revision ${SYSTEM_POWER_MODEL_REVISION.slice(0, 7)}. Available for 8K / 1K with validated telemetry on supported hardware only; NVL72 systems (GB200, GB300) and points without values are omitted.`,
+    },
     vsTtft: (word: string) => `vs. ${word} Time To First Token`,
     vsE2eLatency: (pctl?: string) =>
       pctl ? `vs. ${pctl} End-to-end Latency` : 'vs. End-to-end Latency',
@@ -166,6 +181,15 @@ const STRINGS = {
     noChartData: '当前模型、场景与筛选条件下没有匹配的基准测试数据。请调整上方筛选条件查看结果。',
     noSystemPowerData:
       '当前选择没有可用的系统功耗估算。请选择 8K / 1K 场景；估算仅覆盖 GPU 遥测已验证、硬件受支持、八卡机箱位置已知的运行。存在遥测数据时，仍可单独查看 GPU 实测功耗。',
+    noUtilityModeledData:
+      '当前选择没有可用的数据中心建模数值。该边界需要 8K / 1K 场景、已验证的 GPU 遥测，且硬件在机箱功耗模型覆盖范围内（不含 NVL72 系统）。可切换到其他功耗边界以保留数据点。',
+    powerBasisAssumptions: {
+      'gpu-provisioned':
+        'GPU 额定边界 · 功率取硬件注册表中每 GPU 的额定 TDP，因此每种硬件的功率曲线为水平线。每输出 token 能耗 = TDP × 分配的 GPU 数 ÷ 整个部署的输出 tok/s；分离式配置将 prefill 与 decode GPU 一并计入。未公布 TDP 的硬件不绘制。',
+      'utility-provisioned':
+        '全电源配置边界 · 功率取硬件注册表中每 GPU 的全电源配置（all-in）市电功率（来源：SemiAnalysis Datacenter Industry Model），因此每种硬件的功率曲线为水平线。每输出 token 能耗 = all-in 功率 × 分配的 GPU 数 ÷ 整个部署的输出 tok/s；分离式配置将 prefill 与 decode GPU 一并计入，这与未加门控的“每输出 token 全电源配置能耗”按 decode GPU 计算不同。',
+      'utility-modeled': `数据中心建模边界 · 将 GPU 实测功耗经机箱功耗模型（CPU、DRAM、平台开销、PSU 损耗）推算至市电侧：机箱交流功耗估算 × PUE ${AIR_COOLED_SYSTEM_PUE}（风冷，仅应用一次），再除以实测 GPU 数；每输出 token 能耗按同一比例放大实测能耗。机箱功耗模型版本 ${SYSTEM_POWER_MODEL_REVISION.slice(0, 7)}。仅适用于 8K / 1K、遥测已验证且硬件受支持的运行；NVL72 系统（GB200、GB300）及缺少数值的数据点不绘制。`,
+    },
     vsTtft: (word: string) => `vs. ${word === 'Median' ? '中位' : word} 首 token 延迟（TTFT）`,
     vsE2eLatency: (pctl?: string) => (pctl ? `vs. ${pctl} 端到端延迟` : 'vs. 端到端延迟'),
   },
@@ -291,9 +315,19 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     selectedXAxisMode,
     tokenRevenuePricing,
     showLineLabels,
+    powerCompare,
   } = useInferenceDisplay();
   const { setSelectedDates, setSelectedDatesFromRunExpansion, setIsLegendExpanded } =
     useInferenceActions();
+  // The metric key carries the power boundary; the caption discloses it for
+  // the derived boundaries (there is no separate URL param).
+  const selectedPowerBasis = getMeasuredMetricConfig(selectedYAxisMetric)?.basis;
+  // The Measured Power "Timeline" display swaps the scatter body for the
+  // per-second telemetry traces (PowerTimeline); table view and captions are
+  // unchanged because the metric key aliases the measured average.
+  const selectedMeasuredConfig = getMeasuredMetricConfig(selectedYAxisMetric);
+  const isPowerTimeline =
+    selectedMeasuredConfig?.family === 'power' && selectedMeasuredConfig.display === 'timeline';
   const selectedBenchmarkType: 'single_turn' | 'agentic_traces' =
     selectedSequence === Sequence.AgenticTraces ? 'agentic_traces' : 'single_turn';
   const workflowInfoBenchmarkType =
@@ -456,6 +490,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
           selectedPercentile,
           tcoBasis,
           selectedXAxisMode,
+          powerCompare,
         },
       );
 
@@ -505,6 +540,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     selectedXAxisMetric,
     selectedE2eXAxisMetric,
     selectedPercentile,
+    powerCompare,
     selectedXAxisMode,
     tokenRevenuePricing,
     tcoBasis,
@@ -825,7 +861,9 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
               <p className="max-w-md text-center text-sm text-muted-foreground">
                 {isModeledSystemPowerConfigKey(selectedYAxisMetric)
                   ? t.noSystemPowerData
-                  : t.noChartData}
+                  : selectedPowerBasis === 'utility-modeled'
+                    ? t.noUtilityModeledData
+                    : t.noChartData}
               </p>
             </Card>,
           ]
@@ -1013,6 +1051,8 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                               {getSequenceLabel(graph.sequence as Sequence, locale)}{' '}
                               {metricChartTitle(graph.chartDefinition, selectedYAxisMetric, locale)}{' '}
                               {(() => {
+                                // The timeline's x axis is time, not the scatter x metric.
+                                if (isPowerTimeline) return null;
                                 const xField = graph.chartDefinition.x_scale_field;
                                 if (xField?.endsWith('_ttft')) {
                                   const percentile = xField.replace(/_ttft$/u, '');
@@ -1140,6 +1180,15 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                               {t.systemPowerAssumptions}
                             </p>
                           )}
+                          {selectedPowerBasis && selectedPowerBasis !== 'gpu-measured' && (
+                            <p
+                              className="mb-2 text-xs text-muted-foreground"
+                              data-testid="power-basis-assumptions"
+                              data-power-basis={selectedPowerBasis}
+                            >
+                              {t.powerBasisAssumptions[selectedPowerBasis]}
+                            </p>
+                          )}
                           {isUnofficialRun &&
                             selectedXAxisMode === 'e2e-normalized-interactivity' && (
                               <p className="mb-2 text-xs text-muted-foreground">
@@ -1189,11 +1238,42 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                         );
                       }
 
+                      if (isPowerTimeline) {
+                        return (
+                          <div className="relative">
+                            <PowerTimeline
+                              chartId={`chart-${graphIndex}`}
+                              // Display limits clip outliers from the scatter domain; the
+                              // timeline draws every measured config, so restore them.
+                              data={[
+                                ...graph.data,
+                                ...(graph.clippedData ?? []).map((entry) => entry.point),
+                              ]}
+                              overlayData={
+                                selectUnofficialOverlayForMode(
+                                  selectedXAxisMode,
+                                  graph.chartDefinition.chartType,
+                                  overlayDataByChartType,
+                                ) ?? undefined
+                              }
+                              yLabel={metricLabel(
+                                graph.chartDefinition,
+                                selectedYAxisMetric,
+                                locale,
+                              )}
+                              caption={chartCaption}
+                            />
+                          </div>
+                        );
+                      }
+
                       return isGpuComparison ? (
                         <GPUGraph
                           chartId={`chart-${graphIndex}`}
                           modelLabel={graph.model}
-                          data={graph.data}
+                          // Date comparison draws one hardware across runs; the
+                          // boundary / role siblings are a same-run overlay only.
+                          data={graph.data.filter((point) => !point.powerVariant)}
                           xLabel={resolvedXLabel}
                           yLabel={metricLabel(graph.chartDefinition, selectedYAxisMetric, locale)}
                           chartDefinition={graph.chartDefinition}
diff --git a/packages/app/src/components/inference/ui/GPUGraph.tsx b/packages/app/src/components/inference/ui/GPUGraph.tsx
index 01fc782eb..ac17588d9 100644
--- a/packages/app/src/components/inference/ui/GPUGraph.tsx
+++ b/packages/app/src/components/inference/ui/GPUGraph.tsx
@@ -1,5 +1,7 @@
 'use client';
 
+import { useFeatureGate } from '@/lib/use-feature-gate';
+import { getMeasuredMetricConfig } from '@/components/inference/measured-metric-config';
 import { track } from '@/lib/analytics';
 import { isPersistedBenchmarkId } from '@/lib/benchmark-id';
 import { useEphemeralUrlState } from '@/hooks/useUrlState';
@@ -48,6 +50,7 @@ import {
   chartFrontier,
   upperPowerEnvelope,
   isPowerCurveMetric,
+  isPowerGaugeSeries,
   isMeasuredPowerCurveMetric,
 } from '@/components/inference/utils/powerCurves';
 import type {
@@ -109,6 +112,14 @@ import {
 } from '@/components/inference/ui/line-label-layer';
 import { QuickFiltersDialog } from '@/components/inference/ui/QuickFiltersDialog';
 
+const PowerTelemetryDialog = dynamic(
+  () =>
+    import('@/components/inference/power-telemetry-dialog').then(
+      (module) => module.PowerTelemetryDialog,
+    ),
+  { ssr: false },
+);
+
 const FixedSequenceLogDialog = dynamic(() =>
   import('@/components/inference/log-viewer/fixed-sequence-log-dialog').then(
     (module) => module.FixedSequenceLogDialog,
@@ -255,6 +266,11 @@ const GPUGraph = React.memo(
       setQuickFilterPower,
     } = useInferenceActions();
     const locale = useLocale();
+    const featureGateUnlocked = useFeatureGate();
+    const showPowerTelemetry =
+      featureGateUnlocked || getMeasuredMetricConfig(selectedYAxisMetric) !== undefined;
+    const showPowerTelemetryRef = useRef(showPowerTelemetry);
+    showPowerTelemetryRef.current = showPowerTelemetry;
     const legendT = GPU_STRINGS[locale];
     const frontierDirection = chartDefinition[
       `${selectedYAxisMetric}_roofline` as keyof ChartDefinition
@@ -443,10 +459,20 @@ const GPUGraph = React.memo(
       if (!powerEnvelopeMode) return paretoRooflines;
       const result: Record<string, InferenceData[]> = {};
       for (const [key, points] of Object.entries(groupedData)) {
-        result[key] = upperPowerEnvelope(points, chartDefinition.chartType !== 'e2e');
+        result[key] = upperPowerEnvelope(
+          points,
+          chartDefinition.chartType !== 'e2e',
+          isPowerGaugeSeries(selectedYAxisMetric, points[0]),
+        );
       }
       return result;
-    }, [powerEnvelopeMode, groupedData, paretoRooflines, chartDefinition.chartType]);
+    }, [
+      powerEnvelopeMode,
+      groupedData,
+      paretoRooflines,
+      chartDefinition.chartType,
+      selectedYAxisMetric,
+    ]);
 
     const boundaryPointKeys = useMemo(() => {
       const keys = new Set<string>();
@@ -511,6 +537,7 @@ const GPUGraph = React.memo(
     const logAvailabilityRef = useRef(logAvailability);
     logAvailabilityRef.current = logAvailability;
     const [fixedLogPointId, setFixedLogPointId] = useState<number | null>(null);
+    const [powerTelemetryPoint, setPowerTelemetryPoint] = useState<InferenceData | null>(null);
 
     // Warning annotations for visible series with known upstream issues —
     // same treatment the scatter view gets, applied to the date-comparison view.
@@ -1251,7 +1278,7 @@ const GPUGraph = React.memo(
       );
     }
 
-    return (
+    const chart = (
       <D3Chart<InferenceData>
         ref={chartRef}
         // Embeds drop the zoom/pan hint line; the host page has its own caption.
@@ -1363,6 +1390,7 @@ const GPUGraph = React.memo(
               yLabel,
               selectedYAxisMetric,
               hardwareConfig,
+              showPowerTelemetry: showPowerTelemetryRef.current,
               runUrl: d.run_url ? updateRepoUrl(d.run_url) : undefined,
               hasTrace: isPersistedBenchmarkId(d.id)
                 ? traceAvailabilityRef.current?.[d.id] === true
@@ -1424,6 +1452,19 @@ const GPUGraph = React.memo(
                 });
               });
             }
+            const powerBtn = tooltipEl.querySelector('[data-action="view-power-telemetry"]');
+            if (powerBtn && isPersistedBenchmarkId(d.id)) {
+              powerBtn.addEventListener('click', (event) => {
+                event.stopPropagation();
+                setPowerTelemetryPoint(d);
+                chartRef.current?.dismissTooltip();
+                track('inference_power_telemetry_opened', {
+                  id: d.id,
+                  hwKey: d.hwKey,
+                  conc: d.conc,
+                });
+              });
+            }
             const logsBtn = tooltipEl.querySelector('[data-action="view-logs"]');
             if (logsBtn && typeof d.id === 'number') {
               logsBtn.addEventListener('click', (event) => {
@@ -1694,6 +1735,21 @@ const GPUGraph = React.memo(
         }
       />
     );
+
+    return (
+      <>
+        {powerTelemetryPoint === null ? null : (
+          <PowerTelemetryDialog
+            key={powerTelemetryPoint.id}
+            point={powerTelemetryPoint}
+            onOpenChange={(open) => {
+              if (!open) setPowerTelemetryPoint(null);
+            }}
+          />
+        )}
+        {chart}
+      </>
+    );
   },
 );
 
diff --git a/packages/app/src/components/inference/ui/InferenceTable.test.ts b/packages/app/src/components/inference/ui/InferenceTable.test.ts
index bf9ab1b0c..09294dddc 100644
--- a/packages/app/src/components/inference/ui/InferenceTable.test.ts
+++ b/packages/app/src/components/inference/ui/InferenceTable.test.ts
@@ -1,7 +1,12 @@
 import { describe, it, expect } from 'vitest';
+import { createElement } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
 
 import type { ChartDefinition, InferenceData } from '@/components/inference/types';
-import { formatInferenceTableNumber } from '@/components/inference/ui/InferenceTable';
+import InferenceTable, {
+  formatInferenceTableNumber,
+} from '@/components/inference/ui/InferenceTable';
+import { expandPowerCompareSeries } from '../utils/power-compare';
 
 import * as inferenceTableModule from './InferenceTable';
 import { chartDefinitions } from '../metric-registry';
@@ -42,6 +47,54 @@ function makePoint(overrides: Partial<InferenceData>): InferenceData {
 }
 
 describe('InferenceTable sorting logic', () => {
+  it.each(['roles', 'boundaries'] as const)(
+    'renders and sorts each %s comparison by its plotted value',
+    (mode) => {
+      const base = makePoint({
+        hwKey: 'gb300_dynamo-trt',
+        y: 708.1,
+        measuredAvgPower: { y: 708.1, roof: false },
+        measuredPrefillAvgPower: { y: 760.442, roof: false },
+        measuredDecodeAvgPower: { y: 690.652, roof: false },
+        gpuProvisionedWatts: { y: 1400, roof: false },
+        utilityProvisionedWatts: { y: 1920, roof: false },
+      });
+      const points = expandPowerCompareSeries([base], 'y_measuredAvgPower', mode);
+      const sorted = sortRowsByYMetric(points, chartDefinitions[0], 'y_measuredAvgPower');
+      expect(sorted.map((point) => point.y)).toEqual(
+        mode === 'roles' ? [690.652, 708.1, 760.442] : [708.1, 1400, 1920],
+      );
+
+      const html = renderToStaticMarkup(
+        createElement(InferenceTable, {
+          data: points,
+          chartDefinition: chartDefinitions[0],
+          selectedYAxisMetric: 'y_measuredAvgPower',
+        }),
+      );
+      const body = html.split('<tbody>')[1].split('</tbody>')[0];
+      const cells = [...body.matchAll(/<tr\b[^>]*>(?<row>.*?)<\/tr>/gu)].map((match) =>
+        [...match.groups!.row.matchAll(/<td\b[^>]*>(?<cell>.*?)<\/td>/gu)].map(
+          (cell) => cell.groups!.cell,
+        ),
+      );
+      expect(cells.map((row) => [row[2], row[3]])).toEqual(
+        mode === 'roles'
+          ? [
+              ['Decode GPUs', '691'],
+              ['All GPUs', '708'],
+              ['Prefill GPUs', '760'],
+            ]
+          : [
+              ['GPU measured', '708'],
+              ['GPU provisioned (TDP)', '1,400'],
+              ['Utility provisioned (all-in)', '1,920'],
+            ],
+      );
+      expect(points.every((point) => point.measuredAvgPower?.y === 708.1)).toBe(true);
+    },
+  );
+
   it('sorts supported modeled estimates by ascending power', () => {
     const definition = chartDefinitions[0];
     const metric = 'y_modeledChassisPowerPerGpu';
diff --git a/packages/app/src/components/inference/ui/InferenceTable.tsx b/packages/app/src/components/inference/ui/InferenceTable.tsx
index b6cdafa7e..0d4e8ab74 100644
--- a/packages/app/src/components/inference/ui/InferenceTable.tsx
+++ b/packages/app/src/components/inference/ui/InferenceTable.tsx
@@ -7,6 +7,7 @@ import { type DataTableColumn, DataTable } from '@/components/ui/data-table';
 import { chipCounts } from '@/lib/chip-counts';
 import { getNestedYValue, metricLabel, xAxisLabel } from '@/lib/chart-utils';
 import { isModeledSystemPowerConfigKey } from '@/components/inference/metric-registry';
+import { inferPowerCompare, powerSeriesLabel } from '@/components/inference/utils/power-compare';
 import { sortRowsByYMetric } from '@/components/inference/ui/inference-table-sort';
 import { type Precision, getPrecisionLabel } from '@/lib/data-mappings';
 import { getDisplayLabel } from '@/lib/utils';
@@ -43,6 +44,7 @@ export function inferenceTableHeaderLabels(
     physicalChips: locale === 'zh' ? '物理芯片数' : 'Physical Chips',
     configuredChips: locale === 'zh' ? '配置中的芯片数' : 'Configured Chip Count',
     concurrency: locale === 'zh' ? '并发数' : 'Conc',
+    series: locale === 'zh' ? '系列' : 'Series',
     yMetric: metricLabel(chartDefinition, selectedYAxisMetric, locale),
     xMetric: xAxisLabel(chartDefinition, locale),
     throughput: locale === 'zh' ? '单芯片吞吐量 (tok/s)' : 'Throughput/Chip (tok/s)',
@@ -66,6 +68,9 @@ export default function InferenceTable({
     () => sortRowsByYMetric(data, chartDefinition, selectedYAxisMetric),
     [data, chartDefinition, selectedYAxisMetric],
   );
+  // Boundary / role clones (`i_pcompare`) share every config column with their
+  // base row; the series column is what tells them apart.
+  const powerCompare = useMemo(() => inferPowerCompare(data), [data]);
 
   const columns = useMemo<DataTableColumn<InferenceData>[]>(
     () => [
@@ -85,6 +90,19 @@ export default function InferenceTable({
         className: 'whitespace-nowrap',
         importance: 'key',
       },
+      ...(powerCompare === 'none'
+        ? []
+        : [
+            {
+              header: headers.series,
+              cell: (row: InferenceData) =>
+                powerSeriesLabel(row, selectedYAxisMetric, powerCompare, locale),
+              sortValue: (row: InferenceData) =>
+                powerSeriesLabel(row, selectedYAxisMetric, powerCompare, locale),
+              className: 'whitespace-nowrap',
+              importance: 'key' as const,
+            },
+          ]),
       {
         header: headers.tensorParallelism,
         align: 'right',
@@ -129,8 +147,12 @@ export default function InferenceTable({
       {
         header: headers.yMetric,
         align: 'right',
-        cell: (row) => formatInferenceTableNumber(yPath ? getNestedYValue(row, yPath) : row.y),
-        sortValue: (row) => (yPath ? getNestedYValue(row, yPath) : row.y),
+        // Comparison clones keep the source metrics; y holds the plotted role/boundary.
+        cell: (row) =>
+          formatInferenceTableNumber(
+            row.powerVariant || !yPath ? row.y : getNestedYValue(row, yPath),
+          ),
+        sortValue: (row) => (row.powerVariant || !yPath ? row.y : getNestedYValue(row, yPath)),
         className: 'tabular-nums',
         importance: 'key',
       },
@@ -151,7 +173,7 @@ export default function InferenceTable({
         importance: 'key',
       },
     ],
-    [yPath, headers, showModeledPower],
+    [yPath, headers, showModeledPower, powerCompare, selectedYAxisMetric, locale],
   );
 
   return (
diff --git a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
index 46f0600eb..0373fc5bd 100644
--- a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
+++ b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
@@ -7,15 +7,24 @@ import {
   SelectTrigger,
   SelectValue,
 } from '@/components/ui/select';
+import { track } from '@/lib/analytics';
+import { POWER_BASES, POWER_BASIS_LABELS, type PowerBasis } from '@/lib/power-basis';
 import { useLocale } from '@/lib/use-locale';
 import {
   changeMeasuredMetricConfig,
   getMeasuredMetricConfig,
   type MeasuredMetricConfigChange,
 } from '../measured-metric-config';
+import type { PowerCompare } from '../types';
+import { POWER_COMPARE_MODES, powerCompareAvailable } from '../utils/power-compare';
 
 const STRINGS = {
   en: {
+    basis: 'Boundary',
+    basisHelp:
+      'Where power is counted. GPU measured: runner telemetry from the GPU boards. GPU provisioned: rated TDP per GPU. Utility provisioned: all-in provisioned utility power per GPU. Utility modeled: measured GPU power carried through the modeled chassis to the utility meter with PUE. Points without a value for the chosen boundary are omitted, never replaced with an estimate.',
+    basisHint:
+      'Derived boundaries report average power per chip across all GPUs, and whole-deployment joules per output token. Changing another setting returns to GPU measured.',
     scope: 'Scope',
     scopeHelp:
       'All GPUs measures the whole deployment. Prefill and decode select only GPUs serving that role.',
@@ -29,7 +38,8 @@ const STRINGS = {
     roleHint: 'Prefill and decode power support Average only.',
     display: 'Display',
     displayHelp:
-      'Power per chip in watts, or average power as a percentage of chip TDP. Percent of TDP is available for the all-GPU average only.',
+      'Power per chip in watts, average power as a percentage of chip TDP, or the per-second telemetry timeline behind the average. Percent of TDP and Timeline are available for the all-GPU average only.',
+    timeline: 'Timeline',
     denominator: 'Per',
     denominatorHelp:
       'Choose the energy denominator. All-GPU energy per input or output token includes the whole deployment; role energy is selected separately under Scope.',
@@ -40,8 +50,21 @@ const STRINGS = {
     unit: 'Unit',
     unitHelp:
       'Energy is shown in joules. Energy per successful query can also be shown in watt-hours.',
+    compare: 'Compare',
+    compareHelp:
+      'Overlay sibling series on the same points, in the hardware colour with a dash per series. All boundaries: GPU measured, GPU provisioned, utility provisioned and utility modeled. Prefill vs decode: each worker pool next to the whole deployment; on the energy axis the prefill pool is carried onto the output-token axis by the served input:output ratio. Available for the whole-deployment average W/chip and J per output token.',
+    compareNone: 'Off',
+    compareBoundaries: 'All boundaries',
+    compareRoles: 'Prefill vs decode',
+    compareUnavailable:
+      'The comparison is paused for this setting: it needs the whole-deployment average W/chip or J per output token.',
   },
   zh: {
+    basis: '功耗边界',
+    basisHelp:
+      '选择功耗的计量边界。GPU 实测：来自 GPU 板卡的运行器遥测；GPU 额定：每 GPU 的额定 TDP；全电源配置：每 GPU 的全电源配置（all-in）市电功率；数据中心建模：将 GPU 实测功耗经机箱功耗模型推算至市电侧并计入 PUE。所选边界缺少数值的数据点将被省略，不会用估算值替代。',
+    basisHint:
+      '推导边界提供全部 GPU 的平均每芯片功率，以及整个部署的每输出 token 能耗；更改其他设置将返回 GPU 实测。',
     scope: '统计范围',
     scopeHelp: '全部 GPU 对应整个部署；预填充和解码仅统计承担相应任务的 GPU。',
     all: '全部 GPU',
@@ -54,7 +77,8 @@ const STRINGS = {
     roleHint: '预填充和解码功率仅支持平均值。',
     display: '显示方式',
     displayHelp:
-      '显示单芯片功率（瓦），或平均功率占芯片 TDP 的百分比。TDP 百分比仅支持全部 GPU 的平均功率。',
+      '显示单芯片功率（瓦）、平均功率占芯片 TDP 的百分比，或平均值背后的逐秒遥测时间线。TDP 百分比和时间线仅支持全部 GPU 的平均功率。',
+    timeline: '时间线',
     denominator: '能耗分母',
     denominatorHelp:
       '选择能耗的分母。按输入或输出 token 归一化的全部 GPU 能耗仍包含整个部署；预填充或解码能耗需在统计范围中单独选择。',
@@ -64,22 +88,44 @@ const STRINGS = {
     query: '成功请求',
     unit: '单位',
     unitHelp: '能耗以焦耳显示；每个成功请求的能耗也可显示为瓦时。',
+    compare: '对比',
+    compareHelp:
+      '在同一批数据点上叠加同源系列：颜色仍按硬件区分，每个系列用不同虚线表示。全部边界：GPU 实测、GPU 额定、全电源配置、数据中心建模；预填充 vs 解码：各 worker 池与整个部署并列，能耗轴上的预填充能耗按实际服务的输入/输出 token 比折算到每输出 token。仅适用于整个部署的平均 W/芯片和每输出 token 能耗。',
+    compareNone: '关闭',
+    compareBoundaries: '全部边界',
+    compareRoles: '预填充 vs 解码',
+    compareUnavailable: '当前设置下对比已暂停：需要整个部署的平均 W/芯片或每输出 token 能耗。',
   },
 } as const;
 
 export function MeasuredMetricControls({
   metric,
   onChange,
+  compare = 'none',
+  onCompareChange,
 }: {
   metric: string;
   onChange: (metric: string) => void;
+  /** Comparison series overlaid on the metric (`i_pcompare`). */
+  compare?: PowerCompare;
+  onCompareChange?: (mode: PowerCompare) => void;
 }) {
-  const t = STRINGS[useLocale()];
+  const locale = useLocale();
+  const t = STRINGS[locale];
   const config = getMeasuredMetricConfig(metric);
   if (!config) return null;
+  const compareLabels: Record<PowerCompare, string> = {
+    none: t.compareNone,
+    boundaries: t.compareBoundaries,
+    roles: t.compareRoles,
+  };
+  const compareActive = compare !== 'none';
+  const compareApplies = powerCompareAvailable(metric, compare);
   const change = (next: MeasuredMetricConfigChange) =>
     onChange(changeMeasuredMetricConfig(metric, next));
+  const basisId = `measured-${config.family}-basis`;
   const scopeId = `measured-${config.family}-scope`;
+  const derivedBasis = config.basis !== 'gpu-measured';
   const roleScope =
     config.family === 'energy'
       ? config.denominator === 'input'
@@ -91,9 +137,31 @@ export function MeasuredMetricControls({
 
   return (
     <div
-      className="col-span-full grid min-w-0 gap-3 sm:grid-cols-3"
+      className="col-span-full grid min-w-0 grid-cols-[repeat(auto-fit,minmax(min(100%,12rem),1fr))] gap-3"
       data-testid="measured-metric-controls"
     >
+      <div className="flex min-w-0 flex-col gap-1.5">
+        <LabelWithTooltip htmlFor={basisId} label={t.basis} tooltip={t.basisHelp} />
+        <Select
+          value={config.basis}
+          onValueChange={(value) => {
+            const basis = value as PowerBasis;
+            track('inference_power_basis_changed', { basis, family: config.family });
+            change({ basis });
+          }}
+        >
+          <SelectTrigger id={basisId} data-testid={basisId} className="w-full">
+            <SelectValue />
+          </SelectTrigger>
+          <SelectContent portalled={false}>
+            {POWER_BASES.map((basis) => (
+              <SelectItem key={basis} value={basis} data-value={basis}>
+                {POWER_BASIS_LABELS[basis][locale]}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
       {config.family === 'energy' && (
         <div className="flex min-w-0 flex-col gap-1.5">
           <LabelWithTooltip
@@ -159,7 +227,7 @@ export function MeasuredMetricControls({
               role="group"
               size="default"
               className="w-full"
-              buttonClassName="flex-1 justify-center"
+              buttonClassName="min-w-max flex-auto justify-center"
               ariaLabel={t.statistic}
               value={config.statistic}
               onValueChange={(statistic) => change({ statistic })}
@@ -204,6 +272,13 @@ export function MeasuredMetricControls({
                 >
                   % TDP
                 </SelectItem>
+                <SelectItem
+                  value="timeline"
+                  data-value="timeline"
+                  disabled={config.scope !== 'all' || config.statistic !== 'average'}
+                >
+                  {t.timeline}
+                </SelectItem>
               </SelectContent>
             </Select>
           </div>
@@ -237,6 +312,59 @@ export function MeasuredMetricControls({
           </Select>
         </div>
       )}
+      {onCompareChange && (
+        <div className="flex min-w-0 flex-col gap-1.5">
+          <LabelWithTooltip
+            htmlFor="measured-power-compare"
+            label={t.compare}
+            tooltip={t.compareHelp}
+          />
+          <Select
+            value={compare}
+            onValueChange={(value) => {
+              const mode = value as PowerCompare;
+              track('inference_power_compare_changed', { mode, family: config.family });
+              onCompareChange(mode);
+            }}
+          >
+            <SelectTrigger
+              id="measured-power-compare"
+              data-testid="measured-power-compare"
+              className="w-full"
+            >
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent portalled={false}>
+              {POWER_COMPARE_MODES.map((mode) => (
+                <SelectItem
+                  key={mode}
+                  value={mode}
+                  data-value={mode}
+                  disabled={!powerCompareAvailable(metric, mode)}
+                >
+                  {compareLabels[mode]}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        </div>
+      )}
+      {derivedBasis && (
+        <p
+          className="col-span-full text-xs text-muted-foreground"
+          data-testid="measured-basis-hint"
+        >
+          {t.basisHint}
+        </p>
+      )}
+      {compareActive && !compareApplies && (
+        <p
+          className="col-span-full text-xs text-muted-foreground"
+          data-testid="measured-compare-hint"
+        >
+          {t.compareUnavailable}
+        </p>
+      )}
     </div>
   );
 }
diff --git a/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx b/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
index a3dd548b0..cad29732b 100644
--- a/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
+++ b/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
@@ -2,8 +2,16 @@
 
 import { useMemo } from 'react';
 import { useInferenceData, useInferenceFilters } from '../InferenceContext';
-import { isMeasuredEnergyConfigKey, metricOptionTitle, type MetricKey } from '../metric-registry';
+import {
+  isMeasuredEnergyConfigKey,
+  isPowerBasisConfigKey,
+  metricOptionTitle,
+  POWER_BASIS_METRIC_CONFIG_KEYS,
+  type MetricKey,
+} from '../metric-registry';
+import { getMeasuredMetricConfig } from '../measured-metric-config';
 import type { InferenceData } from '../types';
+import { powerBasisNormalization } from '@/lib/power-basis';
 import { matchesQuickFilters } from '../utils/quickFilters';
 import {
   powerMetricAvailability,
@@ -33,6 +41,17 @@ const STRINGS = {
       ambiguous: 'Whole-deployment energy schema unavailable',
       missing: 'Metric not reported',
     },
+    basisLabels: {
+      available: 'Value available',
+      noSpec: 'No published spec for this hardware',
+      noThroughput: 'No output throughput reported',
+      noNormalization: 'Whole-deployment GPU count unavailable for this disaggregated row',
+      noTelemetry: 'No validated GPU telemetry',
+      invalid: 'Validation failed',
+      modelWorkload: 'Chassis model covers 8K / 1K only',
+      modelHardware: 'Hardware not in the chassis power model',
+      modelUnsupported: 'Chassis model unsupported for this deployment',
+    },
     note: 'A missing verdict does not establish age or validity. Prefill/decode metrics measure separate worker pools. Missing values are never replaced with zero or TDP estimates.',
     all: 'Availability of all measured metrics',
     evidence: 'Selected metric: source details',
@@ -54,6 +73,17 @@ const STRINGS = {
       ambiguous: '缺少整个部署的能耗 schema',
       missing: '未提供此指标',
     },
+    basisLabels: {
+      available: '有数值',
+      noSpec: '该硬件没有公开的规格参数',
+      noThroughput: '未报告输出吞吐量',
+      noNormalization: '无法确定该分离式部署的 GPU 总数',
+      noTelemetry: '没有已验证的 GPU 遥测',
+      invalid: '验证失败',
+      modelWorkload: '机箱功耗模型仅覆盖 8K / 1K',
+      modelHardware: '硬件不在机箱功耗模型范围内',
+      modelUnsupported: '机箱功耗模型不支持此部署',
+    },
     note: '缺少验证结论不能判断数据新旧或有效性。prefill/decode 指标仅衡量独立 worker 池。缺失值不会被替换为零或 TDP 估算值。',
     all: '所有实测指标的可用性',
     evidence: '当前指标的来源详情',
@@ -61,6 +91,99 @@ const STRINGS = {
   },
 } as const;
 
+/**
+ * Why a point lacks a derived power boundary (lib/power-basis.ts). Provisioned
+ * boundaries are spec constants, so their watts exist for any registered
+ * hardware and their energy additionally needs output throughput plus, for
+ * disaggregated rows, the whole-deployment GPU count that
+ * `powerBasisNormalization` recovers only for fixed-sequence runs with integer
+ * prefill/decode counts. The modeled boundary is measured telemetry carried
+ * through the chassis model, so it inherits the telemetry verdict and the
+ * model's own unsupported reasons.
+ */
+export type PowerBasisAvailabilityState =
+  | 'available'
+  | 'noSpec'
+  | 'noThroughput'
+  | 'noNormalization'
+  | 'noTelemetry'
+  | 'invalid'
+  | 'modelWorkload'
+  | 'modelHardware'
+  | 'modelUnsupported';
+
+const POWER_BASIS_AVAILABILITY_STATES: readonly PowerBasisAvailabilityState[] = [
+  'available',
+  'noSpec',
+  'noThroughput',
+  'noNormalization',
+  'noTelemetry',
+  'invalid',
+  'modelWorkload',
+  'modelHardware',
+  'modelUnsupported',
+];
+
+const hasFiniteValue = (point: InferenceData, key: MetricKey): boolean => {
+  const value = point[key];
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'y' in value &&
+    typeof value.y === 'number' &&
+    Number.isFinite(value.y)
+  );
+};
+
+export function powerBasisState(
+  point: InferenceData,
+  configKey: string,
+): PowerBasisAvailabilityState {
+  const key = configKey.replace(/^y_/u, '') as MetricKey;
+  if (hasFiniteValue(point, key)) return 'available';
+  const config = getMeasuredMetricConfig(configKey);
+  if (config?.basis === 'utility-modeled') {
+    if (point.power_valid === 0) return 'invalid';
+    const model = point.modeledSystemPower;
+    if (model?.status === 'unsupported') {
+      if (model.reason === 'workload') return 'modelWorkload';
+      if (model.reason === 'hardware') return 'modelHardware';
+      if (model.reason === 'telemetry') return 'noTelemetry';
+      return 'modelUnsupported';
+    }
+    // A supported model without a plotted value means B1 is absent (B4 follows B1).
+    return 'noTelemetry';
+  }
+  // Provisioned energy needs the watts sibling plus the whole-deployment
+  // normalization; the same helper that withheld the value says which half is
+  // missing, so the explanation cannot drift from the formula.
+  const wattsKey = (
+    config?.basis === 'gpu-provisioned' ? 'gpuProvisionedWatts' : 'utilityProvisionedWatts'
+  ) satisfies MetricKey;
+  if (!hasFiniteValue(point, wattsKey)) return 'noSpec';
+  const perGpu = point.output_tput_per_gpu;
+  if (typeof perGpu !== 'number' || !Number.isFinite(perGpu) || perGpu <= 0) return 'noThroughput';
+  // Throughput exists, so only the disaggregated GPU count can be missing.
+  // Chart points may lack the counts an aggregate entry always has; an
+  // unknown count is exactly the "unavailable" case the helper reports.
+  const { allocatedGpus } = powerBasisNormalization({
+    output_tput_per_gpu: perGpu,
+    disagg: point.disagg ?? false,
+    benchmark_type: point.benchmark_type,
+    num_prefill_gpu: point.num_prefill_gpu ?? Number.NaN,
+    num_decode_gpu: point.num_decode_gpu ?? Number.NaN,
+  });
+  return allocatedGpus === null ? 'noNormalization' : 'noThroughput';
+}
+
+function powerBasisAvailability(points: readonly InferenceData[], metric: string) {
+  const counts = Object.fromEntries(
+    POWER_BASIS_AVAILABILITY_STATES.map((state) => [state, 0]),
+  ) as Record<PowerBasisAvailabilityState, number>;
+  for (const point of points) counts[powerBasisState(point, metric)]++;
+  return { metric, counts, available: counts.available, total: points.length };
+}
+
 export function PowerMetricAvailabilityPanel({
   points,
   metric,
@@ -74,16 +197,35 @@ export function PowerMetricAvailabilityPanel({
 }) {
   const locale = useLocale();
   const t = STRINGS[locale];
-  const availability = useMemo(() => powerMetricAvailability(points), [points]);
+  const availability = useMemo(
+    () => [
+      ...powerMetricAvailability(points),
+      ...POWER_BASIS_METRIC_CONFIG_KEYS.map((key) => powerBasisAvailability(points, key)),
+    ],
+    [points],
+  );
   const selected = availability.find((entry) => entry.metric === metric);
   if (!selected) return null;
+  const isBasis = isPowerBasisConfigKey(metric);
+  const stateOf = (point: InferenceData) =>
+    isBasis ? powerBasisState(point, metric) : powerMetricState(point, metric);
+  // The two dictionaries overlap on `invalid`; the selected metric, not the
+  // key, decides which copy applies so the measured strings stay untouched.
+  const labelOf = (state: PowerAvailabilityState | PowerBasisAvailabilityState) =>
+    isBasis
+      ? t.basisLabels[state as PowerBasisAvailabilityState]
+      : t.labels[state as PowerAvailabilityState];
   const sources = new Map<
     string,
-    { point: InferenceData; state: PowerAvailabilityState; count: number }
+    {
+      point: InferenceData;
+      state: PowerAvailabilityState | PowerBasisAvailabilityState;
+      count: number;
+    }
   >();
   for (const point of points) {
-    const state = powerMetricState(point, metric);
-    if (state === 'strict') continue;
+    const state = stateOf(point);
+    if (state === 'strict' || state === 'available') continue;
     const key = JSON.stringify([point.hwKey, point.run_url, state, point.power_invalid_reasons]);
     const group = sources.get(key);
     if (group) group.count++;
@@ -108,7 +250,10 @@ export function PowerMetricAvailabilityPanel({
           <p>
             {Object.entries(selected.counts)
               .filter(([, count]) => count > 0)
-              .map(([state, count]) => `${t.labels[state as PowerAvailabilityState]}: ${count}`)
+              .map(
+                ([state, count]) =>
+                  `${labelOf(state as PowerAvailabilityState | PowerBasisAvailabilityState)}: ${count}`,
+              )
               .join(' · ')}
           </p>
           <details
@@ -139,7 +284,7 @@ export function PowerMetricAvailabilityPanel({
               <ul className="mt-2 max-h-48 space-y-2 overflow-auto">
                 {[...sources.values()].map(({ point, state, count }, index) => (
                   <li key={index}>
-                    {point.hwKey}: {t.labels[state]} ({count})
+                    {point.hwKey}: {labelOf(state)} ({count})
                     {point.power_invalid_reasons?.length
                       ? ` · ${point.power_invalid_reasons.join(', ')}`
                       : ''}
@@ -221,7 +366,7 @@ export function PowerMetricAvailability({
     quickFilters,
     compareGpuPair,
   ]);
-  if (!isMeasuredEnergyConfigKey(metric)) return null;
+  if (!isMeasuredEnergyConfigKey(metric) && !isPowerBasisConfigKey(metric)) return null;
   return (
     <PowerMetricAvailabilityPanel
       points={points}
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.test-harness.tsx b/packages/app/src/components/inference/ui/ScatterGraph.test-harness.tsx
index 2cebdba58..5e72fb046 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.test-harness.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.test-harness.tsx
@@ -80,6 +80,10 @@ class MockResizeObserver {
   unobserve() {}
   disconnect() {}
 }
+const originalGetComputedTextLength = Object.getOwnPropertyDescriptor(
+  SVGElement.prototype,
+  'getComputedTextLength',
+);
 const originalGetBBox = Object.getOwnPropertyDescriptor(SVGElement.prototype, 'getBBox');
 
 export const point = (
@@ -220,6 +224,12 @@ export const rebuildCount = () => vi.mocked(setupChartStructure).mock.calls.leng
 beforeEach(() => {
   globalThis.__scatterPathnameState.value = '/inference';
   vi.stubGlobal('ResizeObserver', MockResizeObserver);
+  Object.defineProperty(SVGElement.prototype, 'getComputedTextLength', {
+    configurable: true,
+    value(this: SVGElement) {
+      return (this.textContent?.length ?? 0) * 7;
+    },
+  });
   Object.defineProperty(SVGElement.prototype, 'getBBox', {
     configurable: true,
     value: () =>
@@ -259,6 +269,15 @@ beforeEach(() => {
 afterEach(() => {
   vi.unstubAllGlobals();
   vi.restoreAllMocks();
+  if (originalGetComputedTextLength) {
+    Object.defineProperty(
+      SVGElement.prototype,
+      'getComputedTextLength',
+      originalGetComputedTextLength,
+    );
+  } else {
+    Reflect.deleteProperty(SVGElement.prototype, 'getComputedTextLength');
+  }
   if (originalGetBBox) {
     Object.defineProperty(SVGElement.prototype, 'getBBox', originalGetBBox);
   } else {
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index fc860d3ad..9f6656adf 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -1,10 +1,13 @@
 'use client';
 
+import { useFeatureGate } from '@/lib/use-feature-gate';
+import { getMeasuredMetricConfig } from '@/components/inference/measured-metric-config';
 import { track } from '@/lib/analytics';
 import { isPersistedBenchmarkId } from '@/lib/benchmark-id';
 import { useEphemeralUrlState } from '@/hooks/useUrlState';
 import { rememberChartStateInUrl } from '@/lib/url-state';
 import * as d3 from 'd3';
+import { CHART_TYPE } from '@/lib/d3-chart/typography';
 import dynamic from 'next/dynamic';
 import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
 
@@ -16,6 +19,7 @@ import {
   useInferenceDisplay,
   useInferenceFilters,
 } from '@/components/inference/InferenceContext';
+import { usePerfRulerStore } from '@/components/inference/perf-ruler-store';
 import { useTraceAvailability } from '@/hooks/api/use-trace-availability';
 import { useLogAvailability } from '@/hooks/api/use-log-availability';
 import { computeToggle } from '@/hooks/useTogglableSet';
@@ -47,7 +51,13 @@ import { matchKnownConfigIssues, pointMatchesIssue } from '@/lib/known-issues';
 import { useLocale } from '@/lib/use-locale';
 import { getLineLabelVendorIcon } from '@/lib/vendor-logos';
 import { formatNumber, getDisplayLabel, updateRepoUrl } from '@/lib/utils';
-import { getInferenceHardwareConfig, getInferenceRunLabel } from '@/lib/inference-labels';
+import {
+  getInferenceHardwareConfig,
+  getInferenceRunLabel,
+  getOverlayLineLabel,
+  OVERLAY_LABEL_MARKER,
+  overlayRunTag,
+} from '@/lib/inference-labels';
 import { D3Chart } from '@/lib/d3-chart/D3Chart';
 import type {
   CustomLayerConfig,
@@ -76,6 +86,7 @@ import {
   renderPerfRulers,
   type PerfRulerEndInput,
   type PerfRulerGeometry,
+  type PerfRulerMeasurement,
   type PerfRulerRenderEntry,
   type PerfRulerState,
 } from '@/lib/d3-chart/layers/perf-ruler';
@@ -111,6 +122,7 @@ import {
   chartFrontier,
   upperPowerEnvelope,
   isPowerCurveMetric,
+  isPowerGaugeSeries,
   isMeasuredPowerCurveMetric,
 } from '@/components/inference/utils/powerCurves';
 import type {
@@ -118,17 +130,38 @@ import type {
   ClippedInferenceData,
   InferenceData,
   ScatterGraphProps,
+  PowerVariant,
 } from '@/components/inference/types';
 import {
   generateOverlayTooltipContent,
   generateTooltipContent,
 } from '@/components/inference/utils/tooltipUtils';
+import {
+  POWER_TIMELINE_METRIC_KEY,
+  requestPowerTraceFocus,
+  traceKeyForPoint,
+} from '@/components/inference/utils/powerTimeline';
 import { QuickFiltersDialog } from '@/components/inference/ui/QuickFiltersDialog';
 import { ScatterEmptyState } from '@/components/inference/ui/ScatterEmptyState';
 import {
   scatterPointConfigId,
   scatterPointJoinId,
+  parseScatterSeriesKey,
+  scatterSeriesKey,
 } from '@/components/inference/utils/point-identity';
+import {
+  flatSeriesValue,
+  inferPowerCompare,
+  lineLabelHardwareKey,
+  lineLabelSeriesId,
+  metricPlotsWatts,
+  powerCompareBase,
+  powerLineLabelSuffix,
+  powerVariantDash,
+  powerVariantId,
+  powerVariantLabel,
+  powerVariantsInData,
+} from '@/components/inference/utils/power-compare';
 import LegendPointsDialog from '@/components/inference/ui/LegendPointsDialog';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
 import { renderLegacyPowerRing } from '@/components/inference/utils/legacy-power-marker';
@@ -163,6 +196,14 @@ import {
   fitContinuationLabelBaseline,
 } from '@/components/inference/utils/overflowContinuations';
 
+const PowerTelemetryDialog = dynamic(
+  () =>
+    import('@/components/inference/power-telemetry-dialog').then(
+      (module) => module.PowerTelemetryDialog,
+    ),
+  { ssr: false },
+);
+
 const FixedSequenceLogDialog = dynamic(
   () =>
     import('@/components/inference/log-viewer/fixed-sequence-log-dialog').then(
@@ -221,6 +262,32 @@ const optimalPointKey = (d: InferenceData): string =>
 const EMPTY_OVERLAY_DATA: InferenceData[] = [];
 const EMPTY_CLIPPED_DATA: ClippedInferenceData[] = [];
 
+/**
+ * Legend ids of the comparison-series rows (`i_pcompare`), distinct from
+ * hardware keys so the shared hover / toggle handlers can tell them apart.
+ */
+const POWER_VARIANT_LEGEND_PREFIX = 'power-variant:';
+/** Comparison clones sit behind the base series they annotate. */
+const POWER_VARIANT_POINT_OPACITY = 0.6;
+const pointOpacityForVariant = (d: InferenceData): number =>
+  d.powerVariant ? POWER_VARIANT_POINT_OPACITY : 1;
+/** Dash for a series key's variant id (`parseScatterSeriesKey().variant`). */
+const powerVariantDashById = (variantId: string | null | undefined): string =>
+  variantId ? (VARIANT_DASH_BY_ID.get(variantId) ?? '') : '';
+const VARIANT_DASH_BY_ID = new Map<string, string>(
+  (
+    [
+      ['basis', 'gpu-measured'],
+      ['basis', 'gpu-provisioned'],
+      ['basis', 'utility-provisioned'],
+      ['basis', 'utility-modeled'],
+      ['role', 'all'],
+      ['role', 'prefill'],
+      ['role', 'decode'],
+    ] as const
+  ).map(([kind, id]) => [id, powerVariantDash({ kind, id } as PowerVariant)]),
+);
+
 const LINE_LABEL_RAISE = ['.line-label'] as const;
 /** Decorations sit above the visible shape, which a precision toggle may replace. */
 const POINT_DECORATION_RAISE = ['.offload-halo', '.legacy-power-ring'] as const;
@@ -534,6 +601,7 @@ const ScatterGraph = React.memo(
       setQuickFilterDeployment,
       setQuickFilterSpec,
       setQuickFilterPower,
+      setSelectedYAxisMetric,
     } = useInferenceActions();
     const paretoDirection = chartDefinition[`${selectedYAxisMetric}_roofline`] as
       | ParetoDirection
@@ -552,15 +620,31 @@ const ScatterGraph = React.memo(
         const groups = groupPointsByDate(points);
         if (showPowerEnvelope) {
           for (const [date, samples] of groups) {
-            groups.set(date, upperPowerEnvelope(samples, chartDefinition.chartType !== 'e2e'));
+            groups.set(
+              date,
+              upperPowerEnvelope(
+                samples,
+                chartDefinition.chartType !== 'e2e',
+                isPowerGaugeSeries(selectedYAxisMetric, samples[0]),
+              ),
+            );
           }
         }
         return groups;
       },
-      [showPowerEnvelope, chartDefinition.chartType],
+      [showPowerEnvelope, chartDefinition.chartType, selectedYAxisMetric],
     );
     const locale = useLocale();
+    const featureGateUnlocked = useFeatureGate();
+    const showPowerTelemetry =
+      featureGateUnlocked || getMeasuredMetricConfig(selectedYAxisMetric) !== undefined;
     const legendT = SCATTER_STRINGS[locale];
+    // Comparison series (`i_pcompare`) switched off from the legend. Chart-local,
+    // like Optimal Only's point set: the URL carries the comparison, not which
+    // of its rows a reader hid while looking.
+    const [hiddenPowerVariants, setHiddenPowerVariants] = useState<ReadonlySet<string>>(
+      () => new Set(),
+    );
     const ephemeralUrlState = useEphemeralUrlState();
     const costLimit = chartDefinition.y_cost_limit ?? 0;
     const latencyLimit = chartDefinition.y_latency_limit ?? 0;
@@ -801,7 +885,7 @@ const ScatterGraph = React.memo(
       () =>
         data.reduce(
           (acc, point) => {
-            const key = `${point.hwKey}_${point.precision}`;
+            const key = scatterSeriesKey(point);
             if (!acc[key]) acc[key] = [];
             acc[key].push(point);
             return acc;
@@ -938,7 +1022,7 @@ const ScatterGraph = React.memo(
       }
       const buckets = new Map<string, Bucket>();
       const getBucket = (point: InferenceData) => {
-        const key = `${point.hwKey}|${point.precision}|${point.date}`;
+        const key = `${scatterSeriesKey(point)}|${point.date}`;
         let bucket = buckets.get(key);
         if (!bucket) {
           bucket = {
@@ -987,7 +1071,7 @@ const ScatterGraph = React.memo(
       const buckets = new Map<string, Bucket>();
       const getBucket = (point: InferenceData) => {
         const runIndex = overlayRunIndex(point.run_url ?? null, runIndexByUrl);
-        const key = `${point.hwKey}|${point.precision}|${point.date}|run${runIndex}`;
+        const key = `${scatterSeriesKey(point)}|${point.date}|run${runIndex}`;
         let bucket = buckets.get(key);
         if (!bucket) {
           bucket = {
@@ -1092,6 +1176,8 @@ const ScatterGraph = React.memo(
       interface Entry {
         hwKey: string;
         runIndex: number;
+        /** Comparison variant id for boundary / role clones, null for the run's base series. */
+        variant: string | null;
         points: InferenceData[];
       }
       if (processedOverlayData.length === 0) return {} as Record<string, Entry>;
@@ -1100,8 +1186,15 @@ const ScatterGraph = React.memo(
       const grouped = processedOverlayData.reduce(
         (acc, p) => {
           const runIndex = overlayRunIndex(p.run_url ?? null, runIndexByUrl);
-          const key = `${p.hwKey}_${p.precision}_run${runIndex}`;
-          if (!acc[key]) acc[key] = { hwKey: String(p.hwKey), runIndex, points: [] };
+          const key = `${scatterSeriesKey(p)}_run${runIndex}`;
+          if (!acc[key]) {
+            acc[key] = {
+              hwKey: String(p.hwKey),
+              runIndex,
+              variant: p.powerVariant?.id ?? null,
+              points: [],
+            };
+          }
           acc[key].points.push(p);
           return acc;
         },
@@ -1180,9 +1273,11 @@ const ScatterGraph = React.memo(
     // its X marker sitting on the dashed roofline and read as a pareto point.
     const isOverlayPointVisible = useCallback(
       (d: InferenceData) =>
+        !hiddenPowerVariants.has(powerVariantId(d.powerVariant)) &&
         (!hideNonOptimal || overlayOptimalPoints.has(d)) &&
         (!showPowerEnvelope || showAllMeasurements || overlayEnvelopePoints.has(d)),
       [
+        hiddenPowerVariants,
         hideNonOptimal,
         overlayOptimalPoints,
         showPowerEnvelope,
@@ -1216,6 +1311,45 @@ const ScatterGraph = React.memo(
     );
     const { data: persistedLogAvailability } = useLogAvailability(persistedPointIds);
     const [fixedLogPointId, setFixedLogPointId] = useState<number | null>(null);
+    const [powerTelemetryPoint, setPowerTelemetryPoint] = useState<InferenceData | null>(null);
+
+    // "View power trace" on a pinned tooltip (official or overlay point): the
+    // same-tab click stays in-page — remember which trace to emphasise, switch
+    // the metric to the Timeline display, and let the anchor's href keep
+    // serving open-in-new-tab. Listeners are attached per pin because the
+    // tooltip HTML is replaced on every pin.
+    const attachPowerTraceAction = useCallback(
+      (tooltipEl: HTMLElement, d: InferenceData, overlay: boolean) => {
+        const action = tooltipEl.querySelector('[data-action="view-power-trace"]');
+        const traceKey = traceKeyForPoint(d);
+        if (!action || !traceKey) return;
+        action.addEventListener('click', (actionEvent) => {
+          actionEvent.stopPropagation();
+          // Modifier / auxiliary clicks keep the anchor's own behaviour: the
+          // href opens this chart's timeline in a new tab or window.
+          const mouse = actionEvent as MouseEvent;
+          if (
+            mouse.button !== 0 ||
+            mouse.metaKey ||
+            mouse.ctrlKey ||
+            mouse.shiftKey ||
+            mouse.altKey
+          ) {
+            return;
+          }
+          actionEvent.preventDefault();
+          requestPowerTraceFocus(traceKey);
+          chartRef.current?.dismissTooltip();
+          setSelectedYAxisMetric(POWER_TIMELINE_METRIC_KEY);
+          track('inference_power_trace_opened', {
+            hwKey: String(d.hwKey),
+            conc: d.conc,
+            overlay,
+          });
+        });
+      },
+      [setSelectedYAxisMetric],
+    );
 
     // --- Legend points table (per-series drill-down opened from the legend) ---
     const [pointsTableTarget, setPointsTableTarget] = useState<LegendPointsTarget | null>(null);
@@ -1251,6 +1385,7 @@ const ScatterGraph = React.memo(
         const pts = pointsData.filter(
           (p) =>
             p.hwKey === hwKey &&
+            !p.powerVariant &&
             selectedPrecisions.includes(p.precision) &&
             (!hideNonOptimal || optimalPointKeys.has(optimalPointKey(p))),
         );
@@ -1266,6 +1401,7 @@ const ScatterGraph = React.memo(
       const pts = processedOverlayData.filter(
         (p) =>
           overlayRunIndex(p.run_url ?? null, runIndexByUrl) === runIndex &&
+          !p.powerVariant &&
           activeOverlayHwTypes.has(p.hwKey as string) &&
           (!hideNonOptimal || overlayOptimalPoints.has(p)),
       );
@@ -1486,6 +1622,7 @@ const ScatterGraph = React.memo(
       (d: InferenceData) =>
         effectiveActiveHwTypes.has(d.hwKey as string) &&
         selectedPrecisions.includes(d.precision) &&
+        !hiddenPowerVariants.has(powerVariantId(d.powerVariant)) &&
         (!hideNonOptimal || optimalPointKeys.has(optimalPointKey(d))) &&
         (!showPowerEnvelope ||
           showAllMeasurements ||
@@ -1493,6 +1630,7 @@ const ScatterGraph = React.memo(
       [
         effectiveActiveHwTypes,
         selectedPrecisions,
+        hiddenPowerVariants,
         hideNonOptimal,
         optimalPointKeys,
         showPowerEnvelope,
@@ -1669,12 +1807,69 @@ const ScatterGraph = React.memo(
       getCssColor,
     ]);
 
+    // The comparison in effect and the base series' identity under it. The
+    // base is the selected metric's own series; deriving it from which variant
+    // no official point carries breaks when only an overlay carries the
+    // comparison, and line labels need the same answer as the legend rows.
+    const powerCompareMode = useMemo(() => {
+      const official = inferPowerCompare(pointsData);
+      return official === 'none' ? inferPowerCompare(processedOverlayData) : official;
+    }, [pointsData, processedOverlayData]);
+    const powerCompareBaseId = useMemo(
+      () => powerVariantId(powerCompareBase(selectedYAxisMetric, powerCompareMode)),
+      [selectedYAxisMetric, powerCompareMode],
+    );
+
+    // One legend row per comparison series present (base first). Rows toggle
+    // chart-local visibility and hover-highlight that series across hardware.
+    const powerVariantLegendItems = useMemo(() => {
+      const allPoints = [...pointsData, ...processedOverlayData];
+      const variants = powerVariantsInData(allPoints, selectedYAxisMetric);
+      const baseId = powerCompareBaseId;
+      return variants.map((variant) => {
+        const id = powerVariantId(variant);
+        const legendId = `${POWER_VARIANT_LEGEND_PREFIX}${id}`;
+        const isBase = id === baseId;
+        return {
+          name: legendId,
+          hw: legendId,
+          label: powerVariantLabel(variant, locale),
+          color: 'var(--foreground)',
+          // The base series is solid, like its points; siblings carry their dash.
+          lineDasharray: isBase ? '1 0' : powerVariantDash(variant) || '1 0',
+          isActive: !hiddenPowerVariants.has(isBase ? '' : id),
+          isRemovable: false,
+          onClick: () => {
+            const key = isBase ? '' : id;
+            setHiddenPowerVariants((prev) => {
+              const next = new Set(prev);
+              if (next.has(key)) next.delete(key);
+              else next.add(key);
+              return next;
+            });
+            track('inference_power_compare_series_toggled', {
+              series: id,
+              visible: hiddenPowerVariants.has(key),
+            });
+          },
+        };
+      });
+    }, [
+      pointsData,
+      processedOverlayData,
+      selectedYAxisMetric,
+      powerCompareBaseId,
+      locale,
+      hiddenPowerVariants,
+    ]);
+
     const powerTierCounts = useMemo(() => {
-      const officialTotal = pointsData.filter((point) =>
-        selectedPrecisions.includes(point.precision),
+      // Comparison clones re-plot the same measurements; count each once.
+      const officialTotal = pointsData.filter(
+        (point) => !point.powerVariant && selectedPrecisions.includes(point.precision),
       );
-      const overlayTotal = processedOverlayData.filter((point) =>
-        selectedPrecisions.includes(point.precision),
+      const overlayTotal = processedOverlayData.filter(
+        (point) => !point.powerVariant && selectedPrecisions.includes(point.precision),
       );
       const officialVisible = officialTotal.filter(isPointVisible);
       const overlayVisible = overlayTotal.filter(
@@ -1699,9 +1894,13 @@ const ScatterGraph = React.memo(
         const hw = el.dataset.hwKey;
         const prec = el.dataset.precision;
         if (hw === null || hw === undefined || prec === null || prec === undefined) return false;
-        return effectiveActiveHwTypes.has(hw) && selectedPrecisions.includes(prec);
+        return (
+          effectiveActiveHwTypes.has(hw) &&
+          selectedPrecisions.includes(prec) &&
+          !hiddenPowerVariants.has(el.dataset.powerVariant ?? '')
+        );
       },
-      [effectiveActiveHwTypes, selectedPrecisions],
+      [effectiveActiveHwTypes, selectedPrecisions, hiddenPowerVariants],
     );
 
     // --- Interaction state ref ---
@@ -1718,6 +1917,7 @@ const ScatterGraph = React.memo(
       isPointVisible,
       isOverlayPointVisible,
       effectiveActiveHwTypes,
+      hiddenPowerVariants,
       selectedPrecisions,
       activeOverlayHwTypes,
       getCssColor,
@@ -1725,11 +1925,13 @@ const ScatterGraph = React.memo(
       knownIssueAnnotations,
       traceAvailability,
       logAvailability: persistedLogAvailability,
+      showPowerTelemetry,
     });
     interactionRef.current = {
       isPointVisible,
       isOverlayPointVisible,
       effectiveActiveHwTypes,
+      hiddenPowerVariants,
       selectedPrecisions,
       activeOverlayHwTypes,
       getCssColor,
@@ -1737,6 +1939,7 @@ const ScatterGraph = React.memo(
       knownIssueAnnotations,
       traceAvailability,
       logAvailability: persistedLogAvailability,
+      showPowerTelemetry,
     };
 
     // --- Perf ruler (opt-in: click two curves, drag the ruler to any iso-x) ---
@@ -1748,17 +1951,39 @@ const ScatterGraph = React.memo(
     // the curves' rendered paths at the iso-x — neither end needs to be a
     // data point. Multiple rulers accumulate (capped in the pure module);
     // completing one immediately allows starting the next.
-    const [preferPerfRulerMode, setPerfRulerMode] = useState(false);
+    //
+    // The primary chart's rulers live in the InferenceProvider store so they
+    // ride along in share links (`i_rulers`) and survive a remount (table
+    // view toggle). Every other instance — the replay chart, which draws the
+    // same curve classes, and harnesses mounted without the provider — keeps
+    // component-local state. Both paths share one `[state, setState]` pair
+    // below, so the reducers, refs, and draw passes are path-agnostic.
+    const perfRulerStore = usePerfRulerStore();
+    const persistedRulers = perfRulerStore?.chartId === chartId ? perfRulerStore : undefined;
+    // Rulers only render while the mode is on (and the mode-off effect below
+    // clears them), so restored share-link rulers — pending or already
+    // committed by a previous mount — switch the mode on for this instance.
+    const [preferPerfRulerMode, setPerfRulerMode] = useState(
+      () =>
+        persistedRulers !== undefined &&
+        (persistedRulers.pending !== null || persistedRulers.state.rulers.length > 0),
+    );
     const perfRulerMode = preferPerfRulerMode && (!showPowerEnvelope || isMeasuredPowerAxis);
-    const [perfRulerState, setPerfRulerState] = useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
+    const [localPerfRulerState, setLocalPerfRulerState] =
+      useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
+    const perfRulerState = persistedRulers ? persistedRulers.state : localPerfRulerState;
+    const setPerfRulerState = persistedRulers ? persistedRulers.setState : setLocalPerfRulerState;
     // Changing the x- or y-axis metric (including the x percentile, which
     // `x_scale_field` encodes) clears every ruler: the curves are redrawn
     // in different units, so a ruler that persisted would measure a ratio
     // the user never placed. Runs before the draw pass so no stale ruler
-    // ever paints over the new curves.
+    // ever paints over the new curves. Render-time adjustment is only legal
+    // for this component's own state, so the hook targets the local state;
+    // the store applies the same reset to persisted rulers inside the
+    // provider (see usePerfRulerStoreValue).
     usePerfRulerAxisReset(
       perfRulerAxisMetricKey(chartDefinition.x_scale_field, selectedYAxisMetric),
-      setPerfRulerState,
+      setLocalPerfRulerState,
     );
     // Draw passes read mode/state through refs so toggling off clears the
     // rulers in the same pre-paint layout pass — lines/labels must never
@@ -1824,6 +2049,51 @@ const ScatterGraph = React.memo(
       [],
     );
 
+    // Share-link rulers commit only once BOTH curve paths are in the DOM —
+    // otherwise the prune pass would eat them before their data (i_gpus,
+    // comparison dates, overlay runs) has arrived. Hidden curves (opacity 0)
+    // count as present, like for prune. The iso-x is clamped to the pair's
+    // overlap through the drawn paths, so a rounded or since-shifted iso-x
+    // still renders; a pair with disjoint spans can never be measured on
+    // these axes and is dropped. This runs from the draw pass rather than a
+    // React effect: the chart first draws in a D3Chart-local re-render
+    // (dimensions are measured after mount), which re-renders nothing here,
+    // so an effect keyed on our props could miss the first draw and leave
+    // resolvable rulers pending for the rest of the session. The store is
+    // read through a ref for the same reason the draw passes read the ruler
+    // state through refs. Nothing commits while the mode is off (forced off
+    // by the power envelope, or switched off by the user) — the mode-off
+    // effect discards pending rulers, and the analytics event must not
+    // report a restore nobody saw. Draw passes can repeat before React has
+    // applied a commit, so the pending list handed over is remembered by
+    // identity and skipped until the store replaces it.
+    const persistedRulersRef = useRef(persistedRulers);
+    persistedRulersRef.current = persistedRulers;
+    const committedPendingRef = useRef<readonly PerfRulerMeasurement[] | null>(null);
+    const commitPendingPerfRulers = useCallback(
+      (zoomGroup: d3.Selection<SVGGElement, unknown, null, undefined>) => {
+        const store = persistedRulersRef.current;
+        const pending = store?.pending ?? null;
+        if (!store || !pending || !perfRulerModeRef.current) return;
+        if (committedPendingRef.current === pending) return;
+        const curveExists = (cls: string) => !zoomGroup.select(`.${CSS.escape(cls)}`).empty();
+        const resolved: PerfRulerMeasurement[] = [];
+        const remaining: PerfRulerMeasurement[] = [];
+        for (const ruler of pending) {
+          if (!curveExists(ruler.curveA) || !curveExists(ruler.curveB)) {
+            remaining.push(ruler);
+            continue;
+          }
+          const isoX = clampPerfRulerIsoXToOverlap(ruler.curveA, ruler.curveB, ruler.isoX);
+          if (isoX !== null) resolved.push({ ...ruler, isoX });
+        }
+        if (remaining.length === pending.length) return;
+        committedPendingRef.current = pending;
+        store.commitPending(resolved, remaining.length > 0 ? remaining : null);
+      },
+      [clampPerfRulerIsoXToOverlap],
+    );
+
     // Curve click (widened hit strokes): iso-x is the click's x pixel
     // through the CURRENT rendered x scale, stored in data space.
     const handlePerfRulerCurveClick = useCallback(
@@ -1852,7 +2122,7 @@ const ScatterGraph = React.memo(
       (point: InferenceData, source: 'official' | 'overlay') => {
         const ctx = perfRulerDrawCtxRef.current;
         if (!ctx) return;
-        const series = `${String(point.hwKey)}_${point.precision}`;
+        const series = scatterSeriesKey(point);
         const base =
           source === 'overlay'
             ? `overlay-roofline-${series}_run${overlayRunIndex(point.run_url ?? null, runIndexByUrl)}`
@@ -1882,8 +2152,12 @@ const ScatterGraph = React.memo(
     // the switch handler also clears synchronously, this covers
     // programmatic mode changes). `clearPerfRulers` bails out with the same
     // reference when there is nothing to clear.
+    // Share-link rulers still waiting for their curves go too — the user
+    // switched the tool off, so nothing should surface later.
     useEffect(() => {
-      if (!perfRulerMode) setPerfRulerState(clearPerfRulers);
+      if (perfRulerMode) return;
+      setPerfRulerState(clearPerfRulers);
+      persistedRulers?.discardPending();
     }, [perfRulerMode]);
 
     // Invisible widened hit strokes over every rendered roofline path
@@ -2033,6 +2307,7 @@ const ScatterGraph = React.memo(
       ) => {
         perfRulerDrawCtxRef.current = { zoomGroup, xScale, yScale, width, height };
         syncPerfRulerHitPaths(zoomGroup);
+        commitPendingPerfRulers(zoomGroup);
         const state = perfRulerStateRef.current;
         const entries: PerfRulerRenderEntry[] = [];
         if (perfRulerModeRef.current && state.rulers.length > 0) {
@@ -2086,7 +2361,7 @@ const ScatterGraph = React.memo(
         );
         if (!dragHandles.empty()) dragHandles.call(perfRulerDrag);
       },
-      [syncPerfRulerHitPaths, perfRulerDrag],
+      [syncPerfRulerHitPaths, commitPendingPerfRulers, perfRulerDrag],
     );
     drawPerfRulerRef.current = drawPerfRuler;
 
@@ -2120,16 +2395,29 @@ const ScatterGraph = React.memo(
         const svg = chartRef.current?.getSvgElement?.();
         if (!svg) return;
         const root = d3.select(svg);
+        // A comparison-series legend row highlights that boundary / role
+        // across every hardware instead of one hardware across series.
+        const variantId = hwKey.startsWith(POWER_VARIANT_LEGEND_PREFIX)
+          ? hwKey.slice(POWER_VARIANT_LEGEND_PREFIX.length)
+          : null;
+        const matchesPoint = (d: InferenceData) =>
+          variantId === null
+            ? String(d.hwKey) === hwKey
+            : powerVariantId(d.powerVariant) === variantId;
         root
           .selectAll<SVGGElement, InferenceData>('.dot-group')
           .style('opacity', (d) =>
-            isPointVisible(d) ? (String(d.hwKey) === hwKey ? 1 : 0.15) : 0,
+            isPointVisible(d) ? (matchesPoint(d) ? pointOpacityForVariant(d) : 0.15) : 0,
           );
         root
           .selectAll<SVGElement, unknown>('.roofline-path, .official-overflow-continuation')
           .style('opacity', function () {
             if (!isRooflineVisible(this)) return 0;
-            return this.dataset.hwKey === hwKey ? null : '0.15';
+            const matches =
+              variantId === null
+                ? this.dataset.hwKey === hwKey
+                : (this.dataset.powerVariant ?? '') === variantId;
+            return matches ? null : '0.15';
           });
         root
           .selectAll<SVGGElement, unknown>('.parallelism-label, .line-label')
@@ -2146,7 +2434,7 @@ const ScatterGraph = React.memo(
       const root = d3.select(svg);
       root
         .selectAll<SVGGElement, InferenceData>('.dot-group')
-        .style('opacity', (d) => (isPointVisible(d) ? 1 : 0));
+        .style('opacity', (d) => (isPointVisible(d) ? pointOpacityForVariant(d) : 0));
       root
         .selectAll<SVGElement, unknown>('.roofline-path, .official-overflow-continuation')
         .style('opacity', function () {
@@ -2159,9 +2447,16 @@ const ScatterGraph = React.memo(
             (this as SVGGElement).dataset,
             effectiveActiveHwTypes,
             selectedPrecisions,
+            activeOverlayHwTypes,
           );
         });
-    }, [isPointVisible, isRooflineVisible, effectiveActiveHwTypes, selectedPrecisions]);
+    }, [
+      isPointVisible,
+      isRooflineVisible,
+      effectiveActiveHwTypes,
+      selectedPrecisions,
+      activeOverlayHwTypes,
+    ]);
 
     // --- Zoom config ---
     const eventPrefix = chartDefinition.chartType === 'e2e' ? 'latency' : 'interactivity';
@@ -2230,6 +2525,7 @@ const ScatterGraph = React.memo(
             yLabel,
             selectedYAxisMetric,
             hardwareConfig,
+            showPowerTelemetry: interactionRef.current.showPowerTelemetry,
             runUrl: d.run_url ? updateRepoUrl(d.run_url) : undefined,
             hasTrace:
               d.benchmark_type === 'agentic_traces' && isPersistedBenchmarkId(d.id)
@@ -2291,6 +2587,15 @@ const ScatterGraph = React.memo(
               });
             });
           }
+          const powerBtn = tooltipEl.querySelector('[data-action="view-power-telemetry"]');
+          if (powerBtn && isPersistedBenchmarkId(d.id)) {
+            powerBtn.addEventListener('click', (event) => {
+              event.stopPropagation();
+              setPowerTelemetryPoint(d);
+              chartRef.current?.dismissTooltip();
+              track('inference_power_telemetry_opened', { id: d.id, hwKey: d.hwKey, conc: d.conc });
+            });
+          }
           const logsBtn = tooltipEl.querySelector('[data-action="view-logs"]');
           if (logsBtn && typeof d.id === 'number') {
             logsBtn.addEventListener('click', (btnEvent) => {
@@ -2308,10 +2613,12 @@ const ScatterGraph = React.memo(
               });
             });
           }
+          attachPowerTraceAction(tooltipEl, d, false);
         },
         attachToLayer: 1, // scatter layer is index 1 (after rooflines at 0)
       }),
       [
+        attachPowerTraceAction,
         xLabel,
         yLabel,
         selectedYAxisMetric,
@@ -2325,6 +2632,31 @@ const ScatterGraph = React.memo(
 
     // --- Layers ---
     const layers = useMemo((): LayerConfig<InferenceData>[] => {
+      // Line-label identity of one drawn series under a power comparison
+      // (`i_pcompare`): the base series keeps the hardware key, so pinned
+      // anchors and hover hooks keep working; a sibling is `<hw>::<variant>`.
+      const wattsAxis = metricPlotsWatts(selectedYAxisMetric);
+      const lineLabelIdentity = (hw: string, points: readonly InferenceData[]) => {
+        const variant = points[0]?.powerVariant;
+        const variantId = powerVariantId(variant);
+        const isBase = !variant || variantId === powerCompareBaseId;
+        return { variant, variantId, isBase, seriesId: lineLabelSeriesId(hw, variant, isBase) };
+      };
+      // A sibling's label says which series it is; a flat provisioned boundary
+      // (TDP, all-in) on a watts axis also states its value.
+      const lineLabelSuffix = (
+        identity: ReturnType<typeof lineLabelIdentity>,
+        points: readonly InferenceData[],
+      ) =>
+        powerLineLabelSuffix(identity.variant, {
+          isBase: identity.isBase,
+          locale,
+          flatWatts:
+            !identity.isBase && wattsAxis && identity.variant?.kind === 'basis'
+              ? flatSeriesValue(points.map((point) => point.y))
+              : null,
+        });
+
       // ── Layer 0: Rooflines + gradient labels (custom) ──
       const rooflineLayer: CustomLayerConfig = {
         type: 'custom',
@@ -2362,6 +2694,8 @@ const ScatterGraph = React.memo(
             key: string;
             hw: string;
             precision: string;
+            /** Comparison variant id (`i_pcompare`), '' for the base series. */
+            variant: string;
             points: InferenceData[];
             stroke: string;
             visible: boolean;
@@ -2370,10 +2704,11 @@ const ScatterGraph = React.memo(
           const activeGradientIds = new Set<string>();
 
           Object.entries(displayedRooflines).forEach(([key, pts]) => {
-            const hw = key.split('_').slice(0, -1).join('_');
-            const precision = key.split('_').pop()!;
+            const { hw, precision, variant } = parseScatterSeriesKey(key);
             const visible =
-              ir.effectiveActiveHwTypes.has(hw) && ir.selectedPrecisions.includes(precision);
+              ir.effectiveActiveHwTypes.has(hw) &&
+              ir.selectedPrecisions.includes(precision) &&
+              !ir.hiddenPowerVariants.has(variant ?? '');
             const baseStroke = ir.getCssColor(ir.resolveColor(hw));
 
             // Split into per-date sub-paths so the line never crosses dates.
@@ -2417,6 +2752,7 @@ const ScatterGraph = React.memo(
                 key: entryKey,
                 hw,
                 precision,
+                variant: variant ?? '',
                 points: datePoints,
                 stroke,
                 visible,
@@ -2444,9 +2780,12 @@ const ScatterGraph = React.memo(
             .attr('data-curve-kind', showPowerEnvelope ? 'power-envelope' : 'pareto')
             .attr('data-hw-key', (d) => d.hw)
             .attr('data-precision', (d) => d.precision)
+            .attr('data-power-variant', (d) => d.variant || null)
             .attr('fill', 'none')
             .attr('stroke', (d) => d.stroke)
             .attr('stroke-width', 2.5)
+            // Comparison siblings share the hardware colour; the dash tells them apart.
+            .attr('stroke-dasharray', (d) => powerVariantDashById(d.variant) || null)
             .attr('d', (d) => lineGen(d.points))
             .style('transition', 'opacity 150ms ease')
             .style('opacity', (d) => (d.visible ? 1 : 0));
@@ -2467,10 +2806,11 @@ const ScatterGraph = React.memo(
           if (showGradientLabels) {
             Object.entries(allPointLabelsByKey).forEach(([key, pointLabels]) => {
               if (pointLabels.length < 2) return;
-              const hw = key.split('_').slice(0, -1).join('_');
-              const precision = key.split('_').pop()!;
+              const { hw, precision, variant } = parseScatterSeriesKey(key);
               const visible =
-                ir.effectiveActiveHwTypes.has(hw) && ir.selectedPrecisions.includes(precision);
+                ir.effectiveActiveHwTypes.has(hw) &&
+                ir.selectedPrecisions.includes(precision) &&
+                !ir.hiddenPowerVariants.has(variant ?? '');
 
               const segments: { label: string; color: string; points: InferenceData[] }[] = [];
               let cur = {
@@ -2568,12 +2908,22 @@ const ScatterGraph = React.memo(
 
           // ── Line labels (run name along each roofline) ──
           let lineLabels: LineLabelPlacement[] = [];
+          // Comparison variant and label suffix per label key, for the text
+          // segments and the `data-power-variant` hook on each pill.
+          const lineLabelMeta = new Map<
+            string,
+            { variantId: string; suffix: string; runTag: string }
+          >();
           if (showLineLabels) {
             const multiPrecision = ir.selectedPrecisions.length > 1;
             const officialByGroup = new Map<string, (typeof entries)[number]>();
             for (const entry of entries) {
               if (!entry.visible) continue;
-              const groupKey = multiPrecision ? entry.key : entry.hw;
+              // One label per hardware and, under a power comparison, per
+              // sibling series: the measured line and its boundary / pool
+              // lines each say which one they are, instead of the longest
+              // line taking the hardware's only label.
+              const groupKey = multiPrecision ? entry.key : `${entry.hw}::${entry.variant}`;
               const previous = officialByGroup.get(groupKey);
               if (!previous || entry.points.length > previous.points.length) {
                 officialByGroup.set(groupKey, entry);
@@ -2582,39 +2932,58 @@ const ScatterGraph = React.memo(
 
             const officialSeries: LineLabelSeries<InferenceData>[] = [
               ...officialByGroup.values(),
-            ].map((entry) => ({
-              key: entry.key,
-              seriesId: entry.hw,
-              label: lineLabelText(
-                entry.hw,
-                entry.precision,
-                multiPrecision,
-                modelLabel,
-                entry.points,
-              ),
-              color: ir.getCssColor(ir.resolveColor(entry.hw)),
-              points: entry.points,
-              keepVisibleOnCollision: entry.points.length === 1,
-            }));
+            ].map((entry) => {
+              const identity = lineLabelIdentity(entry.hw, entry.points);
+              const suffix = lineLabelSuffix(identity, entry.points);
+              lineLabelMeta.set(entry.key, { variantId: identity.variantId, suffix, runTag: '' });
+              return {
+                key: entry.key,
+                seriesId: identity.seriesId,
+                label: `${lineLabelText(
+                  entry.hw,
+                  entry.precision,
+                  multiPrecision,
+                  modelLabel,
+                  entry.points,
+                )}${suffix}`,
+                color: ir.getCssColor(ir.resolveColor(entry.hw)),
+                points: entry.points,
+              };
+            });
+            // Runs drawing the same hardware need a run tag on their pills.
+            const overlayRunsByHw = new Map<string, Set<number>>();
+            for (const group of Object.values(displayedOverlayRooflines)) {
+              if (!ir.activeOverlayHwTypes.has(group.hwKey)) continue;
+              if (!overlayRunsByHw.has(group.hwKey)) overlayRunsByHw.set(group.hwKey, new Set());
+              overlayRunsByHw.get(group.hwKey)!.add(group.runIndex);
+            }
             const overlaySeries: LineLabelSeries<InferenceData>[] = Object.entries(
               displayedOverlayRooflines,
             ).flatMap(([overlayKey, group]) => {
               if (!ir.activeOverlayHwTypes.has(group.hwKey)) return [];
               const info = unofficialRunInfos[group.runIndex];
               const precision = group.points[0]?.precision ?? '';
-              const runLabel = info
-                ? getInferenceRunLabel(`✕ ${info.branch || `run ${info.id}`}`, group.points)
-                : '';
+              const hardwareLabel = lineLabelText(
+                group.hwKey,
+                precision,
+                multiPrecision,
+                modelLabel,
+                group.points,
+              );
+              const sharesHardware = (overlayRunsByHw.get(group.hwKey)?.size ?? 0) > 1;
+              const runTag = info && sharesHardware ? overlayRunTag(info) : '';
               const label = info
-                ? multiPrecision
-                  ? `${runLabel} ${getPrecisionLabel(precision as Precision)}`
-                  : runLabel
-                : lineLabelText(group.hwKey, precision, multiPrecision, modelLabel, group.points);
+                ? getOverlayLineLabel(hardwareLabel, info, sharesHardware)
+                : hardwareLabel;
+              const identity = lineLabelIdentity(group.hwKey, group.points);
+              const suffix = lineLabelSuffix(identity, group.points);
+              const key = `overlay-${overlayKey}`;
+              lineLabelMeta.set(key, { variantId: identity.variantId, suffix, runTag });
               return [
                 {
-                  key: `overlay-${overlayKey}`,
-                  seriesId: group.hwKey,
-                  label,
+                  key,
+                  seriesId: identity.seriesId,
+                  label: `${label}${suffix}`,
                   color: overlayRunColor(group.runIndex),
                   points: group.points,
                 },
@@ -2637,16 +3006,19 @@ const ScatterGraph = React.memo(
             const labeledKeys = new Set(lineLabels.map((label) => label.key));
             for (const entry of entries) {
               if (labeledKeys.has(entry.key)) continue;
+              const identity = lineLabelIdentity(entry.hw, entry.points);
+              const suffix = lineLabelSuffix(identity, entry.points);
+              lineLabelMeta.set(entry.key, { variantId: identity.variantId, suffix, runTag: '' });
               lineLabels.push({
                 key: entry.key,
-                seriesId: entry.hw,
-                label: lineLabelText(
+                seriesId: identity.seriesId,
+                label: `${lineLabelText(
                   entry.hw,
                   entry.precision,
                   multiPrecision,
                   modelLabel,
                   entry.points,
-                ),
+                )}${suffix}`,
                 color: ir.getCssColor(ir.resolveColor(entry.hw)),
                 x: xScale(entry.points[0].x),
                 y: yScale(entry.points[0].y),
@@ -2663,20 +3035,35 @@ const ScatterGraph = React.memo(
           }
 
           renderLineLabels(zoomGroup, lineLabels, {
-            seriesAttribute: 'data-hw-key',
-            iconFor: (label) => getLineLabelVendorIcon(label.seriesId),
+            seriesAttribute: 'data-series-id',
+            iconFor: (label) => getLineLabelVendorIcon(lineLabelHardwareKey(label.seriesId)),
             configureGroup: (labelGroup, label) => {
               labelGroup
                 .attr('data-visible', label.visible ? '1' : '0')
+                // Legend hover and filter sync key labels by hardware alone;
+                // the variant names the comparison sibling ('' for the base).
+                .attr('data-hw-key', lineLabelHardwareKey(label.seriesId))
+                .attr('data-power-variant', lineLabelMeta.get(label.key)?.variantId ?? '')
                 .select('.ll-bg')
                 .attr('opacity', 0.95);
             },
             configureText: (text, label) => {
-              const config = getHardwareConfig(label.seriesId, modelLabel);
+              const config = getHardwareConfig(lineLabelHardwareKey(label.seriesId), modelLabel);
+              // Parse the hardware part without the variant suffix, which gets
+              // its own segment so the engine is still matched at the end.
+              const meta = lineLabelMeta.get(label.key);
+              const suffix = meta?.suffix ?? '';
+              const runTag = meta?.runTag ?? '';
+              let coreLabel = suffix ? label.label.slice(0, -suffix.length) : label.label;
+              if (runTag) coreLabel = coreLabel.slice(0, -runTag.length);
+              // Overlay pills lead with the run marker; the hardware behind it is
+              // parsed like an official pill so the GPU name stays bold.
+              const marker = coreLabel.startsWith(OVERLAY_LABEL_MARKER) ? OVERLAY_LABEL_MARKER : '';
+              coreLabel = coreLabel.slice(marker.length);
               const hardwareLabel = getDisplayLabel(config);
               const isHardwareLabel =
-                label.label === hardwareLabel || label.label.startsWith(`${config.label} `);
-              const remainingLabel = isHardwareLabel ? label.label.slice(config.label.length) : '';
+                coreLabel === hardwareLabel || coreLabel.startsWith(`${config.label} `);
+              const remainingLabel = isHardwareLabel ? coreLabel.slice(config.label.length) : '';
               // Use this curve's resolved suffix, not the generic hwKey label:
               // official and overlay curves can share a key but differ by run.
               const engineLabel =
@@ -2686,8 +3073,18 @@ const ScatterGraph = React.memo(
                 engineLabel && remainingLabel.endsWith(engineLabel)
                   ? remainingLabel.slice(0, -engineLabel.length)
                   : remainingLabel;
+              const markerSegments = marker
+                ? [{ className: 'll-marker', text: marker, fill: 'white', weight: '600' }]
+                : [];
+              const runSegments = runTag
+                ? [{ className: 'll-run', text: runTag, fill: '#d1d5db', weight: '400' }]
+                : [];
+              const variantSegments = suffix
+                ? [{ className: 'll-variant', text: suffix, fill: 'white', weight: '500' }]
+                : [];
               const segments = isHardwareLabel
                 ? [
+                    ...markerSegments,
                     { className: 'll-gpu', text: config.label, fill: 'white', weight: '700' },
                     ...(precisionLabel
                       ? [
@@ -2709,14 +3106,19 @@ const ScatterGraph = React.memo(
                           },
                         ]
                       : []),
+                    ...runSegments,
+                    ...variantSegments,
                   ]
                 : [
+                    ...markerSegments,
                     {
                       className: 'll-plain',
-                      text: label.label,
+                      text: coreLabel,
                       fill: 'white',
                       weight: '600',
                     },
+                    ...runSegments,
+                    ...variantSegments,
                   ];
               text
                 .selectAll<SVGTSpanElement, (typeof segments)[number]>('tspan')
@@ -2725,7 +3127,24 @@ const ScatterGraph = React.memo(
                 .attr('class', (segment) => segment.className)
                 .attr('fill', (segment) => segment.fill)
                 .attr('font-weight', (segment) => segment.weight)
+                .attr('x', null)
+                .attr('dy', null)
                 .text((segment) => segment.text);
+              // Keep the framework and role visible when a pill is wider than
+              // the mobile plot, without shrinking its text or dropping fields.
+              const textX = Number(text.attr('x') ?? 0);
+              const maxLineWidth = ctx.width - textX - 10;
+              let lineWidth = 0;
+              text.selectAll<SVGTSpanElement, unknown>('tspan').each(function () {
+                const width = this.getComputedTextLength();
+                if (lineWidth > 0 && lineWidth + width > maxLineWidth) {
+                  d3.select(this)
+                    .attr('x', textX)
+                    .attr('dy', CHART_TYPE.lineLabel + 3);
+                  lineWidth = 0;
+                }
+                lineWidth += width;
+              });
             },
           });
           // Labels can be joined independently of the Pareto display pass.
@@ -2826,11 +3245,11 @@ const ScatterGraph = React.memo(
               { key: string; seriesId: string; points: InferenceData[] }
             >();
             for (const [key, points] of Object.entries(displayedRooflines)) {
-              const hardware = key.split('_').slice(0, -1).join('_');
-              const precision = key.split('_').pop()!;
+              const { hw: hardware, precision, variant } = parseScatterSeriesKey(key);
               if (
                 !ir.effectiveActiveHwTypes.has(hardware) ||
-                !ir.selectedPrecisions.includes(precision)
+                !ir.selectedPrecisions.includes(precision) ||
+                ir.hiddenPowerVariants.has(variant ?? '')
               ) {
                 continue;
               }
@@ -2838,12 +3257,12 @@ const ScatterGraph = React.memo(
               const singleDate = pointsByDate.size === 1;
               for (const [date, datePoints] of pointsByDate) {
                 const entryKey = singleDate ? key : `${key}__${encodeURIComponent(date)}`;
-                const groupKey = multiPrecision ? entryKey : hardware;
+                const groupKey = multiPrecision ? entryKey : `${hardware}::${variant ?? ''}`;
                 const previous = bestByGroup.get(groupKey);
                 if (!previous || datePoints.length > previous.points.length) {
                   bestByGroup.set(groupKey, {
                     key: entryKey,
-                    seriesId: hardware,
+                    seriesId: lineLabelIdentity(hardware, datePoints).seriesId,
                     points: datePoints,
                   });
                 }
@@ -2854,7 +3273,6 @@ const ScatterGraph = React.memo(
                 ...entry,
                 label: '',
                 color: '',
-                keepVisibleOnCollision: entry.points.length === 1,
               }),
             );
             const overlaySeries: LineLabelSeries<InferenceData>[] = Object.entries(
@@ -2864,7 +3282,7 @@ const ScatterGraph = React.memo(
                 ? [
                     {
                       key: `overlay-${overlayKey}`,
-                      seriesId: group.hwKey,
+                      seriesId: lineLabelIdentity(group.hwKey, group.points).seriesId,
                       label: '',
                       color: '',
                       points: group.points,
@@ -2898,7 +3316,8 @@ const ScatterGraph = React.memo(
             interactionRef.current.getCssColor(
               interactionRef.current.resolveColor(d.hwKey as string),
             ),
-          getOpacity: (d) => (interactionRef.current.isPointVisible(d) ? 1 : 0),
+          getOpacity: (d) =>
+            interactionRef.current.isPointVisible(d) ? pointOpacityForVariant(d) : 0,
           getPointerEvents: (d) => (interactionRef.current.isPointVisible(d) ? 'auto' : 'none'),
           hideLabels: !showPointLabels || showGradientLabels,
           // Concurrency (C=) is appended only when the advanced
@@ -2908,6 +3327,7 @@ const ScatterGraph = React.memo(
           dataAttrs: {
             'hw-key': (d) => String(d.hwKey),
             precision: (d) => d.precision,
+            'power-variant': (d) => d.powerVariant?.id ?? '',
             // Lets the agentic coach mark pick an anchor out of the DOM
             // without knowing anything about React state.
             'benchmark-type': (d) => d.benchmark_type ?? '',
@@ -2986,6 +3406,7 @@ const ScatterGraph = React.memo(
                 points: InferenceData[];
                 stroke: string;
                 runIndex: number;
+                variant: string | null;
               }
               const ovEntries: OvEntry[] = [];
               Object.entries(displayedOverlayRooflines).forEach(([key, group]) => {
@@ -2997,6 +3418,7 @@ const ScatterGraph = React.memo(
                     // Color by run — same palette entry the legend uses, so they match.
                     stroke: overlayRunColor(group.runIndex),
                     runIndex: group.runIndex,
+                    variant: group.variant,
                   });
                 }
               });
@@ -3014,9 +3436,21 @@ const ScatterGraph = React.memo(
                 .attr('fill', 'none')
                 .attr('stroke', (d) => d.stroke)
                 .attr('stroke-width', 2)
-                .attr('stroke-dasharray', (d) => overlayRooflineDasharray(d.runIndex))
+                .attr('data-power-variant', (d) => d.variant)
+                // The run keeps its colour; a comparison sibling takes the
+                // variant dash so it reads like its official counterpart.
+                .attr('stroke-dasharray', (d) =>
+                  d.variant
+                    ? powerVariantDashById(d.variant)
+                    : overlayRooflineDasharray(d.runIndex),
+                )
                 .attr('d', (d) => lineGen(d.points))
-                .style('filter', null);
+                .style('filter', null)
+                // Comparison rows hidden from the legend (the decoration effect
+                // keeps this in step with later toggles).
+                .style('opacity', (d) =>
+                  interactionRef.current.hiddenPowerVariants.has(d.variant ?? '') ? 0 : null,
+                );
 
               // Overlay X-shape points — index-keyed so every point renders
               const overlayPoints = zoomGroup
@@ -3052,7 +3486,7 @@ const ScatterGraph = React.memo(
               overlayPoints.each(function (d) {
                 const visible = interactionRef.current.isOverlayPointVisible(d);
                 d3.select(this)
-                  .style('opacity', visible ? 1 : 0)
+                  .style('opacity', visible ? pointOpacityForVariant(d) : 0)
                   .style('pointer-events', visible ? 'auto' : 'none');
               });
               overlayPoints
@@ -3136,6 +3570,9 @@ const ScatterGraph = React.memo(
                     y: point.y,
                     overlay: true,
                   });
+                  // The shared helper has just rendered the pinned content into
+                  // this element and pinned it via `handle`.
+                  attachPowerTraceAction(ctx.tooltipElement, point, true);
                 },
               });
             },
@@ -3406,10 +3843,12 @@ const ScatterGraph = React.memo(
       xLabel,
       yLabel,
       selectedYAxisMetric,
+      powerCompareBaseId,
       isMeasuredEnergyAxis,
       chartDefinition,
       locale,
       drawPerfRuler,
+      attachPowerTraceAction,
     ]);
 
     // Layers handle for the decoration effect — lets it re-run individual
@@ -3488,7 +3927,9 @@ const ScatterGraph = React.memo(
       zoomGroup.selectAll<SVGGElement, InferenceData>('.dot-group').each(function (d) {
         const point = d3.select(this);
         const visible = ir.isPointVisible(d);
-        point.style('opacity', visible ? 1 : 0).style('pointer-events', visible ? 'auto' : 'none');
+        point
+          .style('opacity', visible ? pointOpacityForVariant(d) : 0)
+          .style('pointer-events', visible ? 'auto' : 'none');
         const color =
           (showGradientLabels && gradientColorByPoint.get(d)) ||
           ir.getCssColor(ir.resolveColor(d.hwKey as string));
@@ -3507,9 +3948,20 @@ const ScatterGraph = React.memo(
       zoomGroup.selectAll<SVGGElement, InferenceData>('.unofficial-overlay-pt').each(function (d) {
         const visible = ir.isOverlayPointVisible(d);
         d3.select(this)
-          .style('opacity', visible ? 1 : 0)
+          .style('opacity', visible ? pointOpacityForVariant(d) : 0)
           .style('pointer-events', visible ? 'auto' : 'none');
       });
+      // Overlay rooflines are only drawn for active overlay hardware; a
+      // comparison row hidden from the legend is the one visibility toggle
+      // they answer to here.
+      zoomGroup.selectAll<SVGPathElement, unknown>('.overlay-roofline-path').each(function () {
+        const roofline = d3.select(this);
+        if (ir.hiddenPowerVariants.has(this.dataset.powerVariant ?? '')) {
+          roofline.style('opacity', 0);
+        } else {
+          roofline.style('opacity', null);
+        }
+      });
 
       // Rooflines: visibility and solid-stroke recolor as direct writes. Keep
       // gradient url references intact and never touch animated path geometry.
@@ -3519,7 +3971,9 @@ const ScatterGraph = React.memo(
         if (!hw || !precision) return;
         const roofline = d3.select(this);
         const visible =
-          ir.effectiveActiveHwTypes.has(hw) && ir.selectedPrecisions.includes(precision);
+          ir.effectiveActiveHwTypes.has(hw) &&
+          ir.selectedPrecisions.includes(precision) &&
+          !ir.hiddenPowerVariants.has(this.dataset.powerVariant ?? '');
         roofline.style('opacity', visible ? 1 : 0);
         const stroke = roofline.attr('stroke');
         if (stroke && !stroke.startsWith('url(')) {
@@ -3553,6 +4007,7 @@ const ScatterGraph = React.memo(
             (this as SVGGElement).dataset,
             ir.effectiveActiveHwTypes,
             ir.selectedPrecisions,
+            ir.activeOverlayHwTypes,
           );
         });
     }, [
@@ -3711,7 +4166,9 @@ const ScatterGraph = React.memo(
       // brings a hidden ruler back); curves whose paths left the DOM
       // entirely are truly gone from the data, so prune each ruler (and the
       // draft) that references one. `prunePerfRulers` bails out with the
-      // same reference when nothing changed.
+      // same reference when nothing changed. Share-link rulers still
+      // pending are not state yet, so prune cannot touch them; drawPerfRuler
+      // above committed those whose curves now exist.
       setPerfRulerState((prev) =>
         prunePerfRulers(prev, (cls) => !display.zoomGroup.select(`.${CSS.escape(cls)}`).empty()),
       );
@@ -3973,6 +4430,9 @@ const ScatterGraph = React.memo(
                         )
                       : null,
                   })),
+                // Comparison series (`i_pcompare`): one dash-swatch row per
+                // boundary / role, toggling that series across every hardware.
+                ...powerVariantLegendItems,
               ]}
               disableActiveSort={false}
               isLegendExpanded={isLegendExpanded}
@@ -4126,7 +4586,10 @@ const ScatterGraph = React.memo(
                           // the pre-paint decoration effect then removes the rulers
                           // and the curve hit strokes before the next frame (no
                           // lingering lines after toggle-off).
-                          if (!checked) setPerfRulerState(clearPerfRulers);
+                          if (!checked) {
+                            setPerfRulerState(clearPerfRulers);
+                            persistedRulers?.discardPending();
+                          }
                           track('latency_perf_ruler_toggled', { enabled: checked });
                         },
                       },
@@ -4174,6 +4637,7 @@ const ScatterGraph = React.memo(
                             count: perfRulerState.rulers.length,
                           });
                           setPerfRulerState(clearPerfRulers);
+                          persistedRulers?.discardPending();
                         },
                       },
                     ]
@@ -4226,6 +4690,15 @@ const ScatterGraph = React.memo(
             }
           />
         )}
+        {powerTelemetryPoint === null ? null : (
+          <PowerTelemetryDialog
+            key={powerTelemetryPoint.id}
+            point={powerTelemetryPoint}
+            onOpenChange={(open) => {
+              if (!open) setPowerTelemetryPoint(null);
+            }}
+          />
+        )}
         {fixedLogPointId === null ? null : (
           <FixedSequenceLogDialog
             pointId={fixedLogPointId}
diff --git a/packages/app/src/components/inference/ui/inference-table-sort.ts b/packages/app/src/components/inference/ui/inference-table-sort.ts
index d9eb9b8bf..112ec5062 100644
--- a/packages/app/src/components/inference/ui/inference-table-sort.ts
+++ b/packages/app/src/components/inference/ui/inference-table-sort.ts
@@ -25,8 +25,8 @@ export function sortRowsByYMetric(
   const yAscending = rooflineDir?.startsWith('lower');
 
   return [...data].toSorted((a, b) => {
-    const ay = getNestedYValue(a, yPath);
-    const by = getNestedYValue(b, yPath);
+    const ay = a.powerVariant ? a.y : getNestedYValue(a, yPath);
+    const by = b.powerVariant ? b.y : getNestedYValue(b, yPath);
     return yAscending ? ay - by : by - ay;
   });
 }
diff --git a/packages/app/src/components/inference/ui/line-label-layer.test.ts b/packages/app/src/components/inference/ui/line-label-layer.test.ts
index 33bb77256..e3eda7273 100644
--- a/packages/app/src/components/inference/ui/line-label-layer.test.ts
+++ b/packages/app/src/components/inference/ui/line-label-layer.test.ts
@@ -14,17 +14,12 @@ interface Point {
   y: number;
 }
 
-const series = (
-  key: string,
-  points: Point[],
-  keepVisibleOnCollision = false,
-): LineLabelSeries<Point> => ({
+const series = (key: string, points: Point[]): LineLabelSeries<Point> => ({
   key,
   seriesId: key,
   label: key,
   color: '#000',
   points,
-  keepVisibleOnCollision,
 });
 
 const identity = (value: number) => value;
diff --git a/packages/app/src/components/inference/ui/line-label-layer.ts b/packages/app/src/components/inference/ui/line-label-layer.ts
index 6da0a7a23..a3b635dfa 100644
--- a/packages/app/src/components/inference/ui/line-label-layer.ts
+++ b/packages/app/src/components/inference/ui/line-label-layer.ts
@@ -16,7 +16,6 @@ export interface LineLabelSeries<TPoint extends CartesianPoint> {
   label: string;
   color: string;
   points: readonly TPoint[];
-  keepVisibleOnCollision?: boolean;
 }
 
 export interface LineLabelPlacement {
@@ -26,6 +25,12 @@ export interface LineLabelPlacement {
   color: string;
   x: number;
   y: number;
+  /**
+   * `placeLineLabels` always emits `true`: every series it is given keeps its
+   * pill, overlapping if it must. The only producer of `false` is the caller's
+   * de-duplication pass, which keeps a hidden data-join entry for a curve that
+   * lost the one-label-per-hardware contest (GH #470).
+   */
   visible: boolean;
 }
 
@@ -146,16 +151,16 @@ interface PillLayoutItem {
  * its anchor, and both mirrors together. Every candidate is clamped into
  * `bounds` before the overlap test, so nothing leaves the plot. When every
  * mirrored candidate collides, nearby rows are tried before the default spot
- * is kept: an overlapped label is still
- * better than a missing one, and the fallback matches what the anchor pass
- * already tolerates for pinned anchors.
+ * is kept: an overlapped label is still better than a missing one, and the
+ * fallback matches what the anchor pass already tolerates.
  *
  * With no bounds — a chart that clips nothing — the anchor offset is applied
  * unchanged and the collision pass is skipped, preserving that chart's
  * existing layout.
  *
  * Hidden pills get their default transform and occupy no space, so a label
- * that later becomes visible reappears where the anchor pass put it.
+ * that later becomes visible reappears where the anchor pass put it. Only the
+ * caller's de-duplication pass hides pills; the anchor pass never does.
  */
 function layoutPills(
   items: readonly PillLayoutItem[],
@@ -319,6 +324,21 @@ function lineCandidates<TPoint extends CartesianPoint>(
   return candidates;
 }
 
+/**
+ * Anchor one pill per series along its line.
+ *
+ * Each series tries `ANCHOR_SLOTS` fractions along its own points, rotated by
+ * its index so converging curves spread out instead of stacking at the
+ * endpoint. A series that finds a clear slot takes it. A series that finds none
+ * is deferred and placed afterwards on its least crowded slot, so it never
+ * steals a clear slot from a series that could have used it.
+ *
+ * Every series gets a visible pill. The overlap that survives here is resolved
+ * by `layoutPills`, which runs later with the pills' real measured boxes; the
+ * crude nominal box used here is far too small to decide that a label is
+ * unplaceable — a rendered pill is routinely two to three times
+ * `collisionWidth`.
+ */
 export function placeLineLabels<TPoint extends CartesianPoint>(
   series: readonly LineLabelSeries<TPoint>[],
   xScale: (value: number) => number,
@@ -346,6 +366,35 @@ export function placeLineLabels<TPoint extends CartesianPoint>(
         Math.abs(other.y - y) < collisionHeight &&
         Math.abs(other.x - x) < other.halfW + labelHalfWidth,
     );
+  /**
+   * Nominal overlap area against the labels already placed. The same crude box
+   * model as `collides`, scored instead of thresholded, so a slot that clips one
+   * neighbour is preferred over one that sits on three.
+   */
+  const collisionCost = (x: number, y: number) =>
+    placed.reduce((cost, other) => {
+      const dx = other.halfW + labelHalfWidth - Math.abs(other.x - x);
+      const dy = collisionHeight - Math.abs(other.y - y);
+      return dx > 0 && dy > 0 ? cost + dx * dy : cost;
+    }, 0);
+
+  const emit = (entry: LineLabelSeries<TPoint>, point: TPoint) => {
+    const x = xScale(point.x);
+    const y = yScale(point.y);
+    placed.push({ x, y, halfW: labelHalfWidth });
+    result.push({
+      key: entry.key,
+      seriesId: entry.seriesId,
+      label: entry.label,
+      color: entry.color,
+      x,
+      y,
+      visible: true,
+    });
+  };
+
+  /** Series with no clear slot, deferred to a second pass — see below. */
+  const crowded: { entry: LineLabelSeries<TPoint>; candidates: TPoint[] }[] = [];
 
   for (const [seriesIndex, entry] of sorted.entries()) {
     if (entry.points.length === 0) continue;
@@ -376,35 +425,37 @@ export function placeLineLabels<TPoint extends CartesianPoint>(
 
     const candidate = candidates.find((point) => !collides(xScale(point.x), yScale(point.y)));
     if (candidate) {
-      const x = xScale(candidate.x);
-      const y = yScale(candidate.y);
-      placed.push({ x, y, halfW: labelHalfWidth });
-      result.push({
-        key: entry.key,
-        seriesId: entry.seriesId,
-        label: entry.label,
-        color: entry.color,
-        x,
-        y,
-        visible: true,
-      });
+      emit(entry, candidate);
       continue;
     }
 
-    const fallback = entry.points[0];
-    const x = xScale(fallback.x);
-    const y = yScale(fallback.y);
-    const visible = entry.keepVisibleOnCollision === true;
-    if (visible) placed.push({ x, y, halfW: labelHalfWidth });
-    result.push({
-      key: entry.key,
-      seriesId: entry.seriesId,
-      label: entry.label,
-      color: entry.color,
-      x,
-      y,
-      visible,
-    });
+    // No clear slot. Defer rather than claim one now: a series that is going to
+    // overlap something must not take a slot a later series could have had to
+    // itself.
+    crowded.push({ entry, candidates });
+  }
+
+  // Every series keeps a pill. `layoutPills` runs after this with the real
+  // measured boxes and can still mirror it, shift it a row and clamp it into the
+  // plot — "an overlapped label is still better than a missing one". Emitting the
+  // crowded ones last also hands that pass the clean labels first, so the crowded
+  // ones do the moving.
+  //
+  // This is where the chart stopped promising that line labels never overlap
+  // (#132 introduced the drop as the only way to honour that, #434 restated it).
+  // The promise was worth less than it cost: a dropped pill is silent, and with
+  // line labels on, PNG export omits the legend, so the series loses its only
+  // identifier. An overlapping pill at least announces itself.
+  for (const { entry, candidates } of crowded) {
+    emit(
+      entry,
+      candidates.reduce((best, point) =>
+        collisionCost(xScale(point.x), yScale(point.y)) <
+        collisionCost(xScale(best.x), yScale(best.y))
+          ? point
+          : best,
+      ),
+    );
   }
 
   return result;
diff --git a/packages/app/src/components/inference/ui/line-label-visibility.test.ts b/packages/app/src/components/inference/ui/line-label-visibility.test.ts
index 80e17b049..3b4a075d8 100644
--- a/packages/app/src/components/inference/ui/line-label-visibility.test.ts
+++ b/packages/app/src/components/inference/ui/line-label-visibility.test.ts
@@ -53,6 +53,26 @@ describe('labelOpacityForActiveState', () => {
   });
 });
 
+describe('labelOpacityForActiveState with ?unofficialrun= overlays', () => {
+  const official = new Set(['gb200_dynamo-sglang']);
+  const precisions = ['fp8'];
+
+  it('hides an overlay label when its overlay hardware row is off, even if the official row is on', () => {
+    expect(
+      labelOpacityForActiveState(
+        {
+          hwKey: 'gb200_dynamo-sglang',
+          lineKey: 'overlay-gb200_dynamo-sglang_fp8_run1',
+          visible: '1',
+        },
+        official,
+        precisions,
+        new Set(['gb300_dynamo-sglang']),
+      ),
+    ).toBe(0);
+  });
+});
+
 describe('labelOpacityForHover', () => {
   it('lights up the kept label for the hovered hardware', () => {
     expect(labelOpacityForHover({ hwKey: 'b300_sglang', visible: '1' }, 'b300_sglang')).toBe(1);
diff --git a/packages/app/src/components/inference/ui/line-label-visibility.ts b/packages/app/src/components/inference/ui/line-label-visibility.ts
index a8b34b810..9dfa8e878 100644
--- a/packages/app/src/components/inference/ui/line-label-visibility.ts
+++ b/packages/app/src/components/inference/ui/line-label-visibility.ts
@@ -25,6 +25,8 @@
 export interface LabelAttrs {
   /** `data-hw-key` — base hardware key, shared across a hw's curves. */
   hwKey?: string;
+  /** `data-line-key` — `overlay-…` marks an unofficial-run curve's label. */
+  lineKey?: string;
   /** `data-precision` — set on parallelism labels, absent on line labels. */
   precision?: string;
   /** `data-visible` — `'1'`/`'0'`; only line labels set this. */
@@ -50,16 +52,24 @@ export const labelOpacityForHover = (attrs: LabelAttrs, hoveredHwKey: string): 0
  * filter-change sync effect. Line labels (no precision) show when their
  * hardware is active **and** the render kept them; parallelism labels show when
  * their hardware is active and their precision is selected.
+ *
+ * An `?unofficialrun=` overlay curve answers to the overlay legend rows, not
+ * the official ones: its label follows `activeOverlayHwTypes`, so soloing an
+ * official hardware no longer hides the overlay pills of every other hardware
+ * (and hiding an official row keeps its overlay twin labelled).
  */
 export const labelOpacityForActiveState = (
   attrs: LabelAttrs,
   activeHwTypes: ReadonlySet<string>,
   selectedPrecisions: readonly string[],
+  activeOverlayHwTypes?: ReadonlySet<string>,
 ): 0 | 1 => {
   const { hwKey, precision } = attrs;
   if (!hwKey) return 0;
+  const isOverlay = attrs.lineKey?.startsWith('overlay-') ?? false;
+  const active = isOverlay && activeOverlayHwTypes ? activeOverlayHwTypes : activeHwTypes;
   if (!precision) {
-    return activeHwTypes.has(hwKey) && renderKept(attrs) ? 1 : 0;
+    return active.has(hwKey) && renderKept(attrs) ? 1 : 0;
   }
-  return activeHwTypes.has(hwKey) && selectedPrecisions.includes(precision) ? 1 : 0;
+  return active.has(hwKey) && selectedPrecisions.includes(precision) ? 1 : 0;
 };
diff --git a/packages/app/src/components/inference/utils.ts b/packages/app/src/components/inference/utils.ts
index 5284aac3b..1794cd585 100644
--- a/packages/app/src/components/inference/utils.ts
+++ b/packages/app/src/components/inference/utils.ts
@@ -8,8 +8,15 @@ import { getGpuSpecs, type TcoBasis } from '@/lib/constants';
 import chartDefinitions from '@/components/inference/metric-registry';
 import { resolveXAxisField } from '@/components/inference/utils/resolveXAxisField';
 import { remapInferencePoint } from '@/lib/chart-utils';
+import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
 
-import type { ChartDefinition, ClippedInferenceData, InferenceData, YAxisMetricKey } from './types';
+import type {
+  ChartDefinition,
+  ClippedInferenceData,
+  InferenceData,
+  PowerCompare,
+  YAxisMetricKey,
+} from './types';
 import type { XAxisMode } from './hooks/useChartData';
 
 /**
@@ -145,6 +152,7 @@ export function processOverlayChartData(
     selectedXAxisMode?: XAxisMode;
     restrictToNormalizedFrontier?: boolean;
     tcoBasis?: TcoBasis;
+    powerCompare?: PowerCompare;
   },
 ): InferenceData[] {
   return processOverlayChartDataWithClipping(
@@ -171,6 +179,8 @@ export function processOverlayChartDataWithClipping(
     selectedXAxisMode?: XAxisMode;
     restrictToNormalizedFrontier?: boolean;
     tcoBasis?: TcoBasis;
+    /** Sibling boundary / role series, mirroring the official path in useChartData. */
+    powerCompare?: PowerCompare;
   },
 ): ProcessedChartData {
   const chartDef = (chartDefinitions as ChartDefinition[]).find((d) => d.chartType === chartType);
@@ -222,9 +232,13 @@ export function processOverlayChartDataWithClipping(
   // for the natural axis and for agentic (long TTFTs are normal there).
   const isTtftX = xAxisField.endsWith('_ttft');
 
-  const processedData = sourceData
-    .filter((d) => metricKey in d)
-    .map((d) => remapInferencePoint(d, metricKey, xAxisField));
+  const processedData = expandPowerCompareSeries(
+    sourceData
+      .filter((d) => metricKey in d)
+      .map((d) => remapInferencePoint(d, metricKey, xAxisField)),
+    selectedYAxisMetric,
+    options?.powerCompare ?? 'none',
+  );
 
   // The normalized metric is derived from persisted request traces, which an
   // unofficial overlay does not have. An all-false canonical stamp prevents a
diff --git a/packages/app/src/components/inference/utils/best-series-per-sku.ts b/packages/app/src/components/inference/utils/best-series-per-sku.ts
index 6799b9631..2a35f0b9c 100644
--- a/packages/app/src/components/inference/utils/best-series-per-sku.ts
+++ b/packages/app/src/components/inference/utils/best-series-per-sku.ts
@@ -40,7 +40,9 @@ export function bestSeriesPerSku(points: InferenceData[], direction: Direction):
   const bySku = new Map<string, Map<string, InferenceData[]>>();
   const featured = new Set<string>();
   for (const point of points) {
-    if (!isFrontierEligible(point) || !Number.isFinite(point.y)) continue;
+    // Comparison clones re-plot the same configs at another boundary or role;
+    // the best series per SKU is judged on the selected metric alone.
+    if (point.powerVariant || !isFrontierEligible(point) || !Number.isFinite(point.y)) continue;
     const sku = baseSku(point);
     const key = String(point.hwKey);
     if (point.framework === 'tilert') featured.add(key);
diff --git a/packages/app/src/components/inference/utils/point-identity.ts b/packages/app/src/components/inference/utils/point-identity.ts
index 2c975593e..0cc8bbed8 100644
--- a/packages/app/src/components/inference/utils/point-identity.ts
+++ b/packages/app/src/components/inference/utils/point-identity.ts
@@ -23,9 +23,47 @@ export function scatterPointConfigId(point: InferenceData): string {
   // Agentic series omit spec decoding from hwKey so one curve can mix methods.
   // It remains point identity to avoid collapsing overlapping MTP/STP results.
   key += agenticSpecDecodingKeySuffix(point);
+  // Comparison clones share every config field with their base point.
+  if (point.powerVariant) key += `|variant-${point.powerVariant.id}`;
   return key;
 }
 
+/**
+ * Comparison-series suffix inside a scatter series key. Letters, digits and
+ * dashes only, so the key stays a valid CSS class token (the perf ruler and
+ * `i_rulers` address rooflines by class) and needs no escaping.
+ */
+const SERIES_VARIANT_DELIMITER = '-v-';
+
+/**
+ * Identity of one drawn series: hardware key, precision and, on a power
+ * comparison, the boundary or role variant. Rooflines, frontiers, line labels
+ * and the perf ruler all key on this string.
+ */
+export function scatterSeriesKey(
+  point: Pick<InferenceData, 'hwKey' | 'precision' | 'powerVariant'>,
+): string {
+  const base = `${point.hwKey}_${point.precision}`;
+  return point.powerVariant ? `${base}${SERIES_VARIANT_DELIMITER}${point.powerVariant.id}` : base;
+}
+
+export interface ScatterSeriesIdentity {
+  hw: string;
+  precision: string;
+  /** Comparison variant id (`gpu-provisioned`, `prefill`, …) or null for the base series. */
+  variant: string | null;
+}
+
+/** Inverse of `scatterSeriesKey`; hardware keys may themselves contain underscores. */
+export function parseScatterSeriesKey(key: string): ScatterSeriesIdentity {
+  const delimiter = key.indexOf(SERIES_VARIANT_DELIMITER);
+  const core = delimiter === -1 ? key : key.slice(0, delimiter);
+  const variant = delimiter === -1 ? null : key.slice(delimiter + SERIES_VARIANT_DELIMITER.length);
+  const parts = core.split('_');
+  const precision = parts.pop() ?? '';
+  return { hw: parts.join('_'), precision, variant };
+}
+
 /**
  * Stable D3 join key for an official scatter point.
  *
diff --git a/packages/app/src/components/inference/utils/power-compare.ts b/packages/app/src/components/inference/utils/power-compare.ts
new file mode 100644
index 000000000..d0dea0b73
--- /dev/null
+++ b/packages/app/src/components/inference/utils/power-compare.ts
@@ -0,0 +1,326 @@
+/**
+ * Comparison series for the gated measured-power charts (`i_pcompare`).
+ *
+ * The selected metric stays the chart's base series. A comparison adds sibling
+ * series drawn from the SAME points — one per other power boundary
+ * (`boundaries`, PowerX Figures 2/3) or per worker role (`roles`, Figures 6/7)
+ * — so ScatterGraph can draw them with the hardware's colour and a per-variant
+ * dash through its ordinary series pipeline (frontier, Optimal Only, tooltip,
+ * table, CSV, `?unofficialrun=` overlay). A variant point is a clone of its
+ * base point with `y` remapped and `powerVariant` set; base points are left
+ * untouched so a chart without comparison is byte-identical to before.
+ *
+ * Variants exist only where the metric names a whole-deployment average
+ * (W per chip) or J per output token, because those are the only quantities
+ * every boundary and role publishes on a common axis; everywhere else the
+ * comparison yields no series and the control says so.
+ */
+import type { Locale } from '@/lib/i18n';
+import {
+  POWER_BASES,
+  POWER_BASIS_FIELDS,
+  POWER_BASIS_LABELS,
+  type PowerBasis,
+} from '@/lib/power-basis';
+
+import { getMeasuredMetricConfig } from '../measured-metric-config';
+import type { InferenceData, PowerCompare, PowerRole, PowerVariant } from '../types';
+
+export const POWER_COMPARE_MODES = [
+  'none',
+  'boundaries',
+  'roles',
+] as const satisfies readonly PowerCompare[];
+
+export function parsePowerCompare(value: string | null | undefined): PowerCompare {
+  return value === 'boundaries' || value === 'roles' ? value : 'none';
+}
+
+/** Point fields a comparison series can plot; each is a `{ y, roof }` pair. */
+export type PowerSeriesField = keyof Pick<
+  InferenceData,
+  | 'measuredAvgPower'
+  | 'measuredPrefillAvgPower'
+  | 'measuredDecodeAvgPower'
+  | 'measuredJPerOutputToken'
+  | 'measuredDecodeJPerOutputToken'
+  | 'reconstructedPrefillJPerOutputToken'
+  | 'gpuProvisionedWatts'
+  | 'gpuProvisionedJPerOutputToken'
+  | 'utilityProvisionedWatts'
+  | 'utilityProvisionedJPerOutputToken'
+  | 'utilityModeledWatts'
+  | 'utilityModeledJPerOutputToken'
+>;
+
+export interface PowerCompareSeries {
+  variant: PowerVariant;
+  field: PowerSeriesField;
+}
+
+const ROLES = ['all', 'prefill', 'decode'] as const satisfies readonly PowerRole[];
+
+const ROLE_WATT_FIELDS: Record<PowerRole, PowerSeriesField> = {
+  all: 'measuredAvgPower',
+  prefill: 'measuredPrefillAvgPower',
+  decode: 'measuredDecodeAvgPower',
+};
+// Energy per output token per role. The prefill pool's own figure is per input
+// token; `reconstructedPrefillJPerOutputToken` carries it onto the output-token
+// axis (utils/role-energy.ts).
+const ROLE_ENERGY_FIELDS: Record<PowerRole, PowerSeriesField> = {
+  all: 'measuredJPerOutputToken',
+  prefill: 'reconstructedPrefillJPerOutputToken',
+  decode: 'measuredDecodeJPerOutputToken',
+};
+
+const ROLE_LABELS: Record<PowerRole, { en: string; zh: string }> = {
+  all: { en: 'All GPUs', zh: '全部 GPU' },
+  prefill: { en: 'Prefill GPUs', zh: '预填充 GPU' },
+  decode: { en: 'Decode GPUs', zh: '解码 GPU' },
+};
+
+/** SVG dash per variant; the base series and `all` stay solid. */
+const VARIANT_DASH: Record<string, string> = {
+  'gpu-measured': '',
+  'gpu-provisioned': '8 4',
+  'utility-provisioned': '3 3',
+  'utility-modeled': '10 3 2 3',
+  all: '',
+  prefill: '7 3',
+  decode: '2 3',
+};
+
+/**
+ * The quantity a metric key plots on the comparison's common axis, or null
+ * when the key is not a whole-deployment average W/chip or J per output token.
+ */
+function comparableQuantity(metric: string): 'watts' | 'energy' | null {
+  const config = getMeasuredMetricConfig(metric);
+  if (!config) return null;
+  if (config.family === 'power') {
+    return config.scope === 'all' && config.statistic === 'average' && config.display === 'watts'
+      ? 'watts'
+      : null;
+  }
+  return config.scope === 'all' && config.denominator === 'output' && config.unit === 'joules'
+    ? 'energy'
+    : null;
+}
+
+/**
+ * The base series' own identity under a comparison — the boundary or role the
+ * selected metric already plots — or null when the metric admits no comparison
+ * of that kind.
+ */
+export function powerCompareBase(metric: string, mode: PowerCompare): PowerVariant | null {
+  const config = getMeasuredMetricConfig(metric);
+  if (!config || mode === 'none') return null;
+  if (mode === 'boundaries') {
+    return comparableQuantity(metric) ? { kind: 'basis', id: config.basis } : null;
+  }
+  if (config.basis !== 'gpu-measured') return null;
+  if (config.family === 'power') {
+    return config.statistic === 'average' && config.display === 'watts'
+      ? { kind: 'role', id: config.scope }
+      : null;
+  }
+  // Role energy compares J per output token; a prefill J per input token axis
+  // has no decode counterpart.
+  return config.denominator === 'output' && config.unit === 'joules' && config.scope !== 'prefill'
+    ? { kind: 'role', id: config.scope }
+    : null;
+}
+
+/** The sibling series a comparison adds to the selected metric (never the base itself). */
+export function powerCompareVariants(metric: string, mode: PowerCompare): PowerCompareSeries[] {
+  const base = powerCompareBase(metric, mode);
+  const config = getMeasuredMetricConfig(metric);
+  if (!base || !config) return [];
+  if (base.kind === 'basis') {
+    const quantity = comparableQuantity(metric);
+    if (!quantity) return [];
+    return POWER_BASES.filter((basis) => basis !== base.id).map((basis) => ({
+      variant: { kind: 'basis', id: basis },
+      field:
+        basis === 'gpu-measured'
+          ? quantity === 'watts'
+            ? 'measuredAvgPower'
+            : 'measuredJPerOutputToken'
+          : POWER_BASIS_FIELDS[basis][quantity],
+    }));
+  }
+  const fields = config.family === 'power' ? ROLE_WATT_FIELDS : ROLE_ENERGY_FIELDS;
+  return ROLES.filter((role) => role !== base.id).map((role) => ({
+    variant: { kind: 'role', id: role },
+    field: fields[role],
+  }));
+}
+
+/** Whether choosing `mode` on `metric` draws anything. `none` is always available. */
+export function powerCompareAvailable(metric: string, mode: PowerCompare): boolean {
+  return mode === 'none' || powerCompareVariants(metric, mode).length > 0;
+}
+
+/**
+ * Appends one clone per comparison series to `points` (already remapped onto
+ * the selected metric). A point lacking a variant's field contributes nothing
+ * to that series — never a 0 — so the availability rules of each boundary and
+ * role carry through unchanged.
+ */
+export function expandPowerCompareSeries(
+  points: readonly InferenceData[],
+  metric: string,
+  mode: PowerCompare,
+): InferenceData[] {
+  const series = powerCompareVariants(metric, mode);
+  if (series.length === 0) return [...points];
+  const result: InferenceData[] = [...points];
+  for (const { variant, field } of series) {
+    for (const point of points) {
+      const value = point[field];
+      if (!value || !Number.isFinite(value.y)) continue;
+      result.push({ ...point, y: value.y, roof: value.roof, powerVariant: variant });
+    }
+  }
+  return result;
+}
+
+/** Comparison mode implied by the variants present in a rendered point set. */
+export function inferPowerCompare(points: readonly InferenceData[]): PowerCompare {
+  for (const point of points) {
+    if (point.powerVariant?.kind === 'basis') return 'boundaries';
+    if (point.powerVariant?.kind === 'role') return 'roles';
+  }
+  return 'none';
+}
+
+/** Distinct variants in draw order: the base first, then siblings in canonical order. */
+export function powerVariantsInData(
+  points: readonly InferenceData[],
+  metric: string,
+): PowerVariant[] {
+  const mode = inferPowerCompare(points);
+  if (mode === 'none') return [];
+  const present = new Set(points.map((point) => point.powerVariant?.id).filter(Boolean));
+  const base = powerCompareBase(metric, mode);
+  const ordered: PowerVariant[] =
+    mode === 'boundaries'
+      ? POWER_BASES.map((id) => ({ kind: 'basis', id }))
+      : ROLES.map((id) => ({ kind: 'role', id }));
+  return ordered.filter((variant) => variant.id === base?.id || present.has(variant.id));
+}
+
+export function powerVariantId(variant: PowerVariant | null | undefined): string {
+  return variant?.id ?? '';
+}
+
+export function powerVariantDash(variant: PowerVariant | null | undefined): string {
+  return variant ? VARIANT_DASH[variant.id] : '';
+}
+
+export function powerVariantLabel(variant: PowerVariant, locale: Locale): string {
+  return variant.kind === 'basis'
+    ? POWER_BASIS_LABELS[variant.id][locale]
+    : ROLE_LABELS[variant.id][locale];
+}
+
+/** Short boundary names for in-chart line labels; the legend keeps the full names. */
+const BASIS_SHORT_LABELS: Record<PowerBasis, { en: string; zh: string }> = {
+  'gpu-measured': { en: 'Measured', zh: '实测' },
+  'gpu-provisioned': { en: 'TDP', zh: 'TDP' },
+  'utility-provisioned': { en: 'All-in', zh: '全站' },
+  'utility-modeled': { en: 'PUE modeled', zh: 'PUE 建模' },
+};
+
+/** Suffix text a line label carries for one comparison series. */
+export function powerVariantShortLabel(variant: PowerVariant, locale: Locale): string {
+  return variant.kind === 'basis'
+    ? BASIS_SHORT_LABELS[variant.id][locale]
+    : ROLE_LABELS[variant.id][locale];
+}
+
+/** `700 W`, `1.37 kW`, `19.2 kW`: kilowatts from 1000 W, at most two decimals, zeros trimmed. */
+export function formatWatts(watts: number): string {
+  if (Math.abs(watts) >= 1000) {
+    return `${(watts / 1000).toFixed(2).replace(/\.?0+$/u, '')} kW`;
+  }
+  return `${Math.round(watts)} W`;
+}
+
+/**
+ * The value a series holds at every point, or null when it varies. A
+ * provisioned boundary (TDP, all-in) is one number per hardware, so its line
+ * label can state it instead of sending the reader to the axis. Non-finite
+ * values are ignored; an empty series is null.
+ */
+export function flatSeriesValue(values: readonly number[], relTolerance = 0.005): number | null {
+  const finite = values.filter((value) => Number.isFinite(value));
+  if (finite.length === 0) return null;
+  const first = finite[0];
+  const tolerance = Math.abs(first) * relTolerance;
+  return finite.every((value) => Math.abs(value - first) <= tolerance) ? first : null;
+}
+
+export interface PowerLineLabelOptions {
+  /** The selected metric's own series keeps the plain hardware label. */
+  isBase: boolean;
+  locale: Locale;
+  /** Shared watts of a flat series (`flatSeriesValue`), appended after the name. */
+  flatWatts?: number | null;
+}
+
+const LINE_LABEL_SUFFIX_SEPARATOR = ' · ';
+
+/** Suffix appended to a comparison sibling's line label; '' for the base series. */
+export function powerLineLabelSuffix(
+  variant: PowerVariant | null | undefined,
+  opts: PowerLineLabelOptions,
+): string {
+  if (opts.isBase || !variant) return '';
+  const watts =
+    typeof opts.flatWatts === 'number' && Number.isFinite(opts.flatWatts)
+      ? ` ${formatWatts(opts.flatWatts)}`
+      : '';
+  return `${LINE_LABEL_SUFFIX_SEPARATOR}${powerVariantShortLabel(variant, opts.locale)}${watts}`;
+}
+
+const LINE_LABEL_SERIES_DELIMITER = '::';
+
+/**
+ * Line-label series id: the hardware key for the base series (existing pinned
+ * anchors and hover hooks key on it) and `<hw>::<variant>` for a sibling.
+ */
+export function lineLabelSeriesId(
+  hw: string,
+  variant: PowerVariant | null | undefined,
+  isBase: boolean,
+): string {
+  return isBase || !variant ? hw : `${hw}${LINE_LABEL_SERIES_DELIMITER}${variant.id}`;
+}
+
+/** Inverse of `lineLabelSeriesId`: the hardware key behind a line-label series id. */
+export function lineLabelHardwareKey(seriesId: string): string {
+  const index = seriesId.indexOf(LINE_LABEL_SERIES_DELIMITER);
+  return index === -1 ? seriesId : seriesId.slice(0, index);
+}
+
+/** Whether `metric` plots watts per chip, so a flat boundary's label can state its value. */
+export function metricPlotsWatts(metric: string): boolean {
+  const config = getMeasuredMetricConfig(metric);
+  return config?.family === 'power' && config.display === 'watts';
+}
+
+/**
+ * Series label for a table or CSV row: the point's variant, or the base
+ * series' identity when the chart is comparing and this is a base point.
+ */
+export function powerSeriesLabel(
+  point: Pick<InferenceData, 'powerVariant'>,
+  metric: string,
+  mode: PowerCompare,
+  locale: Locale,
+): string {
+  const variant = point.powerVariant ?? powerCompareBase(metric, mode);
+  return variant ? powerVariantLabel(variant, locale) : '';
+}
diff --git a/packages/app/src/components/inference/utils/powerCurves.test.ts b/packages/app/src/components/inference/utils/powerCurves.test.ts
index a71f8bde2..dc0125649 100644
--- a/packages/app/src/components/inference/utils/powerCurves.test.ts
+++ b/packages/app/src/components/inference/utils/powerCurves.test.ts
@@ -94,8 +94,12 @@ describe('upper power envelope', () => {
   it('mirrors the boundary for latency and resolves tied coordinates deterministically', () => {
     const fast = point(1, 1, 350);
     const middle = point(8, 2, 700);
+    const plateau = point(16, 3, 700);
     const slow = point(32, 4, 950);
-    const samples = [slow, point(16, 3, 700), point(4, 2, 500), middle, { ...middle }, fast];
+    // Measured watts: a tie at the running maximum is a repeat marker, so the
+    // plateau leaves the boundary and Optimal Only can collapse it; a repeated
+    // X keeps only its first vertex.
+    const samples = [slow, plateau, point(4, 2, 500), middle, { ...middle }, fast];
     expect(upperPowerEnvelope(samples, false)).toEqual([fast, middle, slow]);
     expect(
       upperPowerEnvelope(
@@ -103,6 +107,8 @@ describe('upper power envelope', () => {
         true,
       ).map((p) => p.y),
     ).toEqual([950, 700, 350]);
+    // A gauge keeps the plateau: it is part of the outer edge it draws.
+    expect(upperPowerEnvelope(samples, false, true)).toEqual([fast, middle, plateau, slow]);
   });
 
   it('uses only finite positive coordinates and preserves singleton boundaries', () => {
diff --git a/packages/app/src/components/inference/utils/powerCurves.ts b/packages/app/src/components/inference/utils/powerCurves.ts
index 35146640a..13ac7209e 100644
--- a/packages/app/src/components/inference/utils/powerCurves.ts
+++ b/packages/app/src/components/inference/utils/powerCurves.ts
@@ -1,3 +1,4 @@
+import { isPowerBasisConfigKey } from '@/components/inference/metric-registry';
 import type { InferenceData } from '@/components/inference/types';
 import {
   isFrontierEligible,
@@ -15,14 +16,40 @@ const POWER_CURVE_METRICS: ReadonlySet<string> = new Set([
   'y_measuredDecodeAvgPower',
   'y_measuredPowerPercentTdp',
   'y_modeledChassisPowerPerGpu',
+  // Provisioned / modelled boundary gauges: same upper-envelope curve as measured watts.
+  'y_gpuProvisionedWatts',
+  'y_utilityProvisionedWatts',
+  'y_utilityModeledWatts',
 ]);
 
 export function isPowerCurveMetric(metric: string): boolean {
   return POWER_CURVE_METRICS.has(metric);
 }
 
+/**
+ * Power gauges whose curve is always the upper envelope and whose Optimal Only
+ * toggle only hides off-envelope markers: measured watts plus the provisioned /
+ * modelled boundary gauges that sit beside them. A Pareto corner would collapse
+ * a flat TDP series to one marker. The modelled chassis axis keeps its legacy
+ * Pareto behaviour.
+ */
 export function isMeasuredPowerCurveMetric(metric: string): boolean {
-  return isPowerCurveMetric(metric) && metric !== 'y_modeledChassisPowerPerGpu';
+  return (
+    isPowerCurveMetric(metric) &&
+    (metric !== 'y_modeledChassisPowerPerGpu' || isPowerBasisConfigKey(metric))
+  );
+}
+
+/**
+ * Whether a drawn series is a provisioned or modelled gauge rather than
+ * telemetry: a boundary axis, or a boundary comparison clone of one. Gauges
+ * keep envelope ties (see `upperPowerEnvelope`); measured series, the measured
+ * boundary clone and role clones stay on the strict envelope.
+ */
+export function isPowerGaugeSeries(metric: string, sample: InferenceData | undefined): boolean {
+  const variant = sample?.powerVariant;
+  if (variant) return variant.kind === 'basis' && variant.id !== 'gpu-measured';
+  return isPowerBasisConfigKey(metric);
 }
 
 /** No declared direction means there is no Pareto frontier to draw or filter by. */
@@ -45,14 +72,23 @@ export function chartFrontier(
 export function upperPowerEnvelope(
   points: readonly InferenceData[],
   maximizeX: boolean,
+  keepTies = false,
 ): InferenceData[] {
   const sorted = points
     .filter((point) => isFrontierEligible(point) && Number.isFinite(point.y) && point.y > 0)
     .sort((a, b) => (maximizeX ? b.x - a.x : a.x - b.x) || b.y - a.y);
+  // Measured telemetry keeps the strict envelope: a tie at the running maximum
+  // is a repeat marker that Optimal Only collapses. A provisioned or modelled
+  // gauge (`keepTies`) is flat by construction, so its ties stay on the
+  // boundary and the series draws across its tested x-range instead of one
+  // marker. Repeated X keeps only its first vertex so the smoothing never
+  // backtracks.
   let maxY = -Infinity;
+  let lastX = Number.NaN;
   const envelope = sorted.filter((point) => {
-    if (point.y <= maxY) return false;
+    if (point.y < maxY || (point.y === maxY && (!keepTies || point.x === lastX))) return false;
     maxY = point.y;
+    lastX = point.x;
     return true;
   });
   return maximizeX ? envelope.toReversed() : envelope;
diff --git a/packages/app/src/components/inference/utils/role-energy.test.ts b/packages/app/src/components/inference/utils/role-energy.test.ts
new file mode 100644
index 000000000..102703cc0
--- /dev/null
+++ b/packages/app/src/components/inference/utils/role-energy.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+
+import { reconstructedRoleEnergy } from './role-energy';
+
+// A disaggregated 8K/1K run: the deployment's energy over the window divided
+// by 8× more input than output tokens, so J/out ÷ J/in = 7.9 = the served ratio.
+const entry = {
+  disagg: true,
+  power_valid: 1,
+  power_metric_schema_version: 2,
+  joules_per_input_token: 1,
+  joules_per_output_token: 7.9,
+  prefill_joules_per_input_token: 0.25,
+  decode_joules_per_output_token: 6,
+};
+
+describe('reconstructedRoleEnergy', () => {
+  it('expresses prefill energy per output token with the served token ratio and sums the roles', () => {
+    expect(reconstructedRoleEnergy(entry)).toEqual({
+      prefill: 1.975,
+      decode: 6,
+      total: 7.975,
+      prefillShare: (100 * 1.975) / 7.975,
+    });
+  });
+});
diff --git a/packages/app/src/components/inference/utils/role-energy.ts b/packages/app/src/components/inference/utils/role-energy.ts
new file mode 100644
index 000000000..89e6b37f2
--- /dev/null
+++ b/packages/app/src/components/inference/utils/role-energy.ts
@@ -0,0 +1,64 @@
+/**
+ * Reconstructs how a disaggregated deployment's request energy splits between
+ * its prefill and decode pools (PowerX Figure 7).
+ *
+ * Schema-2 aggregate energy has one numerator: the deployment's energy over the
+ * validated window is divided by input tokens for `joules_per_input_token` and
+ * by output tokens for `joules_per_output_token`. Their ratio is therefore the
+ * input:output token ratio the benchmark actually served. Multiplying the
+ * prefill pool's J per input token by that ratio expresses the prefill energy
+ * per output token, on the same axis as the decode pool's J per output token.
+ * The two add up to the whole request's J per output token, which equals the
+ * deployment figure whenever the role energies partition the deployment energy.
+ *
+ * Nothing is estimated: every input is a same-window telemetry figure, and the
+ * result is `undefined` whenever one is missing, not validated, or not from a
+ * disaggregated deployment.
+ */
+export interface RoleEnergyInput {
+  disagg?: boolean;
+  power_valid?: number;
+  power_metric_schema_version?: number;
+  joules_per_input_token?: number;
+  joules_per_output_token?: number;
+  prefill_joules_per_input_token?: number;
+  decode_joules_per_output_token?: number;
+}
+
+export interface ReconstructedRoleEnergy {
+  /** Prefill pool energy per output token (J). */
+  prefill: number;
+  /** Decode pool energy per output token (J). */
+  decode: number;
+  /** Prefill + decode (J per output token). */
+  total: number;
+  /** Prefill share of the reconstructed total, in percent. */
+  prefillShare: number;
+}
+
+const positive = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isFinite(value) && value > 0;
+
+export function reconstructedRoleEnergy(
+  entry: RoleEnergyInput,
+): ReconstructedRoleEnergy | undefined {
+  if (!entry.disagg || entry.power_valid !== 1 || entry.power_metric_schema_version !== 2) {
+    return undefined;
+  }
+  const input = entry.joules_per_input_token;
+  const output = entry.joules_per_output_token;
+  const prefill = entry.prefill_joules_per_input_token;
+  const decode = entry.decode_joules_per_output_token;
+  if (!positive(input) || !positive(output) || !positive(prefill) || !positive(decode)) {
+    return undefined;
+  }
+  const prefillPerOutputToken = prefill * (output / input);
+  const total = prefillPerOutputToken + decode;
+  if (!positive(prefillPerOutputToken) || !positive(total)) return undefined;
+  return {
+    prefill: prefillPerOutputToken,
+    decode,
+    total,
+    prefillShare: (100 * prefillPerOutputToken) / total,
+  };
+}
diff --git a/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts b/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
new file mode 100644
index 000000000..45157d317
--- /dev/null
+++ b/packages/app/src/components/inference/utils/tooltip-utils.power-trace.test.ts
@@ -0,0 +1,94 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { HardwareConfig, InferenceData, OverlayData } from '@/components/inference/types';
+import {
+  generateOverlayTooltipContent,
+  type OverlayTooltipConfig,
+  type TooltipConfig,
+} from '@/components/inference/utils/tooltipUtils';
+
+// "View power trace" on pinned tooltips: the deep link from a measured-power
+// scatter point to its per-second telemetry on the Timeline display.
+
+const RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34716669498';
+const AUDIT_NAME =
+  'dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc64_b200-host-0123';
+const ACTION = 'data-action="view-power-trace"';
+
+const hardwareConfig = {
+  b200: {
+    name: 'b200',
+    label: 'B200',
+    suffix: '',
+    gpu: 'B200',
+    color: 'blue',
+    power: 1000,
+    costh: 5,
+    costr: 1.25,
+  },
+} as unknown as HardwareConfig;
+
+function measuredPoint(overrides: Partial<InferenceData> = {}): InferenceData {
+  return {
+    id: 980001,
+    date: '2026-09-01',
+    x: 60,
+    y: 600,
+    tp: 8,
+    conc: 64,
+    hwKey: 'b200',
+    precision: 'fp4',
+    benchmark_type: 'single_turn',
+    run_url: RUN_URL,
+    power_audit: { source: `power_validation_${AUDIT_NAME}.json` },
+    tpPerGpu: { y: 400, roof: false },
+    tpPerMw: { y: 50, roof: false },
+    costh: { y: 1, roof: false },
+    costr: { y: 1, roof: false },
+    costhi: { y: 1, roof: false },
+    costri: { y: 1, roof: false },
+    ...overrides,
+  } as InferenceData;
+}
+
+function config(overrides: Partial<TooltipConfig> = {}): TooltipConfig {
+  return {
+    data: measuredPoint(),
+    isPinned: true,
+    xLabel: 'Interactivity (tok/s/user)',
+    yLabel: 'Measured Power per Chip (W)',
+    selectedYAxisMetric: 'y_measuredAvgPower',
+    hardwareConfig,
+    ...overrides,
+  };
+}
+
+function overlayConfig(overrides: Partial<OverlayTooltipConfig> = {}): OverlayTooltipConfig {
+  return {
+    ...config({ data: measuredPoint({ id: 0 }) }),
+    overlayData: {
+      label: 'powerx-timeline',
+      hardwareConfig,
+      data: [],
+      runUrl: RUN_URL,
+    } as unknown as OverlayData,
+    ...overrides,
+  };
+}
+
+describe('View power trace tooltip action', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('renders on pinned overlay tooltips whose points carry id 0', () => {
+    const html = generateOverlayTooltipContent(overlayConfig());
+    expect(html).toContain(`<a ${ACTION}`);
+    expect(html).toContain('View power trace &rarr;');
+    expect(html).not.toContain('data-action="view-logs"');
+    expect(generateOverlayTooltipContent(overlayConfig({ isPinned: false }))).not.toContain(ACTION);
+    expect(
+      generateOverlayTooltipContent(overlayConfig({ selectedYAxisMetric: 'y_tpPerGpu' })),
+    ).not.toContain(ACTION);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/tooltipUtils.ts b/packages/app/src/components/inference/utils/tooltipUtils.ts
index 314941a89..2ae288497 100644
--- a/packages/app/src/components/inference/utils/tooltipUtils.ts
+++ b/packages/app/src/components/inference/utils/tooltipUtils.ts
@@ -6,6 +6,7 @@ import { isPersistedBenchmarkId } from '@/lib/benchmark-id';
 import { frameworkFamily } from '@/lib/framework-family';
 import type { Locale } from '@/lib/i18n';
 import { isKvOffloadEnabled } from '@/lib/kv-offload';
+import { chartStateHref } from '@/lib/url-state';
 import { chipCounts } from '@/lib/chip-counts';
 import type { SystemPowerUnsupportedReason } from '@/lib/modeled-system-power';
 
@@ -14,6 +15,13 @@ import {
   isMeasuredEnergyConfigKey,
   isModeledSystemPowerConfigKey,
 } from '@/components/inference/metric-registry';
+import { getMeasuredMetricConfig } from '@/components/inference/measured-metric-config';
+import { powerVariantLabel } from '@/components/inference/utils/power-compare';
+import {
+  POWER_TIMELINE_METRIC_KEY,
+  traceKeyForPoint,
+} from '@/components/inference/utils/powerTimeline';
+import { reconstructedRoleEnergy } from '@/components/inference/utils/role-energy';
 import {
   meaningfulParallelismSize,
   parallelismLabel,
@@ -49,6 +57,8 @@ export interface TooltipConfig {
   hasTrace?: boolean;
   /** Whether this official DB-backed point has a linked `server_logs` row. */
   hasLog?: boolean;
+  /** Opt in only when the host handles the dialog action. */
+  showPowerTelemetry?: boolean;
   /** Page locale for tooltip metadata labels. Defaults to English. */
   locale?: Locale;
 }
@@ -157,6 +167,8 @@ const TOOLTIP_STRINGS = {
     powerCertified: 'Validated (current PowerX method)',
     powerLegacy: 'Historical (not validated under the current method)',
     powerWithheld: 'Measured power withheld',
+    series: 'Series',
+    roleEnergyShare: 'Share of request energy',
   },
   zh: {
     dismiss: '点击其他区域关闭',
@@ -176,9 +188,39 @@ const TOOLTIP_STRINGS = {
     powerCertified: '已验证（采用当前 PowerX 方法）',
     powerLegacy: '历史测量（尚未按当前方法验证）',
     powerWithheld: '实测功耗未采信',
+    series: '系列',
+    roleEnergyShare: '在请求能耗中的占比',
   },
 } as const;
 
+/**
+ * Which comparison series (`i_pcompare`) a point belongs to, for the clones a
+ * boundary / role comparison appends. On the energy axis a role clone also
+ * reports its share of the reconstructed request energy (utils/role-energy.ts).
+ */
+const powerVariantHTML = (
+  d: InferenceData,
+  selectedYAxisMetric: string,
+  locale: Locale,
+): string => {
+  const variant = d.powerVariant;
+  if (!variant) return '';
+  const t = TOOLTIP_STRINGS[locale];
+  let html = tooltipLine(t.series, powerVariantLabel(variant, locale));
+  if (
+    variant.kind === 'role' &&
+    variant.id !== 'all' &&
+    getMeasuredMetricConfig(selectedYAxisMetric)?.family === 'energy'
+  ) {
+    const energy = reconstructedRoleEnergy(d);
+    if (energy) {
+      const share = variant.id === 'prefill' ? energy.prefillShare : 100 - energy.prefillShare;
+      html += tooltipLine(t.roleEnergyShare, `${share.toFixed(1)}%`);
+    }
+  }
+  return html;
+};
+
 const totalChipsHTML = (d: InferenceData, selectedYAxisMetric: string, locale: Locale): string => {
   const t = TOOLTIP_STRINGS[locale];
   const { physical, configured } = chipCounts(
@@ -228,6 +270,8 @@ const SYSTEM_POWER_STRINGS = {
         : `${chassis} eight-GPU chassis · ${measured} of ${modeled} GPUs measured, extrapolated to full chassis`,
     extrapolation:
       'Unmeasured chassis GPUs are assumed to run the same workload at the measured per-GPU power; deployment values are the measured GPUs’ share.',
+    uniformHosts:
+      'No per-host telemetry for this multinode deployment; every chassis is modeled at the deployment-mean GPU power.',
     normalization: 'AC power is divided by all modeled chassis GPUs, including prefill and decode.',
     boundary: 'Includes GPU chassis CPUs; excludes separate CPU-only frontend/router hosts.',
     model: 'Power model source',
@@ -257,6 +301,7 @@ const SYSTEM_POWER_STRINGS = {
         : `${chassis} 个八卡机箱 · 实测 ${measured}/${modeled} 张 GPU，按满机箱外推`,
     extrapolation:
       '假设机箱内未实测的 GPU 运行相同负载、功耗与实测每卡功耗相同；部署数值为实测 GPU 所占份额。',
+    uniformHosts: '该多节点部署没有逐主机功耗数据；每个机箱按部署平均每卡功耗建模。',
     normalization: '交流功耗按所有建模机箱的 GPU 总数分摊，包括 Prefill 与 Decode。',
     boundary: '计入 GPU 机箱内的 CPU；不计入独立的纯 CPU 前端或路由主机。',
     model: '功耗模型来源',
@@ -303,7 +348,7 @@ const modeledSystemPowerHTML = (
         ? `
       ${tooltipLine(t.deploymentAc, `${fmt(estimate.deploymentAcWatts)} W`)}
       ${tooltipLine(`${t.facility} (PUE ${fmt(estimate.pue)})`, `${fmt(estimate.deploymentFacilityWatts)} W`)}
-      <div style="color: var(--muted-foreground); margin-bottom: 4px;">${t.topology(estimate.chassisCount, estimate.gpuCount, estimate.modeledGpuCount)}${estimate.chassisBasis === 'extrapolated' ? `<br/>${t.extrapolation}` : ''}<br/>${t.assumptions}<br/>${t.platformAssumptions}<br/>${t.normalization}<br/>${t.boundary}</div>
+      <div style="color: var(--muted-foreground); margin-bottom: 4px;">${t.topology(estimate.chassisCount, estimate.gpuCount, estimate.modeledGpuCount)}${estimate.chassisBasis === 'extrapolated' ? `<br/>${t.extrapolation}` : ''}${estimate.topologyBasis === 'uniform-hosts' ? `<br/>${t.uniformHosts}` : ''}<br/>${t.assumptions}<br/>${t.platformAssumptions}<br/>${t.normalization}<br/>${t.boundary}</div>
       ${tooltipLine(t.model, `<a href="${escapeHtml(sourceUrl)}" target="_blank" rel="noopener noreferrer" style="text-decoration: underline;">${escapeHtml(estimate.hardware)} · ${escapeHtml(estimate.modelRevision.slice(0, 12))}</a>`)}
       <a href="${escapeHtml(readmeUrl)}" target="_blank" rel="noopener noreferrer" style="text-decoration: underline;">${t.sweep}</a>
     `
@@ -493,39 +538,108 @@ const generateAgenticHTML = (d: InferenceData, locale: Locale): string => {
 };
 
 const ACTION_STRINGS = {
-  en: { charts: 'View charts', logs: 'View logs' },
-  zh: { charts: '查看图表', logs: '查看日志' },
+  en: {
+    charts: 'View charts',
+    logs: 'View logs',
+    powerTelemetry: 'View PowerX',
+    powerTrace: 'View power trace',
+  },
+  zh: {
+    charts: '查看图表',
+    logs: '查看日志',
+    powerTelemetry: '查看 PowerX',
+    powerTrace: '查看功耗曲线',
+  },
 } as const;
 
-const pointDetailActionLink = (action: 'view-charts' | 'view-logs', href: string, label: string) =>
+type TooltipAction = 'view-charts' | 'view-logs' | 'view-power-trace';
+
+const pointDetailActionLink = (action: TooltipAction, href: string, label: string) =>
   `<a data-action="${action}" href="${href}" style="
     display: block; width: 100%; padding: 4px 8px; font-size: 11px; font-weight: 500;
     border: 1px solid var(--border); border-radius: 6px; cursor: pointer;
     background: var(--accent); color: var(--accent-foreground); text-align: center; text-decoration: none;
   ">${label} &rarr;</a>`;
 
-/** Point-detail links rendered only for persisted, pinned official points. */
-const viewActionsHTML = (
-  isPinned: boolean,
-  hasTraceData: boolean,
-  hasLogData: boolean,
-  pointId: number | undefined,
-  benchmarkType: string | undefined,
-  locale: Locale,
-): string => {
-  const isAgentic = benchmarkType === 'agentic_traces';
-  const showCharts = isAgentic && hasTraceData;
-  if (!isPinned || !isPersistedBenchmarkId(pointId) || (!showCharts && !hasLogData)) return '';
-  const prefix = locale === 'zh' ? '/zh' : '';
-  const agenticHref = agenticDetailHref(pointId, locale);
-  const logHref = isAgentic
-    ? `${agenticHref}${agenticHref.includes('?') ? '&' : '?'}view=logs`
-    : `${prefix}/inference/logs/${pointId}`;
+/**
+ * Whether a point on the measured-power / energy scatter can jump to its
+ * per-second telemetry on the Timeline display. Overlay points qualify too:
+ * the trace is keyed by run id and audit name, not by a persisted row id.
+ */
+export const showsPowerTraceAction = (
+  point: Pick<InferenceData, 'power_audit' | 'run_url'>,
+  selectedYAxisMetric: string,
+): boolean =>
+  selectedYAxisMetric !== POWER_TIMELINE_METRIC_KEY &&
+  getMeasuredMetricConfig(selectedYAxisMetric) !== undefined &&
+  traceKeyForPoint(point) !== null;
+
+/**
+ * Same-tab click is intercepted by the chart (in-page metric switch); the href
+ * keeps open-in-new-tab landing on the Timeline display of THIS chart. The
+ * address bar is stripped of chart state after load, so the share-link store
+ * is layered over the live location first (`chartStateHref`).
+ */
+const powerTraceHref = (): string =>
+  typeof window === 'undefined' ? '#' : chartStateHref({ i_metric: POWER_TIMELINE_METRIC_KEY });
+
+interface ViewActionsInput {
+  isPinned: boolean;
+  hasTraceData: boolean;
+  hasLogData: boolean;
+  point: InferenceData;
+  /**
+   * Metric the chart currently plots, when that chart can switch to the
+   * Timeline display in place (the scatter). Omitted by charts that cannot,
+   * so they never render a "View power trace" link nothing would handle.
+   */
+  powerTraceMetric?: string;
+  showPowerTelemetry?: boolean;
+  locale: Locale;
+}
+
+/**
+ * Point-detail links rendered only on pinned tooltips. "View charts" and
+ * "View logs" need a persisted row id (overlay points have none); "View power
+ * trace" needs only the run and audit source, so it works for overlays too.
+ */
+const viewActionsHTML = ({
+  isPinned,
+  hasTraceData,
+  hasLogData,
+  point,
+  powerTraceMetric,
+  showPowerTelemetry,
+  locale,
+}: ViewActionsInput): string => {
+  if (!isPinned) return '';
   const t = ACTION_STRINGS[locale];
-  const actions = [
-    showCharts ? pointDetailActionLink('view-charts', agenticHref, t.charts) : '',
-    hasLogData ? pointDetailActionLink('view-logs', logHref, t.logs) : '',
-  ].filter(Boolean);
+  const actions: string[] = [];
+  const pointId = point.id;
+  const isAgentic = point.benchmark_type === 'agentic_traces';
+  const showCharts = isAgentic && hasTraceData;
+  if (isPersistedBenchmarkId(pointId) && (showCharts || hasLogData)) {
+    const prefix = locale === 'zh' ? '/zh' : '';
+    const agenticHref = agenticDetailHref(pointId, locale);
+    if (showCharts) {
+      actions.push(pointDetailActionLink('view-charts', agenticHref, t.charts));
+    }
+    if (hasLogData) {
+      const logHref = isAgentic
+        ? `${agenticHref}${agenticHref.includes('?') ? '&' : '?'}view=logs`
+        : `${prefix}/inference/logs/${pointId}`;
+      actions.push(pointDetailActionLink('view-logs', logHref, t.logs));
+    }
+  }
+  if (showPowerTelemetry && isPersistedBenchmarkId(pointId)) {
+    actions.push(
+      `<button type="button" data-action="view-power-telemetry" class="w-full rounded-md border border-border bg-accent px-2 py-1 text-xs font-medium text-accent-foreground cursor-pointer">${t.powerTelemetry} &rarr;</button>`,
+    );
+  }
+  if (powerTraceMetric !== undefined && showsPowerTraceAction(point, powerTraceMetric)) {
+    actions.push(pointDetailActionLink('view-power-trace', powerTraceHref(), t.powerTrace));
+  }
+  if (actions.length === 0) return '';
   return `<div style="display: grid; gap: 6px; margin-top: 8px;">${actions.join('')}</div>`;
 };
 
@@ -708,6 +822,7 @@ export const generateTooltipContent = (config: TooltipConfig): string => {
           : ''
       }
       ${powerTierHTML(d, selectedYAxisMetric, locale)}
+      ${powerVariantHTML(d, selectedYAxisMetric, locale)}
       ${modeledSystemPowerHTML(d, selectedYAxisMetric, isPinned, locale)}
       ${totalChipsHTML(d, selectedYAxisMetric, locale)}
       ${generateParallelismHTML(d, locale)}
@@ -718,7 +833,15 @@ export const generateTooltipContent = (config: TooltipConfig): string => {
       ${generateAgenticHTML(d, locale)}
       ${generateWorkerPowerHTML(d, isPinned, locale)}
       ${runLinkHTML(runUrl, locale)}
-      ${viewActionsHTML(isPinned, Boolean(hasTrace), Boolean(config.hasLog), d.id, d.benchmark_type, locale)}
+      ${viewActionsHTML({
+        isPinned,
+        hasTraceData: Boolean(hasTrace),
+        hasLogData: Boolean(config.hasLog),
+        point: d,
+        showPowerTelemetry: config.showPowerTelemetry,
+        powerTraceMetric: selectedYAxisMetric,
+        locale,
+      })}
     </div>
   `;
 };
@@ -752,6 +875,7 @@ export const generateOverlayTooltipContent = (config: OverlayTooltipConfig): str
       ${tooltipLine(xLabel, fmt(d.x))}
       ${tooltipLine(yLabel, fmt(d.y))}
       ${powerTierHTML(d, selectedYAxisMetric, locale)}
+      ${powerVariantHTML(d, selectedYAxisMetric, locale)}
       ${modeledSystemPowerHTML(d, selectedYAxisMetric, isPinned, locale)}
       ${totalChipsHTML(d, selectedYAxisMetric, locale)}
       ${generateParallelismHTML(d, locale)}
@@ -761,6 +885,14 @@ export const generateOverlayTooltipContent = (config: OverlayTooltipConfig): str
       ${powerWithheldHTML(d, locale)}
       ${generateAgenticHTML(d, locale)}
       ${generateWorkerPowerHTML(d, isPinned, locale)}
+      ${viewActionsHTML({
+        isPinned,
+        hasTraceData: false,
+        hasLogData: false,
+        point: d,
+        powerTraceMetric: selectedYAxisMetric,
+        locale,
+      })}
     </div>
   `;
 };
@@ -813,6 +945,7 @@ export const generateGPUGraphTooltipContent = (config: TooltipConfig): string =>
           : ''
       }
       ${powerTierHTML(d, selectedYAxisMetric, locale)}
+      ${powerVariantHTML(d, selectedYAxisMetric, locale)}
       ${modeledSystemPowerHTML(d, selectedYAxisMetric, isPinned, locale)}
       ${totalChipsHTML(d, selectedYAxisMetric, locale)}
       ${generateParallelismHTML(d, locale)}
@@ -823,7 +956,14 @@ export const generateGPUGraphTooltipContent = (config: TooltipConfig): string =>
       ${generateAgenticHTML(d, locale)}
       ${generateWorkerPowerHTML(d, isPinned, locale)}
       ${runLinkHTML(runUrl, locale)}
-      ${viewActionsHTML(isPinned, Boolean(hasTrace), Boolean(hasLog), d.id, d.benchmark_type, locale)}
+      ${viewActionsHTML({
+        isPinned,
+        hasTraceData: Boolean(hasTrace),
+        hasLogData: Boolean(hasLog),
+        point: d,
+        showPowerTelemetry: config.showPowerTelemetry,
+        locale,
+      })}
     </div>
   `;
 };
diff --git a/packages/app/src/lib/chart-utils.test.ts b/packages/app/src/lib/chart-utils.test.ts
index 9d5203b66..a23699602 100644
--- a/packages/app/src/lib/chart-utils.test.ts
+++ b/packages/app/src/lib/chart-utils.test.ts
@@ -928,6 +928,89 @@ describe('createChartDataPoint energy fields', () => {
   });
 });
 
+// ===========================================================================
+// createChartDataPoint — power-boundary fields (B2 GPU provisioned, B3 utility
+// provisioned, B4 utility modeled). Mock specs: tdp 700 W, power 700 "kW".
+// ===========================================================================
+const boundaryPoint = (e: AggDataEntry) =>
+  createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
+
+describe('createChartDataPoint power-boundary fields', () => {
+  // Eight measured GPUs (2 prefill + 6 decode) on two partially filled chassis:
+  // the model evaluates 16 GPUs, so only deploymentFacilityWatts ÷ gpuCount yields 877.5 W.
+  // Every other numerator/denominator pairing gives a different number.
+  const supportedModel = {
+    status: 'supported' as const,
+    hardware: 'h100',
+    modelRevision: 'test',
+    modelPath: 'test',
+    gpuCount: 8,
+    chassisCount: 2,
+    modeledGpuCount: 16,
+    measuredGpuWattsPerGpu: 500,
+    chassisAcWatts: 10_400,
+    chassisAcWattsPerGpu: 650,
+    facilityWatts: 13_520,
+    deploymentAcWatts: 5400,
+    deploymentFacilityWatts: 7020,
+    pue: 1.3,
+    telemetryBasis: 'validated-v2' as const,
+    topologyBasis: 'worker-hosts' as const,
+    chassisBasis: 'extrapolated' as const,
+  };
+  const validated = {
+    power_valid: 1,
+    power_metric_schema_version: 2,
+    avg_power_w: 500,
+    joules_per_output_token: 10,
+    modeledSystemPower: supportedModel,
+  };
+  it('emits all six boundary fields for a validated official row', () => {
+    const p = boundaryPoint(
+      entry({ output_tput_per_gpu: 400, benchmark_type: 'single_turn', ...validated }),
+    );
+    expect(p.gpuProvisionedWatts).toEqual({ y: 700, roof: false });
+    expect(p.gpuProvisionedJPerOutputToken?.y).toBeCloseTo(700 / 400, 10);
+    expect(p.utilityProvisionedWatts).toEqual({ y: 700_000, roof: false });
+    expect(p.utilityProvisionedJPerOutputToken?.y).toBeCloseTo(700_000 / 400, 10);
+    // B4 W = deployment facility ÷ measured GPUs; J scales B1 by B4 W ÷ B1 W.
+    expect(p.utilityModeledWatts).toEqual({ y: 877.5, roof: false });
+    expect(p.utilityModeledJPerOutputToken?.y).toBeCloseTo((10 * 877.5) / 500, 10);
+    // Existing measured (B1) fields are untouched by the new boundaries.
+    expect(p.measuredAvgPower).toEqual({ y: 500, roof: false });
+    expect(p.measuredJPerOutputToken).toEqual({ y: 10, roof: false });
+  });
+
+  it('normalizes fixed-sequence disaggregated energy by all GPUs while jOutput stays per decode GPU', () => {
+    const p = boundaryPoint(
+      entry({
+        output_tput_per_gpu: 400,
+        disagg: true,
+        benchmark_type: 'single_turn',
+        num_prefill_gpu: 4,
+        num_decode_gpu: 4,
+      }),
+    );
+    expect(p.gpuProvisionedJPerOutputToken?.y).toBeCloseTo((700 * 8) / (400 * 4), 10);
+    expect(p.utilityProvisionedJPerOutputToken?.y).toBeCloseTo((700_000 * 8) / (400 * 4), 10);
+    expect(p.jOutput?.y).toBeCloseTo(700_000 / 400, 10);
+    expect(p.utilityProvisionedJPerOutputToken?.y).toBeCloseTo(2 * p.jOutput!.y, 10);
+
+    const agentic = boundaryPoint(
+      entry({
+        output_tput_per_gpu: 400,
+        disagg: true,
+        benchmark_type: 'agentic_traces',
+        num_prefill_gpu: 4,
+        num_decode_gpu: 4,
+      }),
+    );
+    expect(agentic.gpuProvisionedWatts?.y).toBe(700);
+    expect(agentic.gpuProvisionedJPerOutputToken).toBeUndefined();
+    expect(agentic.utilityProvisionedJPerOutputToken).toBeUndefined();
+  });
+});
+
 // ===========================================================================
 // createChartDataPoint — measured power / energy fields (from runner telemetry)
 // ===========================================================================
@@ -952,20 +1035,6 @@ describe('createChartDataPoint measured power fields', () => {
     expect(missing.measuredP75Power).toBeUndefined();
     expect(missing.measuredP90Power).toBeUndefined();
   });
-  it('emits measuredAvgPower when avg_power_w is present on the entry', () => {
-    const e = entry({ avg_power_w: 685.5 });
-    const point = createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
-    expect(point.measuredAvgPower).toBeDefined();
-    expect(point.measuredAvgPower!.y).toBe(685.5);
-    expect(point.measuredAvgPower!.roof).toBe(false);
-  });
-
-  it('emits measuredJPerOutputToken when joules_per_output_token is present', () => {
-    const e = entry({ joules_per_output_token: 8.4 });
-    const point = createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
-    expect(point.measuredJPerOutputToken).toBeDefined();
-    expect(point.measuredJPerOutputToken!.y).toBe(8.4);
-  });
 
   it('derives J/query, Wh/query, and percent TDP from validated source fields', () => {
     const e = entry({ avg_power_w: 560, joules_per_successful_query: 1800 });
@@ -1019,14 +1088,6 @@ describe('createChartDataPoint measured power fields', () => {
     expect(point.measuredAvgPower!.y).toBe(0);
   });
 
-  it('emits measuredJPerTotalToken when joules_per_total_token is present', () => {
-    const e = entry({ joules_per_total_token: 0.93 });
-    const point = createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
-    expect(point.measuredJPerTotalToken).toBeDefined();
-    expect(point.measuredJPerTotalToken!.y).toBe(0.93);
-    expect(point.measuredJPerTotalToken!.roof).toBe(false);
-  });
-
   it('emits J/output and J/total independently — different denominators', () => {
     // 8k1k workload: J/output ≈ 9 × J/total (input is ~8x output, so output/total ≈ 1/9).
     const e = entry({ joules_per_output_token: 2.04, joules_per_total_token: 0.23 });
@@ -1051,30 +1112,6 @@ describe('createChartDataPoint measured power fields', () => {
 // createChartDataPoint — per-stage measured power / energy (disagg prefill/decode)
 // ===========================================================================
 describe('createChartDataPoint per-stage measured power fields', () => {
-  it('emits measuredPrefillAvgPower when prefill_avg_power_w is present', () => {
-    const e = entry({ prefill_avg_power_w: 920.3 });
-    const point = createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
-    expect(point.measuredPrefillAvgPower).toBeDefined();
-    expect(point.measuredPrefillAvgPower!.y).toBe(920.3);
-    expect(point.measuredPrefillAvgPower!.roof).toBe(false);
-  });
-
-  it('emits measuredDecodeAvgPower when decode_avg_power_w is present', () => {
-    const e = entry({ decode_avg_power_w: 612.1 });
-    const point = createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
-    expect(point.measuredDecodeAvgPower).toBeDefined();
-    expect(point.measuredDecodeAvgPower!.y).toBe(612.1);
-    expect(point.measuredDecodeAvgPower!.roof).toBe(false);
-  });
-
-  it('emits measuredJPerInputToken when joules_per_input_token is present', () => {
-    const e = entry({ joules_per_input_token: 0.27 });
-    const point = createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
-    expect(point.measuredJPerInputToken).toBeDefined();
-    expect(point.measuredJPerInputToken!.y).toBe(0.27);
-    expect(point.measuredJPerInputToken!.roof).toBe(false);
-  });
-
   it('omits all per-stage fields on legacy rows predating per-stage attribution', () => {
     // Single-node / pre-disagg runs emit avg_power_w only, no prefill/decode split.
     const e = entry({ avg_power_w: 685.5 });
@@ -1084,15 +1121,6 @@ describe('createChartDataPoint per-stage measured power fields', () => {
     expect(point.measuredJPerInputToken).toBeUndefined();
   });
 
-  it('emits prefill and decode independently — the disagg per-stage split', () => {
-    // GB300 disagg: prefill GPUs run compute-bound (higher W) than decode GPUs.
-    const e = entry({ prefill_avg_power_w: 948, decode_avg_power_w: 631 });
-    const point = createChartDataPoint('2025-01-01', e, 'median_e2el', 'tput_per_gpu', 'h100');
-    expect(point.measuredPrefillAvgPower!.y).toBe(948);
-    expect(point.measuredDecodeAvgPower!.y).toBe(631);
-    expect(point.measuredPrefillAvgPower!.y).toBeGreaterThan(point.measuredDecodeAvgPower!.y);
-  });
-
   it('preserves a zero per-stage power value (not falsy-coerced away)', () => {
     // Same typeof===number gate as total power — 0 W must survive, not be dropped.
     const e = entry({ prefill_avg_power_w: 0, decode_avg_power_w: 0 });
diff --git a/packages/app/src/lib/chart-utils.ts b/packages/app/src/lib/chart-utils.ts
index e94032342..78b62b2d8 100644
--- a/packages/app/src/lib/chart-utils.ts
+++ b/packages/app/src/lib/chart-utils.ts
@@ -11,6 +11,7 @@ import type {
   AggDataEntry,
   ChartDefinition,
   InferenceData,
+  PowerBasisFieldKey,
   YAxisMetricKey,
 } from '@/components/inference/types';
 import {
@@ -20,6 +21,8 @@ import {
 import { DEFAULT_TCO_BASIS, getGpuSpecs, isKnownGpu, type TcoBasis } from '@/lib/constants';
 import { getVendor, type Vendor } from '@/lib/dynamic-colors';
 import type { Locale } from '@/lib/i18n';
+import { buildPowerBasisChartFields, type PowerBasisChartFields } from '@/lib/power-basis';
+import { reconstructedRoleEnergy } from '@/components/inference/utils/role-energy';
 
 // ---------------------------------------------------------------------------
 // High-contrast color generation (iwanthue — k-means in CIELab)
@@ -289,7 +292,13 @@ export function buildAvailabilityHwKey(
   return hwKey;
 }
 
-export type DerivedMetricKey = BenchmarkMetricKey;
+// Power-boundary fields are derived here before the registry exposes them as
+// axes; the union collapses once METRIC_REGISTRY carries the same keys. The
+// reconstructed prefill energy is a comparison-only series (never an axis).
+export type DerivedMetricKey =
+  | BenchmarkMetricKey
+  | PowerBasisFieldKey
+  | 'reconstructedPrefillJPerOutputToken';
 export type DerivedChartFields = Pick<InferenceData, DerivedMetricKey>;
 
 const chartMetric = (y: number): { y: number; roof: boolean } => ({ y, roof: false });
@@ -411,6 +420,11 @@ export function buildDerivedChartFields(
       hardwarePower && tputPerGpu ? (hardwarePower * 1000) / tputPerGpu : 0,
     );
   }
+  // jOutput keeps the historical per-GPU normalization: for disaggregated rows
+  // output_tput_per_gpu is per decode GPU, so this is all-in W of one decode GPU
+  // per output token and ignores the prefill pool. The power-boundary field
+  // utilityProvisionedJPerOutputToken uses the same all-in W but counts every
+  // allocated GPU, so the two differ on disaggregated rows by (P + D) / D.
   if (hardwarePower > 0 && wants('jOutput') && outputTputPerGpu) {
     fields.jOutput = chartMetric(hardwarePower ? (hardwarePower * 1000) / outputTputPerGpu : 0);
   }
@@ -426,6 +440,14 @@ export function buildDerivedChartFields(
     if (wants(key)) fields[key] = value;
   }
 
+  const powerBasis = buildPowerBasisChartFields(entry, specs);
+  for (const [key, value] of Object.entries(powerBasis) as [
+    keyof PowerBasisChartFields,
+    { y: number; roof: boolean },
+  ][]) {
+    if (wants(key)) fields[key] = value;
+  }
+
   if (wants('modeledChassisPowerPerGpu') && entry.modeledSystemPower?.status === 'supported') {
     fields.modeledChassisPowerPerGpu = chartMetric(entry.modeledSystemPower.chassisAcWattsPerGpu);
   }
@@ -521,6 +543,8 @@ type MeasuredPowerChartFields = Partial<
     | 'measuredJPerSuccessfulQuery'
     | 'measuredWhPerSuccessfulQuery'
     | 'measuredPowerPercentTdp'
+    | 'measuredPowerTimeline'
+    | 'reconstructedPrefillJPerOutputToken'
   >
 >;
 
@@ -530,8 +554,13 @@ function buildMeasuredPowerChartFields(
   tdpWatts: number,
 ): MeasuredPowerChartFields {
   return {
+    // The timeline axis aliases the validated average: the point set (and
+    // its table row) is the same, only the chart body changes.
     ...(typeof entry.avg_power_w === 'number'
-      ? { measuredAvgPower: chartMetric(entry.avg_power_w) }
+      ? {
+          measuredAvgPower: chartMetric(entry.avg_power_w),
+          measuredPowerTimeline: chartMetric(entry.avg_power_w),
+        }
       : {}),
     ...(typeof entry.p75_power_w === 'number' && Number.isFinite(entry.p75_power_w)
       ? { measuredP75Power: chartMetric(entry.p75_power_w) }
@@ -562,6 +591,14 @@ function buildMeasuredPowerChartFields(
     ...(typeof entry.decode_joules_per_output_token === 'number'
       ? { measuredDecodeJPerOutputToken: chartMetric(entry.decode_joules_per_output_token) }
       : {}),
+    // Prefill energy on the output-token axis, so the roles comparison can
+    // stack it against the decode pool (PowerX Figure 7).
+    ...(() => {
+      const roleEnergy = reconstructedRoleEnergy(entry);
+      return roleEnergy
+        ? { reconstructedPrefillJPerOutputToken: chartMetric(roleEnergy.prefill) }
+        : {};
+    })(),
     ...(typeof entry.joules_per_successful_query === 'number'
       ? {
           measuredJPerSuccessfulQuery: chartMetric(entry.joules_per_successful_query),
diff --git a/packages/app/src/lib/csv-export-helpers.test.ts b/packages/app/src/lib/csv-export-helpers.test.ts
index 5fe616931..316f6af1f 100644
--- a/packages/app/src/lib/csv-export-helpers.test.ts
+++ b/packages/app/src/lib/csv-export-helpers.test.ts
@@ -8,6 +8,7 @@ import {
   historicalTrendToCsv,
 } from './csv-export-helpers';
 import type { InferenceData } from '@/components/inference/types';
+import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
 
 const makePoint = (overrides: Partial<InferenceData> = {}): InferenceData => ({
   x: 100,
@@ -752,3 +753,39 @@ describe('historicalTrendToCsv (mirrors HistoricalTrendsDisplay export)', () =>
     expect(rows[1][headers.indexOf('Date')]).toBe('2025-01-15');
   });
 });
+
+describe('inferenceChartToCsv power comparison', () => {
+  it.each([false, true])('exports plotted role values with overlay=%s', (overlay) => {
+    const base = makePoint({
+      hwKey: 'gb300_dynamo-trt',
+      y: 708.1,
+      measuredAvgPower: { y: 708.1, roof: false },
+      measuredPrefillAvgPower: { y: 760.442, roof: false },
+      measuredDecodeAvgPower: { y: 690.652, roof: false },
+      run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/35532106109',
+    });
+    const points = expandPowerCompareSeries([base], 'y_measuredAvgPower', 'roles');
+    const { headers, rows } = inferenceChartToCsv(
+      overlay ? [] : points,
+      'Kimi-K3',
+      'agentic-traces',
+      overlay ? points : [],
+      {
+        yHeader: 'Measured Power per Chip (W)',
+        yPath: 'measuredAvgPower.y',
+        xHeader: 'Interactivity (tok/s/user)',
+      },
+    );
+    expect(
+      rows.map((row) => [
+        row[headers.indexOf('Power Series')],
+        row[headers.indexOf('Measured Power per Chip (W)')],
+      ]),
+    ).toEqual([
+      ['All GPUs', 708.1],
+      ['Prefill GPUs', 760.442],
+      ['Decode GPUs', 690.652],
+    ]);
+    expect(points.every((point) => point.measuredAvgPower?.y === 708.1)).toBe(true);
+  });
+});
diff --git a/packages/app/src/lib/csv-export-helpers.ts b/packages/app/src/lib/csv-export-helpers.ts
index 576569af8..a58ba948f 100644
--- a/packages/app/src/lib/csv-export-helpers.ts
+++ b/packages/app/src/lib/csv-export-helpers.ts
@@ -9,6 +9,7 @@
 
 import { METRIC_REGISTRY } from '@/components/inference/metric-registry';
 import type { InferenceData, TrendDataPoint } from '@/components/inference/types';
+import { inferPowerCompare, powerSeriesLabel } from '@/components/inference/utils/power-compare';
 import { chipCounts } from '@/lib/chip-counts';
 import type { SubmissionVolumeRow } from '@/lib/submissions-types';
 
@@ -57,6 +58,12 @@ export function inferenceChartToCsv(
   const islOsl = sequenceToIslOsl(sequence);
   const showModeledPower =
     displayedMetrics?.yPath === METRIC_REGISTRY.modeledChassisPowerPerGpu.field;
+  // A power comparison (`i_pcompare`) appends boundary / role clones of the
+  // plotted points; name each row's series so the export stays unambiguous.
+  const allPoints = [...data, ...overlayData];
+  const powerCompare = inferPowerCompare(allPoints);
+  const showPowerSeries = powerCompare !== 'none';
+  const plottedMetric = displayedMetrics ? `y_${displayedMetrics.yPath.split('.')[0]}` : '';
   const headers = [
     'Model',
     'ISL',
@@ -111,13 +118,15 @@ export function inferenceChartToCsv(
     'Physical Chips',
     'DP',
     ...(showModeledPower ? ['Configured Chip Count'] : []),
+    ...(showPowerSeries ? ['Power Series'] : []),
   ];
 
   const displayedColumns = displayedMetrics
     ? [
         {
           header: displayedMetrics.yHeader,
-          value: (point: InferenceData) => nestedMetric(point, displayedMetrics.yPath),
+          value: (point: InferenceData) =>
+            point.powerVariant ? point.y : nestedMetric(point, displayedMetrics.yPath),
         },
         { header: displayedMetrics.xHeader, value: (point: InferenceData) => point.x },
       ].filter(
@@ -128,7 +137,7 @@ export function inferenceChartToCsv(
     : [];
   headers.splice(10, 0, ...displayedColumns.map((column) => column.header));
 
-  const rows = [...data, ...overlayData]
+  const rows = allPoints
     .filter((d) => !d.hidden)
     .map((d) => {
       const chips = chipCounts(d, showModeledPower);
@@ -177,6 +186,7 @@ export function inferenceChartToCsv(
         chips.physical,
         d.dp ?? '',
         ...(showModeledPower ? [chips.configured] : []),
+        ...(showPowerSeries ? [powerSeriesLabel(d, plottedMetric, powerCompare, 'en')] : []),
       ];
       row.splice(10, 0, ...displayedColumns.map((column) => column.value(d)));
       return row;
diff --git a/packages/app/src/lib/inference-labels.ts b/packages/app/src/lib/inference-labels.ts
index c95883095..7854d7d41 100644
--- a/packages/app/src/lib/inference-labels.ts
+++ b/packages/app/src/lib/inference-labels.ts
@@ -41,6 +41,48 @@ export function inferenceFrameworkLabelOverride(
 }
 
 /** Keep unofficial-run identity/markers while making its special engine visible. */
+/** Leads every unofficial-run label, in line labels and legend rows alike. */
+export const OVERLAY_LABEL_MARKER = '✕ ';
+const RUN_TAG_MAX = 20;
+const RUN_TAG_TAIL = 17;
+
+export interface OverlayRunIdentity {
+  id: number | string;
+  branch?: string | null;
+}
+
+/**
+ * Short, still recognisable name for a run: the whole branch when it is short,
+ * else its last path segment, else the branch tail (klaud nightlies end in
+ * `<date>-<sha>`). Falls back to the run id when the branch is unknown.
+ */
+export function shortRunTag(run: OverlayRunIdentity): string {
+  const branch = run.branch?.trim() || `run ${run.id}`;
+  if (branch.length <= RUN_TAG_MAX) return branch;
+  const segment = branch.slice(branch.lastIndexOf('/') + 1);
+  if (segment.length > 0 && segment.length <= RUN_TAG_MAX) return segment;
+  return `…${branch.slice(-RUN_TAG_TAIL)}`;
+}
+
+/** ` · <tag>` appended to an overlay line label when other runs draw the same hardware. */
+export function overlayRunTag(run: OverlayRunIdentity): string {
+  return ` · ${shortRunTag(run)}`;
+}
+
+/**
+ * Line-label text for an unofficial-run curve. Pills name the hardware, not the
+ * branch: branch names run to 70+ characters and the legend already carries
+ * them. The run tag is added only when several overlay runs draw the same
+ * hardware, so the pills stay distinguishable.
+ */
+export function getOverlayLineLabel(
+  hardwareLabel: string,
+  run: OverlayRunIdentity,
+  sharesHardware: boolean,
+): string {
+  return `${OVERLAY_LABEL_MARKER}${hardwareLabel}${sharesHardware ? overlayRunTag(run) : ''}`;
+}
+
 export function getInferenceRunLabel(
   label: string,
   points: readonly (RunProvenance & { framework?: string })[],
diff --git a/packages/app/src/lib/modeled-system-power.test.ts b/packages/app/src/lib/modeled-system-power.test.ts
index c968537ae..c8fb4c26e 100644
--- a/packages/app/src/lib/modeled-system-power.test.ts
+++ b/packages/app/src/lib/modeled-system-power.test.ts
@@ -222,6 +222,89 @@ describe('modeled system power admission and accounting', () => {
     expect(modelSystemPower(source)).toMatchObject({ reason: 'role-power' });
   });
 
+  it('models an aggregate multinode deployment without worker telemetry at the deployment mean', () => {
+    // Kimi K3 B200 dynamo-vLLM TP8/PP2 (prod rows, 2026-09-17): two eight-GPU hosts,
+    // aggregate producer, no per-worker array. The K3 H200 vLLM row below is
+    // TP16 × 2 DP replicas across four hosts.
+    const b200 = row({
+      is_multinode: true,
+      num_prefill_gpu: 16,
+      num_decode_gpu: 16,
+      decode_num_workers: 1,
+      metrics: {
+        power_valid: 1,
+        power_metric_schema_version: 2,
+        avg_power_w: 715.095,
+        avg_total_gpu_power_w: 11441.513,
+        decode_pp: 2,
+      },
+    });
+    const perChassis = estimateChassisPower('b200', 11441.513 / 2, 1.3)!;
+    const estimate = modelSystemPower(b200);
+    expect(estimate).toMatchObject({
+      status: 'supported',
+      topologyBasis: 'uniform-hosts',
+      chassisBasis: 'full',
+      gpuCount: 16,
+      chassisCount: 2,
+      modeledGpuCount: 16,
+    });
+    if (estimate.status !== 'supported') throw new Error('unreachable');
+    expect(estimate.chassisAcWatts).toBeCloseTo(perChassis.chassisAcWatts * 2, 6);
+    expect(estimate.deploymentFacilityWatts).toBe(estimate.facilityWatts);
+    expect(estimate.chassisAcWattsPerGpu).toBeCloseTo(perChassis.chassisAcWatts / 8, 6);
+
+    const h200 = row({
+      hardware: 'h200',
+      is_multinode: true,
+      prefill_tp: 16,
+      decode_tp: 16,
+      decode_ep: 32,
+      decode_dp_attention: true,
+      decode_num_workers: 2,
+      num_prefill_gpu: 32,
+      num_decode_gpu: 32,
+      metrics: {
+        power_valid: 1,
+        power_metric_schema_version: 2,
+        avg_power_w: 167.357,
+        avg_total_gpu_power_w: 5355.413,
+        decode_pp: 1,
+      },
+    });
+    expect(modelSystemPower(h200)).toMatchObject({
+      status: 'supported',
+      topologyBasis: 'uniform-hosts',
+      chassisCount: 4,
+      gpuCount: 32,
+    });
+
+    // A replica count that does not explain the telemetry width is not guessed around.
+    expect(modelSystemPower({ ...h200, decode_num_workers: 1 })).toMatchObject({
+      reason: 'gpu-count',
+    });
+    // Twelve GPUs cannot fill whole eight-GPU hosts; placement is unknown.
+    const twelve = row({ is_multinode: true, decode_tp: 12, prefill_tp: 12 });
+    twelve.metrics.avg_total_gpu_power_w = twelve.metrics.avg_power_w * 12;
+    expect(modelSystemPower(twelve)).toMatchObject({ reason: 'topology' });
+    // Per-worker telemetry, when present, keeps the more exact worker path.
+    const withWorkers = {
+      ...b200,
+      workers: ['host-a', 'host-b'].map((host, worker_idx) => ({
+        role: 'agg',
+        worker_idx,
+        hosts: [host],
+        num_gpus: 8,
+        avg_power_w: 715.095,
+      })),
+    };
+    expect(modelSystemPower(withWorkers)).toMatchObject({
+      status: 'supported',
+      topologyBasis: 'worker-hosts',
+      chassisCount: 2,
+    });
+  });
+
   it('preserves meaningful aggregate PP and PCP aliases before checking physical width', () => {
     for (const widths of [
       { decode_pp: 1, prefill_pp: 2 },
diff --git a/packages/app/src/lib/modeled-system-power.ts b/packages/app/src/lib/modeled-system-power.ts
index 550fe23fc..aadb737f6 100644
--- a/packages/app/src/lib/modeled-system-power.ts
+++ b/packages/app/src/lib/modeled-system-power.ts
@@ -43,7 +43,13 @@ export type SystemPowerEstimate =
       deploymentFacilityWatts: number;
       pue: number;
       telemetryBasis: 'validated-v2' | 'validated-unversioned-single-node';
-      topologyBasis: 'single-node' | 'worker-hosts';
+      /**
+       * 'single-node': one host, one chassis. 'worker-hosts': one chassis per
+       * measured worker, each at its own telemetry. 'uniform-hosts': an
+       * aggregate multinode deployment whose producer emitted no per-worker
+       * telemetry; every eight-GPU chassis is modeled at the deployment mean.
+       */
+      topologyBasis: 'single-node' | 'worker-hosts' | 'uniform-hosts';
       /**
        * 'full': every chassis had all eight GPUs measured. 'extrapolated': at least
        * one chassis was partially allocated; its model input is the measured per-GPU
@@ -138,7 +144,7 @@ export function modelSystemPower(
   }
 
   const chassis: MeasuredChassis[] = [];
-  let topologyBasis: 'single-node' | 'worker-hosts';
+  let topologyBasis: 'single-node' | 'worker-hosts' | 'uniform-hosts';
   if (row.disagg === false && row.is_multinode === false) {
     // One host cannot hold more than one chassis.
     if (gpuCount > CHASSIS_GPU_COUNT) return unavailable('topology');
@@ -173,6 +179,36 @@ export function modelSystemPower(
           ? m.avg_total_gpu_power_w
           : m.avg_power_w * CHASSIS_GPU_COUNT,
     });
+  } else if (row.disagg === false && (!Array.isArray(row.workers) || row.workers.length === 0)) {
+    // Aggregate multinode producers emit no per-worker telemetry. Symmetric
+    // TP/PP/DP shards load every host alike, so each full eight-GPU chassis is
+    // modeled at the deployment mean; the supported hardware only ships in
+    // eight-GPU hosts, so the count must fill whole chassis on several hosts.
+    // Disaggregated roles differ in load and stay on the worker path.
+    const hostCount = gpuCount / CHASSIS_GPU_COUNT;
+    if (!count(hostCount) || hostCount < 2) return unavailable('topology');
+    const tp = row.decode_tp > 0 ? row.decode_tp : row.prefill_tp;
+    const pp = Math.max(m.pp ?? 1, m.decode_pp ?? 1, m.prefill_pp ?? 1);
+    const pcp = Math.max(m.pcp_size ?? 1, m.decode_pcp_size ?? 1, m.prefill_pcp_size ?? 1);
+    // Data-parallel replicas widen the deployment beyond one TP×PP×PCP group.
+    const replicas = Math.max(1, row.decode_num_workers);
+    if (
+      !count(tp) ||
+      !count(pp) ||
+      !count(pcp) ||
+      !count(replicas) ||
+      tp * pp * pcp * replicas !== gpuCount
+    ) {
+      return unavailable('gpu-count');
+    }
+    topologyBasis = 'uniform-hosts';
+    for (let host = 0; host < hostCount; host++) {
+      chassis.push({
+        measuredGpus: CHASSIS_GPU_COUNT,
+        // Partition the producer's exact total so the chassis inputs sum back to it.
+        modelInputWatts: m.avg_total_gpu_power_w / hostCount,
+      });
+    }
   } else {
     // A role average across several hosts is insufficient for nonlinear
     // fan/PSU evaluation. Require one chassis per measured worker and a
diff --git a/packages/app/src/lib/power-basis.test.ts b/packages/app/src/lib/power-basis.test.ts
new file mode 100644
index 000000000..0aa67a4f5
--- /dev/null
+++ b/packages/app/src/lib/power-basis.test.ts
@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+
+import type { BenchmarkRow } from '@/lib/api';
+import { rowToAggDataEntry, transformBenchmarkRows } from '@/lib/benchmark-transform';
+import { buildDerivedChartFields, getHardwareKey } from '@/lib/chart-utils';
+import { POWER_BASIS_FIELDS } from '@/lib/power-basis';
+
+// Qwen3.5 B200 c1, run 34175132645: actual rounded telemetry, eight GPUs
+// (same fixture as modeled-system-power.test.ts) plus an output rate.
+function row(overrides: Partial<BenchmarkRow> = {}): BenchmarkRow {
+  return {
+    id: 441192,
+    model: 'qwen3.5',
+    hardware: 'b200',
+    framework: 'sglang',
+    precision: 'fp8',
+    spec_method: 'none',
+    disagg: false,
+    is_multinode: false,
+    prefill_tp: 8,
+    prefill_ep: 1,
+    prefill_dp_attention: false,
+    prefill_num_workers: 0,
+    decode_tp: 8,
+    decode_ep: 1,
+    decode_dp_attention: false,
+    decode_num_workers: 0,
+    num_prefill_gpu: 8,
+    num_decode_gpu: 8,
+    benchmark_type: 'single_turn',
+    isl: 8192,
+    osl: 1024,
+    conc: 1,
+    offload_mode: 'off',
+    image: 'lmsysorg/sglang:v0.5.19-cu130',
+    date: '2026-09-08',
+    run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645/attempts/1',
+    metrics: {
+      power_valid: 1,
+      power_metric_schema_version: 2,
+      avg_power_w: 349.859,
+      avg_total_gpu_power_w: 2798.868,
+      total_gpu_energy_j: 120361.299,
+      joules_per_output_token: 12.937902,
+      tput_per_gpu: 270,
+      output_tput_per_gpu: 30,
+      pp: 1,
+      pcp_size: 1,
+      median_intvty: 100,
+    },
+    ...overrides,
+  };
+}
+
+/** Full official-path derivation for one row with real HW_REGISTRY specs. */
+function derive(source: BenchmarkRow) {
+  const entry = rowToAggDataEntry(source);
+  const hwKey = getHardwareKey(entry);
+  return { entry, hwKey, fields: buildDerivedChartFields(entry, hwKey) };
+}
+
+describe('power boundaries through the derived-field builder', () => {
+  it('serves the same fields to ?unofficialrun= overlays through transformBenchmarkRows', () => {
+    const { chartData } = transformBenchmarkRows([row()], 'median', 'external');
+    const point = chartData[0][0];
+    const official = derive(row()).fields;
+    for (const basis of Object.values(POWER_BASIS_FIELDS)) {
+      expect(point[basis.watts]).toEqual(official[basis.watts]);
+      expect(point[basis.energy]).toEqual(official[basis.energy]);
+      expect(point[basis.watts]?.roof).toBe(false);
+    }
+  });
+});
diff --git a/packages/app/src/lib/power-basis.ts b/packages/app/src/lib/power-basis.ts
new file mode 100644
index 000000000..034eeca2d
--- /dev/null
+++ b/packages/app/src/lib/power-basis.ts
@@ -0,0 +1,211 @@
+/**
+ * Power boundaries for one benchmark point, from the GPU board out to the
+ * utility meter. Pure numbers only — no React, DOM, or registry imports — so
+ * the derived-field builder, overlays, and tests share one formula set.
+ *
+ * | Basis                  | W / GPU                                          | J / output token                          |
+ * | ---------------------- | ------------------------------------------------ | ----------------------------------------- |
+ * | B1 gpu-measured        | `avg_power_w` (existing `measuredAvgPower`)      | `joules_per_output_token` (existing)      |
+ * | B2 gpu-provisioned     | `HW_REGISTRY.tdp`                                | W × N_alloc ÷ total output tok/s          |
+ * | B3 utility-provisioned | `HW_REGISTRY.power` × 1000                       | W × N_alloc ÷ total output tok/s          |
+ * | B4 utility-modeled     | modeled `deploymentFacilityWatts` ÷ `gpuCount`   | B1 J/out × (B4 W ÷ B1 W)                  |
+ *
+ * N_alloc counts every allocated GPU (prefill + decode for disaggregation);
+ * total output tok/s is the whole deployment's. B4 reuses the estimate that
+ * `modelSystemPower` already attached to the entry — PUE is applied exactly
+ * once inside that model, never here — and is withheld wherever B1 is.
+ * Unavailable values are `null`; callers omit the field rather than plotting 0.
+ */
+import type { AggDataEntry, InferenceData, PowerBasisFieldKey } from '@/components/inference/types';
+
+export const POWER_BASES = [
+  'gpu-measured',
+  'gpu-provisioned',
+  'utility-provisioned',
+  'utility-modeled',
+] as const;
+export type PowerBasis = (typeof POWER_BASES)[number];
+export type PowerQuantity = 'watts' | 'energy';
+
+export const POWER_BASIS_LABELS: Record<PowerBasis, { en: string; zh: string }> = {
+  'gpu-measured': { en: 'GPU measured', zh: 'GPU 实测' },
+  'gpu-provisioned': { en: 'GPU provisioned (TDP)', zh: 'GPU 额定（TDP）' },
+  'utility-provisioned': { en: 'Utility provisioned (all-in)', zh: '全电源配置（all-in）' },
+  'utility-modeled': { en: 'Utility modeled (PUE)', zh: '数据中心建模（含 PUE）' },
+};
+
+/** InferenceData keys per derived basis and quantity. B1 lives on the measured* fields. */
+export const POWER_BASIS_FIELDS: Record<
+  Exclude<PowerBasis, 'gpu-measured'>,
+  Record<PowerQuantity, PowerBasisFieldKey>
+> = {
+  'gpu-provisioned': {
+    watts: 'gpuProvisionedWatts',
+    energy: 'gpuProvisionedJPerOutputToken',
+  },
+  'utility-provisioned': {
+    watts: 'utilityProvisionedWatts',
+    energy: 'utilityProvisionedJPerOutputToken',
+  },
+  'utility-modeled': {
+    watts: 'utilityModeledWatts',
+    energy: 'utilityModeledJPerOutputToken',
+  },
+};
+
+export interface PowerBasisInput {
+  /** B2 W/GPU: HW_REGISTRY tdp. 0 means the spec is not yet available. */
+  tdpWatts: number | null;
+  /** B3 W/GPU: HW_REGISTRY all-in power, already in watts. */
+  utilityWatts: number | null;
+  /** Every GPU the deployment occupies (prefill + decode for disaggregation). */
+  allocatedGpus: number | null;
+  /** Whole-deployment successful output tokens per second. */
+  totalOutputTokPerSec: number | null;
+  /** B1 W/GPU from validated telemetry. */
+  measuredWatts: number | null;
+  /** B1 J/output token from the same telemetry window. */
+  measuredJPerOutputToken: number | null;
+  /**
+   * B4 W/GPU: modeled facility watts (PUE already applied) per measured GPU.
+   * B4 is a scaling of B1, so it is withheld whenever `measuredWatts` is null.
+   */
+  modeledFacilityWattsPerGpu: number | null;
+}
+
+export type PowerBasisValues = Record<PowerBasisFieldKey, number | null>;
+
+const positive = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isFinite(value) && value > 0;
+const count = (value: unknown): value is number => positive(value) && Number.isSafeInteger(value);
+const orNull = (value: number): number | null => (positive(value) ? value : null);
+
+/**
+ * Derives the B2–B4 boundary values from plain numbers. Any unavailable input
+ * yields `null` for the values that depend on it and leaves the rest intact.
+ */
+export function computePowerBasisFields(input: PowerBasisInput): PowerBasisValues {
+  const tdp = positive(input.tdpWatts) ? input.tdpWatts : null;
+  const utility = positive(input.utilityWatts) ? input.utilityWatts : null;
+  const measuredWatts = positive(input.measuredWatts) ? input.measuredWatts : null;
+  const measuredJ = positive(input.measuredJPerOutputToken) ? input.measuredJPerOutputToken : null;
+  // B4 is B1 carried out to the utility meter, so it follows B1's availability:
+  // no measured watts, no modeled boundary (B3 ≥ B4 ≥ B1 needs its anchor).
+  const modeled =
+    measuredWatts !== null && positive(input.modeledFacilityWattsPerGpu)
+      ? input.modeledFacilityWattsPerGpu
+      : null;
+
+  // Provisioned energy: GPU-seconds spent per output token by the whole
+  // deployment (N_alloc ÷ total tok/s) × W per GPU = J per output token.
+  const gpuSecondsPerOutputToken =
+    positive(input.allocatedGpus) && positive(input.totalOutputTokPerSec)
+      ? input.allocatedGpus / input.totalOutputTokPerSec
+      : null;
+  const provisionedEnergy = (watts: number | null) =>
+    watts !== null && gpuSecondsPerOutputToken !== null
+      ? orNull(watts * gpuSecondsPerOutputToken)
+      : null;
+
+  // Modeled energy scales the producer's same-window E/N by modeled ÷ measured W,
+  // so it inherits B1's token denominator instead of re-deriving one.
+  const modeledEnergy =
+    modeled !== null && measuredWatts !== null && measuredJ !== null
+      ? orNull((measuredJ * modeled) / measuredWatts)
+      : null;
+
+  return {
+    gpuProvisionedWatts: tdp,
+    gpuProvisionedJPerOutputToken: provisionedEnergy(tdp),
+    utilityProvisionedWatts: utility,
+    utilityProvisionedJPerOutputToken: provisionedEnergy(utility),
+    utilityModeledWatts: modeled,
+    utilityModeledJPerOutputToken: modeledEnergy,
+  };
+}
+
+type PowerBasisEntry = Pick<
+  AggDataEntry,
+  | 'output_tput_per_gpu'
+  | 'disagg'
+  | 'benchmark_type'
+  | 'num_prefill_gpu'
+  | 'num_decode_gpu'
+  | 'avg_power_w'
+  | 'joules_per_output_token'
+  | 'modeledSystemPower'
+>;
+
+/**
+ * Whole-deployment normalization for the provisioned energies. Aggregate rows
+ * already report output per allocated GPU, so N_alloc cancels and the ratio
+ * 1 GPU : per-GPU throughput is exact without trusting display counts (legacy
+ * ingest can encode TP × EP twice). Fixed-sequence disaggregated rows report
+ * output per decode GPU while the deployment also powers the prefill pool, so
+ * total output = per-GPU × decode GPUs and N_alloc = prefill + decode GPUs.
+ * Other disaggregated benchmark types are left out: whether AgentX throughput
+ * already divides by all GPUs is not verifiable in-app.
+ */
+export function powerBasisNormalization(
+  entry: Pick<
+    PowerBasisEntry,
+    'output_tput_per_gpu' | 'disagg' | 'benchmark_type' | 'num_prefill_gpu' | 'num_decode_gpu'
+  >,
+): Pick<PowerBasisInput, 'allocatedGpus' | 'totalOutputTokPerSec'> {
+  const perGpu = entry.output_tput_per_gpu;
+  const unavailable = { allocatedGpus: null, totalOutputTokPerSec: null };
+  if (!positive(perGpu)) return unavailable;
+  if (!entry.disagg) return { allocatedGpus: 1, totalOutputTokPerSec: perGpu };
+  if (entry.benchmark_type !== 'single_turn') return unavailable;
+  const prefill = entry.num_prefill_gpu;
+  const decode = entry.num_decode_gpu;
+  if (!count(prefill) || !count(decode)) return unavailable;
+  return { allocatedGpus: prefill + decode, totalOutputTokPerSec: perGpu * decode };
+}
+
+/**
+ * B4 W/GPU from the estimate `rowToAggDataEntry` attached. The model owns
+ * telemetry admission: `modelSystemPower` requires `power_valid === 1` plus
+ * schema v2, or the validated unversioned single-node producer it records as
+ * `telemetryBasis: 'validated-unversioned-single-node'`. That is the same
+ * population the app plots as B1 (`measuredAvgPower`) and as
+ * `modeledChassisPowerPerGpu`, so B4 renders exactly where they do. The public
+ * API's stricter `strictV2` row filter is not re-applied here; it is not
+ * applied to the chart's B1 either.
+ */
+export function modeledFacilityWattsPerGpu(
+  entry: Pick<PowerBasisEntry, 'modeledSystemPower'>,
+): number | null {
+  const model = entry.modeledSystemPower;
+  if (model?.status !== 'supported') return null;
+  if (!positive(model.deploymentFacilityWatts) || !count(model.gpuCount)) return null;
+  return orNull(model.deploymentFacilityWatts / model.gpuCount);
+}
+
+export type PowerBasisChartFields = Partial<Pick<InferenceData, PowerBasisFieldKey>>;
+
+/**
+ * Chart-shaped B2–B4 fields for one entry. Keys are present only for finite,
+ * positive values: the metric filters drop a point by `metricKey in point`,
+ * and the coordinate remap falls back to raw throughput when a key exists
+ * with an unusable value.
+ */
+export function buildPowerBasisChartFields(
+  entry: PowerBasisEntry,
+  specs: { tdp?: number; power?: number },
+): PowerBasisChartFields {
+  const values = computePowerBasisFields({
+    tdpWatts: specs.tdp ?? null,
+    utilityWatts: positive(specs.power) ? specs.power * 1000 : null,
+    ...powerBasisNormalization(entry),
+    measuredWatts: entry.avg_power_w ?? null,
+    measuredJPerOutputToken: entry.joules_per_output_token ?? null,
+    modeledFacilityWattsPerGpu: modeledFacilityWattsPerGpu(entry),
+  });
+  const fields: PowerBasisChartFields = {};
+  for (const key of Object.keys(values) as PowerBasisFieldKey[]) {
+    const y = values[key];
+    if (y !== null) fields[key] = { y, roof: false };
+  }
+  return fields;
+}
diff --git a/packages/app/src/lib/url-state.ts b/packages/app/src/lib/url-state.ts
index da7bb00d3..78755aa95 100644
--- a/packages/app/src/lib/url-state.ts
+++ b/packages/app/src/lib/url-state.ts
@@ -63,6 +63,12 @@ const URL_STATE_KEYS = [
   'i_spec',
   // Measured-power certification tiers ('certified' / 'legacy', comma-joined).
   'i_power',
+  // Completed Perf Rulers on the primary inference chart: `isoX|curveA|curveB`
+  // entries joined by `;` (see serializePerfRulers in d3-chart/layers/perf-ruler).
+  'i_rulers',
+  // Comparison series overlaid on a gated power metric: `boundaries` (every
+  // power boundary) or `roles` (prefill / decode pools). Empty = the metric alone.
+  'i_pcompare',
   // Exact serving-envelope pair behind an Overview 30-day comparison cell.
   'i_overview_current',
   'i_overview_baseline',
@@ -177,6 +183,8 @@ export const PARAM_DEFAULTS: Record<UrlStateKey, string> = {
   i_disagg: '',
   i_spec: '',
   i_power: '',
+  i_rulers: '',
+  i_pcompare: '',
   i_overview_current: '',
   i_overview_baseline: '',
   e_rundate: '',
@@ -492,6 +500,26 @@ export function rememberChartStateInUrl(): string {
   return chartParams.toString();
 }
 
+/**
+ * The current page's URL carrying its chart state plus `overrides`,
+ * canonicalised like `rememberChartStateInUrl`: chart params and both
+ * unofficial-run spellings are dropped from the live address bar before the
+ * store's state (and the overrides) are layered on. For anchors that must
+ * work with open-in-new-tab, where the in-memory state would otherwise be lost.
+ */
+export function chartStateHref(overrides: Record<string, string>): string {
+  const { origin, pathname, hash, search } = window.location;
+  const merged = new URLSearchParams(search);
+  for (const key of URL_STATE_KEYS) merged.delete(key);
+  // Collected first: deleting while iterating the params would skip entries.
+  const staleRunKeys = [...merged.keys()].filter((key) => UNOFFICIAL_RUN_PARAM_RE.test(key));
+  for (const key of staleRunKeys) merged.delete(key);
+  for (const [key, value] of collectTabParams()) merged.set(key, value);
+  for (const [key, value] of Object.entries(overrides)) merged.set(key, value);
+  const query = merged.toString();
+  return `${origin}${pathname}${query ? `?${query}` : ''}${hash}`;
+}
+
 /**
  * Append the current chart state to an outbound in-app href, so the page it
  * opens can link back to the chart the user left. Used for the agentic

From f1422bd81ec3bca796d9e7cc79c23617b7de73d3 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 066/103] ci: migrate before ingest and support Neon branch
 targets
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Run admin:db:migrate before ingest and overrides so writers never meet a missing
column; let agentic ingest target a Neon branch; only invalidate the cache after
overrides actually applied.

中文：ingest 与 overrides 前先执行 admin:db:migrate，避免写入端遇到缺列；agentic ingest 可指向 Neon 分支；仅在 overrides 实际生效后失效缓存。
---
 .github/workflows/apply-run-overrides.yml    | 16 ++++++++++++++++
 .github/workflows/ingest-agentic-results.yml | 12 ++++++++++++
 .github/workflows/ingest-results.yml         |  2 ++
 3 files changed, 30 insertions(+)

diff --git a/.github/workflows/apply-run-overrides.yml b/.github/workflows/apply-run-overrides.yml
index 749880e80..819f09aca 100644
--- a/.github/workflows/apply-run-overrides.yml
+++ b/.github/workflows/apply-run-overrides.yml
@@ -53,7 +53,18 @@ jobs:
         env:
           CYPRESS_INSTALL_BINARY: '0'
 
+      # This workflow fires on a push to run-overrides.ts, which can land before the
+      # next ingest dispatch has applied a pending migration. admin:db:verify counts
+      # every table it knows about, so without this step it fails on a schema the
+      # checked-out ref expects but production does not have yet. Same command and
+      # ordering as ingest-results.yml; migrations are idempotent by filename.
+      - name: Run migrations
+        env:
+          DATABASE_WRITE_URL: ${{ secrets.DATABASE_WRITE_URL }}
+        run: bun run admin:db:migrate --yes
+
       - name: Apply run overrides
+        id: apply
         env:
           DATABASE_WRITE_URL: ${{ secrets.DATABASE_WRITE_URL }}
           RUN_ID: ${{ inputs.run_id }}
@@ -69,10 +80,15 @@ jobs:
           DATABASE_WRITE_URL: ${{ secrets.DATABASE_WRITE_URL }}
         run: bun run admin:db:verify
 
+      # Once the overrides are in the database the CDN is stale, so these must run
+      # even if the verify step above fails. Skipping them leaves the dashboard
+      # serving pre-override data with only a red workflow as the signal.
       - name: Invalidate production cache
+        if: ${{ always() && steps.apply.outcome == 'success' }}
         env:
           INVALIDATE_SECRET: ${{ secrets.VERCEL_INVALIDATE_SECRET }}
         run: bun run admin:cache:invalidate https://inferencex.semianalysis.com
 
       - name: Warm production cache
+        if: ${{ always() && steps.apply.outcome == 'success' }}
         run: bun run admin:cache:warmup https://inferencex.semianalysis.com
diff --git a/.github/workflows/ingest-agentic-results.yml b/.github/workflows/ingest-agentic-results.yml
index b81cd68b0..3dcd23773 100644
--- a/.github/workflows/ingest-agentic-results.yml
+++ b/.github/workflows/ingest-agentic-results.yml
@@ -31,6 +31,11 @@ on:
         description: InferenceX Actions run ID to ingest
         required: true
         type: string
+      require-power:
+        description: Require the versioned PowerX manifest and all declared evidence
+        required: false
+        default: false
+        type: boolean
       run-attempt:
         description: InferenceX Actions run attempt to ingest
         required: false
@@ -85,6 +90,11 @@ on:
         description: InferenceX Actions run ID to ingest
         required: true
         type: string
+      require-power:
+        description: Require the versioned PowerX manifest and all declared evidence
+        required: false
+        default: false
+        type: boolean
       run-attempt:
         description: InferenceX Actions run attempt to ingest
         required: false
@@ -276,6 +286,7 @@ jobs:
             github.event.client_payload.run-id || inputs.run-id }}
           ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true || inputs.require-power == true }}
         run: bun run admin:db:prepare:ci
 
       - name: Run migrations
@@ -288,6 +299,7 @@ jobs:
           INGEST_RUN_ATTEMPT: ${{ steps.artifacts.outputs.merge-run-attempt }}
           INGEST_ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true || inputs.require-power == true }}
           UNMAPPED_ENTITIES_OUTPUT: ${{ github.workspace }}/unmapped-entities.json
           POWER_PUBLICATION_MANIFEST: ${{ github.workspace }}/power-publication.json
         run: bun run admin:db:ingest:ci
diff --git a/.github/workflows/ingest-results.yml b/.github/workflows/ingest-results.yml
index 04b253e34..d66e50a8f 100644
--- a/.github/workflows/ingest-results.yml
+++ b/.github/workflows/ingest-results.yml
@@ -60,6 +60,7 @@ jobs:
             github.event.client_payload.run-id }}
           ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true }}
         run: bun run admin:db:prepare:ci
 
       - name: Run migrations
@@ -75,6 +76,7 @@ jobs:
           INGEST_RUN_ATTEMPT: ${{ steps.artifacts.outputs.merge-run-attempt }}
           INGEST_ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true }}
           POWER_PUBLICATION_MANIFEST: ${{ github.workspace }}/power-publication.json
           UNMAPPED_ENTITIES_OUTPUT: ${{ github.workspace }}/unmapped-entities.json
         run: bun run admin:db:ingest:ci

From 9096c00b2ac54d4333763125590c017818a7fd89 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 067/103] feat(ui): persist perf rulers in share links
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Serialize curve-to-curve perf rulers into the i_rulers URL parameter and restore them on
load; the InferenceContext and url-state wiring lives in the boundary-metrics commit.

中文：把曲线间 perf ruler 序列化到 i_rulers URL 参数并在加载时恢复；InferenceContext 与 url-state 的接线在边界指标提交中。
---
 .../components/inference/perf-ruler-store.ts  | 179 ++++++++++++++++++
 .../lib/d3-chart/layers/perf-ruler.test.ts    |  30 +++
 .../app/src/lib/d3-chart/layers/perf-ruler.ts |  66 +++++++
 3 files changed, 275 insertions(+)
 create mode 100644 packages/app/src/components/inference/perf-ruler-store.ts

diff --git a/packages/app/src/components/inference/perf-ruler-store.ts b/packages/app/src/components/inference/perf-ruler-store.ts
new file mode 100644
index 000000000..98bbfd692
--- /dev/null
+++ b/packages/app/src/components/inference/perf-ruler-store.ts
@@ -0,0 +1,179 @@
+'use client';
+
+import {
+  type Dispatch,
+  type SetStateAction,
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+import { track } from '@/lib/analytics';
+import { perfRulerAxisMetricKey } from '@/hooks/usePerfRulerAxisReset';
+import {
+  EMPTY_PERF_RULER_STATE,
+  MAX_PERF_RULERS,
+  type PerfRulerMeasurement,
+  type PerfRulerState,
+  clearPerfRulers,
+  parsePerfRulers,
+} from '@/lib/d3-chart/layers/perf-ruler';
+
+/**
+ * @file perf-ruler-store.ts
+ * @description Provider-owned Perf Ruler state for the primary inference
+ * chart, so completed rulers persist in share links (`i_rulers`). Lives
+ * beside `InferenceContext` rather than inside it so `ScatterGraph` can
+ * consume the store without importing the (heavily mocked) provider module.
+ */
+
+/**
+ * The chart instance whose Perf Rulers persist in share links. `ChartDisplay`
+ * mounts the primary chart as `chart-${graphIndex}` and only graph 0 is ever
+ * visible; the replay chart (`replay-chart-0`) draws interpolated frames of
+ * the same curves and must NOT bind, or every ruler would render twice and
+ * the replay's prune pass could delete rulers the main chart still shows.
+ */
+export const PERSISTED_PERF_RULER_CHART_ID = 'chart-0';
+
+/**
+ * Perf-ruler store for the persisted chart. Lives in its own context rather
+ * than the Display domain so a ruler commit does not rerender every display
+ * consumer, and so harnesses that mount `InferenceContextsProvider` with
+ * static mock values (no store) keep the chart's component-local fallback.
+ *
+ * `state` holds COMMITTED rulers: the D3 layer renders them and `i_rulers`
+ * serializes them. `pending` holds rulers parsed from the share link whose
+ * curves may not have been drawn yet — data, `i_gpus`, comparison dates,
+ * and `?unofficialrun=` overlays all arrive after the chart's first draw,
+ * and the chart prunes any committed ruler whose curve path is absent from
+ * the DOM. The chart therefore commits a pending ruler only once BOTH of
+ * its curve paths exist (see the perf-ruler decoration effect in
+ * ScatterGraph); rulers whose curves never appear stay pending, invisible
+ * and unserialized, until an axis change or an explicit clear discards them.
+ */
+export interface PerfRulerStore {
+  chartId: string;
+  state: PerfRulerState;
+  setState: Dispatch<SetStateAction<PerfRulerState>>;
+  pending: readonly PerfRulerMeasurement[] | null;
+  /**
+   * Commit share-link rulers whose curves now exist (`resolved`, iso-x
+   * already clamped to the pair's overlap) and keep `remaining` pending.
+   */
+  commitPending: (
+    resolved: readonly PerfRulerMeasurement[],
+    remaining: readonly PerfRulerMeasurement[] | null,
+  ) => void;
+  /** Drop share-link rulers that were never committed (toggle-off, clear). */
+  discardPending: () => void;
+}
+
+/**
+ * Axis identity of the chart `ChartDisplay` renders as `chart-0`, for the
+ * store's axis reset. `graphs` is always `[interactivity, e2e]`, but
+ * ChartDisplay shows the e2e graph for every non-interactivity x mode
+ * (`visibleGraphs`), so the rendered chart — not `graphs[0]` — is what the
+ * rulers were placed on. The x mode itself is part of the identity as well:
+ * the derived agentic modes (e2e-normalized interactivity, …) override the
+ * e2e graph's `x_scale_field` inside ChartDisplay only, so here the same
+ * definition still reads `<pctl>_e2el` for those modes. Percentile changes
+ * are already encoded in `x_scale_field`. Null while no graph exists.
+ */
+export function persistedPerfRulerAxisKey(
+  graphs: readonly { chartDefinition: { chartType: string; x_scale_field: string } }[],
+  xAxisMode: string,
+  yAxisMetric: string,
+): string | null {
+  const wantedType = xAxisMode === 'interactivity' ? 'interactivity' : 'e2e';
+  const graph =
+    graphs.find((candidate) => candidate.chartDefinition.chartType === wantedType) ?? graphs[0];
+  if (!graph) return null;
+  return perfRulerAxisMetricKey(`${xAxisMode}:${graph.chartDefinition.x_scale_field}`, yAxisMetric);
+}
+
+/** Provided by `InferenceProvider`; exported for chart component tests. */
+export const PerfRulerStoreContext = createContext<PerfRulerStore | undefined>(undefined);
+
+/** The persisted-ruler store, or undefined outside `InferenceProvider`. */
+export function usePerfRulerStore(): PerfRulerStore | undefined {
+  return useContext(PerfRulerStoreContext);
+}
+
+/**
+ * Owns the persisted perf-ruler state. Exported so component tests can host a
+ * real store around a chart without the full provider.
+ *
+ * `axisMetricKey` is the persisted chart's axis identity
+ * ({@link persistedPerfRulerAxisKey}), or null while no chart definition exists.
+ * The axis reset runs HERE, not through `usePerfRulerAxisReset` in the chart:
+ * that hook adjusts state during the chart's render, which is only legal for
+ * the chart's own state — updating a provider's state from a child's render
+ * is a React error. Same semantics: a change of either axis metric clears
+ * committed rulers (redrawn curves would give a ratio nobody placed) and
+ * discards pending ones (they were placed on the old axes). The null → key
+ * transition on first data is not a change, so share-link rulers survive
+ * the load; the x-mode fallback for fixed sequences also settles before any
+ * chart definition exists.
+ */
+export function usePerfRulerStoreValue(
+  chartId: string,
+  initialSerialized: string | undefined,
+  axisMetricKey: string | null,
+): PerfRulerStore {
+  const [state, setState] = useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
+  const [pending, setPending] = useState<readonly PerfRulerMeasurement[] | null>(() => {
+    const parsed = parsePerfRulers(initialSerialized).rulers;
+    return parsed.length > 0 ? parsed : null;
+  });
+  // `interactivity_perf_ruler_shared_load` fires once per store — once per
+  // opened link — with the number of rulers the link carried, the first time
+  // any of them renders. Rulers commit per curve arrival (below), so a
+  // per-commit event would count one link several times with partial counts.
+  const linkRulerCountRef = useRef(pending?.length ?? 0);
+  const sharedLoadReportedRef = useRef(false);
+
+  const [appliedAxisMetricKey, setAppliedAxisMetricKey] = useState(axisMetricKey);
+  if (axisMetricKey !== null && axisMetricKey !== appliedAxisMetricKey) {
+    setAppliedAxisMetricKey(axisMetricKey);
+    if (appliedAxisMetricKey !== null) {
+      setState(clearPerfRulers);
+      setPending(null);
+    }
+  }
+
+  const commitPending = useCallback(
+    (
+      resolved: readonly PerfRulerMeasurement[],
+      remaining: readonly PerfRulerMeasurement[] | null,
+    ) => {
+      if (resolved.length > 0) {
+        setState((prev) => {
+          // Fresh ids from the live counter: a ruler placed by hand before the
+          // share-link rulers resolved must keep its own join key.
+          const rulers = [
+            ...prev.rulers,
+            ...resolved.map((ruler, index) => ({ ...ruler, id: prev.nextId + index })),
+          ];
+          while (rulers.length > MAX_PERF_RULERS) rulers.shift();
+          return { rulers, draft: prev.draft, nextId: prev.nextId + resolved.length };
+        });
+        if (!sharedLoadReportedRef.current) {
+          sharedLoadReportedRef.current = true;
+          track('interactivity_perf_ruler_shared_load', { count: linkRulerCountRef.current });
+        }
+      }
+      setPending(remaining);
+    },
+    [],
+  );
+  const discardPending = useCallback(() => setPending(null), []);
+
+  return useMemo(
+    () => ({ chartId, state, setState, pending, commitPending, discardPending }),
+    [chartId, state, pending, commitPending, discardPending],
+  );
+}
diff --git a/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts b/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
index d50fe1573..c7cc0ad80 100644
--- a/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
+++ b/packages/app/src/lib/d3-chart/layers/perf-ruler.test.ts
@@ -16,10 +16,12 @@ import {
   isPerfRulerCurveVisible,
   movePerfRulerIsoX,
   nextPerfRulerState,
+  parsePerfRulers,
   pathXExtent,
   perfRulerCurveSet,
   prunePerfRulers,
   renderPerfRulers,
+  serializePerfRulers,
   type PerfRulerEndInput,
   type PerfRulerGeometry,
   type PerfRulerLabelLayoutOptions,
@@ -889,6 +891,34 @@ describe('perfRulerCurveSet', () => {
   });
 });
 
+// ── serializePerfRulers / parsePerfRulers (share links) ─────────────
+
+describe('serializePerfRulers / parsePerfRulers', () => {
+  const OFFICIAL_A = 'roofline-b200_trt_fp8';
+  const OFFICIAL_B = 'roofline-mi355x_sglang_fp4';
+  // Overlay curves carry the unofficial run index; power-envelope curves are
+  // split per date with the encoded date appended (`%2F` from a slash).
+  const OVERLAY = 'overlay-roofline-h100_vllm_fp8_run1__2026-09%2F11';
+
+  it('round-trips completed rulers, including overlay and date-scoped curve ids', () => {
+    const state = complete(
+      complete(EMPTY_PERF_RULER_STATE, OFFICIAL_A, OFFICIAL_B, 41.5),
+      OFFICIAL_A,
+      OVERLAY,
+      120,
+    );
+    const encoded = serializePerfRulers(state);
+    expect(encoded).toBe(`41.5|${OFFICIAL_A}|${OFFICIAL_B};120|${OFFICIAL_A}|${OVERLAY}`);
+    const parsed = parsePerfRulers(encoded);
+    expect(parsed.rulers).toEqual([
+      { id: 1, curveA: OFFICIAL_A, curveB: OFFICIAL_B, isoX: 41.5 },
+      { id: 2, curveA: OFFICIAL_A, curveB: OVERLAY, isoX: 120 },
+    ]);
+    expect(parsed.draft).toBeNull();
+    expect(parsed.nextId).toBe(3);
+  });
+});
+
 // ── pathXExtent ─────────────────────────────────────────────
 
 describe('pathXExtent', () => {
diff --git a/packages/app/src/lib/d3-chart/layers/perf-ruler.ts b/packages/app/src/lib/d3-chart/layers/perf-ruler.ts
index c44143529..ef13b2a1d 100644
--- a/packages/app/src/lib/d3-chart/layers/perf-ruler.ts
+++ b/packages/app/src/lib/d3-chart/layers/perf-ruler.ts
@@ -323,6 +323,72 @@ export function prunePerfRulers(
   return { ...prev, rulers, draft };
 }
 
+const PERF_RULER_URL_RULER_SEPARATOR = ';';
+const PERF_RULER_URL_FIELD_SEPARATOR = '|';
+/**
+ * Shape of a curve id the link may reference: one roofline path's identity
+ * class (`roofline-<series>` / `overlay-roofline-<series>`), never the shared
+ * `roofline-path` / `overlay-roofline-path` marker classes or any other node
+ * inside the zoom group — those match many paths, so a hand-edited link
+ * would draw a ruler between whichever two come first in DOM order.
+ */
+const PERF_RULER_CURVE_ID = /^(?:overlay-)?roofline-(?!path$)[\w%.-]+$/u;
+
+/**
+ * Share-link encoding of the COMPLETED rulers (`i_rulers`). One ruler per
+ * `;`, fields joined by `|`: `isoX|curveA|curveB`. Curve ids are the rendered
+ * roofline path identity classes (`roofline-<hwKey>_<precision>`,
+ * `overlay-roofline-<hwKey>_<precision>_run<N>`, optionally `__<encoded
+ * date>`), whose alphabet is `[A-Za-z0-9_%.-]`, so neither separator can
+ * appear inside one; `URLSearchParams` percent-encodes both on the wire.
+ * The iso-x is rounded to four significant digits to keep links short — a
+ * 0.05% shift on the x metric is far below the ruler's visual resolution.
+ * The draft is never serialized: it is an unfinished click, not a
+ * measurement. Empty state serializes to '' so the param strips as default.
+ */
+export function serializePerfRulers(state: PerfRulerState): string {
+  return state.rulers
+    .map((ruler) =>
+      [Number(ruler.isoX.toPrecision(4)), ruler.curveA, ruler.curveB].join(
+        PERF_RULER_URL_FIELD_SEPARATOR,
+      ),
+    )
+    .join(PERF_RULER_URL_RULER_SEPARATOR);
+}
+
+/**
+ * Inverse of {@link serializePerfRulers}. Malformed entries (wrong field
+ * count, non-numeric iso-x, identical curve ids, or ids that are not
+ * roofline identity classes) are dropped silently — a hand-edited or
+ * truncated link degrades to fewer rulers, never to an error. The list is capped at
+ * {@link MAX_PERF_RULERS} keeping the NEWEST (last-serialized) entries, the
+ * same end the click reducer drops from. Ids are reassigned 1..n with
+ * `nextId = n + 1`, so parsed rulers are valid D3 join keys and a ruler
+ * placed afterwards never collides. Returns {@link EMPTY_PERF_RULER_STATE}
+ * (same reference) for '', null, or an all-malformed value.
+ */
+export function parsePerfRulers(raw: string | null | undefined): PerfRulerState {
+  if (!raw) return EMPTY_PERF_RULER_STATE;
+  const parsed: Omit<PerfRulerMeasurement, 'id'>[] = [];
+  for (const entry of raw.split(PERF_RULER_URL_RULER_SEPARATOR)) {
+    const fields = entry.split(PERF_RULER_URL_FIELD_SEPARATOR);
+    if (fields.length !== 3) continue;
+    const [isoXField, curveA, curveB] = fields;
+    if (isoXField.trim() === '' || curveA === curveB) continue;
+    if (!PERF_RULER_CURVE_ID.test(curveA) || !PERF_RULER_CURVE_ID.test(curveB)) continue;
+    const isoX = Number(isoXField);
+    if (!Number.isFinite(isoX)) continue;
+    parsed.push({ curveA, curveB, isoX });
+  }
+  if (parsed.length === 0) return EMPTY_PERF_RULER_STATE;
+  const kept = parsed.slice(-MAX_PERF_RULERS);
+  return {
+    rulers: kept.map((ruler, index) => ({ id: index + 1, ...ruler })),
+    draft: null,
+    nextId: kept.length + 1,
+  };
+}
+
 /** Every curve referenced by any ruler or the draft (hit-halo styling). */
 export function perfRulerCurveSet(state: PerfRulerState): Set<string> {
   const curves = new Set<string>();

From 61c3ac006e9d29d470a4087b2f228205fe5d1c54 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 068/103] feat(api): DB-first gpu-metrics routes, point cache
 and views parity
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Serve /api/gpu-metrics from the database first and fall back to live GitHub artifacts
only when a run is not ingested; add /api/v1/gpu-metrics-point behind a revision-keyed
Blob cache; keep the public views route shape identical for stored and live runs and
normalize live NVIDIA timestamps to ISO UTC.

中文：/api/gpu-metrics 优先读数据库，仅在 run 未入库时回退到 GitHub artifact；新增以 revision 为键的 Blob 缓存 /api/v1/gpu-metrics-point；公开 views 路由对入库与 live run 保持同一形状，live NVIDIA 时间戳归一为 ISO UTC。
---
 packages/app/scripts/powerx-blob-fixture.ts   |  76 +++
 .../app/api/gpu-metrics/route.context.test.ts | 109 +++
 .../app/api/gpu-metrics/route.sources.test.ts | 120 ++++
 .../app/src/app/api/gpu-metrics/route.test.ts | 343 +++++++++-
 packages/app/src/app/api/gpu-metrics/route.ts | 625 +++++++++++++++++-
 .../api/v1/gpu-metrics-point/route.test.ts    | 264 ++++++++
 .../src/app/api/v1/gpu-metrics-point/route.ts |  46 ++
 .../src/app/api/v1/views/extensions.test.ts   |   2 +-
 .../api/v1/views/gpu-metrics/route.test.ts    | 101 +++
 .../src/app/api/v1/views/gpu-metrics/route.ts |  33 +-
 .../gpu-power/power-audit-bundle.test.ts      | 164 +++++
 .../gpu-power/power-audit-bundle.ts           | 373 +++++++++++
 .../components/gpu-power/power-series.test.ts | 103 +++
 .../src/components/gpu-power/power-series.ts  | 212 ++++++
 .../gpu-power/stored-gpu-stats.test.ts        | 128 ++++
 .../components/gpu-power/stored-gpu-stats.ts  |  30 +
 .../gpu-power/stored-power-series.ts          | 168 +++++
 .../app/src/hooks/api/benchmark-id-query.ts   |   2 +
 .../src/hooks/api/use-gpu-metrics-point.ts    |  24 +
 packages/app/src/lib/api-route-catalog.ts     |  64 +-
 packages/app/src/lib/github-artifacts.test.ts |   6 +-
 packages/app/src/lib/github-artifacts.ts      |  20 +-
 .../app/src/lib/views-api/docs/extensions.ts  |  24 +-
 .../skills/inferencex-api/integrity.json      |   2 +-
 .../references/dashboard-views.md             |  13 +-
 25 files changed, 2957 insertions(+), 95 deletions(-)
 create mode 100644 packages/app/scripts/powerx-blob-fixture.ts
 create mode 100644 packages/app/src/app/api/gpu-metrics/route.context.test.ts
 create mode 100644 packages/app/src/app/api/gpu-metrics/route.sources.test.ts
 create mode 100644 packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
 create mode 100644 packages/app/src/app/api/v1/gpu-metrics-point/route.ts
 create mode 100644 packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
 create mode 100644 packages/app/src/components/gpu-power/power-audit-bundle.test.ts
 create mode 100644 packages/app/src/components/gpu-power/power-audit-bundle.ts
 create mode 100644 packages/app/src/components/gpu-power/power-series.test.ts
 create mode 100644 packages/app/src/components/gpu-power/power-series.ts
 create mode 100644 packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
 create mode 100644 packages/app/src/components/gpu-power/stored-gpu-stats.ts
 create mode 100644 packages/app/src/components/gpu-power/stored-power-series.ts
 create mode 100644 packages/app/src/hooks/api/use-gpu-metrics-point.ts

diff --git a/packages/app/scripts/powerx-blob-fixture.ts b/packages/app/scripts/powerx-blob-fixture.ts
new file mode 100644
index 000000000..ea283fc10
--- /dev/null
+++ b/packages/app/scripts/powerx-blob-fixture.ts
@@ -0,0 +1,76 @@
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+
+/** Local HTTP transport for the real Blob SDK; never contacts a Blob store. */
+export async function startPowerxBlobFixture(port = 0) {
+  const objects = new Map<string, string>();
+  const counts = { reads: 0, writes: 0, failedWrites: 0 };
+  let rejectWrites = false;
+  const server = createServer(async (request, response) => {
+    const url = new URL(request.url!, 'http://localhost');
+    const pathname = url.searchParams.get('pathname') ?? url.searchParams.get('url');
+    response.setHeader('content-type', 'application/json');
+    const fail = (status: number, code: string) => {
+      response.writeHead(status);
+      response.end(JSON.stringify({ error: { code, message: code } }));
+    };
+    if (url.pathname === '/body') {
+      counts.reads++;
+      const body = objects.get(pathname!);
+      if (body === undefined) return fail(404, 'not_found');
+      response.end(body);
+      return;
+    }
+    if (!pathname) return fail(400, 'bad_request');
+    if (request.method === 'PUT') {
+      counts.writes++;
+      if (rejectWrites) {
+        counts.failedWrites++;
+        request.resume();
+        return fail(403, 'forbidden');
+      }
+      const chunks: Buffer[] = [];
+      for await (const chunk of request) chunks.push(Buffer.from(chunk));
+      objects.set(pathname, Buffer.concat(chunks).toString());
+    }
+    if (!objects.has(pathname)) return fail(404, 'not_found');
+    const address = server.address() as AddressInfo;
+    const bodyUrl = `http://127.0.0.1:${address.port}/body?url=${encodeURIComponent(pathname)}`;
+    response.end(
+      JSON.stringify({
+        url: bodyUrl,
+        downloadUrl: bodyUrl,
+        pathname,
+        size: Buffer.byteLength(objects.get(pathname)!),
+        contentType: 'application/json',
+        uploadedAt: new Date().toISOString(),
+        etag: 'local-fixture',
+      }),
+    );
+  });
+  await new Promise<void>((resolve) => {
+    server.listen(port, '127.0.0.1', resolve);
+  });
+  const address = server.address() as AddressInfo;
+  return {
+    env: {
+      VERCEL_BLOB_API_URL: `http://127.0.0.1:${address.port}`,
+      BLOB_READ_WRITE_TOKEN: 'vercel_blob_rw_local_fixture',
+      BLOB_CACHE_PREFIX: 'powerx-local-acceptance',
+    },
+    objects,
+    counts,
+    rejectWrites: (value: boolean) => {
+      rejectWrites = value;
+    },
+    close: () =>
+      new Promise<void>((resolve, reject) => {
+        server.closeAllConnections();
+        server.close((error) =>
+          error && (error as NodeJS.ErrnoException).code !== 'ERR_SERVER_NOT_RUNNING'
+            ? reject(error)
+            : resolve(),
+        );
+      }),
+  };
+}
diff --git a/packages/app/src/app/api/gpu-metrics/route.context.test.ts b/packages/app/src/app/api/gpu-metrics/route.context.test.ts
new file mode 100644
index 000000000..1e2b58eeb
--- /dev/null
+++ b/packages/app/src/app/api/gpu-metrics/route.context.test.ts
@@ -0,0 +1,109 @@
+import AdmZip from 'adm-zip';
+import { NextRequest } from 'next/server';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { readStored } = vi.hoisted(() => ({ readStored: vi.fn() }));
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({ getDb: () => ({}) }));
+vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
+  getGpuMetricsForRun: readStored,
+}));
+
+import { GET } from './route';
+
+const HEADER =
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
+const CSV = `${HEADER}\n2026/09/21 00:00:00.000, 0, 100 W, 40, 1500, 2000, 90, 80\n2026/09/21 00:00:01.000, 0, 200 W, 41, 1500, 2000, 90, 80\n`;
+
+beforeEach(() => {
+  readStored.mockReset().mockResolvedValue(null);
+  vi.stubEnv('GITHUB_TOKEN', 'controlled-not-a-real-token');
+  vi.stubEnv('DATABASE_READONLY_URL', 'postgresql://controlled.invalid/never-contacted');
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.unstubAllEnvs();
+});
+
+function liveArtifact(files: Record<string, string>) {
+  const zip = new AdmZip();
+  for (const [entry, contents] of Object.entries(files)) zip.addFile(entry, Buffer.from(contents));
+  const bytes = zip.toBuffer();
+  vi.stubGlobal(
+    'fetch',
+    vi.fn((input: unknown) => {
+      const url = String(input);
+      if (url.includes('/artifacts?')) {
+        return Promise.resolve(
+          Response.json({
+            artifacts: [
+              {
+                id: 2,
+                name: 'gpu_metrics_probe_live',
+                archive_download_url: 'https://example.test/dl/live',
+              },
+            ],
+          }),
+        );
+      }
+      if (url === 'https://example.test/dl/live') {
+        return Promise.resolve(
+          new Response(new Uint8Array(bytes), {
+            headers: { 'Content-Length': String(bytes.length) },
+          }),
+        );
+      }
+      if (url.endsWith('/actions/runs/12345')) {
+        return Promise.resolve(
+          Response.json({
+            id: 12345,
+            name: 'Controlled context fixture',
+            head_branch: 'test',
+            head_sha: 'fixture',
+            created_at: '2026-09-21T00:00:00Z',
+            html_url: 'https://example.test/runs/12345',
+            conclusion: 'success',
+            status: 'completed',
+          }),
+        );
+      }
+      throw new Error(`Unexpected network request: ${url}`);
+    }),
+  );
+}
+
+async function readRoute() {
+  const response = await GET(new NextRequest('http://localhost/api/gpu-metrics?runId=12345'));
+  expect(response.status).toBe(200);
+  return response.json();
+}
+
+describe('GET /api/gpu-metrics collector context', () => {
+  it('uses each host directory context and skips malformed neighboring context files', async () => {
+    liveArtifact({
+      'gpu_metrics_context.json': '{"timestamp_timezone":"+12:00"}',
+      'host-a/gpu_metrics.csv': CSV,
+      'host-a/gpu_metrics_bad_context.json': '{bad json',
+      'host-a/gpu_metrics_context.json': '{"timestamp_timezone":"-07:00"}',
+      'host-b/gpu_metrics.csv': CSV,
+      'host-b/gpu_metrics_context.json': '{"timestamp_timezone":"+05:30"}',
+    });
+    const raw = await readRoute();
+    expect(raw.artifacts).toMatchObject([
+      {
+        name: 'gpu_metrics_probe_live/host-a/gpu_metrics.csv',
+        data: [
+          { timestamp: '2026-09-21T07:00:00.000Z' },
+          { timestamp: '2026-09-21T07:00:01.000Z' },
+        ],
+      },
+      {
+        name: 'gpu_metrics_probe_live/host-b/gpu_metrics.csv',
+        data: [
+          { timestamp: '2026-09-20T18:30:00.000Z' },
+          { timestamp: '2026-09-20T18:30:01.000Z' },
+        ],
+      },
+    ]);
+  });
+});
diff --git a/packages/app/src/app/api/gpu-metrics/route.sources.test.ts b/packages/app/src/app/api/gpu-metrics/route.sources.test.ts
new file mode 100644
index 000000000..afe830736
--- /dev/null
+++ b/packages/app/src/app/api/gpu-metrics/route.sources.test.ts
@@ -0,0 +1,120 @@
+import { NextRequest } from 'next/server';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+import { parseCsvData } from '@/components/gpu-power/types';
+
+const { readRun } = vi.hoisted(() => ({ readRun: vi.fn() }));
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({
+  getDb: () => ({}),
+}));
+vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
+  getGpuMetricsForRun: readRun,
+}));
+
+import { POST } from './route';
+
+const RUN_ID = '12345';
+const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
+const NAME_A = 'dsr1_conc32_b200';
+const NAME_B = 'dsr1_conc64_b200';
+const source = (name: string) => `power_validation_${name}.json`;
+const csvName = (name: string) => `gpu_metrics_${name}`;
+const SOURCE_A = source(NAME_A);
+const SOURCE_B = source(NAME_B);
+const START = Date.parse('2026-03-01T00:00:00Z') / 1000;
+const workflowRun = {
+  id: 1,
+  githubRunId: Number(RUN_ID),
+  runAttempt: 1,
+  name: 'Run Sweep',
+  date: '2026-03-01',
+  htmlUrl: RUN_URL,
+  headBranch: 'main',
+  headSha: 'abc123',
+  conclusion: 'success',
+  status: 'completed',
+  createdAt: '2026-03-01T00:00:00Z',
+};
+
+function csv(power: number): string {
+  return [
+    'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+    `2026/03/01 00:00:00.000, 0, ${power} W, 65, 1500 MHz, 2000 MHz, 95 %, 80 %`,
+    `2026/03/01 00:00:01.000, 0, ${power + 10} W, 65, 1500 MHz, 2000 MHz, 95 %, 80 %`,
+  ].join('\n');
+}
+
+function stored(name: string, power = 100): GpuMetricSeries {
+  return {
+    id: 1,
+    artifactName: csvName(name),
+    configKey: name,
+    fileName: 'gpu_metrics.csv',
+    vendor: 'nvidia',
+    sampleIntervalS: 1,
+    sampleCount: 2,
+    gpuCount: 1,
+    startedAt: '2026-03-01T00:00:00Z',
+    endedAt: '2026-03-01T00:00:01Z',
+    sidecars: {
+      seriesInventory: [{ fileName: 'gpu_metrics.csv', sampleCount: 2 }],
+    },
+    benchmarkResultIds: [1],
+    stats: [],
+    data: parseCsvData(csv(power)).map((row, index) => ({
+      ...row,
+      timestamp: new Date((START + index) * 1000).toISOString(),
+    })),
+  };
+}
+
+function request(body: unknown, prefix = 'dsr1_', raw = false): NextRequest {
+  const params = new URLSearchParams({
+    runId: RUN_ID,
+    series: 'power',
+    prefix,
+  });
+  return new NextRequest(`http://localhost/api/gpu-metrics?${params}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: raw ? String(body) : JSON.stringify(body),
+  });
+}
+
+beforeEach(() => {
+  readRun.mockReset().mockResolvedValue({ workflowRun, series: [stored(NAME_A)] });
+  vi.stubEnv('DATABASE_READONLY_URL', 'postgresql://readonly.example.test/test');
+  vi.stubEnv('GITHUB_TOKEN', 'test-token');
+  vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Unexpected GitHub request')));
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
+});
+
+describe('Timeline requested-source coverage', () => {
+  it('keeps known missing hosts as 503 even when another requested series is healthy', async () => {
+    const partial = stored(NAME_B, 300);
+    partial.sidecars.seriesInventory = [
+      { fileName: 'gpu_metrics.csv', sampleCount: 2 },
+      { fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
+    ];
+    readRun.mockResolvedValue({
+      workflowRun,
+      series: [stored(NAME_A), partial],
+    });
+    vi.stubEnv('GITHUB_TOKEN', '');
+    const response = await POST(request({ sources: [SOURCE_A, SOURCE_B] }));
+    expect(readRun).toHaveBeenCalledWith({}, Number(RUN_ID), {
+      prefix: 'dsr1_',
+      sourceResults: [NAME_A, NAME_B],
+    });
+    expect(response.status).toBe(503);
+    expect(await response.json()).toMatchObject({
+      code: 'STORED_TELEMETRY_INCOMPLETE',
+      artifact: csvName(NAME_B),
+    });
+  });
+});
diff --git a/packages/app/src/app/api/gpu-metrics/route.test.ts b/packages/app/src/app/api/gpu-metrics/route.test.ts
index c34a2147f..2b1dd8f15 100644
--- a/packages/app/src/app/api/gpu-metrics/route.test.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.test.ts
@@ -1,22 +1,37 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import type * as GpuPowerTypes from '@/components/gpu-power/types';
 
-const { mockParseCsvData } = vi.hoisted(() => ({
-  mockParseCsvData: vi.fn((csv: string) => {
-    if (csv.trim().length === 0) return [];
-    return [
-      {
-        timestamp: '2026-03-01T00:00:00Z',
-        index: 0,
-        power: 300,
-        temperature: 65,
-        smClock: 1500,
-        memClock: 2000,
-        gpuUtil: 95,
-        memUtil: 80,
-      },
-    ];
-  }),
-}));
+const { mockParseCsvData, zipArchives } = vi.hoisted(() => {
+  interface ZipEntry {
+    entryName: string;
+    data: string;
+  }
+  const csvArchive: ZipEntry[] = [
+    { entryName: 'gpu_metrics_0.csv', data: 'timestamp,index,power\n2026-03-01T00:00:00Z,0,300' },
+  ];
+  return {
+    mockParseCsvData: vi.fn((csv: string): GpuPowerTypes.GpuMetricRow[] => {
+      if (csv.trim().length === 0) return [];
+      return [
+        {
+          timestamp: '2026-03-01T00:00:00Z',
+          index: 0,
+          power: 300,
+          temperature: 65,
+          smClock: 1500,
+          memClock: 2000,
+          gpuUtil: 95,
+          memUtil: 80,
+        },
+      ];
+    }),
+    /**
+     * Entries the adm-zip mock serves, keyed by the downloaded buffer's text.
+     * An empty download (the default in older tests) is the one-CSV artifact.
+     */
+    zipArchives: { byKey: new Map<string, ZipEntry[]>(), csvArchive },
+  };
+});
 
 vi.mock('@semianalysisai/inferencex-constants', () => ({
   GITHUB_API_BASE: 'https://api.github.com',
@@ -28,36 +43,60 @@ vi.mock('@/components/gpu-power/types', () => ({
   parseCsvData: mockParseCsvData,
 }));
 
+const { mockGetGpuMetricsForRun } = vi.hoisted(() => ({
+  mockGetGpuMetricsForRun: vi.fn(),
+}));
+
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({
+  getDb: () => ({}),
+}));
+
+vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
+  getGpuMetricsForRun: mockGetGpuMetricsForRun,
+}));
+
 vi.mock('adm-zip', () => {
-  const csvContent = 'timestamp,index,power\n2026-03-01T00:00:00Z,0,300';
   class MockAdmZip {
+    private readonly key: string;
+    constructor(buffer: Buffer) {
+      this.key = buffer.toString('utf8');
+    }
     getEntries() {
-      return [
-        {
-          entryName: 'gpu_metrics_0.csv',
-          isDirectory: false,
-          getData: () => Buffer.from(csvContent),
-        },
-      ];
+      const entries = zipArchives.byKey.get(this.key) ?? zipArchives.csvArchive;
+      return entries.map((entry) => ({
+        entryName: entry.entryName,
+        isDirectory: false,
+        getData: () => Buffer.from(entry.data),
+      }));
     }
   }
   return { default: MockAdmZip };
 });
 
-import { GET } from './route';
+import { databasePayloadToResponse, GET, readGpuMetricsForView } from './route';
 import { NextRequest } from 'next/server';
 
 const originalFetch = globalThis.fetch;
 let origToken: string | undefined;
+let origReadonlyUrl: string | undefined;
 
 function req(url: string): NextRequest {
   return new NextRequest(new URL(url, 'http://localhost'));
 }
 
+function nvidiaRow(second: number, power: number): string {
+  return `2026/03/01 00:00:0${second}.000, 0, ${power} W, 65, 1500 MHz, 2000 MHz, 95 %, 80 %`;
+}
+
 beforeEach(() => {
   vi.clearAllMocks();
+  zipArchives.byKey.clear();
   origToken = process.env.GITHUB_TOKEN;
+  origReadonlyUrl = process.env.DATABASE_READONLY_URL;
   process.env.GITHUB_TOKEN = 'test-gh-token';
+  // No readonly URL: the GitHub fallback is exercised unless a test opts in.
+  delete process.env.DATABASE_READONLY_URL;
+  mockGetGpuMetricsForRun.mockResolvedValue(null);
 });
 
 afterEach(() => {
@@ -67,6 +106,258 @@ afterEach(() => {
   } else {
     process.env.GITHUB_TOKEN = origToken;
   }
+  if (origReadonlyUrl === undefined) {
+    delete process.env.DATABASE_READONLY_URL;
+  } else {
+    process.env.DATABASE_READONLY_URL = origReadonlyUrl;
+  }
+});
+
+const storedRunPayload = {
+  workflowRun: {
+    id: 7,
+    githubRunId: 34557177019,
+    runAttempt: 1,
+    name: 'Run Sweep - dsr1 fp4 b200',
+    date: '2026-09-11',
+    htmlUrl: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34557177019',
+    headBranch: 'main',
+    headSha: 'deadbeef',
+    conclusion: 'success',
+    status: 'completed',
+    createdAt: '2026-09-11T04:00:00.000Z',
+  },
+  series: [
+    {
+      id: 1,
+      artifactName: 'gpu_metrics_dsr1_conc32_b200-x_0',
+      configKey: 'dsr1_conc32_b200-x_0',
+      fileName: 'gpu_metrics.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 2,
+      gpuCount: 1,
+      startedAt: '2026-09-11T04:19:41.982Z',
+      endedAt: '2026-09-11T04:19:42.990Z',
+      sidecars: {},
+      benchmarkResultIds: [10],
+      stats: [],
+      data: [
+        {
+          timestamp: '2026-09-11T04:19:41.982Z',
+          index: 0,
+          power: 187.8,
+          temperature: 33,
+          smClock: 120,
+          memClock: 3996,
+          gpuUtil: 0,
+          memUtil: 0,
+        },
+        {
+          timestamp: '2026-09-11T04:19:42.990Z',
+          index: 0,
+          power: 912.1,
+          temperature: 61,
+          smClock: 1965,
+          memClock: 3996,
+          gpuUtil: 98,
+          memUtil: 74,
+        },
+      ],
+    },
+    {
+      id: 2,
+      artifactName: 'gpu_metrics_multinode_b200-x_0',
+      configKey: 'multinode_b200-x_0',
+      fileName: 'results/gpu_metrics_rank0.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 0,
+      gpuCount: 0,
+      startedAt: '2026-09-11T04:19:41.982Z',
+      endedAt: '2026-09-11T04:19:41.982Z',
+      sidecars: {},
+      benchmarkResultIds: [11],
+      stats: [],
+      data: [],
+    },
+    {
+      id: 3,
+      artifactName: 'gpu_metrics_multinode_b200-x_0',
+      configKey: 'multinode_b200-x_0',
+      fileName: 'results/gpu_metrics_rank1.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 0,
+      gpuCount: 0,
+      startedAt: '2026-09-11T04:19:41.982Z',
+      endedAt: '2026-09-11T04:19:41.982Z',
+      sidecars: {},
+      benchmarkResultIds: [11],
+      stats: [],
+      data: [],
+    },
+  ],
+};
+
+describe('databasePayloadToResponse', () => {
+  it('shapes the stored digest like the GitHub payload and disambiguates multinode CSVs', () => {
+    const response = databasePayloadToResponse(storedRunPayload);
+    expect(response.source).toBe('database');
+    expect(response.runInfo).toEqual({
+      id: 34557177019,
+      name: 'Run Sweep - dsr1 fp4 b200',
+      branch: 'main',
+      sha: 'deadbeef',
+      createdAt: '2026-09-11T04:00:00.000Z',
+      url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34557177019',
+      conclusion: 'success',
+      status: 'completed',
+    });
+    expect(response.artifacts.map((artifact) => artifact.name)).toEqual([
+      'gpu_metrics_dsr1_conc32_b200-x_0',
+      'gpu_metrics_multinode_b200-x_0/results/gpu_metrics_rank0.csv',
+      'gpu_metrics_multinode_b200-x_0/results/gpu_metrics_rank1.csv',
+    ]);
+    expect(response.artifacts[0]!.data).toHaveLength(2);
+    expect(response.artifacts[0]!.series?.benchmarkResultIds).toEqual([10]);
+    expect(response.artifacts[0]!.series).not.toHaveProperty('data');
+  });
+});
+
+describe('GET /api/gpu-metrics — database first', () => {
+  it('serves the stored digest without touching GitHub when the run is ingested', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    mockGetGpuMetricsForRun.mockResolvedValueOnce(storedRunPayload);
+    globalThis.fetch = vi.fn();
+
+    const res = await GET(req('/api/gpu-metrics?runId=34557177019'));
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.source).toBe('database');
+    expect(body.artifacts).toHaveLength(3);
+    expect(mockGetGpuMetricsForRun).toHaveBeenCalledWith({}, 34557177019, {
+      prefix: null,
+      sourceResults: null,
+    });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('passes selectors to the reader and preserves exact host labels for a scoped view', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    const names = databasePayloadToResponse(storedRunPayload).artifacts.map((entry) => entry.name);
+    mockGetGpuMetricsForRun.mockResolvedValueOnce({
+      ...storedRunPayload,
+      artifactNames: names,
+      series: [storedRunPayload.series[2]],
+    });
+    globalThis.fetch = vi.fn();
+    const response = await readGpuMetricsForView(
+      req('/api/gpu-metrics?runId=34557177019'),
+      names[2]!,
+    );
+    expect(await response.json()).toMatchObject({
+      artifactNames: names,
+      artifacts: [{ name: names[2] }],
+    });
+    expect(mockGetGpuMetricsForRun).toHaveBeenCalledWith({}, 34557177019, {
+      prefix: null,
+      sourceResults: null,
+      artifact: names[2],
+    });
+    mockGetGpuMetricsForRun.mockResolvedValueOnce({
+      ...storedRunPayload,
+      artifactNames: names,
+      series: [],
+    });
+    const missing = await readGpuMetricsForView(
+      req('/api/gpu-metrics?runId=34557177019'),
+      'missing',
+    );
+    expect(await missing.json()).toMatchObject({ artifactNames: names, artifacts: [] });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('reports a database failure separately instead of treating it as missing data', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    mockGetGpuMetricsForRun.mockRejectedValueOnce(new Error('relation does not exist'));
+    globalThis.fetch = vi.fn().mockResolvedValueOnce({ ok: false, status: 404 });
+
+    const res = await GET(req('/api/gpu-metrics?runId=99'));
+    expect(res.status).toBe(503);
+    expect(await res.json()).toMatchObject({ code: 'DATABASE_UNAVAILABLE' });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('checks retained file/sample coverage before using a truncated host CSV fallback', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    const { parseCsvData } = await vi.importActual<typeof GpuPowerTypes>(
+      '@/components/gpu-power/types',
+    );
+    const header =
+      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
+    const hostA = [header, nvidiaRow(0, 300), nvidiaRow(0, 999), nvidiaRow(1, 310)].join('\n');
+    // host-b lost its GPU 1 row: one of the two retained samples.
+    const hostB = [header, nvidiaRow(0, 500)].join('\n');
+    zipArchives.byKey.set('coverage', [
+      { entryName: 'host-a/gpu_metrics.csv', data: hostA },
+      { entryName: 'host-b/gpu_metrics.csv', data: hostB },
+    ]);
+    mockParseCsvData.mockImplementationOnce(parseCsvData).mockImplementationOnce(parseCsvData);
+    mockGetGpuMetricsForRun.mockResolvedValueOnce({
+      ...storedRunPayload,
+      series: [
+        {
+          ...storedRunPayload.series[0],
+          artifactName: 'gpu_metrics_live',
+          fileName: 'host-a/gpu_metrics.csv',
+          sidecars: {
+            seriesInventory: [
+              { fileName: 'host-a/gpu_metrics.csv', sampleCount: 2 },
+              { fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
+            ],
+          },
+        },
+      ],
+    });
+    globalThis.fetch = vi
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            id: 34557177019,
+            name: 'Sweep',
+            head_branch: 'main',
+            head_sha: 'abc',
+            created_at: '2026-03-01T00:00:00Z',
+            html_url: 'https://example.test/run',
+            status: 'completed',
+            conclusion: 'success',
+          }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            artifacts: [
+              { id: 1, name: 'gpu_metrics_live', archive_download_url: 'https://example.test/zip' },
+            ],
+          }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        arrayBuffer: () => Promise.resolve(new TextEncoder().encode('coverage').buffer),
+      });
+    const res = await GET(req('/api/gpu-metrics?runId=34557177019&series=power'));
+    expect(res.status).toBe(503);
+    expect(await res.json()).toMatchObject({
+      code: 'STORED_TELEMETRY_INCOMPLETE',
+      artifact: 'gpu_metrics_live',
+    });
+    expect(globalThis.fetch).toHaveBeenCalledTimes(3);
+  });
 });
 
 describe('GET /api/gpu-metrics', () => {
diff --git a/packages/app/src/app/api/gpu-metrics/route.ts b/packages/app/src/app/api/gpu-metrics/route.ts
index 59a607f35..b9f351d66 100644
--- a/packages/app/src/app/api/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.ts
@@ -1,10 +1,70 @@
 /**
- * DO NOT ADD CACHING (blob, CDN, or unstable_cache) to this route.
- * It fetches live GitHub Actions artifacts which change while a run is in progress.
+ * PowerX telemetry for one GitHub Actions run.
+ *
+ * Reads the ingest-time telemetry digest first (migration 016: series,
+ * samples, per-GPU statistics, point links). Runs that have not been ingested
+ * yet, including runs still in progress, fall back to the live GitHub
+ * artifacts exactly as before.
+ *
+ * DO NOT ADD CACHING (blob, CDN, or unstable_cache) to this route. The
+ * fallback fetches live GitHub Actions artifacts which change while a run is
+ * in progress, and stored telemetry must reflect a successful re-ingest immediately.
+ *
+ * Two telemetry collectors publish GPU power for a run:
+ * - single-node runners (nvidia-smi / amd-smi) publish one `gpu_metrics_<RESULT_FILENAME>`
+ *   CSV artifact per benchmark config;
+ * - Slurm / Dynamo disaggregated runners (DCGM) publish one `power_audit_<RESULT_FILENAME>`
+ *   bundle per concurrency sweep, holding the sweep's samples plus one
+ *   `power_validation_*.json` window per config
+ *   (`components/gpu-power/power-audit-bundle.ts`).
+ *
+ * Two response shapes:
+ * - default: every `gpu_metrics_*` artifact's parsed rows (the `/gpu-metrics`
+ *   page), from the stored digest when the run is ingested, else from GitHub;
+ *   bundles are ignored on the GitHub path;
+ * - `series=power`: compact per-GPU watt series bucketed to one second
+ *   (`components/gpu-power/power-series.ts`) for the PowerX timeline, from
+ *   CSV artifacts and from bundles cut per validation window. The timeline
+ *   joins them to chart points by `source` (bundle) or artifact name (CSV).
+ *   Persisted samples and validation windows use the same bucketing/cut
+ *   transform as artifacts, so historical runs survive artifact expiry.
+ * `prefix=<RESULT_FILENAME prefix>` narrows either shape to the artifacts of
+ * one model / workload / precision so a full nightly sweep is not downloaded
+ * for one chart. A bundle names a whole sweep, so it also matches when the
+ * prefix extends past its name into the per-concurrency suffix.
+ * Timeline POSTs sorted validation basenames in `{ sources: [...] }` to recover
+ * missing siblings while keeping fully covered DB reads independent of GitHub.
+ * `sourceCoverage` describes those requested identities, not full-run completeness.
  */
 import { type NextRequest, NextResponse } from 'next/server';
 
-import { parseCsvData } from '@/components/gpu-power/types';
+import { getDb } from '@semianalysisai/inferencex-db/connection';
+import {
+  getGpuMetricsForRun,
+  type GpuMetricsRunPayload,
+  type GpuMetricsRunSelection,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import type {
+  GpuMetricRow,
+  GpuPowerRunInfo,
+  GpuMetricsArtifact,
+  GpuPowerApiResponse,
+} from '@/components/gpu-power/types';
+import {
+  cutPowerAuditBundle,
+  isPowerAuditBundleEntry,
+  parsePowerCsvData,
+} from '@/components/gpu-power/power-audit-bundle';
+import {
+  bucketPowerFiles,
+  parseTelemetryTimestampUtc,
+  type GpuPowerSeries,
+} from '@/components/gpu-power/power-series';
+import {
+  storedPowerSeries,
+  StoredTelemetryIncompleteError,
+} from '@/components/gpu-power/stored-power-series';
 import {
   downloadGithubArtifact,
   extractZipEntries,
@@ -12,12 +72,270 @@ import {
   fetchGithubWorkflowRun,
   getGithubToken,
   normalizeGithubRunInfo,
+  readZipEntries,
+  type GithubArtifact,
   type GithubWorkflowRun,
 } from '@/lib/github-artifacts';
 
 const MAX_ARTIFACT_BYTES = 50 * 1024 * 1024;
+/** Bundles carry a whole sweep (215 MB seen for nw8); only the power entries are decoded. */
+const MAX_BUNDLE_BYTES = 256 * 1024 * 1024;
+/** Bundle downloads are latency-bound; match the other artifact routes' budget. */
+export const maxDuration = 300;
+/** Parallel artifact downloads; GitHub's zip redirects are latency-bound, not CPU-bound. */
+const DOWNLOAD_CONCURRENCY = 4;
+const ARTIFACT_PREFIX = 'gpu_metrics_';
+const BUNDLE_PREFIX = 'power_audit_';
+/** RESULT_FILENAME characters: model, workload, precision, framework, parallelism, host, hash. */
+const PREFIX_PATTERN = /^[A-Za-z0-9._-]{1,200}$/u;
+const SOURCE_PATTERN = /^power_validation_[A-Za-z0-9._-]{1,200}\.json$/u;
+const MAX_REQUEST_BYTES = 256 * 1024;
+
+export type GpuMetricsSource = 'database' | 'github';
+
+export type GpuMetricsArtifactPayload = GpuMetricsArtifact;
+
+export interface GpuMetricsRouteResponse extends GpuPowerApiResponse {
+  source: GpuMetricsSource;
+  artifactNames?: string[];
+}
+
+/** Shape the stored digest like the GitHub payload so the explorer is source-agnostic. */
+export function databasePayloadToResponse(payload: GpuMetricsRunPayload): GpuMetricsRouteResponse {
+  const run = payload.workflowRun;
+  const filesPerArtifact = new Map<string, number>();
+  for (const series of payload.series) {
+    filesPerArtifact.set(series.artifactName, (filesPerArtifact.get(series.artifactName) ?? 0) + 1);
+  }
+  return {
+    source: 'database',
+    ...(payload.artifactNames ? { artifactNames: payload.artifactNames } : {}),
+    runInfo: {
+      id: run.githubRunId,
+      name: run.name,
+      branch: run.headBranch ?? '',
+      sha: run.headSha ?? '',
+      createdAt: run.createdAt ?? `${run.date}T00:00:00Z`,
+      url:
+        run.htmlUrl ??
+        `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${run.githubRunId}`,
+      conclusion: run.conclusion ?? '',
+      status: run.status ?? '',
+    },
+    artifacts: payload.series.map(({ data, ...series }) => ({
+      // Multinode uploads carry one CSV per node; keep them distinguishable.
+      name:
+        (filesPerArtifact.get(series.artifactName) ?? 1) > 1 ||
+        payload.artifactNames?.includes(`${series.artifactName}/${series.fileName}`)
+          ? `${series.artifactName}/${series.fileName}`
+          : series.artifactName,
+      data,
+      series,
+    })),
+  };
+}
+
+/** The GitHub path also carries the bundle series the timeline draws. */
+interface GithubArtifactPayload {
+  name: string;
+  files: { name: string; data: GpuMetricRow[] }[];
+}
+
+interface GithubGpuMetricsResponse extends Omit<GpuMetricsRouteResponse, 'artifacts'> {
+  artifacts: GithubArtifactPayload[];
+  source: 'github';
+  bundleSeries: GpuPowerSeries[];
+}
+
+type TelemetryJob =
+  | { kind: 'csv'; artifact: GithubArtifact }
+  | { kind: 'bundle'; artifact: GithubArtifact };
+
+type TelemetryResult =
+  | { kind: 'csv'; parsed: GithubArtifactPayload }
+  | { kind: 'bundle'; series: GpuPowerSeries[] };
+
+/** Fetches one artifact zip, or `null` (with a warning) when it fails or exceeds `maxBytes`. */
+async function downloadZip(
+  artifact: GithubArtifact,
+  githubToken: string,
+  maxBytes: number,
+): Promise<Buffer | null> {
+  const dlResp = await downloadGithubArtifact(artifact.archive_download_url, githubToken);
+  if (!dlResp.ok) {
+    console.warn(`Failed to download artifact ${artifact.name}: ${dlResp.statusText}`);
+    return null;
+  }
+
+  const contentLength = dlResp.headers.get('Content-Length');
+  if (contentLength && parseInt(contentLength, 10) > maxBytes) {
+    console.warn(`Artifact ${artifact.name} exceeds ${maxBytes / (1024 * 1024)} MB, skipping`);
+    return null;
+  }
+  return Buffer.from(await dlResp.arrayBuffer());
+}
+
+async function downloadArtifact(
+  artifact: GithubArtifact,
+  githubToken: string,
+): Promise<GithubArtifactPayload | null> {
+  const buffer = await downloadZip(artifact, githubToken, MAX_ARTIFACT_BYTES);
+  if (!buffer) return null;
+  const contexts = new Map<string, Record<string, unknown>>();
+  const contextFiles = extractZipEntries(buffer, '.json', (name, contents) => {
+    const base = name.slice(name.lastIndexOf('/') + 1);
+    if (!base.includes('gpu_metrics') || !base.toLowerCase().endsWith('_context.json')) return [];
+    const context: unknown = JSON.parse(contents);
+    return context && typeof context === 'object' && !Array.isArray(context)
+      ? [{ name, context: context as Record<string, unknown> }]
+      : [];
+  });
+  // Ingest uses code-unit filename order, not archive order or the host locale.
+  contextFiles.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  for (const { name, context } of contextFiles) {
+    const directory = name.slice(0, name.lastIndexOf('/') + 1);
+    if (!contexts.has(directory)) contexts.set(directory, context);
+  }
+  const files = extractZipEntries(
+    buffer,
+    '.csv',
+    (entryName, contents) => {
+      const directory = entryName.slice(0, entryName.lastIndexOf('/') + 1);
+      const data = parsePowerCsvData(contents, contexts.get(directory) ?? null);
+      return data.length > 0 ? [{ name: entryName, data }] : [];
+    },
+    (entryName, error) => {
+      console.warn(`Failed to parse CSV ${entryName} from ${artifact.name}:`, error);
+    },
+  );
+  return files.length > 0 ? { name: artifact.name, files } : null;
+}
+
+async function downloadBundle(
+  artifact: GithubArtifact,
+  githubToken: string,
+): Promise<GpuPowerSeries[] | null> {
+  const buffer = await downloadZip(artifact, githubToken, MAX_BUNDLE_BYTES);
+  if (!buffer) return null;
+  const series = cutPowerAuditBundle(
+    artifact.name,
+    readZipEntries(buffer, isPowerAuditBundleEntry),
+  );
+  return series.length > 0 ? series : null;
+}
+
+/**
+ * One artifact download and parse. A corrupt or truncated archive is that
+ * artifact's failure alone: it is logged and skipped so the other series of
+ * the run still reach the chart (the client would otherwise retry the whole
+ * multi-hundred-megabyte request).
+ */
+async function runJob(job: TelemetryJob, githubToken: string): Promise<TelemetryResult | null> {
+  try {
+    if (job.kind === 'csv') {
+      const parsed = await downloadArtifact(job.artifact, githubToken);
+      return parsed ? { kind: 'csv', parsed } : null;
+    }
+    const series = await downloadBundle(job.artifact, githubToken);
+    return series ? { kind: 'bundle', series } : null;
+  } catch (error) {
+    console.warn(`Failed to read artifact ${job.artifact.name}:`, error);
+    return null;
+  }
+}
+
+/** Downloads in listing order with a bounded number of requests in flight. */
+async function downloadTelemetry(
+  jobs: TelemetryJob[],
+  githubToken: string,
+): Promise<TelemetryResult[]> {
+  const results: (TelemetryResult | null)[] = Array.from({ length: jobs.length }, () => null);
+  let next = 0;
+  const worker = async () => {
+    while (next < jobs.length) {
+      const index = next++;
+      results[index] = await runJob(jobs[index], githubToken);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(DOWNLOAD_CONCURRENCY, jobs.length) }, worker));
+  return results.filter((result): result is TelemetryResult => result !== null);
+}
+
+/**
+ * A bundle names a whole sweep, while the client's prefix (the longest common
+ * prefix of its points' validation names) may run into the `_sa-bench_…_conc<c>`
+ * suffix; either side being a prefix of the other selects the bundle.
+ */
+function isWantedBundle(name: string, prefix: string | null): boolean {
+  if (!name.startsWith(BUNDLE_PREFIX)) return false;
+  if (prefix === null) return true;
+  const wanted = `${BUNDLE_PREFIX}${prefix}`;
+  return name.startsWith(wanted) || wanted.startsWith(name);
+}
+
+/** Validation basenames identify individual windows, including siblings in one bundle. */
+function seriesSource(series: GpuPowerSeries): string | null {
+  return (
+    series.source ??
+    (series.artifact.startsWith(ARTIFACT_PREFIX)
+      ? `power_validation_${series.artifact.slice(ARTIFACT_PREFIX.length)}.json`
+      : null)
+  );
+}
+
+function isRequestedArtifact(name: string, sources: string[] | null): boolean {
+  return (
+    sources === null ||
+    sources.some((source) => {
+      const result = source.slice('power_validation_'.length, -'.json'.length);
+      return name === `${ARTIFACT_PREFIX}${result}` || isWantedBundle(name, result);
+    })
+  );
+}
+
+function sourceCoverage(series: GpuPowerSeries[], sources: string[] | null) {
+  const available = new Set(series.map(seriesSource));
+  const missingSources = sources?.filter((source) => !available.has(source)) ?? [];
+  return {
+    status: sources === null ? 'unknown' : missingSources.length > 0 ? 'incomplete' : 'complete',
+    missingSources,
+  };
+}
+
+function powerSeriesResponse(
+  source: GpuMetricsSource,
+  runInfo: GpuPowerRunInfo,
+  series: GpuPowerSeries[],
+  sources: string[] | null,
+) {
+  return NextResponse.json(
+    { source, runInfo, series, sourceCoverage: sourceCoverage(series, sources) },
+    { headers: { 'Cache-Control': 'no-store' } },
+  );
+}
 
-async function fetchGpuMetrics(runId: string) {
+/**
+ * Narrows a stored run to the artifacts a `prefix` names, mirroring the GitHub
+ * listing filter so both sources answer the same request the same way.
+ */
+function filterArtifactsByPrefix(
+  artifacts: GpuMetricsArtifactPayload[],
+  prefix: string | null,
+): GpuMetricsArtifactPayload[] {
+  if (prefix === null) return artifacts;
+  const wanted = `${ARTIFACT_PREFIX}${prefix}`;
+  return artifacts.filter((artifact) => {
+    const name = artifact.series?.artifactName ?? artifact.name;
+    return name.startsWith(wanted) || isWantedBundle(name, prefix);
+  });
+}
+
+async function fetchGpuMetricsFromGithub(
+  runId: string,
+  prefix: string | null,
+  includeBundles: boolean,
+  sources: string[] | null = null,
+): Promise<GithubGpuMetricsResponse> {
   const githubToken = getGithubToken();
   if (!githubToken) throw new Error('GitHub token not configured');
 
@@ -27,57 +345,292 @@ async function fetchGpuMetrics(runId: string) {
 
   const artifacts = await fetchGithubRunArtifacts(runId, githubToken);
 
-  const gpuArtifacts = artifacts.filter((a) => a.name.startsWith('gpu_metrics'));
-  if (gpuArtifacts.length === 0) throw new Error('No gpu_metrics artifacts found for this run');
-
-  const parsedArtifacts: { name: string; data: ReturnType<typeof parseCsvData> }[] = [];
-  for (const artifact of gpuArtifacts) {
-    const dlResp = await downloadGithubArtifact(artifact.archive_download_url, githubToken);
-    if (!dlResp.ok) {
-      console.warn(`Failed to download artifact ${artifact.name}: ${dlResp.statusText}`);
-      continue;
+  // `eval_gpu_metrics_*` artifacts are excluded by the bare `gpu_metrics` test.
+  const wanted = prefix ? `${ARTIFACT_PREFIX}${prefix}` : 'gpu_metrics';
+  const jobs: TelemetryJob[] = artifacts
+    .filter((a) => a.name.startsWith(wanted) && isRequestedArtifact(a.name, sources))
+    .map((artifact) => ({ kind: 'csv', artifact }));
+  if (includeBundles) {
+    for (const artifact of artifacts) {
+      if (isWantedBundle(artifact.name, prefix) && isRequestedArtifact(artifact.name, sources))
+        jobs.push({ kind: 'bundle', artifact });
     }
-
-    const contentLength = dlResp.headers.get('Content-Length');
-    if (contentLength && parseInt(contentLength, 10) > MAX_ARTIFACT_BYTES) {
-      console.warn(`Artifact ${artifact.name} exceeds 50 MB, skipping`);
-      continue;
-    }
-
-    const rows = extractZipEntries(
-      Buffer.from(await dlResp.arrayBuffer()),
-      '.csv',
-      (_entryName, contents) => parseCsvData(contents),
-      (entryName, error) => {
-        console.warn(`Failed to parse CSV ${entryName} from ${artifact.name}:`, error);
-      },
+  }
+  if (jobs.length === 0) {
+    throw new Error(
+      includeBundles
+        ? 'No telemetry artifacts (gpu_metrics or power_audit) found for this run'
+        : 'No gpu_metrics artifacts found for this run',
     );
-    if (rows.length > 0) parsedArtifacts.push({ name: artifact.name, data: rows });
   }
 
-  if (parsedArtifacts.length === 0) throw new Error('No Chip metrics data found in artifacts');
+  const results = await downloadTelemetry(jobs, githubToken);
+  if (results.length === 0) throw new Error('No Chip metrics data found in artifacts');
 
+  const parsedArtifacts: GithubArtifactPayload[] = [];
+  const bundleSeries: GpuPowerSeries[] = [];
+  for (const result of results) {
+    if (result.kind === 'csv') parsedArtifacts.push(result.parsed);
+    else bundleSeries.push(...result.series);
+  }
   return {
-    runInfo: normalizeGithubRunInfo(run),
+    source: 'github',
+    runInfo: normalizeGithubRunInfo(run) as GpuPowerRunInfo,
     artifacts: parsedArtifacts,
+    bundleSeries,
   };
 }
 
-export async function GET(request: NextRequest) {
-  const runId = request.nextUrl.searchParams.get('runId');
+async function fetchGpuMetricsFromDatabase(
+  runId: string,
+  selection: GpuMetricsRunSelection,
+): Promise<GpuMetricsRouteResponse | null> {
+  if (!process.env.DATABASE_READONLY_URL) return null;
+  const payload = await getGpuMetricsForRun(getDb(), Number(runId), selection);
+  return payload ? databasePayloadToResponse(payload) : null;
+}
+
+export function GET(request: NextRequest) {
+  return readGpuMetrics(request, null);
+}
+
+/** Selecting a host must not discard the explorer's sibling artifact choices. */
+export function readGpuMetricsForView(request: NextRequest, artifact: string | null) {
+  return readGpuMetrics(request, null, artifact);
+}
+
+/** Read-only Timeline transport; the body avoids URL limits for a run's point identities. */
+export async function POST(request: NextRequest) {
+  const reader = request.body?.getReader();
+  const chunks: Uint8Array[] = [];
+  let bytes = 0;
+  try {
+    if (reader) {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        bytes += value.byteLength;
+        if (bytes > MAX_REQUEST_BYTES) {
+          await reader.cancel();
+          return NextResponse.json({ error: 'Request body exceeds 256 KiB' }, { status: 413 });
+        }
+        chunks.push(value);
+      }
+    }
+    const body: unknown = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    const sources =
+      body && typeof body === 'object' && !Array.isArray(body) && 'sources' in body
+        ? body.sources
+        : null;
+    if (
+      !Array.isArray(sources) ||
+      sources.length === 0 ||
+      sources.length > 1000 ||
+      !sources.every(
+        (source): source is string => typeof source === 'string' && SOURCE_PATTERN.test(source),
+      )
+    ) {
+      return NextResponse.json(
+        { error: 'sources must contain 1–1000 power_validation_<RESULT_FILENAME>.json basenames' },
+        { status: 400 },
+      );
+    }
+    if (request.nextUrl.searchParams.get('series') !== 'power') {
+      return NextResponse.json({ error: 'POST requires series=power' }, { status: 400 });
+    }
+    const prefix = request.nextUrl.searchParams.get('prefix');
+    if (
+      prefix !== null &&
+      sources.some((source) => !source.startsWith(`power_validation_${prefix}`))
+    ) {
+      return NextResponse.json({ error: 'Every source must match prefix' }, { status: 400 });
+    }
+    return readGpuMetrics(request, [...new Set(sources)].sort());
+  } catch {
+    return NextResponse.json({ error: 'Request body must be valid JSON' }, { status: 400 });
+  } finally {
+    reader?.releaseLock();
+  }
+}
+
+async function readGpuMetrics(
+  request: NextRequest,
+  sources: string[] | null,
+  selectedArtifact?: string | null,
+) {
+  const params = request.nextUrl.searchParams;
+  const runId = params.get('runId');
 
   if (!runId || !/^\d+$/u.test(runId)) {
     return NextResponse.json({ error: 'runId must be a numeric workflow run ID' }, { status: 400 });
   }
+  const prefix = params.get('prefix');
+  if (prefix !== null && !PREFIX_PATTERN.test(prefix)) {
+    return NextResponse.json(
+      { error: 'prefix must be a RESULT_FILENAME prefix (letters, digits, . _ -)' },
+      { status: 400 },
+    );
+  }
+  const series = params.get('series');
+  if (series !== null && series !== 'power') {
+    return NextResponse.json({ error: 'series must be "power" when present' }, { status: 400 });
+  }
+
+  let stored: GpuMetricsRouteResponse | null;
+  try {
+    stored = await fetchGpuMetricsFromDatabase(runId, {
+      prefix,
+      sourceResults:
+        sources?.map((source) => source.slice('power_validation_'.length, -'.json'.length)) ?? null,
+      ...(selectedArtifact === undefined ? {} : { artifact: selectedArtifact }),
+    });
+  } catch (error) {
+    // Missing data may use live artifacts; a failed read cannot establish absence.
+    console.error(`gpu-metrics: database lookup failed for run ${runId}:`, error);
+    return NextResponse.json(
+      {
+        error: 'Stored telemetry is temporarily unavailable. Retry the request.',
+        code: 'DATABASE_UNAVAILABLE',
+      },
+      { status: 503, headers: { 'Cache-Control': 'no-store' } },
+    );
+  }
 
+  const incomplete: StoredTelemetryIncompleteError[] = [];
+  const databaseSeries: GpuPowerSeries[] = [];
+  let githubFallbackStarted = false;
   try {
-    const data = await fetchGpuMetrics(runId);
-    return NextResponse.json(data);
+    if (stored) {
+      const artifacts = filterArtifactsByPrefix(stored.artifacts, prefix).filter((artifact) =>
+        isRequestedArtifact(artifact.series?.artifactName ?? artifact.name, sources),
+      );
+      if (series === 'power') {
+        const groups = Map.groupBy(
+          artifacts.flatMap((artifact) =>
+            artifact.series ? [{ ...artifact.series, data: artifact.data }] : [],
+          ),
+          (entry) => entry.artifactName,
+        );
+        for (const entries of groups.values()) {
+          try {
+            databaseSeries.push(
+              ...storedPowerSeries(entries).filter(
+                (entry) => sources === null || sources.includes(seriesSource(entry) ?? ''),
+              ),
+            );
+          } catch (error) {
+            if (!(error instanceof StoredTelemetryIncompleteError)) throw error;
+            incomplete.push(error);
+            console.warn(
+              'gpu-metrics: incomplete stored telemetry, trying artifacts:',
+              error.message,
+            );
+          }
+        }
+        if (
+          incomplete.length === 0 &&
+          databaseSeries.length > 0 &&
+          sourceCoverage(databaseSeries, sources).missingSources.length === 0
+        ) {
+          return powerSeriesResponse('database', stored.runInfo, databaseSeries, sources);
+        }
+      } else if (artifacts.length > 0 || stored.artifactNames) {
+        return NextResponse.json(
+          { ...stored, artifacts },
+          { headers: { 'Cache-Control': 'no-store' } },
+        );
+      }
+    }
+    if (series === 'power') {
+      githubFallbackStarted = true;
+      const { runInfo, artifacts, bundleSeries } = await fetchGpuMetricsFromGithub(
+        runId,
+        prefix,
+        true,
+        sources === null ? null : sourceCoverage(databaseSeries, sources).missingSources,
+      );
+      const powerSeries = artifacts
+        .map((artifact) => bucketPowerFiles(artifact.name, artifact.files))
+        .filter((entry): entry is GpuPowerSeries => entry !== null);
+      // A fallback response can combine durable history with live recovery.
+      // Keep healthy stored windows even when their GitHub copies expired,
+      // and never replace or duplicate them with a live copy. source='github'
+      // records that this response required fallback, not that every row is live.
+      const databaseSources = new Set(databaseSeries.map(seriesSource));
+      const combined = [
+        ...databaseSeries,
+        ...[...powerSeries, ...bundleSeries].filter(
+          (entry) =>
+            !databaseSources.has(seriesSource(entry)) &&
+            (sources === null || sources.includes(seriesSource(entry) ?? '')),
+        ),
+      ];
+      for (const missing of incomplete) {
+        const incompleteArtifact = missing.artifact;
+        const live = artifacts.find((artifact) => artifact.name === incompleteArtifact);
+        const inventory = stored?.artifacts.find(
+          (artifact) => artifact.series?.artifactName === incompleteArtifact,
+        )?.series?.sidecars.seriesInventory;
+        // A matching name alone cannot prove that missing hosts/samples recovered.
+        // Bundle cuts do not retain the raw inventory, so known-incomplete bundles
+        // require re-ingest; ordinary un-ingested bundle fallback stays available.
+        if (!live || !Array.isArray(inventory) || inventory.length === 0) throw missing;
+        const counts = new Map(
+          live.files.map((file) => [
+            file.name,
+            new Set(
+              file.data.flatMap((row) => {
+                const time = parseTelemetryTimestampUtc(row.timestamp);
+                return time === null || !Number.isInteger(row.index) || !Number.isFinite(row.power)
+                  ? []
+                  : [`${row.index}:${time}`];
+              }),
+            ).size,
+          ]),
+        );
+        if (
+          !inventory.every(
+            (expected) =>
+              expected !== null &&
+              typeof expected === 'object' &&
+              typeof expected.fileName === 'string' &&
+              typeof expected.sampleCount === 'number' &&
+              counts.get(expected.fileName) === expected.sampleCount,
+          )
+        )
+          throw missing;
+      }
+      return powerSeriesResponse('github', runInfo, combined, sources);
+    }
+    const live = await fetchGpuMetricsFromGithub(runId, prefix, false);
+    return NextResponse.json(
+      {
+        source: live.source,
+        runInfo: live.runInfo,
+        artifacts: live.artifacts.flatMap(({ name, files }) =>
+          files.map((file) => ({
+            name: files.length > 1 ? `${name}/${file.name}` : name,
+            data: file.data,
+          })),
+        ),
+      },
+      { headers: { 'Cache-Control': 'no-store' } },
+    );
   } catch (error) {
     console.error('Error fetching GPU power data:', error);
+    const missing = error instanceof StoredTelemetryIncompleteError ? error : incomplete[0];
+    if (githubFallbackStarted && !missing && stored && databaseSeries.length > 0) {
+      return powerSeriesResponse('database', stored.runInfo, databaseSeries, sources);
+    }
     return NextResponse.json(
-      { error: error instanceof Error ? error.message : 'Unknown error occurred' },
-      { status: 500 },
+      missing
+        ? {
+            error: missing.message,
+            code: 'STORED_TELEMETRY_INCOMPLETE',
+            artifact: missing.artifact,
+          }
+        : { error: error instanceof Error ? error.message : 'Unknown error occurred' },
+      { status: missing ? 503 : 500, headers: { 'Cache-Control': 'no-store' } },
     );
   }
 }
diff --git a/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts b/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
new file mode 100644
index 000000000..0fdad8907
--- /dev/null
+++ b/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
@@ -0,0 +1,264 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { gunzipSync } from 'node:zlib';
+import { PGlite } from '@electric-sql/pglite';
+import { NextRequest } from 'next/server';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ingestGpuMetricsArtifact } from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
+import type * as GpuMetricStatsModule from '@semianalysisai/inferencex-db/lib/gpu-metric-stats';
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+import { getGpuMetricsPointRevision } from '@semianalysisai/inferencex-db/queries/gpu-metrics-revision';
+import { startPowerxBlobFixture } from '../../../../../scripts/powerx-blob-fixture';
+
+const algorithm = vi.hoisted(() => ({ version: 1 }));
+vi.mock('@semianalysisai/inferencex-db/lib/gpu-metric-stats', async (importOriginal) => {
+  const actual = await importOriginal<typeof GpuMetricStatsModule>();
+  return {
+    ...actual,
+    get GPU_STATS_VERSION() {
+      return algorithm.version;
+    },
+  };
+});
+
+const connection = vi.hoisted(() => ({ getDb: vi.fn() }));
+vi.mock('@semianalysisai/inferencex-db/connection', () => connection);
+// The query, cache abstraction, Blob SDK, HTTP transport and ETL are real.
+import { GET } from './route';
+
+let db: PGlite;
+type Sql = Parameters<typeof ingestGpuMetricsArtifact>[0];
+let sql: Sql;
+let blob: Awaited<ReturnType<typeof startPowerxBlobFixture>>;
+let root: string;
+let sampleReads = 0;
+const artifactName = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+const artifact = () => ({ artifactName, artifactDir: root });
+
+function client(database: Pick<PGlite, 'query'>) {
+  return Object.assign(
+    async (strings: TemplateStringsArray, ...values: unknown[]) => {
+      const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+      if (query.includes('from gpu_metric_samples')) sampleReads++;
+      const result = await database.query<Record<string, unknown>>(query, values);
+      return result.rows;
+    },
+    { json: JSON.stringify, array: (value: unknown) => value },
+  );
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
+    await db.exec(
+      fs.readFileSync(new URL(`../../../../../../db/migrations/${name}`, import.meta.url), 'utf8'),
+    );
+  }
+  await db.exec(`ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+    VALUES (1, 34557177019, 1, 'Run Sweep', 'completed', 'success', '2026-09-11', '2026-09-11');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 4, 4, 4, 4);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+      (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}');`);
+  sql = Object.assign(client(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(client(tx) as unknown as Sql)),
+  }) as unknown as Sql;
+  connection.getDb.mockReturnValue(sql);
+  blob = await startPowerxBlobFixture();
+  for (const [key, value] of Object.entries(blob.env)) vi.stubEnv(key, value);
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-cache-recovery-'));
+  // Retained run 34175132645, attempt 1; source and excerpt hashes live beside the fixture.
+  const csv = fs.readFileSync(
+    new URL('../../../../../../../docs/fixtures/powerx-reingest/nvidia.csv', import.meta.url),
+  );
+  expect(createHash('sha256').update(csv).digest('hex')).toBe(
+    '833cf864da4618579deeeda89b3ddde6dbf8b7b32b7877fda643f18411ee3481',
+  );
+  fs.writeFileSync(path.join(root, 'gpu_metrics.csv'), csv);
+}, 20_000);
+
+afterAll(async () => {
+  vi.unstubAllEnvs();
+  await blob?.close();
+  await db?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+beforeEach(async () => {
+  algorithm.version = 1;
+  await db.exec(
+    'TRUNCATE gpu_metric_series RESTART IDENTITY CASCADE; UPDATE benchmark_results SET power_audit = null;',
+  );
+  blob.objects.clear();
+  Object.assign(blob.counts, { reads: 0, writes: 0, failedWrites: 0 });
+  sampleReads = 0;
+  // Injected test sidecars: the retained source does not establish its timezone or identity.
+  fs.writeFileSync(
+    path.join(root, 'gpu_metrics_context.json'),
+    JSON.stringify({ timestamp_timezone: 'UTC' }),
+  );
+  fs.writeFileSync(
+    path.join(root, 'gpu_metrics_identity.csv'),
+    'index, uuid, name\n0, GPU-old, NVIDIA B200\n',
+  );
+});
+
+async function request(id: number) {
+  const response = await GET(new NextRequest(`http://localhost/api/v1/gpu-metrics-point?id=${id}`));
+  const bytes = Buffer.from(await response.arrayBuffer());
+  const body =
+    response.headers.get('content-encoding') === 'gzip'
+      ? gunzipSync(bytes).toString()
+      : bytes.toString();
+  return { response, body: JSON.parse(body) };
+}
+
+describe('artifact → local DB → real Blob cache → point API recovery', () => {
+  it('requires live revision checks for successful and missing responses', async () => {
+    const missing = await request(10);
+    expect(missing.response.headers.get('cache-control')).toBe('no-store');
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10],
+    });
+    const present = await request(10);
+    expect(present.response.headers.get('cache-control')).toBe('no-store');
+  });
+  it('refreshes missing points, shared links, timezone and identity repairs without purging', async () => {
+    const missing = await request(10);
+    expect(missing.response.status).toBe(404);
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10],
+    });
+    const old = await request(10);
+    expect(old.response.status).toBe(200);
+    const originalSeries: GpuMetricSeries = old.body.series[0];
+    expect(originalSeries).toMatchObject({
+      sampleCount: 24,
+      gpuCount: 8,
+      startedAt: '2026-09-08T07:20:19.279Z',
+      endedAt: '2026-09-08T07:20:21.279Z',
+    });
+    expect(originalSeries.data).toHaveLength(24);
+    expect(originalSeries.data.filter((row) => row.index === 0).map((row) => row.power)).toEqual([
+      380.42, 336.61, 337.18,
+    ]);
+    expect(blob.objects.size).toBe(1);
+    const beforeHit = blob.counts.reads;
+    const beforeSampleReads = sampleReads;
+    const cached = await request(10);
+    expect(cached.body).toEqual(old.body);
+    expect(blob.counts.reads).toBe(beforeHit + 1);
+    expect(sampleReads).toBe(beforeSampleReads);
+
+    const unlinked = await request(11);
+    expect(unlinked.response.status).toBe(404);
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [11],
+    });
+    for (const id of [10, 11]) {
+      const linked = await request(id);
+      expect(linked.body.series[0].benchmarkResultIds).toEqual([10, 11]);
+    }
+    const oldRevision = await getGpuMetricsPointRevision(client(db), 10);
+    fs.writeFileSync(
+      path.join(root, 'gpu_metrics_context.json'),
+      JSON.stringify({ timestamp_timezone: '+08:00' }),
+    );
+    fs.writeFileSync(
+      path.join(root, 'gpu_metrics_identity.csv'),
+      'index, uuid, name\n0, GPU-corrected, NVIDIA B200\n',
+    );
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10, 11],
+    });
+    expect(await getGpuMetricsPointRevision(client(db), 10)).not.toBe(oldRevision);
+    for (const id of [10, 11]) {
+      const repaired = await request(id);
+      expect(repaired.body.series[0].data[0].timestamp).toBe('2026-09-07T23:20:19.279Z');
+      expect(repaired.body.series[0].sampleCount).toBe(24);
+      expect(JSON.stringify(repaired.body.series[0].sidecars)).toContain('GPU-corrected');
+    }
+    const revision = await getGpuMetricsPointRevision(client(db), 10);
+    const writes = blob.counts.writes;
+    const unchanged = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10, 11],
+    });
+    expect(unchanged.seriesSkipped).toBe(1);
+    expect(await getGpuMetricsPointRevision(client(db), 10)).toBe(revision);
+    await request(10);
+    expect(blob.counts.writes).toBe(writes);
+    const samples = await db.query('select count(*)::int as n from gpu_metric_samples');
+    expect(samples.rows).toEqual([{ n: 24 }]);
+  });
+});
+
+const power = (body: { series: GpuMetricSeries[] }) =>
+  body.series[0]!.stats.find((s) => s.gpuIndex === 0 && s.metric === 'power_w')!;
+
+it('bypasses warmed shared-point caches on algorithm upgrade, then persists through unchanged re-ingest', async () => {
+  const input = { workflowRunId: 1, artifact: artifact(), benchmarkResultIds: [10, 11] };
+  const first = await ingestGpuMetricsArtifact(sql, input);
+  await sql`update gpu_metric_gpu_stats set mean_value = -1`;
+
+  for (const id of [10, 11]) {
+    const cached = await request(id);
+    expect(power(cached.body).mean).toBe(-1);
+  }
+  const oldRevision = await getGpuMetricsPointRevision(client(db), 10);
+  const originalSamples =
+    await sql`select * from gpu_metric_samples order by series_id, sampled_at, gpu_index`;
+  // Model a code deploy: no DB row, sample, sidecar or link has changed.
+  algorithm.version = 2;
+  expect(await getGpuMetricsPointRevision(client(db), 10)).not.toBe(oldRevision);
+  for (const id of [10, 11]) {
+    const refreshed = await request(id);
+    expect(power(refreshed.body).mean).toBeCloseTo(351.403333, 3);
+  }
+  expect(await sql`select stats_version from gpu_metric_series`).toEqual([{ stats_version: 1 }]);
+  expect(await sql`select distinct mean_value from gpu_metric_gpu_stats`).toEqual([
+    { mean_value: -1 },
+  ]);
+  const upgradedRevision = await getGpuMetricsPointRevision(client(db), 10);
+  const repaired = await ingestGpuMetricsArtifact(sql, input);
+  expect(repaired).toMatchObject({
+    seriesIds: first.seriesIds,
+    samplesInserted: 0,
+    seriesSkipped: 0,
+  });
+  expect(await getGpuMetricsPointRevision(client(db), 10)).not.toBe(upgradedRevision);
+  for (const id of [10, 11]) {
+    const refreshed = await request(id);
+    expect(power(refreshed.body).mean).toBeCloseTo(351.403333, 3);
+  }
+  expect(await sql`select stats_version from gpu_metric_series`).toEqual([{ stats_version: 2 }]);
+  expect(
+    await sql`select * from gpu_metric_samples order by series_id, sampled_at, gpu_index`,
+  ).toEqual(originalSamples);
+  const beforeHit = sampleReads;
+  await request(10);
+  expect(sampleReads).toBe(beforeHit);
+  expect(await ingestGpuMetricsArtifact(sql, input)).toMatchObject({
+    samplesInserted: 0,
+    seriesSkipped: 1,
+  });
+});
diff --git a/packages/app/src/app/api/v1/gpu-metrics-point/route.ts b/packages/app/src/app/api/v1/gpu-metrics-point/route.ts
new file mode 100644
index 000000000..6b995ecb2
--- /dev/null
+++ b/packages/app/src/app/api/v1/gpu-metrics-point/route.ts
@@ -0,0 +1,46 @@
+import { getDb } from '@semianalysisai/inferencex-db/connection';
+import { getGpuMetricsPointRevision } from '@semianalysisai/inferencex-db/queries/gpu-metrics-revision';
+import type { NextRequest } from 'next/server';
+import {
+  getGpuMetricsForPoint,
+  type GpuMetricsPointPayload,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import { cachedQuery } from '@/lib/api-cache';
+
+import { idQueryRoute } from '../id-routes';
+
+export const dynamic = 'force-dynamic';
+
+export const CACHE_KEY_PREFIX = 'gpu-metrics-point-v2';
+
+const getCachedGpuMetricsForPoint = cachedQuery(
+  (id: number, _revision: string): Promise<GpuMetricsPointPayload | null> =>
+    getGpuMetricsForPoint(getDb(), id),
+  CACHE_KEY_PREFIX,
+  { blobOnly: true },
+);
+
+/**
+ * GET /api/v1/gpu-metrics-point?id=N
+ *
+ * PowerX telemetry recorded while one benchmark point ran: every linked
+ * gpu_metrics series with full-resolution per-GPU samples and the ingest-time
+ * per-GPU statistics digest. 404 when the point has no linked series (its
+ * run predates migration 016 and the artifacts have expired, or the job
+ * uploaded no gpu_metrics artifact).
+ */
+const handleGet = idQueryRoute({
+  logLabel: 'gpu metrics point',
+  fetch: async (id) => {
+    const revision = await getGpuMetricsPointRevision(getDb(), id);
+    return revision === null ? null : getCachedGpuMetricsForPoint(id, revision);
+  },
+});
+
+export async function GET(request: NextRequest): Promise<Response> {
+  const response = await handleGet(request);
+  // The live revision check must run even when a point used to be missing.
+  response.headers.set('Cache-Control', 'no-store');
+  return response;
+}
diff --git a/packages/app/src/app/api/v1/views/extensions.test.ts b/packages/app/src/app/api/v1/views/extensions.test.ts
index 11d6dac9a..99402904f 100644
--- a/packages/app/src/app/api/v1/views/extensions.test.ts
+++ b/packages/app/src/app/api/v1/views/extensions.test.ts
@@ -19,7 +19,7 @@ const mocks = vi.hoisted(() => ({
   unofficial: vi.fn(),
   submissions: vi.fn(),
 }));
-vi.mock('@/app/api/gpu-metrics/route', () => ({ GET: mocks.metrics }));
+vi.mock('@/app/api/gpu-metrics/route', () => ({ readGpuMetricsForView: mocks.metrics }));
 vi.mock('@/app/api/video-runs/route', () => ({ GET: mocks.video }));
 vi.mock('@/app/api/v1/benchmarks/route', () => ({ GET: mocks.benchmarks }));
 vi.mock('@/app/api/unofficial-run/route', () => ({ GET: mocks.unofficial }));
diff --git a/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts b/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
new file mode 100644
index 000000000..b4f3f167b
--- /dev/null
+++ b/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
@@ -0,0 +1,101 @@
+import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+import type { GpuMetricsArtifact, GpuPowerApiResponse } from '@/components/gpu-power/types';
+import { NextRequest } from 'next/server';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { metrics } = vi.hoisted(() => ({ metrics: vi.fn() }));
+vi.mock('@/app/api/gpu-metrics/route', () => ({
+  GET: metrics,
+  readGpuMetricsForView: metrics,
+}));
+// These source handlers are imported by the shared source module, but this view never calls them.
+vi.mock('@/app/api/v1/benchmarks/route', () => ({ GET: vi.fn() }));
+vi.mock('@/app/api/unofficial-run/route', () => ({ GET: vi.fn() }));
+
+import { GET } from './route';
+
+const rows = [
+  { timestamp: '2026-09-08T00:00:00Z', index: 0, power: 100, temperature: 40 },
+  { timestamp: '2026-09-08T00:00:01Z', index: 0, power: 300, temperature: 42 },
+  { timestamp: '2026-09-08T00:00:01Z', index: 1, power: 50, temperature: 38 },
+];
+const digest: GpuMetricStatRow[] = [
+  {
+    gpuIndex: 0,
+    metric: 'power_w',
+    count: 10,
+    min: 0,
+    max: 800,
+    mean: 350,
+    median: 300,
+    p95: 750,
+    p99: 790,
+    stddev: 200,
+  },
+  {
+    gpuIndex: 1,
+    metric: 'power_w',
+    count: 12,
+    min: 100,
+    max: 900,
+    mean: 700,
+    median: 750,
+    p95: 880,
+    p99: 898,
+    stddev: 80,
+  },
+];
+function artifact(stats: GpuMetricStatRow[] = digest): GpuMetricsArtifact {
+  return {
+    name: 'gpu_metrics_retained/host-a/gpu_metrics.csv',
+    data: rows,
+    series: {
+      id: 1,
+      artifactName: 'gpu_metrics_retained',
+      configKey: 'retained',
+      fileName: 'host-a/gpu_metrics.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 22,
+      gpuCount: 2,
+      startedAt: '2026-09-08T00:00:00Z',
+      endedAt: '2026-09-08T00:00:10Z',
+      sidecars: {},
+      benchmarkResultIds: [10, 11],
+      stats,
+    },
+  };
+}
+const runInfo = {
+  id: 34175132645,
+  name: 'Run Sweep',
+  branch: 'main',
+  sha: 'retained-source',
+  createdAt: '2026-09-08T00:00:00Z',
+  url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645',
+  conclusion: 'success',
+  status: 'completed',
+};
+function source(artifacts: GpuMetricsArtifact[]) {
+  const payload: GpuPowerApiResponse = { runInfo, artifacts };
+  metrics.mockImplementation(() => Response.json(payload));
+}
+const request = (query = '') =>
+  new NextRequest(`http://localhost/api/v1/views/gpu-metrics?runId=${runInfo.id}${query}`);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  source([artifact()]);
+});
+
+describe('GET /api/v1/views/gpu-metrics full-record statistics', () => {
+  it('returns the stored digest even when raw rows would produce different statistics', async () => {
+    const response = await GET(request());
+    expect(response.status).toBe(200);
+    expect(response.headers.get('cache-control')).toBe('private, no-store');
+    const body = await response.json();
+    expect(body.stats).toEqual(digest.map(({ metric: _metric, ...stats }) => stats));
+    expect(body.rows).toEqual(rows);
+    expect(metrics.mock.calls[0][0].nextUrl.searchParams.get('runId')).toBe(String(runInfo.id));
+  });
+});
diff --git a/packages/app/src/app/api/v1/views/gpu-metrics/route.ts b/packages/app/src/app/api/v1/views/gpu-metrics/route.ts
index 253c8bb1f..9b9ae967d 100644
--- a/packages/app/src/app/api/v1/views/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/v1/views/gpu-metrics/route.ts
@@ -1,10 +1,13 @@
-import { GET as metrics } from '@/app/api/gpu-metrics/route';
+import {
+  readGpuMetricsForView as metrics,
+  type GpuMetricsRouteResponse,
+} from '@/app/api/gpu-metrics/route';
 import { buildCorrelationData, buildGroupedData } from '@/components/gpu-power/chart-data';
+import { storedGpuStatsForMetric } from '@/components/gpu-power/stored-gpu-stats';
 import {
   ALL_METRIC_OPTIONS,
   computeGpuStats,
   getAvailableMetrics,
-  type GpuPowerApiResponse,
 } from '@/components/gpu-power/types';
 import { runViewsRoute, ViewsApiParamError } from '@/lib/views-api/errors';
 import {
@@ -21,24 +24,24 @@ import { type NextRequest, NextResponse } from 'next/server';
 export const dynamic = 'force-dynamic';
 export const maxDuration = 300;
 
-/** Live metrics intentionally bypass both CDN and Blob caching. */
+/** Stored and live metrics bypass response caching so repairs remain observable. */
 export function GET(request: NextRequest) {
   return runViewsRoute('gpu-metrics', async () => {
     validateViewParams(request.nextUrl.searchParams, VIEW_QUERY_PARAMS['gpu-metrics']);
     const s = request.nextUrl.searchParams;
     if (!s.get('runId')) throw new ViewsApiParamError('runId', 'runId is required');
     const runId = parseNumberParam(s.get('runId'), 'runId', 0, { min: 1, integer: true });
-    const data = await readResponse<GpuPowerApiResponse>(
-      await metrics(sourceRequest(request, '/api/gpu-metrics', { runId: String(runId) })),
+    const data = await readResponse<GpuMetricsRouteResponse>(
+      await metrics(
+        sourceRequest(request, '/api/gpu-metrics', { runId: String(runId) }),
+        s.get('artifact'),
+      ),
     );
+    const artifactNames = data.artifactNames ?? data.artifacts.map((a) => a.name);
     const artifact = s.get('artifact') ?? data.artifacts[0]?.name;
     const selected = data.artifacts.find((a) => a.name === artifact);
     if (artifact && !selected)
-      throw new ViewsApiParamError(
-        'artifact',
-        'Unknown artifact',
-        data.artifacts.map((a) => a.name),
-      );
+      throw new ViewsApiParamError('artifact', 'Unknown artifact', artifactNames);
     const rows = selected?.data ?? [];
     const availableMetrics = getAvailableMetrics(rows);
     const keys = ALL_METRIC_OPTIONS.map((m) => m.key);
@@ -70,9 +73,11 @@ export function GET(request: NextRequest) {
     );
     const direction = parseEnumParam(s.get('direction'), 'direction', ['asc', 'desc'], 'asc');
     // The UI statistics table uses all chips; chart visibility does not filter it.
-    const stats = computeGpuStats(rows, metric).sort(
-      (a, b) => (a[sort] - b[sort]) * (direction === 'asc' ? 1 : -1),
-    );
+    const stats = (
+      selected?.series
+        ? storedGpuStatsForMetric(selected.series.stats, metric)
+        : computeGpuStats(rows, metric)
+    ).sort((a, b) => (a[sort] - b[sort]) * (direction === 'asc' ? 1 : -1));
     return NextResponse.json(
       {
         view: 'gpu-metrics',
@@ -90,7 +95,7 @@ export function GET(request: NextRequest) {
           direction,
         },
         runInfo: data.runInfo,
-        artifacts: data.artifacts.map((a) => a.name),
+        artifacts: artifactNames,
         availableMetrics,
         gpuIndices: indices,
         rows: rows.filter((r) => gpus.includes(r.index)),
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.test.ts b/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
new file mode 100644
index 000000000..eb41678c5
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
@@ -0,0 +1,164 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  BUNDLE_MANIFEST_ENTRY,
+  BUNDLE_SAMPLES_ENTRY,
+  BUNDLE_WINDOW_PAD_SECONDS,
+  cutPowerAuditBundle,
+  parsePowerCsvData,
+} from './power-audit-bundle';
+
+const ARTIFACT = 'power_audit_qwen3.5_8k1k_fp8_dynamo-sglang_x';
+const RESULT = 'qwen3.5_8k1k_fp8_dynamo-sglang_x_sa-bench_isl_8192_osl_1024';
+
+/** `<hostname>/<GPU-uuid>` ids of the 2 × 2 synthetic cluster. */
+const A0 = 'cn01/GPU-a0';
+const A1 = 'cn01/GPU-a1';
+const B0 = 'cn02/GPU-b0';
+const B1 = 'cn02/GPU-b1';
+
+const HEADER = 'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w';
+
+function sample(time: number, device: string, power: number): string {
+  const [hostname, uuid] = device.split('/');
+  const gpuIndex = uuid.endsWith('0') ? 0 : 1;
+  return `1,${time},7,${hostname},${gpuIndex},${uuid},${power}`;
+}
+
+/** Every device sampled once per whole second in `[from, to]`, in scrambled device order. */
+function tick(time: number, watts: Record<string, number>): string[] {
+  return [B1, A1, B0, A0].map((device) => sample(time, device, watts[device]));
+}
+
+const WATTS = { [A0]: 100, [A1]: 110, [B0]: 200, [B1]: 50 };
+
+/** Window 1 at 1000–1010 s, window 2 at 2000–2010 s; nothing near window 3 at 5000 s. */
+const SAMPLES = [
+  HEADER,
+  // Just outside the 60 s pad of window 1.
+  ...tick(1000 - BUNDLE_WINDOW_PAD_SECONDS - 1, WATTS),
+  // Pad boundaries and the window itself.
+  ...tick(1000 - BUNDLE_WINDOW_PAD_SECONDS, WATTS),
+  ...tick(1000, WATTS),
+  ...tick(1005.4, { [A0]: 300, [A1]: 310, [B0]: 400, [B1]: 60 }),
+  ...tick(1010, WATTS),
+  ...tick(1010 + BUNDLE_WINDOW_PAD_SECONDS, WATTS),
+  ...tick(1010 + BUNDLE_WINDOW_PAD_SECONDS + 1, WATTS),
+  // Window 2, sampled by three devices only.
+  sample(2000, A1, 120),
+  sample(2000, A0, 130),
+  sample(2000, B0, 220),
+  sample(2001, A1, 121),
+  sample(2001, A0, 131),
+  sample(2001, B0, 221),
+  // Malformed rows: short line, non-numeric power, blank power (`Number('')`
+  // is 0), blank gpu_index, blank line.
+  '1,2002,7,cn01',
+  `1,2002,7,cn01,0,GPU-a0,N/A`,
+  `1,2002,7,cn01,0,GPU-a0,`,
+  `1,2002,7,cn01, ,GPU-a0,55`,
+  '',
+].join('\n');
+
+const MANIFEST = JSON.stringify({
+  schema_version: 1,
+  producer: 'srt-slurm.dcgm-power',
+  expected_devices: [
+    { hostname: 'cn01', gpu_index: 0, assignments: [{ worker_role: 'prefill' }] },
+    { hostname: 'cn01', gpu_index: 1, assignments: [{ worker_role: 'prefill' }] },
+    { hostname: 'cn02', gpu_index: 0, assignments: [{ worker_role: 'decode' }] },
+    { hostname: 'cn02', gpu_index: 1, assignments: [] },
+  ],
+});
+
+function validationName(conc: number): string {
+  return `power_validation_${RESULT}_conc${conc}_gpus_4_ctx_2_gen_2.json`;
+}
+
+/** Window 1: roles from `per_gpu_role`, where cn02/GPU-b0 is a prefill worker and GPU-b1 is unassigned. */
+const VALIDATION_1 = JSON.stringify({
+  schema_version: 1,
+  benchmark_window: { start_time_unix: 900, end_time_unix: 1100 },
+  selected_window: { concurrency: 1, start_time_unix: 1000, end_time_unix: 1010 },
+  per_gpu_role: { [A0]: 'decode', [A1]: 'prefill', [B0]: 'prefill' },
+});
+
+/** Window 2: no `per_gpu_role` and no `selected_window`, so the manifest and `benchmark_window` apply. */
+const VALIDATION_2 = JSON.stringify({
+  schema_version: 1,
+  benchmark_window: { start_time_unix: 2000, end_time_unix: 2010 },
+});
+
+/** Window 3: valid, but no sample lands within the pad. */
+const VALIDATION_3 = JSON.stringify({
+  selected_window: { concurrency: 3, start_time_unix: 5000, end_time_unix: 5010 },
+});
+
+function bundle(overrides: Record<string, string | undefined> = {}): Map<string, string> {
+  const files = new Map<string, string | undefined>([
+    [validationName(3), VALIDATION_3],
+    [validationName(1), VALIDATION_1],
+    [BUNDLE_SAMPLES_ENTRY, SAMPLES],
+    [BUNDLE_MANIFEST_ENTRY, MANIFEST],
+    [validationName(2), VALIDATION_2],
+  ]);
+  for (const [name, text] of Object.entries(overrides)) files.set(name, text);
+  const present = new Map<string, string>();
+  for (const [name, text] of files) if (text !== undefined) present.set(name, text);
+  return present;
+}
+
+describe('cutPowerAuditBundle', () => {
+  it('orders rows prefill, decode, unassigned, then by hostname and gpu_index', () => {
+    const [first] = cutPowerAuditBundle(ARTIFACT, bundle());
+    expect(first.devices).toEqual([
+      { id: A1, role: 'prefill' },
+      { id: B0, role: 'prefill' },
+      { id: A0, role: 'decode' },
+      { id: B1 },
+    ]);
+    expect(first.gpus).toEqual([0, 1, 2, 3]);
+    expect(first.power).toHaveLength(4);
+    // Row order is the device order: A1 reads 110 W, then 310 W in the window.
+    expect(first.power[0][1]).toBe(110);
+    expect(first.power[0][2]).toBe(310);
+    expect(first.power[3][2]).toBe(60);
+  });
+
+  it('clips samples to the window plus the pad on both sides', () => {
+    const [first] = cutPowerAuditBundle(ARTIFACT, bundle());
+    expect(first.startMs).toBe((1000 - BUNDLE_WINDOW_PAD_SECONDS) * 1000);
+    expect(first.t).toEqual([0, 60, 65, 70, 130]);
+    // 1005.4 s lands in the 1005 s bucket; the malformed 2002 s rows never appear.
+    expect(first.power[2]).toEqual([100, 100, 300, 100, 100]);
+  });
+});
+
+describe('parsePowerCsvData', () => {
+  const NVIDIA_CSV = [
+    'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+    '2026/09/11 04:19:41.123, 0, 350.5 W, 60, 1980 MHz, 2619 MHz, 90 %, 50 %',
+  ].join('\n');
+
+  it('normalizes UTC and missing collector context to ISO UTC like the stored path', () => {
+    // A zone-less stamp left as-is would be parsed as browser-local by `new Date`.
+    for (const context of [null, { timestamp_timezone: 'UTC' }, { timestamp_timezone: '+00:00' }]) {
+      expect(parsePowerCsvData(NVIDIA_CSV, context).map((row) => row.timestamp)).toEqual([
+        '2026-09-11T04:19:41.123Z',
+      ]);
+    }
+  });
+
+  it('applies a non-zero collector offset', () => {
+    expect(
+      parsePowerCsvData(NVIDIA_CSV, { timestamp_timezone: '+08:00' }).map((row) => row.timestamp),
+    ).toEqual(['2026-09-10T20:19:41.123Z']);
+  });
+
+  it('leaves ISO timestamps untouched', () => {
+    const iso = NVIDIA_CSV.replace('2026/09/11 04:19:41.123', '2026-09-11T04:19:41.123Z');
+    expect(parsePowerCsvData(iso, { timestamp_timezone: 'UTC' })[0]?.timestamp).toBe(
+      '2026-09-11T04:19:41.123Z',
+    );
+  });
+});
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.ts b/packages/app/src/components/gpu-power/power-audit-bundle.ts
new file mode 100644
index 000000000..063972401
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.ts
@@ -0,0 +1,373 @@
+/**
+ * Cuts per-config power series out of a `power_audit_<RESULT_FILENAME>` bundle.
+ *
+ * Slurm / Dynamo disaggregated runners do not publish one `gpu_metrics_*` CSV
+ * per config. Their DCGM collector writes one bundle per concurrency sweep:
+ * `LOGS/power/samples.csv` holds ~1 Hz watts for every GPU across the whole
+ * sweep, `LOGS/power/manifest.json` names the devices and their worker role,
+ * and one top-level `power_validation_*.json` per concurrency records the
+ * validated measurement window. Each validation file becomes one
+ * `GpuPowerSeries` whose `source` is that file's basename, so the timeline
+ * joins it to the chart row carrying the same `power_audit.source`.
+ *
+ * Pure: the route hands over the extracted entry texts; nothing here reads
+ * the network or the zip.
+ */
+import { parseNvidiaTimestamp } from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
+import {
+  isPowerAuditValidationEntry,
+  normalizePowerAuditValidations,
+} from '@semianalysisai/inferencex-db/etl/power-audit-validations';
+
+import {
+  bucketPowerSeries,
+  parseTelemetryTimestampUtc,
+  type GpuPowerDevice,
+  type GpuPowerRole,
+  type GpuPowerSeries,
+} from './power-series';
+import { parseCsvData, type GpuMetricRow } from './types';
+
+/** Seconds of telemetry kept on each side of a validated window (ramp-up / drain context). */
+export const BUNDLE_WINDOW_PAD_SECONDS = 60;
+
+export const BUNDLE_SAMPLES_ENTRY = 'LOGS/power/samples.csv';
+export const BUNDLE_MANIFEST_ENTRY = 'LOGS/power/manifest.json';
+
+/** Zip entries the route must extract for `cutPowerAuditBundle`; everything else stays compressed. */
+export function isPowerAuditBundleEntry(entryName: string): boolean {
+  return (
+    entryName === BUNDLE_SAMPLES_ENTRY ||
+    entryName === BUNDLE_MANIFEST_ENTRY ||
+    isPowerAuditValidationEntry(entryName) ||
+    isSmiCsv(entryName) ||
+    isContextEntry(entryName)
+  );
+}
+
+function isSmiCsv(name: string): boolean {
+  return /(?:^|\/)gpu_metrics[^/]*\.csv$/u.test(name) && !/_(?:identity|energy_)/u.test(name);
+}
+
+function isContextEntry(entryName: string): boolean {
+  const name = basename(entryName);
+  return name.includes('gpu_metrics') && name.toLowerCase().endsWith('_context.json');
+}
+
+export interface PowerAuditSample {
+  /** Unix seconds. */
+  time: number;
+  deviceId: string;
+  power: number;
+}
+
+export interface PowerAuditDevice {
+  /** `<hostname>/<GPU-uuid>`, the form `power_audit.observed_gpu_ids` uses. */
+  id: string;
+  hostname: string;
+  gpuIndex: number;
+}
+
+interface ParsedSamples {
+  samples: PowerAuditSample[];
+  /** Devices in first-seen order. */
+  devices: Map<string, PowerAuditDevice>;
+}
+
+const SAMPLE_COLUMNS = ['timestamp_unix', 'hostname', 'gpu_index', 'gpu_uuid', 'power_w'] as const;
+
+const NUMERIC_CELL = /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/iu;
+
+/** A CSV cell as a number, or NaN for anything that is not a plain numeral (`Number('')` is 0). */
+function numericCell(cell: string): number {
+  const text = cell.trim();
+  return NUMERIC_CELL.test(text) ? Number(text) : Number.NaN;
+}
+
+function splitCsvLines(text: string): string[] {
+  return text.split('\n').map((line) => (line.endsWith('\r') ? line.slice(0, -1) : line));
+}
+
+/** Header-driven parse of `samples.csv`; malformed rows are skipped. */
+function parseSamples(csv: string): ParsedSamples {
+  const lines = splitCsvLines(csv);
+  const headerIndex = lines.findIndex((line) => line.trim().length > 0);
+  const empty: ParsedSamples = { samples: [], devices: new Map() };
+  if (headerIndex === -1) return empty;
+  const header = lines[headerIndex].split(',').map((cell) => cell.trim());
+  const columns = SAMPLE_COLUMNS.map((name) => header.indexOf(name));
+  if (columns.includes(-1)) return empty;
+  const [timeCol, hostCol, indexCol, uuidCol, powerCol] = columns;
+  const width = Math.max(...columns) + 1;
+
+  const samples: PowerAuditSample[] = [];
+  const devices = new Map<string, PowerAuditDevice>();
+  for (const line of lines.slice(headerIndex + 1)) {
+    const cells = line.split(',');
+    if (cells.length < width) continue;
+    const time = numericCell(cells[timeCol]);
+    const power = numericCell(cells[powerCol]);
+    const gpuIndex = numericCell(cells[indexCol]);
+    const hostname = cells[hostCol].trim();
+    const uuid = cells[uuidCol].trim();
+    if (
+      !Number.isFinite(time) ||
+      !Number.isFinite(power) ||
+      !Number.isInteger(gpuIndex) ||
+      hostname.length === 0 ||
+      uuid.length === 0
+    ) {
+      continue;
+    }
+    const deviceId = `${hostname}/${uuid}`;
+    if (!devices.has(deviceId)) devices.set(deviceId, { id: deviceId, hostname, gpuIndex });
+    samples.push({ time, deviceId, power });
+  }
+  return { samples, devices };
+}
+
+function asRole(value: unknown): GpuPowerRole | undefined {
+  return value === 'prefill' || value === 'decode' ? value : undefined;
+}
+
+function parseJsonObject(text: string | undefined): Record<string, unknown> | null {
+  if (text === undefined) return null;
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function manifestSlot(hostname: string, gpuIndex: number): string {
+  return `${hostname}#${gpuIndex}`;
+}
+
+/** `expected_devices[].assignments[0].worker_role`, keyed by hostname + gpu_index. */
+function manifestRoles(manifest: Record<string, unknown> | null): Map<string, GpuPowerRole> {
+  const roles = new Map<string, GpuPowerRole>();
+  const expected = manifest?.expected_devices;
+  if (!Array.isArray(expected)) return roles;
+  for (const device of expected) {
+    if (!isRecord(device)) continue;
+    const { hostname, gpu_index: gpuIndex, assignments } = device;
+    if (
+      typeof hostname !== 'string' ||
+      typeof gpuIndex !== 'number' ||
+      !Array.isArray(assignments)
+    ) {
+      continue;
+    }
+    const first: unknown = assignments[0];
+    const role = isRecord(first) ? asRole(first.worker_role) : undefined;
+    if (role) roles.set(manifestSlot(hostname, gpuIndex), role);
+  }
+  return roles;
+}
+
+interface TimeWindow {
+  start: number;
+  end: number;
+}
+
+/** `selected_window`, else `benchmark_window`; `null` when neither has a finite range. */
+function validationWindow(validation: Record<string, unknown>): TimeWindow | null {
+  for (const key of ['selected_window', 'benchmark_window']) {
+    const window = validation[key];
+    if (!isRecord(window)) continue;
+    const start = window.start_time_unix;
+    const end = window.end_time_unix;
+    if (
+      typeof start === 'number' &&
+      typeof end === 'number' &&
+      Number.isFinite(start) &&
+      Number.isFinite(end) &&
+      end >= start
+    ) {
+      return { start, end };
+    }
+  }
+  return null;
+}
+
+const ROLE_ORDER: Record<GpuPowerRole, number> = { prefill: 0, decode: 1 };
+
+function roleRank(role: GpuPowerRole | undefined): number {
+  return role ? ROLE_ORDER[role] : 2;
+}
+
+function compareText(a: string, b: string): number {
+  if (a < b) return -1;
+  return a > b ? 1 : 0;
+}
+
+/** Prefill, then decode, then unassigned; within a role by hostname, then gpu_index. */
+function orderDevices(
+  devices: readonly GpuPowerDevice[],
+  byId: ReadonlyMap<string, PowerAuditDevice>,
+) {
+  return devices.toSorted((a, b) => {
+    const rank = roleRank(a.role) - roleRank(b.role);
+    if (rank !== 0) return rank;
+    const deviceA = byId.get(a.id)!;
+    const deviceB = byId.get(b.id)!;
+    return compareText(deviceA.hostname, deviceB.hostname) || deviceA.gpuIndex - deviceB.gpuIndex;
+  });
+}
+
+function basename(entryName: string): string {
+  return entryName.slice(entryName.lastIndexOf('/') + 1);
+}
+
+/**
+ * Normalize NVIDIA's unzoned wall-clock timestamps to ISO UTC, matching the ingest
+ * parser: the adjacent collector context supplies the offset and missing or UTC
+ * context means zero. Live and stored reads then agree, so a run does not shift by
+ * the browser timezone before ingest. ISO and AMD timestamps pass through unchanged.
+ */
+export function parsePowerCsvData(
+  text: string,
+  context: Record<string, unknown> | null,
+): GpuMetricRow[] {
+  const zone = context?.timestamp_timezone;
+  const offset =
+    typeof zone === 'string'
+      ? /^(?<sign>[+-])(?<h>\d{2}):?(?<m>\d{2})$/u.exec(zone.trim())?.groups
+      : null;
+  const offsetMinutes = offset
+    ? (offset.sign === '-' ? -1 : 1) * (Number(offset.h) * 60 + Number(offset.m))
+    : 0;
+  return parseCsvData(text).map((row) => {
+    const timestamp = parseNvidiaTimestamp(row.timestamp, offsetMinutes);
+    return timestamp === null ? row : { ...row, timestamp: new Date(timestamp).toISOString() };
+  });
+}
+
+/**
+ * One series per validation file that has a window and samples within
+ * `BUNDLE_WINDOW_PAD_SECONDS` of it. Rows follow `devices`, ordered prefill,
+ * decode, unassigned (hostname, then gpu_index inside a role); `gpus` are the
+ * row indices `0..n-1`. Roles come from the validation's `per_gpu_role`, else
+ * the manifest's `expected_devices`. Malformed JSON skips that file; a
+ * missing or empty `samples.csv` yields `[]`. Output is ordered by window start.
+ */
+export function cutPowerAuditBundle(
+  artifact: string,
+  files: ReadonlyMap<string, string>,
+): GpuPowerSeries[] {
+  const validations = normalizePowerAuditValidations(artifact, files);
+  const manifest = parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY));
+  const contextFiles = [...files]
+    .filter(([name]) => isContextEntry(name))
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+  const smiFiles = [...files]
+    .filter(([name]) => isSmiCsv(name))
+    .map(([name, text]) => {
+      const directory = name.slice(0, name.lastIndexOf('/') + 1);
+      let context: Record<string, unknown> | null = null;
+      for (const [entry, contents] of contextFiles) {
+        if (entry.slice(0, entry.lastIndexOf('/') + 1) !== directory) continue;
+        context = parseJsonObject(contents);
+        if (context) break;
+      }
+      const data = parsePowerCsvData(text, context);
+      return { name, data };
+    })
+    .filter((file) => file.data.length > 0);
+  // Ingest prefers the richer SMI CSV when the bundle carries both collectors.
+  if (smiFiles.length > 0) return cutPowerAuditCsvs(artifact, smiFiles, validations, manifest);
+  const samplesText = files.get(BUNDLE_SAMPLES_ENTRY);
+  if (samplesText === undefined) return [];
+  const { samples, devices } = parseSamples(samplesText);
+  if (samples.length === 0) return [];
+  return cutPowerAuditSamples(
+    artifact,
+    samples,
+    devices,
+    validations,
+    parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY)),
+  );
+}
+
+/** Apply bundle window cuts to the richer SMI CSVs without requiring DCGM UUID sidecars. */
+export function cutPowerAuditCsvs(
+  artifact: string,
+  files: readonly { name: string; data: readonly GpuMetricRow[] }[],
+  validations: ReadonlyMap<string, Record<string, unknown>>,
+  manifest: Record<string, unknown> | null,
+): GpuPowerSeries[] {
+  const populated = files.filter((file) => file.data.length > 0);
+  const devices = new Map<string, PowerAuditDevice>();
+  const samples: PowerAuditSample[] = [];
+  for (const file of populated) {
+    for (const row of file.data) {
+      const id = populated.length === 1 ? String(row.index) : `${file.name}/${row.index}`;
+      devices.set(id, { id, hostname: file.name, gpuIndex: row.index });
+      const time = parseTelemetryTimestampUtc(row.timestamp);
+      if (time !== null) samples.push({ deviceId: id, time: time / 1000, power: row.power });
+    }
+  }
+  return cutPowerAuditSamples(artifact, samples, devices, validations, manifest);
+}
+
+/** The same window/device/bucketing transform for persisted samples and artifact CSVs. */
+export function cutPowerAuditSamples(
+  artifact: string,
+  samples: readonly PowerAuditSample[],
+  devices: ReadonlyMap<string, PowerAuditDevice>,
+  validations: ReadonlyMap<string, Record<string, unknown>>,
+  manifest: Record<string, unknown> | null,
+): GpuPowerSeries[] {
+  const fallbackRoles = manifestRoles(manifest);
+  const cut: { start: number; series: GpuPowerSeries }[] = [];
+  for (const [entryName, validation] of validations) {
+    const window = validationWindow(validation);
+    if (!window) continue;
+
+    const lo = window.start - BUNDLE_WINDOW_PAD_SECONDS;
+    const hi = window.end + BUNDLE_WINDOW_PAD_SECONDS;
+    const inRange = samples.filter((sample) => sample.time >= lo && sample.time <= hi);
+    if (inRange.length === 0) continue;
+
+    const explicitRoles = isRecord(validation.per_gpu_role) ? validation.per_gpu_role : {};
+    const present = [...new Set(inRange.map((sample) => sample.deviceId))].map((id) => {
+      const device = devices.get(id)!;
+      const role =
+        asRole(explicitRoles[id]) ??
+        fallbackRoles.get(manifestSlot(device.hostname, device.gpuIndex));
+      return role ? { id, role } : { id };
+    });
+    const ordered = orderDevices(present, devices);
+    const rowOf = new Map(ordered.map((device, row) => [device.id, row]));
+
+    const rows: GpuMetricRow[] = inRange.map((sample) => ({
+      timestamp: String(sample.time),
+      index: rowOf.get(sample.deviceId)!,
+      power: sample.power,
+    }));
+    const series = bucketPowerSeries(artifact, rows);
+    if (!series) continue;
+    // The synthetic `index` is the device's position in `ordered`, so each
+    // bucketed row maps back to its device; `gpus` becomes plain row indices.
+    cut.push({
+      start: window.start,
+      series: {
+        ...series,
+        artifact,
+        source: basename(entryName),
+        gpus: series.gpus.map((_, row) => row),
+        devices: series.gpus.map((row) => ordered[row]),
+      },
+    });
+  }
+  return cut
+    .toSorted((a, b) => a.start - b.start || compareText(a.series.source!, b.series.source!))
+    .map((entry) => entry.series);
+}
diff --git a/packages/app/src/components/gpu-power/power-series.test.ts b/packages/app/src/components/gpu-power/power-series.test.ts
new file mode 100644
index 000000000..4b5a0fd91
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-series.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  bucketPowerSeries,
+  bucketPowerFiles,
+  bucketTimeMs,
+  meanPowerAt,
+  sumPowerAt,
+  type GpuPowerSeries,
+} from './power-series';
+import type { GpuMetricRow } from './types';
+
+function row(timestamp: string, index: number, power: number): GpuMetricRow {
+  return {
+    timestamp,
+    index,
+    power,
+    temperature: 40,
+    smClock: 1,
+    memClock: 1,
+    gpuUtil: 0,
+    memUtil: 0,
+  };
+}
+
+describe('bucketPowerSeries', () => {
+  it('aligns every GPU on one-second buckets and marks missing samples null', () => {
+    const rows = [
+      row('2026/09/12 20:20:41.817', 0, 194.4),
+      row('2026/09/12 20:20:41.820', 1, 192.4),
+      row('2026/09/12 20:20:42.816', 0, 300),
+      // GPU 1 skipped this tick; GPU 0 sampled twice in the next one.
+      row('2026/09/12 20:20:43.815', 0, 400),
+      row('2026/09/12 20:20:43.900', 0, 500),
+      row('2026/09/12 20:20:43.818', 1, 350),
+    ];
+    const series = bucketPowerSeries('gpu_metrics_test', rows);
+    expect(series).not.toBeNull();
+    expect(series!.startMs).toBe(Date.UTC(2026, 8, 12, 20, 20, 41));
+    expect(series!.bucketSeconds).toBe(1);
+    expect(series!.gpus).toEqual([0, 1]);
+    expect(series!.t).toEqual([0, 1, 2]);
+    expect(series!.power).toEqual([
+      [194.4, 300, 450],
+      [192.4, null, 350],
+    ]);
+    expect(meanPowerAt(series!, 1)).toBe(300);
+    expect(meanPowerAt(series!, 2)).toBe(400);
+    expect(bucketTimeMs(series!, 2)).toBe(Date.UTC(2026, 8, 12, 20, 20, 43));
+  });
+});
+
+describe('sumPowerAt', () => {
+  const series: GpuPowerSeries = {
+    artifact: 'power_audit_sweep',
+    startMs: Date.UTC(2026, 8, 12, 20, 0, 0),
+    bucketSeconds: 1,
+    gpus: [0, 1, 2],
+    t: [0, 1, 2],
+    power: [
+      [100, null, 300],
+      [50, 60, null],
+      [10, null, null],
+    ],
+  };
+
+  it('returns null for a partial pool, an unsampled bucket, an empty pool or an unknown row', () => {
+    // GPU 0 and 2 have no sample in bucket 1: a partial sum would read as a dip.
+    expect(sumPowerAt(series, [0, 1, 2], 1)).toBeNull();
+    expect(sumPowerAt(series, [0, 1], 2)).toBeNull();
+    expect(sumPowerAt(series, [0, 2], 1)).toBeNull();
+    expect(sumPowerAt(series, [], 0)).toBeNull();
+    expect(sumPowerAt(series, [7], 0)).toBeNull();
+  });
+});
+
+describe('bucketPowerFiles', () => {
+  it('keeps repeated GPU indices from different host files separate with stable identity', () => {
+    const time = '2026-09-12T04:00:00Z';
+    const files = [
+      { name: 'host-b/gpu_metrics.csv', data: [row(time, 0, 500)] },
+      { name: 'host-a/gpu_metrics.csv', data: [row(time, 0, 100), row(time, 2, 200)] },
+      { name: 'empty.csv', data: [] },
+    ];
+    const expected = {
+      artifact: 'gpu_metrics_multinode',
+      startMs: Date.parse(time),
+      bucketSeconds: 1,
+      gpus: [0, 1, 2],
+      t: [0],
+      power: [[100], [200], [500]],
+      devices: [
+        { id: 'host-a/gpu_metrics.csv/0' },
+        { id: 'host-a/gpu_metrics.csv/2' },
+        { id: 'host-b/gpu_metrics.csv/0' },
+      ],
+    };
+    expect(bucketPowerFiles('gpu_metrics_multinode', files)).toEqual(expected);
+    expect(bucketPowerFiles('gpu_metrics_multinode', files.toReversed())).toEqual(expected);
+    expect(bucketPowerFiles('empty', [])).toBeNull();
+    expect(bucketPowerFiles('single', [files[0]])?.gpus).toEqual([0]);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/power-series.ts b/packages/app/src/components/gpu-power/power-series.ts
new file mode 100644
index 000000000..8ff75fabb
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-series.ts
@@ -0,0 +1,212 @@
+/**
+ * Compact per-GPU power series for the PowerX timeline.
+ *
+ * A `gpu_metrics_<RESULT_FILENAME>` artifact carries ~1 Hz samples for every
+ * GPU of one benchmark config (server start, warmup, and the measured window).
+ * The raw rows are heavy (a 25-config run is ~27 MB of JSON), so the API can
+ * return this columnar shape instead: one row of watts per GPU, aligned on
+ * fixed-width time buckets, with `null` where a GPU had no sample.
+ *
+ * Runner timestamps are UTC wall clock (`2026/09/12 20:19:57.158`); the
+ * validated measurement window in `power_audit` is UTC epoch seconds, so the
+ * two line up without a timezone guess.
+ */
+import type { GpuMetricRow, GpuPowerRunInfo } from './types';
+
+/** Worker role a GPU served, when the collector's manifest assigns one. */
+export type GpuPowerRole = 'prefill' | 'decode';
+
+export interface GpuPowerDevice {
+  /**
+   * Producer device identifier: the nvidia-smi / amd-smi index (`"3"`) for
+   * `gpu_metrics_*` CSVs, `<hostname>/<GPU-uuid>` for DCGM power-audit
+   * bundles — the same form as `power_audit.observed_gpu_ids` on the row.
+   */
+  id: string;
+  role?: GpuPowerRole;
+}
+
+export interface GpuPowerSeries {
+  /** GitHub artifact name: `gpu_metrics_<RESULT_FILENAME>` or `power_audit_<RESULT_FILENAME>`. */
+  artifact: string;
+  /**
+   * Basename of the `power_validation_*.json` this series belongs to, for
+   * series cut from a power-audit bundle (one bundle holds a whole
+   * concurrency sweep). Absent for `gpu_metrics_*` series, whose artifact
+   * already names one config.
+   */
+  source?: string;
+  /** UTC epoch milliseconds of bucket 0. */
+  startMs: number;
+  /** Bucket width in seconds. */
+  bucketSeconds: number;
+  /** GPU indices, one per row of `power`, ascending. */
+  gpus: number[];
+  /** Seconds since `startMs` for each bucket, ascending. */
+  t: number[];
+  /** Watts per GPU (outer) per bucket (inner); `null` when no sample landed in the bucket. */
+  power: (number | null)[][];
+  /** One entry per row of `power` when the collector reports device identity or roles. */
+  devices?: GpuPowerDevice[];
+}
+
+export interface GpuPowerSeriesResponse {
+  runInfo: GpuPowerRunInfo;
+  series: GpuPowerSeries[];
+  /** Coverage of requested validation identities only, never the full run/sweep. */
+  sourceCoverage?: {
+    status: 'complete' | 'incomplete' | 'unknown';
+    missingSources: string[];
+  };
+}
+
+const RUNNER_TIMESTAMP =
+  /^(?<y>\d{4})[/-](?<mo>\d{2})[/-](?<d>\d{2})[ T](?<h>\d{2}):(?<mi>\d{2}):(?<s>\d{2})(?:\.(?<ms>\d{1,6}))?$/u;
+
+/**
+ * Parses a runner telemetry timestamp as UTC epoch milliseconds.
+ *
+ * nvidia-smi / amd-smi write `YYYY/MM/DD HH:MM:SS.mmm` without a zone; the
+ * collectors run in UTC, and `new Date(...)` would read that as browser local
+ * time, so the digits are assembled explicitly. ISO strings with a zone and
+ * numeric epochs (seconds or milliseconds) are accepted as-is.
+ */
+export function parseTelemetryTimestampUtc(raw: string): number | null {
+  const text = raw.trim();
+  const match = RUNNER_TIMESTAMP.exec(text);
+  if (match?.groups) {
+    const { y, mo, d, h, mi, s, ms } = match.groups;
+    const millis = ms ? Math.round(Number(`0.${ms}`) * 1000) : 0;
+    return Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s), millis);
+  }
+  if (/^\d+(?:\.\d+)?$/u.test(text)) {
+    const numeric = Number(text);
+    return numeric < 1e12 ? Math.round(numeric * 1000) : Math.round(numeric);
+  }
+  const parsed = Date.parse(text);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+/**
+ * Buckets raw per-GPU rows into the compact series. Samples of one GPU that
+ * share a bucket are averaged; repeated GPU/timestamps keep the first sample,
+ * matching ingest. Buckets nobody sampled are omitted from `t`.
+ * Returns `null` when no row carries a parseable timestamp.
+ */
+export function bucketPowerSeries(
+  artifact: string,
+  rows: readonly GpuMetricRow[],
+  bucketSeconds = 1,
+): GpuPowerSeries | null {
+  if (!(bucketSeconds > 0)) throw new RangeError('bucketSeconds must be positive');
+  const bucketMs = bucketSeconds * 1000;
+  let startMs = Number.POSITIVE_INFINITY;
+  const parsed: { ms: number; gpu: number; power: number }[] = [];
+  const seen = new Set<string>();
+  for (const row of rows) {
+    if (!Number.isFinite(row.power) || !Number.isInteger(row.index)) continue;
+    const ms = parseTelemetryTimestampUtc(row.timestamp);
+    if (ms === null) continue;
+    const key = `${row.index}:${ms}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    parsed.push({ ms, gpu: row.index, power: row.power });
+    if (ms < startMs) startMs = ms;
+  }
+  if (parsed.length === 0) return null;
+  startMs = Math.floor(startMs / bucketMs) * bucketMs;
+
+  const gpus = [...new Set(parsed.map((sample) => sample.gpu))].toSorted((a, b) => a - b);
+  const gpuRow = new Map(gpus.map((gpu, row) => [gpu, row]));
+  // bucket index -> per GPU [sum, count]
+  const buckets = new Map<number, [number, number][]>();
+  for (const sample of parsed) {
+    const bucket = Math.floor((sample.ms - startMs) / bucketMs);
+    let cells = buckets.get(bucket);
+    if (!cells) {
+      cells = gpus.map(() => [0, 0]);
+      buckets.set(bucket, cells);
+    }
+    const cell = cells[gpuRow.get(sample.gpu)!];
+    cell[0] += sample.power;
+    cell[1] += 1;
+  }
+  const bucketIndices = [...buckets.keys()].toSorted((a, b) => a - b);
+  const power: (number | null)[][] = gpus.map(() =>
+    Array.from({ length: bucketIndices.length }, (): number | null => null),
+  );
+  bucketIndices.forEach((bucket, column) => {
+    const cells = buckets.get(bucket)!;
+    cells.forEach(([sum, count], row) => {
+      power[row][column] = count > 0 ? Math.round((sum / count) * 100) / 100 : null;
+    });
+  });
+  return {
+    artifact,
+    startMs,
+    bucketSeconds,
+    gpus,
+    t: bucketIndices.map((bucket) => bucket * bucketSeconds),
+    power,
+  };
+}
+
+/** Keep host-local GPU indices distinct when one artifact stages multiple CSVs. */
+export function bucketPowerFiles(
+  artifact: string,
+  files: readonly { name: string; data: readonly GpuMetricRow[] }[],
+): GpuPowerSeries | null {
+  const populated = files
+    .filter((file) => file.data.length > 0)
+    .toSorted((a, b) => a.name.localeCompare(b.name));
+  if (populated.length === 0) return null;
+  if (populated.length === 1) return bucketPowerSeries(artifact, populated[0].data);
+  const devices = populated.flatMap((file) =>
+    [...new Set(file.data.map((row) => row.index))]
+      .toSorted((a, b) => a - b)
+      .map((gpu) => ({ id: `${file.name}/${gpu}`, file, gpu })),
+  );
+  const rows = devices.flatMap(({ file, gpu }, index) =>
+    file.data.filter((row) => row.index === gpu).map((row) => ({ ...row, index })),
+  );
+  const bucketed = bucketPowerSeries(artifact, rows);
+  return bucketed ? { ...bucketed, devices: devices.map(({ id }) => ({ id })) } : null;
+}
+
+/** Mean watts across the GPUs that have a sample in bucket `column`, or `null`. */
+export function meanPowerAt(series: GpuPowerSeries, column: number): number | null {
+  let sum = 0;
+  let count = 0;
+  for (const row of series.power) {
+    const value = row[column];
+    if (value === null || value === undefined) continue;
+    sum += value;
+    count += 1;
+  }
+  return count > 0 ? sum / count : null;
+}
+
+/**
+ * Summed watts over `rows` in bucket `column`, or `null` unless EVERY row has
+ * a sample: a pool total with a device missing would read as a dip against
+ * the pool's TDP, so the bucket is left as a gap instead.
+ */
+export function sumPowerAt(
+  series: GpuPowerSeries,
+  rows: readonly number[],
+  column: number,
+): number | null {
+  if (rows.length === 0) return null;
+  let sum = 0;
+  for (const row of rows) {
+    const value = series.power[row]?.[column];
+    if (value === null || value === undefined) return null;
+    sum += value;
+  }
+  return sum;
+}
+
+/** UTC epoch milliseconds of bucket `column`. */
+export function bucketTimeMs(series: GpuPowerSeries, column: number): number {
+  return series.startMs + series.t[column] * 1000;
+}
diff --git a/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts b/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
new file mode 100644
index 000000000..893b1ae2a
--- /dev/null
+++ b/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
@@ -0,0 +1,128 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  computeGpuMetricStats,
+  parseGpuMetricsCsv,
+  type GpuMetricSample,
+} from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
+import {
+  prepareGpuMetricsArtifact,
+  statMetricColumn,
+} from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
+
+import { storedGpuStatsForMetric } from './stored-gpu-stats';
+import { ALL_METRIC_OPTIONS, computeGpuStats, parseCsvData, type GpuMetricRow } from './types';
+
+function storedStats(samples: GpuMetricSample[]) {
+  return computeGpuMetricStats(samples).map((row) => ({
+    ...row,
+    metric: statMetricColumn(row.metric),
+  }));
+}
+
+function assertAllMetricStats(samples: GpuMetricSample[], rows: GpuMetricRow[]) {
+  const digest = storedStats(samples);
+  for (const { key } of ALL_METRIC_OPTIONS) {
+    const actual = storedGpuStatsForMetric(digest, key);
+    const expected = computeGpuStats(rows, key);
+    expect(actual, key).toHaveLength(expected.length);
+    for (const [index, row] of actual.entries()) {
+      expect(row.gpuIndex).toBe(expected[index].gpuIndex);
+      expect(row.count).toBe(expected[index].count);
+      // ETL sums sorted samples while the live reader sums recording order.
+      for (const field of ['min', 'max', 'mean', 'median', 'p95', 'p99', 'stddev'] as const) {
+        expect(row[field], `${key}.${field}`).toBeCloseTo(expected[index][field], 10);
+      }
+    }
+  }
+}
+
+describe('storedGpuStatsForMetric', () => {
+  it.each(['UTC', 'America/Los_Angeles'])(
+    'matches live NVIDIA and ingest populations across DST in %s',
+    (timezone) => {
+      const csv = [
+        'timestamp,index,power.draw [W]',
+        '2026/03/08 02:30:00.000,0,100',
+        '2026/03/08 02:30:00.000,0,900',
+        '2026/03/08 03:30:00.000,0,300',
+      ].join('\n');
+      const artifactDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-stats-dst-'));
+      const originalTimezone = process.env.TZ;
+      try {
+        process.env.TZ = timezone;
+        fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
+        const [prepared] = prepareGpuMetricsArtifact({
+          artifactDir,
+          artifactName: 'gpu_metrics_nvidia_dst',
+        });
+        expect(
+          prepared.samples.map((sample) => new Date(sample.timestampMs).toISOString()),
+        ).toEqual(['2026-03-08T02:30:00.000Z', '2026-03-08T03:30:00.000Z']);
+        const live = parseCsvData(csv);
+        // Preserve raw timestamps for the bundle's later context-offset adjustment.
+        expect(live.map((row) => row.timestamp)).toEqual([
+          '2026/03/08 02:30:00.000',
+          '2026/03/08 03:30:00.000',
+        ]);
+        expect(live.map((row) => row.power)).toEqual([100, 300]);
+        const actual = computeGpuStats(live, 'power');
+        expect(actual).toEqual([
+          {
+            gpuIndex: 0,
+            count: 2,
+            min: 100,
+            max: 300,
+            mean: 200,
+            median: 200,
+            p95: 290,
+            p99: 298,
+            stddev: 100,
+          },
+        ]);
+        const { metric: _metric, ...expected } = prepared.stats[0];
+        expect(actual).toEqual([expected]);
+      } finally {
+        if (originalTimezone === undefined) delete process.env.TZ;
+        else process.env.TZ = originalTimezone;
+        fs.rmSync(artifactDir, { recursive: true, force: true });
+      }
+    },
+  );
+
+  it('preserves NVIDIA units, zero readings, and full-record percentiles', () => {
+    const csv = [
+      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+      '2026/09/21 00:00:00, 0, 0 W, N/A, 120 MHz, 3996 MHz, 0 %, 0 %',
+      '2026/09/21 00:00:01, 0, 912.1 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+      '2026/09/21 00:00:02, 0, 187.8 W, 35, 120 MHz, 3996 MHz, 0 %, 0 %',
+      // Conflicting stop-time flush must not change the first reading.
+      '2026/09/21 00:00:02, 0, 999 W, 90, 120 MHz, 3996 MHz, 0 %, 0 %',
+    ].join('\n');
+    const samples = parseGpuMetricsCsv(csv)!.samples.slice(0, 3);
+    assertAllMetricStats(samples, parseCsvData(csv));
+    const [power] = storedGpuStatsForMetric(storedStats(samples), 'power');
+    expect(power.count).toBe(3);
+    expect(power.median).toBe(187.8);
+    expect(power.p95).toBeCloseTo(839.67, 10);
+    expect(power.p99).toBeCloseTo(897.614, 10);
+  });
+
+  it('maps every AMD metric without converting missing readings to zero', () => {
+    const csv = [
+      'timestamp,gpu,gfx_activity,umc_activity,mm_activity,socket_power,gfx_voltage,soc_voltage,mem_voltage,gfx_0_clk,mem_0_clk,fclk_0_clk,socclk_0_clk,edge,hotspot,mem',
+      '1789948800,0,0,0,N/A,0,N/A,N/A,N/A,N/A,2000,1250,39,N/A,N/A,24',
+      '1789948801,0,95,80,5,1180,850,900,1250,2402,2050,1300,40,55,78,60',
+      '1789948801,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0',
+    ].join('\n');
+    const samples = parseGpuMetricsCsv(csv)!.samples.slice(0, 2);
+    assertAllMetricStats(samples, parseCsvData(csv));
+    expect(storedGpuStatsForMetric(storedStats(samples), 'gfxVoltage')[0]).toMatchObject({
+      count: 1,
+      mean: 850,
+      stddev: 0,
+    });
+  });
+});
diff --git a/packages/app/src/components/gpu-power/stored-gpu-stats.ts b/packages/app/src/components/gpu-power/stored-gpu-stats.ts
new file mode 100644
index 000000000..5eda4d3b2
--- /dev/null
+++ b/packages/app/src/components/gpu-power/stored-gpu-stats.ts
@@ -0,0 +1,30 @@
+import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import type { GpuMetricKey, GpuStats } from './types';
+
+const STORED_METRIC: Record<GpuMetricKey, string> = {
+  power: 'power_w',
+  temperature: 'temperature_c',
+  smClock: 'sm_clock_mhz',
+  memClock: 'mem_clock_mhz',
+  gpuUtil: 'gpu_util_pct',
+  memUtil: 'mem_util_pct',
+  edgeTemp: 'edge_temp_c',
+  memTemp: 'mem_temp_c',
+  gfxVoltage: 'gfx_voltage_mv',
+  socVoltage: 'soc_voltage_mv',
+  memVoltage: 'mem_voltage_mv',
+  fclk: 'fclk_mhz',
+  socClk: 'socclk_mhz',
+  mmActivity: 'mm_activity_pct',
+};
+
+/** Full-record statistics, including startup/warmup; never a measured-window summary. */
+export function storedGpuStatsForMetric(
+  stats: readonly GpuMetricStatRow[],
+  metricKey: GpuMetricKey,
+): GpuStats[] {
+  return stats
+    .filter((row) => row.metric === STORED_METRIC[metricKey])
+    .map(({ metric: _metric, ...row }) => row);
+}
diff --git a/packages/app/src/components/gpu-power/stored-power-series.ts b/packages/app/src/components/gpu-power/stored-power-series.ts
new file mode 100644
index 000000000..964d44812
--- /dev/null
+++ b/packages/app/src/components/gpu-power/stored-power-series.ts
@@ -0,0 +1,168 @@
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import {
+  cutPowerAuditSamples,
+  cutPowerAuditCsvs,
+  type PowerAuditDevice,
+  type PowerAuditSample,
+} from './power-audit-bundle';
+import { bucketPowerFiles, type GpuPowerSeries } from './power-series';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export class StoredTelemetryIncompleteError extends Error {
+  readonly artifact: string;
+
+  constructor(artifact: string, reason: string) {
+    super(`${artifact}: ${reason}. Re-ingest this artifact for the same run and attempt.`);
+    this.name = 'StoredTelemetryIncompleteError';
+    this.artifact = artifact;
+  }
+}
+
+/** Compare storage against the original parsed artifact, not only surviving host rows. */
+function checkSeriesInventory(artifact: string, series: readonly GpuMetricSeries[]): void {
+  for (const entry of series) {
+    const inventory = entry.sidecars.seriesInventory;
+    if (!Array.isArray(inventory)) continue;
+    for (const expected of inventory) {
+      if (
+        !isRecord(expected) ||
+        typeof expected.fileName !== 'string' ||
+        typeof expected.sampleCount !== 'number'
+      )
+        continue;
+      const actual = series.find((candidate) => candidate.fileName === expected.fileName);
+      if (!actual || actual.data.length !== expected.sampleCount) {
+        throw new StoredTelemetryIncompleteError(
+          artifact,
+          `stored file/sample coverage is incomplete for ${expected.fileName}`,
+        );
+      }
+    }
+  }
+}
+
+/** Reconstruct only source/window evidence retained by the pre-validation ingest. */
+function storedValidations(series: readonly GpuMetricSeries[]) {
+  const validations = new Map<string, Record<string, unknown>>();
+  for (const entry of series) {
+    if (!isRecord(entry.sidecars.validations)) continue;
+    for (const [name, validation] of Object.entries(entry.sidecars.validations)) {
+      if (/^power_validation_[^/]+\.json$/u.test(name) && isRecord(validation)) {
+        validations.set(name, validation);
+      }
+    }
+  }
+  // New ingests carry the complete original documents, including role overrides.
+  // The legacy path has source + the selected serving window and manifest roles.
+  if (validations.size > 0) return validations;
+  for (const entry of series) {
+    for (const audit of entry.powerAudits ?? []) {
+      const { source, window_start_unix: start, window_end_unix: end } = audit;
+      if (
+        typeof source !== 'string' ||
+        typeof start !== 'number' ||
+        typeof end !== 'number' ||
+        !Number.isFinite(start) ||
+        !Number.isFinite(end) ||
+        end < start
+      )
+        continue;
+      const name = source.slice(source.lastIndexOf('/') + 1);
+      if (!/^power_validation_[^/]+\.json$/u.test(name)) continue;
+      validations.set(name, { selected_window: { start_time_unix: start, end_time_unix: end } });
+    }
+  }
+  return validations;
+}
+
+function storedBundle(artifact: string, series: readonly GpuMetricSeries[]): GpuPowerSeries[] {
+  const validations = storedValidations(series);
+  if (validations.size === 0)
+    throw new StoredTelemetryIncompleteError(artifact, 'validation window provenance is missing');
+  const smiFiles = series.filter((entry) => /(?:^|\/)gpu_metrics[^/]*\.csv$/u.test(entry.fileName));
+  if (smiFiles.length > 0) {
+    const manifest = smiFiles.find((entry) => isRecord(entry.sidecars.powerManifest))?.sidecars
+      .powerManifest;
+    return cutPowerAuditCsvs(
+      artifact,
+      smiFiles.map((entry) => ({ name: entry.fileName, data: entry.data })),
+      validations,
+      isRecord(manifest) ? manifest : null,
+    );
+  }
+  const devices = new Map<string, PowerAuditDevice>();
+  const samples: PowerAuditSample[] = [];
+  for (const entry of series) {
+    const identity = entry.sidecars.identity;
+    if (!Array.isArray(identity)) continue;
+    const ids = new Map<number, string>();
+    for (const item of identity) {
+      if (!isRecord(item)) continue;
+      const { hostname, gpu_index: gpuIndex, gpu_uuid: uuid } = item;
+      if (typeof hostname !== 'string' || typeof gpuIndex !== 'number' || typeof uuid !== 'string')
+        continue;
+      const id = `${hostname}/${uuid}`;
+      ids.set(gpuIndex, id);
+      devices.set(id, { id, hostname, gpuIndex });
+    }
+    for (const row of entry.data) {
+      const deviceId = ids.get(row.index);
+      if (!deviceId)
+        throw new StoredTelemetryIncompleteError(
+          artifact,
+          `device identity is missing for ${entry.fileName} GPU ${row.index}`,
+        );
+      samples.push({ deviceId, time: Date.parse(row.timestamp) / 1000, power: row.power });
+    }
+  }
+  const manifest = series.find((entry) => isRecord(entry.sidecars.context))?.sidecars.context;
+  const expectedDevices = isRecord(manifest) ? manifest.expected_devices : null;
+  if (Array.isArray(expectedDevices)) {
+    const slots = new Set(
+      [...devices.values()].map((device) => `${device.hostname}#${device.gpuIndex}`),
+    );
+    for (const expected of expectedDevices) {
+      if (
+        isRecord(expected) &&
+        typeof expected.hostname === 'string' &&
+        typeof expected.gpu_index === 'number' &&
+        !slots.has(`${expected.hostname}#${expected.gpu_index}`)
+      ) {
+        throw new StoredTelemetryIncompleteError(
+          artifact,
+          `expected device ${expected.hostname} GPU ${expected.gpu_index} is not stored`,
+        );
+      }
+    }
+  }
+  return cutPowerAuditSamples(
+    artifact,
+    samples,
+    devices,
+    validations,
+    isRecord(manifest) ? manifest : null,
+  );
+}
+
+/** Apply the artifact path's existing cuts and one-second means to persisted rows. */
+export function storedPowerSeries(series: readonly GpuMetricSeries[]): GpuPowerSeries[] {
+  const groups = new Map<string, GpuMetricSeries[]>();
+  for (const entry of series) {
+    const group = groups.get(entry.artifactName) ?? [];
+    group.push(entry);
+    groups.set(entry.artifactName, group);
+  }
+  return [...groups].flatMap(([artifact, entries]) => {
+    checkSeriesInventory(artifact, entries);
+    if (artifact.startsWith('power_audit_')) return storedBundle(artifact, entries);
+    const bucketed = bucketPowerFiles(
+      artifact,
+      entries.map((entry) => ({ name: entry.fileName, data: entry.data })),
+    );
+    return bucketed ? [bucketed] : [];
+  });
+}
diff --git a/packages/app/src/hooks/api/benchmark-id-query.ts b/packages/app/src/hooks/api/benchmark-id-query.ts
index d1540f1d8..0f9adf95b 100644
--- a/packages/app/src/hooks/api/benchmark-id-query.ts
+++ b/packages/app/src/hooks/api/benchmark-id-query.ts
@@ -49,6 +49,7 @@ export function useByIdQuery<T, TSelected = T>(
   id: number | null,
   enabled: boolean,
   select?: (data: T) => TSelected,
+  freshness?: { staleTime: number; refetchOnWindowFocus: boolean },
 ) {
   const selectNullable = useCallback(
     (data: T | null): TSelected | null =>
@@ -67,6 +68,7 @@ export function useByIdQuery<T, TSelected = T>(
     },
     enabled,
     staleTime: STALE_TIME_MS,
+    ...freshness,
     // TanStack Query re-runs select when its function identity changes. Keep
     // this wrapper stable so decoding a large compact payload happens only
     // when the cached wire data or the caller's selector actually changes.
diff --git a/packages/app/src/hooks/api/use-gpu-metrics-point.ts b/packages/app/src/hooks/api/use-gpu-metrics-point.ts
new file mode 100644
index 000000000..53ae1dbe8
--- /dev/null
+++ b/packages/app/src/hooks/api/use-gpu-metrics-point.ts
@@ -0,0 +1,24 @@
+import type {
+  GpuMetricsPointPayload,
+  GpuMetricSeries,
+  GpuMetricStatRow,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import { useByIdQuery } from './benchmark-id-query';
+
+export type { GpuMetricsPointPayload, GpuMetricSeries, GpuMetricStatRow };
+
+/**
+ * Lazy-fetch the PowerX telemetry linked to one benchmark point. Enabled only
+ * while the PowerX detail view is open: a series is one 1 s sample per GPU for
+ * the whole job (hundreds of KB), so it is not paid for on every page load.
+ */
+export function useGpuMetricsPoint(id: number | null, enabled = false) {
+  return useByIdQuery<GpuMetricsPointPayload>(
+    'gpu-metrics-point',
+    id,
+    enabled && Boolean(id),
+    undefined,
+    { staleTime: 0, refetchOnWindowFocus: true },
+  );
+}
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 2f8a5ceb3..70c72a16b 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -115,7 +115,7 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'published-read',
     operationId: 'get-gpu-metrics-view',
-    sourceSha256: '34860f3f64e4070bf4c0bf390c3b61f34bdb98b673a90d119bae162226dc1edd',
+    sourceSha256: '9513c85ee406f390f73c15757ea30ad9d902b2ec0e39dde25a0e305def2ff7a2',
   },
   {
     source: 'src/app/api/v1/views/gpu-specs/route.ts',
@@ -275,10 +275,21 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'ui-artifact-read',
     exclusionReason: {
-      en: 'UI-only live GPU metric artifact lookup; its run artifact shape is not a stable public contract.',
-      zh: '仅供界面读取实时 GPU 指标制品；其运行制品结构不是稳定的公开契约。',
+      en: 'UI-only PowerX raw/series=power read: DB-first with artifact fallback, separate host/GPU identities and adjacent CSV context timezone normalization. GET has no expected identities and reports sourceCoverage unknown. Healthy stored windows survive fallback; known-incomplete CSVs require retained file/sample inventory and known-incomplete bundles require re-ingest. DB failures return 503 DATABASE_UNAVAILABLE; unresolved stored gaps return 503 STORED_TELEMETRY_INCOMPLETE. Responses use no-store. This is not a stable public API.',
+      zh: '仅供 PowerX 界面读取原始遥测或 series=power：优先 DB，缺失时回退产物，保留主机/GPU 身份，并按相邻 CSV context 规范化时区。GET 没有预期身份清单，sourceCoverage 为 unknown。回退保留健康存储窗口；已知不完整 CSV 须满足文件/样本清单，已知不完整 bundle 须重新 ingest。数据库故障返回 503 DATABASE_UNAVAILABLE，未恢复的存储缺口返回 503 STORED_TELEMETRY_INCOMPLETE。响应使用 no-store，不作为稳定公开 API。',
     },
-    sourceSha256: '28e6cee4d67396ee8ea2e5a7e18271c6ee86228c33f33a20bf573f3a601ba8ed',
+    sourceSha256: '80fd8ea1d462b2d47d42411d8361db72802943a94c7ffb91879244c69ef2c693',
+  },
+  {
+    source: 'src/app/api/gpu-metrics/route.ts',
+    path: '/api/gpu-metrics',
+    method: 'POST',
+    classification: 'ui-artifact-read',
+    exclusionReason: {
+      en: 'Read-only Timeline transport with runId, series=power and optional prefix in the query; JSON sources contains 1–1000 validation basenames with RESULT_FILENAME up to 200 ASCII letters/digits/dot/underscore/hyphen, matching prefix. Invalid input returns 400; bodies over 256 KiB return 413. Fully covered DB reads skip GitHub; missing identities fall back and merge by validation source, preserving stored sibling windows. Offline GitHub preserves healthy DB series with incomplete sourceCoverage. Coverage describes only requested identities, never whole-run/sample completeness. The GET no-store/error/inventory guarantees also apply. UI-owned, excluded from the stable public API.',
+      zh: 'Timeline 只读传输：查询参数为 runId、series=power 和可选 prefix；JSON sources 含 1–1000 个验证文件 basename，RESULT_FILENAME 最长 200 个 ASCII 字母/数字/点/下划线/连字符，且须匹配 prefix。输入错误返回 400，正文超过 256 KiB 返回 413。DB 已覆盖请求时跳过 GitHub，否则按缺失身份回退，以 validation source 为键合并，并保留已存储的同 bundle 兄弟窗口。GitHub 离线仍返回健康 DB 序列，sourceCoverage 标记 incomplete。覆盖仅针对请求身份，不代表整次 run 或样本完整性。沿用 GET 的 no-store、错误和清单约束；属于界面接口，不纳入稳定公开 API。',
+    },
+    sourceSha256: '80fd8ea1d462b2d47d42411d8361db72802943a94c7ffb91879244c69ef2c693',
   },
   {
     source: 'src/app/api/openapi.json/route.ts',
@@ -534,6 +545,17 @@ export const apiRouteCatalog = [
     operationId: 'list-reliability',
     sourceSha256: 'ce1c5db78b47548beb77a69797f10fb33853cde01cea5c44675c8ad3519bcf20',
   },
+  {
+    source: 'src/app/api/v1/gpu-metrics-point/route.ts',
+    path: '/api/v1/gpu-metrics-point',
+    method: 'GET',
+    classification: 'page-bff',
+    exclusionReason: {
+      en: 'Point-detail BFF returning linked PowerX telemetry series, per-GPU digests and retained validation/audit metadata. Every read checks a live DB revision before using the Blob payload cache; responses use no-store, missing data returns 404, and database failures remain errors. Re-ingest, shared-link and digest algorithm/stored-version changes do not require manual cache purges. Outdated digests are recomputed read-only from retained samples. Coupled to the PowerX tab implementation.',
+      zh: '数据点详情页专用 BFF；返回关联的 PowerX 遥测序列、每 GPU 统计摘要及保留的验证与审计元数据。每次读取先核对数据库版本再使用 Blob 缓存；响应使用 no-store，数据缺失返回 404，数据库故障仍作为错误返回。重新入库、共享链接及摘要算法或存储版本变化无需手动清理缓存；旧摘要从保留样本只读重算。与 PowerX 标签页实现紧密耦合。',
+    },
+    sourceSha256: 'c04a01fcd8e1cb4cb7101a46a0ba44b227f2696819c499bcc93be8ee7a8ce255',
+  },
   {
     source: 'src/app/api/v1/request-chart-data/route.ts',
     path: '/api/v1/request-chart-data',
@@ -821,6 +843,38 @@ export interface ApiContractSourceDigest {
  * touching a route module. Digest changes require an explicit documentation review.
  */
 export const apiContractSourceDigests = [
+  {
+    source: '../db/src/etl/power-audit-validations.ts',
+    sourceSha256: '44a607747b79d038bb8f4e53590efba689d376c143f50a5d750d3552faa0c442',
+    reviewArea: {
+      en: 'Shared legacy and nested AgentX validation identity normalization for artifact and stored Timeline windows.',
+      zh: '产物与数据库 Timeline 窗口共用的 legacy 和嵌套 AgentX validation 身份规范化。',
+    },
+  },
+  {
+    source: 'src/components/gpu-power/power-audit-bundle.ts',
+    sourceSha256: '96aa2ed60692116d5b5219b90b562fdc8143b63359bd917bbc91812ffaf274a8',
+    reviewArea: {
+      en: 'Artifact Timeline validation windows, strict nested AgentX result identity, adjacent context selection, timezone normalization and device identity semantics.',
+      zh: '产物 Timeline 验证窗口、严格匹配的嵌套 AgentX result 身份、相邻 context 选择、时区规范化及设备身份语义。',
+    },
+  },
+  {
+    source: 'src/components/gpu-power/stored-gpu-stats.ts',
+    sourceSha256: '77e9f6ad6eef5f3c30899a9a24d04b0d85b64b0293bea9c38964a9680a55e289',
+    reviewArea: {
+      en: 'Stored full-record GPU metric mappings, authoritative missing digests, and UI/API statistics parity.',
+      zh: '已存全记录 GPU 指标映射、缺失摘要语义，以及界面和 API 的统计一致性。',
+    },
+  },
+  {
+    source: 'src/components/gpu-power/types.ts',
+    sourceSha256: 'e8c5460821f5d8228bcf8b7dd087abe14e29a8e220e1d8bcd75112fb5ead1baa',
+    reviewArea: {
+      en: 'GPU telemetry units, missing values, timestamp deduplication, and full-record live statistics definitions.',
+      zh: 'GPU 遥测单位、缺失值、时间戳去重，以及实时产物全记录统计的定义。',
+    },
+  },
   {
     source: 'src/lib/views-api/upstream-error.ts',
     sourceSha256: 'c3f1b4c318e1ae771a67edd85f16d69b7316461334604fd8c892254eface715a',
@@ -841,7 +895,7 @@ export const apiContractSourceDigests = [
 
   {
     source: 'src/components/gpu-power/chart-data.ts',
-    sourceSha256: '34bdab18810a5e6688d150b71c4c1b22d383a63775672c0c915549b841c48475',
+    sourceSha256: '3e4bed7d693f146c97ac52cc0bb64d854a9dee2a1fa8d5dbf534ac4e1e78fa3f',
     reviewArea: {
       en: 'Dashboard read-only selector and calculation parity.',
       zh: '仪表板只读接口的选择项与计算一致性。',
diff --git a/packages/app/src/lib/github-artifacts.test.ts b/packages/app/src/lib/github-artifacts.test.ts
index 4a80ae8a4..622f851a6 100644
--- a/packages/app/src/lib/github-artifacts.test.ts
+++ b/packages/app/src/lib/github-artifacts.test.ts
@@ -123,6 +123,7 @@ describe('extractZipEntries', () => {
   it('skips non-matching files and continues after parse errors', () => {
     const zip = new AdmZip();
     zip.addFile('good.json', Buffer.from('{"id":1}', 'utf8'));
+    zip.addFile('upper.JSON', Buffer.from('{"id":2}', 'utf8'));
     zip.addFile('bad.json', Buffer.from('not json', 'utf8'));
     zip.addFile('notes.txt', Buffer.from('ignore me', 'utf8'));
 
@@ -136,7 +137,10 @@ describe('extractZipEntries', () => {
       },
     );
 
-    expect(rows).toEqual([{ entryName: 'good.json', payload: { id: 1 } }]);
+    expect(rows).toEqual([
+      { entryName: 'good.json', payload: { id: 1 } },
+      { entryName: 'upper.JSON', payload: { id: 2 } },
+    ]);
     expect(parseErrors).toEqual(['bad.json']);
   });
 });
diff --git a/packages/app/src/lib/github-artifacts.ts b/packages/app/src/lib/github-artifacts.ts
index 3fe278903..d29162741 100644
--- a/packages/app/src/lib/github-artifacts.ts
+++ b/packages/app/src/lib/github-artifacts.ts
@@ -120,6 +120,24 @@ export function downloadGithubArtifact(url: string, token: string): Promise<Resp
   });
 }
 
+/**
+ * Decodes only the entries `predicate` selects, keyed by entry name. The rest
+ * of the archive stays compressed, so picking a few small files out of a
+ * multi-hundred-megabyte bundle costs the central directory, not the payload.
+ */
+export function readZipEntries(
+  buffer: Buffer,
+  predicate: (entryName: string) => boolean,
+): Map<string, string> {
+  const zip = new AdmZip(buffer);
+  const files = new Map<string, string>();
+  for (const entry of zip.getEntries()) {
+    if (entry.isDirectory || !predicate(entry.entryName)) continue;
+    files.set(entry.entryName, entry.getData().toString('utf8'));
+  }
+  return files;
+}
+
 export function extractZipEntries<T>(
   buffer: Buffer,
   extension: string,
@@ -131,7 +149,7 @@ export function extractZipEntries<T>(
   const rows: T[] = [];
 
   for (const entry of zip.getEntries()) {
-    if (!entry.entryName.endsWith(extension)) {
+    if (!entry.entryName.toLowerCase().endsWith(extension.toLowerCase())) {
       continue;
     }
 
diff --git a/packages/app/src/lib/views-api/docs/extensions.ts b/packages/app/src/lib/views-api/docs/extensions.ts
index dc35e0676..150861156 100644
--- a/packages/app/src/lib/views-api/docs/extensions.ts
+++ b/packages/app/src/lib/views-api/docs/extensions.ts
@@ -22,8 +22,8 @@ const PARAMETER_NOTES: Record<string, [string, string]> = {
     '快照截止日期，格式为 YYYY-MM-DD。指定 runId 时改为读取该次运行的逻辑快照。',
   ],
   runId: [
-    'Positive safe integer workflow run ID. Omit to select the default run; required for live GPU metrics.',
-    '正安全整数格式的工作流运行 ID。不填时选择默认运行；实时 GPU 指标必须填写。',
+    'Positive safe integer workflow run ID. Omit to select the default run; required for GPU metrics.',
+    '正安全整数格式的工作流运行 ID。不填时选择默认运行；GPU 指标必须填写。',
   ],
   precisions: [
     'Comma-separated precision keys; omitted selection uses available curve density. Calculator extensions auto-select the densest official precision and include precisions present in unofficial-run overlays.',
@@ -381,9 +381,19 @@ const NEW_VIEWS = {
     { rows: objects, options: object },
   ],
   'gpu-metrics': [
-    'Live GPU metrics and statistics',
-    '实时 GPU 指标与统计',
-    { runInfo: object, artifacts: strings, rows: objects, stats: objects, rendering: object },
+    'GPU telemetry and full-record statistics',
+    'GPU 遥测与全记录统计',
+    {
+      runInfo: object,
+      artifacts: strings,
+      rows: objects,
+      stats: {
+        ...objects,
+        description:
+          'Per-GPU statistics for the selected file/host series, including startup and warmup. Current-version stored digests are authoritative, including an empty or missing metric digest. Outdated or unversioned digests are recomputed read-only from retained DB samples using the current full-record algorithm. Count is the finite-reading count after first-wins timestamp/GPU deduplication. Mean is sample-weighted, P50/P95/P99 use linear interpolation at p*(N-1), and standard deviation divides by N. Values use the selected metric unit; the storage-only metric column is omitted. GPU visibility and chart downsampling do not change this population. These are not serving-window power or J/token.',
+      },
+      rendering: object,
+    },
   ],
   video: [
     'Published video evidence and tradeoffs',
@@ -412,14 +422,14 @@ export const operations: ApiOperation[] = Object.entries(NEW_VIEWS).map(
           view === 'video'
             ? ' Only already published artifacts are read. Cell, phase, slot and GPU-basis choices select result evidence and normalized serving rates; x/y/cost/workload filters produce computed tradeoff points. Local bundles and arbitrary URLs are excluded. Responses are no-store.'
             : view === 'gpu-metrics'
-              ? ' Live artifact reads are no-store; statistics use all chips and unsampled values, while chart rows respect selected GPU indices.'
+              ? ' Telemetry reads stored DB series first and falls back to GitHub artifacts when storage is absent. Responses use private, no-store; an upstream database failure remains HTTP 503 rather than an empty dataset. File/host series retain separate identities. Full-record statistics include startup and warmup and use current-version stored per-GPU digests; a current empty or missing metric digest stays empty. Outdated or unversioned digests are recomputed read-only from retained DB samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. Statistics expose the selected metric values without the storage-only metric column. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings.'
               : ''
         }`,
         `只读${zh}，使用仪表板的数据读取和计算函数。未知或重复查询键返回 400；响应包含解析后的参数，保留缺失数据。仅影响样式的控件不作为 API 参数。${
           view === 'video'
             ? ' 仅读取已发布产物。cell、阶段、slot 和 GPU 口径选择对应结果证据，并计算 serving 归一化速率；x/y、成本及工作负载筛选生成权衡图数据点。不读取本地数据包或任意 URL。响应不缓存。'
             : view === 'gpu-metrics'
-              ? ' 实时产物读取不缓存；统计量使用所有芯片的未降采样值，图表行则按芯片索引筛选。'
+              ? ' 遥测优先读取数据库中已存储的序列；缺少存储数据时回退到 GitHub 产物。响应使用 private, no-store；上游数据库故障保留 HTTP 503，不作为空数据返回。各文件、主机的序列身份独立保留。全记录统计包含服务启动与 warmup，已有数据使用当前算法版本的每 GPU 统计摘要；当前摘要为空或缺少所选指标时仍返回空统计数组。旧版本或无版本摘要从保留的 DB 样本只读重算。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。统计项只包含所选指标的数值，不返回数据库内部的 metric 字段。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。'
               : ''
         }`,
       ),
diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index b9389a7d7..690397040 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -8,7 +8,7 @@
     "references/cli-contract.md": "fa44faa38d889b4fbdee5ba42752b47758ee3706fab150513bd4e6db87a86cb0",
     "references/cli.md": "96b228f34cb3600f4548f4dc84df8506531747286763c56ca834c77bee05e1eb",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "57d78ece6595c3b8a28bf09722a633b3fe8e9e1322046534856d1f34e30ee805",
+    "references/dashboard-views.md": "339ebf9e7b33e4d586c852452a42a8ccf020e7edc0427f434d51cd092e69486e",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/pareto.md": "1b4d2d163f982e3f2d97addce310789eae9c1e5badd82dd7501708c9e0385027",
     "references/powerx.md": "cf8adcc5dfe395c5fb659908819980a872475f862f22b723815af43d363cedad",
diff --git a/packages/skills/skills/inferencex-api/references/dashboard-views.md b/packages/skills/skills/inferencex-api/references/dashboard-views.md
index 6f97cf3c5..81f123044 100644
--- a/packages/skills/skills/inferencex-api/references/dashboard-views.md
+++ b/packages/skills/skills/inferencex-api/references/dashboard-views.md
@@ -59,7 +59,7 @@ which controls belong together.
 | `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                               |
 | `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                    |
 | `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                 |
-| `gpu-metrics`                   | Required run, artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. Raw rows and statistics remain unsampled; live response is no-store.                                             |
+| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first telemetry; full-record statistics use stored digests. Responses are no-store.                 |
 | `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                    |
 
 ## Interpretation and maintenance
@@ -94,8 +94,15 @@ Custom chip costs are USD/chip-hour, token prices USD/million tokens,
 interactivity tok/s/user, and video costs USD/deployment-hour. Preserve the
 response's resolved TCO, utilization, license share, topology and power basis.
 Modeled and provisioned power are distinct. Missing measured evidence is not zero.
-GPU chart projections preserve the existing renderer's missing-metric zero
-fallback; use unsampled `rows` to distinguish absent optional sensor values.
+GPU chart projections omit missing metric readings; measured zero remains zero.
+The selected file/host series' full-record statistics include startup and warmup
+and cover all chips regardless of visibility or chart downsampling. Stats rows omit
+the storage-only `metric` column; `params.metric` identifies the selected metric. Current-version stored digests
+are authoritative, including empty or absent metric digests. Outdated or
+unversioned digests are recomputed read-only from retained DB samples. Keep these sample-weighted statistics separate from
+serving-window power, J/token and selected-time-window calculations. The view reads
+stored telemetry first, falls back to artifacts for missing storage, and preserves
+upstream 503 failures. Treat an error as unavailable evidence, not an empty dataset.
 
 Zoom, axis scale, theme, labels, report expansion, media playback and download
 buttons are presentation state, not new datasets. AI-chart provider keys and

From 10d99016d438d5000474baa57fdfac4e5953af79 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 069/103] feat(ui): per-point PowerX view on the agentic detail
 page
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Open a benchmark point's stored telemetry from the chart tooltip: a PowerX tab on the
agentic detail page and a dialog from the scatter/GPU charts, with per-chip toggles, a
server-metric overlay and loading/error/missing states that keep cached data on a failed
refetch.

中文：从图表 tooltip 打开 benchmark 点的入库遥测：agentic 详情页的 PowerX 标签页与散点/GPU 图的对话框，含逐芯片开关、server 指标叠加，以及刷新失败时保留缓存数据的加载/错误/缺失状态。
---
 .../cypress/component/power-telemetry.cy.tsx  | 205 ++++++++
 .../agentic-point/agentic-point-detail.tsx    |   6 +
 .../agentic-point/overlay-sources.ts          |  83 ++++
 .../agentic-point/power-telemetry-view.tsx    | 448 ++++++++++++++++++
 .../agentic-point/use-detail-view.ts          |   8 +-
 .../inference/power-telemetry-dialog.tsx      |  51 ++
 6 files changed, 799 insertions(+), 2 deletions(-)
 create mode 100644 packages/app/cypress/component/power-telemetry.cy.tsx
 create mode 100644 packages/app/src/components/inference/agentic-point/overlay-sources.ts
 create mode 100644 packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
 create mode 100644 packages/app/src/components/inference/power-telemetry-dialog.tsx

diff --git a/packages/app/cypress/component/power-telemetry.cy.tsx b/packages/app/cypress/component/power-telemetry.cy.tsx
new file mode 100644
index 000000000..332a5fde4
--- /dev/null
+++ b/packages/app/cypress/component/power-telemetry.cy.tsx
@@ -0,0 +1,205 @@
+import { QueryClient, QueryClientProvider, useQuery } from '@tanstack/react-query';
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+import { useState } from 'react';
+
+import { TelemetryDisplayControls } from '@/components/gpu-power/TelemetryDisplayControls';
+import {
+  DEFAULT_TELEMETRY_DISPLAY,
+  type TelemetryDisplayState,
+} from '@/components/gpu-power/telemetry-smoothing';
+import { PowerTelemetryView } from '@/components/inference/agentic-point/power-telemetry-view';
+import type { GpuMetricsPointPayload, GpuMetricSeries } from '@/hooks/api/use-gpu-metrics-point';
+import { registerAnalyticsClient } from '@/lib/analytics';
+
+const ID = 206887;
+const endpoint = `/api/v1/gpu-metrics-point?id=${ID}`;
+const queryKey = ['gpu-metrics-point', ID];
+const chart = '[data-testid="power-telemetry-chart"]';
+
+function series(id: number, host: string, base: number): GpuMetricSeries {
+  const data = [0, 1, 2].flatMap((second) =>
+    [0, 1].map((index) => ({
+      timestamp: `2026-09-21T00:00:0${second}Z`,
+      index,
+      power: base + index * 100 + second * 10,
+      temperature: 40 + index + second,
+    })),
+  );
+  return {
+    id,
+    artifactName: 'gpu_metrics_qwen35_b200',
+    configKey: 'qwen35_b200_tp8',
+    fileName: `${host}/gpu_metrics.csv`,
+    vendor: 'nvidia',
+    sampleIntervalS: 1,
+    sampleCount: data.length,
+    gpuCount: 2,
+    startedAt: data[0].timestamp,
+    endedAt: data.at(-1)!.timestamp,
+    sidecars: {},
+    benchmarkResultIds: [ID],
+    stats: [0, 1].map((gpuIndex) => ({
+      gpuIndex,
+      metric: 'power_w',
+      count: 3,
+      min: base + gpuIndex * 100,
+      max: base + gpuIndex * 100 + 20,
+      mean: base + gpuIndex * 100 + 10,
+      median: base + gpuIndex * 100 + 10,
+      p95: base + gpuIndex * 100 + 19,
+      p99: base + gpuIndex * 100 + 19.8,
+      stddev: Math.sqrt(200 / 3),
+    })),
+    data,
+  };
+}
+
+const payload: GpuMetricsPointPayload = {
+  benchmarkResultId: ID,
+  series: [series(1, 'host-a', 500), series(2, 'host-b', 700)],
+};
+
+function QueryStatus() {
+  const { status } = useQuery({ queryKey, enabled: false });
+  return <output data-testid="query-status">{status}</output>;
+}
+
+function mountPoint(path = '/inference/agentic/206887') {
+  const client = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 0 } } });
+  cy.mount(
+    <PathnameContext.Provider value={path}>
+      <QueryClientProvider client={client}>
+        <div className="p-4">
+          <PowerTelemetryView id={ID} enabled hardware="b200" serverMetricsEnabled={false} />
+          <QueryStatus />
+        </div>
+      </QueryClientProvider>
+    </PathnameContext.Provider>,
+  );
+  return client;
+}
+
+function Controls() {
+  const [display, setDisplay] = useState<TelemetryDisplayState>(DEFAULT_TELEMETRY_DISPLAY);
+  return (
+    <>
+      <TelemetryDisplayControls
+        value={display}
+        onChange={setDisplay}
+        analyticsPrefix="power_test"
+        idPrefix="display"
+      />
+      <output>{JSON.stringify(display)}</output>
+    </>
+  );
+}
+
+describe('PowerX telemetry interactions', () => {
+  beforeEach(() => {
+    registerAnalyticsClient({ capture: cy.stub().as('capture') });
+  });
+
+  it('changes display, window and chip aggregation independently and tracks each action', () => {
+    cy.mount(<Controls />);
+    cy.get('[data-testid="display-mode-points"]').click();
+    cy.get('#display-window').should('not.exist');
+    cy.get('[data-testid="display-series-mean"]').click();
+    cy.get('[data-testid="display-mode-rolling"]').click();
+    cy.get('#display-window').click();
+    cy.get('[role="option"]').contains('60 s').click();
+    cy.get('output').should('have.text', '{"mode":"rolling","windowS":60,"series":"mean"}');
+    cy.get('@capture').should('have.been.calledWith', 'power_test_display_mode_changed', {
+      mode: 'points',
+    });
+    cy.get('@capture').should('have.been.calledWith', 'power_test_series_mode_changed', {
+      series: 'mean',
+    });
+    cy.get('@capture').should('have.been.calledWith', 'power_test_smoothing_window_changed', {
+      windowS: 60,
+    });
+    cy.get('@capture').its('callCount').should('eq', 4);
+  });
+
+  it('shows loading, distinguishes an initial failure from missing data, and retries', () => {
+    let failed = true;
+    cy.intercept('GET', endpoint, (request) => {
+      request.reply(failed ? { statusCode: 503, delay: 150, body: {} } : { body: payload });
+    }).as('telemetry');
+    mountPoint();
+    cy.get('[data-testid="power-telemetry-loading"]').should('contain.text', 'Loading PowerX');
+    cy.wait('@telemetry');
+    cy.get('[data-testid="power-telemetry-query-error"]').should('contain.text', 'Failed to load');
+    cy.get('[data-testid="power-telemetry-missing"]').should('not.exist');
+    cy.then(() => {
+      failed = false;
+    });
+    cy.contains('button', 'Retry').click();
+    cy.wait('@telemetry');
+    cy.get(chart).find('svg .point').should('have.length', 6);
+    cy.get('@capture').should(
+      'have.been.calledWith',
+      'inference_agentic_power_telemetry_retry_clicked',
+    );
+  });
+
+  it('shows a genuine missing point without offering an error retry', () => {
+    cy.intercept('GET', endpoint, { statusCode: 404, body: {} });
+    mountPoint();
+    cy.get('[data-testid="power-telemetry-missing"]').should('contain.text', `#${ID}`);
+    cy.get('[data-testid="power-telemetry-query-error"]').should('not.exist');
+    cy.get(chart).should('not.exist');
+  });
+
+  it('preserves a rendered chart when a background refetch fails', () => {
+    let failed = false;
+    cy.intercept('GET', endpoint, (request) => {
+      request.reply(failed ? { statusCode: 503, body: {} } : { body: payload });
+    }).as('telemetry');
+    const client = mountPoint();
+    cy.wait('@telemetry');
+    cy.get(chart).find('svg .point').should('have.length', 6);
+    cy.then(() => {
+      failed = true;
+      return client.refetchQueries({ queryKey });
+    });
+    cy.wait('@telemetry');
+    cy.get('[data-testid="query-status"]').should('have.text', 'error');
+    cy.get(chart).find('svg .point').should('have.length', 6);
+    cy.get('[data-testid="power-telemetry-query-error"]').should('not.exist');
+  });
+
+  for (const [locale, width] of [
+    ['en', 1280],
+    ['zh', 390],
+  ] as const) {
+    it(`keeps chip filters scoped to a host and renders ${locale} at ${width}px`, () => {
+      cy.viewport(width, 900);
+      cy.intercept('GET', endpoint, { body: payload });
+      mountPoint(`${locale === 'zh' ? '/zh' : ''}/inference/agentic/${ID}`);
+      cy.get(chart).find('svg .point').should('have.length', 6);
+      cy.get('[data-testid="power-telemetry-sample-count"]').should('have.text', '6');
+      cy.get('table tbody tr').first().find('td').eq(4).should('have.text', '510.0');
+      cy.get('[data-testid="chart-legend"]')
+        .contains(locale === 'zh' ? '芯片 0' : 'Chip 0')
+        .click();
+      cy.get(chart).find('svg .point').should('have.length', 3);
+      cy.get('#power-telemetry-series-select').click();
+      cy.get('[role="option"]').contains('host-b').click();
+      cy.get(chart).find('svg .point').should('have.length', 6);
+      cy.get('table tbody tr').first().find('td').eq(4).should('have.text', '710.0');
+      cy.get('[data-testid="power-telemetry-display-mode-points"]').click();
+      cy.get('[data-testid="power-telemetry-display-series-mean"]').click();
+      cy.get(chart).find('svg .point').should('have.length', 3);
+      cy.get('[data-testid="power-telemetry-view"]').should(($view) => {
+        expect($view[0].scrollWidth).to.be.at.most($view[0].clientWidth + 1);
+      });
+      cy.get('[data-testid="power-telemetry-metric-select"]').should(
+        'contain.text',
+        locale === 'zh' ? '功耗' : 'Power',
+      );
+      cy.get('[data-testid="power-telemetry-view"]').screenshot(
+        `power-telemetry-${locale}-${width}`,
+      );
+    });
+  }
+});
diff --git a/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx b/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx
index 369078c40..f53d51dce 100644
--- a/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx
+++ b/packages/app/src/components/inference/agentic-point/agentic-point-detail.tsx
@@ -33,6 +33,7 @@ import {
   type StagePhase,
 } from './phase-slice';
 import { PointSummary } from './point-summary';
+import { PowerTelemetryView } from './power-telemetry-view';
 import { RequestMetricOverTime, SequenceMetricCard } from './request-metric-cards';
 import { ServerLogViewer } from './server-log-viewer';
 import {
@@ -61,6 +62,7 @@ export const AGENTIC_POINT_DETAIL_STRINGS = {
     ttftOverTime: 'TTFT over time',
     perPoint: 'Per-point',
     requestTimeline: 'Request timeline',
+    powerX: 'PowerX',
     aggregatesAcrossConfigs: 'Aggregates across configs',
     logs: 'Logs',
     detailView: 'Detail view',
@@ -94,6 +96,7 @@ export const AGENTIC_POINT_DETAIL_STRINGS = {
     ttftOverTime: 'TTFT 随时间变化',
     perPoint: '单点',
     requestTimeline: '请求时间线',
+    powerX: 'PowerX',
     aggregatesAcrossConfigs: '跨配置聚合',
     logs: '日志',
     detailView: '详情视图',
@@ -149,6 +152,7 @@ export function AgenticPointDetail({ id }: Props) {
     () => [
       { value: 'point', label: t.perPoint, testId: 'detail-view-point' },
       { value: 'timeline', label: t.requestTimeline, testId: 'detail-view-timeline' },
+      { value: 'power', label: t.powerX, testId: 'detail-view-power' },
       { value: 'aggregates', label: t.aggregatesAcrossConfigs, testId: 'detail-view-aggregates' },
       { value: 'logs', label: t.logs, testId: 'detail-view-logs' },
     ],
@@ -347,6 +351,8 @@ export function AgenticPointDetail({ id }: Props) {
 
       {view === 'logs' ? (
         <ServerLogViewer id={id} enabled />
+      ) : view === 'power' ? (
+        <PowerTelemetryView id={id} enabled hardware={siblingsData?.sku.hardware} />
       ) : view === 'aggregates' ? (
         aggregatesQuery.isError ? (
           <RetryableQueryError
diff --git a/packages/app/src/components/inference/agentic-point/overlay-sources.ts b/packages/app/src/components/inference/agentic-point/overlay-sources.ts
new file mode 100644
index 000000000..029274f25
--- /dev/null
+++ b/packages/app/src/components/inference/agentic-point/overlay-sources.ts
@@ -0,0 +1,83 @@
+import type { TraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
+import type { Locale } from '@/lib/i18n';
+
+/** One server-metric series that can be drawn over the chip telemetry chart. */
+export interface OverlaySource {
+  key: string;
+  label: { en: string; zh: string };
+  unit: string;
+  color: string;
+  /** Seconds-from-trace-start samples, already in display units. */
+  points: (metrics: TraceServerMetrics) => { t: number; value: number }[];
+}
+
+const percent = (points: readonly { t: number; value: number }[]) =>
+  points.map((p) => ({ t: p.t, value: p.value * 100 }));
+
+/**
+ * Menu of overlay candidates, in display order. Only sources whose series is
+ * non-empty for the point are offered (see `availableOverlaySources`).
+ */
+export const OVERLAY_SOURCES: readonly OverlaySource[] = [
+  {
+    key: 'decodeTps',
+    label: { en: 'Decode throughput', zh: 'Decode 吞吐量' },
+    unit: 'tok/s',
+    color: '#8b5cf6',
+    points: (m) => m.decodeTps,
+  },
+  {
+    key: 'prefillTps',
+    label: { en: 'Prefill throughput', zh: 'Prefill 吞吐量' },
+    unit: 'tok/s',
+    color: '#06b6d4',
+    points: (m) => m.prefillTps,
+  },
+  {
+    key: 'kvCacheUsage',
+    label: { en: 'KV cache utilization', zh: 'KV cache 利用率' },
+    unit: '%',
+    color: '#f59e0b',
+    points: (m) => percent(m.kvCacheUsage),
+  },
+  {
+    key: 'hostKvCacheUsage',
+    label: { en: 'Host KV cache utilization', zh: '主机 KV cache 利用率' },
+    unit: '%',
+    color: '#d97706',
+    points: (m) => percent(m.hostKvCacheUsage),
+  },
+  {
+    key: 'prefixCacheHitRate',
+    label: { en: 'Prefix cache hit rate', zh: 'Prefix cache 命中率' },
+    unit: '%',
+    color: '#10b981',
+    points: (m) => percent(m.prefixCacheHitRate),
+  },
+  {
+    key: 'prefixCacheHitsTps',
+    label: { en: 'Prefix cache hits', zh: 'Prefix cache 命中量' },
+    unit: 'tok/s',
+    color: '#14b8a6',
+    points: (m) => m.prefixCacheHitsTps,
+  },
+  {
+    key: 'queueDepth',
+    label: { en: 'Queue depth (running + waiting)', zh: '队列深度（运行中 + 等待中）' },
+    unit: 'req',
+    color: '#ec4899',
+    points: (m) => m.queueDepth.map((p) => ({ t: p.t, value: p.total })),
+  },
+];
+
+/** Sources that have at least one sample for this point, in menu order. */
+export function availableOverlaySources(
+  metrics: TraceServerMetrics | null | undefined,
+): OverlaySource[] {
+  if (!metrics) return [];
+  return OVERLAY_SOURCES.filter((source) => source.points(metrics).length > 0);
+}
+
+export function overlaySourceLabel(source: OverlaySource, locale: Locale): string {
+  return source.label[locale];
+}
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
new file mode 100644
index 000000000..7d56ef9a2
--- /dev/null
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -0,0 +1,448 @@
+'use client';
+
+import { useMemo, useState } from 'react';
+
+import GpuMetricsChart, {
+  GPU_COLORS,
+  type TelemetryOverlaySeries,
+} from '@/components/gpu-power/GpuPowerChart';
+import GpuStatsTable from '@/components/gpu-power/GpuStatsTable';
+import { TelemetryDisplayControls } from '@/components/gpu-power/TelemetryDisplayControls';
+import {
+  DEFAULT_TELEMETRY_DISPLAY,
+  toAbsoluteMs,
+  type TelemetryDisplayState,
+} from '@/components/gpu-power/telemetry-smoothing';
+import {
+  type GpuMetricKey,
+  type GpuMetricRow,
+  ALL_METRIC_OPTIONS,
+  getAvailableMetrics,
+  getGpuMetricLabel,
+} from '@/components/gpu-power/types';
+import { Card } from '@/components/ui/card';
+import ChartLegend from '@/components/ui/chart-legend';
+import { Label } from '@/components/ui/label';
+import { RetryableQueryError } from '@/components/ui/retryable-query-error';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import { useGpuMetricsPoint, type GpuMetricSeries } from '@/hooks/api/use-gpu-metrics-point';
+import { useTraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
+
+import { availableOverlaySources, overlaySourceLabel } from './overlay-sources';
+import { track } from '@/lib/analytics';
+import { useLocale } from '@/lib/use-locale';
+
+const STRINGS = {
+  en: {
+    loading: 'Loading PowerX telemetry…',
+    error: 'Failed to load PowerX telemetry.',
+    missing:
+      'No PowerX telemetry is stored for benchmark point #{id}. Telemetry may not have been collected or ingested.',
+    series: 'Telemetry series',
+    metric: 'Metric',
+    vendor: 'Collector',
+    samples: 'Samples',
+    chips: 'Chips',
+    interval: 'Sample interval',
+    window: 'Recorded window',
+    sharedNote:
+      'This series covers the whole benchmark job, including server start-up and warm-up, so summary rows below span more than the measured serving window.',
+    perGpuStats: 'Per-chip statistics',
+    chip: 'Chip',
+    secondsUnit: 's',
+    resetFilter: 'Show all chips',
+    overlayToggle: 'Overlay server metric',
+    overlayNone: 'None',
+    overlayLoading: 'Loading server metrics…',
+    overlayError: 'Server metrics failed to load; overlays are unavailable.',
+    overlayUnavailable: 'This point has no server-metric series to overlay.',
+    overlayAligned: 'The overlay is aligned to the telemetry by wall-clock timestamps.',
+    overlayRelative:
+      'The trace has no wall-clock timestamps, so the overlay and the telemetry are both aligned at their own t=0.',
+  },
+  zh: {
+    loading: '正在加载 PowerX 遥测数据……',
+    error: 'PowerX 遥测数据加载失败。',
+    missing: '基准测试数据点 #{id} 没有存储的 PowerX 遥测数据。遥测数据可能尚未采集或入库。',
+    series: '遥测序列',
+    metric: '指标',
+    vendor: '采集器',
+    samples: '样本数',
+    chips: '芯片数',
+    interval: '采样间隔',
+    window: '记录时间窗口',
+    sharedNote:
+      '该序列覆盖整个基准测试任务，包括服务启动与 warmup 阶段，因此下方统计范围大于实际测量的服务窗口。',
+    perGpuStats: '单芯片统计信息',
+    chip: '芯片',
+    secondsUnit: '秒',
+    resetFilter: '显示全部芯片',
+    overlayToggle: '叠加服务端指标',
+    overlayNone: '无',
+    overlayLoading: '正在加载服务端指标……',
+    overlayError: '服务端指标加载失败，无法叠加显示。',
+    overlayUnavailable: '该数据点没有可叠加的服务端指标序列。',
+    overlayAligned: '叠加曲线已按绝对时间戳与遥测数据对齐。',
+    overlayRelative: 'trace 缺少绝对时间戳，因此叠加曲线与遥测数据均从各自的 t=0 开始对齐。',
+  },
+} as const;
+
+const VENDOR_LABEL: Record<string, string> = { nvidia: 'nvidia-smi', amd: 'amd-smi' };
+
+/**
+ * Single-node CSVs come from the vendor CLI; multinode power bundles record
+ * their own producer (e.g. `srt-slurm.dcgm-power`) in the context sidecar.
+ */
+export function collectorLabel(series: Pick<GpuMetricSeries, 'vendor' | 'sidecars'>): string {
+  const context = series.sidecars?.context;
+  const producer =
+    context && typeof context === 'object' ? (context as { producer?: unknown }).producer : null;
+  if (typeof producer === 'string' && producer.trim() !== '') return producer;
+  return VENDOR_LABEL[series.vendor] ?? series.vendor;
+}
+
+interface Props {
+  id: number;
+  enabled: boolean;
+  /** The point's hardware key, for the TDP reference line. */
+  hardware?: string;
+  /** Fixed-sequence points do not have AgentX server-metric overlays. */
+  serverMetricsEnabled?: boolean;
+}
+
+function seriesLabel(series: GpuMetricSeries, total: number): string {
+  return total > 1 ? `${series.artifactName} · ${series.fileName}` : series.artifactName;
+}
+
+/**
+ * PowerX tab of the per-point detail page: the full-resolution chip telemetry
+ * recorded while this benchmark point ran, read from the ingest-time digest
+ * (migration 016) rather than from GitHub artifacts.
+ */
+export function PowerTelemetryView({ id, enabled, hardware, serverMetricsEnabled = true }: Props) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const query = useGpuMetricsPoint(id, enabled);
+  const seriesList = query.data?.series ?? [];
+
+  const [seriesSelection, setSeriesSelection] = useState<{ id: number; seriesId: number } | null>(
+    null,
+  );
+  const selectedSeries =
+    (seriesSelection?.id === id
+      ? seriesList.find((series) => series.id === seriesSelection.seriesId)
+      : undefined) ?? seriesList[0];
+  const data: GpuMetricRow[] = useMemo(() => selectedSeries?.data ?? [], [selectedSeries]);
+  const availableMetrics = useMemo(() => getAvailableMetrics(data), [data]);
+
+  const [metricSelection, setMetricSelection] = useState<GpuMetricKey>('power');
+  const metricKey: GpuMetricKey = availableMetrics.some((m) => m.key === metricSelection)
+    ? metricSelection
+    : 'power';
+  const metricConfig = ALL_METRIC_OPTIONS.find((m) => m.key === metricKey)!;
+  const allGpuIndices = useMemo(
+    () => [...new Set(data.map((row) => row.index))].toSorted((a, b) => a - b),
+    [data],
+  );
+  // Hidden chips are scoped to the series they were hidden on so switching
+  // series never carries over a stale filter.
+  const [hiddenSelection, setHiddenSelection] = useState<{
+    seriesId: number;
+    hidden: number[];
+  } | null>(null);
+  const hiddenGpus = useMemo(
+    () =>
+      new Set(
+        hiddenSelection && hiddenSelection.seriesId === selectedSeries?.id
+          ? hiddenSelection.hidden
+          : [],
+      ),
+    [hiddenSelection, selectedSeries?.id],
+  );
+  const visibleGpus = useMemo(
+    () => new Set(allGpuIndices.filter((gpuIndex) => !hiddenGpus.has(gpuIndex))),
+    [allGpuIndices, hiddenGpus],
+  );
+  const toggleGpu = (gpuIndex: number) => {
+    if (!selectedSeries) return;
+    track('inference_agentic_power_gpu_toggled', { id, gpuIndex });
+    const next = new Set(hiddenGpus);
+    if (next.has(gpuIndex)) next.delete(gpuIndex);
+    else next.add(gpuIndex);
+    setHiddenSelection({ seriesId: selectedSeries.id, hidden: [...next] });
+  };
+  const [isLegendExpanded, setIsLegendExpanded] = useState(true);
+  const [display, setDisplay] = useState<TelemetryDisplayState>(DEFAULT_TELEMETRY_DISPLAY);
+
+  // Server-metric overlay. The series are fetched as soon as the tab opens so
+  // the menu can list exactly the metrics this point has; one source at a time.
+  const metricsQuery = useTraceServerMetrics(id, enabled && serverMetricsEnabled);
+  const serverMetrics = metricsQuery.data;
+  const overlaySources = useMemo(() => availableOverlaySources(serverMetrics), [serverMetrics]);
+  const [overlaySelection, setOverlaySelection] = useState<{ id: number; key: string } | null>(
+    null,
+  );
+  const overlayKey = overlaySelection?.id === id ? overlaySelection.key : 'none';
+  const overlaySource = overlaySources.find((source) => source.key === overlayKey) ?? null;
+  // Trace timeslices carry epoch-ns starts, so both series can share wall-clock
+  // time. A zero startNs means the trace only has relative time.
+  const overlayAbsolute = Boolean(serverMetrics && serverMetrics.startNs > 0);
+  const overlay = useMemo<TelemetryOverlaySeries | null>(() => {
+    if (!overlaySource || !serverMetrics || !selectedSeries) return null;
+    const originMs = overlayAbsolute
+      ? serverMetrics.startNs / 1e6
+      : new Date(selectedSeries.startedAt).getTime();
+    return {
+      label: overlaySourceLabel(overlaySource, locale),
+      unit: overlaySource.unit,
+      color: overlaySource.color,
+      points: toAbsoluteMs(overlaySource.points(serverMetrics), originMs),
+    };
+  }, [overlaySource, serverMetrics, selectedSeries, overlayAbsolute, locale]);
+  const overlayNote = ((): string | null => {
+    if (metricsQuery.isLoading) return t.overlayLoading;
+    if (metricsQuery.isError) return t.overlayError;
+    if (overlaySources.length === 0) return t.overlayUnavailable;
+    if (!overlay) return null;
+    return overlayAbsolute ? t.overlayAligned : t.overlayRelative;
+  })();
+
+  if (!enabled) return null;
+
+  if (query.isLoading) {
+    return (
+      <div
+        className="rounded-lg border border-border/40 bg-card/40 p-4 text-sm text-muted-foreground"
+        data-testid="power-telemetry-loading"
+      >
+        {t.loading}
+      </div>
+    );
+  }
+  if (query.isError && !query.data) {
+    return (
+      <RetryableQueryError
+        message={t.error}
+        analyticsEvent="inference_agentic_power_telemetry_retry_clicked"
+        onRetry={query.refetch}
+        testId="power-telemetry-query-error"
+      />
+    );
+  }
+  if (!selectedSeries) {
+    return (
+      <div
+        className="rounded-lg border border-border/40 bg-card/40 p-4 text-sm text-muted-foreground"
+        data-testid="power-telemetry-missing"
+      >
+        {t.missing.replace('{id}', String(id))}
+      </div>
+    );
+  }
+
+  const durationS = Math.max(
+    0,
+    (new Date(selectedSeries.endedAt).getTime() - new Date(selectedSeries.startedAt).getTime()) /
+      1000,
+  );
+  const numberLocale = locale === 'zh' ? 'zh-CN' : undefined;
+
+  return (
+    <div className="flex flex-col gap-4" data-testid="power-telemetry-view">
+      <Card>
+        <dl className="mb-4 grid grid-cols-2 gap-x-4 gap-y-3 text-sm sm:grid-cols-3 lg:grid-cols-5">
+          <div className="min-w-0">
+            <dt className="text-xs text-muted-foreground">{t.vendor}</dt>
+            <dd className="font-medium">{collectorLabel(selectedSeries)}</dd>
+          </div>
+          <div className="min-w-0">
+            <dt className="text-xs text-muted-foreground">{t.samples}</dt>
+            <dd className="font-medium tabular-nums" data-testid="power-telemetry-sample-count">
+              {selectedSeries.sampleCount.toLocaleString(numberLocale)}
+            </dd>
+          </div>
+          <div className="min-w-0">
+            <dt className="text-xs text-muted-foreground">{t.chips}</dt>
+            <dd className="font-medium tabular-nums">{selectedSeries.gpuCount}</dd>
+          </div>
+          <div className="min-w-0">
+            <dt className="text-xs text-muted-foreground">{t.interval}</dt>
+            <dd className="font-medium tabular-nums">
+              {selectedSeries.sampleIntervalS === null
+                ? '—'
+                : `${selectedSeries.sampleIntervalS.toFixed(2)} ${t.secondsUnit}`}
+            </dd>
+          </div>
+          <div className="min-w-0">
+            <dt className="text-xs text-muted-foreground">{t.window}</dt>
+            <dd className="font-medium tabular-nums">
+              {new Date(selectedSeries.startedAt).toLocaleTimeString(numberLocale)} ·{' '}
+              {Math.round(durationS).toLocaleString(numberLocale)} {t.secondsUnit}
+            </dd>
+          </div>
+        </dl>
+        <div className="grid grid-cols-1 sm:grid-cols-[1fr_auto] items-end gap-3">
+          {seriesList.length > 1 && (
+            <div className="space-y-1 min-w-0">
+              <Label htmlFor="power-telemetry-series-select">{t.series}</Label>
+              <Select
+                value={String(selectedSeries.id)}
+                onValueChange={(value) => {
+                  track('inference_agentic_power_series_selected', { id, seriesId: Number(value) });
+                  setSeriesSelection({ id, seriesId: Number(value) });
+                }}
+              >
+                <SelectTrigger id="power-telemetry-series-select" className="w-full truncate">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {seriesList.map((series) => (
+                    <SelectItem key={series.id} value={String(series.id)}>
+                      {seriesLabel(series, seriesList.length)}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+          )}
+          <div className="space-y-1">
+            <Label htmlFor="power-telemetry-metric-select">{t.metric}</Label>
+            <Select
+              value={metricKey}
+              onValueChange={(value) => {
+                track('inference_agentic_power_metric_changed', { id, metric: value });
+                setMetricSelection(value as GpuMetricKey);
+              }}
+            >
+              <SelectTrigger
+                id="power-telemetry-metric-select"
+                data-testid="power-telemetry-metric-select"
+                className="w-full sm:w-56"
+              >
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {availableMetrics.map((m) => (
+                  <SelectItem key={m.key} value={m.key}>
+                    {getGpuMetricLabel(m, locale)} ({m.unit})
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+        </div>
+        <TelemetryDisplayControls
+          value={display}
+          onChange={setDisplay}
+          analyticsPrefix="inference_agentic_power"
+          idPrefix="power-telemetry-display"
+          className="mt-3 border-t border-border/60 pt-3"
+        />
+        {serverMetricsEnabled && (
+          <div className="mt-3 flex flex-wrap items-end gap-x-3 gap-y-1">
+            <div className="space-y-1">
+              <Label htmlFor="power-telemetry-overlay">{t.overlayToggle}</Label>
+              <Select
+                value={overlayKey}
+                disabled={overlaySources.length === 0}
+                onValueChange={(value) => {
+                  track('inference_agentic_power_overlay_changed', { id, source: value });
+                  setOverlaySelection({ id, key: value });
+                }}
+              >
+                <SelectTrigger
+                  id="power-telemetry-overlay"
+                  data-testid="power-telemetry-overlay-select"
+                  className="w-full sm:w-64"
+                >
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="none">{t.overlayNone}</SelectItem>
+                  {overlaySources.map((source) => (
+                    <SelectItem key={source.key} value={source.key}>
+                      {overlaySourceLabel(source, locale)} ({source.unit})
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+            {overlayNote && (
+              <span
+                className="pb-2 text-xs text-muted-foreground"
+                data-testid="power-telemetry-overlay-note"
+              >
+                {overlayNote}
+              </span>
+            )}
+          </div>
+        )}
+      </Card>
+
+      <Card className="relative" data-testid="power-telemetry-chart">
+        <GpuMetricsChart
+          data={data}
+          visibleGpus={visibleGpus}
+          metricKey={metricKey}
+          artifactName={selectedSeries.artifactName}
+          hardware={hardware}
+          maxPoints={2000}
+          display={display}
+          overlay={overlay}
+          legendElement={
+            <ChartLegend
+              variant="sidebar"
+              legendItems={allGpuIndices.map((gpuIndex) => ({
+                name: `${t.chip} ${gpuIndex}`,
+                hw: String(gpuIndex),
+                label: `${t.chip} ${gpuIndex}`,
+                color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
+                isActive: visibleGpus.has(gpuIndex),
+                onClick: () => toggleGpu(gpuIndex),
+              }))}
+              onItemRemove={(hw) => {
+                const gpuIndex = Number(hw);
+                if (visibleGpus.has(gpuIndex)) toggleGpu(gpuIndex);
+              }}
+              isLegendExpanded={isLegendExpanded}
+              onExpandedChange={(expanded) => {
+                setIsLegendExpanded(expanded);
+                track('inference_agentic_power_legend_expanded', { id, expanded });
+              }}
+              actions={
+                hiddenGpus.size === 0
+                  ? []
+                  : [
+                      {
+                        id: 'power-telemetry-show-all-chips',
+                        label: t.resetFilter,
+                        onClick: () => {
+                          track('inference_agentic_power_gpu_reset_filter', { id });
+                          setHiddenSelection(null);
+                        },
+                      },
+                    ]
+              }
+            />
+          }
+          caption={
+            <span className="text-xs text-muted-foreground">
+              {getGpuMetricLabel(metricConfig, locale)} · {t.sharedNote}
+            </span>
+          }
+        />
+      </Card>
+
+      <Card>
+        <h3 className="mb-2 text-sm font-medium">{t.perGpuStats}</h3>
+        <GpuStatsTable data={data} metricKey={metricKey} storedStats={selectedSeries.stats} />
+      </Card>
+    </div>
+  );
+}
diff --git a/packages/app/src/components/inference/agentic-point/use-detail-view.ts b/packages/app/src/components/inference/agentic-point/use-detail-view.ts
index 1a97a85cc..b08b3a868 100644
--- a/packages/app/src/components/inference/agentic-point/use-detail-view.ts
+++ b/packages/app/src/components/inference/agentic-point/use-detail-view.ts
@@ -6,10 +6,14 @@ import { useClientSearchParams } from '@/hooks/useClientSearch';
 import { track } from '@/lib/analytics';
 import { replaceClientSearch } from '@/lib/client-navigation';
 
-export type DetailView = 'point' | 'timeline' | 'aggregates' | 'logs';
+export type DetailView = 'point' | 'timeline' | 'power' | 'aggregates' | 'logs';
 
 const isDetailView = (value: string | null): value is DetailView =>
-  value === 'point' || value === 'timeline' || value === 'aggregates' || value === 'logs';
+  value === 'point' ||
+  value === 'timeline' ||
+  value === 'power' ||
+  value === 'aggregates' ||
+  value === 'logs';
 
 /** URL-persisted detail view (`?view=`; per-point is the unadorned default). */
 export function useDetailView(): [DetailView, (nextView: DetailView) => void] {
diff --git a/packages/app/src/components/inference/power-telemetry-dialog.tsx b/packages/app/src/components/inference/power-telemetry-dialog.tsx
new file mode 100644
index 000000000..e20718a55
--- /dev/null
+++ b/packages/app/src/components/inference/power-telemetry-dialog.tsx
@@ -0,0 +1,51 @@
+'use client';
+
+import type { InferenceData } from '@/components/inference/types';
+import { PowerTelemetryView } from '@/components/inference/agentic-point/power-telemetry-view';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import { isPersistedBenchmarkId } from '@/lib/benchmark-id';
+import { useLocale } from '@/lib/use-locale';
+
+const STRINGS = {
+  en: { point: 'Benchmark point', concurrency: 'Concurrency' },
+  zh: { point: '基准测试数据点', concurrency: '并发数' },
+} as const;
+
+interface Props {
+  point: InferenceData;
+  onOpenChange: (open: boolean) => void;
+}
+
+export function PowerTelemetryDialog({ point, onOpenChange }: Props) {
+  const t = STRINGS[useLocale()];
+  if (!isPersistedBenchmarkId(point.id)) return null;
+
+  return (
+    <Dialog open onOpenChange={onOpenChange}>
+      <DialogContent
+        className="flex max-h-[94vh] w-[min(96vw,80rem)] max-w-[min(96vw,80rem)] flex-col gap-3 overflow-y-auto p-3 sm:p-5"
+        data-testid="power-telemetry-dialog"
+      >
+        <DialogHeader className="pr-6">
+          <DialogTitle>PowerX</DialogTitle>
+          <DialogDescription className="break-words">
+            {t.point} #{point.id} · {point.hwKey} · {point.precision.toUpperCase()} ·{' '}
+            {t.concurrency} {point.conc}
+          </DialogDescription>
+        </DialogHeader>
+        <PowerTelemetryView
+          id={point.id}
+          enabled
+          hardware={point.hw}
+          serverMetricsEnabled={point.benchmark_type === 'agentic_traces'}
+        />
+      </DialogContent>
+    </Dialog>
+  );
+}

From 875edcb93bccf6ff5b7d0022bb2089313dcc0c36 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 070/103] feat(ui): explorer smoothing controls and stored
 full-record statistics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The /gpu-metrics explorer reads stored series, shows full-record statistics from the
ingest digest, adds points/rolling display modes with a mean-of-chips line, and refetches
on focus so a re-ingest shows up in an open tab.

中文：/gpu-metrics explorer 读取入库序列，展示 ingest 摘要的全记录统计，新增点/滑动平均显示模式与芯片均值线，并在窗口聚焦时刷新以反映重入库。
---
 packages/app/cypress/e2e/gpu-power.cy.ts      |   6 +-
 .../components/gpu-power/GpuPowerChart.tsx    | 392 +++++++++++++++---
 .../components/gpu-power/GpuPowerDisplay.tsx  | 173 ++++----
 .../components/gpu-power/GpuStatsTable.tsx    |  99 +++--
 .../gpu-power/TelemetryDisplayControls.tsx    | 139 +++++++
 .../components/gpu-power/chart-data.test.ts   |  33 ++
 .../src/components/gpu-power/chart-data.ts    |  43 +-
 .../gpu-power/telemetry-smoothing.test.ts     |  34 ++
 .../gpu-power/telemetry-smoothing.ts          | 160 +++++++
 .../src/components/gpu-power/types.test.ts    | 365 +---------------
 .../app/src/components/gpu-power/types.ts     | 323 ++++-----------
 packages/app/src/lib/d3-chart/layers/lines.ts |   4 +-
 12 files changed, 967 insertions(+), 804 deletions(-)
 create mode 100644 packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
 create mode 100644 packages/app/src/components/gpu-power/chart-data.test.ts
 create mode 100644 packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
 create mode 100644 packages/app/src/components/gpu-power/telemetry-smoothing.ts

diff --git a/packages/app/cypress/e2e/gpu-power.cy.ts b/packages/app/cypress/e2e/gpu-power.cy.ts
index 2ff041dd5..eb769267b 100644
--- a/packages/app/cypress/e2e/gpu-power.cy.ts
+++ b/packages/app/cypress/e2e/gpu-power.cy.ts
@@ -211,9 +211,9 @@ describe('PowerX Chinese route', () => {
       .should('contain.text', '秒')
       .and('contain.text', '功耗 (W)');
     cy.get('[data-testid="gpu-metrics-chart-svg"]').should('contain.text', '点击数据点固定提示框');
-    cy.get('[data-testid="gpu-metrics-chart-svg"] svg .point')
-      .first()
-      .trigger('mouseenter', { force: true });
+    cy.get('[data-testid="gpu-metrics-chart-svg"] svg .point').first().scrollIntoView();
+    // Exercise the supported mobile interaction, not a forced off-screen hover.
+    cy.get('[data-testid="gpu-metrics-chart-svg"] svg .point').first().click();
     cy.get('[data-chart-tooltip]:visible')
       .should('contain.text', '芯片 0')
       .and('contain.text', '功耗：');
diff --git a/packages/app/src/components/gpu-power/GpuPowerChart.tsx b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
index 09635c51a..fa3f33b5d 100644
--- a/packages/app/src/components/gpu-power/GpuPowerChart.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
@@ -2,13 +2,25 @@
 
 import * as d3 from 'd3';
 import React, { useMemo } from 'react';
-import { buildGroupedData, type ParsedPoint } from './chart-data';
+import { buildTelemetryData, type ParsedPoint } from './chart-data';
 
 import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import type { RenderContext } from '@/lib/d3-chart/D3Chart/types';
+import { CHART_TYPE, px } from '@/lib/d3-chart/typography';
 import { useLocale } from '@/lib/use-locale';
+import {
+  DEFAULT_TELEMETRY_DISPLAY,
+  estimateSampleIntervalMs,
+  meanAcrossSeries,
+  nearestSample,
+  rollingTimeAverage,
+  type TelemetryDisplayState,
+  type TimedSample,
+} from './telemetry-smoothing';
 import {
   ALL_METRIC_OPTIONS,
   detectTdpFromArtifactName,
+  tdpForHardware,
   getGpuMetricLabel,
   getGpuMetricYAxisLabel,
   type GpuMetricKey,
@@ -26,6 +38,10 @@ const STRINGS = {
     power: 'Power',
     temp: 'Temp',
     utilization: 'Chip Util',
+    rollingSuffix: (windowS: number) => `${windowS} s rolling avg`,
+    meanChips: 'Mean of visible chips',
+    meanCount: (n: number) => `${n} chips`,
+    rightAxis: 'right axis',
   },
   zh: {
     empty: '暂无可显示的芯片指标数据。',
@@ -36,23 +52,155 @@ const STRINGS = {
     power: '功耗',
     temp: '温度',
     utilization: '芯片利用率',
+    rollingSuffix: (windowS: number) => `${windowS} 秒滚动平均`,
+    meanChips: '可见芯片均值',
+    meanCount: (n: number) => `${n} 个芯片`,
+    rightAxis: '右轴',
   },
 } as const;
 
+/** A second time series drawn over the telemetry on its own right-hand axis. */
+export interface TelemetryOverlaySeries {
+  label: string;
+  unit: string;
+  color: string;
+  /** Absolute-time samples; the chart re-bases them onto its own t=0. */
+  points: TimedSample[];
+}
+
 interface GpuMetricsChartProps {
   data: GpuMetricRow[];
   visibleGpus: Set<number>;
   metricKey: GpuMetricKey;
   artifactName: string;
+  /**
+   * Hardware key of the benchmark point (`b200`, `h200`, …). Multinode bundle
+   * names are hash-truncated and carry no SKU token, so callers that know the
+   * point pass it explicitly; the artifact-name sniff stays the fallback.
+   */
+  hardware?: string;
   legendElement?: React.ReactNode;
   caption?: React.ReactNode;
   /** Max interactive points before LTTB downsampling. Infinity to disable. */
   maxPoints?: number;
+  /** Raw samples vs. time-window rolling average. Defaults to raw samples. */
+  display?: TelemetryDisplayState;
+  /** Optional secondary series (e.g. decode throughput) on a right y-axis. */
+  overlay?: TelemetryOverlaySeries | null;
+}
+
+/** Mean across the visible chips, aligned by nearest sample within one poll interval. */
+function buildMeanSeries(groups: Map<number, ParsedPoint[]>, t0Ms: number): ParsedPoint[] {
+  const arrays = [...groups.values()];
+  if (arrays.length === 0) return [];
+  const longest = arrays.reduce((a, b) => (b.length > a.length ? b : a));
+  const mean = meanAcrossSeries(arrays, estimateSampleIntervalMs(longest));
+  return mean.map((p) => ({
+    seconds: (p.ms - t0Ms) / 1000,
+    ms: p.ms,
+    value: p.value,
+    gpuIndex: MEAN_INDEX,
+    raw: null,
+    count: p.count,
+  }));
+}
+
+/** Replace each point's value with its centered time-window mean. */
+function smoothSeries(points: ParsedPoint[], windowS: number): ParsedPoint[] {
+  const averaged = rollingTimeAverage(points, windowS * 1000);
+  return points.map((point, i) => ({ ...point, value: averaged[i]!.value, raw: null }));
+}
+
+/** Per-chip palette shared with legends that toggle chips on and off. */
+export const GPU_COLORS = d3.schemeTableau10;
+/** Pseudo chip index and line key for the mean across visible chips. */
+const MEAN_INDEX = -1;
+const MEAN_KEY = 'mean';
+const MEAN_COLOR = 'var(--foreground)';
+
+function lineKey(gpuIndex: number): string {
+  return gpuIndex === MEAN_INDEX ? MEAN_KEY : String(gpuIndex);
 }
 
-const GPU_COLORS = d3.schemeTableau10;
+function colorFor(gpuIndex: number): string {
+  return gpuIndex === MEAN_INDEX ? MEAN_COLOR : GPU_COLORS[gpuIndex % GPU_COLORS.length]!;
+}
 const CHART_ID = 'gpu-metrics-line';
 const MARGIN = { top: 24, right: 20, bottom: 60, left: 60 };
+/** Room for the overlay's right axis ticks and rotated title. */
+const MARGIN_WITH_OVERLAY = { ...MARGIN, right: 84 };
+
+interface OverlayPoint {
+  x: number;
+  y: number;
+}
+
+function overlayYScale(points: OverlayPoint[], height: number): d3.ScaleLinear<number, number> {
+  const max = d3.max(points, (p) => p.y) ?? 0;
+  return d3
+    .scaleLinear()
+    .domain([0, max > 0 ? max * 1.05 : 1])
+    .range([height, 0])
+    .nice();
+}
+
+function overlayLine(
+  xScale: d3.ScaleLinear<number, number>,
+  yScale: d3.ScaleLinear<number, number>,
+): d3.Line<OverlayPoint> {
+  return d3
+    .line<OverlayPoint>()
+    .x((p) => xScale(p.x))
+    .y((p) => yScale(p.y))
+    .curve(d3.curveMonotoneX);
+}
+
+/**
+ * Draw the overlay path inside the clipped zoom group and its axis in the
+ * unclipped root group. Both are removed first so toggling the overlay off
+ * (or re-rendering) never leaves a stale axis behind.
+ */
+function renderOverlay(
+  group: d3.Selection<SVGGElement, unknown, null, undefined>,
+  ctx: RenderContext,
+  overlay: TelemetryOverlaySeries | null | undefined,
+  points: OverlayPoint[],
+): void {
+  group.selectAll('.telemetry-overlay').remove();
+  ctx.layout.g.selectAll('.telemetry-overlay-axis').remove();
+  if (!overlay || points.length === 0) return;
+  const xScale = ctx.xScale as d3.ScaleLinear<number, number>;
+  const yScale = overlayYScale(points, ctx.height);
+  group
+    .append('path')
+    .attr('class', 'telemetry-overlay')
+    .attr('fill', 'none')
+    .attr('stroke', overlay.color)
+    .attr('stroke-width', 1.75)
+    .attr('opacity', 0.9)
+    .attr('pointer-events', 'none')
+    .attr('d', overlayLine(xScale, yScale)(points));
+
+  const axis = ctx.layout.g
+    .append('g')
+    .attr('class', 'telemetry-overlay-axis')
+    .attr('transform', `translate(${ctx.width},0)`)
+    .call(d3.axisRight(yScale).ticks(6).tickSize(4).tickFormat(d3.format('~s')));
+  axis.select('.domain').attr('stroke', overlay.color);
+  axis.selectAll('.tick line').attr('stroke', overlay.color);
+  axis
+    .selectAll('.tick text')
+    .attr('fill', overlay.color)
+    .attr('font-size', px(CHART_TYPE.axisLabel));
+  axis
+    .append('text')
+    .attr('class', 'telemetry-overlay-axis-label')
+    .attr('transform', `translate(${ctx.layout.margin.right - 14},${ctx.height / 2}) rotate(90)`)
+    .attr('text-anchor', 'middle')
+    .attr('fill', overlay.color)
+    .attr('font-size', px(CHART_TYPE.axisLabel))
+    .text(`${overlay.label} (${overlay.unit})`);
+}
 
 const GpuMetricsChart = React.memo(
   ({
@@ -60,19 +208,42 @@ const GpuMetricsChart = React.memo(
     visibleGpus,
     metricKey,
     artifactName,
+    hardware,
     legendElement,
     caption,
     maxPoints,
+    display = DEFAULT_TELEMETRY_DISPLAY,
+    overlay,
   }: GpuMetricsChartProps) => {
     const locale = useLocale();
     const t = STRINGS[locale];
     const metricConfig = ALL_METRIC_OPTIONS.find((m) => m.key === metricKey)!;
+    const rolling = display.mode === 'rolling';
+    const showChips = display.series !== 'mean';
+    const showMean = display.series !== 'chips';
 
-    const groupedData = useMemo(
-      () => buildGroupedData(data, visibleGpus, metricKey),
+    const { t0Ms, groups: rawGroups } = useMemo(
+      () => buildTelemetryData(data, visibleGpus, metricKey),
       [data, visibleGpus, metricKey],
     );
 
+    // Displayed series keyed by chip index (MEAN_INDEX for the mean line):
+    // per-chip and/or mean, then optionally smoothed.
+    const groupedData = useMemo(() => {
+      const series = new Map<number, ParsedPoint[]>();
+      if (showChips) for (const [gpuIndex, points] of rawGroups) series.set(gpuIndex, points);
+      if (showMean) {
+        const mean = buildMeanSeries(rawGroups, t0Ms);
+        if (mean.length > 0) series.set(MEAN_INDEX, mean);
+      }
+      if (!rolling) return series;
+      const smoothed = new Map<number, ParsedPoint[]>();
+      for (const [gpuIndex, points] of series) {
+        smoothed.set(gpuIndex, smoothSeries(points, display.windowS));
+      }
+      return smoothed;
+    }, [rawGroups, t0Ms, showChips, showMean, rolling, display.windowS]);
+
     const allPoints = useMemo(() => {
       const pts: ParsedPoint[] = [];
       for (const points of groupedData.values()) pts.push(...points);
@@ -83,11 +254,64 @@ const GpuMetricsChart = React.memo(
     const lineData = useMemo(() => {
       const result: Record<string, { x: number; y: number }[]> = {};
       for (const [gpuIndex, points] of groupedData) {
-        result[String(gpuIndex)] = points.map((p) => ({ x: p.seconds, y: p.value }));
+        result[lineKey(gpuIndex)] = points.map((p) => ({ x: p.seconds, y: p.value }));
       }
       return result;
     }, [groupedData]);
 
+    // Overlay samples, smoothed with the same window as the chip lines when
+    // averaging so both series answer the same "how much over N seconds"
+    // question, then re-based onto the telemetry's t=0.
+    const overlaySamples = useMemo<TimedSample[]>(() => {
+      if (!overlay) return [];
+      return rolling ? rollingTimeAverage(overlay.points, display.windowS * 1000) : overlay.points;
+    }, [overlay, rolling, display.windowS]);
+    const overlayPoints = useMemo<OverlayPoint[]>(
+      () => overlaySamples.map((p) => ({ x: (p.ms - t0Ms) / 1000, y: p.value })),
+      [overlaySamples, t0Ms],
+    );
+    const hasOverlay = Boolean(overlay) && overlayPoints.length > 0;
+
+    const hasMeanLine = groupedData.has(MEAN_INDEX);
+    const keyRow =
+      hasMeanLine || hasOverlay ? (
+        <div
+          className="mt-1 flex flex-wrap items-center gap-x-4 gap-y-1 text-xs text-muted-foreground"
+          data-testid="gpu-metrics-chart-keys"
+        >
+          {hasMeanLine && (
+            <span className="inline-flex items-center gap-1.5">
+              <span
+                aria-hidden
+                className="inline-block h-0.5 w-4 rounded"
+                style={{ background: MEAN_COLOR }}
+              />
+              {t.meanChips}
+            </span>
+          )}
+          {hasOverlay && overlay && (
+            <span
+              className="inline-flex items-center gap-1.5"
+              data-testid="gpu-metrics-overlay-key"
+            >
+              <span
+                aria-hidden
+                className="inline-block h-0.5 w-4 rounded"
+                style={{ background: overlay.color }}
+              />
+              {overlay.label} ({overlay.unit} · {t.rightAxis})
+            </span>
+          )}
+        </div>
+      ) : null;
+    const resolvedCaption =
+      caption || keyRow ? (
+        <>
+          {caption}
+          {keyRow}
+        </>
+      ) : undefined;
+
     // Scale domains
     const xDomain = useMemo(() => {
       if (allPoints.length === 0) return [0, 100] as [number, number];
@@ -95,14 +319,23 @@ const GpuMetricsChart = React.memo(
       return ext;
     }, [allPoints]);
 
-    const tdpInfo = metricKey === 'power' ? detectTdpFromArtifactName(artifactName) : null;
+    const tdpInfo =
+      metricKey === 'power'
+        ? (tdpForHardware(hardware) ?? detectTdpFromArtifactName(artifactName))
+        : null;
 
     const yDomain = useMemo(() => {
       if (allPoints.length === 0) return [0, 100] as [number, number];
       const ext = d3.extent(allPoints, (d) => d.value) as [number, number];
       const range = ext[1] - ext[0];
-      const yMin = Math.max(0, ext[0] - range * 0.05);
-      let yMax = ext[1] + range * 0.05;
+      // Constant telemetry and floating-point noise still need a readable axis.
+      const padding = Math.max(
+        range * 0.05,
+        Math.max(Math.abs(ext[0]), Math.abs(ext[1])) * 0.01,
+        1,
+      );
+      const yMin = Math.max(0, ext[0] - padding);
+      let yMax = ext[1] + padding;
       if (tdpInfo && tdpInfo.tdp > yMax) yMax = tdpInfo.tdp * 1.05;
       return [yMin, yMax] as [number, number];
     }, [allPoints, tdpInfo]);
@@ -120,46 +353,52 @@ const GpuMetricsChart = React.memo(
         chartId={CHART_ID}
         data={allPoints}
         height={600}
-        margin={MARGIN}
+        margin={hasOverlay ? MARGIN_WITH_OVERLAY : MARGIN}
         watermark="logo"
         testId="gpu-metrics-chart-svg"
         grabCursor={true}
         instructions={t.instructions}
         xScale={{ type: 'linear', domain: xDomain, nice: true }}
         yScale={{ type: 'linear', domain: yDomain, nice: true }}
-        xAxis={{ label: t.seconds, tickCount: 10 }}
+        xAxis={{
+          label: t.seconds,
+          tickValues: (scale) => {
+            const secondsScale = scale as d3.ScaleLinear<number, number>;
+            const [left, right] = secondsScale.range();
+            return secondsScale.ticks(Math.max(2, Math.min(10, Math.floor((right - left) / 60))));
+          },
+        }}
         yAxis={{ label: getGpuMetricYAxisLabel(metricConfig, locale), tickCount: 8 }}
         layers={[
           // TDP reference line (power metric only)
           {
             type: 'custom',
             key: 'tdp-line',
-            render: tdpInfo
-              ? (group, ctx) => {
-                  const yScale = ctx.yScale as d3.ScaleLinear<number, number>;
-                  const tdpY = yScale(tdpInfo.tdp);
-                  group.selectAll('.tdp-line').remove();
-                  const tdpGroup = group.append('g').attr('class', 'tdp-line');
-                  tdpGroup
-                    .append('line')
-                    .attr('x1', 0)
-                    .attr('x2', ctx.width)
-                    .attr('y1', tdpY)
-                    .attr('y2', tdpY)
-                    .attr('stroke', '#ef4444')
-                    .attr('stroke-width', 1.5)
-                    .attr('stroke-dasharray', '6,4');
-                  tdpGroup
-                    .append('text')
-                    .attr('x', ctx.width - 4)
-                    .attr('y', tdpY - 6)
-                    .attr('text-anchor', 'end')
-                    .attr('fill', '#ef4444')
-                    .attr('font-size', '11px')
-                    .attr('font-weight', '600')
-                    .text(`${tdpInfo.sku} TDP: ${tdpInfo.tdp}W`);
-                }
-              : null,
+            render: (group, ctx) => {
+              group.selectAll('.tdp-line').remove();
+              if (!tdpInfo) return;
+              const yScale = ctx.yScale as d3.ScaleLinear<number, number>;
+              const tdpY = yScale(tdpInfo.tdp);
+              const tdpGroup = group.append('g').attr('class', 'tdp-line');
+              tdpGroup
+                .append('line')
+                .attr('x1', 0)
+                .attr('x2', ctx.width)
+                .attr('y1', tdpY)
+                .attr('y2', tdpY)
+                .attr('stroke', '#ef4444')
+                .attr('stroke-width', 1.5)
+                .attr('stroke-dasharray', '6,4');
+              tdpGroup
+                .append('text')
+                .attr('x', ctx.width - 4)
+                .attr('y', tdpY - 6)
+                .attr('text-anchor', 'end')
+                .attr('fill', '#ef4444')
+                .attr('font-size', '11px')
+                .attr('font-weight', '600')
+                .text(`${tdpInfo.sku} TDP: ${tdpInfo.tdp}W`);
+            },
           },
           // GPU lines
           {
@@ -167,8 +406,8 @@ const GpuMetricsChart = React.memo(
             key: 'gpu-lines',
             lines: lineData,
             config: {
-              getColor: (key) => GPU_COLORS[parseInt(key, 10) % GPU_COLORS.length],
-              strokeWidth: 1.5,
+              getColor: (key) => (key === MEAN_KEY ? MEAN_COLOR : colorFor(parseInt(key, 10))),
+              getStrokeWidth: (key) => (key === MEAN_KEY ? 2.5 : rolling ? 1.75 : 1.5),
               curve: d3.curveMonotoneX,
             },
           },
@@ -182,11 +421,31 @@ const GpuMetricsChart = React.memo(
               getCy: () => 0,
               getX: (d) => d.seconds,
               getY: (d) => d.value,
-              getColor: (d) => GPU_COLORS[d.gpuIndex % GPU_COLORS.length],
-              getRadius: () => 2,
+              // Averaged mode draws lines only; the circles stay as invisible
+              // hover targets so the tooltip and crosshair keep working.
+              getColor: (d) => (rolling ? 'transparent' : colorFor(d.gpuIndex)),
+              getRadius: () => (rolling ? 3 : 2),
               maxPoints,
             },
           },
+          // Secondary series on a right-hand axis (e.g. decode throughput)
+          {
+            type: 'custom',
+            key: 'telemetry-overlay',
+            render: (group, ctx) => {
+              renderOverlay(group, ctx, hasOverlay ? overlay : null, overlayPoints);
+            },
+            onZoom: (group, ctx) => {
+              if (!hasOverlay) return;
+              const xScale = ctx.newXScale as d3.ScaleLinear<number, number>;
+              group
+                .select<SVGPathElement>('.telemetry-overlay')
+                .attr(
+                  'd',
+                  overlayLine(xScale, overlayYScale(overlayPoints, ctx.height))(overlayPoints),
+                );
+            },
+          },
         ]}
         zoom={{
           enabled: true,
@@ -197,29 +456,60 @@ const GpuMetricsChart = React.memo(
         tooltip={{
           rulerType: 'crosshair',
           content: (d: ParsedPoint, isPinned: boolean) => {
-            const color = GPU_COLORS[d.gpuIndex % GPU_COLORS.length];
+            const color = colorFor(d.gpuIndex);
+            const sep = locale === 'zh' ? '：' : ':';
+            const title =
+              d.gpuIndex === MEAN_INDEX
+                ? `${t.meanChips}${d.count ? ` · ${t.meanCount(d.count)}` : ''}`
+                : `${t.chip} ${d.gpuIndex}`;
+            const overlayAt = hasOverlay ? nearestSample(overlaySamples, d.ms) : null;
+            const overlayRow =
+              overlay && overlayAt
+                ? `<div class="mt-1" style="color: ${overlay.color}">${overlay.label}${sep} ${
+                    overlayAt.value >= 100 ? overlayAt.value.toFixed(0) : overlayAt.value.toFixed(1)
+                  } ${overlay.unit}</div>`
+                : '';
             return `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md backdrop-blur-sm" style="min-width: 160px; user-select: ${isPinned ? 'text' : 'none'}">
               ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
-              <div class="font-semibold mb-1" style="color: ${color}">${t.chip} ${d.gpuIndex}</div>
+              <div class="font-semibold mb-1" style="color: ${color}">${title}</div>
               <div class="text-muted-foreground">${d.seconds.toFixed(1)}${locale === 'zh' ? ' 秒' : 's'}</div>
-              <div class="mt-1 font-medium">${getGpuMetricLabel(metricConfig, locale)}${locale === 'zh' ? '：' : ':'} ${d.value.toFixed(1)} ${metricConfig.unit}</div>
-              <div class="text-muted-foreground">${t.power}${locale === 'zh' ? '：' : ':'} ${d.raw.power.toFixed(1)} W</div>
-              <div class="text-muted-foreground">${t.temp}${locale === 'zh' ? '：' : ':'} ${d.raw.temperature}\u00B0C</div>
-              <div class="text-muted-foreground">${t.utilization}${locale === 'zh' ? '：' : ':'} ${d.raw.gpuUtil}%</div>
+              <div class="mt-1 font-medium">${getGpuMetricLabel(metricConfig, locale)}${sep} ${d.value.toFixed(1)} ${metricConfig.unit}</div>
+              ${rolling ? `<div class="text-muted-foreground">${t.rollingSuffix(display.windowS)}</div>` : ''}
+              ${
+                d.raw
+                  ? `<div class="text-muted-foreground">${t.power}${sep} ${d.raw.power.toFixed(1)} W</div>${
+                      d.raw.temperature === undefined
+                        ? ''
+                        : `<div class="text-muted-foreground">${t.temp}${sep} ${d.raw.temperature}\u00B0C</div>`
+                    }${
+                      d.raw.gpuUtil === undefined
+                        ? ''
+                        : `<div class="text-muted-foreground">${t.utilization}${sep} ${d.raw.gpuUtil}%</div>`
+                    }`
+                  : ''
+              }
+              ${overlayRow}
             </div>`;
           },
           getRulerX: (d, xScale) => (xScale as d3.ScaleLinear<number, number>)(d.seconds),
           getRulerY: (d, yScale) => yScale(d.value),
-          onHoverStart: (sel) => {
-            sel.attr('r', 5).attr('stroke', 'white').attr('stroke-width', 1);
+          onHoverStart: (sel, d) => {
+            sel
+              .attr('r', 5)
+              .attr('fill', colorFor(d.gpuIndex))
+              .attr('stroke', 'white')
+              .attr('stroke-width', 1);
           },
-          onHoverEnd: (sel) => {
-            sel.attr('r', 2).attr('stroke', 'none');
+          onHoverEnd: (sel, d) => {
+            sel
+              .attr('r', rolling ? 3 : 2)
+              .attr('fill', rolling ? 'transparent' : colorFor(d.gpuIndex))
+              .attr('stroke', 'none');
           },
           attachToLayer: 2,
         }}
         legendElement={legendElement}
-        caption={caption}
+        caption={resolvedCaption}
       />
     );
   },
diff --git a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
index f0949589c..d28dbf25d 100644
--- a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
@@ -33,6 +33,8 @@ import { useClientSearchParams } from '@/hooks/useClientSearch';
 import GpuCorrelationChart from './GpuCorrelationChart';
 import GpuMetricsChart from './GpuPowerChart';
 import GpuStatsTable from './GpuStatsTable';
+import { DEFAULT_TELEMETRY_DISPLAY, type TelemetryDisplayState } from './telemetry-smoothing';
+import { TelemetryDisplayControls } from './TelemetryDisplayControls';
 import {
   type GpuMetricKey,
   type GpuPowerApiResponse,
@@ -81,6 +83,7 @@ const STRINGS = {
     chip: 'Chip',
     chartToolbar: 'Chart controls',
     correlationAxes: 'Correlation axes',
+    displayControls: 'Line options',
   },
   zh: {
     heading: 'PowerX',
@@ -119,6 +122,7 @@ const STRINGS = {
     chip: '芯片',
     chartToolbar: '图表控制',
     correlationAxes: '相关性坐标轴',
+    displayControls: '曲线选项',
   },
 } as const;
 
@@ -175,6 +179,7 @@ export default function GpuMetricsDisplay() {
     gcTime: 0,
     retry: false,
     refetchOnMount: 'always',
+    refetchOnWindowFocus: true,
   });
   const artifacts = query.data?.artifacts ?? [];
   const runInfo = query.data?.runInfo ?? null;
@@ -200,10 +205,8 @@ export default function GpuMetricsDisplay() {
     artifacts.some((artifact) => artifact.name === selectedArtifactCandidate)
       ? selectedArtifactCandidate
       : (artifacts[0]?.name ?? '');
-  const currentData = useMemo(
-    () => artifacts.find((artifact) => artifact.name === selectedArtifact)?.data ?? [],
-    [artifacts, selectedArtifact],
-  );
+  const currentArtifact = artifacts.find((artifact) => artifact.name === selectedArtifact);
+  const currentData = useMemo(() => currentArtifact?.data ?? [], [currentArtifact]);
   const availableMetrics = useMemo(() => getAvailableMetrics(currentData), [currentData]);
   const urlMetric = searchParams.get('gm_metric');
   const selectedMetricCandidate = selectionApplies ? selection.metric : urlMetric;
@@ -237,6 +240,16 @@ export default function GpuMetricsDisplay() {
   const [chartView, setChartView] = useState<GpuMetricsView>('chart');
   const [corrXMetric, setCorrXMetric] = useState<GpuMetricKey>('power');
   const [corrYMetric, setCorrYMetric] = useState<GpuMetricKey>('temperature');
+  // A power-only series (multinode DCGM bundle) has no temperature axis to
+  // default to; use the first other collected metric instead of an empty plot.
+  const effectiveCorrYMetric = useMemo<GpuMetricKey>(
+    () =>
+      availableMetrics.some((m) => m.key === corrYMetric)
+        ? corrYMetric
+        : (availableMetrics.find((m) => m.key !== corrXMetric)?.key ?? corrXMetric),
+    [availableMetrics, corrXMetric, corrYMetric],
+  );
+  const [display, setDisplay] = useState<TelemetryDisplayState>(DEFAULT_TELEMETRY_DISPLAY);
   const viewOptions = useMemo<SegmentedToggleOption<GpuMetricsView>[]>(
     () => [
       {
@@ -359,6 +372,52 @@ export default function GpuMetricsDisplay() {
     else setCorrYMetric(value as GpuMetricKey);
   }, []);
 
+  const legendElement = (
+    <ChartLegend
+      variant="sidebar"
+      onItemRemove={removeGpu}
+      legendItems={allGpuIndices.map((gpuIndex) => ({
+        name: `${t.chip} ${gpuIndex}`,
+        hw: String(gpuIndex),
+        label: `${t.chip} ${gpuIndex}`,
+        color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
+        isActive: visibleGpus.has(gpuIndex),
+        onClick: () => toggleGpu(gpuIndex),
+      }))}
+      isLegendExpanded={isLegendExpanded}
+      onExpandedChange={(expanded) => {
+        setIsLegendExpanded(expanded);
+        track('gpu_metrics_legend_expanded', { expanded });
+      }}
+      actions={
+        allGpusSelected
+          ? []
+          : [
+              {
+                id:
+                  chartView === 'correlation'
+                    ? 'gpu-metrics-reset-filter-2'
+                    : 'gpu-metrics-reset-filter',
+                label: t.resetFilter,
+                onClick: selectAllGpus,
+              },
+            ]
+      }
+      switches={[
+        {
+          id:
+            chartView === 'correlation' ? 'gpu-metrics-downsample-corr' : 'gpu-metrics-downsample',
+          label: t.downsample,
+          checked: downsample,
+          onCheckedChange: (c) => {
+            setDownsample(c);
+            track('gpu_metrics_downsample_toggled', { enabled: c });
+          },
+        },
+      ]}
+    />
+  );
+
   return (
     <section data-testid="gpu-metrics-display">
       <Card className="mb-4">
@@ -608,7 +667,7 @@ export default function GpuMetricsDisplay() {
                   <div className="space-y-1 min-w-0">
                     <Label htmlFor="gpu-metrics-correlation-y">{t.yAxis}</Label>
                     <Select
-                      value={corrYMetric}
+                      value={effectiveCorrYMetric}
                       onValueChange={(v) => handleCorrelationMetricChange('y', v)}
                     >
                       <SelectTrigger id="gpu-metrics-correlation-y" className="w-full">
@@ -627,6 +686,17 @@ export default function GpuMetricsDisplay() {
               </ControlPanel>
             )}
 
+            {chartView === 'chart' && (
+              <ControlPanel legend={t.displayControls} className="mb-3 no-export">
+                <TelemetryDisplayControls
+                  value={display}
+                  onChange={setDisplay}
+                  analyticsPrefix="gpu_metrics"
+                  idPrefix="gpu-metrics-display"
+                />
+              </ControlPanel>
+            )}
+
             {chartView === 'chart' && (
               <GpuMetricsChart
                 data={currentData}
@@ -634,6 +704,7 @@ export default function GpuMetricsDisplay() {
                 metricKey={selectedMetric}
                 artifactName={selectedArtifact}
                 maxPoints={downsample ? 2000 : Infinity}
+                display={display}
                 caption={
                   <>
                     <h2 className="text-lg font-semibold">
@@ -643,47 +714,7 @@ export default function GpuMetricsDisplay() {
                     <UnofficialDomainNotice />
                   </>
                 }
-                legendElement={
-                  <ChartLegend
-                    variant="sidebar"
-                    onItemRemove={removeGpu}
-                    legendItems={allGpuIndices.map((gpuIndex) => ({
-                      name: `${t.chip} ${gpuIndex}`,
-                      hw: String(gpuIndex),
-                      label: `${t.chip} ${gpuIndex}`,
-                      color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
-                      isActive: visibleGpus.has(gpuIndex),
-                      onClick: () => toggleGpu(gpuIndex),
-                    }))}
-                    isLegendExpanded={isLegendExpanded}
-                    onExpandedChange={(expanded) => {
-                      setIsLegendExpanded(expanded);
-                      track('gpu_metrics_legend_expanded', { expanded });
-                    }}
-                    actions={
-                      allGpusSelected
-                        ? []
-                        : [
-                            {
-                              id: 'gpu-metrics-reset-filter',
-                              label: t.resetFilter,
-                              onClick: selectAllGpus,
-                            },
-                          ]
-                    }
-                    switches={[
-                      {
-                        id: 'gpu-metrics-downsample',
-                        label: t.downsample,
-                        checked: downsample,
-                        onCheckedChange: (c) => {
-                          setDownsample(c);
-                          track('gpu_metrics_downsample_toggled', { enabled: c });
-                        },
-                      },
-                    ]}
-                  />
-                }
+                legendElement={legendElement}
               />
             )}
             {chartView === 'correlation' && (
@@ -691,7 +722,7 @@ export default function GpuMetricsDisplay() {
                 data={currentData}
                 visibleGpus={visibleGpus}
                 xMetric={corrXMetric}
-                yMetric={corrYMetric}
+                yMetric={effectiveCorrYMetric}
                 maxPoints={downsample ? 2000 : Infinity}
                 caption={
                   <>
@@ -699,47 +730,7 @@ export default function GpuMetricsDisplay() {
                     <UnofficialDomainNotice />
                   </>
                 }
-                legendElement={
-                  <ChartLegend
-                    variant="sidebar"
-                    onItemRemove={removeGpu}
-                    legendItems={allGpuIndices.map((gpuIndex) => ({
-                      name: `${t.chip} ${gpuIndex}`,
-                      hw: String(gpuIndex),
-                      label: `${t.chip} ${gpuIndex}`,
-                      color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
-                      isActive: visibleGpus.has(gpuIndex),
-                      onClick: () => toggleGpu(gpuIndex),
-                    }))}
-                    isLegendExpanded={isLegendExpanded}
-                    onExpandedChange={(expanded) => {
-                      setIsLegendExpanded(expanded);
-                      track('gpu_metrics_legend_expanded', { expanded });
-                    }}
-                    actions={
-                      allGpusSelected
-                        ? []
-                        : [
-                            {
-                              id: 'gpu-metrics-reset-filter-2',
-                              label: t.resetFilter,
-                              onClick: selectAllGpus,
-                            },
-                          ]
-                    }
-                    switches={[
-                      {
-                        id: 'gpu-metrics-downsample-corr',
-                        label: t.downsample,
-                        checked: downsample,
-                        onCheckedChange: (c) => {
-                          setDownsample(c);
-                          track('gpu_metrics_downsample_toggled', { enabled: c });
-                        },
-                      },
-                    ]}
-                  />
-                }
+                legendElement={legendElement}
               />
             )}
           </Card>
@@ -749,7 +740,11 @@ export default function GpuMetricsDisplay() {
             <h3 className="text-sm font-semibold mb-2">
               {t.perGpuStats} ({getGpuMetricLabel(metricConfig, locale)})
             </h3>
-            <GpuStatsTable data={currentData} metricKey={selectedMetric} />
+            <GpuStatsTable
+              data={currentData}
+              metricKey={selectedMetric}
+              storedStats={currentArtifact?.series?.stats}
+            />
           </Card>
         </>
       )}
diff --git a/packages/app/src/components/gpu-power/GpuStatsTable.tsx b/packages/app/src/components/gpu-power/GpuStatsTable.tsx
index 2d569786a..d301f5acb 100644
--- a/packages/app/src/components/gpu-power/GpuStatsTable.tsx
+++ b/packages/app/src/components/gpu-power/GpuStatsTable.tsx
@@ -1,9 +1,11 @@
 'use client';
 
 import React, { useMemo, useState } from 'react';
+import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
 
 import { track } from '@/lib/analytics';
 import { useLocale } from '@/lib/use-locale';
+import { storedGpuStatsForMetric } from './stored-gpu-stats';
 
 import {
   type GpuMetricKey,
@@ -16,18 +18,26 @@ import {
 interface GpuStatsTableProps {
   data: GpuMetricRow[];
   metricKey: GpuMetricKey;
+  /** Full-record digest; omit only for live artifacts without stored statistics. */
+  storedStats?: readonly GpuMetricStatRow[];
 }
 
 type SortCol = keyof GpuStats;
 
 const fmtStat = (v: number) => (v >= 1000 ? v.toFixed(0) : v.toFixed(1));
 
-const GpuStatsTable = React.memo(({ data, metricKey }: GpuStatsTableProps) => {
+const GpuStatsTable = React.memo(({ data, metricKey, storedStats }: GpuStatsTableProps) => {
   const locale = useLocale();
   const [sortCol, setSortCol] = useState<SortCol>('gpuIndex');
   const [sortAsc, setSortAsc] = useState(true);
 
-  const stats = useMemo(() => computeGpuStats(data, metricKey), [data, metricKey]);
+  const stats = useMemo(
+    () =>
+      storedStats === undefined
+        ? computeGpuStats(data, metricKey)
+        : storedGpuStatsForMetric(storedStats, metricKey),
+    [data, metricKey, storedStats],
+  );
   const metricConfig = ALL_METRIC_OPTIONS.find((m) => m.key === metricKey)!;
 
   const sorted = useMemo(
@@ -66,47 +76,54 @@ const GpuStatsTable = React.memo(({ data, metricKey }: GpuStatsTableProps) => {
   ];
 
   return (
-    <div className="overflow-x-auto">
-      <table className="w-full text-xs">
-        <thead>
-          <tr className="border-b">
-            {cols.map((c) => (
-              <th
-                key={c.key}
-                className="px-2 py-1.5 text-left font-medium text-muted-foreground"
-                aria-sort={sortCol === c.key ? (sortAsc ? 'ascending' : 'descending') : 'none'}
-              >
-                <button
-                  type="button"
-                  className="cursor-pointer select-none hover:text-foreground"
-                  onClick={() => handleSort(c.key)}
+    <div>
+      <p className="mb-2 text-xs text-muted-foreground" data-testid="gpu-stats-scope">
+        {locale === 'zh'
+          ? '全记录统计，包含服务启动与 warmup；不随图表所选时间窗口变化。'
+          : 'Full-record statistics include startup and warmup; the selected chart window does not change this table.'}
+      </p>
+      <div className="overflow-x-auto">
+        <table className="w-full text-xs">
+          <thead>
+            <tr className="border-b">
+              {cols.map((c) => (
+                <th
+                  key={c.key}
+                  className="px-2 py-1.5 text-left font-medium text-muted-foreground"
+                  aria-sort={sortCol === c.key ? (sortAsc ? 'ascending' : 'descending') : 'none'}
                 >
-                  {c.label}
-                  {c.key !== 'gpuIndex' && c.key !== 'count' ? ` (${metricConfig.unit})` : ''}
-                  {sortCol === c.key && (sortAsc ? ' \u2191' : ' \u2193')}
-                </button>
-              </th>
-            ))}
-          </tr>
-        </thead>
-        <tbody>
-          {sorted.map((s) => (
-            <tr key={s.gpuIndex} className="border-b border-border/50 hover:bg-muted/50">
-              <td className="px-2 py-1 font-medium">{s.gpuIndex}</td>
-              <td className="px-2 py-1">
-                {locale === 'zh' ? s.count.toLocaleString('zh-CN') : s.count.toLocaleString()}
-              </td>
-              <td className="px-2 py-1">{fmtStat(s.min)}</td>
-              <td className="px-2 py-1">{fmtStat(s.max)}</td>
-              <td className="px-2 py-1">{fmtStat(s.mean)}</td>
-              <td className="px-2 py-1">{fmtStat(s.median)}</td>
-              <td className="px-2 py-1">{fmtStat(s.p95)}</td>
-              <td className="px-2 py-1">{fmtStat(s.p99)}</td>
-              <td className="px-2 py-1">{fmtStat(s.stddev)}</td>
+                  <button
+                    type="button"
+                    className="cursor-pointer select-none hover:text-foreground"
+                    onClick={() => handleSort(c.key)}
+                  >
+                    {c.label}
+                    {c.key !== 'gpuIndex' && c.key !== 'count' ? ` (${metricConfig.unit})` : ''}
+                    {sortCol === c.key && (sortAsc ? ' \u2191' : ' \u2193')}
+                  </button>
+                </th>
+              ))}
             </tr>
-          ))}
-        </tbody>
-      </table>
+          </thead>
+          <tbody>
+            {sorted.map((s) => (
+              <tr key={s.gpuIndex} className="border-b border-border/50 hover:bg-muted/50">
+                <td className="px-2 py-1 font-medium">{s.gpuIndex}</td>
+                <td className="px-2 py-1">
+                  {locale === 'zh' ? s.count.toLocaleString('zh-CN') : s.count.toLocaleString()}
+                </td>
+                <td className="px-2 py-1">{fmtStat(s.min)}</td>
+                <td className="px-2 py-1">{fmtStat(s.max)}</td>
+                <td className="px-2 py-1">{fmtStat(s.mean)}</td>
+                <td className="px-2 py-1">{fmtStat(s.median)}</td>
+                <td className="px-2 py-1">{fmtStat(s.p95)}</td>
+                <td className="px-2 py-1">{fmtStat(s.p99)}</td>
+                <td className="px-2 py-1">{fmtStat(s.stddev)}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
     </div>
   );
 });
diff --git a/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx b/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
new file mode 100644
index 000000000..816de67e3
--- /dev/null
+++ b/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
@@ -0,0 +1,139 @@
+'use client';
+
+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 { track } from '@/lib/analytics';
+import { useLocale } from '@/lib/use-locale';
+
+import {
+  SMOOTHING_WINDOWS_S,
+  type SmoothingWindowS,
+  type TelemetryDisplayMode,
+  type TelemetryDisplayState,
+  type TelemetrySeriesMode,
+} from './telemetry-smoothing';
+
+const STRINGS = {
+  en: {
+    display: 'Display',
+    points: 'Points',
+    rolling: 'Rolling average',
+    window: 'Window',
+    windowOption: (s: number) => `${s} s`,
+    series: 'Lines',
+    chips: 'Per chip',
+    mean: 'Mean of chips',
+    both: 'Both',
+  },
+  zh: {
+    display: '显示方式',
+    points: '数据点',
+    rolling: '滚动平均',
+    window: '窗口',
+    windowOption: (s: number) => `${s} 秒`,
+    series: '曲线',
+    chips: '单芯片',
+    mean: '芯片均值',
+    both: '两者',
+  },
+} as const;
+
+interface Props {
+  value: TelemetryDisplayState;
+  onChange: (next: TelemetryDisplayState) => void;
+  /** Analytics event prefix, e.g. `gpu_metrics` → `gpu_metrics_display_mode_changed`. */
+  analyticsPrefix: string;
+  /** Prefix for control ids so two charts on one page do not collide. */
+  idPrefix: string;
+  className?: string;
+}
+
+/**
+ * Display-mode controls shared by the PowerX explorer and the per-point PowerX
+ * tab: raw samples vs. a time-window rolling average, and per-chip lines vs.
+ * the mean across the visible chips.
+ */
+export function TelemetryDisplayControls({
+  value,
+  onChange,
+  analyticsPrefix,
+  idPrefix,
+  className,
+}: Props) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+
+  const modeOptions: SegmentedToggleOption<TelemetryDisplayMode>[] = [
+    { value: 'points', label: t.points, testId: `${idPrefix}-mode-points` },
+    { value: 'rolling', label: t.rolling, testId: `${idPrefix}-mode-rolling` },
+  ];
+  const seriesOptions: SegmentedToggleOption<TelemetrySeriesMode>[] = [
+    { value: 'chips', label: t.chips, testId: `${idPrefix}-series-chips` },
+    { value: 'mean', label: t.mean, testId: `${idPrefix}-series-mean` },
+    { value: 'both', label: t.both, testId: `${idPrefix}-series-both` },
+  ];
+
+  return (
+    <div className={className} data-testid={`${idPrefix}-controls`}>
+      <div className="flex flex-wrap items-end gap-x-4 gap-y-3">
+        <div className="space-y-1">
+          <Label id={`${idPrefix}-mode-label`}>{t.display}</Label>
+          <SegmentedToggle
+            value={value.mode}
+            options={modeOptions}
+            role="group"
+            ariaLabel={t.display}
+            onValueChange={(mode) => {
+              track(`${analyticsPrefix}_display_mode_changed`, { mode });
+              onChange({ ...value, mode });
+            }}
+          />
+        </div>
+        {value.mode === 'rolling' && (
+          <div className="space-y-1">
+            <Label htmlFor={`${idPrefix}-window`}>{t.window}</Label>
+            <Select
+              value={String(value.windowS)}
+              onValueChange={(raw) => {
+                const windowS = Number(raw) as SmoothingWindowS;
+                track(`${analyticsPrefix}_smoothing_window_changed`, { windowS });
+                onChange({ ...value, windowS });
+              }}
+            >
+              <SelectTrigger id={`${idPrefix}-window`} className="w-24" size="sm">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {SMOOTHING_WINDOWS_S.map((s) => (
+                  <SelectItem key={s} value={String(s)}>
+                    {t.windowOption(s)}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+        )}
+        <div className="space-y-1">
+          <Label id={`${idPrefix}-series-label`}>{t.series}</Label>
+          <SegmentedToggle
+            value={value.series}
+            options={seriesOptions}
+            role="group"
+            ariaLabel={t.series}
+            onValueChange={(series) => {
+              track(`${analyticsPrefix}_series_mode_changed`, { series });
+              onChange({ ...value, series });
+            }}
+          />
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/packages/app/src/components/gpu-power/chart-data.test.ts b/packages/app/src/components/gpu-power/chart-data.test.ts
new file mode 100644
index 000000000..f7912f47c
--- /dev/null
+++ b/packages/app/src/components/gpu-power/chart-data.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { buildCorrelationData, buildGroupedData, buildTelemetryData } from './chart-data';
+import type { GpuMetricRow } from './types';
+
+const rows: GpuMetricRow[] = [
+  { timestamp: '2026-09-21T00:00:00Z', index: 0, power: 100 },
+  { timestamp: '2026-09-21T00:00:02Z', index: 1, power: 200, temperature: 40 },
+  { timestamp: '2026-09-21T00:00:03Z', index: 1, power: 250 },
+  { timestamp: '2026-09-21T00:00:04Z', index: 1, power: 0, temperature: 0 },
+];
+
+describe('shared telemetry chart preparation', () => {
+  it('keeps the whole-series time origin when a chip is hidden and skips missing readings', () => {
+    const { t0Ms, groups } = buildTelemetryData(rows, new Set([1]), 'temperature');
+    expect(t0Ms).toBe(Date.parse(rows[0].timestamp));
+    expect(groups.get(1)?.map(({ seconds, ms, value }) => ({ seconds, ms, value }))).toEqual([
+      { seconds: 2, ms: t0Ms + 2000, value: 40 },
+      { seconds: 4, ms: t0Ms + 4000, value: 0 },
+    ]);
+    expect(groups.has(0)).toBe(false);
+    expect(buildGroupedData(rows, new Set([1]), 'temperature').get(1)).toEqual([
+      { seconds: 2, value: 40, gpuIndex: 1, raw: rows[1] },
+      { seconds: 4, value: 0, gpuIndex: 1, raw: rows[3] },
+    ]);
+  });
+
+  it('omits unsampled correlation metrics while retaining measured zeros', () => {
+    expect(buildCorrelationData(rows, new Set([0, 1]), 'power', 'temperature')).toEqual([
+      { x: 200, y: 40, gpuIndex: 1, raw: rows[1] },
+      { x: 0, y: 0, gpuIndex: 1, raw: rows[3] },
+    ]);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/chart-data.ts b/packages/app/src/components/gpu-power/chart-data.ts
index 7c0aef074..51db731f9 100644
--- a/packages/app/src/components/gpu-power/chart-data.ts
+++ b/packages/app/src/components/gpu-power/chart-data.ts
@@ -1,10 +1,16 @@
 import type { GpuMetricKey, GpuMetricRow } from './types';
 export interface ParsedPoint {
   seconds: number;
+  /** Absolute sample time in ms; smoothing and alignment work in this space. */
+  ms: number;
   value: number;
   gpuIndex: number;
-  raw: GpuMetricRow;
+  /** The raw sample behind this point; null once the value has been averaged. */
+  raw: GpuMetricRow | null;
+  /** For the mean line: how many chips contributed at this timestamp. */
+  count?: number;
 }
+
 function parseTimestamp(raw: string): Date | null {
   const isoDate = new Date(raw);
   if (!isNaN(isoDate.getTime())) return isoDate;
@@ -15,28 +21,33 @@ function parseTimestamp(raw: string): Date | null {
   return null;
 }
 
-export function buildGroupedData(
+export function buildTelemetryData(
   data: GpuMetricRow[],
   visibleGpus: Set<number>,
   metricKey: GpuMetricKey,
-): Map<number, ParsedPoint[]> {
+): { t0Ms: number; groups: Map<number, ParsedPoint[]> } {
+  // t=0 is the first sample of the whole series, not of the visible chips, so
+  // hiding a chip never shifts the time axis under the remaining lines.
   let minTime = Infinity;
   const parsed: { row: GpuMetricRow; ms: number }[] = [];
   for (const row of data) {
-    if (!visibleGpus.has(row.index)) continue;
     const time = parseTimestamp(row.timestamp);
     if (!time) continue;
     const ms = time.getTime();
-    parsed.push({ row, ms });
     if (ms < minTime) minTime = ms;
+    if (visibleGpus.has(row.index)) parsed.push({ row, ms });
   }
 
   const groups = new Map<number, ParsedPoint[]>();
   for (const { row, ms } of parsed) {
+    const value = row[metricKey];
+    // A metric the collector never sampled has no point, not a zero.
+    if (value === undefined) continue;
     if (!groups.has(row.index)) groups.set(row.index, []);
     groups.get(row.index)!.push({
       seconds: (ms - minTime) / 1000,
-      value: row[metricKey] ?? 0,
+      ms,
+      value,
       gpuIndex: row.index,
       raw: row,
     });
@@ -44,7 +55,19 @@ export function buildGroupedData(
   for (const points of groups.values()) {
     points.sort((a, b) => a.seconds - b.seconds);
   }
-  return groups;
+  return { t0Ms: minTime, groups };
+}
+
+/** Keep the read-only view's serialized point shape while sharing chart preparation. */
+export function buildGroupedData(
+  data: GpuMetricRow[],
+  visibleGpus: Set<number>,
+  metricKey: GpuMetricKey,
+) {
+  const { groups } = buildTelemetryData(data, visibleGpus, metricKey);
+  return new Map(
+    [...groups].map(([index, points]) => [index, points.map(({ ms: _ms, ...point }) => point)]),
+  );
 }
 
 export function buildCorrelationData(
@@ -55,5 +78,9 @@ export function buildCorrelationData(
 ) {
   return data
     .filter((r) => visibleGpus.has(r.index))
-    .map((r) => ({ x: r[xMetric] ?? 0, y: r[yMetric] ?? 0, gpuIndex: r.index, raw: r }));
+    .flatMap((r) => {
+      const x = r[xMetric];
+      const y = r[yMetric];
+      return x === undefined || y === undefined ? [] : [{ x, y, gpuIndex: r.index, raw: r }];
+    });
 }
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
new file mode 100644
index 000000000..c181eac2d
--- /dev/null
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+
+import { meanAcrossSeries, rollingTimeAverage, type TimedSample } from './telemetry-smoothing';
+
+const T0 = Date.parse('2026-09-15T21:36:14.107Z');
+
+/** One sample per second starting at T0, values from `values`. */
+function everySecond(values: number[], offsetMs = 0): TimedSample[] {
+  return values.map((value, i) => ({ ms: T0 + offsetMs + i * 1000, value }));
+}
+
+describe('rollingTimeAverage', () => {
+  it('averages a centered window and shrinks it at the series edges', () => {
+    // 1 s cadence, 2 s window => each sample sees itself and its immediate neighbours.
+    const out = rollingTimeAverage(everySecond([100, 200, 600, 200, 100]), 2000);
+    expect(out.map((p) => p.value)).toEqual([150, 300, 1000 / 3, 300, 150]);
+    expect(out.map((p) => p.ms)).toEqual(everySecond([0, 0, 0, 0, 0]).map((p) => p.ms));
+  });
+});
+
+describe('meanAcrossSeries', () => {
+  it('picks the nearest sample when a chip dropped a row', () => {
+    const chip0 = everySecond([0, 0, 0, 0]);
+    const chip1: TimedSample[] = [
+      { ms: T0, value: 10 },
+      // row at T0 + 1000 dropped
+      { ms: T0 + 2000, value: 30 },
+      { ms: T0 + 3000, value: 40 },
+    ];
+    const out = meanAcrossSeries([chip0, chip1], 400);
+    expect(out.map((p) => p.count)).toEqual([2, 1, 2, 2]);
+    expect(out.map((p) => p.value)).toEqual([5, 0, 15, 20]);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
new file mode 100644
index 000000000..a9ec9a307
--- /dev/null
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
@@ -0,0 +1,160 @@
+/**
+ * Pure time-series helpers for the PowerX telemetry charts. They operate on
+ * absolute millisecond timestamps so irregular sampling (dropped rows, a few
+ * ms of skew between chips) is handled by time, not by sample index.
+ */
+
+export interface TimedSample {
+  /** Absolute timestamp in milliseconds since the Unix epoch. */
+  ms: number;
+  value: number;
+}
+
+/** Rolling-average window choices offered by the chart controls, in seconds. */
+export const SMOOTHING_WINDOWS_S = [10, 30, 60, 300] as const;
+export type SmoothingWindowS = (typeof SMOOTHING_WINDOWS_S)[number];
+
+export interface AggregatedSample extends TimedSample {
+  /** Number of chips that contributed a sample within tolerance. */
+  count: number;
+}
+
+export type TelemetryDisplayMode = 'points' | 'rolling';
+/** Per-chip lines, one mean line across the visible chips, or both. */
+export type TelemetrySeriesMode = 'chips' | 'mean' | 'both';
+
+export interface TelemetryDisplayState {
+  mode: TelemetryDisplayMode;
+  windowS: SmoothingWindowS;
+  series: TelemetrySeriesMode;
+}
+
+/** Rolling average is the default: at 1 s cadence the raw points read as noise. */
+export const DEFAULT_TELEMETRY_DISPLAY: TelemetryDisplayState = {
+  mode: 'rolling',
+  windowS: 30,
+  series: 'chips',
+};
+
+/**
+ * Centered time-window mean. Each output sample averages every input sample
+ * whose timestamp lies within `windowMs / 2` (inclusive) of its own, so the
+ * smoothed line stays time-aligned with the raw one instead of lagging by half
+ * a window as a trailing average would. Window edges are inclusive on both
+ * sides; samples near the start or end of the series average over the shorter
+ * one-sided neighbourhood that exists.
+ *
+ * `samples` must be sorted by `ms` ascending. O(n) via prefix sums.
+ */
+export function rollingTimeAverage(
+  samples: readonly TimedSample[],
+  windowMs: number,
+): TimedSample[] {
+  if (samples.length === 0) return [];
+  if (!(windowMs > 0)) return samples.map(({ ms, value }) => ({ ms, value }));
+  const half = windowMs / 2;
+  const n = samples.length;
+  const prefix = new Float64Array(n + 1);
+  for (let i = 0; i < n; i += 1) prefix[i + 1] = prefix[i]! + samples[i]!.value;
+
+  const out: TimedSample[] = Array.from({ length: n });
+  let lo = 0;
+  let hi = 0;
+  for (let i = 0; i < n; i += 1) {
+    const center = samples[i]!.ms;
+    while (samples[lo]!.ms < center - half) lo += 1;
+    while (hi < n && samples[hi]!.ms <= center + half) hi += 1;
+    const count = hi - lo;
+    out[i] = { ms: center, value: (prefix[hi]! - prefix[lo]!) / count };
+  }
+  return out;
+}
+
+/**
+ * Median gap between consecutive samples, in ms. Used as the alignment
+ * tolerance when averaging chips that were polled a few ms apart. Falls back
+ * to `fallbackMs` when fewer than two distinct timestamps exist.
+ */
+export function estimateSampleIntervalMs(
+  samples: readonly TimedSample[],
+  fallbackMs = 1000,
+): number {
+  const gaps: number[] = [];
+  for (let i = 1; i < samples.length; i += 1) {
+    const gap = samples[i]!.ms - samples[i - 1]!.ms;
+    if (gap > 0) gaps.push(gap);
+  }
+  if (gaps.length === 0) return fallbackMs;
+  gaps.sort((a, b) => a - b);
+  return gaps[Math.floor(gaps.length / 2)]!;
+}
+
+/**
+ * Mean across several chips at each timestamp of the reference chip (the one
+ * with the most samples, first on ties). For every reference sample each other
+ * chip contributes its nearest sample if that sample lies within
+ * `toleranceMs`; chips with no sample that close are left out of that mean
+ * rather than interpolated, and `count` records how many contributed.
+ *
+ * Every inner array must be sorted by `ms` ascending.
+ */
+export function meanAcrossSeries(
+  series: readonly (readonly TimedSample[])[],
+  toleranceMs: number,
+): AggregatedSample[] {
+  const populated = series.filter((s) => s.length > 0);
+  if (populated.length === 0) return [];
+  let reference = populated[0]!;
+  for (const s of populated) if (s.length > reference.length) reference = s;
+  const others = populated.filter((s) => s !== reference);
+  const cursors: number[] = Array.from({ length: others.length }, () => 0);
+  const tolerance = Math.max(0, toleranceMs);
+
+  return reference.map((ref) => {
+    let sum = ref.value;
+    let count = 1;
+    for (let k = 0; k < others.length; k += 1) {
+      const other = others[k]!;
+      let cursor = cursors[k]!;
+      while (
+        cursor + 1 < other.length &&
+        Math.abs(other[cursor + 1]!.ms - ref.ms) <= Math.abs(other[cursor]!.ms - ref.ms)
+      ) {
+        cursor += 1;
+      }
+      cursors[k] = cursor;
+      const candidate = other[cursor]!;
+      if (Math.abs(candidate.ms - ref.ms) <= tolerance) {
+        sum += candidate.value;
+        count += 1;
+      }
+    }
+    return { ms: ref.ms, value: sum / count, count };
+  });
+}
+
+/**
+ * Convert a relative-seconds series (`t` from its own start) to absolute
+ * milliseconds so it can share an x-axis with wall-clock telemetry.
+ */
+export function toAbsoluteMs(
+  points: readonly { t: number; value: number }[],
+  originMs: number,
+): TimedSample[] {
+  return points.map((p) => ({ ms: originMs + p.t * 1000, value: p.value }));
+}
+
+/** Sample nearest to `ms` (earlier one on a tie), or null when the series is empty. */
+export function nearestSample(samples: readonly TimedSample[], ms: number): TimedSample | null {
+  if (samples.length === 0) return null;
+  let lo = 0;
+  let hi = samples.length - 1;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (samples[mid]!.ms < ms) lo = mid + 1;
+    else hi = mid;
+  }
+  const after = samples[lo]!;
+  const before = lo > 0 ? samples[lo - 1]! : after;
+  return Math.abs(before.ms - ms) <= Math.abs(after.ms - ms) ? before : after;
+}
diff --git a/packages/app/src/components/gpu-power/types.test.ts b/packages/app/src/components/gpu-power/types.test.ts
index cefd8d6ef..1d741a5fa 100644
--- a/packages/app/src/components/gpu-power/types.test.ts
+++ b/packages/app/src/components/gpu-power/types.test.ts
@@ -3,11 +3,9 @@ import { describe, expect, it } from 'vitest';
 import {
   ALL_METRIC_OPTIONS,
   computeGpuStats,
-  detectAnomalies,
   detectTdpFromArtifactName,
   getAvailableMetrics,
   type GpuMetricRow,
-  GPU_METRIC_OPTIONS,
   parseCsvData,
 } from './types';
 
@@ -47,49 +45,16 @@ describe('parseCsvData', () => {
     expect(result[1].power).toBe(76.08);
   });
 
-  it('parses CSV with bare numeric values (no unit suffixes)', () => {
-    const csv = `${CSV_HEADER}
-2024-01-15T10:00:00Z, 0, 250.5, 72, 1980, 1593, 95, 80
-2024-01-15T10:00:00Z, 1, 300.2, 68, 1950, 1593, 88, 75`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(2);
-    expect(result[0].power).toBe(250.5);
-    expect(result[0].smClock).toBe(1980);
-    expect(result[1].power).toBe(300.2);
-  });
-
   it('returns empty array for header-only CSV', () => {
     expect(parseCsvData(CSV_HEADER)).toEqual([]);
   });
 
-  it('returns empty array for empty string', () => {
-    expect(parseCsvData('')).toEqual([]);
-  });
-
-  it('skips rows with insufficient columns', () => {
-    const csv = `${CSV_HEADER}
-2026/03/07 00:20:37.071, 0, 76.78 W
-2026/03/07 00:20:37.071, 1, 76.08 W, 29, 345 MHz, 3201 MHz, 0 %, 0 %`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(1);
-    expect(result[0].index).toBe(1);
-  });
-
   it('skips rows with NaN values', () => {
     const csv = `${CSV_HEADER}
 2026/03/07 00:20:37.071, abc, 76.78 W, 30, 345 MHz, 3201 MHz, 0 %, 0 %`;
     expect(parseCsvData(csv)).toEqual([]);
   });
 
-  it('trims whitespace from values', () => {
-    const csv = `${CSV_HEADER}
- 2026/03/07 00:20:37.071 , 0 , 76.78 W , 30 , 345 MHz , 3201 MHz , 0 % , 0 % `;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(1);
-    expect(result[0].timestamp).toBe('2026/03/07 00:20:37.071');
-    expect(result[0].power).toBe(76.78);
-  });
-
   it('handles Windows-style line endings', () => {
     const csv = `${CSV_HEADER}\r\n2026/03/07 00:20:37.071, 0, 76.78 W, 30, 345 MHz, 3201 MHz, 0 %, 0 %\r\n`;
     const result = parseCsvData(csv);
@@ -97,19 +62,6 @@ describe('parseCsvData', () => {
     expect(result[0].power).toBe(76.78);
   });
 
-  it('parses multiple timestamps for same GPU correctly', () => {
-    const csv = `${CSV_HEADER}
-2026/03/07 00:20:37.071, 0, 76.78 W, 30, 345 MHz, 3201 MHz, 0 %, 0 %
-2026/03/07 00:20:38.076, 0, 76.70 W, 30, 345 MHz, 3201 MHz, 0 %, 0 %
-2026/03/07 00:20:39.076, 0, 80.49 W, 31, 345 MHz, 3201 MHz, 0 %, 0 %`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(3);
-    expect(result[0].power).toBe(76.78);
-    expect(result[1].power).toBe(76.7);
-    expect(result[2].power).toBe(80.49);
-    expect(result[2].temperature).toBe(31);
-  });
-
   it('ignores extra columns beyond the expected 8', () => {
     const csv = `${CSV_HEADER}
 2026/03/07 00:20:37.071, 0, 76.78, 30, 345, 3201, 0, 0, extra1, extra2`;
@@ -119,21 +71,6 @@ describe('parseCsvData', () => {
     expect(result[0].memUtil).toBe(0);
   });
 
-  it('handles 8-GPU real-world scenario', () => {
-    const lines = [];
-    for (let gpu = 0; gpu < 8; gpu++) {
-      lines.push(
-        `2026/03/07 00:20:37.071, ${gpu}, ${300 + gpu * 10}, ${65 + gpu}, 1980, 1593, 95, 80`,
-      );
-    }
-    const csv = `${CSV_HEADER}\n${lines.join('\n')}`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(8);
-    expect(result[7].index).toBe(7);
-    expect(result[7].power).toBe(370);
-    expect(result[7].temperature).toBe(72);
-  });
-
   // --- AMD amd-smi format ---
 
   it('auto-detects and parses AMD amd-smi CSV format', () => {
@@ -178,18 +115,6 @@ describe('parseCsvData', () => {
     expect(result[0].temperature).toBe(38); // falls back to edge
   });
 
-  it('AMD: handles quoted array fields with embedded commas', () => {
-    const amdHeader =
-      'timestamp,gpu,gfx_activity,umc_activity,mm_activity,vcn_activity,jpeg_activity,socket_power,gfx_0_clk,mem_0_clk,edge,hotspot,mem';
-    const csv = `${amdHeader}
-1772939616,0,95,80,N/A,"['N/A', 'N/A', 'N/A', 'N/A']","['N/A', 'N/A']",350,1980,901,38,72,65`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(1);
-    expect(result[0].power).toBe(350);
-    expect(result[0].smClock).toBe(1980);
-    expect(result[0].temperature).toBe(72);
-  });
-
   it('AMD: parses real-world amd-smi row with all columns', () => {
     // Full amd-smi header with ~100+ columns
     const amdHeader =
@@ -207,26 +132,6 @@ describe('parseCsvData', () => {
     expect(result[0].temperature).toBe(40); // hotspot
   });
 
-  it('AMD: parses 8 GPUs from same timestamp', () => {
-    const amdHeader =
-      'timestamp,gpu,gfx_activity,umc_activity,socket_power,gfx_0_clk,mem_0_clk,edge,hotspot,mem';
-    const lines = [];
-    for (let gpu = 0; gpu < 8; gpu++) {
-      lines.push(
-        `1772939616,${gpu},${90 + gpu},${70 + gpu},${300 + gpu * 5},${1900 + gpu * 10},901,${35 + gpu},${60 + gpu},${50 + gpu}`,
-      );
-    }
-    const csv = `${amdHeader}\n${lines.join('\n')}`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(8);
-    expect(result[0].index).toBe(0);
-    expect(result[7].index).toBe(7);
-    expect(result[7].power).toBe(335);
-    expect(result[7].gpuUtil).toBe(97);
-    expect(result[7].temperature).toBe(67); // hotspot
-    expect(result[7].smClock).toBe(1970);
-  });
-
   it('AMD: skips rows with N/A power', () => {
     const amdHeader =
       'timestamp,gpu,gfx_activity,umc_activity,socket_power,gfx_0_clk,mem_0_clk,edge,hotspot,mem';
@@ -245,7 +150,7 @@ describe('parseCsvData', () => {
 1772939616,0,0,0,135,133,901,N/A,N/A,41`;
     const result = parseCsvData(csv);
     expect(result).toHaveLength(1);
-    expect(result[0].temperature).toBe(0); // defaults to 0 when both are N/A
+    expect(result[0].temperature).toBeUndefined();
   });
 
   it('AMD: populates all AMD-specific metric fields', () => {
@@ -279,17 +184,6 @@ describe('parseCsvData', () => {
     expect(result[0].fclk).toBe(1300);
     expect(result[0].socClk).toBe(28);
   });
-
-  it('NVIDIA: does not have AMD-specific fields', () => {
-    const csv = `${CSV_HEADER}
-2026/03/07 00:20:37.071, 0, 300, 65, 1980, 1593, 95, 80`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(1);
-    expect(result[0].edgeTemp).toBeUndefined();
-    expect(result[0].memTemp).toBeUndefined();
-    expect(result[0].gfxVoltage).toBeUndefined();
-    expect(result[0].fclk).toBeUndefined();
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -297,22 +191,6 @@ describe('parseCsvData', () => {
 // ---------------------------------------------------------------------------
 
 describe('getAvailableMetrics', () => {
-  it('returns only common metrics for NVIDIA data', () => {
-    const nvidiaRow: GpuMetricRow = {
-      timestamp: '2026/03/07 00:20:37.071',
-      index: 0,
-      power: 300,
-      temperature: 65,
-      smClock: 1980,
-      memClock: 1593,
-      gpuUtil: 95,
-      memUtil: 80,
-    };
-    const metrics = getAvailableMetrics([nvidiaRow]);
-    const keys = metrics.map((m) => m.key);
-    expect(keys).toEqual(['power', 'temperature', 'smClock', 'memClock', 'gpuUtil', 'memUtil']);
-  });
-
   it('returns common + AMD metrics for AMD data', () => {
     const amdRow: GpuMetricRow = {
       timestamp: '2026-03-07T00:00:00Z',
@@ -364,11 +242,6 @@ describe('getAvailableMetrics', () => {
     expect(keys).not.toContain('gfxVoltage');
     expect(keys).not.toContain('fclk');
   });
-
-  it('returns common metrics for empty data', () => {
-    const metrics = getAvailableMetrics([]);
-    expect(metrics.length).toBe(6);
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -383,54 +256,14 @@ describe('detectTdpFromArtifactName', () => {
     expect(result).toEqual({ sku: 'H200', tdp: 700 });
   });
 
-  it('detects H100 from artifact name', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp8_h100-sxm_0');
-    expect(result).toEqual({ sku: 'H100', tdp: 700 });
-  });
-
   it('detects GB200 without matching B200', () => {
     const result = detectTdpFromArtifactName('gpu_metrics_model_fp4_gb200-nvl72_0');
     expect(result).toEqual({ sku: 'GB200', tdp: 1200 });
   });
 
-  it('detects GB300 without matching B300', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp4_gb300-nvl72_0');
-    expect(result).toEqual({ sku: 'GB300', tdp: 1400 });
-  });
-
-  it('detects B200 when no GB prefix', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp4_b200-sxm_0');
-    expect(result).toEqual({ sku: 'B200', tdp: 1000 });
-  });
-
-  it('detects B300 when no GB prefix', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp4_b300-sxm_0');
-    expect(result).toEqual({ sku: 'B300', tdp: 1200 });
-  });
-
-  it('detects MI300X from artifact name', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp8_mi300x_0');
-    expect(result).toEqual({ sku: 'MI300X', tdp: 750 });
-  });
-
-  it('detects MI325X from artifact name', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp8_mi325x_0');
-    expect(result).toEqual({ sku: 'MI325X', tdp: 1000 });
-  });
-
-  it('detects MI355X from artifact name', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp4_mi355x_0');
-    expect(result).toEqual({ sku: 'MI355X', tdp: 1400 });
-  });
-
   it('returns null for unrecognized GPU', () => {
     expect(detectTdpFromArtifactName('gpu_metrics_model_fp8_unknown_0')).toBeNull();
   });
-
-  it('is case-insensitive', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp8_H200-SXM_0');
-    expect(result).toEqual({ sku: 'H200', tdp: 700 });
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -451,187 +284,11 @@ function makeRow(
   };
 }
 
-// ---------------------------------------------------------------------------
-// detectAnomalies
-// ---------------------------------------------------------------------------
-
-describe('detectAnomalies', () => {
-  it('returns empty array for empty data', () => {
-    expect(detectAnomalies([], 'power')).toEqual([]);
-  });
-
-  it('detects statistical outliers via MAD', () => {
-    const rows: GpuMetricRow[] = [];
-    for (let i = 0; i < 10; i++) {
-      rows.push(
-        makeRow({
-          timestamp: `2026/03/07 00:20:${37 + i}.000`,
-          index: 0,
-          power: i === 9 ? 600 : 300 + (i % 3),
-        }),
-      );
-    }
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'statistical')).toBe(true);
-    const stat = anomalies.find((a) => a.type === 'statistical')!;
-    expect(stat.gpuIndex).toBe(0);
-    expect(stat.value).toBe(600);
-  });
-
-  it('detects thermal throttle above 83°C', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, temperature: 70 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'thermal')).toBe(true);
-    const thermal = anomalies.find((a) => a.type === 'thermal')!;
-    expect(thermal.value).toBe(85);
-  });
-
-  it('detects near-TDP power draw', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 300 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 650 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, power: 300 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power', 'gpu_metrics_h200_test');
-    expect(anomalies.some((a) => a.type === 'near_tdp')).toBe(true);
-  });
-
-  it('does not flag near-TDP without artifact name', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 650 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 650 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, power: 650 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'near_tdp')).toBe(false);
-  });
-
-  it('detects utilization drop to 0% after high usage', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, gpuUtil: 95 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, gpuUtil: 0 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, gpuUtil: 90 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'util_drop')).toBe(true);
-  });
-
-  it('does not flag all-identical values as anomalies', () => {
-    const rows: GpuMetricRow[] = [];
-    for (let i = 0; i < 10; i++) {
-      rows.push(makeRow({ timestamp: `2026/03/07 00:20:${37 + i}.000`, index: 0, power: 300 }));
-    }
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.filter((a) => a.type === 'statistical')).toHaveLength(0);
-  });
-
-  it('deduplicates anomalies at same second', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:37.500', index: 0, temperature: 86 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, temperature: 65 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    const thermals = anomalies.filter(
-      (a) => a.type === 'thermal' && a.gpuIndex === 0 && Math.round(a.seconds) === 0,
-    );
-    expect(thermals).toHaveLength(1);
-  });
-
-  it('detects clock drop when SM clock drops >30% below median', () => {
-    const rows: GpuMetricRow[] = [];
-    // 9 rows at 1980 MHz, 1 row at 1000 MHz (49% drop)
-    for (let i = 0; i < 10; i++) {
-      rows.push(
-        makeRow({
-          timestamp: `2026/03/07 00:20:${37 + i}.000`,
-          index: 0,
-          smClock: i === 5 ? 1000 : 1980,
-        }),
-      );
-    }
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'clock_drop')).toBe(true);
-    const drop = anomalies.find((a) => a.type === 'clock_drop')!;
-    expect(drop.value).toBe(1000);
-  });
-
-  it('detects anomalies independently per GPU', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 1, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 1, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 1, temperature: 65 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'temperature');
-    const thermals = anomalies.filter((a) => a.type === 'thermal');
-    expect(thermals).toHaveLength(2);
-    expect(thermals.map((a) => a.gpuIndex).toSorted()).toEqual([0, 1]);
-  });
-
-  it('skips GPU groups with fewer than 3 samples for MAD detection', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 100 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 900 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    // Only 2 samples — MAD-based statistical detection should be skipped
-    expect(anomalies.filter((a) => a.type === 'statistical')).toHaveLength(0);
-  });
-
-  it('anomaly message includes GPU index and metric value', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 2, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 2, temperature: 90 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 2, temperature: 65 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'temperature');
-    const thermal = anomalies.find((a) => a.type === 'thermal')!;
-    expect(thermal.message).toContain('Chip 2');
-    expect(thermal.message).toContain('90');
-    expect(thermal.message).toContain('83');
-  });
-
-  it('does not flag util_drop when previous utilization is <= 50%', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, gpuUtil: 40 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, gpuUtil: 0 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, gpuUtil: 50 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'util_drop')).toBe(false);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // computeGpuStats
 // ---------------------------------------------------------------------------
 
 describe('computeGpuStats', () => {
-  it('computes correct statistics for a single GPU', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 100 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 200 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, power: 300 }),
-      makeRow({ timestamp: '2026/03/07 00:20:40.000', index: 0, power: 400 }),
-      makeRow({ timestamp: '2026/03/07 00:20:41.000', index: 0, power: 500 }),
-    ];
-    const stats = computeGpuStats(rows, 'power');
-    expect(stats).toHaveLength(1);
-    expect(stats[0].gpuIndex).toBe(0);
-    expect(stats[0].count).toBe(5);
-    expect(stats[0].min).toBe(100);
-    expect(stats[0].max).toBe(500);
-    expect(stats[0].mean).toBe(300);
-    expect(stats[0].median).toBe(300);
-  });
-
   it('returns stats per GPU sorted by index', () => {
     const rows = [
       makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 1, power: 200 }),
@@ -695,23 +352,3 @@ describe('computeGpuStats', () => {
     expect(stats[0].stddev).toBe(0);
   });
 });
-
-// ---------------------------------------------------------------------------
-// GPU_METRIC_OPTIONS
-// ---------------------------------------------------------------------------
-
-describe('GPU_METRIC_OPTIONS', () => {
-  it('covers all 6 GpuMetricKey values', () => {
-    const keys = GPU_METRIC_OPTIONS.map((m) => m.key);
-    expect(keys).toEqual(['power', 'temperature', 'smClock', 'memClock', 'gpuUtil', 'memUtil']);
-  });
-
-  it('each option has non-empty label, unit, and yAxisLabel', () => {
-    for (const opt of GPU_METRIC_OPTIONS) {
-      expect(opt.label.length).toBeGreaterThan(0);
-      expect(opt.unit.length).toBeGreaterThan(0);
-      expect(opt.yAxisLabel.length).toBeGreaterThan(0);
-      expect(opt.yAxisLabel).toContain(opt.unit);
-    }
-  });
-});
diff --git a/packages/app/src/components/gpu-power/types.ts b/packages/app/src/components/gpu-power/types.ts
index 814eb2bb5..6c82d5616 100644
--- a/packages/app/src/components/gpu-power/types.ts
+++ b/packages/app/src/components/gpu-power/types.ts
@@ -1,24 +1,16 @@
 import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
-
-export interface GpuMetricRow {
-  timestamp: string;
-  index: number;
-  power: number;
-  temperature: number;
-  smClock: number;
-  memClock: number;
-  gpuUtil: number;
-  memUtil: number;
-  // AMD-specific optional fields
-  edgeTemp?: number;
-  memTemp?: number;
-  gfxVoltage?: number;
-  socVoltage?: number;
-  memVoltage?: number;
-  fclk?: number;
-  socClk?: number;
-  mmActivity?: number;
-}
+import {
+  parseAmdTimestamp,
+  parseNvidiaTimestamp,
+  splitCsvLine,
+} from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
+import type {
+  GpuMetricSampleRow,
+  GpuMetricSeries,
+  GpuMetricStatRow,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+export type GpuMetricRow = GpuMetricSampleRow;
 
 export interface GpuPowerRunInfo {
   id: number;
@@ -34,6 +26,8 @@ export interface GpuPowerRunInfo {
 export interface GpuMetricsArtifact {
   name: string;
   data: GpuMetricRow[];
+  /** Only database-backed artifacts carry the full-record digest. */
+  series?: Omit<GpuMetricSeries, 'data'>;
 }
 
 export interface GpuPowerApiResponse {
@@ -199,17 +193,24 @@ export const ALL_METRIC_OPTIONS: GpuMetricConfig[] = [...GPU_METRIC_OPTIONS, ...
 
 /**
  * Returns the metric options that have data in the given dataset.
- * AMD-specific metrics are only shown when at least one row has a non-undefined value.
+ * A metric is shown only when at least one row has a finite reading.
  */
 export function getAvailableMetrics(data: GpuMetricRow[]): GpuMetricConfig[] {
   if (data.length === 0) return GPU_METRIC_OPTIONS;
-  return ALL_METRIC_OPTIONS.filter((m) => data.some((row) => row[m.key] !== undefined));
+  return ALL_METRIC_OPTIONS.filter((m) => data.some((row) => Number.isFinite(row[m.key])));
 }
 
 /**
  * Detect GPU SKU from an artifact name and return its TDP in watts.
  * Artifact names look like: gpu_metrics_dsr1_1k8k_fp8_sglang_tp8_..._h200-nb_0
  */
+/** TDP for a known hardware key, e.g. the benchmark point's own `hardware`. */
+export function tdpForHardware(hardware: string | undefined): { sku: string; tdp: number } | null {
+  const key = hardware?.toLowerCase();
+  const entry = key ? HW_REGISTRY[key] : undefined;
+  return entry ? { sku: key!.toUpperCase(), tdp: entry.tdp } : null;
+}
+
 export function detectTdpFromArtifactName(
   artifactName: string,
 ): { sku: string; tdp: number } | null {
@@ -224,21 +225,6 @@ export function detectTdpFromArtifactName(
   return null;
 }
 
-export interface Anomaly {
-  type: 'statistical' | 'thermal' | 'near_tdp' | 'clock_drop' | 'util_drop';
-  label: string;
-  gpuIndex: number;
-  seconds: number;
-  value: number;
-  message: string;
-}
-
-function median(values: number[]): number {
-  const sorted = [...values].toSorted((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-}
-
 function parseTimestampToMs(raw: string): number | null {
   const d = new Date(raw);
   if (!isNaN(d.getTime())) return d.getTime();
@@ -247,158 +233,6 @@ function parseTimestampToMs(raw: string): number | null {
   return null;
 }
 
-/**
- * Detect anomalies in GPU metrics data using MAD-based Modified Z-score
- * (per NIST/Iglewicz & Hoaglin, threshold 3.5) plus domain-specific GPU thresholds.
- */
-export function detectAnomalies(
-  data: GpuMetricRow[],
-  metricKey: GpuMetricKey,
-  artifactName?: string,
-): Anomaly[] {
-  if (data.length === 0) return [];
-
-  const anomalies: Anomaly[] = [];
-  const tdpInfo = artifactName ? detectTdpFromArtifactName(artifactName) : null;
-
-  // Find earliest timestamp for seconds calculation
-  let minTime = Infinity;
-  for (const row of data) {
-    const ms = parseTimestampToMs(row.timestamp);
-    if (ms !== null && ms < minTime) minTime = ms;
-  }
-
-  // Group by GPU index
-  const gpuGroups = new Map<number, GpuMetricRow[]>();
-  for (const row of data) {
-    if (!gpuGroups.has(row.index)) gpuGroups.set(row.index, []);
-    gpuGroups.get(row.index)!.push(row);
-  }
-
-  for (const [gpuIndex, rows] of gpuGroups) {
-    const rawValues = rows.map((r) => r[metricKey]);
-    // Skip if any values are undefined (metric not available for this vendor)
-    if (rawValues.some((v) => v === undefined)) continue;
-    const values = rawValues as number[];
-    if (values.length < 3) continue;
-
-    // MAD-based Modified Z-score detection
-    const med = median(values);
-    const absDeviations = values.map((v) => Math.abs(v - med));
-    const mad = median(absDeviations);
-
-    // Pre-compute SM clock median for clock_drop detection (avoid O(n^2))
-    const smMedian =
-      metricKey === 'smClock' || metricKey === 'power' ? median(rows.map((r) => r.smClock)) : 0;
-
-    for (let i = 0; i < rows.length; i++) {
-      const row = rows[i];
-      const ms = parseTimestampToMs(row.timestamp);
-      const seconds = ms === null ? i : (ms - minTime) / 1000;
-
-      // Statistical outlier (MAD)
-      if (mad > 0) {
-        const modifiedZ = (0.6745 * (values[i] - med)) / mad;
-        if (Math.abs(modifiedZ) > 3.5) {
-          anomalies.push({
-            type: 'statistical',
-            label: 'Statistical Outlier',
-            gpuIndex,
-            seconds,
-            value: values[i],
-            message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: ${metricKey} = ${values[i].toFixed(1)} (Modified Z = ${modifiedZ.toFixed(1)}, median = ${med.toFixed(1)})`,
-          });
-        }
-      }
-
-      // Domain-specific: thermal throttle (temperature > 83°C)
-      if (row.temperature > 83) {
-        anomalies.push({
-          type: 'thermal',
-          label: 'Thermal Throttle',
-          gpuIndex,
-          seconds,
-          value: row.temperature,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: temperature ${row.temperature}°C exceeds throttle threshold (83°C)`,
-        });
-      }
-
-      // Domain-specific: near TDP (power > 90% of TDP)
-      if (tdpInfo && row.power > tdpInfo.tdp * 0.9) {
-        anomalies.push({
-          type: 'near_tdp',
-          label: 'Near TDP',
-          gpuIndex,
-          seconds,
-          value: row.power,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: power ${row.power.toFixed(1)}W is ${((row.power / tdpInfo.tdp) * 100).toFixed(0)}% of TDP (${tdpInfo.tdp}W)`,
-        });
-      }
-
-      // Domain-specific: clock drop (SM clock > 30% below median)
-      if (
-        (metricKey === 'smClock' || metricKey === 'power') &&
-        smMedian > 0 &&
-        row.smClock < smMedian * 0.7
-      ) {
-        anomalies.push({
-          type: 'clock_drop',
-          label: 'Clock Drop',
-          gpuIndex,
-          seconds,
-          value: row.smClock,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: SM clock ${row.smClock} MHz dropped ${((1 - row.smClock / smMedian) * 100).toFixed(0)}% below median (${smMedian.toFixed(0)} MHz)`,
-        });
-      }
-
-      // Domain-specific: utilization drop (GPU util = 0 after being > 50%)
-      if (row.gpuUtil === 0 && i > 0 && rows[i - 1].gpuUtil > 50) {
-        anomalies.push({
-          type: 'util_drop',
-          label: 'Utilization Drop',
-          gpuIndex,
-          seconds,
-          value: 0,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: utilization dropped to 0% (was ${rows[i - 1].gpuUtil}%)`,
-        });
-      }
-    }
-  }
-
-  // Deduplicate: keep only one anomaly per (type, gpuIndex, second)
-  const seen = new Set<string>();
-  const deduped = anomalies.filter((a) => {
-    const key = `${a.type}_${a.gpuIndex}_${Math.round(a.seconds)}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-
-  return deduped.toSorted((a, b) => a.seconds - b.seconds);
-}
-
-/**
- * Split a CSV line respecting double-quoted fields (which may contain commas).
- * Required for AMD amd-smi CSV where array fields like "['N/A', 'N/A']" are quoted.
- */
-function splitCsvLine(line: string): string[] {
-  const result: string[] = [];
-  let current = '';
-  let inQuotes = false;
-  for (const char of line) {
-    if (char === '"') {
-      inQuotes = !inQuotes;
-    } else if (char === ',' && !inQuotes) {
-      result.push(current.trim());
-      current = '';
-    } else {
-      current += char;
-    }
-  }
-  result.push(current.trim());
-  return result;
-}
-
 /**
  * Build a column-index lookup from a CSV header line.
  * Returns a map of header name → column index.
@@ -407,7 +241,7 @@ function buildColumnMap(headerLine: string): Map<string, number> {
   const headers = splitCsvLine(headerLine);
   const map = new Map<string, number>();
   for (let i = 0; i < headers.length; i++) {
-    map.set(headers[i].toLowerCase(), i);
+    map.set(headers[i].toLowerCase().replace(/\s*\[.*\]$/u, ''), i);
   }
   return map;
 }
@@ -418,40 +252,39 @@ function buildColumnMap(headerLine: string): Map<string, number> {
  * clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]
  */
 function parseNvidiaCsv(lines: string[]): GpuMetricRow[] {
+  const columns = buildColumnMap(lines[0]);
+  const col = (name: string) => columns.get(name) ?? -1;
+  const iTimestamp = col('timestamp');
+  const iIndex = col('index');
+  const iPower = col('power.draw');
+  if (iTimestamp < 0 || iIndex < 0 || iPower < 0) return [];
   const results: GpuMetricRow[] = [];
   for (let i = 1; i < lines.length; i++) {
     const cols = lines[i].split(',').map((c) => c.trim());
-    if (cols.length < 8) continue;
-
-    const index = parseInt(cols[1], 10);
-    const power = parseFloat(cols[2]);
-    const temperature = parseFloat(cols[3]);
-    const smClock = parseFloat(cols[4]);
-    const memClock = parseFloat(cols[5]);
-    const gpuUtil = parseFloat(cols[6]);
-    const memUtil = parseFloat(cols[7]);
-
-    if ([index, power, temperature, smClock, memClock, gpuUtil, memUtil].some(isNaN)) continue;
+    if (cols.length <= Math.max(iTimestamp, iIndex, iPower)) continue;
+    const index = parseInt(cols[iIndex], 10);
+    const power = safeFloat(cols[iPower]);
+    if (!Number.isInteger(index) || index < 0 || power === undefined) continue;
 
     results.push({
-      timestamp: cols[0],
+      timestamp: cols[iTimestamp],
       index,
       power,
-      temperature,
-      smClock,
-      memClock,
-      gpuUtil,
-      memUtil,
+      temperature: safeFloat(cols[col('temperature.gpu')]),
+      smClock: safeFloat(cols[col('clocks.current.sm')]),
+      memClock: safeFloat(cols[col('clocks.current.memory')]),
+      gpuUtil: safeFloat(cols[col('utilization.gpu')]),
+      memUtil: safeFloat(cols[col('utilization.memory')]),
     });
   }
   return results;
 }
 
-/** Safely parse a float, returning undefined for N/A or unparseable values. */
+/** Missing, unparseable and nonfinite readings stay absent; measured zero is valid. */
 function safeFloat(val: string | undefined): number | undefined {
   if (val === undefined || val === 'N/A' || val === '') return undefined;
   const n = parseFloat(val);
-  return isNaN(n) ? undefined : n;
+  return Number.isFinite(n) ? n : undefined;
 }
 
 /**
@@ -484,28 +317,25 @@ function parseAmdCsv(lines: string[], colMap: Map<string, number>): GpuMetricRow
   const results: GpuMetricRow[] = [];
   for (let i = 1; i < lines.length; i++) {
     const cols = splitCsvLine(lines[i]);
-    if (cols.length < 3) continue;
+    if (cols.length <= Math.max(iTimestamp, iGpu, iPower)) continue;
 
     const index = parseInt(cols[iGpu], 10);
-    const power = parseFloat(cols[iPower]);
+    const power = safeFloat(cols[iPower]);
     // Prefer hotspot temp, fall back to edge
-    let temperature = iHotspot >= 0 ? parseFloat(cols[iHotspot]) : NaN;
-    if (isNaN(temperature) && iEdge >= 0) temperature = parseFloat(cols[iEdge]);
-    const smClock = iGfxClk >= 0 ? parseFloat(cols[iGfxClk]) : 0;
-    const memClock = iMemClk >= 0 ? parseFloat(cols[iMemClk]) : 0;
-    const gpuUtil = iGfxActivity >= 0 ? parseFloat(cols[iGfxActivity]) : 0;
-    const memUtil = iUmcActivity >= 0 ? parseFloat(cols[iUmcActivity]) : 0;
-
-    if (isNaN(index) || isNaN(power)) continue;
-    if (isNaN(temperature)) temperature = 0;
-
-    // AMD timestamps are Unix epoch seconds — convert to ms-based string for consistency
-    const rawTimestamp = cols[iTimestamp];
-    const epochSec = parseFloat(rawTimestamp);
-    const timestamp =
-      !isNaN(epochSec) && epochSec > 1e9 && epochSec < 1e11
-        ? new Date(epochSec * 1000).toISOString()
-        : rawTimestamp;
+    const temperature = safeFloat(cols[iHotspot]) ?? safeFloat(cols[iEdge]);
+    const smClock = safeFloat(cols[iGfxClk]);
+    const memClock = safeFloat(cols[iMemClk]);
+    const gpuUtil = safeFloat(cols[iGfxActivity]);
+    const memUtil = safeFloat(cols[iUmcActivity]);
+
+    if (!Number.isInteger(index) || index < 0 || power === undefined) continue;
+
+    // Round epoch fractions exactly as ingest does before constructing the dedup key.
+    const timestampMs = parseAmdTimestamp(cols[iTimestamp]);
+    if (timestampMs === null) continue;
+    const date = new Date(timestampMs);
+    if (!Number.isFinite(date.getTime())) continue;
+    const timestamp = date.toISOString();
 
     // AMD-specific metrics
     const edgeTemp = iEdge >= 0 ? safeFloat(cols[iEdge]) : undefined;
@@ -552,28 +382,27 @@ export function parseCsvData(csvText: string): GpuMetricRow[] {
 
   const headerLower = lines[0].toLowerCase();
 
-  // Detect AMD format by checking for amd-smi specific columns
-  if (headerLower.includes('socket_power') || headerLower.includes('gfx_activity')) {
-    const colMap = buildColumnMap(lines[0]);
-    return parseAmdCsv(lines, colMap);
-  }
-
-  return parseNvidiaCsv(lines);
+  const rows =
+    headerLower.includes('socket_power') || headerLower.includes('gfx_activity')
+      ? parseAmdCsv(lines, buildColumnMap(lines[0]))
+      : parseNvidiaCsv(lines);
+  // Normalize one CSV at a time: host-local indices may repeat in other files.
+  // Keep the first device/timestamp sample, matching the persisted digest.
+  const seen = new Set<string>();
+  return rows.filter((row) => {
+    // NVIDIA's naive collector clock must not use the reader's local DST rules.
+    const ms = parseNvidiaTimestamp(row.timestamp) ?? parseTimestampToMs(row.timestamp);
+    if (ms === null || !Number.isFinite(ms)) return false;
+    const key = `${row.index}:${ms}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
 }
 
 // --- Statistics ---
 
-export interface GpuStats {
-  gpuIndex: number;
-  count: number;
-  min: number;
-  max: number;
-  mean: number;
-  median: number;
-  p95: number;
-  p99: number;
-  stddev: number;
-}
+export type GpuStats = Omit<GpuMetricStatRow, 'metric'>;
 
 function percentile(sorted: number[], p: number): number {
   const idx = (p / 100) * (sorted.length - 1);
@@ -587,7 +416,7 @@ export function computeGpuStats(data: GpuMetricRow[], metricKey: GpuMetricKey):
   const groups = new Map<number, number[]>();
   for (const row of data) {
     const val = row[metricKey];
-    if (val === undefined) continue;
+    if (val === undefined || !Number.isFinite(val)) continue;
     if (!groups.has(row.index)) groups.set(row.index, []);
     groups.get(row.index)!.push(val);
   }
diff --git a/packages/app/src/lib/d3-chart/layers/lines.ts b/packages/app/src/lib/d3-chart/layers/lines.ts
index 075a1be71..885e0630d 100644
--- a/packages/app/src/lib/d3-chart/layers/lines.ts
+++ b/packages/app/src/lib/d3-chart/layers/lines.ts
@@ -9,6 +9,8 @@ export interface LineConfig {
   /** Optional per-series SVG dash pattern; return `none` for a solid line. */
   getStrokeDasharray?: (key: string) => string;
   strokeWidth?: number;
+  /** Optional per-series stroke width; falls back to `strokeWidth`, then 2. */
+  getStrokeWidth?: (key: string) => number;
   curve?: d3.CurveFactory;
   /** Return false to create gaps in the line (e.g., missing data points). */
   isDefined?: (d: { x: number; y: number }) => boolean;
@@ -61,7 +63,7 @@ export function renderLines(
     .attr('class', (d) => `line-path line-${d.key}`)
     .attr('stroke', (d) => config.getColor(d.key))
     .attr('stroke-dasharray', (d) => config.getStrokeDasharray?.(d.key) ?? null)
-    .attr('stroke-width', config.strokeWidth ?? 2)
+    .attr('stroke-width', (d) => config.getStrokeWidth?.(d.key) ?? config.strokeWidth ?? 2)
     .attr('d', (d) => lineGenerator(d.points));
 }
 

From 38b2d3ebb78e6f251ebcf76612ef4cdb2a6c276c Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 071/103] feat(ui): measured power timeline
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Draw the one-second power traces of the drawn runs on a shared time axis, grouped by
pool with reference labels, honoring hardware toggles and unofficial-run overlays.

中文：在共享时间轴上绘制已绘 run 的每秒功耗轨迹，按 pool 分组并带参考标签，遵循硬件开关与非正式 run 叠加。
---
 .../cypress/component/power-timeline.cy.tsx   |  184 ++
 .../components/inference/ui/PowerTimeline.tsx | 1481 +++++++++++++++++
 .../inference/utils/powerTimeline.test.ts     |   21 +
 .../inference/utils/powerTimeline.ts          |  344 ++++
 4 files changed, 2030 insertions(+)
 create mode 100644 packages/app/cypress/component/power-timeline.cy.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerTimeline.tsx
 create mode 100644 packages/app/src/components/inference/utils/powerTimeline.test.ts
 create mode 100644 packages/app/src/components/inference/utils/powerTimeline.ts

diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
new file mode 100644
index 000000000..01fc78f13
--- /dev/null
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -0,0 +1,184 @@
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+
+import type { GpuPowerSeries, GpuPowerSeriesResponse } from '@/components/gpu-power/power-series';
+import PowerTimeline from '@/components/inference/ui/PowerTimeline';
+import type { InferenceData } from '@/components/inference/types';
+import { Model, Precision, Sequence } from '@/lib/data-mappings';
+import { overlayRunColor } from '@/lib/overlay-run-style';
+
+import {
+  createMockHardwareConfig,
+  createMockInferenceData,
+  createMockUnofficialRunContext,
+} from '../support/mock-data';
+import { mountWithProviders } from '../support/test-utils';
+
+// PowerTimeline joins chart points to `gpu_metrics_<RESULT_FILENAME>` artifacts
+// by the `power_audit.source` file name and draws one trace per config. Overlay
+// runs keep their run colour and follow the overlay hardware filter.
+
+const RUN_ID = '34716669498';
+const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
+const OVERLAY_RUN_ID = '31415926535';
+const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
+const START_MS = Date.UTC(2026, 8, 12, 20, 20, 0);
+const hwConfig = createMockHardwareConfig();
+const HW_TYPES = new Set(['b200', 'h100']);
+
+const resultName = (hardware: string, conc: number) =>
+  `dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc${conc}_${hardware}-host-0123456789abcdef0123`;
+const WINDOW = {
+  // Window covers the last 20 s of a 60 s job.
+  window_start_unix: (START_MS + 40_000) / 1000,
+  window_end_unix: (START_MS + 60_000) / 1000,
+};
+
+function measuredPoint(
+  hwKey: string,
+  conc: number,
+  watts: number,
+  overrides: Partial<InferenceData> = {},
+): InferenceData {
+  return createMockInferenceData({
+    hwKey,
+    conc,
+    tp: 8,
+    x: conc,
+    y: watts,
+    precision: Precision.FP4,
+    run_url: RUN_URL,
+    measuredAvgPower: { y: watts, roof: true },
+    measuredPowerTimeline: { y: watts, roof: true },
+    power_audit: {
+      source: `power_validation_${resultName(hwKey.split('_')[0], conc)}.json`,
+      ...WINDOW,
+    },
+    ...overrides,
+  });
+}
+
+/** 61 one-second buckets: idle 200 W, ramps to `peak` inside the window. */
+function series(hwKey: string, conc: number, peak: number, gpus = [0, 1]): GpuPowerSeries {
+  const t = Array.from({ length: 61 }, (_, i) => i);
+  return {
+    artifact: `gpu_metrics_${resultName(hwKey.split('_')[0], conc)}`,
+    startMs: START_MS,
+    bucketSeconds: 1,
+    gpus,
+    t,
+    power: gpus.map((gpu) => t.map((second) => (second >= 40 ? peak + gpu * 10 : 200 + gpu))),
+  };
+}
+
+const response: GpuPowerSeriesResponse = {
+  runInfo: {
+    id: Number(RUN_ID),
+    name: 'Run Sweep',
+    branch: 'main',
+    sha: 'abc123',
+    createdAt: '2026-09-12T20:00:00Z',
+    url: RUN_URL,
+    conclusion: 'success',
+    status: 'completed',
+  },
+  series: [series('b200', 16, 700), series('b200', 64, 900)],
+};
+
+function mountTimeline(
+  data: InferenceData[],
+  options: {
+    overlay?: Parameters<typeof PowerTimeline>[0]['overlayData'];
+    unofficial?: Parameters<typeof createMockUnofficialRunContext>[0];
+  } = {},
+) {
+  mountWithProviders(
+    <PathnameContext.Provider value="/inference">
+      <div style={{ width: 1100, height: 700 }}>
+        <PowerTimeline
+          chartId="power-timeline-test"
+          data={data}
+          overlayData={options.overlay}
+          yLabel="Measured Average Power per Chip over Time (W)"
+        />
+      </div>
+    </PathnameContext.Provider>,
+    {
+      inference: {
+        selectedModel: Model.DeepSeek_V4_Pro,
+        selectedSequence: Sequence.EightK_OneK,
+        selectedYAxisMetric: 'y_measuredPowerTimeline',
+        hardwareConfig: hwConfig,
+        activeHwTypes: new Set(HW_TYPES),
+        hwTypesWithData: new Set(HW_TYPES),
+      },
+      unofficial: options.unofficial ?? {},
+    },
+  );
+}
+
+const svg = () => cy.get('[data-testid="power-timeline-chart-svg"]');
+
+describe('PowerTimeline', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message.includes('ResizeObserver loop')) return false;
+    });
+  });
+
+  it('colours overlay-run traces by run and honours the overlay hardware filter', () => {
+    const overlayPoint = measuredPoint('h200', 16, 500, {
+      run_url: OVERLAY_RUN_URL,
+      power_audit: {
+        source: `power_validation_${resultName('h200', 16)}.json`,
+        ...WINDOW,
+      },
+    });
+    const overlayResponse: GpuPowerSeriesResponse = {
+      runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
+      series: [series('h200', 16, 500)],
+    };
+    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
+    cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+      body: overlayResponse,
+    }).as('overlay');
+    mountTimeline([measuredPoint('b200', 16, 700)], {
+      overlay: {
+        data: [overlayPoint],
+        hardwareConfig: hwConfig,
+        label: 'powerx-timeline',
+        runUrl: OVERLAY_RUN_URL,
+      },
+      unofficial: createMockUnofficialRunContext({
+        isUnofficialRun: true,
+        unofficialRunInfos: [
+          {
+            id: Number(OVERLAY_RUN_ID),
+            name: 'powerx-timeline',
+            branch: 'powerx-timeline',
+            sha: 'abc000',
+            createdAt: '2026-09-12T00:00:00Z',
+            url: OVERLAY_RUN_URL,
+            conclusion: 'success',
+            status: 'completed',
+            isNonMainBranch: true,
+          },
+        ],
+        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
+        activeOverlayHwTypes: new Set(['h200']),
+      }),
+    });
+    cy.wait(['@official', '@overlay']);
+
+    svg().within(() => {
+      cy.get('path.power-trace[data-run-index="0"][data-segment="window"]')
+        .should('have.length', 1)
+        .and('have.attr', 'stroke', overlayRunColor(0));
+      cy.get('path.power-trace[data-hw="b200"][data-segment="window"]').should('have.length', 1);
+      // Two runs: the axis defaults to elapsed time so traces overlap by phase.
+      cy.get('text').contains('Time since telemetry start').should('exist');
+      // Reference lines cover both hardware SKUs.
+      cy.get('.power-reference[data-reference="tdp"]').should('have.length', 2);
+    });
+    cy.get('[data-testid="chart-legend"]').should('contain.text', '✕ powerx-timeline');
+  });
+});
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
new file mode 100644
index 000000000..6a56f0c4d
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -0,0 +1,1481 @@
+'use client';
+
+/**
+ * PowerX "Timeline" display: the per-second GPU power behind each measured
+ * average, drawn over the whole benchmark job.
+ *
+ * ChartDisplay renders this instead of ScatterGraph when the Measured Power
+ * Display control is `timeline` (`y_measuredPowerTimeline`). The point set is
+ * the same as the Measured Avg Power axis; each point's `power_audit.source`
+ * names its `gpu_metrics_*` artifact — or, for disaggregated Slurm / Dynamo
+ * rows, its validation file inside a `power_audit_*` bundle — which
+ * `/api/gpu-metrics?series=power` returns as one-second per-GPU buckets
+ * (`components/gpu-power/power-series.ts`).
+ *
+ * One trace per config, coloured by hardware (official) or by run (unofficial
+ * overlay). The validated measurement window is emphasized; the rest of the
+ * job (server start, warmup) is drawn faint. Rated TDP is a dashed reference
+ * per hardware; the all-in provisioned line is opt-in because it would halve
+ * the vertical resolution of the traces.
+ *
+ * Pool mode (bundle series carry worker roles) sums each prefill / decode pool
+ * instead, against pool-sized TDP references, so a disaggregated deployment
+ * reads as two lines on a watts axis. A pinned scatter tooltip can deep-link
+ * here focused on one config (`requestPowerTraceFocus`).
+ */
+import * as d3 from 'd3';
+import { useQueries } from '@tanstack/react-query';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
+
+import {
+  bucketTimeMs,
+  meanPowerAt,
+  sumPowerAt,
+  type GpuPowerSeries,
+  type GpuPowerSeriesResponse,
+} from '@/components/gpu-power/power-series';
+import ChartLegend, { type LegendSwitchConfig } from '@/components/ui/chart-legend';
+import { SegmentedToggle } from '@/components/ui/segmented-toggle';
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
+import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
+import { useThemeColors } from '@/hooks/useThemeColors';
+import { track } from '@/lib/analytics';
+import { computeToggle } from '@/lib/toggle-set';
+import { getModelSortIndex } from '@/lib/constants';
+import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import type { LayerConfig, RenderContext, ZoomContext } from '@/lib/d3-chart/D3Chart/types';
+import { lttbDownsample } from '@/lib/d3-chart/downsample';
+import { CHART_FONT_SANS, CHART_TYPE, px } from '@/lib/d3-chart/typography';
+import { overlayRunColor, overlayRunIndex } from '@/lib/overlay-run-style';
+import { useLocale } from '@/lib/use-locale';
+import { getDisplayLabel } from '@/lib/utils';
+
+import {
+  useInferenceActions,
+  useInferenceData,
+  useInferenceDisplay,
+  useInferenceFilters,
+} from '../InferenceContext';
+import type { InferenceData, OverlayData } from '../types';
+import { powerVariantDash } from '../utils/power-compare';
+import {
+  allGpuPool,
+  consumePowerTraceFocus,
+  groupPoolsBySize,
+  joinPowerTimeline,
+  planPowerTimelineRequests,
+  prioritizeRun,
+  prioritizeRuns,
+  referenceLabelSlots,
+  runIdFromUrl,
+  traceConfigLabel,
+  traceKeyRunId,
+  tracePools,
+  windowPhase,
+  type MissingTrace,
+  type MissingTraceReason,
+  type PoolSizeGroup,
+  type PowerPool,
+  type PowerPoolRole,
+  type PowerTimelineRequest,
+  type PowerTimelineTrace,
+  type WindowPhase,
+} from '../utils/powerTimeline';
+
+/** Distinct workflow runs fetched per chart; each is one GitHub artifact sweep. */
+export const POWER_TIMELINE_MAX_RUNS = 4;
+/** Hover targets per trace after LTTB; paths keep every bucket. */
+const HIT_POINTS_PER_TRACE = 200;
+/** Above this many visible traces the `c<conc>` end labels would only overlap. */
+const MAX_LABELED_TRACES = 40;
+/** Up to this many undrawn configs are named individually; beyond, per hardware. */
+const MAX_LISTED_MISSING = 8;
+const CHART_HEIGHT = 600;
+const MARGIN = { top: 24, right: 84, bottom: 60, left: 64 };
+
+const STRINGS = {
+  en: {
+    timeAxis: 'Time axis',
+    wall: 'Wall clock (UTC)',
+    elapsed: 'Since start',
+    xWall: 'Time (UTC)',
+    xElapsed: 'Time since telemetry start (m:ss)',
+    perGpu: 'One line per GPU',
+    perGpuHelp: 'Draw every GPU of a config instead of the mean across its GPUs.',
+    pools: 'Prefill / decode pools',
+    poolsHelp:
+      'One line per worker-role pool: the summed board power of the prefill GPUs and of the decode GPUs of a config. Dashed references are pool size × rated TDP.',
+    utilityLines: 'All-in provisioned lines',
+    utilityHelp:
+      'Dashed reference at the all-in provisioned utility power per GPU from the hardware registry (SemiAnalysis Datacenter Industry Model). Off by default because it compresses the traces.',
+    loading: (runs: number) =>
+      `Loading GPU telemetry for ${runs} run${runs === 1 ? '' : 's'}… (may take a minute)`,
+    loadError: (runId: string, message: string) => `Run ${runId}: ${message}`,
+    missing: (missing: number, total: number) =>
+      `${missing} of ${total} measured configs have no telemetry trace and are not drawn.`,
+    missingReason: {
+      'no-source': (count: number) =>
+        `${count} predate per-config telemetry provenance in the benchmark row`,
+      'no-run': (count: number) => `${count} carry no workflow run`,
+      'run-not-fetched': (count: number) => `${count} come from runs that were not loaded`,
+      'not-in-run': (count: number) =>
+        `${count} have no gpu_metrics artifact or power-audit bundle in their run (expired, or another collector)`,
+    } satisfies Record<MissingTraceReason, (count: number) => string>,
+    missingUndrawn: 'Not drawn',
+    noTraces:
+      'No telemetry traces for the visible hardware. Enable a series in the legend or choose another date.',
+    noArtifacts:
+      'These points predate per-config telemetry artifacts, so no timeline is available for them.',
+    droppedRuns: (runs: number) =>
+      `Telemetry from ${runs} more run${runs === 1 ? '' : 's'} was not loaded (limit ${POWER_TIMELINE_MAX_RUNS} runs per chart).`,
+    telemetry: 'Telemetry',
+    method:
+      'One-second means of per-GPU board power (nvidia-smi / amd-smi, or DCGM on Slurm / Dynamo runs) over the whole benchmark job; the emphasized segment is the validated window behind the measured average. Dashed lines: rated TDP per hardware from the hardware registry.',
+    methodPools:
+      'In pool mode each line is the summed power of one worker-role pool (prefill or decode GPUs) and the dashed references are pool size × rated TDP.',
+    instructions:
+      'Shift+Scroll to zoom horizontally · Drag to pan · Double-click to reset · Click a point to pin tooltip',
+    dismiss: 'Click elsewhere to dismiss',
+    phase: {
+      before: 'Before window (startup / warmup)',
+      window: 'Measurement window',
+      after: 'After window',
+      unknown: 'Window not recorded',
+    } satisfies Record<WindowPhase, string>,
+    meanPerGpu: 'Mean per GPU',
+    gpus: (count: number) => `${count} GPU${count === 1 ? '' : 's'}`,
+    min: 'min',
+    max: 'max',
+    validated: 'Validated average',
+    sinceStart: 'since start',
+    tdp: 'TDP',
+    allIn: 'all-in',
+    poolShort: { prefill: 'prefill', decode: 'decode', all: 'all GPUs' } satisfies Record<
+      PowerPoolRole,
+      string
+    >,
+    yPool: 'GPU pool power (W)',
+    pool: 'Pool',
+    poolPower: 'Pool power',
+    poolTdp: 'pool TDP',
+    focused: (label: string) => `Focused on ${label}`,
+    showAll: 'Show all',
+    unofficialRun: 'Unofficial run',
+    branch: 'Branch',
+    viewWorkflow: 'View workflow run',
+  },
+  zh: {
+    timeAxis: '时间轴',
+    wall: '实际时刻（UTC）',
+    elapsed: '相对起点',
+    xWall: '时间（UTC）',
+    xElapsed: '距遥测开始的时间（分:秒）',
+    perGpu: '每个 GPU 一条线',
+    perGpuHelp: '绘制配置中每个 GPU 的曲线，而不是各 GPU 的平均值。',
+    pools: '预填充 / 解码 GPU 池',
+    poolsHelp:
+      '按 worker 角色分池绘制：每条线是同一配置中预填充 GPU 或解码 GPU 的板卡功耗之和。虚线参考为池内 GPU 数量 × 额定 TDP。',
+    utilityLines: '全电源配置参考线',
+    utilityHelp:
+      '按硬件注册表中每 GPU 的全电源配置（all-in）市电功率绘制虚线参考（SemiAnalysis 数据中心行业模型）。默认关闭，因为它会压缩曲线的纵向分辨率。',
+    loading: (runs: number) => `正在加载 ${runs} 个运行的 GPU 遥测数据……（可能需要约一分钟）`,
+    loadError: (runId: string, message: string) => `运行 ${runId}：${message}`,
+    missing: (missing: number, total: number) =>
+      `${total} 个有实测值的配置中有 ${missing} 个没有遥测曲线，未绘制。`,
+    missingReason: {
+      'no-source': (count: number) => `${count} 个的基准测试行早于按配置记录的遥测来源`,
+      'no-run': (count: number) => `${count} 个没有工作流运行信息`,
+      'run-not-fetched': (count: number) => `${count} 个来自未加载的运行`,
+      'not-in-run': (count: number) =>
+        `${count} 个在其运行中没有 gpu_metrics 产物或 power-audit 数据包（产物已过期，或使用其他采集器）`,
+    } satisfies Record<MissingTraceReason, (count: number) => string>,
+    missingUndrawn: '未绘制',
+    noTraces: '当前可见硬件没有遥测曲线。请在图例中启用一个系列或选择其他日期。',
+    noArtifacts: '这些数据点早于按配置上传的遥测产物，因此没有可用的时间线。',
+    droppedRuns: (runs: number) =>
+      `另有 ${runs} 个运行的遥测数据未加载（每张图表最多 ${POWER_TIMELINE_MAX_RUNS} 个运行）。`,
+    telemetry: '遥测来源',
+    method:
+      '整个基准测试任务期间每个 GPU 板卡功耗（nvidia-smi / amd-smi，Slurm / Dynamo 运行为 DCGM）的一秒平均值；加粗段为实测平均值所依据的有效测量窗口。虚线：硬件注册表中各硬件的额定 TDP。',
+    methodPools:
+      '在 GPU 池模式下，每条线是一个 worker 角色池（预填充或解码 GPU）的功耗总和，虚线参考为池内 GPU 数量 × 额定 TDP。',
+    instructions: 'Shift+滚轮横向缩放 · 拖动平移 · 双击重置 · 点击数据点固定提示框',
+    dismiss: '点击其他区域关闭',
+    phase: {
+      before: '测量窗口之前（启动 / warmup）',
+      window: '测量窗口内',
+      after: '测量窗口之后',
+      unknown: '未记录测量窗口',
+    } satisfies Record<WindowPhase, string>,
+    meanPerGpu: '每 GPU 平均',
+    gpus: (count: number) => `${count} 个 GPU`,
+    min: '最小',
+    max: '最大',
+    validated: '有效平均值',
+    sinceStart: '距起点',
+    tdp: 'TDP',
+    allIn: 'all-in',
+    poolShort: { prefill: '预填充', decode: '解码', all: '全部 GPU' } satisfies Record<
+      PowerPoolRole,
+      string
+    >,
+    yPool: 'GPU 池功耗（W）',
+    pool: 'GPU 池',
+    poolPower: '池功耗',
+    poolTdp: '池 TDP',
+    focused: (label: string) => `聚焦：${label}`,
+    showAll: '显示全部',
+    unofficialRun: '非官方运行',
+    branch: '分支',
+    viewWorkflow: '查看工作流运行',
+  },
+} as const;
+
+type XMode = 'wall' | 'elapsed';
+type LineMode = 'mean' | 'gpu' | 'pool';
+
+interface TimelineSample {
+  trace: PowerTimelineTrace;
+  color: string;
+  overlayIndex: number | null;
+  column: number;
+  timeMs: number;
+  /** Data-space x for the active mode: epoch ms (wall) or seconds (elapsed). */
+  x: number;
+  /** Mean watts across the GPUs sampled in the bucket; the pool's summed watts in pool mode. */
+  y: number;
+  min: number;
+  max: number;
+  /** GPUs with a sample in the bucket (inside the pool, in pool mode). */
+  gpuCount: number;
+  phase: WindowPhase;
+  /** The pool this sample sums and its device count, in pool mode. */
+  pool?: { role: PowerPoolRole; gpuCount: number };
+}
+
+interface TracePoint {
+  x: number;
+  y: number | null;
+}
+
+interface TracePath {
+  id: string;
+  traceKey: string;
+  hwKey: string;
+  overlayIndex: number | null;
+  color: string;
+  segment: 'full' | 'window';
+  width: number;
+  opacity: number;
+  points: TracePoint[];
+  /** Worker-role pool the line sums, in pool mode. */
+  pool?: PowerPoolRole;
+}
+
+interface ReferenceLine {
+  id: string;
+  watts: number;
+  label: string;
+  color: string;
+  kind: 'tdp' | 'utility';
+  /** Pools the line is sized for, in pool mode (roles sharing one GPU count). */
+  pools?: PowerPoolRole[];
+}
+
+/** Vertical distance between stacked reference labels that share a watts value. */
+const REFERENCE_LABEL_ROW = 13;
+
+interface TraceLabel {
+  /** Join key: the trace key, plus the pool role in pool mode. */
+  id: string;
+  traceKey: string;
+  hwKey: string;
+  pool?: PowerPoolRole;
+  color: string;
+  text: string;
+  x: number;
+  y: number;
+}
+
+interface DrawModel {
+  paths: TracePath[];
+  labels: TraceLabel[];
+}
+
+export interface PowerTimelineProps {
+  chartId: string;
+  /** Official points of the chart (display-limit clipped points restored). */
+  data: InferenceData[];
+  overlayData?: OverlayData;
+  yLabel: string;
+  caption?: React.ReactNode;
+}
+
+async function fetchPowerSeries(
+  request: PowerTimelineRequest,
+  signal: AbortSignal,
+): Promise<GpuPowerSeriesResponse> {
+  const params = new URLSearchParams({ runId: request.runId, series: 'power' });
+  if (request.prefix) params.set('prefix', request.prefix);
+  const response = await fetch(`/api/gpu-metrics?${params.toString()}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ sources: request.sources }),
+    cache: 'no-store',
+    signal,
+  });
+  const body = (await response.json()) as GpuPowerSeriesResponse | { error: string };
+  if (!response.ok) {
+    throw new Error('error' in body ? body.error : `HTTP ${response.status}`);
+  }
+  return body as GpuPowerSeriesResponse;
+}
+
+function formatElapsed(totalSeconds: number): string {
+  const seconds = Math.max(0, Math.round(totalSeconds));
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = seconds % 60;
+  const mm = h > 0 ? String(m).padStart(2, '0') : String(m);
+  return `${h > 0 ? `${h}:` : ''}${mm}:${String(s).padStart(2, '0')}`;
+}
+
+const formatUtcClock = d3.utcFormat('%H:%M:%S');
+const formatUtcDate = d3.utcFormat('%Y-%m-%d');
+/** Pool sums run to thousands of watts; group the digits. */
+const formatWatts = d3.format(',.0f');
+
+function baseHardware(hwKey: string): string {
+  return hwKey.split('_')[0];
+}
+
+/**
+ * The pools a trace draws in pool mode: its worker-role pools, or every GPU as
+ * one pool when the collector assigned no roles (a single-node trace then shows
+ * its deployment total on the same axis).
+ */
+function drawnPools(series: GpuPowerSeries): PowerPool[] {
+  const pools = tracePools(series);
+  return pools.length > 0 ? pools : [allGpuPool(series)];
+}
+
+/** SVG dash of a pool line: per role from the comparison palette; `all` stays solid. */
+function poolDash(pool: PowerPoolRole): string | null {
+  const dash = powerVariantDash({ kind: 'role', id: pool });
+  return dash === '' ? null : dash;
+}
+
+interface TraceRow {
+  id: string;
+  pool?: PowerPoolRole;
+  values: (number | null)[];
+}
+
+/** One polyline's values per line mode: the GPU mean, each GPU, or each pool's sum. */
+function traceRows(series: GpuPowerSeries, lineMode: LineMode): TraceRow[] {
+  if (lineMode === 'gpu') {
+    return series.gpus.map((gpu, row) => ({ id: `gpu${gpu}`, values: series.power[row] }));
+  }
+  if (lineMode === 'pool') {
+    return drawnPools(series).map((pool) => ({
+      id: `pool:${pool.role}`,
+      pool: pool.role,
+      values: series.t.map((_, column) => sumPowerAt(series, pool.rows, column)),
+    }));
+  }
+  return [{ id: 'mean', values: series.t.map((_, column) => meanPowerAt(series, column)) }];
+}
+
+/** Builds the mean, per-GPU or per-pool polylines plus the window emphasis for one trace. */
+function tracePaths(
+  trace: PowerTimelineTrace,
+  color: string,
+  overlayIndex: number | null,
+  xMode: XMode,
+  lineMode: LineMode,
+): TracePath[] {
+  const { series } = trace;
+  const xOf = (column: number) =>
+    xMode === 'wall' ? bucketTimeMs(series, column) : series.t[column] - series.t[0];
+  const rows = traceRows(series, lineMode);
+  const faint = lineMode === 'gpu' ? 0.22 : 0.32;
+  const strong = lineMode === 'gpu' ? 0.85 : 1;
+  const widths = lineMode === 'gpu' ? [1, 1.5] : [1.25, 2.25];
+  const paths: TracePath[] = [];
+  for (const row of rows) {
+    const full: TracePoint[] = [];
+    const window: TracePoint[] = [];
+    row.values.forEach((value, column) => {
+      const point = { x: xOf(column), y: value };
+      full.push(point);
+      if (windowPhase(trace, bucketTimeMs(series, column)) === 'window') window.push(point);
+    });
+    paths.push({
+      id: `${trace.key}:${row.id}:full`,
+      traceKey: trace.key,
+      hwKey: trace.point.hwKey,
+      overlayIndex,
+      color,
+      segment: 'full',
+      width: widths[0],
+      opacity: faint,
+      points: full,
+      pool: row.pool,
+    });
+    if (window.length > 1) {
+      paths.push({
+        id: `${trace.key}:${row.id}:window`,
+        traceKey: trace.key,
+        hwKey: trace.point.hwKey,
+        overlayIndex,
+        color,
+        segment: 'window',
+        width: widths[1],
+        opacity: strong,
+        points: window,
+        pool: row.pool,
+      });
+    }
+  }
+  return paths;
+}
+
+/**
+ * Hover targets of one trace: one stream over all its GPUs (mean watts), or in
+ * pool mode one stream per pool (summed watts) so the tooltip can name the pool.
+ */
+function traceSamples(
+  trace: PowerTimelineTrace,
+  color: string,
+  overlayIndex: number | null,
+  xMode: XMode,
+  lineMode: LineMode,
+): TimelineSample[] {
+  const { series } = trace;
+  if (lineMode !== 'pool') {
+    const rows = series.power.map((_, row) => row);
+    return sampleRows(trace, color, overlayIndex, xMode, rows, undefined);
+  }
+  return drawnPools(series).flatMap((pool) =>
+    sampleRows(trace, color, overlayIndex, xMode, pool.rows, {
+      role: pool.role,
+      gpuCount: pool.rows.length,
+    }),
+  );
+}
+
+function sampleRows(
+  trace: PowerTimelineTrace,
+  color: string,
+  overlayIndex: number | null,
+  xMode: XMode,
+  rows: readonly number[],
+  pool: TimelineSample['pool'],
+): TimelineSample[] {
+  const { series } = trace;
+  const samples: TimelineSample[] = [];
+  for (let column = 0; column < series.t.length; column++) {
+    let sum = 0;
+    let count = 0;
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (const row of rows) {
+      const value = series.power[row]?.[column];
+      if (value === null || value === undefined) continue;
+      sum += value;
+      count += 1;
+      if (value < min) min = value;
+      if (value > max) max = value;
+    }
+    // A pool bucket missing a device is a gap, as in `sumPowerAt`, not a dip.
+    if (count === 0 || (pool && count < rows.length)) continue;
+    const timeMs = bucketTimeMs(series, column);
+    samples.push({
+      trace,
+      color,
+      overlayIndex,
+      column,
+      timeMs,
+      x: xMode === 'wall' ? timeMs : series.t[column] - series.t[0],
+      y: pool ? sum : sum / count,
+      min,
+      max,
+      gpuCount: count,
+      phase: windowPhase(trace, timeMs),
+      pool,
+    });
+  }
+  return lttbDownsample(
+    samples,
+    HIT_POINTS_PER_TRACE,
+    (sample) => sample.x,
+    (sample) => sample.y,
+  );
+}
+
+type AnyContinuousScale = d3.ScaleLinear<number, number>;
+
+function drawTraces(
+  group: d3.Selection<SVGGElement, unknown, null, undefined>,
+  xScale: AnyContinuousScale,
+  yScale: AnyContinuousScale,
+  model: DrawModel,
+  highlight: string | null,
+): void {
+  const line = d3
+    .line<TracePoint>()
+    .defined((point) => point.y !== null)
+    .x((point) => xScale(point.x))
+    .y((point) => yScale(point.y ?? 0))
+    .curve(d3.curveLinear);
+  const selection = group
+    .selectAll<SVGPathElement, TracePath>('path.power-trace')
+    .data(model.paths, (path) => path.id);
+  selection.exit().remove();
+  selection
+    .enter()
+    .append('path')
+    .attr('class', 'power-trace')
+    .attr('fill', 'none')
+    .attr('stroke-linejoin', 'round')
+    .attr('stroke-linecap', 'round')
+    .merge(selection)
+    .attr('data-trace-key', (path) => path.traceKey)
+    .attr('data-hw', (path) => path.hwKey)
+    .attr('data-segment', (path) => path.segment)
+    .attr('data-run-index', (path) => (path.overlayIndex === null ? null : path.overlayIndex))
+    .attr('data-pool', (path) => path.pool ?? null)
+    .attr('stroke-dasharray', (path) => (path.pool ? poolDash(path.pool) : null))
+    .attr('stroke', (path) => path.color)
+    .attr('stroke-width', (path) => path.width)
+    .attr('opacity', (path) => traceOpacity(path, highlight))
+    .attr('d', (path) => line(path.points));
+}
+
+function traceOpacity(path: TracePath, highlight: string | null): number {
+  if (highlight === null) return path.opacity;
+  return highlight === path.hwKey || highlight === path.traceKey
+    ? Math.min(1, path.opacity + 0.15)
+    : path.opacity * 0.15;
+}
+
+function drawLabels(
+  group: d3.Selection<SVGGElement, unknown, null, undefined>,
+  xScale: AnyContinuousScale,
+  yScale: AnyContinuousScale,
+  model: DrawModel,
+  plotWidth: number,
+  highlight: string | null,
+): void {
+  const selection = group
+    .selectAll<SVGTextElement, TraceLabel>('text.power-trace-label')
+    .data(model.labels, (label) => label.id);
+  selection.exit().remove();
+  selection
+    .enter()
+    .append('text')
+    .attr('class', 'power-trace-label')
+    .attr('font-family', CHART_FONT_SANS)
+    .attr('font-size', px(CHART_TYPE.dataLabel))
+    .attr('font-weight', '600')
+    .attr('dominant-baseline', 'middle')
+    .attr('pointer-events', 'none')
+    .merge(selection)
+    .attr('data-hw', (label) => label.hwKey)
+    .attr('data-pool', (label) => label.pool ?? null)
+    .attr('fill', (label) => label.color)
+    .attr('opacity', (label) =>
+      highlight === null || highlight === label.hwKey || highlight === label.traceKey ? 1 : 0.2,
+    )
+    .text((label) => label.text)
+    .each(function (label) {
+      const x = xScale(label.x);
+      const y = yScale(label.y);
+      // Sit just past the last sample; flip inside the plot near the right edge.
+      const overflow = x + 6 + label.text.length * 6.5 > plotWidth;
+      d3.select(this)
+        .attr('text-anchor', overflow ? 'end' : 'start')
+        .attr('x', overflow ? x - 6 : x + 6)
+        .attr('y', y);
+    });
+}
+
+function drawReferenceLines(
+  group: d3.Selection<SVGGElement, unknown, null, undefined>,
+  yScale: AnyContinuousScale,
+  width: number,
+  lines: ReferenceLine[],
+): void {
+  group.selectAll('.power-reference').remove();
+  const slots = referenceLabelSlots(lines);
+  lines.forEach((line, index) => {
+    const y = yScale(line.watts);
+    const g = group
+      .append('g')
+      .attr('class', 'power-reference')
+      .attr('data-reference', line.kind)
+      .attr('data-pool', line.pools?.join(' ') ?? null)
+      .attr('data-watts', line.watts);
+    g.append('line')
+      .attr('x1', 0)
+      .attr('x2', width)
+      .attr('y1', y)
+      .attr('y2', y)
+      .attr('stroke', line.color)
+      .attr('stroke-width', 1.25)
+      .attr('stroke-dasharray', line.kind === 'tdp' ? '6,4' : '2,4')
+      .attr('opacity', 0.9);
+    g.append('text')
+      .attr('x', width - 4)
+      .attr('y', y - 5 - slots[index] * REFERENCE_LABEL_ROW)
+      .attr('text-anchor', 'end')
+      .attr('fill', line.color)
+      .attr('font-family', CHART_FONT_SANS)
+      .attr('font-size', px(CHART_TYPE.annotation))
+      .attr('font-weight', '600')
+      .text(line.label);
+  });
+}
+
+/** Reasons, then the undrawn configs (named when few, counted per hardware when many). */
+function describeMissing(
+  missing: readonly MissingTrace[],
+  t: (typeof STRINGS)[keyof typeof STRINGS],
+  hardwareLabel: (point: InferenceData) => string,
+): string {
+  const reasons = new Map<MissingTraceReason, number>();
+  for (const { reason } of missing) reasons.set(reason, (reasons.get(reason) ?? 0) + 1);
+  const reasonText = [...reasons.entries()]
+    .map(([reason, count]) => t.missingReason[reason](count))
+    .join('; ');
+  let list: string;
+  if (missing.length <= MAX_LISTED_MISSING) {
+    list = missing
+      .map(({ point }) => `${hardwareLabel(point)} ${traceConfigLabel(point)}`)
+      .join(' · ');
+  } else {
+    const perHardware = new Map<string, number>();
+    for (const { point } of missing) {
+      const label = hardwareLabel(point);
+      perHardware.set(label, (perHardware.get(label) ?? 0) + 1);
+    }
+    list = [...perHardware.entries()].map(([label, count]) => `${label} ×${count}`).join(' · ');
+  }
+  return `${reasonText}. ${t.missingUndrawn}: ${list}`;
+}
+
+export default function PowerTimeline({
+  chartId,
+  data,
+  overlayData,
+  yLabel,
+  caption,
+}: PowerTimelineProps) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const { hardwareConfig, hwTypesWithData } = useInferenceData();
+  const { activeHwTypes, selectedPrecisions, quickFilters } = useInferenceFilters();
+  const { isLegendExpanded, highContrast } = useInferenceDisplay();
+  const { setBestPerSku, toggleHwType, setIsLegendExpanded } = useInferenceActions();
+  const {
+    unofficialRunInfos,
+    runIndexByUrl,
+    activeOverlayHwTypes,
+    localOfficialOverride,
+    setUnifiedOverlaySelection,
+  } = useUnofficialRun();
+
+  const [xModeChoice, setXModeChoice] = useState<XMode | null>(null);
+  const [lineMode, setLineMode] = useState<LineMode>('mean');
+  const [showUtility, setShowUtility] = useState(false);
+  const [highlight, setHighlight] = useState<string | null>(null);
+  /** Trace a "View power trace" deep link asked for, once the join has produced it. */
+  const [focusKey, setFocusKey] = useState<string | null>(null);
+  /** The deep-link request, read once on mount; `undefined` until read, `null` once honoured. */
+  const requestedFocusRef = useRef<string | null | undefined>(undefined);
+
+  // The chart's point list still carries every precision, quick-filtered rows
+  // and rows without a validated average (ScatterGraph applies those gates at
+  // draw time); only rows that plot on the measured-average axis for the
+  // current selection have a trace to look up.
+  const plotsHere = useCallback(
+    (point: InferenceData) =>
+      point.measuredPowerTimeline !== undefined &&
+      selectedPrecisions.includes(point.precision) &&
+      matchesQuickFilters(point, quickFilters),
+    [selectedPrecisions, quickFilters],
+  );
+  const measuredData = useMemo(() => data.filter(plotsHere), [data, plotsHere]);
+  const overlayPoints = useMemo(
+    () => (overlayData?.data ?? []).filter(plotsHere),
+    [overlayData, plotsHere],
+  );
+  const overlayPointSet = useMemo(() => new Set<InferenceData>(overlayPoints), [overlayPoints]);
+  const allPoints = useMemo(
+    () => [...measuredData, ...overlayPoints],
+    [measuredData, overlayPoints],
+  );
+
+  const hwKeysInData = useMemo(
+    () =>
+      [...new Set(measuredData.map((point) => point.hwKey))].toSorted(
+        (a, b) => getModelSortIndex(a) - getModelSortIndex(b) || a.localeCompare(b),
+      ),
+    [measuredData],
+  );
+  const stableHcKeys = useMemo(() => [...hwTypesWithData], [hwTypesWithData]);
+  const activeOfficialKeys = useMemo(() => [...activeHwTypes], [activeHwTypes]);
+  const { resolveColor, getCssColor } = useThemeColors({
+    highContrast,
+    identifiers: hwKeysInData,
+    activeKeys: activeOfficialKeys,
+    hcKeys: stableHcKeys,
+  });
+
+  // ── Telemetry fetch: one request per workflow run ──────────────────────────
+  const requests = useMemo(() => planPowerTimelineRequests(allPoints), [allPoints]);
+  // The deep-link request is read once, before planning, so its run is fetched
+  // even when the chart spans more runs than the cap.
+  if (requestedFocusRef.current === undefined) {
+    requestedFocusRef.current = consumePowerTraceFocus();
+  }
+  const focusRunRef = useRef(traceKeyRunId(requestedFocusRef.current));
+  // Overlay runs were requested explicitly (`?unofficialrun=`), so they take
+  // the cap's slots before official runs; the deep-linked run still goes first.
+  const overlayRunIds = useMemo(
+    () =>
+      new Set(
+        overlayPoints
+          .map((point) => runIdFromUrl(point.run_url))
+          .filter((runId): runId is string => runId !== null),
+      ),
+    [overlayPoints],
+  );
+  const fetchedRequests = useMemo(
+    () =>
+      prioritizeRun(prioritizeRuns(requests, overlayRunIds), focusRunRef.current).slice(
+        0,
+        POWER_TIMELINE_MAX_RUNS,
+      ),
+    [requests, overlayRunIds],
+  );
+  const droppedRuns = requests.length - fetchedRequests.length;
+  const queries = useQueries({
+    queries: fetchedRequests.map((request) => ({
+      queryKey: ['power-timeline', request.runId, request.prefix, request.sources] as const,
+      queryFn: ({ signal }: { signal: AbortSignal }) => fetchPowerSeries(request, signal),
+      staleTime: 0,
+      refetchOnWindowFocus: true,
+      retry: 1,
+    })),
+  });
+  const loadingRuns = queries.filter((query) => query.isPending).length;
+  const errors = fetchedRequests
+    .map((request, index) => ({ request, error: queries[index].error }))
+    .filter(
+      (entry): entry is { request: PowerTimelineRequest; error: Error } =>
+        entry.error instanceof Error,
+    );
+  const responses = useMemo(() => {
+    const map = new Map<string, GpuPowerSeriesResponse>();
+    fetchedRequests.forEach((request, index) => {
+      const response = queries[index].data;
+      if (response) map.set(request.runId, response);
+    });
+    return map;
+    // Query data objects are stable per fetch; deriving from them keeps the map memoised.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [fetchedRequests, ...queries.map((query) => query.data)]);
+
+  const { traces, missing } = useMemo(
+    () => joinPowerTimeline(allPoints, responses),
+    [allPoints, responses],
+  );
+  const hasAnyArtifact = requests.length > 0;
+
+  // Honour the deep link once its trace exists; a disaggregated trace opens in
+  // pool mode because its prefill / decode split is what the reader came for.
+  useEffect(() => {
+    const requested = requestedFocusRef.current;
+    if (!requested) return;
+    const trace = traces.find((entry) => entry.key === requested);
+    if (!trace) return;
+    requestedFocusRef.current = null;
+    setFocusKey(trace.key);
+    if (tracePools(trace.series).length > 0) setLineMode('pool');
+  }, [traces]);
+
+  useEffect(() => {
+    if (loadingRuns > 0 || responses.size === 0) return;
+    track('inference_power_timeline_loaded', {
+      traces: traces.length,
+      missing: missing.length,
+      runs: responses.size,
+    });
+  }, [loadingRuns, responses.size, traces.length, missing.length]);
+
+  // ── Visible traces and their colours ────────────────────────────────────────
+  const colorForTrace = useCallback(
+    (trace: PowerTimelineTrace): { color: string; overlayIndex: number | null } => {
+      if (overlayPointSet.has(trace.point)) {
+        const index = overlayRunIndex(trace.point.run_url ?? null, runIndexByUrl);
+        return { color: overlayRunColor(index), overlayIndex: index };
+      }
+      return { color: getCssColor(resolveColor(trace.point.hwKey)), overlayIndex: null };
+    },
+    [overlayPointSet, runIndexByUrl, getCssColor, resolveColor],
+  );
+  // Same visibility source as ScatterGraph: an overlay session may hold a
+  // local official selection that has not been written back to the filters.
+  const officialHwTypes = localOfficialOverride ?? activeHwTypes;
+  // With an overlay loaded the chart reads localOfficialOverride, so a legend
+  // click must write the unified selection the way ScatterGraph does; the
+  // context's toggleHwType would change activeHwTypes with no visible effect.
+  const handleToggleHwType = useCallback(
+    (key: string) => {
+      if (!overlayData) {
+        toggleHwType(key);
+        return;
+      }
+      setBestPerSku(false, { applySelection: false });
+      const official = new Set([...officialHwTypes].filter((hw) => hwTypesWithData.has(hw)));
+      setUnifiedOverlaySelection(
+        computeToggle(official, key, hwTypesWithData),
+        activeOverlayHwTypes,
+      );
+    },
+    [
+      overlayData,
+      toggleHwType,
+      setBestPerSku,
+      officialHwTypes,
+      hwTypesWithData,
+      setUnifiedOverlaySelection,
+      activeOverlayHwTypes,
+    ],
+  );
+  const visibleTraces = useMemo(
+    () =>
+      traces.filter((trace) =>
+        overlayPointSet.has(trace.point)
+          ? activeOverlayHwTypes.has(trace.point.hwKey)
+          : officialHwTypes.has(trace.point.hwKey),
+      ),
+    [traces, overlayPointSet, activeOverlayHwTypes, officialHwTypes],
+  );
+  // Focus follows visibility: hiding the focused hardware in the legend lifts
+  // the dimming and the chip instead of dimming everything with nothing lit.
+  const focusedTrace = useMemo(
+    () => visibleTraces.find((trace) => trace.key === focusKey) ?? null,
+    [visibleTraces, focusKey],
+  );
+  /** Legend hover wins over the deep-link focus while it lasts. */
+  const activeHighlight = highlight ?? focusedTrace?.key ?? null;
+  const visibleRunCount = useMemo(
+    () => new Set(visibleTraces.map((trace) => trace.runId)).size,
+    [visibleTraces],
+  );
+  const xMode: XMode = xModeChoice ?? (visibleRunCount <= 1 ? 'wall' : 'elapsed');
+
+  // The pools switch is offered only where a visible trace carries worker roles;
+  // pool mode left without one would draw deployment totals with no way back.
+  const hasPools = useMemo(
+    () => visibleTraces.some((trace) => tracePools(trace.series).length > 0),
+    [visibleTraces],
+  );
+  useEffect(() => {
+    if (lineMode === 'pool' && !hasPools && visibleTraces.length > 0) setLineMode('mean');
+  }, [lineMode, hasPools, visibleTraces.length]);
+
+  const model = useMemo<DrawModel>(() => {
+    const paths: TracePath[] = [];
+    const labels: TraceLabel[] = [];
+    for (const trace of visibleTraces) {
+      const { color, overlayIndex } = colorForTrace(trace);
+      const tracePathSet = tracePaths(trace, color, overlayIndex, xMode, lineMode);
+      paths.push(...tracePathSet);
+      if (visibleTraces.length > MAX_LABELED_TRACES) continue;
+      // One end label per trace; per pool in pool mode, so the role reads off the line.
+      const groups: { pool?: PowerPoolRole; paths: TracePath[] }[] =
+        lineMode === 'pool'
+          ? drawnPools(trace.series).map((pool) => ({
+              pool: pool.role,
+              paths: tracePathSet.filter((path) => path.pool === pool.role),
+            }))
+          : [{ paths: tracePathSet }];
+      for (const group of groups) {
+        const anchor =
+          group.paths.find((path) => path.segment === 'window') ??
+          group.paths.find((path) => path.segment === 'full');
+        const last = anchor?.points.filter((point) => point.y !== null).at(-1);
+        if (!last || last.y === null) continue;
+        labels.push({
+          id: group.pool ? `${trace.key}:${group.pool}` : trace.key,
+          traceKey: trace.key,
+          hwKey: trace.point.hwKey,
+          pool: group.pool,
+          color,
+          text: group.pool
+            ? `c${trace.point.conc} · ${t.poolShort[group.pool]}`
+            : `c${trace.point.conc}`,
+          x: last.x,
+          y: last.y,
+        });
+      }
+    }
+    return { paths, labels };
+  }, [visibleTraces, colorForTrace, xMode, lineMode, t]);
+
+  const samples = useMemo(
+    () =>
+      visibleTraces.flatMap((trace) => {
+        const { color, overlayIndex } = colorForTrace(trace);
+        return traceSamples(trace, color, overlayIndex, xMode, lineMode);
+      }),
+    [visibleTraces, colorForTrace, xMode, lineMode],
+  );
+
+  // Rated references: per hardware in mean / per-GPU modes; per (hardware,
+  // pool size) in pool mode, scaled to the pool so the summed line and its
+  // ceiling share the axis. Roles of one hardware that hold the same number
+  // of GPUs share a ceiling and draw as one line (`prefill / decode ×16`).
+  const referenceLines = useMemo<ReferenceLine[]>(() => {
+    const lines: ReferenceLine[] = [];
+    const pushLines = (base: string, color: string, pool?: PoolSizeGroup) => {
+      const specs = HW_REGISTRY[base];
+      if (!specs) return;
+      const label = specs.label ?? base.toUpperCase();
+      const size = pool?.size ?? 1;
+      const id = pool ? `${base}:${pool.roles.join('+')}:${pool.size}` : base;
+      const name = pool
+        ? `${label} ${pool.roles.map((role) => t.poolShort[role]).join(' / ')} ×${pool.size}`
+        : label;
+      if (specs.tdp > 0) {
+        lines.push({
+          id: `tdp:${id}`,
+          watts: specs.tdp * size,
+          label: `${name} ${t.tdp} ${specs.tdp * size} W`,
+          color,
+          kind: 'tdp',
+          pools: pool?.roles,
+        });
+      }
+      if (showUtility && specs.power > 0) {
+        const watts = pool ? Math.round(specs.power * 1000) * size : specs.power * 1000;
+        lines.push({
+          id: `utility:${id}`,
+          watts,
+          label: `${name} ${t.allIn} ${Math.round(watts)} W`,
+          color,
+          kind: 'utility',
+          pools: pool?.roles,
+        });
+      }
+    };
+    // First trace of a hardware sets the reference colour, as before.
+    const perBase = new Map<string, { color: string; pools: PowerPool[] }>();
+    for (const trace of visibleTraces) {
+      const base = baseHardware(trace.point.hwKey);
+      if (!perBase.has(base)) perBase.set(base, { color: colorForTrace(trace).color, pools: [] });
+      if (lineMode === 'pool') perBase.get(base)!.pools.push(...drawnPools(trace.series));
+    }
+    for (const [base, { color, pools }] of perBase) {
+      if (lineMode !== 'pool') {
+        pushLines(base, color);
+        continue;
+      }
+      for (const group of groupPoolsBySize(pools)) pushLines(base, color, group);
+    }
+    return lines;
+  }, [visibleTraces, colorForTrace, showUtility, lineMode, t]);
+
+  // ── Scales ─────────────────────────────────────────────────────────────────
+  const xDomain = useMemo<[number, number]>(() => {
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (const path of model.paths) {
+      if (path.segment !== 'full') continue;
+      for (const point of path.points) {
+        if (point.x < min) min = point.x;
+        if (point.x > max) max = point.x;
+      }
+    }
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+      return xMode === 'wall' ? [Date.UTC(2026, 0, 1), Date.UTC(2026, 0, 1, 0, 10)] : [0, 600];
+    }
+    return min === max ? [min, max + (xMode === 'wall' ? 60_000 : 60)] : [min, max];
+  }, [model.paths, xMode]);
+  const yDomain = useMemo<[number, number]>(() => {
+    let max = 0;
+    for (const path of model.paths) {
+      for (const point of path.points) if (point.y !== null && point.y > max) max = point.y;
+    }
+    for (const line of referenceLines) if (line.watts > max) max = line.watts;
+    return [0, max > 0 ? max * 1.06 : 100];
+  }, [model.paths, referenceLines]);
+
+  const xTickFormat = useMemo(() => {
+    if (xMode === 'elapsed') return (value: d3.AxisDomain) => formatElapsed(Number(value));
+    const span = xDomain[1] - xDomain[0];
+    const crossesDate = formatUtcDate(new Date(xDomain[0])) !== formatUtcDate(new Date(xDomain[1]));
+    const format = d3.utcFormat(
+      crossesDate ? '%m/%d %H:%M' : span < 3 * 60_000 ? '%H:%M:%S' : '%H:%M',
+    );
+    return (value: d3.AxisDomain) =>
+      format(value instanceof Date ? value : new Date(Number(value)));
+  }, [xMode, xDomain]);
+
+  // ── Layers ─────────────────────────────────────────────────────────────────
+  const highlightRef = useRef(activeHighlight);
+  highlightRef.current = activeHighlight;
+  const layers = useMemo<LayerConfig<TimelineSample>[]>(
+    () => [
+      {
+        type: 'custom',
+        key: 'power-reference-lines',
+        render: (group, ctx) => {
+          drawReferenceLines(group, ctx.yScale as AnyContinuousScale, ctx.width, referenceLines);
+        },
+      },
+      {
+        type: 'custom',
+        key: 'power-traces',
+        render: (group, ctx: RenderContext) => {
+          drawTraces(
+            group,
+            ctx.xScale as AnyContinuousScale,
+            ctx.yScale as AnyContinuousScale,
+            model,
+            highlightRef.current,
+          );
+        },
+        onZoom: (group, ctx: ZoomContext) => {
+          drawTraces(
+            group,
+            ctx.newXScale as AnyContinuousScale,
+            ctx.newYScale as AnyContinuousScale,
+            model,
+            highlightRef.current,
+          );
+        },
+      },
+      {
+        type: 'point',
+        key: 'power-hit-points',
+        data: samples,
+        config: {
+          getCx: () => 0,
+          getCy: () => 0,
+          getX: (sample) => sample.x,
+          getY: (sample) => sample.y,
+          getColor: (sample) => sample.color,
+          getRadius: () => 2,
+          // Pool streams of one trace share columns; the role keeps their keys apart.
+          keyFn: (sample) =>
+            sample.pool
+              ? `${sample.trace.key}:${sample.pool.role}:${sample.column}`
+              : `${sample.trace.key}:${sample.column}`,
+          maxPoints: Number.POSITIVE_INFINITY,
+        },
+      },
+      {
+        type: 'custom',
+        key: 'power-trace-labels',
+        render: (group, ctx: RenderContext) => {
+          drawLabels(
+            group,
+            ctx.xScale as AnyContinuousScale,
+            ctx.yScale as AnyContinuousScale,
+            model,
+            ctx.width,
+            highlightRef.current,
+          );
+        },
+        onZoom: (group, ctx: ZoomContext) => {
+          drawLabels(
+            group,
+            ctx.newXScale as AnyContinuousScale,
+            ctx.newYScale as AnyContinuousScale,
+            model,
+            ctx.width,
+            highlightRef.current,
+          );
+        },
+      },
+    ],
+    [referenceLines, model, samples],
+  );
+
+  const onDisplayUpdate = useCallback(
+    (ctx: RenderContext) => {
+      const root = d3.select(ctx.layout.svg.node() as SVGSVGElement);
+      root
+        .selectAll<SVGPathElement, TracePath>('path.power-trace')
+        .attr('opacity', (path) => traceOpacity(path, activeHighlight));
+      root
+        .selectAll<SVGTextElement, TraceLabel>('text.power-trace-label')
+        .attr('opacity', (label) =>
+          activeHighlight === null ||
+          activeHighlight === label.hwKey ||
+          activeHighlight === label.traceKey
+            ? 1
+            : 0.2,
+        );
+    },
+    [activeHighlight],
+  );
+
+  const hardwareLabel = useCallback(
+    (point: InferenceData): string => {
+      const config = overlayPointSet.has(point)
+        ? overlayData?.hardwareConfig[point.hwKey]
+        : hardwareConfig[point.hwKey];
+      return config ? getDisplayLabel(config) : point.hwKey;
+    },
+    [overlayPointSet, overlayData, hardwareConfig],
+  );
+
+  const tooltipContent = useCallback(
+    (sample: TimelineSample, isPinned: boolean) => {
+      const { trace } = sample;
+      const point = trace.point;
+      const overlayInfo =
+        sample.overlayIndex === null ? null : unofficialRunInfos[sample.overlayIndex];
+      const tdp = HW_REGISTRY[baseHardware(point.hwKey)]?.tdp ?? 0;
+      const elapsed = formatElapsed((sample.timeMs - trace.series.startMs) / 1000);
+      const clock = `${formatUtcClock(new Date(sample.timeMs))} UTC`;
+      const time =
+        xMode === 'wall' ? `${clock} · +${elapsed} ${t.sinceStart}` : `+${elapsed} · ${clock}`;
+      const colon = locale === 'zh' ? '：' : ':';
+      const validated = point.measuredAvgPower?.y;
+      const { pool } = sample;
+      const readings = pool
+        ? `<div class="mt-1 text-muted-foreground">${t.pool}${colon} ${t.poolShort[pool.role]} · ${t.gpus(pool.gpuCount)}</div>
+        <div class="font-medium">${t.poolPower}${colon} ${formatWatts(sample.y)} W${
+          tdp > 0
+            ? ` <span class="text-muted-foreground">(${((sample.y / (tdp * pool.gpuCount)) * 100).toFixed(0)}% ${t.poolTdp})</span>`
+            : ''
+        }</div>
+        <div class="text-muted-foreground">${t.meanPerGpu}${colon} ${(sample.y / sample.gpuCount).toFixed(1)} W · ${t.min} ${sample.min.toFixed(1)} W · ${t.max} ${sample.max.toFixed(1)} W</div>`
+        : `<div class="mt-1 font-medium">${t.meanPerGpu}${colon} ${sample.y.toFixed(1)} W${
+            tdp > 0
+              ? ` <span class="text-muted-foreground">(${((sample.y / tdp) * 100).toFixed(0)}% ${t.tdp})</span>`
+              : ''
+          }</div>
+        <div class="text-muted-foreground">${t.gpus(sample.gpuCount)} · ${t.min} ${sample.min.toFixed(1)} W · ${t.max} ${sample.max.toFixed(1)} W</div>`;
+      return `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md backdrop-blur-sm" style="min-width: 210px; user-select: ${isPinned ? 'text' : 'none'}">
+        ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
+        <div class="font-semibold mb-1" style="color: ${sample.color}">${hardwareLabel(point)} · ${traceConfigLabel(point)}${
+          overlayInfo ? ` · ✕ ${overlayInfo.branch || `run ${overlayInfo.id}`}` : ''
+        }</div>
+        <div class="text-muted-foreground">${time}</div>
+        ${readings}
+        <div class="text-muted-foreground">${t.phase[sample.phase]}</div>
+        ${
+          typeof validated === 'number'
+            ? `<div class="text-muted-foreground">${t.validated}${colon} ${validated.toFixed(1)} W</div>`
+            : ''
+        }
+      </div>`;
+    },
+    [unofficialRunInfos, xMode, t, locale, hardwareLabel],
+  );
+
+  // ── Legend ─────────────────────────────────────────────────────────────────
+  const legendItems = useMemo(() => {
+    const overlayItems =
+      overlayData && unofficialRunInfos.length > 0
+        ? unofficialRunInfos
+            .map((info, index) => {
+              const hasPoints = overlayPoints.some(
+                (point) => overlayRunIndex(point.run_url ?? null, runIndexByUrl) === index,
+              );
+              if (!hasPoints) return null;
+              const branch = info.branch || `run ${info.id}`;
+              return {
+                name: `✕ unofficial-run-${info.id}`,
+                label: `✕ ${branch}`,
+                color: overlayRunColor(index),
+                title: `${t.unofficialRun}: ${branch}`,
+                isHighlighted: true,
+                hw: `overlay-run-${info.id}`,
+                isActive: true,
+                isRemovable: false,
+                onClick: () => {},
+                tooltip: (
+                  <div className="font-normal text-xs">
+                    <div className="text-red-500 font-semibold">{t.unofficialRun}</div>
+                    <div>
+                      {t.branch}: {branch}
+                    </div>
+                    {info.url && (
+                      <a
+                        href={info.url}
+                        target="_blank"
+                        rel="noopener noreferrer"
+                        className="underline"
+                      >
+                        {t.viewWorkflow}
+                      </a>
+                    )}
+                  </div>
+                ),
+              };
+            })
+            .filter((item): item is NonNullable<typeof item> => item !== null)
+        : [];
+    const officialItems = hwKeysInData
+      .filter((key) => hwTypesWithData.has(key) && hardwareConfig[key])
+      .map((key) => {
+        const config = hardwareConfig[key];
+        return {
+          name: config.name,
+          label: getDisplayLabel(config),
+          color: resolveColor(key),
+          title: config.gpu,
+          hw: key,
+          isActive: officialHwTypes.has(key),
+          onClick: () => {
+            handleToggleHwType(key);
+            track('latency_hw_type_toggled', { hw: key });
+          },
+          tooltip: null,
+        };
+      });
+    return [...overlayItems, ...officialItems];
+  }, [
+    overlayData,
+    unofficialRunInfos,
+    overlayPoints,
+    runIndexByUrl,
+    hwKeysInData,
+    hwTypesWithData,
+    hardwareConfig,
+    resolveColor,
+    officialHwTypes,
+    handleToggleHwType,
+    t,
+  ]);
+
+  // Per-GPU and pools are two views of the same lines, so either switch turns
+  // the other off; both fall back to the mean.
+  const chooseLineMode = (next: LineMode) => {
+    setLineMode(next);
+    track('inference_power_timeline_lines_changed', { lines: next });
+  };
+  const switches: LegendSwitchConfig[] = [
+    {
+      id: 'power-timeline-per-gpu',
+      label: t.perGpu,
+      checked: lineMode === 'gpu',
+      onCheckedChange: (checked) => chooseLineMode(checked ? 'gpu' : 'mean'),
+      infoTooltip: t.perGpuHelp,
+    },
+  ];
+  if (hasPools) {
+    switches.push({
+      id: 'power-timeline-pools',
+      label: t.pools,
+      checked: lineMode === 'pool',
+      onCheckedChange: (checked) => chooseLineMode(checked ? 'pool' : 'mean'),
+      infoTooltip: t.poolsHelp,
+    });
+  }
+  switches.push({
+    id: 'power-timeline-utility',
+    label: t.utilityLines,
+    checked: showUtility,
+    onCheckedChange: (checked) => {
+      setShowUtility(checked);
+      track('inference_power_timeline_utility_toggled', { enabled: checked });
+    },
+    infoTooltip: t.utilityHelp,
+  });
+
+  const legendElement = (
+    <ChartLegend
+      variant="sidebar"
+      legendItems={legendItems}
+      isLegendExpanded={isLegendExpanded}
+      onExpandedChange={(expanded) => {
+        setIsLegendExpanded(expanded);
+        track('latency_legend_expanded', { expanded });
+      }}
+      onItemHover={(id) => setHighlight(id)}
+      onItemHoverEnd={() => setHighlight(null)}
+      hideAtomFootnote
+      switches={switches}
+    />
+  );
+
+  const runInfos = useMemo(
+    () =>
+      fetchedRequests
+        .map((request) => responses.get(request.runId)?.runInfo)
+        .filter((info): info is NonNullable<typeof info> => Boolean(info)),
+    [fetchedRequests, responses],
+  );
+
+  const toolbar = (
+    <div
+      className="flex flex-wrap items-center justify-end gap-2 pb-1"
+      data-testid="power-timeline-toolbar"
+    >
+      <span className="text-xs text-muted-foreground">{t.timeAxis}</span>
+      <SegmentedToggle<XMode>
+        value={xMode}
+        ariaLabel={t.timeAxis}
+        role="group"
+        options={[
+          { value: 'wall', label: t.wall, testId: 'power-timeline-axis-wall' },
+          { value: 'elapsed', label: t.elapsed, testId: 'power-timeline-axis-elapsed' },
+        ]}
+        onValueChange={(mode) => {
+          setXModeChoice(mode);
+          track('inference_power_timeline_axis_changed', { mode });
+        }}
+      />
+    </div>
+  );
+
+  let emptyMessage: string | null = null;
+  if (loadingRuns > 0) emptyMessage = t.loading(loadingRuns);
+  else if (!hasAnyArtifact) emptyMessage = t.noArtifacts;
+  else if (visibleTraces.length === 0) emptyMessage = t.noTraces;
+
+  return (
+    <div className="relative flex flex-col gap-2" data-testid="power-timeline">
+      <D3Chart<TimelineSample>
+        key={`${chartId}-${xMode}-${lineMode}`}
+        chartId={chartId}
+        data={samples}
+        height={CHART_HEIGHT}
+        margin={MARGIN}
+        watermark={overlayData && overlayPoints.length > 0 ? 'unofficial' : 'logo'}
+        testId="power-timeline-chart-svg"
+        grabCursor
+        instructions={t.instructions}
+        xScale={
+          xMode === 'wall'
+            ? { type: 'time', domain: [new Date(xDomain[0]), new Date(xDomain[1])] }
+            : { type: 'linear', domain: xDomain }
+        }
+        yScale={{ type: 'linear', domain: yDomain, nice: true }}
+        xAxis={{
+          label: xMode === 'wall' ? t.xWall : t.xElapsed,
+          tickValues: (scale) => {
+            const timeScale = scale as
+              | d3.ScaleTime<number, number>
+              | d3.ScaleLinear<number, number>;
+            const [left, right] = timeScale.range();
+            return timeScale.ticks(Math.max(2, Math.min(10, Math.floor((right - left) / 80))));
+          },
+          tickFormat: xTickFormat,
+        }}
+        yAxis={{ label: lineMode === 'pool' ? t.yPool : yLabel, tickCount: 8 }}
+        layers={layers}
+        displayIdentity={activeHighlight ?? ''}
+        onDisplayUpdate={onDisplayUpdate}
+        zoom={{
+          enabled: true,
+          axes: 'x',
+          scaleExtent: [1, 60],
+          resetEventName: `power_timeline_zoom_reset_${chartId}`,
+        }}
+        tooltip={{
+          rulerType: 'crosshair',
+          content: tooltipContent,
+          getRulerX: (sample, xScale) => (xScale as AnyContinuousScale)(sample.x),
+          getRulerY: (sample, yScale) => yScale(sample.y),
+          onHoverStart: (selection) => {
+            selection.attr('r', 5).attr('stroke', 'white').attr('stroke-width', 1);
+          },
+          onHoverEnd: (selection) => {
+            selection.attr('r', 2).attr('stroke', 'none');
+          },
+          attachToLayer: 2,
+        }}
+        legendElement={legendElement}
+        caption={
+          <>
+            {caption}
+            {toolbar}
+          </>
+        }
+        noDataOverlay={
+          emptyMessage ? (
+            <div
+              className="absolute inset-0 flex items-center justify-center px-6 text-center text-sm text-muted-foreground"
+              data-testid="power-timeline-empty"
+              aria-live="polite"
+            >
+              {emptyMessage}
+            </div>
+          ) : undefined
+        }
+      />
+      <div
+        className="flex flex-col gap-1 px-1 text-xs text-muted-foreground"
+        data-testid="power-timeline-status"
+      >
+        {focusedTrace && (
+          <p
+            className="inline-flex items-center gap-2 self-start rounded-full border px-2 py-0.5"
+            data-testid="power-timeline-focus"
+          >
+            <span>
+              {t.focused(
+                `${hardwareLabel(focusedTrace.point)} · ${traceConfigLabel(focusedTrace.point)}`,
+              )}
+            </span>
+            <button
+              type="button"
+              className="underline decoration-dotted hover:text-foreground"
+              data-testid="power-timeline-focus-clear"
+              onClick={() => {
+                setFocusKey(null);
+                track('inference_power_timeline_focus_cleared');
+              }}
+            >
+              {t.showAll}
+            </button>
+          </p>
+        )}
+        {errors.map(({ request, error }) => (
+          <p key={request.runId} className="text-destructive" role="alert">
+            {t.loadError(request.runId, error.message)}
+          </p>
+        ))}
+        {droppedRuns > 0 && <p>{t.droppedRuns(droppedRuns)}</p>}
+        {loadingRuns === 0 && missing.length > 0 && traces.length > 0 && (
+          <p data-testid="power-timeline-missing">
+            {t.missing(missing.length, traces.length + missing.length)}{' '}
+            {describeMissing(missing, t, hardwareLabel)}
+          </p>
+        )}
+        {runInfos.length > 0 && (
+          <p data-testid="power-timeline-source">
+            {t.telemetry}:{' '}
+            {runInfos.map((info, index) => (
+              <React.Fragment key={info.id}>
+                {index > 0 && ' · '}
+                <a
+                  href={info.url}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  className="underline decoration-dotted"
+                >
+                  {`run ${info.id}`}
+                </a>
+                {info.createdAt ? ` (${formatUtcDate(new Date(info.createdAt))})` : ''}
+              </React.Fragment>
+            ))}
+          </p>
+        )}
+        <p>{t.method}</p>
+        {hasPools && <p>{t.methodPools}</p>}
+      </div>
+    </div>
+  );
+}
diff --git a/packages/app/src/components/inference/utils/powerTimeline.test.ts b/packages/app/src/components/inference/utils/powerTimeline.test.ts
new file mode 100644
index 000000000..409a74ad1
--- /dev/null
+++ b/packages/app/src/components/inference/utils/powerTimeline.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+
+import { prioritizeRuns } from './powerTimeline';
+
+describe('prioritizeRuns', () => {
+  const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
+    runId,
+    prefix: '',
+    sources: [],
+  }));
+
+  it('moves overlay runs ahead of official runs and keeps both orders', () => {
+    expect(prioritizeRuns(requests, new Set(['5', '3'])).map((request) => request.runId)).toEqual([
+      '3',
+      '5',
+      '1',
+      '2',
+      '4',
+    ]);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/powerTimeline.ts b/packages/app/src/components/inference/utils/powerTimeline.ts
new file mode 100644
index 000000000..cff71ac26
--- /dev/null
+++ b/packages/app/src/components/inference/utils/powerTimeline.ts
@@ -0,0 +1,344 @@
+/**
+ * Joins chart points to the per-second GPU telemetry behind their measured
+ * average power (the PowerX "Timeline" display).
+ *
+ * Every validated row records its window in `power_audit`, whose `source` is
+ * `power_validation_<name>.json`. Two collectors publish the telemetry:
+ * - single-node runners upload one `gpu_metrics_<name>` CSV artifact per
+ *   config, so the source names the artifact exactly;
+ * - Slurm / Dynamo runners upload one `power_audit_<RESULT_FILENAME>` bundle per
+ *   sweep whose `LOGS/power/samples.csv` covers every concurrency; the API cuts
+ *   it into one series per `power_validation_*.json` it contains and labels
+ *   each with that `source`, so the same file name joins it to the row.
+ * Nothing is matched by hardware or concurrency; points whose telemetry is
+ * missing (expired artifact, another collector) are reported, not guessed.
+ */
+import type {
+  GpuPowerRole,
+  GpuPowerSeries,
+  GpuPowerSeriesResponse,
+} from '@/components/gpu-power/power-series';
+import type { InferenceData } from '@/components/inference/types';
+
+export const POWER_TIMELINE_METRIC_KEY = 'y_measuredPowerTimeline';
+const ARTIFACT_PREFIX = 'gpu_metrics_';
+const SOURCE_PATTERN = /^(?:.*\/)?power_validation_(?<name>.+)\.json$/u;
+
+interface AuditedPoint {
+  power_audit?: { source?: string } | null;
+}
+
+/** The `<name>` of a point's `power_validation_<name>.json` audit source. */
+export function telemetryNameForPoint(point: AuditedPoint): string | null {
+  const source = point.power_audit?.source;
+  if (!source) return null;
+  return SOURCE_PATTERN.exec(source)?.groups?.name ?? null;
+}
+
+/** `gpu_metrics_<RESULT_FILENAME>` for a point, from its power-audit source. */
+export function telemetryArtifactForPoint(point: AuditedPoint): string | null {
+  const name = telemetryNameForPoint(point);
+  return name ? `${ARTIFACT_PREFIX}${name}` : null;
+}
+
+/**
+ * Stable identity of a point's trace: run id plus audit name. Unique within a
+ * chart because the audit name carries the config and the concurrency.
+ */
+export function traceKeyForPoint(point: AuditedPoint & { run_url?: string }): string | null {
+  const runId = runIdFromUrl(point.run_url);
+  const name = telemetryNameForPoint(point);
+  return runId && name ? `${runId}:${name}` : null;
+}
+
+/** Workflow run id from a GitHub Actions run URL. */
+export function runIdFromUrl(url: string | null | undefined): string | null {
+  return url?.match(/\/runs\/(?<runId>\d+)/u)?.groups?.runId ?? null;
+}
+
+export function longestCommonPrefix(values: readonly string[]): string {
+  if (values.length === 0) return '';
+  let prefix = values[0];
+  for (const value of values) {
+    let end = 0;
+    while (end < prefix.length && end < value.length && prefix[end] === value[end]) end++;
+    prefix = prefix.slice(0, end);
+    if (prefix === '') break;
+  }
+  return prefix;
+}
+
+export interface PowerTimelineRequest {
+  runId: string;
+  /** RESULT_FILENAME prefix shared by every wanted artifact of the run. */
+  prefix: string;
+  /** Sorted, unique validation basenames expected by the displayed points. */
+  sources: string[];
+}
+
+/**
+ * One request per workflow run, narrowed to the common RESULT_FILENAME prefix
+ * of the points' artifacts so a sweep of other models is not downloaded.
+ * Points without a run URL or an audit source plan nothing.
+ */
+export function planPowerTimelineRequests(
+  points: readonly InferenceData[],
+): PowerTimelineRequest[] {
+  const byRun = new Map<string, Set<string>>();
+  for (const point of points) {
+    const runId = runIdFromUrl(point.run_url);
+    const artifact = telemetryArtifactForPoint(point);
+    if (!runId || !artifact) continue;
+    if (!byRun.has(runId)) byRun.set(runId, new Set());
+    byRun.get(runId)!.add(artifact);
+  }
+  return [...byRun.entries()]
+    .toSorted(([a], [b]) => a.localeCompare(b))
+    .map(([runId, artifacts]) => {
+      const names = [...artifacts].toSorted();
+      return {
+        runId,
+        prefix: longestCommonPrefix(names.map((name) => name.slice(ARTIFACT_PREFIX.length))),
+        sources: names.map((name) => `power_validation_${name.slice(ARTIFACT_PREFIX.length)}.json`),
+      };
+    });
+}
+
+/** Run id half of a trace key (`traceKeyForPoint`). */
+export function traceKeyRunId(key: string | null | undefined): string | null {
+  const runId = key?.split(':')[0];
+  return runId || null;
+}
+
+/**
+ * Moves the request for `runId` to the front so it survives the per-chart run
+ * cap; the order of the other requests is kept. Returns the same array when
+ * nothing needs moving.
+ */
+export function prioritizeRun(
+  requests: PowerTimelineRequest[],
+  runId: string | null,
+): PowerTimelineRequest[] {
+  const index = runId ? requests.findIndex((request) => request.runId === runId) : -1;
+  if (index <= 0) return requests;
+  return [requests[index], ...requests.slice(0, index), ...requests.slice(index + 1)];
+}
+
+/**
+ * Moves every request whose run is in `runIds` ahead of the others, keeping
+ * the relative order inside both groups. Unofficial-run overlays are loaded
+ * on purpose, so their telemetry must survive the per-chart run cap before
+ * official rows compete for the remaining slots. Returns the same array when
+ * nothing needs moving.
+ */
+export function prioritizeRuns(
+  requests: PowerTimelineRequest[],
+  runIds: ReadonlySet<string>,
+): PowerTimelineRequest[] {
+  if (runIds.size === 0) return requests;
+  const first = requests.filter((request) => runIds.has(request.runId));
+  if (first.length === 0 || first.length === requests.length) return requests;
+  const rest = requests.filter((request) => !runIds.has(request.runId));
+  const moved = first.some((request, index) => requests[index] !== request);
+  return moved ? [...first, ...rest] : requests;
+}
+
+export interface PowerTimelineTrace {
+  /** `traceKeyForPoint(point)`. */
+  key: string;
+  point: InferenceData;
+  runId: string;
+  series: GpuPowerSeries;
+  /** Validated measurement window (UTC ms) from `power_audit`, when recorded. */
+  windowStartMs: number | null;
+  windowEndMs: number | null;
+}
+
+/**
+ * Why a validated point has no trace:
+ * - `no-source`: the row predates `power_audit.source` (older schema), so no
+ *   artifact can be named;
+ * - `no-run`: no workflow run URL to look in;
+ * - `run-not-fetched`: its run is not among the loaded responses (over the
+ *   per-chart run limit, still loading, or the request failed);
+ * - `not-in-run`: the run was loaded but holds neither a matching
+ *   `gpu_metrics_*` artifact nor a power-audit bundle with the point's
+ *   validation file (expired, over the download cap, or another collector).
+ */
+export type MissingTraceReason = 'no-source' | 'no-run' | 'run-not-fetched' | 'not-in-run';
+
+export interface MissingTrace {
+  point: InferenceData;
+  reason: MissingTraceReason;
+}
+
+export interface PowerTimelineJoin {
+  traces: PowerTimelineTrace[];
+  /** Points with a validated average but no telemetry trace, with the reason. */
+  missing: MissingTrace[];
+}
+
+/** Attaches fetched series to points; order follows `points`. */
+export function joinPowerTimeline(
+  points: readonly InferenceData[],
+  responses: ReadonlyMap<string, GpuPowerSeriesResponse>,
+): PowerTimelineJoin {
+  const traces: PowerTimelineTrace[] = [];
+  const missing: MissingTrace[] = [];
+  for (const point of points) {
+    const runId = runIdFromUrl(point.run_url);
+    const name = telemetryNameForPoint(point);
+    if (!name) {
+      missing.push({ point, reason: 'no-source' });
+      continue;
+    }
+    if (!runId) {
+      missing.push({ point, reason: 'no-run' });
+      continue;
+    }
+    const response = responses.get(runId);
+    if (!response) {
+      missing.push({ point, reason: 'run-not-fetched' });
+      continue;
+    }
+    // A bundle-cut series names the point's validation file; a per-config
+    // CSV artifact names the config itself.
+    const source = `power_validation_${name}.json`;
+    const artifact = `${ARTIFACT_PREFIX}${name}`;
+    const series =
+      response.series.find((entry) => entry.source === source) ??
+      response.series.find((entry) => entry.source === undefined && entry.artifact === artifact);
+    if (!series) {
+      missing.push({ point, reason: 'not-in-run' });
+      continue;
+    }
+    const audit = point.power_audit;
+    traces.push({
+      key: `${runId}:${name}`,
+      point,
+      runId,
+      series,
+      windowStartMs: unixSecondsToMs(audit?.window_start_unix),
+      windowEndMs: unixSecondsToMs(audit?.window_end_unix),
+    });
+  }
+  return { traces, missing };
+}
+
+function unixSecondsToMs(seconds: number | undefined): number | null {
+  return typeof seconds === 'number' && Number.isFinite(seconds) ? seconds * 1000 : null;
+}
+
+/** Sample position relative to the validated window. */
+export type WindowPhase = 'before' | 'window' | 'after' | 'unknown';
+
+export function windowPhase(trace: PowerTimelineTrace, timeMs: number): WindowPhase {
+  if (trace.windowStartMs === null || trace.windowEndMs === null) return 'unknown';
+  if (timeMs < trace.windowStartMs) return 'before';
+  if (timeMs > trace.windowEndMs) return 'after';
+  return 'window';
+}
+
+/** Short config label: `TP8 · c64`, plus `PD` for disaggregated points. */
+export function traceConfigLabel(point: InferenceData): string {
+  const parts: string[] = [];
+  if (point.disagg) parts.push('PD');
+  if (typeof point.tp === 'number' && point.tp > 0) parts.push(`TP${point.tp}`);
+  parts.push(`c${point.conc}`);
+  return parts.join(' · ');
+}
+
+// ── Worker-role pools ────────────────────────────────────────────────────────
+
+export type PowerPoolRole = GpuPowerRole | 'all';
+
+export interface PowerPool {
+  role: PowerPoolRole;
+  /** Row indices into `series.power`, in series order. */
+  rows: number[];
+}
+
+const POOL_ORDER: readonly PowerPoolRole[] = ['all', 'prefill', 'decode'];
+
+/**
+ * The GPU pools of a series by worker role, in `prefill`, `decode` order —
+ * only the roles that have at least one device. A series whose collector
+ * assigns no roles yields no pools; callers fall back to `allGpuPool`.
+ */
+export function tracePools(series: Pick<GpuPowerSeries, 'devices' | 'power'>): PowerPool[] {
+  const rows = new Map<PowerPoolRole, number[]>();
+  series.devices?.forEach((device, row) => {
+    if (!device.role) return;
+    if (!rows.has(device.role)) rows.set(device.role, []);
+    rows.get(device.role)!.push(row);
+  });
+  return POOL_ORDER.filter((role) => rows.has(role)).map((role) => ({
+    role,
+    rows: rows.get(role)!,
+  }));
+}
+
+export interface PoolSizeGroup {
+  size: number;
+  roles: PowerPoolRole[];
+}
+
+/**
+ * Pools that hold the same number of GPUs share one rated ceiling, so their
+ * reference draws once, labelled `prefill / decode ×16`, instead of two labels
+ * printed over each other. Sizes ascending, roles in pool order, deduplicated.
+ */
+export function groupPoolsBySize(
+  pools: readonly Pick<PowerPool, 'role' | 'rows'>[],
+): PoolSizeGroup[] {
+  const bySize = new Map<number, Set<PowerPoolRole>>();
+  for (const pool of pools) {
+    if (!bySize.has(pool.rows.length)) bySize.set(pool.rows.length, new Set());
+    bySize.get(pool.rows.length)!.add(pool.role);
+  }
+  return [...bySize.entries()]
+    .toSorted(([a], [b]) => a - b)
+    .map(([size, roles]) => ({
+      size,
+      roles: POOL_ORDER.filter((role) => roles.has(role)),
+    }));
+}
+
+/**
+ * Label row for each reference line: lines at the same watts (different
+ * hardware with an equal pool ceiling) stack their labels upward, slot 0 on
+ * the line and slot n `n` rows above, instead of overprinting. Input order.
+ */
+export function referenceLabelSlots(lines: readonly { watts: number }[]): number[] {
+  const used = new Map<number, number>();
+  return lines.map((line) => {
+    const slot = used.get(line.watts) ?? 0;
+    used.set(line.watts, slot + 1);
+    return slot;
+  });
+}
+
+/** Every GPU of the series as one pool. */
+export function allGpuPool(series: Pick<GpuPowerSeries, 'power'>): PowerPool {
+  return { role: 'all', rows: series.power.map((_, row) => row) };
+}
+
+// ── Deep link from a pinned scatter tooltip ─────────────────────────────────
+//
+// "View power trace" on a pinned tooltip switches the metric to the Timeline
+// display; the timeline mounts afterwards and reads the requested trace here
+// so it can emphasise that config. Module state rather than URL state: the
+// focus is a one-shot gesture, and the share link stays `i_metric` alone.
+
+let pendingFocus: string | null = null;
+
+export function requestPowerTraceFocus(key: string): void {
+  pendingFocus = key;
+}
+
+/** The pending focus request, cleared on read. */
+export function consumePowerTraceFocus(): string | null {
+  const key = pendingFocus;
+  pendingFocus = null;
+  return key;
+}

From 77345164bcd498aa4ab91c6019d2b5ef184f95d3 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 072/103] docs: PowerX persistence runbook and telemetry
 pipeline notes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Document the telemetry digest, receipts, migration prerequisites, targeted repair and
rollback, the gpu-metrics views route, and the new API route entries.

中文：记录遥测摘要、回执、迁移前置条件、定向修复与回滚、gpu-metrics views 路由及新增 API 路由条目。
---
 AGENTS.md                           |   1 +
 docs/dashboard-readonly-views.md    |  13 +-
 docs/data-pipeline.md               | 216 +++++++++++++++++--
 docs/index.md                       |   1 +
 docs/powerx-persistence-recovery.md | 307 ++++++++++++++++++++++++++++
 5 files changed, 520 insertions(+), 18 deletions(-)
 create mode 100644 docs/powerx-persistence-recovery.md

diff --git a/AGENTS.md b/AGENTS.md
index baf40e2dc..61be9ec0e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -85,6 +85,7 @@ API routes (`packages/app/src/app/api/v1/`):
 - `reliability` — raw `ReliabilityRow[]`
 - `evaluations` — raw `EvalRow[]`
 - `server-log` — retrieve benchmark runtime logs
+- `gpu-metrics-point?id=N` — PowerX chip telemetry (samples + per-GPU digest) linked to one benchmark point
 - `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
diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 1ca378966..04294ebce 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -44,7 +44,9 @@ combinations, not the full Cartesian product of all possible filter values.
 - Evaluation/reliability: chart-data, date resolution and rolling aggregation.
 - CollectiveX: selected EP/KV/swap chart and fit helpers.
 - Submissions/images: existing table, weekly/cumulative and image freshness helpers.
-- GPU metrics: shared line/correlation transforms and unsampled statistics.
+- GPU metrics: shared line/correlation transforms and stored full-record per-GPU
+  digests. Live artifacts alone calculate statistics from samples; empty stored
+  digests remain empty. File/host identity and missing-versus-zero semantics persist.
 - Video: checksum-verified stored bundles, serving/fidelity selectors and tradeoffs.
 - Overview/rankings/compare: existing discovery-page assembly and scenario helpers.
 
@@ -61,6 +63,11 @@ OperatorX is feature-gated in navigation and uses page-owned
 contract.
 Zoom, theme, axis scale, labels, media playback and report expansion are renderer
 state. GPU interactive downsampling does not alter returned raw data or statistics.
+The GPU statistics table includes startup and warmup for all chips in the selected
+series, regardless of chip visibility. It is separate from serving-window power,
+J/token and selected-time-window calculations. Run telemetry is DB-first with an
+artifact fallback for missing storage; the public view returns private, no-store
+responses and preserves upstream 503 failures.
 
 Run-specific recognition labels are also presentation-only. Run `35879254139`
 displays `UMBP MoRI SGLang` through October 9, 2026 in America/New_York
@@ -89,6 +96,10 @@ those properties.
 私有上传、密钥、提示词、反馈及管理操作不作为公开读取接口。
 OperatorX 的入口受功能开关控制，页面使用专属的 `/api/v1/operatorx/*`
 接口；目前没有发布 `/api/v1/views/operatorx` 契约。
+GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全记录统计使用所选文件、
+主机序列的全部芯片摘要，包含启动与 warmup；已有摘要为空时不补算，缺失读数不补零。
+芯片显隐和图表降采样不改变该统计，也不改变 serving-window 或 J/token 的计算口径。
+响应使用 private, no-store，上游 503 保留为错误响应。
 
 测试覆盖契约同步及代表性的筛选行为，并未穷举所有参数组合。生产数据库上的
 完整 UI/API 对照仍需集成审查，不能仅凭单元测试宣称已完成。
diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index ca9a196aa..a7a365103 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -84,23 +84,36 @@ must use the append-only contract below.
 
 ### Required Power Publication
 
-Ordinary sweeps that opt into `require-power` upload the producer's
-`required-power-sweep-manifest/sweep_manifest.json`. Before any CI ingest upsert,
-the app matches its required benchmark rows by recipe fingerprint, concurrency,
-and scenario/sequence lengths, then requires valid v2 power and positive energy.
-Disaggregated recipes also require both role energy measurements. Identical
-per-job and collected artifact copies are allowed; conflicting copies fail.
-Matching uses the ingest mapper's canonical identity, including AgentX `users`
-precedence over `conc`. After benchmark writes, any required point omitted by a
-purge or another filter fails the run; purged data is never restored to satisfy
-the declaration.
-
-The manifest must name the source run and head. A successful earlier attempt of
-that same run may supply the scope and retained points when failed jobs are
-rerun; ingestion logs both declared and current attempts. Sweeps without this
-optional manifest keep historical behavior. The separate PowerX publication
-receipt compares ingested 8K/1K and AgentX measurements with the database and
-public API after cache invalidation; it does not assert browser rendering.
+Required ordinary sweeps upload a versioned
+`required-power-sweep-manifest/sweep_manifest.json`. The [shared v2 fixture and
+contract](./fixtures/powerx-manifest-v2/README.md) bind the complete required
+matrix to source run/head/attempt, point identities, topology, exact measurement
+windows, physical node/GPU roles and hashed evidence. Both repositories test the
+same bytes. Unversioned required manifests fail closed; optional legacy bundles
+retain their existing behavior.
+
+Artifact preparation validates required evidence before workflow migrations.
+Required intent also travels in the dispatch payload, so losing both the manifest
+and changelog marker cannot downgrade an ordinary required dispatch. Ingestion
+repeats validation before workflow/config upserts, checks purges/backfills before
+writing, and projects the resulting published curves from base-table state. It
+models the actual latest-attempt, whole-curve and same-image append-only rules.
+An unexplained loss of an existing recipe or concurrency point rejects ingestion.
+Destructive replacement requires exact old-snapshot and lost-point identities in
+the manifest; the ordinary producer supplies no such permission.
+
+The source run and head must match. A successful earlier attempt of that same run
+may supply retained evidence when failed jobs are rerun; ingestion logs declared
+and current attempts. Required energy must be finite and positive. Missing,
+invalid and measured zero remain different values even though all fail this gate.
+Disaggregated deployments require physical evidence for both roles.
+
+This is pure preflight, not atomic publication. Schema migrations occur after
+artifact validation but before the curve check. Concurrent writers and failures
+during the existing per-file importer remain a risk; staging plus an atomic,
+serialized promotion is the follow-up described in the contract. The separate
+PowerX receipt still compares source measurements against the DB and exact-run
+API after ingestion. It does not prove latest-curve visibility or browser rendering.
 
 ### Append-Only Curve Extensions
 
@@ -526,6 +539,175 @@ Producers (`aggregate_power.py`) annotate every aggregate result row with two op
 
 Reads are **permanently tolerant**: `queries/benchmarks.ts` selects the columns as `to_jsonb(br) -> 'power_invalid_reasons'` (and `lb` on the matview branch) rather than bare column references. A bare reference fails during query planning until the next ingest workflow applies the migration, because migrations run in the ingest workflows rather than at Vercel deploy. The key lookup degrades to NULL while the column is missing and is byte-identical once it exists, making deploy order irrelevant.
 
+### PowerX Telemetry Digest (`gpu_metric_*`, migration 016)
+
+Every single-node benchmark job (`benchmark-tmpl.yml`) samples `nvidia-smi` /
+`amd-smi` once per second for its whole lifetime and uploads the CSV as
+`gpu_metrics_<suffix>` next to `bmk_<suffix>` (agentic jobs: `bmk_agentic_<suffix>`,
+still paired by the bare suffix). The multinode template uploads no `gpu_metrics_`
+artifact; its telemetry travels inside `power_audit_<suffix>` as
+`LOGS/power/samples.csv`, one deployment-wide CSV written by srt-slurm's
+`dcgm-power` collector (`timestamp_unix, hostname, gpu_index, gpu_uuid, power_w`,
+power only). `etl/multinode-power-samples.ts` regroups it per host and the ingest
+stores one series per host (`file_name` = `LOGS/power/samples.csv#<hostname>`),
+so multinode and disaggregated points get per-GPU power curves with null clocks,
+temperature and utilization. Single-node jobs upload a `power_audit_` bundle too,
+so discovery and backfill pairing use it only for a suffix with no `gpu_metrics_`
+upload. The PowerX explorer used to download and parse the artifacts from GitHub
+on every request and lost them after GitHub's 90-day retention. CI ingest now
+digests them at ingest time, in the same step that links server logs:
+
+- `gpu_metric_series` — one row per (workflow run, artifact, CSV path): vendor,
+  CSV sha256, sample count, GPU count, recorded window, median cadence, and the
+  parsed sidecars (`gpu_metrics_context.json`, identity, amd-smi energy counters).
+- `gpu_metric_samples` — full-resolution rows, one per (GPU, sample). NVIDIA
+  fills the six common columns; AMD additionally fills edge/memory temperature,
+  voltages, FCLK/SOCCLK and multimedia activity. Timestamps are UTC; NVIDIA's
+  zone-less `YYYY/MM/DD HH:MM:SS.mmm` is interpreted with the context sidecar's
+  `timestamp_timezone` (the producer writes UTC).
+- `gpu_metric_gpu_stats` — per (series, GPU, metric) count/min/max/mean/median/
+  p95/p99/stddev computed at ingest; matching algorithm versions avoid rescanning samples.
+- `benchmark_result_gpu_metrics` — links each benchmark point to the series that
+  was recorded while it ran (several series per point for multinode artifacts).
+
+Ingest is idempotent: the same CSV hash, sidecars, and unique sample count refresh
+only the point links when `stats_version` matches `GPU_STATS_VERSION`. An outdated
+digest is rebuilt without replacing samples or links. A source change replaces the samples and digest inside one
+transaction, including corrected timezone or identity sidecars. Repeated samples
+keep the first row per (GPU, timestamp) before computing counts and statistics,
+matching the sample table's primary key. Explicitly re-ingesting a run also
+repairs older duplicate-inflated counts and digests; `--all` skips runs already
+containing series, so target those runs with `--run` or use `--force`. Series are
+stored per artifact, not per point: an AgentX per-concurrency job maps to one
+point, while older fixed-sequence jobs that swept several concurrencies in one
+job share one series across points. Windowing a series to the measured serving
+interval is a reader concern; the raw series deliberately includes server
+start-up and warm-up so both phases can be inspected.
+
+Run readers filter artifact prefixes and requested Timeline sources in SQL before
+loading samples. The public GPU metrics view loads only its selected file/host
+series while retaining the complete artifact-name inventory. Both point and run
+readers fetch samples in primary-key pages of at most 10,000 rows, preserving
+microsecond cursors and returning the complete selected series in time order.
+
+The point and run readers assemble a series from separate autocommit statements
+(series rows, statistics, samples). After loading, they re-read the series
+version key (`csv_sha256`, `sample_count`, `ingested_at`, `stats_version`) and retry the whole
+read when a re-ingest committed in between, so one payload never mixes the
+statistics of one version with the samples of another.
+
+`bun run admin:db:backfill-gpu-metrics --all --yes` attaches telemetry for runs
+ingested before this migration. The reachable history is bounded by GitHub's
+90-day artifact retention (the upload step sets no `retention-days`) because the
+GCS backup, which keeps every artifact name, only mirrors `schedule` and `push`
+runs on `main`; PR sweeps and manual dispatches — nearly every telemetry-bearing
+run — are never copied. Our own GCS reader (`lib/gcs-artifacts.ts`) additionally
+ignores everything but `bmk_`/`server_logs_` objects, so widening the mirror's run
+filter would also need a reader change before backfill could use it.
+
+Readers: `/api/gpu-metrics?runId=` serves stored telemetry first, including
+`series=power` Timeline buckets reconstructed with retained windows and device
+identities. Missing storage falls back to GitHub artifacts. Known-incomplete CSV
+fallback must match retained filenames and sample counts; known-incomplete bundles
+need exact-source re-ingest. Healthy DB series remain in mixed fallback responses.
+Database failures return `503 DATABASE_UNAVAILABLE`; incomplete storage without
+usable fallback returns `503 STORED_TELEMETRY_INCOMPLETE` with re-ingest guidance.
+Timeline requests use read-only POST with sorted validation basenames in a `sources`
+JSON body. Stored coverage of those identities permits an artifact-independent response;
+missing siblings, including other windows in the same bundle, use source-level DB-first
+merging. Unavailable artifacts leave healthy DB traces readable with explicit missing
+sources. `sourceCoverage` describes only the requested identities; legacy GET reports
+coverage unknown. Plain CSV fallback applies the adjacent context timezone just like
+ingest and bundle reads. Raw multi-file artifacts retain separate file/host series.
+Successful reads and storage errors use no-store.
+
+AgentX nested validation documents are matched to the exact root result and retained
+window before receiving a canonical validation filename alias. Original path, result
+filename and validation hash remain in stored sidecars. CI attaches recovered source
+and window metadata before benchmark publication/upsert; targeted telemetry re-ingest
+fills only NULL provenance for a unique explicit run/result/concurrency match, even
+when samples are unchanged. Metrics and validity remain untouched. Benchmark metadata
+repair additionally needs the existing materialized-view refresh and benchmark-cache
+invalidation before the UI planner can discover the restored Timeline source.
+
+`/api/v1/gpu-metrics-point?id=` powers the PowerX point-detail tab. Every request
+checks the current DB revision before reading its Blob payload cache. Sidecar repairs,
+new point links and shared-series changes therefore select fresh payloads without a
+manual purge. Success, missing-point and error responses use no-store; missing data
+is 404 and database failures remain errors. Cache-write failures log a warning and
+serve the fresh uncached result; the next request retries cache population.
+
+The public `/api/v1/views/gpu-metrics` projection and full-record UI table use the
+same per-GPU statistics digest for the selected file/host series. Current-version
+empty or missing metric digests remain empty. Unversioned or outdated digests
+are recomputed read-only from retained DB samples with the shared ingest algorithm.
+Incomplete retained samples leave statistics empty while preserving raw data for
+the existing source-gap recovery path; stats-only writes fail until the source is repaired.
+Statistics include startup and warmup, retain measured zero, and exclude missing
+readings per metric after first-wins timestamp/GPU deduplication. Mean is
+sample-weighted, percentiles interpolate at `p * (N - 1)`, and standard deviation
+divides by `N`. GPU visibility and chart downsampling do not alter this population.
+Serving-window power, J/token and selected-time-window calculations remain separate.
+
+中文：历史遥测和 Timeline 优先读取数据库；缺少存储数据时回退到 GitHub 产物，
+文件、主机与 GPU 的身份保持独立。数据库故障返回 503；已知存储不完整且无法恢复时，
+返回带定向重新入库提示的 503。Timeline 通过只读 POST 传入所需来源标识；缺失的兄弟曲线
+按来源补齐，GitHub 不可用时仍返回健康的 DB 曲线，并显式标出缺失来源。旧的 GET
+没有预期清单，覆盖状态为 unknown。sourceCoverage 仅描述本次请求，不代表整个 run
+的完整性；普通 CSV 与 bundle、ingest 使用相同的 context 时区。
+点详情每次读取先核对数据库版本，修正 sidecar 或共享关联后
+无需手动清缓存；响应均为 no-store。全记录统计使用已存摘要，包含启动与 warmup；
+缺失读数不补零；当前版本的摘要为空时保留为空，旧版本或无版本摘要从 DB 样本只读重算。它与 serving-window 功率、J/token 和
+用户所选时间窗口的统计分别处理。
+
+### Full-record statistics upgrades (migration 017)
+
+`GPU_STATS_VERSION` identifies the full-record digest algorithm, independently
+of source hashes and serving-window power schema versions. Bump it whenever
+metric populations, mappings, units or statistical definitions change. Migration
+017 marks existing series as version 0 (unknown); it does not certify old digests.
+Readers also treat a not-yet-migrated column as version 0, allowing app deployment
+before the writer migration. Read fallback does not write to the database.
+
+Point-cache revisions include both the deployed algorithm version and the stored
+version, so an algorithm deployment and subsequent digest repair each bypass old
+payloads for every linked point. Browser responses remain no-store; an already
+open tab receives the new result on its existing refetch/focus path.
+
+After applying migration 017 to the explicitly selected DB, use the existing
+backfill entry point (commands below are operator instructions, not automatic writes):
+
+```bash
+bun run admin:db:backfill-gpu-metrics --stats-only --all --dry-run
+bun run admin:db:backfill-gpu-metrics --stats-only --run <run-id> --attempt <attempt> --artifact <artifact-name> --dry-run
+bun run admin:db:backfill-gpu-metrics --stats-only --run <run-id> --attempt <attempt> --artifact <artifact-name> --yes
+```
+
+This mode uses DB samples only: no GitHub, artifact-retention cutoff, GPU work,
+benchmark publication, or cache purge. Unspecified attempts include all stored
+attempts; `--limit` counts series. Each series is locked and its digest/version
+replaced in one transaction. Current versions are no-ops, failures retain the old
+complete digest and print a scoped retry command with a nonzero exit status.
+Missing samples require source re-ingest. Successful retries skip completed series.
+DB `real` columns round to float32; comparisons with original CSV computations
+should allow float32 tolerance (e.g. 1e-5 relative), not require bit equality.
+
+Before production repair, retain a DB snapshot of affected series metadata and
+digests. Rollback stops the repair worker and restores the prior app/ingest build;
+leave the additive column in place. A prior version-aware build recomputes from
+samples when versions differ. To restore pre-versioned software and old stored
+results, restore the saved digest plus version together while writers are stopped,
+then invalidate the legacy cache. Raw samples and links are never changed by
+stats-only repair. Parser/timezone/identity fixes still require source re-ingest.
+
+中文：统计版本独立于数据 revision 和 serving-window schema。迁移先把旧摘要标记为
+未知版本；读取时可从 DB 样本重算，但不写库。`--stats-only` 支持按 run、attempt、artifact
+定向持久修复，也可覆盖全部保留历史，不依赖 GitHub 产物。每个 series 在事务内更新摘要与
+版本，失败保留旧结果并输出重试命令；成功后再次执行为 no-op。部署算法或修复摘要都会
+改变点详情缓存键，页面下次 refetch 时生效。生产修复前保留快照，回滚保留新增列；旧软件
+需要旧摘要时，停写后成对恢复摘要与版本，并清除旧缓存。此过程不修改 samples、关联或
+serving-window 指标。
+
 ### PowerX publication receipts
 
 The normal CI importer writes `POWER_PUBLICATION_MANIFEST` when configured. Each
diff --git a/docs/index.md b/docs/index.md
index 812ef351e..c67e877ae 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -9,6 +9,7 @@ Design rationale and non-obvious conventions. See [CLAUDE.md](../CLAUDE.md) for
 
 - [API Skill Examples](./inferencex-api-examples.md) — Install the public skill, query benchmarks, export measured PowerX data, and explain empty results
 - [PowerX System Power](./powerx-system-power.md) — Pinned chassis model, measured-input guards, assumptions, and reproducible article exports
+- [PowerX Persistence and Recovery](./powerx-persistence-recovery.md) — Telemetry receipts, migration prerequisites, and targeted repair
 - [API Skill Releases](./inferencex-skills-release.md) — Prepare an immutable package, verify clean installations and agent exports, and publish through the package-specific workflow
 - [API Skill Discovery](./inferencex-skills-discovery.md) — Accept or reject implicit skill discovery in fresh Codex and Claude Code projects
 - [CLI Compatibility](./inferencex-cli-compatibility.md) — Contract 1 schemas, bundle and exit semantics, platform scope, and legacy migration
diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
new file mode 100644
index 000000000..898d5ace7
--- /dev/null
+++ b/docs/powerx-persistence-recovery.md
@@ -0,0 +1,307 @@
+# PowerX persistence and repair
+
+PowerX point detail, the run explorer and Power Timeline read migration-016 telemetry
+from the database. Timeline applies the same prefix selection, validation-window cuts,
+60-second padding and one-second per-device means as the artifact path. Stored samples
+retain UTC timestamps, original units and separate host-local GPU identities. GitHub
+remains the fallback for telemetry that has not been stored. Database failures return an
+error, not an empty result or an artifact fallback.
+
+Timeline sends a read-only `POST /api/gpu-metrics?runId=RUN_ID&series=power&prefix=PREFIX`
+with JSON `{ "sources": ["power_validation_RESULT_FILENAME.json"] }`. The planner sorts
+and deduplicates validation basenames, and includes them in the React Query key. The body
+accepts 1–1000 identities, each RESULT_FILENAME up to 200 ASCII letters/digits/`.`/`_`/`-`,
+matching `prefix` when supplied; invalid input returns 400 and bodies above 256 KiB return 413. POST avoids putting a whole run's identity list in a URL. GET remains compatible with
+the raw explorer and existing callers.
+
+Only requested identities absent from healthy DB series trigger artifact discovery. Merging
+prefers DB by validation identity, so a live sibling window in the same bundle is retained.
+`sourceCoverage: { status, missingSources }` reports coverage of the requested identities:
+`complete` or `incomplete` for POST, `unknown` for GET without an expectation list. It is
+not a full-run/sweep or raw-sample completeness receipt. An unavailable GitHub token, listing
+or download keeps healthy requested DB series readable with incomplete coverage; it cannot
+hide known-incomplete stored telemetry or database failures. Unrelated stored artifacts
+outside the requested identities do not block that read.
+
+Live ordinary CSVs and bundle CSVs normalize NVIDIA wall-clock timestamps to ISO UTC with
+the ingest parser, so live and stored reads agree. Adjacent collector context supplies the
+offset; missing or UTC context means zero. Context must be in the same ZIP directory as
+the CSV; host directories never share offsets. When multiple context candidates exist, both
+ingest and live reads select the first valid object in code-unit filename order, independent
+of archive or filesystem listing order. ISO/AMD timestamps pass through unchanged.
+
+Both paths keep the first row for a device/timestamp, matching the existing ingest
+deduplication, before averaging distinct samples within a bucket. A discovered unreadable
+host CSV alongside readable CSVs fails telemetry preparation before any series is written;
+it cannot disappear from the stored inventory and falsely establish complete coverage.
+
+New ingests preserve validation documents, bundle manifests and expected file/sample
+inventories in the existing series sidecars. Older ingests
+can recover validation source/window from linked benchmark `power_audit` provenance.
+Information never retained, such as historical validation role overrides, cannot be
+reconstructed: recover the exact original artifact and re-ingest it. An incomplete
+stored bundle must not silently become a smaller deployment's average. Incomplete stored
+telemetry can use live CSV fallback only when every retained file and deduplicated sample
+count is present. Missing/header-only host files, truncated data, and a second incomplete
+artifact must not disappear behind another artifact's successful recovery. Complete stored
+artifacts remain in a fallback response even if their GitHub artifacts have expired.
+A known-incomplete power bundle needs re-ingest because the downloaded window cuts do not
+prove its full original host/sample inventory. Un-ingested bundles still use normal artifact
+fallback. Unverifiable recovery returns `503 STORED_TELEMETRY_INCOMPLETE` with the artifact
+and a targeted re-ingest action. DB query failures return `503 DATABASE_UNAVAILABLE` and do
+not attempt artifact fallback.
+
+The live raw explorer also keeps each CSV as a separate series, matching the database
+reader. Multi-file artifact labels include the CSV path, so host-local GPU 0 values cannot
+be merged into one device. Single-file labels remain unchanged.
+
+AgentX artifacts may retain their validation at
+`LOGS/agentic/conc_N/power_validation.json`. Both stored and artifact readers recognize
+this layout only when the exact root result filename, its `conc`, and the retained
+`LOGS/power/windows/agentic_power_concurrency_N.json` agree with the validation's
+selected window. Missing, malformed or mismatched evidence does not create a window.
+The normalized source is `power_validation_<root-result-stem>.json`; it is an alias,
+not an invented top-level file. Stored validation sidecars retain `validation_path`,
+`result_file` and the SHA-256 of the original validation bytes. Legacy top-level
+validation documents take precedence, and power-validity and role values stay unchanged.
+
+Normal CI derives missing AgentX benchmark source/window metadata before publication
+and benchmark upsert, retaining it across aggregate copies of the same full point
+identity. Targeted telemetry re-ingest also fills SQL-NULL `power_audit` after all hosts
+are stored and linked, including sample no-ops. It requires one unambiguous AgentX point
+within the caller's explicit run/result IDs with matching concurrency; it neither
+overwrites non-null provenance nor changes metrics, workers or validity. The ingest
+result reports actual `metadataUpdatedBenchmarkResultIds`. Ordinary benchmark reads
+also require the existing `latest_benchmarks` refresh and benchmark cache invalidation;
+point/Timeline revision changes alone do not refresh the UI's benchmark source list.
+
+## Cache and browser recovery
+
+`/api/v1/gpu-metrics-point?id=N` checks a live database revision before reading its existing
+Blob cache. The revision includes linked series, ingest time, CSV hash, sidecars and shared
+point links/audits. The payload stays in Blob; the revision query reads only metadata.
+Same-input ingest leaves the revision unchanged. A sidecar correction, series replacement,
+new point link or linked audit correction selects a new cache entry, including for every
+point sharing the series. Missing points are not negatively cached. A re-ingest that
+commits while the reader is between its statements changes the series version key
+(`csv_sha256`, `sample_count`, `ingested_at`), which the reader re-checks after loading
+and retries, so a payload never mixes statistics and samples from two versions.
+
+Point and Timeline responses use `Cache-Control: no-store`, so CDN/browser response caches
+cannot skip the database check. Client queries revalidate on mount and window focus.
+An already open page refreshes when revisited/refocused or reloaded; there is no continuous
+polling. A failed Blob write logs `serving uncached result`, returns fresh DB data, and is
+retried on the next read. A database failure remains an API error even if an old Blob exists.
+Old cache generations remain until the existing prefix cleanup runs; repair does not require
+a manual PowerX cache purge. General benchmark cache invalidation still follows normal CI.
+
+## Coverage receipts
+
+The existing `power-publication.json` gains an optional `telemetry` receipt, keyed by run,
+attempt and stable benchmark-point identity. Its stages distinguish expected benchmark
+attachments, produced artifacts, stored series/samples, point links and actual API readback.
+Normal CI builds expectations from benchmark rows before telemetry discovery. Backfill
+also inspects benchmark siblings whose telemetry artifact is absent. Unreadable benchmark
+siblings are recorded in `expectationErrors`; known identities still proceed independently.
+
+`plannedPointCount: null` explicitly means the full planned sweep is unknown. Attachment
+coverage over available benchmark rows does **not** prove full sweep coverage. Point,
+artifact, series and sample counts are separate: a bundle can contain multiple host series
+and multiple points can share those series. Receipt entries list missing identities,
+reasons, and exact run/attempt/artifact recovery targets. DB success leaves API status
+`unknown`; only `verify-power-publication.ts` advances it after an actual HTTP read.
+Telemetry failures remain isolated from benchmark publication failure policy.
+
+The expectation boundary is the successfully mapped, non-purged benchmark rows
+selected for ingestion, plus persisted benchmark identities recovered by the
+receipt query. It is not every raw result or every planned job. Mapping/preflight
+errors remain in the existing ingest diagnostics. Unreadable/unmappable benchmark
+rows and failed config resolution make `expectedSource` unknown while retaining
+known point identities; intentionally failed or purged benchmarks remain excluded.
+The telemetry receipt does not
+reconstruct the planned matrix, even when a separate required-power manifest is
+available; `plannedPointCount` stays null. An unreadable backfill benchmark sibling
+sets `expectationErrors` and makes `expectedPoints` unknown, including when its
+telemetry pair exists.
+Backfill preserves mapped points alongside per-row diagnostics for unmappable rows;
+multiple row errors in one benchmark artifact count as one failed artifact. Every
+mapped point in a correction must match a persisted benchmark before telemetry
+ingest can clear that artifact's recovery failure. An uploaded correction with an
+unmatched point is not a successful repair, even when older data remains readable.
+Later refreshes retain unresolved expectation errors until that exact sibling's
+identities can actually be recovered; an expired sibling cannot disappear from
+the unknown denominator.
+This also applies on the first receipt: a selected expired benchmark sibling records
+an expectation error without attempting a download. Superseded retries and unrelated
+targets remain excluded by the existing logical-name and artifact filters.
+Known failed benchmark rows remain excluded, matching normal CI.
+
+Historical backfill retains the resolver's exact-first, unique-fallback offload matching.
+A proven fallback uses the persisted point's offload identity before receipt counting
+and recovery checks, including benchmark siblings whose telemetry is absent. Repeating
+the recovery removes only the corresponding old null-ID phantom in that artifact's
+scope; real on/off points remain distinct. Conflicting artifact observations or prior
+artifact scope stay visible with an unknown denominator rather than overwriting errors.
+
+Normal CI deliberately retains successful artifacts from earlier attempts of the
+same run/head for `rerun-failed`. Receipt `runAttempt` identifies the persisted
+ingest cohort, not the collection attempt of every artifact. Per-artifact collection
+attempt is unknown unless independently retained in source provenance. Do not
+filter the normal artifact plan to the latest attempt and silently drop successful
+points. Explicit `--download .../attempts/N` rejects a different current attempt;
+targeted GitHub telemetry recovery uses its stricter current-attempt filter below.
+
+An empty or wholly unreadable telemetry correction is an ingest failure, even when
+older stored samples remain readable. A targeted recovery retains unresolved
+`recoveryError` and `recoveryArtifactNames` from other artifacts. Sequential successful
+repairs remove only their own artifact names. Older receipts with an unscoped recovery
+error require a successful full-run refresh to clear that error; repairing a different
+artifact cannot establish recovery. Retained error text describes the failed attempts;
+the remaining artifact names identify the outstanding scope.
+
+| Receipt reason       | Targeted action                                                                                                                                                     |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `artifact_missing`   | Recover the exact listed sibling from the same source provenance; use retained local bytes if GitHub no longer has that attempt. Do not substitute a newer attempt. |
+| `ingest_failed`      | Inspect the recorded error, correct the exact artifact or sidecar, then re-ingest it. Empty/unparseable CSVs do not count as a successful correction.               |
+| `point_link_missing` | Re-ingest the named unchanged artifact for the recorded run/attempt. Existing series/samples remain idempotent and the missing link is restored.                    |
+| `expectationErrors`  | Recover the named benchmark sibling first so its point identities can be enumerated; successful telemetry downloads alone do not establish the denominator.         |
+
+Apply the run/attempt/artifact selectors in each point's `recovery` object to the
+commands below, merge the same receipt, then run the HTTP verifier. A missing explicit
+target or deleted GitHub run reports failure. Neither a successful command nor the
+benchmark-level `matched` status establishes telemetry completeness: inspect the
+separate counts, unknowns and outstanding errors.
+
+The stored inventory distinguishes `storage.status` complete/incomplete/unknown. Missing
+host files and mismatched sample counts remain gaps even when the surviving payload can be
+read. `apiReadablePoints` counts actual successful HTTP reads; `apiCompletePoints` additionally
+requires the retained artifact inventory and every point link. Legacy rows without an inventory
+remain unknown until recovered; they do not silently count as complete. A failed correction or
+receipt recovery error also blocks the complete count, even when older data remains readable.
+
+## Full-record statistics
+
+The point detail, run explorer and public `/api/v1/views/gpu-metrics` projection use the
+stored per-GPU digest for the existing full-record statistics, with name mappings only.
+Units and percentile/stddev definitions are unchanged.
+Zero is a value; missing metrics or an empty digest remain missing. Live, un-ingested
+artifact data still computes statistics in the browser. These tables include startup and
+warmup. They are not serving-window power, energy, or user-selected-window statistics.
+
+For each file/host series and GPU, the population keeps the first row at each timestamp,
+then excludes missing or nonfinite readings separately for each metric. Live CSV parsing
+uses the same rule; a missing optional temperature or clock does not discard valid power.
+Count is exact, mean is sample-weighted, P50/P95/P99 use linear interpolation at
+`p * (N - 1)`, and standard deviation uses the population denominator `N`. Multi-host
+GPU indices must remain in separate series. No time weighting, smoothing, chart zoom or
+GPU visibility filter changes the full-record table. Window calculations still consume
+the selected samples, and serving energy/financial metrics retain their own definitions.
+SQL samples and digests use `real` (float32), so compare stored values with an explicit
+float32 tolerance rather than the tighter tolerance of the in-memory parser tests.
+
+## Local verification
+
+From the repository root:
+
+```sh
+bun install --frozen-lockfile --ignore-scripts
+bun run test:unit
+bun run typecheck
+bun run lint
+bun run fmt
+bun run check:typography
+bun run --cwd packages/app test:unit src/app/api/v1/gpu-metrics-point/route.test.ts
+bun run --cwd packages/app test:unit src/app/api/v1/views/gpu-metrics/route.test.ts
+bun run --cwd packages/db test:unit src/queries/gpu-metrics-timeline.test.ts src/etl/telemetry-receipt.test.ts
+```
+
+The ordinary fixture-backed smoke command remains `bun run test:e2e` with an
+`E2E_FIXTURES=1` dev server. The full cross-browser matrix remains the repository CI gate.
+
+## Deployment and targeted data repair (operator review required)
+
+1. Deploy the reviewed application and ingest/backfill code together. Check the target's
+   migration ledger and apply pending migrations with `bun run admin:db:migrate --yes`
+   before running ingest or backfill. This branch adds `016_gpu_metrics.sql` and
+   `017_gpu_metric_stats_version.sql`; writers require the `stats_version` column from 017. CI ingest workflows migrate automatically, but manual backfill does not.
+   Do not run migrations or backfill against production merely to inspect a receipt.
+2. Retain the original publication receipt, exact artifact bytes, sidecars, source run and
+   attempt. Snapshot the target run's telemetry series, samples, digests and point links
+   before correction. Check that the app reads the same database that ingest writes.
+3. Inspect a bounded candidate with the existing command, using explicitly selected
+   target credentials in the operator environment:
+
+   ```sh
+   bun run admin:db:backfill-gpu-metrics --run RUN_ID --attempt ATTEMPT --dry-run
+   ```
+
+4. Once authorized, repair only the named artifact and merge the existing receipt:
+
+   ```sh
+   bun run admin:db:backfill-gpu-metrics --run RUN_ID --attempt ATTEMPT \
+     --artifact EXACT_ARTIFACT_NAME --receipt /path/power-publication.json --yes
+   bun packages/db/src/verify-power-publication.ts /path/power-publication.json https://TARGET_ORIGIN
+   ```
+
+   Before a backfill that may fill missing AgentX `power_audit`, set
+   `CACHE_INVALIDATE_URL=https://TARGET_ORIGIN/api/v1/invalidate` and
+   `CACHE_INVALIDATE_SECRET` (or `INVALIDATE_SECRET`); protected previews also need
+   `CACHE_PROTECTION_BYPASS_SECRET`. The selected app must use the same DB and its
+   existing cache namespace/Blob prefix. No new cache scope is introduced.
+
+   The backfill checkpoints NULL-audit AgentX candidates in the existing manifest
+   before ingest writes. `benchmarkRefresh` records IDs, retained source-derived
+   audit updates, target endpoint, pending/complete/failed status, check time and
+   error. DB audits must match that saved source evidence. Only the matching
+   publication points' NULL audit fields are enriched; original artifact hashes,
+   benchmark values and unrelated points remain unchanged. Without `--receipt`, the
+   existing default is `power-publication-RUN_ID-attempt-ATTEMPT.json`. Missing
+   configuration fails that pair before ingest; configuration errors cannot
+   silently turn a metadata write into a successful backfill.
+
+   After ingest, refresh runs in this order: `latest_benchmarks` materialized view,
+   the existing invalidate endpoint, then exact-run benchmark API comparison by ID
+   and structured `power_audit`. Refresh failure exits nonzero and retains the
+   responsibility even if the next ingest changes no samples or metadata.
+   To retry only that phase, without downloading artifacts or rewriting samples:
+
+   ```sh
+   bun run admin:db:backfill-gpu-metrics --run RUN_ID --attempt ATTEMPT \
+     --receipt /path/power-publication.json --refresh-cache-only --yes
+   ```
+
+   The receipt's run/attempt, point IDs and endpoint must still match. A checkpoint
+   interrupted before its metadata UPDATE leaves NULL candidates. They retain a
+   failed refresh responsibility and require targeted artifact re-ingest; a later
+   upsert clearing an already-written audit cannot erase that responsibility.
+   Invalid/string-encoded audits fail explicitly. HTTP calls have a 30-second
+   timeout; retries use the saved receipt rather than an unrecorded manual purge.
+   Dry runs never refresh. `complete` covers the recorded IDs and API metadata,
+   not browser state, energy validity or deployment-wide acceptance.
+
+   An explicit `--run` is rechecked even if some series already exist. Unchanged inputs
+   are no-ops. The GitHub backfill route accepts only the current source attempt and
+   filters out earlier attempt artifacts; it refuses a mismatched historical attempt.
+   Expired or older-attempt bytes require retained artifacts through the existing local
+   ingest path (`INGEST_ARTIFACTS_PATH` and exact source-run metadata), after operator
+   review. Never substitute another attempt's bytes. A local sidecar correction must be
+   applied to the retained artifact tree; re-downloading unchanged GitHub bytes cannot fix it.
+   The local ingest entry takes `INGEST_RUN_ID`, `INGEST_RUN_ATTEMPT`,
+   `INGEST_REPO=SemiAnalysisAI/InferenceX`, `INGEST_ARTIFACTS_PATH` and
+   `POWER_PUBLICATION_MANIFEST`, then `bun run admin:db:ingest:ci`. It also requires
+   `GITHUB_TOKEN` and the reviewed `DATABASE_WRITE_URL`. Inspect any retained
+   `reused-ingest-metadata/reuse_source_run.json` first: it overrides run/attempt identity.
+
+5. Inspect per-point receipt gaps and both point/Timeline APIs, then refocus/reload the
+   browser. Check expected hosts, GPU IDs, timestamps and digest values. Ingest success
+   alone is insufficient. No telemetry cache purge is required.
+
+For rollback, revert application code only if needed; additive sidecars/receipt fields are
+compatible with the previous schema. Reverting application code restores its old cache
+behavior, so the existing cache invalidation procedure is required in that case. To undo
+a data correction, re-ingest the retained original bytes/sidecars against the exact same
+run/attempt/point identities, or restore only the snapshotted rows in a reviewed transaction.
+Verify links and counts again. Do not delete a shared series to repair one point.
+
+Local tests do not establish deployment, production repair, expired-artifact recoverability,
+or complete published PowerX coverage.

From 99841c9d075ce8fe007fceb494774a483ef8c2a3 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 073/103] docs: PowerX permanent view, power boundaries and
 state ownership
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Document the gated power-boundary metrics and share-link state, the power-basis
derived fields, uniform-host system power modeling, and the dashboard doc index entry.

中文：记录门控的功耗边界指标与分享链接状态、power-basis 派生字段、统一主机的系统功耗建模及 docs 索引条目。
---
 docs/data-transforms.md       |  21 ++-
 docs/powerx-permanent-view.md | 286 ++++++++++++++++++++++++++++++++++
 docs/powerx-system-power.md   |  23 +--
 docs/state-ownership.md       |  74 +++++++++
 4 files changed, 394 insertions(+), 10 deletions(-)
 create mode 100644 docs/powerx-permanent-view.md

diff --git a/docs/data-transforms.md b/docs/data-transforms.md
index 5fef22b39..f5dcd0935 100644
--- a/docs/data-transforms.md
+++ b/docs/data-transforms.md
@@ -64,7 +64,26 @@ Returns `{ chartData: InferenceData[][], hardwareConfig: HardwareConfig }`.
 - `tpPerMw` — `(tputPerGpu * 1000) / hardwarePower` (GPU power in kW, result in tok/s/MW).
 - Cost-per-million fields — GPU hourly cost divided by tokens-per-hour (in millions): `costh` / `costr` for owning-at-large-hyperscaler-volume / 3-year-rental pricing respectively. Three token variants exist: combined (`costh`/`costr`), output-only (`costhOutput`/`costrOutput`), and input-only (`costhi`/`costri`). The former Neocloud tier (`costn`/`costni`/`costnOutput`) was removed; its share-link keys alias to the hyperscaler-volume metric.
 - Infrastructure purchasing-power fields divide tokens per hour by the same hourly costs. Total (`tokensPerDollarH`/`R`), output-only (`outputTokensPerDollarH`/`R`), and input-only (`inputTokensPerDollarH`/`R`) are separate USD Y-axis metrics. The former ¥-priced `tokensPerRmb*` axes and the Neocloud `*PerDollarN` axes were removed; their share-link keys alias to the matching hyperscaler-volume $ metric. The dashboard defaults to the hyperscaler-volume total-tokens-per-dollar axis (`y_tokensPerDollarH`). Links created for the removed API-price `i_metric=y_tokensPerDollar` axis resolve to the same hyperscaler-volume variant.
-- Energy fields — `jTotal` / `jOutput` / `jInput`: `(hardwarePower * 1000) / tputPerGpu` (Joules per token, where power in kW is converted to W).
+- Energy fields — `jTotal` / `jOutput` / `jInput`: `(hardwarePower * 1000) / tputPerGpu` (Joules per token, where power in kW is converted to W). These divide one GPU's all-in power by that GPU's reported throughput; for disaggregated rows `output_tput_per_gpu` is per decode GPU, so `jOutput` ignores the prefill pool. Its semantics are frozen; the whole-deployment view lives in the power boundaries below.
+- Power-boundary fields — see [Power boundaries](#power-boundaries).
+
+#### Power boundaries
+
+`lib/power-basis.ts` derives the three boundaries beyond GPU-measured telemetry as W per allocated GPU plus J per successful output token. `buildDerivedChartFields` calls `buildPowerBasisChartFields(entry, specs)` right after the measured fields, so the official chart, the `?unofficialrun=` overlay (`transformBenchmarkRows`), and Historical Trends (`rowToLightweightPoint` with `requestedMetrics`) share one formula set; each key is gated by `wants(key)` so selective output stays exact.
+
+| Basis                                         | W / GPU                                                                    | J / output token                   | Fields                                                             |
+| --------------------------------------------- | -------------------------------------------------------------------------- | ---------------------------------- | ------------------------------------------------------------------ |
+| B1 GPU measured                               | `avg_power_w`                                                              | `joules_per_output_token`          | existing `measuredAvgPower`, `measuredJPerOutputToken` (unchanged) |
+| B2 GPU provisioned                            | `HW_REGISTRY.tdp`                                                          | `W × N_alloc ÷ total output tok/s` | `gpuProvisionedWatts`, `gpuProvisionedJPerOutputToken`             |
+| B3 utility provisioned (all-in)               | `HW_REGISTRY.power × 1000`                                                 | `W × N_alloc ÷ total output tok/s` | `utilityProvisionedWatts`, `utilityProvisionedJPerOutputToken`     |
+| B4 utility modeled (measured → chassis → PUE) | `modeledSystemPower.deploymentFacilityWatts ÷ modeledSystemPower.gpuCount` | `B1 J/out × (B4 W ÷ B1 W)`         | `utilityModeledWatts`, `utilityModeledJPerOutputToken`             |
+
+- **N_alloc and total throughput** (`powerBasisNormalization`). Aggregate rows report output per allocated GPU, so `N_alloc` cancels and the builder uses `W ÷ output_tput_per_gpu` without trusting display counts (legacy ingest can encode TP × EP twice). Fixed-sequence disaggregated rows (`disagg && benchmark_type === 'single_turn'`) report output per decode GPU while the deployment also powers the prefill pool, so `total output tok/s = output_tput_per_gpu × num_decode_gpu` and `N_alloc = num_prefill_gpu + num_decode_gpu`; the article's 4P+4D counts eight GPUs, and B3 energy is `(P + D) / D` times `jOutput` on such rows. Other disaggregated benchmark types emit no provisioned energy because it is not verifiable in-app whether AgentX throughput already divides by all GPUs.
+- **B4 source.** Reuses the `SystemPowerEstimate` that `rowToAggDataEntry` attached as `entry.modeledSystemPower`; nothing re-runs `modelSystemPower`. `deploymentFacilityWatts` is chassis AC × PUE with PUE applied exactly once inside `estimateChassisPower`, divided by the physical measured GPU count (not `modeledGpuCount`, which over-counts partially allocated chassis: a 4P+4D deployment on two worker hosts models 16 GPUs while measuring 8, and the unit test pins that divisor). This is a different quantity from the existing `modeledChassisPowerPerGpu` (chassis AC ÷ modeled GPU count, no PUE). Modeled energy scales the producer's same-window `joules_per_output_token` by `B4 W ÷ avg_power_w`, so it inherits B1's token denominator and survives rows whose `output_tput_per_gpu` is missing (the provisioned energies do not; a per-basis point count cannot assume one shared denominator).
+- **Null rules.** A value is emitted only when finite and positive; otherwise the key is omitted (never `{ y: 0 }`), because the metric filters drop points by `metricKey in point` and `remapInferencePoint` falls back to raw throughput when a key exists with an unusable value. B2/B3 W are absent for hardware without registry specs (`getGpuSpecs` returns zeros); their energies are also absent without output throughput or disaggregated counts. B4 requires `modeledSystemPower.status === 'supported'` and B1 watts (`avg_power_w` after `rowToAggDataEntry`'s `power_valid !== 0` admission); B4 energy additionally needs `joules_per_output_token`. Telemetry admission belongs to `modelSystemPower`, which accepts `power_valid === 1` with schema v2 or the validated unversioned single-node producer (`telemetryBasis: 'validated-unversioned-single-node'`), so B4 renders on exactly the rows that show B1 and `modeledChassisPowerPerGpu`; off-8k/1k workloads, unsupported hardware such as GB200/GB300 NVL72 (`reason: 'hardware'`), and telemetry/topology failures withhold it. The public API's `strictV2` row filter is not re-applied in the chart for B1, so it is not re-applied for B4 either (plan §3.1 describes B1 with that filter; the app's chart path is the authority here).
+- **Ordering invariant** (unit-tested on real B200 telemetry): B3 ≥ B4 ≥ B1 and B2 ≥ B1 for both W/GPU and J/out on the same point.
+- **Reconstructed prefill energy** (`reconstructedPrefillJPerOutputToken`, `utils/role-energy.ts`). For validated (`power_valid === 1`, schema 2) disaggregated rows, `prefill_joules_per_input_token × (joules_per_output_token ÷ joules_per_input_token)` carries the prefill pool's energy onto the output-token axis: the ratio is the served input:output token count because schema-2 aggregate energy has one numerator. With `decode_joules_per_output_token` it sums back to the deployment's J/out. It feeds only the `i_pcompare=roles` comparison on the energy axis (PowerX Figure 7) and is never a y-axis of its own; aggregate rows and rows missing any of the four inputs omit it.
+- Historical Trends substitutes `output_tput_per_gpu := tput_per_gpu` for legacy rows lacking output throughput; provisioned energies in trends inherit that fallback.
 
 **GPU specs lookup** happens inside `buildDerivedChartFields`. `getGpuSpecs(hwKey)` (`lib/constants.ts`) splits on `[-_]` to extract the base GPU token (for example, `"b200_trt_mtp"` becomes `"b200"`) and looks it up in `HW_REGISTRY`. Missing keys return zeroed specs, producing `0` cost/energy values rather than crashing.
 
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
new file mode 100644
index 000000000..8e3725ca2
--- /dev/null
+++ b/docs/powerx-permanent-view.md
@@ -0,0 +1,286 @@
+# PowerX Permanent View
+
+How the PowerX article's power-boundary figures live inside `/inference` instead of a
+separate page. The measured-power UI, the four power boundaries, and their share links all
+sit in the existing ↑↑↓↓-gated **Measured Energy** metric group.
+
+## Purpose
+
+The article compares one deployment's power at four boundaries, from the GPU board to the
+utility meter, both as W per GPU and as J per output token. The dashboard already had
+GPU-measured telemetry (`measured*` metrics) and an ungated all-in provisioned energy
+(`jOutput`). This view adds the other boundaries as ordinary y-axis metrics so every chart
+feature (zoom, tooltip, Perf Ruler, Optimal Only, Table, CSV, PNG, `?unofficialrun=` overlay,
+share URL) applies unchanged. One chart engine, no second chart component.
+
+## Gate
+
+The Measured Energy group is `gated: true` in `metric-registry.ts`. `ChartControls` hides a
+gated group while the gate is locked unless the selected `i_metric` belongs to it, so a
+shared link to any boundary renders for a reader who never unlocked the gate, while the
+group stays out of the selector otherwise. The boundary metrics are members of that group
+(`POWER_BASIS_METRIC_CONFIG_KEYS` is spread into it) so they inherit exactly this behaviour.
+
+## Boundaries
+
+| Basis (`PowerBasis`)  | Selector label               | W / GPU metric                               | J / output token metric                           | Source                                                                  |
+| --------------------- | ---------------------------- | -------------------------------------------- | ------------------------------------------------- | ----------------------------------------------------------------------- |
+| `gpu-measured`        | GPU measured                 | `y_measuredAvgPower` (+P75/P90, roles, %TDP) | `y_measuredJPerOutputToken` (+ input/total/query) | runner telemetry; existing metrics, unchanged                           |
+| `gpu-provisioned`     | GPU provisioned (TDP)        | `y_gpuProvisionedWatts`                      | `y_gpuProvisionedJPerOutputToken`                 | `HW_REGISTRY.tdp`                                                       |
+| `utility-provisioned` | Utility provisioned (all-in) | `y_utilityProvisionedWatts`                  | `y_utilityProvisionedJPerOutputToken`             | `HW_REGISTRY.power` (all-in kW per GPU)                                 |
+| `utility-modeled`     | Utility modeled (PUE)        | `y_utilityModeledWatts`                      | `y_utilityModeledJPerOutputToken`                 | `modelSystemPower` chassis AC × PUE 1.3 (applied once), ÷ measured GPUs |
+
+Formulas, the all-GPU normalization (`N_alloc` = prefill + decode GPUs for disaggregated
+rows) and the null rules are specified in
+[Data Transforms → Power boundaries](./data-transforms.md#power-boundaries); the chassis model
+itself in [PowerX System Power](./powerx-system-power.md). The ungated `jOutput` keeps its
+per-decode-GPU normalization; its labels and the boundary metric's `all GPUs` label keep the
+two distinguishable in the selector, the availability list and CSV headers.
+
+Every boundary metric has `polarity: 'lower'`. Energy metrics therefore get the usual
+lower-is-better Pareto frontier. The three watt keys are listed in `POWER_CURVE_METRICS`
+(`utils/powerCurves.ts`), so `ScatterGraph`/`GPUGraph` draw the upper power envelope for them
+exactly as for `y_measuredAvgPower`, and Optimal Only keeps every load point; the declared
+`lower_*` roofline only drives the ascending Table sort. They stay out of
+`isMeasuredPowerCurveMetric`, like `y_modeledChassisPowerPerGpu`, so telemetry-only decorations
+do not apply. `measured-power-direction.test.ts` pins both halves. A flat provisioned series
+(TDP or all-in W is one constant per hardware) has a single envelope vertex per hardware, so no
+envelope line is drawn for it — only the points.
+
+## Why the metric key carries the boundary
+
+There is no `i_pbasis` URL parameter. The Boundary select in `MeasuredMetricControls` is
+presentation over `selectedYAxisMetric`, exactly like Per / Scope / Statistic / Display /
+Unit: `measured-metric-config.ts` gives every Measured Energy key a `basis` and resolves each
+control change to the nearest registered key. Consequences:
+
+- One share link per figure, and `i_metric` already round-trips through every existing
+  surface (share button, Historical Trends hand-off, Table, CSV header).
+- Existing links are byte-identical: all `measured*` keys carry `basis: 'gpu-measured'`, and
+  `MEASURED_METRIC_DEFAULTS` did not change.
+- Choosing a derived boundary snaps to its canonical combination (whole deployment, average
+  watts, joules per output token). Changing any telemetry-only setting while on a derived
+  boundary returns to GPU measured, so no control ever points at a key that does not exist.
+- A gated metric selected through a shared URL keeps its Measured controls, as the
+  `measured*` siblings already do.
+- The Y-axis dropdown's collapsed "Measured Power" / "Measured Energy" option for the other
+  family resolves to `MEASURED_METRIC_DEFAULTS[family]` (GPU measured), so switching family
+  from the dropdown resets the boundary; the resolver itself keeps `basis` on a family change
+  (`changeMeasuredMetricConfig(key, { family })`), which is what a future family control in
+  the Measured row should call.
+
+The Boundary select tracks `inference_power_basis_changed { basis, family }` in addition to the
+existing `inference_y_axis_metric_selected` fired by `ChartControls`.
+
+## Missing values
+
+A point without a value for the selected boundary is omitted from that series only (the
+builders never emit `{ y: 0 }`, and both the official and overlay paths filter by
+`metricKey in point`). The PowerX availability panel explains the gap per point:
+
+| State              | Meaning                                                                                                                                                  |
+| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `noSpec`           | hardware has no `tdp` / `power` in `HW_REGISTRY`                                                                                                         |
+| `noThroughput`     | provisioned watts exist but the row has no output throughput                                                                                             |
+| `noNormalization`  | disaggregated row with throughput but no whole-deployment GPU count (`powerBasisNormalization`: not `single_turn`, or non-integer prefill/decode counts) |
+| `noTelemetry`      | modeled boundary needs validated GPU telemetry (B4 follows B1)                                                                                           |
+| `invalid`          | `power_valid === 0`                                                                                                                                      |
+| `modelWorkload`    | chassis model covers 8K / 1K only                                                                                                                        |
+| `modelHardware`    | hardware outside the chassis profiles (GB200 / GB300 NVL72)                                                                                              |
+| `modelUnsupported` | other `modelSystemPower` reasons (gpu-count, topology, role-power …)                                                                                     |
+
+The chart caption (`data-testid="power-basis-assumptions"`) names the boundary, the formula in
+words, the PUE constant and the chassis-model revision so a screenshot records its method.
+The pinned tooltip's "Modeled system power" block (`tooltipUtils.ts` `modeledSystemPowerHTML`)
+renders only for `measured*` keys and `y_modeledChassisPowerPerGpu`, so on the boundary keys the
+caption is the only per-chart provenance; the caption does not promise more.
+The empty state for the utility-modeled boundary says why nothing rendered and points at the
+Boundary select.
+
+## Article figure → share link
+
+Base: `/inference?g_model=<model>&i_seq=8k/1k&i_prec=<precision>` plus the hardware legend
+selection. Append:
+
+| Figure | Content                                       | Parameters                                                                                                                                                               |
+| ------ | --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 2      | H200 W/GPU, all four boundaries on one chart  | `&i_metric=y_measuredAvgPower&i_pcompare=boundaries` (one boundary at a time: `&i_metric=y_gpuProvisionedWatts` / `y_utilityProvisionedWatts` / `y_utilityModeledWatts`) |
+| 3      | H200 J/output token, all four boundaries      | `&i_metric=y_measuredJPerOutputToken&i_pcompare=boundaries` (single boundary: the matching `…JPerOutputToken` key)                                                       |
+| 4 / 5  | B200 vs B300, GB200 vs GB300 at fixed X       | `&i_metric=<measured key>&i_rulers=<x>` (Perf Ruler, T1)                                                                                                                 |
+| 6      | Prefill vs decode W/GPU with the whole deploy | `&i_metric=y_measuredAvgPower&i_pcompare=roles`                                                                                                                          |
+| 7      | Reconstructed request energy, prefill share   | `&i_metric=y_measuredJPerOutputToken&i_pcompare=roles` (prefill share in the clone's tooltip)                                                                            |
+| 1      | Measured power over the benchmark job         | `&i_metric=y_measuredPowerTimeline` (Display → Timeline, see below)                                                                                                      |
+
+Pinned official dashboard points now offer **View PowerX** when the feature gate is unlocked
+or a measured-metric share link is active. The lazy in-page dialog reads the existing
+`GET /api/v1/gpu-metrics-point?id=N` API, without entering a run ID or changing chart filters.
+This also works in the hardware/date comparison view. The per-chip chart and statistics span
+the recorded job (including startup/warmup), not just the audited serving window. Fixed-sequence
+points do not request AgentX server-metric overlays. Missing telemetry is shown as unavailable,
+not zero power. Unofficial points have no database ID and retain **View power trace**, which
+resolves their run/audit provenance automatically. No API contract or ingestion changes are
+needed for this presentation-only entry point.
+
+The `/gpu-metrics` page keeps the raw per-run explorer (every metric, one artifact at a time);
+the timeline below is the chart-scoped view of the same artifacts.
+
+## Comparison series (`i_pcompare`)
+
+`i_pcompare=boundaries|roles` (default `''`, "Off") overlays sibling series on the selected
+metric without changing it. `utils/power-compare.ts` is the single source: `useChartData` and
+the `?unofficialrun=` processor (`processOverlayChartDataWithClipping`) both call
+`expandPowerCompareSeries`, which appends one clone per sibling to every base point — same
+`x`, `y` taken from the sibling's field, `powerVariant` set — and leaves the base points
+untouched, so a chart without a comparison is byte-identical to before. A point lacking a
+sibling's value contributes nothing to that series (never a 0), so each boundary's and
+role's availability rules carry through unchanged.
+
+| Mode         | Base series                                       | Siblings                   | Fields                                                                                                                                                                               |
+| ------------ | ------------------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `boundaries` | the selected boundary (`basis` of the metric key) | the other three boundaries | `measuredAvgPower` / `POWER_BASIS_FIELDS[*].watts`, or `measuredJPerOutputToken` / `POWER_BASIS_FIELDS[*].energy`                                                                    |
+| `roles`      | the selected scope (`all`, `prefill`, `decode`)   | the other two worker pools | W: `measuredAvgPower`, `measuredPrefillAvgPower`, `measuredDecodeAvgPower`; J/out: `measuredJPerOutputToken`, `reconstructedPrefillJPerOutputToken`, `measuredDecodeJPerOutputToken` |
+
+Siblings exist only where the metric names the whole-deployment **average W/chip** or **J per
+output token** (the only quantities every boundary and role publishes on one axis); role
+energy additionally excludes the prefill J per input token scope. Elsewhere
+`powerCompareVariants` returns nothing, the Compare select disables the option, and — when a
+link arrives with an inapplicable mode — a hint (`measured-compare-hint`) says the comparison is
+paused. The parameter is kept, so switching back to an applicable setting resumes it.
+
+Rendering (`ScatterGraph`): the series key is `scatterSeriesKey(point)` =
+`<hwKey>_<precision>[-v-<variant>]` (`utils/point-identity.ts`), so rooflines, frontiers,
+Optimal Only, line labels, overflow continuations and the perf ruler treat each sibling as its
+own series; `parseScatterSeriesKey` recovers hardware, precision and variant wherever the key
+was previously split on `_`. Siblings keep the hardware colour (overlay runs keep the run
+colour) and take a per-variant `stroke-dasharray` (`powerVariantDash`); clone points render
+at 0.6 opacity behind their base and carry `data-power-variant`. Line labels are placed per
+hardware _and_ sibling: the base series keeps its plain hardware label, while a sibling appends
+` · <short name>` (`powerLineLabelSuffix`: TDP, All-in, PUE modeled, Prefill GPUs, …) and, when a
+boundary is flat on a watts axis, its shared value (`B300 (SGLang) · TDP 1.2 kW`), so an exported
+PNG explains its dashed lines without the legend; each pill carries `data-series-id`
+(`<hw>::<variant>` for a sibling) and `data-power-variant`. The legend appends one
+line-swatch row per series present (base first); rows toggle chart-local visibility
+(`hiddenPowerVariants`, not in the URL) and hover-highlight that series across every hardware.
+`scatterPointConfigId` includes the variant so a clone never replaces its base in a D3 join.
+Tooltips add a "Series" line; on the energy axis a role clone also reports its share of the
+reconstructed request energy. Table adds a "Series" column and CSV a trailing "Power Series"
+column only while clones are present. Comparison clones are excluded from `bestSeriesPerSku`,
+the power-tier counts, the legend points table, the availability panel (which reads
+`selectionPoints`) and the date-comparison `GPUGraph`. Unofficial-run pills read `✕ <hardware>` (`getOverlayLineLabel`); the branch stays in the
+legend and a short run tag (` · main`, ` · …<date>-<sha>`) is appended only when several overlay
+runs draw the same hardware.
+
+Figure 7's reconstruction lives in `utils/role-energy.ts`: schema-2 aggregate energy has one
+numerator, so `J/out ÷ J/in` is the served input:output token ratio and
+`prefill_joules_per_input_token × (J/out ÷ J/in)` is the prefill pool's energy per output
+token; with `decode_joules_per_output_token` it sums back to the deployment's J/out when the
+pool energies partition the total. `buildDerivedChartFields` emits it as
+`reconstructedPrefillJPerOutputToken` for validated (`power_valid === 1`, schema 2)
+disaggregated rows only; it is never a y-axis of its own.
+
+The Compare select tracks `inference_power_compare_changed { mode, family }`; legend rows
+track `inference_power_compare_series_toggled { series, visible }`.
+
+## Power timeline (Display → Timeline)
+
+`y_measuredPowerTimeline` is the third value of the Measured Power **Display** control
+(`watts` / `tdp` / `timeline`, `MeasuredPowerDisplay` in `measured-metric-config.ts`). Its
+registry field aliases `measuredAvgPower`, so the point set, the availability panel, the Table
+view and the share link are those of the measured average; only the chart body changes:
+`ChartDisplay` renders `ui/PowerTimeline.tsx` instead of `ScatterGraph` when the resolved
+config is `display: 'timeline'`.
+
+- **Join.** Each validated row's `power_audit.source` is `power_validation_<name>.json`.
+  Two collectors publish the telemetry behind it (`utils/powerTimeline.ts`):
+  - single-node runners upload one `gpu_metrics_<name>` CSV artifact per config
+    (`benchmark-tmpl.yml`), so the source names the artifact exactly
+    (`telemetryArtifactForPoint`);
+  - Slurm / Dynamo disaggregated runners upload one `power_audit_<RESULT_FILENAME>` bundle per
+    concurrency sweep whose `LOGS/power/samples.csv` (DCGM, `<hostname>/<GPU-uuid>` per device)
+    covers every concurrency. The API cuts it into one series per `power_validation_*.json` the
+    bundle contains (`components/gpu-power/power-audit-bundle.ts`: the validation file's
+    `selected_window` ± 60 s, roles from its `per_gpu_role`, manifest `expected_devices` as the
+    fallback) and labels each with that file name in `series.source`, which `joinPowerTimeline`
+    matches before falling back to the artifact name.
+
+  Nothing is matched by hardware or concurrency. Rows whose telemetry is missing (expired
+  artifact, bundle over the download cap, another collector) are listed under the chart
+  (`data-testid="power-timeline-missing"`), never estimated. Trace keys are
+  `<runId>:<name>` (`traceKeyForPoint`), unique per point in both collectors.
+
+- **Fetch.** One request per workflow run in the visible points
+  (`planPowerTimelineRequests`, at most `POWER_TIMELINE_MAX_RUNS`; a deep-linked trace's run
+  goes first, then `?unofficialrun=` overlay runs, then official runs — `prioritizeRun` /
+  `prioritizeRuns` — so an overlay the user asked for is never the run that gets dropped),
+  narrowed with
+  `prefix=` to the common RESULT_FILENAME prefix so a nightly sweep's other models are not
+  downloaded. `/api/gpu-metrics?series=power` first uses persisted telemetry and returns one-second per-GPU buckets
+  (`components/gpu-power/power-series.ts`, ~1 MB for a 25-config run instead of ~27 MB of
+  raw rows). Missing stored telemetry falls back to artifacts; database failures are explicit errors.
+  See [persistence and repair](./powerx-persistence-recovery.md) for cache freshness and coverage receipts.
+  With `series=power` the artifact fallback also downloads `power_audit_*` bundles whose name
+  shares the prefix (a bundle names the sweep, so the match runs both ways), reads only
+  `LOGS/power/samples.csv`, `LOGS/power/manifest.json` and the top-level
+  `power_validation_*.json` entries, and skips bundles above 256 MiB (the GB200 nw8 sweep is
+  215 MB). A bundle-cut series carries `source` and `devices[] { id, role? }`; CSV series carry
+  neither. Runner timestamps are UTC wall clock and are parsed as such
+  (`parseTelemetryTimestampUtc`); `new Date('2026/09/12 20:19:57')` would read browser local
+  time and misplace the audit window.
+- **Legend with overlays.** Once `?unofficialrun=` data is in, the chart reads
+  `localOfficialOverride`, so the timeline legend writes the unified selection
+  (`setUnifiedOverlaySelection`, `computeToggle` solo semantics) exactly as `ScatterGraph`
+  does; the context's `toggleHwType` alone would change nothing visible there.
+
+- **Drawing.** One trace per config, mean of its GPUs (legend switch: one line per GPU),
+  coloured by hardware for official rows and by `overlayRunColor(runIndex)` for
+  `?unofficialrun=` rows; legend toggles follow `activeHwTypes` / `activeOverlayHwTypes`
+  exactly as in `ScatterGraph`. The whole job is drawn faint and the `power_audit` window
+  emphasized (`data-segment="full" | "window"`). Rated TDP is a dashed reference per hardware;
+  the all-in provisioned line is an opt-in legend switch because it halves the traces'
+  vertical resolution. X axis: wall clock (UTC) when the visible traces come from one run,
+  otherwise seconds since each trace's start; both are a toolbar toggle. `c<conc>` labels sit
+  at the end of the emphasized segment.
+- **Pools (Figure 1).** The legend switch _Prefill / decode pools_ (shown when a visible
+  trace carries worker roles) sums the board power of each role's GPUs
+  (`tracePools` / `sumPowerAt`) and draws one line per pool — prefill dashed `7 3`, decode
+  `2 3`, the same dashes as the `i_pcompare=roles` series — labelled `c<conc> · prefill` /
+  `· decode`, on a _GPU pool power (W)_ axis. Traces without roles draw their deployment total
+  as one `all` line so single-node configs stay comparable. Reference lines become pool size ×
+  rated TDP per (hardware, pool size): roles of one hardware that hold the same GPU count share
+  one line labelled `prefill / decode ×16` (`data-pool` on `.power-reference` lists the roles,
+  `groupPoolsBySize`), and labels of lines at equal watts stack upward (`referenceLabelSlots`)
+  instead of overprinting; and the
+  all-in switch scales the same way. The tooltip names the pool, its summed watts against the
+  pool TDP, and the mean / min / max per GPU inside it. Pool mode and per-GPU lines are
+  mutually exclusive.
+- **Deep link.** A pinned scatter tooltip on any metric of the measured family offers _View
+  power trace_ (`data-action="view-power-trace"`, official and `?unofficialrun=` points
+  alike). It switches the Display to Timeline in place and records the point's trace key in a
+  one-shot module store (`requestPowerTraceFocus`); the timeline consumes it on mount, dims
+  every other trace, switches to pool mode when the trace has roles, and shows a _Focused on …_
+  chip (`data-testid="power-timeline-focus"`) with _Show all_ to clear. The link's `href` is
+  the current page with `i_metric=y_measuredPowerTimeline`, so open-in-new-tab lands on the
+  timeline (unfocused: the focus is a gesture, not URL state).
+- **State.** Axis mode, line mode (mean / per GPU / pools), the all-in switch, the focused
+  trace and hover highlight are component state, not URL state: the share link is `i_metric=y_measuredPowerTimeline` plus the usual
+  scope, and a reader lands on the same defaults.
+- **Analytics.** `inference_power_timeline_loaded { traces, missing, runs }`,
+  `inference_power_timeline_axis_changed { mode }`,
+  `inference_power_timeline_lines_changed { lines: 'mean' | 'gpu' | 'pool' }`,
+  `inference_power_timeline_utility_toggled { enabled }`,
+  `inference_power_trace_opened { hwKey, conc, overlay }` (scatter tooltip action),
+  `inference_power_timeline_focus_cleared`.
+
+## Tests
+
+- `lib/power-basis.test.ts` and `lib/chart-utils.test.ts` — the six boundary values through
+  the real builder, and the same fields on `?unofficialrun=` overlay rows.
+- `gpu-power/power-series.test.ts`, `power-audit-bundle.test.ts` — one-second buckets with
+  `null` gaps, a partial pool is a gap rather than a lower sum, and bundle rows stay on their
+  host/device and role inside the padded window.
+- `utils/powerTimeline.test.ts` — overlay runs are fetched ahead of official runs.
+- `api/gpu-metrics/route*.test.ts` — the stored digest shape, DB-first serving, database
+  failure as 503, known missing hosts, and the retained-inventory recount before a CSV
+  fallback.
+- `cypress/component/power-timeline.cy.tsx`, `power-compare.cy.tsx` — overlay-run colour and
+  the overlay hardware filter.
diff --git a/docs/powerx-system-power.md b/docs/powerx-system-power.md
index e1e1e5426..4eec8f70b 100644
--- a/docs/powerx-system-power.md
+++ b/docs/powerx-system-power.md
@@ -95,15 +95,20 @@ facility kW/GPU used to calculate capacity per GW. Consequently, revenue,
 compute expense, license fee, and profit scale together; profit margin does not
 change. Electricity expense is not recomputed separately.
 
-This opt-in AgentX estimate requires validated schema-v2 telemetry and a
-single-node chassis supported by the pinned model. Validated 1/2/4-GPU allocations
-use the existing full-chassis extrapolation: fill an eight-GPU server with whole
-replicas at the measured per-GPU power and throughput, then divide modeled facility
-power by eight. This assumes replica co-location does not change performance or
-power; it is not a measurement of a partly idle server. The chart, tooltip, and CSV
-label every extrapolated estimate, including interpolation with one partial knot.
-Unsupported GB200/GB300 chassis, multi-node layouts, allocations that cannot tile
-eight GPUs, and missing/invalid measurements stay unavailable with distinct reasons.
+This opt-in AgentX estimate requires validated schema-v2 telemetry and chassis
+supported by the pinned model. Fully measured eight-GPU chassis are supported
+on a single node, per measured worker host, or across an aggregate multinode
+deployment without per-worker telemetry at the deployment-mean GPU power
+(`topologyBasis: 'uniform-hosts'`; symmetric TP/PP/DP shards load each host alike).
+Validated single-node 1/2/4-GPU allocations use full-chassis extrapolation: fill
+an eight-GPU server with whole replicas at the measured per-GPU power and
+throughput, then divide modeled facility power by eight. This assumes replica
+co-location does not change performance or power; it is not a measurement of a
+partly idle server. The chart, tooltip, and CSV label every extrapolated estimate,
+including interpolation with one partial knot. Unsupported GB200/GB300 chassis,
+partial multi-host allocations, disaggregated deployments without per-worker
+telemetry, allocations that cannot tile eight GPUs, and missing/invalid
+measurements stay unavailable with distinct reasons.
 The ordinary 8K/1K transformation keeps its existing admission policy.
 
 At an exact frontier point, use that point's modeled power. Between points,
diff --git a/docs/state-ownership.md b/docs/state-ownership.md
index d4922dae3..4c8ff69d5 100644
--- a/docs/state-ownership.md
+++ b/docs/state-ownership.md
@@ -113,12 +113,65 @@ them.
 Axis and presentation state:
 
 - selected x-axis and y-axis metrics, percentile, and effective x-axis mode
+- the Measured controls (Boundary / Per / Scope / Statistic / Display / Unit) own no state: `measured-metric-config.ts` resolves each selection to the nearest registered metric key and writes it back to `selectedYAxisMetric`, so the power boundary rides on `i_metric` (there is deliberately no `i_pbasis`; see [PowerX Permanent View](./powerx-permanent-view.md))
+- the Measured Power Display value `timeline` (`y_measuredPowerTimeline`) swaps the chart body for `PowerTimeline`; its axis mode, per-GPU lines and all-in reference switch are component state and never enter the URL
 - token-revenue price source (`i_revenue`): normalized uncached/cached/output pricing or the selected model's live OpenRouter catalog prices
 - scale, optimal-point, label, contrast, legend, and overlay controls
 
 Display changes stay in this domain. A contrast or label toggle therefore does not
 notify filter-only or data-only consumers.
 
+**`usePerfRulerStore`** (perf rulers, `i_rulers`)
+
+Completed Perf Rulers on the primary inference chart (`chart-0`) are provider state,
+exposed through a dedicated `PerfRulerStoreContext`
+(`packages/app/src/components/inference/perf-ruler-store.ts`) rather than the display domain: a
+ruler commit would otherwise rerender every display consumer, and harnesses that mount
+`InferenceContextsProvider` with static mock values would silently lose ruler
+interactivity. The store is scoped to one chart id on purpose. The replay chart
+(`replay-chart-0`) draws the same curve classes under the same provider, so a shared
+store would render every ruler twice and let the replay's prune pass delete rulers the
+main chart still shows; it and `GPUGraph` keep component-local state, which `ScatterGraph`
+also falls back to when no store is present.
+
+`ScatterGraph` reads `state`/`setState` from the store, so the existing reducers, refs,
+and draw passes are unchanged. The one thing that moved is the axis reset:
+`usePerfRulerAxisReset` adjusts state during the chart's render, which is only legal for
+the chart's own state, so for persisted rulers the same reset (either axis metric changes
+→ rulers, draft, and pending share-link rulers are cleared) runs inside the provider. Its
+key, `persistedPerfRulerAxisKey`, describes the graph `ChartDisplay` renders as `chart-0`,
+not `graphs[0]`: `graphs` is always `[interactivity, e2e]` and ChartDisplay shows the e2e
+graph for every non-interactivity x mode, so the key picks the graph by `selectedXAxisMode`
+(as `bestHwTypes` does), uses its `x_scale_field` (which carries the percentile), and folds
+the mode itself in because the derived agentic modes override the e2e graph's x field inside
+ChartDisplay only. The first chart definition (null → key) and a reload of the same axes
+(key → null → key) are not axis changes, so share-link rulers survive the load.
+
+Restoring from a link is a two-phase commit because of a load race. Rulers parsed from
+`i_rulers` start as `pending`; data, `i_gpus`, comparison dates, and `?unofficialrun=`
+overlays all arrive after the chart's first draw, and the chart prunes any committed
+ruler whose curve path is absent from the DOM. The chart therefore commits a pending
+ruler only once BOTH of its curve paths exist (hidden-at-opacity-0 counts as present, as
+for prune), clamping the iso-x to the pair's overlap through the drawn paths. The commit
+runs inside the perf-ruler D3 layer's draw pass (`drawPerfRuler`), not in a React effect:
+the chart's first draw happens in a `D3Chart`-local re-render after its container is
+measured, which re-renders nothing in `ScatterGraph`, so an effect keyed on the chart's
+props could miss the first draw and leave resolvable rulers pending for the session. No
+commit happens while the ruler mode is off (the power envelope forces it off on
+non-measured axes; the mode-off effect discards pending rulers instead). Rulers whose
+curves never appear stay pending — invisible and unserialized — until an axis change,
+toggle-off, or clear discards them; this is a deliberate choice over a "data settled"
+readiness predicate (fragile across the async order of availability, benchmark, overlay,
+and derived-metric fetches). The visible cost is that a link whose curves the recipient's
+view lacks lands with the ruler switch on and nothing drawn, and a later legend change on
+the same axes can surface the ruler. A non-empty restore switches the ruler mode on for
+that chart instance (rulers only render in mode) and fires
+`interactivity_perf_ruler_shared_load` once per opened link, with `count` = the number of
+rulers the link carried, the first time any of them renders — never per commit batch, so
+the event counts links, not curve arrivals. Because the URL is read in a `useState`
+initialiser, a retained-provider tab switch onto `/inference?i_rulers=…` does not
+re-import the param — the same limitation as the other `i_*` toggles.
+
 **`useInferenceActions`**
 
 All inference commands and setters. The context value and every exposed action keep
@@ -360,3 +413,24 @@ Dashboard scope membership is declared by `shareParamScopes` in
 `packages/app/src/lib/dashboard-routes.ts`. Tests enforce completeness and route-specific
 share behavior, so this document deliberately does not duplicate a manually maintained
 parameter table.
+
+One entry needs a note on its encoding: `i_rulers` (inference scope, default `''`) is
+`serializePerfRulers` output — `isoX|curveA|curveB` per ruler joined by `;`, where the
+curve ids are the rendered roofline path identity classes (`roofline-<hwKey>_<precision>`,
+`overlay-roofline-<hwKey>_<precision>_run<N>`, optionally `__<encoded date>`) and the
+iso-x is in DATA space rounded to four significant digits. `parsePerfRulers` only accepts
+curve ids of that identity-class shape — the shared `roofline-path` marker class or any
+other zoom-group node would match many paths and draw a ruler between arbitrary curves.
+Only committed rulers are serialized (never the draft or still-pending link rulers), and
+the chart prunes them against the rendered curves, so a link written from one data set
+degrades to fewer rulers, never to an error. Overlay ids depend on the run order in `unofficialruns`, which the share
+link already carries.
+
+`i_pcompare` (inference scope, default `''`) is the power comparison mode, `boundaries` or
+`roles`, owned by `InferenceProvider` as `powerCompare` (display context) with
+`setPowerCompare` (actions). It is written as `''` for `none`. It is deliberately NOT cleared
+when the metric changes to one without a common axis for the siblings: the chart then draws
+the metric alone and the Measured controls show a hint, so the link's intent survives a
+detour through another setting. Which comparison rows a reader hid from the legend is
+`ScatterGraph` component state (`hiddenPowerVariants`), never shared — see
+[PowerX Permanent View](./powerx-permanent-view.md#comparison-series-i_pcompare).

From 7be3d2034b35d531509a902516b5c83eb726bce4 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:52:26 -0700
Subject: [PATCH 074/103] test: retry blog listing visits in E2E
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：将博客列表页的访问放入每个用例的准备阶段，使 Cypress 能在页面加载超时时重试。
---
 packages/app/cypress/e2e/blog.cy.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/app/cypress/e2e/blog.cy.ts b/packages/app/cypress/e2e/blog.cy.ts
index a527bff8b..d34c4e676 100644
--- a/packages/app/cypress/e2e/blog.cy.ts
+++ b/packages/app/cypress/e2e/blog.cy.ts
@@ -38,10 +38,10 @@ describe('Blog', () => {
   });
 
   describe('Blog listing page', () => {
-    before(() => {
+    beforeEach(() => {
       // Stub remote Substack thumbnails with a real 1×1 PNG. A 204 empty body
       // can prevent Firefox from firing `window.load` while eager card images
-      // stay pending, which times out `cy.visit` in before-all.
+      // stay pending. Per-test setup also lets Cypress retry a failed visit.
       cy.intercept(
         {
           method: 'GET',

From a72b9307a3e6a102d0390ff982e8aec46a4eb204 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:56:23 -0700
Subject: [PATCH 075/103] fix: light the base series when its comparison legend
 row is hovered
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Base points and rooflines carry no power variant (only role and boundary
siblings are cloned), while the base legend row's key holds the base id.
Hovering that row therefore matched nothing and dimmed the whole chart.
Map the empty variant back onto the base id for hover matching, and cover
it with a component case that fails on the old code.

中文：基础系列的点和 roofline 不带 power variant（只有角色/边界的
兄弟系列会被克隆），而基础图例行的 key 带有基础 id，悬停时匹配不到
任何元素，整张图全部变暗。现将空 variant 映射回基础 id 用于悬停匹配，
并新增旧代码会失败的组件测试用例。
---
 .../cypress/component/power-compare.cy.tsx    | 29 +++++++++++++++++++
 .../components/inference/ui/ScatterGraph.tsx  | 10 ++++---
 2 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/packages/app/cypress/component/power-compare.cy.tsx b/packages/app/cypress/component/power-compare.cy.tsx
index e1d3917a0..f2a51b485 100644
--- a/packages/app/cypress/component/power-compare.cy.tsx
+++ b/packages/app/cypress/component/power-compare.cy.tsx
@@ -151,4 +151,33 @@ describe('ScatterGraph power comparison series', () => {
       expect(hidden).to.have.length(3);
     });
   });
+
+  it('keeps the base series lit when its legend row is hovered', () => {
+    const official = expandPowerCompareSeries(measuredCurve('b200'), 'y_measuredAvgPower', 'roles');
+    const overlay = expandPowerCompareSeries(
+      measuredCurve('h100', OVERLAY_RUN_URL),
+      'y_measuredAvgPower',
+      'roles',
+    );
+    mountCompare(official, overlay);
+
+    cy.get(`${svg} .roofline-path[data-power-variant="prefill"]`).should('exist');
+    // Base points and rooflines carry no variant id (only role siblings are
+    // cloned), so the base row has to map back onto them.
+    cy.get(legend).contains('label', 'All GPUs').trigger('mouseover');
+    // Wait for the siblings to settle first: opacity transitions over 150 ms,
+    // so a base check taken at once would still read the pre-hover value.
+    cy.get(`${svg} .roofline-path[data-power-variant="prefill"]`).should(
+      'have.css',
+      'opacity',
+      '0.15',
+    );
+    cy.get(`${svg} .roofline-path:not([data-power-variant])`).should('have.css', 'opacity', '1');
+    cy.get(legend).contains('label', 'All GPUs').trigger('mouseout');
+    cy.get(`${svg} .roofline-path[data-power-variant="prefill"]`).should(
+      'have.css',
+      'opacity',
+      '1',
+    );
+  });
 });
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 9f6656adf..318e2dce8 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -2396,14 +2396,16 @@ const ScatterGraph = React.memo(
         if (!svg) return;
         const root = d3.select(svg);
         // A comparison-series legend row highlights that boundary / role
-        // across every hardware instead of one hardware across series.
+        // across every hardware instead of one hardware across series. Base
+        // points and rooflines carry no variant (only siblings are cloned),
+        // so the empty id maps back to the base legend row's id.
         const variantId = hwKey.startsWith(POWER_VARIANT_LEGEND_PREFIX)
           ? hwKey.slice(POWER_VARIANT_LEGEND_PREFIX.length)
           : null;
         const matchesPoint = (d: InferenceData) =>
           variantId === null
             ? String(d.hwKey) === hwKey
-            : powerVariantId(d.powerVariant) === variantId;
+            : (powerVariantId(d.powerVariant) || powerCompareBaseId) === variantId;
         root
           .selectAll<SVGGElement, InferenceData>('.dot-group')
           .style('opacity', (d) =>
@@ -2416,7 +2418,7 @@ const ScatterGraph = React.memo(
             const matches =
               variantId === null
                 ? this.dataset.hwKey === hwKey
-                : (this.dataset.powerVariant ?? '') === variantId;
+                : (this.dataset.powerVariant || powerCompareBaseId) === variantId;
             return matches ? null : '0.15';
           });
         root
@@ -2425,7 +2427,7 @@ const ScatterGraph = React.memo(
             return labelOpacityForHover((this as SVGGElement).dataset, hwKey);
           });
       },
-      [isPointVisible, isRooflineVisible],
+      [isPointVisible, isRooflineVisible, powerCompareBaseId],
     );
 
     const handleLegendHoverEnd = useCallback(() => {

From d10cdd0cb43d4ea4eb0eb983d4f2815b26a3ad77 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:56:33 -0700
Subject: [PATCH 076/103] fix: memoise timeline responses on a fixed-shape
 input
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The response map spread one query result per run into its useMemo deps, so
the array changed length whenever runs joined or left the plot and React
logged the changed-size warning and recomputed. Build the resolved list in
useQueries' combine, which React Query structurally shares, and memoise the
map on that single input. Loading count and errors move into the same
combine. A component case grows the plot from one run to two and asserts
the warning is gone.

中文：响应 map 之前把每个 run 的查询结果展开进 useMemo 依赖数组，
run 加入或离开图表时数组长度变化，React 会报 changed-size 警告并
重新计算。现改为在 useQueries 的 combine 中构建已解析列表（React Query
会做结构共享），map 只依赖这一个输入；加载计数与错误也移入同一 combine。
新增组件用例：图表从一个 run 增长到两个并断言不再出现该警告。
---
 .../cypress/component/power-timeline.cy.tsx   | 84 ++++++++++++++++---
 .../components/inference/ui/PowerTimeline.tsx | 41 ++++-----
 2 files changed, 94 insertions(+), 31 deletions(-)

diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index 01fc78f13..7df453db1 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -1,4 +1,5 @@
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+import { useState } from 'react';
 
 import type { GpuPowerSeries, GpuPowerSeriesResponse } from '@/components/gpu-power/power-series';
 import PowerTimeline from '@/components/inference/ui/PowerTimeline';
@@ -21,6 +22,8 @@ const RUN_ID = '34716669498';
 const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
 const OVERLAY_RUN_ID = '31415926535';
 const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
+const SECOND_RUN_ID = '34716669499';
+const SECOND_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${SECOND_RUN_ID}`;
 const START_MS = Date.UTC(2026, 8, 12, 20, 20, 0);
 const hwConfig = createMockHardwareConfig();
 const HW_TYPES = new Set(['b200', 'h100']);
@@ -84,6 +87,24 @@ const response: GpuPowerSeriesResponse = {
   series: [series('b200', 16, 700), series('b200', 64, 900)],
 };
 
+const Y_LABEL = 'Measured Average Power per Chip over Time (W)';
+
+function providerOverrides(
+  unofficial: Parameters<typeof createMockUnofficialRunContext>[0] = {},
+): Parameters<typeof mountWithProviders>[1] {
+  return {
+    inference: {
+      selectedModel: Model.DeepSeek_V4_Pro,
+      selectedSequence: Sequence.EightK_OneK,
+      selectedYAxisMetric: 'y_measuredPowerTimeline',
+      hardwareConfig: hwConfig,
+      activeHwTypes: new Set(HW_TYPES),
+      hwTypesWithData: new Set(HW_TYPES),
+    },
+    unofficial,
+  };
+}
+
 function mountTimeline(
   data: InferenceData[],
   options: {
@@ -98,21 +119,32 @@ function mountTimeline(
           chartId="power-timeline-test"
           data={data}
           overlayData={options.overlay}
-          yLabel="Measured Average Power per Chip over Time (W)"
+          yLabel={Y_LABEL}
         />
       </div>
     </PathnameContext.Provider>,
-    {
-      inference: {
-        selectedModel: Model.DeepSeek_V4_Pro,
-        selectedSequence: Sequence.EightK_OneK,
-        selectedYAxisMetric: 'y_measuredPowerTimeline',
-        hardwareConfig: hwConfig,
-        activeHwTypes: new Set(HW_TYPES),
-        hwTypesWithData: new Set(HW_TYPES),
-      },
-      unofficial: options.unofficial ?? {},
-    },
+    providerOverrides(options.unofficial),
+  );
+}
+
+/** One measured run at mount; a button adds a second run to the same plot. */
+function GrowingTimeline() {
+  const [data, setData] = useState(() => [measuredPoint('b200', 16, 700)]);
+  return (
+    <PathnameContext.Provider value="/inference">
+      <button
+        type="button"
+        data-testid="add-run"
+        onClick={() =>
+          setData((prev) => [...prev, measuredPoint('h100', 16, 500, { run_url: SECOND_RUN_URL })])
+        }
+      >
+        add run
+      </button>
+      <div style={{ width: 1100, height: 700 }}>
+        <PowerTimeline chartId="power-timeline-test" data={data} yLabel={Y_LABEL} />
+      </div>
+    </PathnameContext.Provider>
   );
 }
 
@@ -181,4 +213,32 @@ describe('PowerTimeline', () => {
     });
     cy.get('[data-testid="chart-legend"]').should('contain.text', '✕ powerx-timeline');
   });
+
+  it('joins a run that arrives after mount without a hook-shape warning', () => {
+    const secondResponse: GpuPowerSeriesResponse = {
+      runInfo: { ...response.runInfo, id: Number(SECOND_RUN_ID), url: SECOND_RUN_URL },
+      series: [series('h100', 16, 500)],
+    };
+    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('first');
+    cy.intercept('POST', `/api/gpu-metrics?runId=${SECOND_RUN_ID}*`, {
+      body: secondResponse,
+    }).as('second');
+    cy.stub(console, 'error').as('consoleError');
+    mountWithProviders(<GrowingTimeline />, providerOverrides());
+    cy.wait('@first');
+    svg().find('path.power-trace[data-segment="window"]').should('have.length', 1);
+
+    cy.get('[data-testid="add-run"]').click();
+    cy.wait('@second');
+    svg().find('path.power-trace[data-segment="window"]').should('have.length', 2);
+    // React logs this when a memo's dependency array changes length between
+    // renders; one query per run used to be spread into that array.
+    cy.get('@consoleError').then((stub) => {
+      const calls = (stub as unknown as { args: unknown[][] }).args;
+      const shapeWarnings = calls.filter((args) =>
+        args.some((a) => typeof a === 'string' && a.includes('changed size between renders')),
+      );
+      expect(shapeWarnings, JSON.stringify(shapeWarnings)).to.have.length(0);
+    });
+  });
 });
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index 6a56f0c4d..45ccecf58 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -24,7 +24,7 @@
  * here focused on one config (`requestPowerTraceFocus`).
  */
 import * as d3 from 'd3';
-import { useQueries } from '@tanstack/react-query';
+import { useQueries, type UseQueryResult } from '@tanstack/react-query';
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
 
@@ -761,7 +761,25 @@ export default function PowerTimeline({
     [requests, overlayRunIds],
   );
   const droppedRuns = requests.length - fetchedRequests.length;
-  const queries = useQueries({
+  // React Query structurally shares the combined result, so `resolved` keeps
+  // its identity until a run's data actually changes. That gives the response
+  // map a fixed-shape memo input; a per-query spread would change the deps
+  // array length whenever runs enter or leave the plot, which React rejects.
+  const combineQueries = useCallback(
+    (results: UseQueryResult<GpuPowerSeriesResponse, Error>[]) => ({
+      loadingRuns: results.filter((query) => query.isPending).length,
+      errors: fetchedRequests.flatMap((request, index) => {
+        const error = results[index]?.error;
+        return error instanceof Error ? [{ request, error }] : [];
+      }),
+      resolved: fetchedRequests.flatMap((request, index) => {
+        const response = results[index]?.data;
+        return response ? [[request.runId, response] as const] : [];
+      }),
+    }),
+    [fetchedRequests],
+  );
+  const { loadingRuns, errors, resolved } = useQueries({
     queries: fetchedRequests.map((request) => ({
       queryKey: ['power-timeline', request.runId, request.prefix, request.sources] as const,
       queryFn: ({ signal }: { signal: AbortSignal }) => fetchPowerSeries(request, signal),
@@ -769,24 +787,9 @@ export default function PowerTimeline({
       refetchOnWindowFocus: true,
       retry: 1,
     })),
+    combine: combineQueries,
   });
-  const loadingRuns = queries.filter((query) => query.isPending).length;
-  const errors = fetchedRequests
-    .map((request, index) => ({ request, error: queries[index].error }))
-    .filter(
-      (entry): entry is { request: PowerTimelineRequest; error: Error } =>
-        entry.error instanceof Error,
-    );
-  const responses = useMemo(() => {
-    const map = new Map<string, GpuPowerSeriesResponse>();
-    fetchedRequests.forEach((request, index) => {
-      const response = queries[index].data;
-      if (response) map.set(request.runId, response);
-    });
-    return map;
-    // Query data objects are stable per fetch; deriving from them keeps the map memoised.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [fetchedRequests, ...queries.map((query) => query.data)]);
+  const responses = useMemo(() => new Map<string, GpuPowerSeriesResponse>(resolved), [resolved]);
 
   const { traces, missing } = useMemo(
     () => joinPowerTimeline(allPoints, responses),

From d314daeca47313211a9706e84db443c19b5bfa0e Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 13:04:18 -0700
Subject: [PATCH 077/103] test: stub optimized blog thumbnails in E2E
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：博客列表页的 E2E 用例统一替换图片优化请求，避免 Firefox 等待缩略图时页面加载超时。
---
 packages/app/cypress/e2e/blog.cy.ts | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/packages/app/cypress/e2e/blog.cy.ts b/packages/app/cypress/e2e/blog.cy.ts
index d34c4e676..b70a927ce 100644
--- a/packages/app/cypress/e2e/blog.cy.ts
+++ b/packages/app/cypress/e2e/blog.cy.ts
@@ -39,17 +39,12 @@ describe('Blog', () => {
 
   describe('Blog listing page', () => {
     beforeEach(() => {
-      // Stub remote Substack thumbnails with a real 1×1 PNG. A 204 empty body
-      // can prevent Firefox from firing `window.load` while eager card images
-      // stay pending. Per-test setup also lets Cypress retry a failed visit.
-      cy.intercept(
-        {
-          method: 'GET',
-          pathname: '/_next/image',
-          query: { url: /^https:\/\/substack-post-media\.s3\.amazonaws\.com\// },
-        },
-        { fixture: '1x1.png', headers: { 'content-type': 'image/png' } },
-      );
+      // The listing checks text and links, so stub every optimized thumbnail.
+      // Waiting on image optimization can keep Firefox from firing `window.load`.
+      cy.intercept('GET', '**/_next/image?*', {
+        fixture: '1x1.png',
+        headers: { 'content-type': 'image/png' },
+      });
       cy.visit('/blog');
     });
 

From 12f382b564461377a5c4dbcc109f27b4c9785da3 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 14:02:58 -0700
Subject: [PATCH 078/103] chore: integrate PowerX article changes locally
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replay the article increment from 2c160b2e to b07e1c76 onto the split DB and UI stack. Retain current persistence safeguards, API contracts, and the dynamic Timeline query regression.

中文：将 PowerX article 增量整合到拆分后的 DB/UI 分支，保留最新持久化保护、API 契约及动态 Timeline 查询回归；本提交仅在本地保存。
---
 docs/d3-charts.md                             |  16 +-
 docs/dashboard-readonly-views.md              | 191 ++++-
 docs/data-pipeline.md                         |  55 +-
 docs/data-transforms.md                       |   6 +-
 docs/powerx-permanent-view.md                 | 141 +++-
 docs/powerx-persistence-recovery.md           |  18 +-
 docs/state-ownership.md                       |   6 +-
 .../component/frontier-points-panel.cy.tsx    |  98 +++
 .../app/cypress/component/gpu-graph.cy.tsx    | 319 ++++++--
 .../component/inference-chart-controls.cy.tsx |   3 +-
 .../power-metric-availability.cy.tsx          |  88 ---
 .../component/power-service-comparison.cy.tsx | 115 +++
 .../cypress/component/power-timeline.cy.tsx   | 214 +++++-
 .../cypress/component/scatter-graph.cy.tsx    |  13 -
 .../cypress/e2e/certified-power-filter.cy.ts  |  28 +-
 .../app/cypress/e2e/inference-chart.cy.ts     | 120 ++-
 packages/app/cypress/e2e/powerx-compare.cy.ts | 213 ++++++
 .../app/cypress/e2e/powerx-timeline.cy.ts     | 198 +++++
 .../app/cypress/e2e/ttft-x-axis-toggle.cy.ts  |  13 +-
 packages/app/cypress/support/mock-data.ts     |  16 +-
 packages/app/cypress/support/share-link.ts    |  20 +
 packages/app/src/app/api/gpu-metrics/route.ts |  18 +-
 .../app/api/v1/views/inference/route.test.ts  | 157 ++++
 .../src/app/api/v1/views/inference/route.ts   | 206 ++++-
 .../app/src/app/api/v1/views/options/route.ts |   5 +
 .../gpu-power/power-audit-bundle.ts           |  22 +-
 .../src/components/gpu-power/power-series.ts  |   2 +
 .../gpu-power/stored-power-series.ts          |   5 +-
 .../app/src/components/gpu-power/types.ts     |  13 +-
 .../components/inference/InferenceContext.tsx |  30 +-
 .../agentic-point/overlay-sources.ts          |   5 -
 .../agentic-point/power-telemetry-view.tsx    |   6 +-
 .../agentic-point/use-detail-view.ts          |   9 +-
 .../inference/axis-metric-explanations.ts     |  33 +-
 .../inference/hooks/chart-data-core.ts        |  10 +-
 .../inference/hooks/useChartData.ts           |  42 +-
 .../hooks/useChartData.x-axis-wiring.test.tsx |  62 +-
 .../inference/hooks/useComparisonSeries.ts    | 129 ++++
 .../inference/hooks/usePowerTraceAction.ts    |  56 ++
 .../components/inference/metric-registry.ts   |   5 +-
 .../app/src/components/inference/types.ts     |  15 +-
 .../inference/ui/ActiveQuickFilters.tsx       |   3 +-
 .../components/inference/ui/ChartControls.tsx |  27 +-
 .../components/inference/ui/ChartDisplay.tsx  | 123 ++-
 .../inference/ui/FrontierPointsPanel.tsx      | 173 +++++
 .../src/components/inference/ui/GPUGraph.tsx  | 719 +++++++++++-------
 .../inference/ui/LegacyPowerLegendKey.tsx     |  51 --
 .../inference/ui/MatchedConcurrencyTable.tsx  | 211 +++++
 .../inference/ui/MeasuredMetricControls.tsx   |  31 -
 .../inference/ui/MeasuredPowerSummary.tsx     | 117 ---
 .../components/inference/ui/PowerFitPanel.tsx | 224 ++++++
 .../inference/ui/PowerMetricAvailability.tsx  | 378 ---------
 .../inference/ui/PowerPanelPlot.tsx           | 196 +++++
 .../inference/ui/PowerRoleGroup.tsx           | 321 ++++++++
 .../inference/ui/PowerServiceComparison.tsx   | 478 ++++++++++++
 .../components/inference/ui/PowerTimeline.tsx | 579 +++++++++-----
 .../inference/ui/PowerTimelineSummary.tsx     | 189 +++++
 .../inference/ui/QuickFiltersDialog.tsx       |  57 +-
 .../ui/ScatterGraph.decoration.test.tsx       |  63 +-
 .../ui/ScatterGraph.overlay.test.tsx          |  42 -
 .../components/inference/ui/ScatterGraph.tsx  | 258 +++----
 .../inference/ui/XAxisModeSelector.tsx        | 137 +++-
 .../src/components/inference/utils.test.ts    |  21 +
 .../app/src/components/inference/utils.ts     |  24 +-
 .../inference/utils/concurrency-series.ts     |  36 +
 .../utils/equal-service-comparison.test.ts    | 165 ++++
 .../utils/equal-service-comparison.ts         | 356 +++++++++
 .../inference/utils/frontier-points.ts        |  44 ++
 .../inference/utils/legacy-power-marker.ts    |  38 -
 .../utils/matched-concurrency.test.ts         |  74 ++
 .../inference/utils/matched-concurrency.ts    | 128 ++++
 .../inference/utils/power-fit.test.ts         |  73 ++
 .../components/inference/utils/power-fit.ts   | 125 +++
 .../utils/power-metric-availability.test.ts   |  61 --
 .../utils/power-metric-availability.ts        |  68 --
 .../components/inference/utils/powerCurves.ts |   5 +-
 .../inference/utils/powerTimeline.test.ts     |  69 +-
 .../inference/utils/powerTimeline.ts          | 160 +++-
 .../inference/utils/quick-filter-summary.ts   |  13 +-
 .../inference/utils/quickFilters.test.ts      |   5 +-
 .../inference/utils/quickFilters.ts           |   8 +-
 .../inference/utils/resolveXAxisField.ts      |  50 +-
 .../components/inference/utils/role-energy.ts |   9 +-
 .../inference/utils/tooltipUtils.ts           |   1 +
 .../inference/utils/topology-filter.test.ts   |  18 +
 .../inference/utils/topology-filter.ts        |  83 ++
 .../inference/utils/x-axis-scale.ts           |   1 +
 packages/app/src/lib/api-route-catalog.ts     |  66 +-
 packages/app/src/lib/benchmark-transform.ts   |   3 +
 packages/app/src/lib/chart-utils.ts           |  39 +-
 .../src/lib/d3-chart/layers/rooflines.test.ts |  32 +-
 .../app/src/lib/d3-chart/layers/rooflines.ts  |  23 +-
 packages/app/src/lib/inference-labels.ts      |   2 +-
 packages/app/src/lib/power-basis.ts           |  26 +-
 packages/app/src/lib/url-state.ts             |  29 +
 .../app/src/lib/views-api/docs/extensions.ts  |   8 +-
 .../app/src/lib/views-api/docs/inference.ts   | 282 ++++++-
 .../app/src/lib/views-api/docs/options.ts     |   6 +
 packages/app/src/lib/views-api/registry.ts    |   8 +
 packages/app/src/lib/views-api/series.ts      |  86 ++-
 packages/app/timings.json                     |   8 +
 packages/db/src/backfill-gpu-metrics.ts       |  22 +-
 packages/db/src/etl/gpu-metrics-artifacts.ts  |  55 +-
 packages/db/src/etl/gpu-metrics-csv.ts        |   2 +-
 packages/db/src/etl/gpu-metrics-ingest.ts     | 103 +--
 .../db/src/etl/multinode-power-samples.ts     |  30 +-
 packages/db/src/etl/power-audit-recovery.ts   |  18 +-
 packages/db/src/etl/power-publication.ts      |   7 +-
 .../db/src/etl/required-power-publication.ts  |   2 +-
 packages/db/src/ingest-ci-run.ts              |  12 +-
 .../db/src/lib/backfill-benchmark-refresh.ts  |   9 +-
 packages/db/src/lib/backfill-runner.ts        |  10 +-
 packages/db/src/lib/telemetry-purge.ts        |  19 +-
 packages/db/src/queries/gpu-metrics.ts        |  42 +-
 packages/db/src/verify-power-publication.ts   |   3 +-
 .../skills/inferencex-api/integrity.json      |   2 +-
 .../references/dashboard-views.md             | 103 ++-
 117 files changed, 7431 insertions(+), 2359 deletions(-)
 create mode 100644 packages/app/cypress/component/frontier-points-panel.cy.tsx
 delete mode 100644 packages/app/cypress/component/power-metric-availability.cy.tsx
 create mode 100644 packages/app/cypress/component/power-service-comparison.cy.tsx
 create mode 100644 packages/app/cypress/e2e/powerx-compare.cy.ts
 create mode 100644 packages/app/cypress/e2e/powerx-timeline.cy.ts
 create mode 100644 packages/app/cypress/support/share-link.ts
 create mode 100644 packages/app/src/components/inference/hooks/useComparisonSeries.ts
 create mode 100644 packages/app/src/components/inference/hooks/usePowerTraceAction.ts
 create mode 100644 packages/app/src/components/inference/ui/FrontierPointsPanel.tsx
 delete mode 100644 packages/app/src/components/inference/ui/LegacyPowerLegendKey.tsx
 create mode 100644 packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
 delete mode 100644 packages/app/src/components/inference/ui/MeasuredPowerSummary.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerFitPanel.tsx
 delete mode 100644 packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerPanelPlot.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerRoleGroup.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerServiceComparison.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerTimelineSummary.tsx
 create mode 100644 packages/app/src/components/inference/utils/concurrency-series.ts
 create mode 100644 packages/app/src/components/inference/utils/equal-service-comparison.test.ts
 create mode 100644 packages/app/src/components/inference/utils/equal-service-comparison.ts
 create mode 100644 packages/app/src/components/inference/utils/frontier-points.ts
 delete mode 100644 packages/app/src/components/inference/utils/legacy-power-marker.ts
 create mode 100644 packages/app/src/components/inference/utils/matched-concurrency.test.ts
 create mode 100644 packages/app/src/components/inference/utils/matched-concurrency.ts
 create mode 100644 packages/app/src/components/inference/utils/power-fit.test.ts
 create mode 100644 packages/app/src/components/inference/utils/power-fit.ts
 delete mode 100644 packages/app/src/components/inference/utils/power-metric-availability.test.ts
 delete mode 100644 packages/app/src/components/inference/utils/power-metric-availability.ts
 create mode 100644 packages/app/src/components/inference/utils/topology-filter.test.ts
 create mode 100644 packages/app/src/components/inference/utils/topology-filter.ts

diff --git a/docs/d3-charts.md b/docs/d3-charts.md
index 98f69d3e6..fba77dfef 100644
--- a/docs/d3-charts.md
+++ b/docs/d3-charts.md
@@ -81,7 +81,7 @@ For machine-readable frontier and hinterland observations, see the
 [Pareto boundary API](./pareto-api.md). The server and chart share
 `src/lib/pareto-frontier.ts`; their input-selection pipelines differ.
 
-Every inference scatter chart exposes a **Pareto Frontier** switch under
+Inference scatter charts with a performance-preference X axis expose a **Pareto Frontier** switch under
 **Advanced**, off by default.
 Collapsing Advanced does not turn off an enabled highlight.
 `i_frontier=1` preserves plain shading in share links; value `2` restores the scenic background.
@@ -122,12 +122,24 @@ The six measured-power metrics (average, prefill, decode, P75, P90 and percentag
 
 Modeled chassis power retains its existing behavior: **Optimal Only** on shows the minimum-power Pareto frontier, which can legitimately contain one point. Turning it off draws the upper power boundary. In that mode, the separate **Show all measurements** switch (`i_allpoints=1`) reveals off-boundary points without changing the curve.
 
-Dividing watts by one hardware's positive, constant TDP preserves its boundary membership. A lower percentage across different chips is not, by itself, an energy-efficiency comparison. Historical rings remain attached to visible historical points.
+Dividing watts by one hardware's positive, constant TDP preserves its boundary membership. A lower percentage across different chips is not, by itself, an energy-efficiency comparison.
 
 Upper boundaries use monotone interpolation between unique-X vertices, including after zoom. Curves are grouped by hardware, precision and date, and additionally by run for unofficial overlays; unrelated dates and runs never share a curve.
 
 **Perf Ruler** is available on all six measured-power axes in both chart views. It measures the ratio of the drawn upper-boundary values at the same X coordinate, using the rendered paths after zoom; clicking an off-boundary dot selects its series' boundary, clamped to the curves' shared X range. The ratio compares power or percentage of TDP, not energy efficiency. Optimal Only changes point visibility without moving the ruler. Hidden or removed curves cannot be measured, and changing either axis clears existing rulers. Modeled chassis power keeps its existing ruler restriction while showing an upper boundary; energy and other Pareto views retain their ruler behavior.
 
+### Observed concurrency sweeps
+
+`i_xmode=concurrency` is an observed-load view, not an optimization axis. It uses the exact positive `conc` values and a linear X scale. Valid metric-bearing load points remain visible even when saved Optimal Only or Best per SKU preferences are enabled; Pareto Frontier, gradient strategy labels, Perf Ruler and Replay are unavailable in this mode. Y-axis units and measured/modelled boundaries do not change.
+
+`groupConcurrencySeries` groups straight-line segments by hardware, precision, topology (`pointTopologyKey`), recipe fingerprint, date, run and power-comparison variant. It never joins TP4 to TP8 or 4P/4D to 16P/16D. A group with repeated concurrency values, or points without run provenance, stays as markers instead of being reduced to an arbitrary average or envelope. Markers retain their original values and identities. These segments connect observations; they do not establish a hardware-controlled comparison or estimate untested loads.
+
+Official and unofficial paths share this behavior. Date comparisons stay on `GPUGraph` and split each compared (date, hardware) series and each unofficial run into the same segments, drawn with linear curves and without frontier, power envelope, Optimal Only or Perf Ruler; each series keeps one line label, on its longest segment. Exact topology quick filters retain that topology's entire load sweep. Share URLs, tables and CSV exports preserve the selected `conc` coordinates.
+
+### Unofficial runs in date comparisons
+
+`GPUGraph` plots `?unofficialrun=` rows next to the compared dates as their own (run, hardware) series, `overlay-run<index>_<hwKey>`. They pass the same precision, quick-filter and overlay-hardware (`activeOverlayHwTypes`) gates as `ScatterGraph`, draw as X markers in `overlayRunColor(runIndex)`, and their curves take `overlayRooflineDasharray(runIndex)` through the roofline layer's per-curve `getDasharray`. They are not date series, so `activeDates` toggles leave them on; the legend lists them first, one `UNOFFICIAL: <branch>` group per run, and dismissing the run removes them. Pinned tooltips, official and overlay alike, offer **View power trace**, which opens the comparison Timeline focused on that trace; official points also keep **View PowerX**.
+
 ## Gradient Roofline Labels
 
 Parallelism strategies (TP4, TEP8, DPAEP4) color roofline paths with gradient stops and use one label per contiguous strategy segment. The reasoning:
diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 04294ebce..95b159ce8 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -11,28 +11,28 @@ All endpoints are GET under /api/v1/views. Unsupported and repeated keys return
 This table records accepted query names; behavioral tests exercise representative
 combinations, not the full Cartesian product of all possible filter values.
 
-| View                            | Accepted query keys                                                                                                                                                                                                                                                                                      |
-| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `cache-reuse`                   | `config`, `date`, `gpus`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                          |
-| `calculator`                    | `costProvider`, `costType`, `costcap`, `date`, `format`, `gpus`, `hideSkuAboveConfigLimit`, `mode`, `model`, `mw`, `percentile`, `precisions`, `runId`, `sequence`, `target`, `tcoBasis`, `unofficialrun`                                                                                                |
-| `collectivex`                   | `activeSeries`, `kvSeries`, `swapSeries`, `backend`, `epSize`, `kvOp`, `kvX`, `kvY`, `modes`, `operation`, `overlapIsl`, `pageTokens`, `percentile`, `phase`, `precision`, `runs`, `sku`, `suite`, `swapDirection`, `swapLayout`, `swapMetric`, `swapPercentile`, `version`, `yAxis`                     |
-| `compare`                       | `format`, `gpus`, `model`, `scenario`, `slug`, `tiers`, `variant`                                                                                                                                                                                                                                        |
-| `current-inferencex-image`      | `asOf`, `frameworks`, `hardware`, `model`, `nodeType`, `precision`, `sequence`, `spec`                                                                                                                                                                                                                   |
-| `evaluation`                    | `unofficialrun`, `benchmark`, `date`, `format`, `gpus`, `model`, `precisions`                                                                                                                                                                                                                            |
-| `first-token`                   | `caps`, `costProvider`, `costType`, `date`, `gpus`, `minInteractivity`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                            |
-| `fleet`                         | `cache`, `costProvider`, `costType`, `format`, `gpus`, `horizon`, `metric`, `model`, `mtbi`, `mw`, `oprice`, `percentile`, `precisions`, `price`, `ramp`, `recovery`, `sequence`, `target`, `tcoBasis`                                                                                                   |
-| `gpu-metrics`                   | `artifact`, `chartView`, `corrXMetric`, `corrYMetric`, `direction`, `downsample`, `gpus`, `metric`, `runId`, `sort`                                                                                                                                                                                      |
-| `gpu-specs`                     | `format`, `metric`                                                                                                                                                                                                                                                                                       |
-| `historical`                    | `deployment`, `end`, `extendToDate`, `format`, `frameworks`, `gpus`, `metric`, `model`, `precisions`, `priceSource`, `sequence`, `start`, `target`, `tcoBasis`, `vendors`                                                                                                                                |
-| `inference`                     | `allPoints`, `best`, `date`, `dates`, `deployment`, `end`, `format`, `frameworks`, `gpus`, `metric`, `model`, `optimal`, `percentile`, `power`, `precisions`, `priceSource`, `runId`, `sequence`, `spec`, `start`, `tcoBasis`, `unofficialrun`, `userCosts`, `userPowers`, `vendors`, `xmetric`, `xmode` |
-| `options`                       | `format`                                                                                                                                                                                                                                                                                                 |
-| `overview`                      | `compare`, `engine`, `format`, `hwrows`, `models`, `ref`, `rows`, `tier`                                                                                                                                                                                                                                 |
-| `profit-estimator`              | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                           |
-| `profit-estimator-per-gigawatt` | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                           |
-| `rankings`                      | `format`, `kind`, `model`, `scenario`                                                                                                                                                                                                                                                                    |
-| `reliability`                   | `asOf`, `format`, `gpus`, `range`                                                                                                                                                                                                                                                                        |
-| `submissions`                   | `direction`, `limit`, `lines`, `mode`, `offset`, `onChangeOnly`, `search`, `sort`                                                                                                                                                                                                                        |
-| `video`                         | `artifact`, `cell`, `compare`, `costs`, `gpuBasis`, `page`, `phase`, `run`, `selected`, `slot`, `source`, `view`, `workload`, `xAxis`, `yAxis`                                                                                                                                                           |
+| View                            | Accepted query keys                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `cache-reuse`                   | `config`, `date`, `gpus`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                                                                                                                                     |
+| `calculator`                    | `costProvider`, `costType`, `costcap`, `date`, `format`, `gpus`, `hideSkuAboveConfigLimit`, `mode`, `model`, `mw`, `percentile`, `precisions`, `runId`, `sequence`, `target`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                                           |
+| `collectivex`                   | `activeSeries`, `kvSeries`, `swapSeries`, `backend`, `epSize`, `kvOp`, `kvX`, `kvY`, `modes`, `operation`, `overlapIsl`, `pageTokens`, `percentile`, `phase`, `precision`, `runs`, `sku`, `suite`, `swapDirection`, `swapLayout`, `swapMetric`, `swapPercentile`, `version`, `yAxis`                                                                                                                                                |
+| `compare`                       | `format`, `gpus`, `model`, `scenario`, `slug`, `tiers`, `variant`                                                                                                                                                                                                                                                                                                                                                                   |
+| `current-inferencex-image`      | `asOf`, `frameworks`, `hardware`, `model`, `nodeType`, `precision`, `sequence`, `spec`                                                                                                                                                                                                                                                                                                                                              |
+| `evaluation`                    | `unofficialrun`, `benchmark`, `date`, `format`, `gpus`, `model`, `precisions`                                                                                                                                                                                                                                                                                                                                                       |
+| `first-token`                   | `caps`, `costProvider`, `costType`, `date`, `gpus`, `minInteractivity`, `model`, `percentile`, `precisions`, `runId`, `sequence`, `tcoBasis`, `unofficialrun`                                                                                                                                                                                                                                                                       |
+| `fleet`                         | `cache`, `costProvider`, `costType`, `format`, `gpus`, `horizon`, `metric`, `model`, `mtbi`, `mw`, `oprice`, `percentile`, `precisions`, `price`, `ramp`, `recovery`, `sequence`, `target`, `tcoBasis`                                                                                                                                                                                                                              |
+| `gpu-metrics`                   | `artifact`, `chartView`, `corrXMetric`, `corrYMetric`, `direction`, `downsample`, `gpus`, `metric`, `runId`, `sort`                                                                                                                                                                                                                                                                                                                 |
+| `gpu-specs`                     | `format`, `metric`                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `historical`                    | `deployment`, `end`, `extendToDate`, `format`, `frameworks`, `gpus`, `metric`, `model`, `precisions`, `priceSource`, `sequence`, `start`, `target`, `tcoBasis`, `vendors`                                                                                                                                                                                                                                                           |
+| `inference`                     | `allPoints`, `best`, `date`, `dates`, `deployment`, `end`, `format`, `frameworks`, `gpus`, `metric`, `model`, `optimal`, `percentile`, `power`, `precisions`, `priceSource`, `runId`, `sequence`, `spec`, `start`, `tcoBasis`, `topologies`, `unofficialrun`, `userCosts`, `userPowers`, `vendors`, `xmetric`, `xmode`, `xstat`, `serviceCompare`, `serviceBaseline`, `serviceComparator`, `serviceTarget`, `roleShare`, `powerFit` |
+| `options`                       | `format`                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `overview`                      | `compare`, `engine`, `format`, `hwrows`, `models`, `ref`, `rows`, `tier`                                                                                                                                                                                                                                                                                                                                                            |
+| `profit-estimator`              | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                                                                                                                                                      |
+| `profit-estimator-per-gigawatt` | `cachedInputPrice`, `costProvider`, `customCosts`, `date`, `dates`, `end`, `gpus`, `inputPrice`, `labCut`, `model`, `outputPrice`, `percentile`, `powerBasis`, `precisions`, `priceSource`, `runId`, `sequence`, `start`, `target`, `tcoBasis`, `unofficialrun`, `utilization`                                                                                                                                                      |
+| `rankings`                      | `format`, `kind`, `model`, `scenario`                                                                                                                                                                                                                                                                                                                                                                                               |
+| `reliability`                   | `asOf`, `format`, `gpus`, `range`                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `submissions`                   | `direction`, `limit`, `lines`, `mode`, `offset`, `onChangeOnly`, `search`, `sort`                                                                                                                                                                                                                                                                                                                                                   |
+| `video`                         | `artifact`, `cell`, `compare`, `costs`, `gpuBasis`, `page`, `phase`, `run`, `selected`, `slot`, `source`, `view`, `workload`, `xAxis`, `yAxis`                                                                                                                                                                                                                                                                                      |
 
 ## Source audit and shared computations
 
@@ -76,6 +76,119 @@ displays `UMBP MoRI SGLang` through October 9, 2026 in America/New_York
 neither API selectors nor response data, framework/hardware keys, or raw CSV
 exports, so no API or OpenAPI contract change is required.
 
+The `/inference` Power Timeline is a different surface from the raw `gpu-metrics`
+explorer. Its existing read-only `/api/gpu-metrics?series=power` source returns
+one-second per-device buckets, role assignments and validation-source identities;
+benchmark `power_audit` supplies the exact serving-window bounds. The public
+`/api/v1/views/gpu-metrics` projection alone does not return that combined evidence
+and must not be described as a serving-window or role-pool projection.
+
+Timeline share fields `i_ptaxis`, `i_ptlines`, `i_ptwindow`, `i_ptfocus`, `i_ptutility`
+and `i_ptconc` are renderer state, not parameters of the raw explorer API. `i_ptconc`
+keeps the chart's rows at one concurrency, so platforms can be read at one load. Window-only
+display selects retained bucket timestamps within the recorded inclusive bounds;
+serving-relative display uses `(bucket UTC ms - window start UTC ms) / 1000`.
+Missing, nonfinite or non-increasing bounds omit that trace in either mode.
+No boundary samples are interpolated, and no stored window statistics or energy
+values are recomputed. Per-GPU/mean/role-pool modes reuse the existing device identity
+and pool-sum calculations. Focus only dims other traces and the utility toggle only
+adds registry references. The validated-window summary below the chart lists each
+trace's run, attempt, validation file and per-run telemetry source (database, or
+GitHub artifact fallback when any requested series was read live), then per pool the
+row's validated average as stored, the largest drawn pool bucket inside the window,
+and GPUs × registry TDP. Raw telemetry, full-record statistics and API responses
+are unchanged by all six display settings. The reusable client helpers are
+`parsePowerTimelineParams`, `powerTimelineSampleX` and `tracePools` in
+`components/inference/utils/powerTimeline.ts`, and `sumPowerAt` in
+`components/gpu-power/power-series.ts`.
+
+Date comparisons are presentation-only as well. With compared dates, `/inference` keeps the
+date-comparison chart on every x-axis mode, including concurrency, draws `?unofficialrun=`
+rows beside the compared series, and the Timeline display follows the same per-date legend
+toggles and colours. The inference view already returns `comparisons` (one projection per
+`dates` or `start`/`end` entry) and `overlays` (one per unofficial run) for every `xmode`.
+The per-date toggles are renderer state, not query keys, so no API or OpenAPI contract
+change is required.
+
+## Fixed-sequence service comparisons
+
+The inference view exposes the same mean/median selector as the dashboard through
+`xstat=median|mean` (default median). Mean streaming speed is **1 / mean TPOT**;
+it is not the arithmetic mean of per-request speeds. Mean TTFT and E2E use their
+recorded mean values. Missing means remain missing; the view never substitutes a
+median. AgentX keeps its selected `percentile`, and concurrency has no statistic:
+`params.xstat` resolves to null in both cases, while `xAxis.statistic` records the
+effective percentile or null.
+
+`serviceCompare=true` adds `serviceSources`, `equalServiceCurve`, and (when
+`serviceTarget` is present) `equalServiceComparison`. Select exact opaque
+`serviceBaseline` and `serviceComparator` keys returned by `serviceSources`,
+encoded with `URLSearchParams`; omitted selections use its first two entries.
+Each source's `label` is display text only: hardware and date, plus precision, topology,
+run or other details only where two sources would otherwise look the same.
+Stale explicit selections remain unavailable. Missing target returns null, not an
+invented operating point. Streaming-speed targets are tok/s/user; TTFT/E2E targets
+are seconds. Concurrency remains a separate observed-load diagnostic, not an
+equal-service comparison axis.
+
+That diagnostic is `matchedConcurrency`, also returned by `serviceCompare=true`: the
+two selected sources paired at every concurrency either one observed. Each side is
+`observed` (J/output token, mean W/GPU and streaming speed at the selected statistic,
+named by `interactivityField`, plus its point identity), `missing`, or `ambiguous`
+when one source's observations at that load disagree; all are listed and none is
+chosen. `changePercent` is `100 × (comparator / baseline − 1)` only when both sides
+were observed. Same-load pairs usually serve different speeds, so the table sits
+beside the equal-service comparison rather than replacing it.
+
+The dashboard and API share `equal-service-comparison.ts`: both consume scoped
+observed points after chart coverage/limits, before frontier and best-per-SKU
+pruning, with power-comparison clones excluded. `allPoints=true` restores clipped
+observations. Source keys retain hardware, precision, exact run, actual source
+date, recipe, topology and workload identity; changing display dates does not
+create a new measured source. Comparisons never join different sources into one
+interpolation bracket. All three metrics use bounded numerical linear
+interpolation of the underlying quantities, then compute
+`100 × (comparator / baseline − 1)`. No log-axis interpolation, extrapolation,
+missing-endpoint bridging or averaging of conflicting duplicate x-values occurs.
+
+Metrics are mean measured GPU board W/GPU, whole-deployment output tokens/s, and
+validated measured GPU J/output token. Each estimate returns its bracket point
+IDs, source/run/topology/recipe identities, endpoint x/value, and whether it was
+interpolated. Unavailable comparisons return explicit reasons and null metrics,
+not zero. This is an operating-point comparison, not proof of a hardware-only
+causal effect. Official, historical and unofficial source identities remain
+visible.
+
+`roleShare=true` returns `roleEnergyShares` and `rolePoints` through the same shared
+role helper. Each role point carries prefill and decode mean W/GPU, role-local
+prefill J/input and decode J/output, and the output-token reconstruction below;
+any missing figure is null.
+Validated disaggregated prefill J/input is multiplied by same-window aggregate
+J/output ÷ J/input, then compared with decode J/output. The percentage denominator
+is reconstructed prefill + decode energy on one output-token basis. Missing or
+invalid role measurements are omitted. This view does not mix pool-local token
+denominators or claim the reconstructed sum was independently measured.
+
+`powerFit=true` returns `powerFits`: per source, an ordinary least-squares line of
+measured mean W/GPU (over all allocated GPUs) against whole-deployment output tok/s
+per allocated GPU. Each fit reports intercept `P₀`, slope `m` (J/output token), R²,
+n and the fitted x-range, plus registry `tdpWatts` and every observation with its
+point identity. Fewer than three distinct output rates return `fit: null` with
+`reason: "too-few-points"`. `P₀` is an extrapolated intercept, not measured idle
+power, and R² is null when power did not vary.
+
+These panel results are JSON-only: `format=csv` with any panel enabled returns
+400, rather than silently exporting only the primary chart. Ordinary CSV retains
+its existing plotted-point contract. Share controls map directly:
+`i_mstat` → `xstat`, `i_servicecompare` → `serviceCompare`, `i_servicebase` →
+`serviceBaseline`, `i_servicepeer` → `serviceComparator`, `i_servicetarget` →
+`serviceTarget`, `i_roleshare` → `roleShare`, and `i_powerfit` → `powerFit`.
+
+The scatter chart's Frontier points table (shown with `i_frontier` on a measured
+power metric) lists the drawn cross-platform frontier with each point's run and
+attempt, and exports it as CSV. The views API has no global-frontier parameter, so
+that table remains dashboard-only.
+
 ## Verification scope
 
 Route tests cover baseline views and selected extension behavior, including
@@ -99,7 +212,41 @@ OperatorX 的入口受功能开关控制，页面使用专属的 `/api/v1/operat
 GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全记录统计使用所选文件、
 主机序列的全部芯片摘要，包含启动与 warmup；已有摘要为空时不补算，缺失读数不补零。
 芯片显隐和图表降采样不改变该统计，也不改变 serving-window 或 J/token 的计算口径。
+
+`/inference` 的 Power Timeline 与原始 `gpu-metrics` 浏览器是两个不同视图。
+时间线通过现有只读 `/api/gpu-metrics?series=power` 获取逐秒采样、设备角色和验证来源，
+再结合基准测试 `power_audit` 中的服务窗口边界；公开的 `/api/v1/views/gpu-metrics`
+本身不返回这组完整证据，不能称为服务窗口或 GPU 池投影视图。
+六个 `i_pt*` 分享字段只控制显示，不是原始浏览器 API 的参数；`i_ptconc` 只保留同一并发数的
+行，便于在同一负载下对照多个平台。窗口模式仅显示已记录
+边界内的采样点（含边界），服务起点模式将 UTC 时间减去窗口起点后换算为秒。
+边界缺失、非有限值或结束不晚于开始时，不绘制对应曲线；不插值补点，也不重算已存储的
+窗口统计或能耗。图下的有效测量窗口汇总列出每条曲线的运行、尝试次数、验证文件和
+遥测来源（数据库，或有序列需实时读取时的 GitHub 产物回退），并按 GPU 池列出基准测试行
+存储的有效平均值、窗口内所绘曲线的最大值，以及 GPU 数 × 注册表 TDP。GPU 池模式复用已有设备角色和求和函数；聚焦仅调暗其他曲线，参考线
+使用硬件注册表。原始遥测、全记录统计和 API 响应均不因这些显示设置而改变。
 响应使用 private, no-store，上游 503 保留为错误响应。
 
+日期对比同样只影响显示。选择对比日期后，`/inference` 在所有 X 轴模式（包括并发数）下都使用日期对比图，
+并与对比序列一同绘制 `?unofficialrun=` 数据；时间线显示沿用同一套按日期切换的图例和配色。
+只读 inference 视图已对每种 `xmode` 返回 `comparisons`（每个 `dates` 或 `start`/`end`
+条目一份投影）和 `overlays`（每个非官方运行一份）。按日期显隐属于渲染状态，不是查询参数，
+因此无需修改 API 或 OpenAPI 契约。
+
+`serviceSources` 中各数据源的 `label` 仅供显示，由硬件和日期组成；只有两个数据源无法区分时，
+才补充精度、拓扑、运行等信息。选择数据源时应使用其 `key`。
+
+`serviceCompare=true` 还返回 `matchedConcurrency`：按并发数逐行配对两个所选数据源，任一方在
+该并发数下有观测即列出一行；每侧为 `observed`、`missing`，或同一负载下观测值不一致时的
+`ambiguous`（全部列出、不选其一）；仅当两侧都有观测时才计算变化百分比。同一并发下两者
+的服务速度通常不同，因此该表只作诊断，不替代同等服务对比。`roleShare=true` 另返回
+`rolePoints`（各角色 W/GPU、按本池 token 计的能耗及按输出 token 重建的能耗）。
+`powerFit=true` 返回 `powerFits`：每个数据源以最小二乘法拟合平均 W/GPU 与每个已分配
+GPU 的输出 tok/s，给出 `P₀`、`m`（J/输出 token）、R²、点数、拟合范围和注册表 TDP；
+不同输出速率少于 3 个时不拟合。`P₀` 是外推截距，不是实测空载功耗。这些面板只支持
+JSON；`i_powerfit` 对应 `powerFit`。散点图的前沿点表（`i_frontier` 开启且为实测功耗
+指标时显示）列出跨平台前沿各点的运行和尝试次数，并可导出 CSV；只读 API 没有全局前沿
+参数。
+
 测试覆盖契约同步及代表性的筛选行为，并未穷举所有参数组合。生产数据库上的
 完整 UI/API 对照仍需集成审查，不能仅凭单元测试宣称已完成。
diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index a7a365103..85130e516 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -605,49 +605,13 @@ run — are never copied. Our own GCS reader (`lib/gcs-artifacts.ts`) additional
 ignores everything but `bmk_`/`server_logs_` objects, so widening the mirror's run
 filter would also need a reader change before backfill could use it.
 
-Readers: `/api/gpu-metrics?runId=` serves stored telemetry first, including
-`series=power` Timeline buckets reconstructed with retained windows and device
-identities. Missing storage falls back to GitHub artifacts. Known-incomplete CSV
-fallback must match retained filenames and sample counts; known-incomplete bundles
-need exact-source re-ingest. Healthy DB series remain in mixed fallback responses.
-Database failures return `503 DATABASE_UNAVAILABLE`; incomplete storage without
-usable fallback returns `503 STORED_TELEMETRY_INCOMPLETE` with re-ingest guidance.
-Timeline requests use read-only POST with sorted validation basenames in a `sources`
-JSON body. Stored coverage of those identities permits an artifact-independent response;
-missing siblings, including other windows in the same bundle, use source-level DB-first
-merging. Unavailable artifacts leave healthy DB traces readable with explicit missing
-sources. `sourceCoverage` describes only the requested identities; legacy GET reports
-coverage unknown. Plain CSV fallback applies the adjacent context timezone just like
-ingest and bundle reads. Raw multi-file artifacts retain separate file/host series.
-Successful reads and storage errors use no-store.
-
-AgentX nested validation documents are matched to the exact root result and retained
-window before receiving a canonical validation filename alias. Original path, result
-filename and validation hash remain in stored sidecars. CI attaches recovered source
-and window metadata before benchmark publication/upsert; targeted telemetry re-ingest
-fills only NULL provenance for a unique explicit run/result/concurrency match, even
-when samples are unchanged. Metrics and validity remain untouched. Benchmark metadata
-repair additionally needs the existing materialized-view refresh and benchmark-cache
-invalidation before the UI planner can discover the restored Timeline source.
-
-`/api/v1/gpu-metrics-point?id=` powers the PowerX point-detail tab. Every request
-checks the current DB revision before reading its Blob payload cache. Sidecar repairs,
-new point links and shared-series changes therefore select fresh payloads without a
-manual purge. Success, missing-point and error responses use no-store; missing data
-is 404 and database failures remain errors. Cache-write failures log a warning and
-serve the fresh uncached result; the next request retries cache population.
-
-The public `/api/v1/views/gpu-metrics` projection and full-record UI table use the
-same per-GPU statistics digest for the selected file/host series. Current-version
-empty or missing metric digests remain empty. Unversioned or outdated digests
-are recomputed read-only from retained DB samples with the shared ingest algorithm.
-Incomplete retained samples leave statistics empty while preserving raw data for
-the existing source-gap recovery path; stats-only writes fail until the source is repaired.
-Statistics include startup and warmup, retain measured zero, and exclude missing
-readings per metric after first-wins timestamp/GPU deduplication. Mean is
-sample-weighted, percentiles interpolate at `p * (N - 1)`, and standard deviation
-divides by `N`. GPU visibility and chart downsampling do not alter this population.
-Serving-window power, J/token and selected-time-window calculations remain separate.
+Readers — `/api/gpu-metrics?runId=` (including the `series=power` Timeline POST),
+the `/api/v1/gpu-metrics-point?id=` point-detail cache and the public
+`/api/v1/views/gpu-metrics` statistics projection — serve stored telemetry first and
+fall back to GitHub artifacts only for storage that is missing; database failures are
+`503` errors, never an empty result. Fallback and coverage rules, AgentX nested
+validation aliases, cache-revision checks and the full-record statistics definitions
+are in [PowerX persistence and repair](./powerx-persistence-recovery.md).
 
 中文：历史遥测和 Timeline 优先读取数据库；缺少存储数据时回退到 GitHub 产物，
 文件、主机与 GPU 的身份保持独立。数据库故障返回 503；已知存储不完整且无法恢复时，
@@ -725,8 +689,3 @@ empty receipt says `no_8k1k_points`, never that power coverage was validated.
 The workflow retains both the input manifest and verification receipt. Cache
 invalidation errors fail the workflow instead of being swallowed. Imported P75/P90
 ledger edits trigger the existing reviewed override workflow.
-
-The dashboard availability panel uses scoped points before Y-metric filtering,
-including visible unofficial overlays. It distinguishes schema-2 validation,
-other validated data, missing verdicts, withheld measurements, unavailable metrics,
-and non-applicable separate-pool metrics without filling missing values.
diff --git a/docs/data-transforms.md b/docs/data-transforms.md
index f5dcd0935..ebf7e541e 100644
--- a/docs/data-transforms.md
+++ b/docs/data-transforms.md
@@ -159,6 +159,10 @@ Both charts share the same Y-axis options. The `y` field is the default `AggData
 - `title` / `titleZh`: bilingual dropdown and chart titles.
 - `polarity`: whether higher or lower values are preferable. The derived chart definitions combine this with x-axis polarity to produce the concrete Pareto corner.
 
-**X-axis selection** takes precedence over the Y metric: selecting an input-energy metric keeps the chosen Interactivity, TTFT, or E2E axis. Fixed-sequence TTFT uses the measured median; agentic TTFT uses the selected percentile. Official data, unofficial overlays, and Replay share the resolved axis. Missing or zero-filled TTFT values are omitted instead of becoming plotted latency measurements. The legacy input-metric override (`inputTputPerGpu` declares `p90_ttft`) applies only to callers without a global x-axis mode.
+**X-axis selection** takes precedence over the Y metric: selecting an input-energy metric keeps the chosen Interactivity, TTFT, or E2E axis. Fixed-sequence service axes use `i_mstat=median|mean` (default `median`); Agentic axes keep the selected percentile. Mean interactivity resolves the separate `mean_tpot_intvty` field, derived as `1 / mean_tpot` with TPOT in seconds, not the arithmetic mean of per-request speeds (`mean_intvty`, retained unchanged). Mean TTFT and E2E use the explicit `mean_ttft` and `mean_e2el` measurements. Missing, non-finite or nonpositive mean measurements are omitted, never replaced by median or raw interactivity. Axes and headings identify Mean/Median; changing the effective field clears Perf Rulers. Official data, unofficial overlays, Replay, tables and CSV share the resolved axis. Concurrency ignores this statistic. Missing or zero-filled TTFT values are omitted instead of becoming plotted latency measurements. The legacy input-metric override (`inputTputPerGpu` declares `p90_ttft`) applies only to callers without a global x-axis mode.
+
+**Observed concurrency** — `i_xmode=concurrency` / API `xmode=concurrency` resolves `conc` through the same `resolveXAxisField` helper for official data, unofficial overlays and the read-only inference view. It has no percentile prefix or preferred X direction: `useChartData` removes roofline directions, and the API returns no frontier/best flags and resolves optimal/best filtering off. Missing, non-finite or nonpositive concurrency is not replaced with latency. Metric-bearing observed loads bypass cost/latency display clipping; tables and CSV retain the same X values. Replay is not offered for this mode.
+
+`pointTopologyKey` supplies exact topology filter keys without concurrency, hardware, precision, date, run or recipe identity. The API includes `topologyKey` on each point so a caller can reuse it as a selector. Rendering adds the omitted identity dimensions before joining observed loads; see [Observed concurrency sweeps](d3-charts.md#observed-concurrency-sweeps). A topology filter does not imply that two platforms' measured concurrency sets, software or other experimental conditions match.
 
 **Limits** — both charts include `y_cost_limit: 5` (clip cost-per-million metrics above $5/M tokens) and `y_latency_limit: 60` (clip x-axis outliers beyond 60s when TTFT is on x). Tokens-per-dollar metrics are not cost-clipped; clipped cost points remain available to the dashed continuation layer.
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 8e3725ca2..b29c3270c 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -76,26 +76,15 @@ existing `inference_y_axis_metric_selected` fired by `ChartControls`.
 
 A point without a value for the selected boundary is omitted from that series only (the
 builders never emit `{ y: 0 }`, and both the official and overlay paths filter by
-`metricKey in point`). The PowerX availability panel explains the gap per point:
-
-| State              | Meaning                                                                                                                                                  |
-| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `noSpec`           | hardware has no `tdp` / `power` in `HW_REGISTRY`                                                                                                         |
-| `noThroughput`     | provisioned watts exist but the row has no output throughput                                                                                             |
-| `noNormalization`  | disaggregated row with throughput but no whole-deployment GPU count (`powerBasisNormalization`: not `single_turn`, or non-integer prefill/decode counts) |
-| `noTelemetry`      | modeled boundary needs validated GPU telemetry (B4 follows B1)                                                                                           |
-| `invalid`          | `power_valid === 0`                                                                                                                                      |
-| `modelWorkload`    | chassis model covers 8K / 1K only                                                                                                                        |
-| `modelHardware`    | hardware outside the chassis profiles (GB200 / GB300 NVL72)                                                                                              |
-| `modelUnsupported` | other `modelSystemPower` reasons (gpu-count, topology, role-power …)                                                                                     |
+`metricKey in point`).
 
 The chart caption (`data-testid="power-basis-assumptions"`) names the boundary, the formula in
 words, the PUE constant and the chassis-model revision so a screenshot records its method.
 The pinned tooltip's "Modeled system power" block (`tooltipUtils.ts` `modeledSystemPowerHTML`)
 renders only for `measured*` keys and `y_modeledChassisPowerPerGpu`, so on the boundary keys the
 caption is the only per-chart provenance; the caption does not promise more.
-The empty state for the utility-modeled boundary says why nothing rendered and points at the
-Boundary select.
+When no point in the selection reports the selected telemetry axis, the chart's empty state says
+the selection has no measured GPU power (`noMeasuredDataHint`) instead of the generic hint.
 
 ## Article figure → share link
 
@@ -143,9 +132,9 @@ role's availability rules carry through unchanged.
 Siblings exist only where the metric names the whole-deployment **average W/chip** or **J per
 output token** (the only quantities every boundary and role publishes on one axis); role
 energy additionally excludes the prefill J per input token scope. Elsewhere
-`powerCompareVariants` returns nothing, the Compare select disables the option, and — when a
-link arrives with an inapplicable mode — a hint (`measured-compare-hint`) says the comparison is
-paused. The parameter is kept, so switching back to an applicable setting resumes it.
+`powerCompareVariants` returns nothing and the Compare select disables the option. A link that
+arrives with an inapplicable mode keeps the parameter, so switching back to an applicable
+setting resumes it.
 
 Rendering (`ScatterGraph`): the series key is `scatterSeriesKey(point)` =
 `<hwKey>_<precision>[-v-<variant>]` (`utils/point-identity.ts`), so rooflines, frontiers,
@@ -165,8 +154,7 @@ line-swatch row per series present (base first); rows toggle chart-local visibil
 Tooltips add a "Series" line; on the energy axis a role clone also reports its share of the
 reconstructed request energy. Table adds a "Series" column and CSV a trailing "Power Series"
 column only while clones are present. Comparison clones are excluded from `bestSeriesPerSku`,
-the power-tier counts, the legend points table, the availability panel (which reads
-`selectionPoints`) and the date-comparison `GPUGraph`. Unofficial-run pills read `✕ <hardware>` (`getOverlayLineLabel`); the branch stays in the
+the legend points table and the date-comparison `GPUGraph`. Unofficial-run pills read `✕ <hardware>` (`getOverlayLineLabel`); the branch stays in the
 legend and a short run tag (` · main`, ` · …<date>-<sha>`) is appended only when several overlay
 runs draw the same hardware.
 
@@ -185,8 +173,8 @@ track `inference_power_compare_series_toggled { series, visible }`.
 
 `y_measuredPowerTimeline` is the third value of the Measured Power **Display** control
 (`watts` / `tdp` / `timeline`, `MeasuredPowerDisplay` in `measured-metric-config.ts`). Its
-registry field aliases `measuredAvgPower`, so the point set, the availability panel, the Table
-view and the share link are those of the measured average; only the chart body changes:
+registry field aliases `measuredAvgPower`, so the point set, the Table view and the share link
+are those of the measured average; only the chart body changes:
 `ChartDisplay` renders `ui/PowerTimeline.tsx` instead of `ScatterGraph` when the resolved
 config is `display: 'timeline'`.
 
@@ -204,14 +192,16 @@ config is `display: 'timeline'`.
     matches before falling back to the artifact name.
 
   Nothing is matched by hardware or concurrency. Rows whose telemetry is missing (expired
-  artifact, bundle over the download cap, another collector) are listed under the chart
-  (`data-testid="power-timeline-missing"`), never estimated. Trace keys are
+  artifact, bundle over the download cap, another collector) are not drawn, never
+  estimated. Trace keys are
   `<runId>:<name>` (`traceKeyForPoint`), unique per point in both collectors.
 
 - **Fetch.** One request per workflow run in the visible points
   (`planPowerTimelineRequests`, at most `POWER_TIMELINE_MAX_RUNS`; a deep-linked trace's run
-  goes first, then `?unofficialrun=` overlay runs, then official runs — `prioritizeRun` /
-  `prioritizeRuns` — so an overlay the user asked for is never the run that gets dropped),
+  goes first, then runs holding a point the legend shows (`?unofficialrun=` overlay runs before
+  official ones), then runs whose points are all hidden — `prioritizeRun` / `prioritizeRuns` — so
+  an overlay the user asked for, or a pair left visible for comparison, is never the run that gets
+  dropped),
   narrowed with
   `prefix=` to the common RESULT_FILENAME prefix so a nightly sweep's other models are not
   downloaded. `/api/gpu-metrics?series=power` first uses persisted telemetry and returns one-second per-GPU buckets
@@ -231,6 +221,17 @@ config is `display: 'timeline'`.
   (`setUnifiedOverlaySelection`, `computeToggle` solo semantics) exactly as `ScatterGraph`
   does; the context's `toggleHwType` alone would change nothing visible there.
 
+- **Date comparison.** With chip configs and comparison dates selected, `ChartDisplay` passes
+  `comparison`, and official traces become the compared (date, chip config) series of the
+  date-comparison `GPUGraph`. `useComparisonSeries` gives both displays the same series, run
+  numbers and colours. The legend lists one row per series with a trace candidate, grouped
+  under its hardware; a click calls `toggleActiveDate` with the same solo semantics, and a
+  soloed date hides the other dates' traces. Overlay runs stay in one _Unofficial run_ group
+  in their run colour and still follow `activeOverlayHwTypes`. The tooltip header, the focus
+  chip and the summary's hardware column add the date or run
+  (`B200 (SGLang) · 2026-09-23`); end labels lead with it only while more than one entry is
+  visible (`2026-09-23 c1`).
+
 - **Drawing.** One trace per config, mean of its GPUs (legend switch: one line per GPU),
   coloured by hardware for official rows and by `overlayRunColor(runIndex)` for
   `?unofficialrun=` rows; legend toggles follow `activeHwTypes` / `activeOverlayHwTypes`
@@ -239,7 +240,8 @@ config is `display: 'timeline'`.
   the all-in provisioned line is an opt-in legend switch because it halves the traces'
   vertical resolution. X axis: wall clock (UTC) when the visible traces come from one run,
   otherwise seconds since each trace's start; both are a toolbar toggle. `c<conc>` labels sit
-  at the end of the emphasized segment.
+  at the end of the emphasized segment; labels that would overprint stack one row apart
+  (`stackTraceLabels`).
 - **Pools (Figure 1).** The legend switch _Prefill / decode pools_ (shown when a visible
   trace carries worker roles) sums the board power of each role's GPUs
   (`tracePools` / `sumPowerAt`) and draws one line per pool — prefill dashed `7 3`, decode
@@ -253,24 +255,82 @@ config is `display: 'timeline'`.
   all-in switch scales the same way. The tooltip names the pool, its summed watts against the
   pool TDP, and the mean / min / max per GPU inside it. Pool mode and per-GPU lines are
   mutually exclusive.
-- **Deep link.** A pinned scatter tooltip on any metric of the measured family offers _View
-  power trace_ (`data-action="view-power-trace"`, official and `?unofficialrun=` points
-  alike). It switches the Display to Timeline in place and records the point's trace key in a
+- **Deep link.** A pinned tooltip on any metric of the measured family, in the scatter chart or
+  the date-comparison `GPUGraph`, offers _View power trace_ (`data-action="view-power-trace"`,
+  official and `?unofficialrun=` points alike). It switches the Display to Timeline in place and records the point's trace key in a
   one-shot module store (`requestPowerTraceFocus`); the timeline consumes it on mount, dims
   every other trace, switches to pool mode when the trace has roles, and shows a _Focused on …_
   chip (`data-testid="power-timeline-focus"`) with _Show all_ to clear. The link's `href` is
-  the current page with `i_metric=y_measuredPowerTimeline`, so open-in-new-tab lands on the
-  timeline (unfocused: the focus is a gesture, not URL state).
-- **State.** Axis mode, line mode (mean / per GPU / pools), the all-in switch, the focused
-  trace and hover highlight are component state, not URL state: the share link is `i_metric=y_measuredPowerTimeline` plus the usual
-  scope, and a reader lands on the same defaults.
+  the current page with `i_metric=y_measuredPowerTimeline` only, so open-in-new-tab lands on
+  the unfocused timeline; once the focus is applied it is written to `i_ptfocus` like the other
+  timeline settings.
+- **Same load across platforms.** The toolbar _Concurrency_ select (`i_ptconc`, default all)
+  keeps the chart's rows at one load, so, for example, GB200 and GB300 prefill/decode pools draw
+  side by side; `i_ptaxis=serving` aligns them at each validated window's start. With two or
+  more hardware types visible, every line label leads with the hardware label. A deep link
+  resets the filter so the focused trace is never filtered out.
+- **Validated-window summary.** `ui/PowerTimelineSummary.tsx` lists each drawn trace's
+  hardware and config, run link, attempt, validation file, per-run telemetry source
+  (`database`, or `GitHub artifact fallback` when `/api/gpu-metrics` read any requested series
+  live) and window length. Per pool (all GPUs, prefill, decode) it shows the GPU count, the
+  row's validated average W/GPU as stored, the largest drawn 1-s pool sum inside the window
+  (`summarizeTraceWindow`) and pool TDP = GPUs × `HW_REGISTRY.tdp`. No average is recomputed.
+- **State.** Axis mode (`i_ptaxis`), line mode (`i_ptlines`: mean / `gpu` / `pool`), window-only
+  display (`i_ptwindow`), the focused trace (`i_ptfocus`), the all-in switch (`i_ptutility`) and
+  the concurrency filter (`i_ptconc`) are `PowerTimeline` component state mirrored into the URL by the component itself
+  (`parsePowerTimelineParams` on mount, `setUrlParams` on change); defaults serialize as `''`.
+  Hover highlight is never shared. See
+  [Dashboard read-only views](./dashboard-readonly-views.md) for the renderer-only status of
+  these fields against the raw `gpu-metrics` API.
 - **Analytics.** `inference_power_timeline_loaded { traces, missing, runs }`,
   `inference_power_timeline_axis_changed { mode }`,
   `inference_power_timeline_lines_changed { lines: 'mean' | 'gpu' | 'pool' }`,
   `inference_power_timeline_utility_toggled { enabled }`,
+  `inference_power_timeline_concurrency_changed { concurrency }`,
   `inference_power_trace_opened { hwKey, conc, overlay }` (scatter tooltip action),
   `inference_power_timeline_focus_cleared`.
 
+## Analysis panels (article figures 6–16)
+
+Figure numbers here follow the current article draft; the share-link table above predates its
+renumbering. Below the measured chart, `ui/PowerServiceComparison.tsx` offers three opt-in
+panels, and the scatter chart adds a fourth. All read the chart's scoped observed points
+(`observedPoints`: official and `?unofficialrun=` rows, comparison clones excluded), keep one
+source per exact run and recipe (`equalServiceSourceKey`), and colour overlay sources with
+`overlayRunColor`.
+
+| Figures      | Panel                                                                                                                                         | Switch (share param)                                                                                    | Helper                                                 |
+| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
+| 6 / 7 / 9    | Same-concurrency table: baseline and comparator J/output token, W/GPU and streaming speed, with % change                                      | _Compare at the same speed / latency_ (`i_servicecompare=1`, sources `i_servicebase` / `i_servicepeer`) | `utils/matched-concurrency.ts`                         |
+| 12 / 13 / 14 | Role group: W/GPU by role, role-local J/input and J/output (not added), J/output token by role with the total, prefill share                  | _Prefill / decode roles_ (`i_roleshare=1`)                                                              | `getRolePoints` in `utils/equal-service-comparison.ts` |
+| 15           | Least-squares fit of mean W/GPU against output tok/s per allocated GPU: points, line, dashed extension to zero, P₀, P₀ ÷ TDP, m, R², n, range | _Power vs output-rate fit_ (`i_powerfit=1`)                                                             | `utils/power-fit.ts`                                   |
+| 16           | Frontier points: the drawn cross-platform frontier and each point's run and attempt                                                           | Legend _Pareto frontier_ (`i_frontier`) on a measured metric                                            | `utils/frontier-points.ts`                             |
+
+- **Same concurrency** pairs only observations; nothing is interpolated. A side missing at a
+  load reads _Not measured_. Disagreeing duplicates of one source read as ambiguous, with none
+  chosen. % change needs both sides. Same load usually means different speed, so the table
+  sits beside the equal-service comparison, not in place of it.
+- **Roles** use validated disaggregated rows. Each panel names its denominator. Missing role
+  telemetry is omitted, never drawn as zero, and share points stay unconnected.
+- **Fit** needs three distinct output rates per source. Output is whole-deployment tok/s over
+  all allocated GPUs, on the same basis as the mean W/GPU. P₀ is an extrapolated intercept,
+  not measured idle power, and R² describes only that line.
+- **Frontier** lists `globalParetoFrontier`'s own output, so the table is exactly what is
+  drawn. Ties keep the first point, official before overlay.
+- **Source labels** (`getEqualServiceSources`) read hardware and date, adding precision,
+  topology, run, attempt, recipe, image or point only where two sources would otherwise look
+  the same. The opaque key stays the exact identity.
+- Plots export PNG and CSV; the frontier table exports CSV only. Panel subtitles and the
+  baseline → comparator pair are export-only, so a PNG names its workload and sources while
+  the screen shows only the source selects. The views API returns
+  `matchedConcurrency`, `rolePoints` and `powerFits`
+  ([Dashboard read-only views](./dashboard-readonly-views.md#fixed-sequence-service-comparisons));
+  it has no global-frontier parameter.
+- Analytics: `inference_equal_service_toggled`, `inference_power_roles_toggled` and
+  `inference_power_fit_toggled` (`{ enabled }`), `inference_equal_service_source_changed
+{ role }`, and chart-button events under `matched_concurrency`, `power_roles`, `power_fit`
+  and `frontier_points`.
+
 ## Tests
 
 - `lib/power-basis.test.ts` and `lib/chart-utils.test.ts` — the six boundary values through
@@ -283,4 +343,15 @@ config is `display: 'timeline'`.
   failure as 503, known missing hosts, and the retained-inventory recount before a CSV
   fallback.
 - `cypress/component/power-timeline.cy.tsx`, `power-compare.cy.tsx` — overlay-run colour and
-  the overlay hardware filter.
+  the overlay hardware filter; in date comparison, per-date trace colours, legend solo toggles
+  and date-prefixed end labels.
+- `cypress/component/gpu-graph.cy.tsx`, `cypress/e2e/inference-chart.cy.ts` and
+  `lib/d3-chart/layers/rooflines.test.ts` — `?unofficialrun=` runs stay on the date-comparison
+  `GPUGraph` in their run colour and dash on the interactivity and concurrency axes, per-curve
+  dashes survive display updates, and concurrency sweeps split per date, run and topology.
+- `utils/matched-concurrency.test.ts`, `utils/power-fit.test.ts`, `utils/powerTimeline.test.ts`
+  — signed same-concurrency deltas, the least-squares fit and R², disaggregated fits on output
+  per allocated GPU, and the peak pool power inside the validated window.
+- `cypress/component/power-service-comparison.cy.tsx`, `frontier-points-panel.cy.tsx`,
+  `power-timeline.cy.tsx` and `cypress/e2e/powerx-compare.cy.ts` — the article panels on
+  `?unofficialrun=` overlay rows.
diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
index 898d5ace7..aee26602d 100644
--- a/docs/powerx-persistence-recovery.md
+++ b/docs/powerx-persistence-recovery.md
@@ -4,8 +4,7 @@ PowerX point detail, the run explorer and Power Timeline read migration-016 tele
 from the database. Timeline applies the same prefix selection, validation-window cuts,
 60-second padding and one-second per-device means as the artifact path. Stored samples
 retain UTC timestamps, original units and separate host-local GPU identities. GitHub
-remains the fallback for telemetry that has not been stored. Database failures return an
-error, not an empty result or an artifact fallback.
+remains the fallback for telemetry that has not been stored.
 
 Timeline sends a read-only `POST /api/gpu-metrics?runId=RUN_ID&series=power&prefix=PREFIX`
 with JSON `{ "sources": ["power_validation_RESULT_FILENAME.json"] }`. The planner sorts
@@ -134,7 +133,6 @@ the unknown denominator.
 This also applies on the first receipt: a selected expired benchmark sibling records
 an expectation error without attempting a download. Superseded retries and unrelated
 targets remain excluded by the existing logical-name and artifact filters.
-Known failed benchmark rows remain excluded, matching normal CI.
 
 Historical backfill retains the resolver's exact-first, unique-fallback offload matching.
 A proven fallback uses the persisted point's offload identity before receipt counting
@@ -182,9 +180,13 @@ receipt recovery error also blocks the complete count, even when older data rema
 ## Full-record statistics
 
 The point detail, run explorer and public `/api/v1/views/gpu-metrics` projection use the
-stored per-GPU digest for the existing full-record statistics, with name mappings only.
+current-version per-GPU digest for the existing full-record statistics, with name mappings
+only. Unversioned or outdated digests (`stats_version` ≠ `GPU_STATS_VERSION`) are recomputed
+read-only from retained DB samples with the shared ingest algorithm; incomplete retained
+samples leave statistics empty for the source-gap recovery path (see
+[statistics upgrades](./data-pipeline.md#full-record-statistics-upgrades-migration-017)).
 Units and percentile/stddev definitions are unchanged.
-Zero is a value; missing metrics or an empty digest remain missing. Live, un-ingested
+Zero is a value; missing metrics or an empty current-version digest remain missing. Live, un-ingested
 artifact data still computes statistics in the browser. These tables include startup and
 warmup. They are not serving-window power, energy, or user-selected-window statistics.
 
@@ -204,12 +206,6 @@ float32 tolerance rather than the tighter tolerance of the in-memory parser test
 From the repository root:
 
 ```sh
-bun install --frozen-lockfile --ignore-scripts
-bun run test:unit
-bun run typecheck
-bun run lint
-bun run fmt
-bun run check:typography
 bun run --cwd packages/app test:unit src/app/api/v1/gpu-metrics-point/route.test.ts
 bun run --cwd packages/app test:unit src/app/api/v1/views/gpu-metrics/route.test.ts
 bun run --cwd packages/db test:unit src/queries/gpu-metrics-timeline.test.ts src/etl/telemetry-receipt.test.ts
diff --git a/docs/state-ownership.md b/docs/state-ownership.md
index 4c8ff69d5..9c4014ccc 100644
--- a/docs/state-ownership.md
+++ b/docs/state-ownership.md
@@ -114,7 +114,7 @@ Axis and presentation state:
 
 - selected x-axis and y-axis metrics, percentile, and effective x-axis mode
 - the Measured controls (Boundary / Per / Scope / Statistic / Display / Unit) own no state: `measured-metric-config.ts` resolves each selection to the nearest registered metric key and writes it back to `selectedYAxisMetric`, so the power boundary rides on `i_metric` (there is deliberately no `i_pbasis`; see [PowerX Permanent View](./powerx-permanent-view.md))
-- the Measured Power Display value `timeline` (`y_measuredPowerTimeline`) swaps the chart body for `PowerTimeline`; its axis mode, per-GPU lines and all-in reference switch are component state and never enter the URL
+- the Measured Power Display value `timeline` (`y_measuredPowerTimeline`) swaps the chart body for `PowerTimeline`; its axis mode, line mode, window-only display, focused trace, all-in reference switch and concurrency filter are component state that `PowerTimeline` itself reads and writes through `useUrlState` as `i_ptaxis` / `i_ptlines` / `i_ptwindow` / `i_ptfocus` / `i_ptutility` / `i_ptconc`, so they never pass through the display domain
 - token-revenue price source (`i_revenue`): normalized uncached/cached/output pricing or the selected model's live OpenRouter catalog prices
 - scale, optimal-point, label, contrast, legend, and overlay controls
 
@@ -319,8 +319,8 @@ How the GPU-across-time comparison works in the inference tab:
 2. `useChartData` (in `InferenceProvider`) calls `buildComparisonDates()` to deduplicate and exclude the main `effectiveRunDate`.
 3. `useQueries` fires one `useBenchmarks(model, date)` request per comparison date in parallel, alongside the main date query.
 4. **Date stamping**: Each row from a comparison query is overwritten with `{ date: comparisonDates[i], actualDate: r.date }`. The `actualDate` field preserves the real DB date. Without this stamp, `activeDates` (keyed by user-selected date strings like `2025-01-15_h100-sxm`) would never match the rows' `date` field, so the toggle set would have no effect.
-5. `activeDates` is a `Set<string>` of `${date}_${gpuKey}` composite keys. It is initialised to all IDs whenever `allDateIds` changes (effect at line 473). Users toggle individual overlays on/off.
-6. Rows from all dates are merged into a single `rows` array and passed through `transformBenchmarkRows` — the chart renders all of them on the same axes, coloured by GPU + date.
+5. `activeDates` is a `Set<string>` of `${date}_${gpuKey}` composite keys. It is initialised to all IDs whenever `allDateIds` changes (effect at line 473). Users toggle individual overlays on/off: the `GPUGraph` legend and, on the Measured Power Timeline display, the `PowerTimeline` legend both call `toggleActiveDate` (`computeToggle` solo semantics). `ChartDisplay`'s `visibleDateComparisonRows` applies the same set to the table, CSV export and PowerX analysis panels. `?unofficialrun=` rows are not date series, so `activeDates` never hides them; they follow `activeOverlayHwTypes`.
+6. Rows from all dates are merged into a single `rows` array and passed through `transformBenchmarkRows` — the chart renders all of them on the same axes, coloured by GPU + date. `useComparisonSeries` owns the series order, run numbers and colours, so `GPUGraph` and `PowerTimeline` draw one (date, GPU) pair in the same colour.
 
 **When the latest date is selected as the main run date**: `useChartData` maps the selected date to `''` if it equals `latestAvailableDate`, reusing the no-date query key from the materialized view rather than firing a duplicate request.
 
diff --git a/packages/app/cypress/component/frontier-points-panel.cy.tsx b/packages/app/cypress/component/frontier-points-panel.cy.tsx
new file mode 100644
index 000000000..4d1af5c0a
--- /dev/null
+++ b/packages/app/cypress/component/frontier-points-panel.cy.tsx
@@ -0,0 +1,98 @@
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+
+import type { InferenceData } from '@/components/inference/types';
+import FrontierPointsPanel from '@/components/inference/ui/FrontierPointsPanel';
+import { globalParetoFrontier } from '@/components/inference/utils/global-pareto';
+import { createMockInferenceData } from '../support/mock-data';
+import { mountWithProviders } from '../support/test-utils';
+
+const RUN = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs';
+const OVERLAY_RUN_URL = `${RUN}/33348766792/attempts/2`;
+const point = (overrides: Partial<InferenceData>) =>
+  createMockInferenceData({
+    hwKey: 'b200_sglang',
+    framework: 'sglang',
+    precision: 'fp8',
+    physicalChips: 4,
+    tp: 4,
+    decode_tp: 4,
+    date: '2026-09-18',
+    run_url: `${RUN}/35317697106/attempts/1`,
+    image: 'lmsysorg/sglang:nightly-dev-cu13-20260918-20518d85',
+    ...overrides,
+  });
+const gb300 = (overrides: Partial<InferenceData>) =>
+  point({
+    hwKey: 'gb300_dynamo-sglang',
+    framework: 'dynamo-sglang',
+    disagg: true,
+    physicalChips: 8,
+    num_prefill_gpu: 4,
+    num_decode_gpu: 4,
+    run_url: `${RUN}/35319969159/attempts/1`,
+    ...overrides,
+  });
+// Interactivity (higher is better) against J/output token (lower is better).
+const official = [
+  point({ id: 1, conc: 128, x: 31.6, y: 0.824 }),
+  point({ id: 2, conc: 1, x: 186.9, y: 9.065 }),
+  gb300({ id: 3, conc: 1, x: 206.3, y: 12.275 }),
+  gb300({ id: 4, conc: 4, x: 172.2, y: 4.634 }),
+  gb300({ id: 5, conc: 64, x: 72.2, y: 1.311 }),
+];
+// Faster and cheaper than GB300 c1, so the overlay point displaces it.
+const overlay = [
+  point({
+    id: 0,
+    hwKey: 'mi355x_sglang',
+    conc: 1,
+    x: 215,
+    y: 11,
+    run_url: OVERLAY_RUN_URL,
+    image: 'lmsysorg/sglang-rocm:v0.5.18-rocm720-mi35x-20260828',
+  }),
+];
+const eligible = [...official, ...overlay];
+const frontier = globalParetoFrontier(eligible, true, false);
+
+function mountPanel() {
+  cy.viewport(1280, 1000);
+  mountWithProviders(
+    <PathnameContext.Provider value="/inference">
+      <div style={{ width: '100%', maxWidth: 1120, padding: 12, boxSizing: 'border-box' }}>
+        <FrontierPointsPanel
+          chartId="frontier-test"
+          eligible={eligible}
+          frontier={frontier}
+          xLabel="Interactivity (tok/s/user)"
+          yLabel="J/output token"
+          overlayPoints={overlay}
+          hardwareLabel={(entry) => entry.hwKey.split('_')[0].toUpperCase()}
+          hardwareColor={() => 'rgb(200, 0, 0)'}
+        />
+      </div>
+    </PathnameContext.Provider>,
+    { unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } } },
+  );
+}
+
+describe('FrontierPointsPanel', () => {
+  it('lists each frontier point with its run and marks the ?unofficialrun= point', () => {
+    mountPanel();
+    cy.get('[data-testid="frontier-points-row"]').should('have.length', 5);
+    cy.get('[data-testid="frontier-points-row"]')
+      .filter(':contains("MI355X")')
+      .should('contain.text', 'unofficial')
+      .and('contain.text', 'attempt 2')
+      .find('a')
+      .should('have.attr', 'href', OVERLAY_RUN_URL)
+      .and('have.text', 'run 33348766792');
+    cy.get('[data-testid="frontier-points-row"]')
+      .filter(':contains("MI355X")')
+      .find('th > span')
+      .first()
+      .should('have.attr', 'style')
+      .and('contain', 'var(--overlay-run-0)');
+    cy.get('[data-testid="frontier-points-table"]').should('not.contain.text', '206.3');
+  });
+});
diff --git a/packages/app/cypress/component/gpu-graph.cy.tsx b/packages/app/cypress/component/gpu-graph.cy.tsx
index b3aa046b2..f65575296 100644
--- a/packages/app/cypress/component/gpu-graph.cy.tsx
+++ b/packages/app/cypress/component/gpu-graph.cy.tsx
@@ -1,19 +1,34 @@
 import GPUGraph from '@/components/inference/ui/GPUGraph';
 import { InferenceContextsProvider } from '@/components/inference/InferenceContext';
-import { useState } from 'react';
+import type { ChartDefinition, InferenceData } from '@/components/inference/types';
+import {
+  UnofficialRunContext,
+  type UnofficialRunContextType,
+} from '@/components/unofficial-run-provider';
+import { useState, type ReactElement } from 'react';
 import { mountWithProviders } from '../support/test-utils';
 import {
   createMockInferenceData,
   createMockChartDefinition,
   createMockHardwareConfig,
   createMockInferenceContextValues,
+  createMockUnofficialRunContext,
 } from '../support/mock-data';
 import { Precision, Sequence } from '@/lib/data-mappings';
+import { overlayRooflineDasharray, overlayRunColor } from '@/lib/overlay-run-style';
+import { computeToggle } from '@/lib/toggle-set';
+import { POWER_TIMELINE_METRIC_KEY } from '@/components/inference/utils/powerTimeline';
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
 
 const defaultChartDef = createMockChartDefinition();
 const hwConfig = createMockHardwareConfig();
 
+// GPUGraph reads the unofficial-run context; no run is loaded unless a test says so.
+const mountGpuGraph = (
+  tree: ReactElement,
+  overrides: Parameters<typeof mountWithProviders>[1] = {},
+) => mountWithProviders(tree, { unofficial: {}, ...overrides });
+
 describe('GPUGraph', () => {
   it('renders SVG within chart container', () => {
     const data = [
@@ -26,7 +41,7 @@ describe('GPUGraph', () => {
       }),
     ];
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu"
@@ -53,7 +68,7 @@ describe('GPUGraph', () => {
   });
 
   it('shows empty state when data is empty', () => {
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-empty"
@@ -80,7 +95,7 @@ describe('GPUGraph', () => {
   });
 
   it('explains missing role-local energy in GPU comparison mode', () => {
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-role-energy-empty"
@@ -110,7 +125,7 @@ describe('GPUGraph', () => {
   });
 
   it('localizes the Chinese comparison empty state', () => {
-    mountWithProviders(
+    mountGpuGraph(
       <PathnameContext.Provider value="/zh/inference">
         <div style={{ width: 390, height: 600 }}>
           <GPUGraph
@@ -166,7 +181,7 @@ describe('GPUGraph', () => {
       }),
     ];
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-data"
@@ -195,58 +210,6 @@ describe('GPUGraph', () => {
     cy.get('[data-testid="gpu-graph"] svg .visible-shape').should('have.length.greaterThan', 0);
   });
 
-  it('draws the historical-power ring and reports measured-point coverage', () => {
-    const data = [
-      createMockInferenceData({
-        hwKey: 'h100',
-        x: 32,
-        y: 2.1,
-        date: '2025-03-01',
-        precision: Precision.FP4,
-        power_tier: 'legacy',
-      }),
-      createMockInferenceData({
-        hwKey: 'h100',
-        x: 64,
-        y: 1.8,
-        date: '2025-03-01',
-        precision: Precision.FP4,
-        power_tier: 'certified',
-      }),
-    ];
-
-    mountWithProviders(
-      <div style={{ width: 800, height: 600 }}>
-        <GPUGraph
-          chartId="test-gpu-measured-power"
-          modelLabel="DeepSeek R1"
-          data={data}
-          xLabel="Interactivity (tok/s/user)"
-          yLabel="Measured Joules per Output Token (J/tok)"
-          chartDefinition={defaultChartDef}
-        />
-      </div>,
-      {
-        inference: {
-          hardwareConfig: hwConfig,
-          selectedGPUs: ['h100'],
-          selectedDates: ['2025-03-01'],
-          selectedDateRange: { startDate: '', endDate: '' },
-          activeDates: new Set(['2025-03-01_h100']),
-          selectedPrecisions: [Precision.FP4],
-          selectedYAxisMetric: 'y_measuredJPerOutputToken',
-          hideNonOptimal: false,
-        },
-      },
-    );
-
-    cy.get('#test-gpu-measured-power svg .legacy-power-ring').should('have.length', 1);
-    cy.get('[data-testid="measured-power-summary"]')
-      .should('contain.text', 'Showing 2 of 2 measured points')
-      .and('contain.text', '1/1 validated')
-      .and('contain.text', '1/1 historical');
-  });
-
   it('shows spec decoding only on hover while retaining the offload halo', () => {
     const data = [
       createMockInferenceData({
@@ -271,7 +234,7 @@ describe('GPUGraph', () => {
       }),
     ];
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-agentic-decorations"
@@ -362,7 +325,7 @@ describe('GPUGraph', () => {
       y_tpPerGpu_roofline: 'upper_left',
     });
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-line-labels"
@@ -420,7 +383,7 @@ describe('GPUGraph', () => {
       }),
     ];
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-no-line-labels"
@@ -461,7 +424,7 @@ describe('GPUGraph', () => {
       }),
     ];
 
-    mountWithProviders(
+    mountGpuGraph(
       <div style={{ width: 800, height: 600 }}>
         <GPUGraph
           chartId="test-gpu-legend"
@@ -557,15 +520,10 @@ describe('GPU comparison power envelopes', () => {
     );
   }
 
-  it('reveals off-boundary measurements and historical rings without changing power envelopes or axes', () => {
-    mountWithProviders(<PowerComparison />);
+  it('reveals off-boundary measurements without changing power envelopes or axes', () => {
+    mountGpuGraph(<PowerComparison />);
     cy.get('#gpu-show-all-measurements').should('not.exist');
     cy.get('#gpu-power-curves .dot-group').should('have.length', 6);
-    cy.get('#gpu-power-curves .legacy-power-ring').should('have.length', 2);
-    cy.get('[data-testid="measured-power-summary"]')
-      .should('contain.text', 'Showing 6 of 12 measured points')
-      .and('contain.text', '4/6 validated')
-      .and('contain.text', '2/6 historical');
     cy.get('#gpu-power-curves .roofline-path')
       .should('have.length', 2)
       .each(($path) => {
@@ -582,11 +540,6 @@ describe('GPU comparison power envelopes', () => {
       );
       cy.get('#gpu-hide-non-optimal').click({ force: true });
       cy.get('#gpu-power-curves .dot-group').should('have.length', 12);
-      cy.get('#gpu-power-curves .legacy-power-ring').should('have.length', 6);
-      cy.get('[data-testid="measured-power-summary"]').should(
-        'contain.text',
-        'Showing 12 of 12 measured points',
-      );
       cy.get('#gpu-hide-non-optimal').should('have.attr', 'data-state', 'unchecked');
       cy.get('#gpu-power-curves svg').should(($current) => {
         expect(
@@ -599,7 +552,6 @@ describe('GPU comparison power envelopes', () => {
       cy.get('#gpu-show-all-measurements').should('not.exist');
       cy.get('#gpu-hide-non-optimal').click({ force: true });
       cy.get('#gpu-power-curves .dot-group').should('have.length', 6);
-      cy.get('#gpu-power-curves .legacy-power-ring').should('have.length', 2);
     });
     cy.get('#gpu-power-curves .line-label').should('have.length', 2);
     cy.get('[data-testid="legend-advanced-toggle"]').click();
@@ -611,7 +563,7 @@ describe('GPU comparison power envelopes', () => {
   });
 
   it('measures power boundaries by comparison date and resets rulers when the metric changes', () => {
-    mountWithProviders(<PowerComparison />);
+    mountGpuGraph(<PowerComparison />);
     cy.get('[data-testid="legend-advanced-toggle"]').click();
     cy.get('#gpu-perf-ruler').click({ force: true });
     const chartId = 'gpu-power-curves';
@@ -648,18 +600,15 @@ describe('GPU comparison power envelopes', () => {
   });
 
   it('keeps boundary measurements by default toward lower latency', () => {
-    mountWithProviders(<PowerComparison latency />);
+    mountGpuGraph(<PowerComparison latency />);
     cy.get('#gpu-power-curves .dot-group').should('have.length', 6);
     cy.get('#gpu-power-curves .roofline-path')
       .should('have.length', 2)
       .each(($path) => expect($path.attr('d')).to.contain('C'));
-    cy.get('#gpu-power-curves [data-testid="power-curve-description"]')
-      .should('contain.text', 'upper power boundary')
-      .and('contain.text', 'not efficiency frontiers');
   });
 
   it('uses the same boundary toggle for percent TDP and fleet percentiles while preserving energy Pareto', () => {
-    mountWithProviders(
+    mountGpuGraph(
       <PathnameContext.Provider value="/zh/inference">
         <PowerComparison />
       </PathnameContext.Provider>,
@@ -669,7 +618,6 @@ describe('GPU comparison power envelopes', () => {
       cy.get('#gpu-hide-non-optimal').should('have.attr', 'data-state', 'checked');
       cy.get('#gpu-power-curves .dot-group').should('have.length', 6);
       cy.get('#gpu-power-curves .roofline-path').should('have.length', 2);
-      cy.get('[data-testid="power-curve-description"]').should('contain', '不代表能效 Pareto 前沿');
       cy.get('#gpu-show-all-measurements').should('not.exist');
       cy.get('#gpu-hide-non-optimal').click({ force: true });
       cy.get('#gpu-power-curves .dot-group').should('have.length', 12);
@@ -684,6 +632,211 @@ describe('GPU comparison power envelopes', () => {
     cy.get('#gpu-power-curves .roofline-path')
       .should('have.length', 2)
       .each(($path) => expect($path.attr('d')).to.contain('C'));
-    cy.get('[data-testid="power-curve-description"]').should('not.exist');
+  });
+});
+
+const runUrl = (id: number) => `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${id}`;
+
+describe('GPU comparison with unofficial runs and load sweeps', () => {
+  const OVERLAY_RUN_URL = runUrl(31415926535);
+  const DATES = ['2025-03-01', '2025-03-15'];
+  const ALL_SERIES = new Set(DATES.map((date) => `${date}_h100`));
+
+  const official = (date: string, conc: number, y: number, tp = 8) =>
+    createMockInferenceData({
+      hwKey: 'h100',
+      date,
+      conc,
+      tp,
+      x: conc,
+      y,
+      precision: Precision.FP4,
+      run_url: runUrl(DATES.indexOf(date) + 1000),
+    });
+  const overlay = (conc: number, y: number) =>
+    createMockInferenceData({
+      hwKey: 'b200',
+      date: '2025-03-20',
+      conc,
+      tp: 8,
+      x: conc,
+      y,
+      precision: Precision.FP4,
+      run_url: OVERLAY_RUN_URL,
+    });
+
+  function Comparison({
+    chartDefinition,
+    data,
+    overlayPoints,
+    unofficial,
+    context,
+  }: {
+    chartDefinition: ChartDefinition;
+    data: InferenceData[];
+    overlayPoints: InferenceData[];
+    unofficial: UnofficialRunContextType;
+    context?: Parameters<typeof createMockInferenceContextValues>[0];
+  }) {
+    const [activeDates, setActiveDates] = useState(new Set(ALL_SERIES));
+    const [overlayHw, setOverlayHw] = useState(new Set(['b200']));
+    const value = createMockInferenceContextValues({
+      hardwareConfig: hwConfig,
+      selectedGPUs: ['h100'],
+      selectedDates: DATES,
+      selectedDateRange: { startDate: '', endDate: '' },
+      activeDates,
+      toggleActiveDate: (id: string) =>
+        setActiveDates((prev) => computeToggle(prev, id, ALL_SERIES)),
+      selectedPrecisions: [Precision.FP4],
+      showLineLabels: true,
+      ...context,
+    });
+    return (
+      <UnofficialRunContext.Provider value={{ ...unofficial, activeOverlayHwTypes: overlayHw }}>
+        <InferenceContextsProvider data={value} filters={value} display={value} actions={value}>
+          <button onClick={() => setOverlayHw(new Set())}>Hide overlay hardware</button>
+          <div style={{ width: 1000, height: 600 }}>
+            <GPUGraph
+              chartId="gpu-overlay"
+              modelLabel="DeepSeek R1"
+              data={data}
+              xLabel="X"
+              yLabel="Throughput / Chip (tok/s)"
+              chartDefinition={chartDefinition}
+              overlayData={{
+                data: overlayPoints,
+                hardwareConfig: hwConfig,
+                label: 'feat/power-sweep',
+                runUrl: OVERLAY_RUN_URL,
+              }}
+            />
+          </div>
+        </InferenceContextsProvider>
+      </UnofficialRunContext.Provider>
+    );
+  }
+
+  const mountComparison = (
+    chartDefinition: ChartDefinition,
+    data: InferenceData[],
+    overlayPoints: InferenceData[],
+    context?: Parameters<typeof createMockInferenceContextValues>[0],
+  ) => {
+    const unofficial = createMockUnofficialRunContext({
+      isUnofficialRun: true,
+      unofficialRunInfos: [
+        {
+          id: 31415926535,
+          name: 'Run Sweep',
+          branch: 'feat/power-sweep',
+          sha: 'abc123',
+          createdAt: '2025-03-20T00:00:00Z',
+          url: OVERLAY_RUN_URL,
+          conclusion: 'success',
+          status: 'completed',
+          isNonMainBranch: true,
+        },
+      ],
+      runIndexByUrl: { [OVERLAY_RUN_URL]: 0 },
+    });
+    mountWithProviders(
+      <Comparison
+        chartDefinition={chartDefinition}
+        data={data}
+        overlayPoints={overlayPoints}
+        unofficial={unofficial}
+        context={context}
+      />,
+    );
+  };
+
+  it('keeps unofficial runs on the date comparison in the run color and dash', () => {
+    mountComparison(
+      createMockChartDefinition({ chartType: 'interactivity', y_tpPerGpu_roofline: 'upper_left' }),
+      DATES.flatMap((date, d) => [8, 16, 32].map((x, i) => official(date, x, 300 - i * 60 + d))),
+      [8, 16, 32].map((x, i) => overlay(x, 400 - i * 60)),
+    );
+
+    cy.get('#gpu-overlay .unofficial-overlay-pt').should('have.length', 3);
+    cy.get('#gpu-overlay .unofficial-overlay-pt .overlay-x').each(($marker) => {
+      expect($marker.attr('stroke')).to.equal(overlayRunColor(0));
+    });
+    cy.get('#gpu-overlay .roofline-overlay-run0_b200_fp4')
+      .should('have.attr', 'stroke', overlayRunColor(0))
+      .and('have.attr', 'stroke-dasharray', overlayRooflineDasharray(0));
+    cy.get('.sidebar-legend')
+      .should('contain.text', 'UNOFFICIAL: feat/power-sweep')
+      .and('contain.text', '✕ B200');
+    cy.get('#gpu-overlay .line-label').should('have.length', 3).and('contain.text', '✕ B200');
+
+    // A date toggle hides that official series; the unofficial run stays.
+    cy.get('.sidebar-legend label').contains('2025-03-15').click();
+    cy.get('#gpu-overlay .dot-group').should('have.length', 3);
+    cy.get('#gpu-overlay .unofficial-overlay-pt').should('have.length', 3);
+
+    cy.contains('button', 'Hide overlay hardware').click();
+    cy.get('#gpu-overlay .unofficial-overlay-pt').should('not.exist');
+    cy.get('#gpu-overlay .roofline-overlay-run0_b200_fp4').should('not.exist');
+    cy.get('.sidebar-legend').should('not.contain.text', 'UNOFFICIAL');
+  });
+
+  it('draws concurrency load sweeps per date, run and topology without frontier tools', () => {
+    mountComparison(
+      createMockChartDefinition({
+        chartType: 'interactivity',
+        x_scale_field: 'conc',
+        y_tpPerGpu_roofline: 'upper_left',
+      }),
+      [
+        // A load sweep is not a frontier: the dip at c16 stays on the line.
+        ...DATES.flatMap((date, d) => [
+          official(date, 8, 300 + d),
+          official(date, 16, 250 + d),
+          official(date, 32, 320 + d),
+        ]),
+        // Another topology on the later date is a separate sweep.
+        official(DATES[1], 8, 150, 4),
+        official(DATES[1], 16, 180, 4),
+      ],
+      [overlay(8, 400), overlay(16, 380), overlay(32, 450)],
+    );
+
+    cy.get('#gpu-overlay .roofline-path').should('have.length', 4);
+    cy.get('#gpu-overlay .roofline-path').each(($path) => {
+      expect($path.attr('d'), 'straight segments between observations').not.to.contain('C');
+    });
+    cy.get('#gpu-overlay .roofline-path[class*="2025-03-01_h100_fp4"]')
+      .invoke('attr', 'd')
+      .should('match', /^M[^L]+L[^L]+L[^L]+$/u);
+    cy.get('#gpu-overlay .roofline-path[class*="overlay-run0_b200_fp4"]').should(
+      'have.attr',
+      'stroke-dasharray',
+      overlayRooflineDasharray(0),
+    );
+    cy.get('#gpu-overlay .dot-group').should('have.length', 8);
+    cy.get('#gpu-hide-non-optimal').should('not.exist');
+    cy.get('[data-testid="legend-advanced-toggle"]').click();
+    cy.get('#gpu-perf-ruler').should('not.exist');
+  });
+
+  it('opens the power trace from an official point on the concurrency comparison', () => {
+    const setSelectedYAxisMetric = cy.stub().as('setMetric');
+    const audited = (date: string, conc: number, y: number): InferenceData => ({
+      ...official(date, conc, y),
+      power_audit: {
+        source: `power_validation_h100_conc${conc}.json`,
+      } as InferenceData['power_audit'],
+    });
+    mountComparison(
+      createMockChartDefinition({ chartType: 'interactivity', x_scale_field: 'conc' }),
+      DATES.flatMap((date, d) => [audited(date, 8, 300 + d), audited(date, 16, 320 + d)]),
+      [],
+      { selectedYAxisMetric: 'y_measuredAvgPower', setSelectedYAxisMetric },
+    );
+
+    cy.get('#gpu-overlay .dot-group .visible-shape').first().click({ force: true });
+    cy.get('[data-chart-tooltip]:visible [data-action="view-power-trace"]').click();
+    cy.get('@setMetric').should('have.been.calledWith', POWER_TIMELINE_METRIC_KEY);
   });
 });
diff --git a/packages/app/cypress/component/inference-chart-controls.cy.tsx b/packages/app/cypress/component/inference-chart-controls.cy.tsx
index 4445d303b..6407da9f7 100644
--- a/packages/app/cypress/component/inference-chart-controls.cy.tsx
+++ b/packages/app/cypress/component/inference-chart-controls.cy.tsx
@@ -863,7 +863,8 @@ describe('Inference axis selector — Chinese Agentic controls', () => {
     );
     cy.get('[data-testid="inference-secondary-controls"] > button').click();
     cy.get('[data-testid="x-axis-mode-selector"]').should('contain.text', '交互性').click();
-    cy.get('[role="grid"] [data-select-option]').should('have.length', 4);
+    cy.get('[role="grid"] [data-select-option]').should('have.length', 5);
+    cy.get('[data-testid="x-axis-mode-concurrency"]').should('have.text', '并发数');
     cy.get('[data-testid="x-axis-mode-e2e-normalized-interactivity"]').should(
       'have.text',
       '端到端归一化交互性',
diff --git a/packages/app/cypress/component/power-metric-availability.cy.tsx b/packages/app/cypress/component/power-metric-availability.cy.tsx
deleted file mode 100644
index 6a6c7b1a6..000000000
--- a/packages/app/cypress/component/power-metric-availability.cy.tsx
+++ /dev/null
@@ -1,88 +0,0 @@
-import { useState } from 'react';
-import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
-import {
-  PowerMetricAvailability,
-  PowerMetricAvailabilityPanel,
-} from '@/components/inference/ui/PowerMetricAvailability';
-import { createMockInferenceData } from '../support/mock-data';
-import { mountWithProviders } from '../support/test-utils';
-import { Precision, Model, Sequence } from '@/lib/data-mappings';
-
-const source = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/123/attempts/2';
-const base = { model: Model.Qwen3_5, precision: Precision.FP8, run_url: source };
-const missing = createMockInferenceData({ ...base, hwKey: 'gb200' });
-const invalid = createMockInferenceData({
-  ...base,
-  hwKey: 'mi355x',
-  power_valid: 0,
-  power_invalid_reasons: ['sampling_gap_exceeded'],
-});
-const measured = createMockInferenceData({
-  ...base,
-  hwKey: 'b200',
-  power_valid: 1,
-  power_metric_schema_version: 2,
-  measuredAvgPower: { y: 640, roof: false },
-});
-function Panel() {
-  const [metric, select] = useState('y_measuredAvgPower');
-  return (
-    <PowerMetricAvailabilityPanel
-      points={[missing, invalid, measured]}
-      metric={metric}
-      onSelect={select}
-    />
-  );
-}
-
-describe('PowerX metric availability', () => {
-  it('explains missing GB and withheld AMD data, exposes source links, and switches metrics', () => {
-    cy.mount(<Panel />);
-    cy.contains('1 of 3 points have this metric');
-    cy.contains('Validation failed: 1');
-    cy.contains('Metric not reported: 1');
-    cy.contains('summary', 'source details').click();
-    cy.contains('sampling_gap_exceeded');
-    cy.contains('a', 'Source run').should('have.attr', 'href', source);
-    cy.contains('summary', 'all measured metrics').click();
-    cy.contains('button', 'Measured Prefill Power per Chip').click();
-    cy.contains('No separate worker pools: 3');
-    cy.contains('0 of 3 points have this metric');
-  });
-  it('uses Chinese copy for the same coverage states', () => {
-    cy.mount(
-      <PathnameContext.Provider value="/zh/inference/qwen-3-5">
-        <Panel />
-      </PathnameContext.Provider>,
-    );
-    cy.contains('3 个数据点中有 1 个提供此指标');
-    cy.contains('验证失败: 1');
-    cy.contains('summary', '所有实测指标的可用性').click();
-    cy.contains('缺失值不会被替换为零或 TDP 估算值');
-  });
-  it('counts filtered unofficial rows before the metric filter and respects hidden overlay hardware', () => {
-    mountWithProviders(
-      <PowerMetricAvailability metric="y_measuredAvgPower" onSelect={cy.stub()} />,
-      {
-        inference: {
-          selectionPoints: [missing],
-          activeHwTypes: new Set(['gb200']),
-          selectedModel: Model.Qwen3_5,
-          selectedSequence: Sequence.EightK_OneK,
-          selectedPrecisions: [Precision.FP8],
-        },
-        unofficial: {
-          isUnofficialRun: true,
-          activeOverlayHwTypes: new Set(['b200']),
-          getOverlayData: () => ({ data: [measured, invalid], hardwareConfig: {} }),
-        },
-      },
-    );
-    cy.contains('1 of 2 points have this metric');
-    cy.contains('Metric not reported: 1');
-    cy.get('[data-testid="power-metric-availability"]').should(
-      'not.contain',
-      'Validation failed: 1',
-    );
-  });
-});
diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
new file mode 100644
index 000000000..e1ab4eb39
--- /dev/null
+++ b/packages/app/cypress/component/power-service-comparison.cy.tsx
@@ -0,0 +1,115 @@
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+
+import type { InferenceData } from '@/components/inference/types';
+import PowerServiceComparison from '@/components/inference/ui/PowerServiceComparison';
+
+import { createMockInferenceData } from '../support/mock-data';
+import { mountWithProviders } from '../support/test-utils';
+
+const metric = (y: number) => ({ y, roof: false });
+const point = (overrides: Partial<InferenceData> = {}) =>
+  createMockInferenceData({
+    hwKey: 'b200_sglang',
+    hw: 'B200',
+    framework: 'sglang',
+    precision: 'fp8',
+    physicalChips: 4,
+    tp: 4,
+    decode_tp: 4,
+    conc: 8,
+    date: '2026-09-23',
+    run_url: 'https://example.invalid/runs/900000001',
+    benchmark_type: 'single_turn',
+    mean_tpot_intvty: 20,
+    output_tput_per_gpu: 50,
+    measuredAvgPower: metric(400),
+    measuredJPerOutputToken: metric(10),
+    ...overrides,
+  });
+// The overlay run: two loads of a second source.
+const comparator = [
+  point({
+    id: 3,
+    hwKey: 'b300_sglang',
+    run_url: 'https://example.invalid/runs/900000002',
+    measuredAvgPower: metric(800),
+    output_tput_per_gpu: 100,
+    measuredJPerOutputToken: metric(8),
+  }),
+  point({
+    id: 4,
+    hwKey: 'b300_sglang',
+    run_url: 'https://example.invalid/runs/900000002',
+    mean_tpot_intvty: 60,
+    conc: 1,
+    measuredAvgPower: metric(1000),
+    output_tput_per_gpu: 200,
+    measuredJPerOutputToken: metric(16),
+  }),
+];
+const OVERLAY_RUN_URL = 'https://example.invalid/runs/900000002';
+// W/GPU = 250 + 0.5 × output tok/s/GPU on four loads of one source.
+const fitLadder = [20, 60, 120, 260].map((rate, index) =>
+  point({
+    id: 20 + index,
+    conc: 2 ** index,
+    mean_tpot_intvty: 100 - 20 * index,
+    output_tput_per_gpu: rate,
+    measuredAvgPower: metric(250 + 0.5 * rate),
+    measuredJPerOutputToken: metric((250 + 0.5 * rate) / rate),
+  }),
+);
+
+function mountComparison(points: InferenceData[], overlay: InferenceData[]) {
+  mountWithProviders(
+    <PathnameContext.Provider value="/inference">
+      <div style={{ width: '100%', maxWidth: 1120, padding: 12, boxSizing: 'border-box' }}>
+        <PowerServiceComparison
+          data={[...points, ...overlay]}
+          overlayData={overlay}
+          xField="mean_tpot_intvty"
+          xLabel="Mean interactivity (output tok/s/user)"
+          interactivityField="mean_tpot_intvty"
+          chartId="power-service-test"
+        />
+      </div>
+    </PathnameContext.Provider>,
+    {
+      inference: {},
+      unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } },
+    },
+  );
+}
+
+describe('PowerServiceComparison', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message.includes('ResizeObserver loop')) return false;
+    });
+  });
+
+  it('colours ?unofficialrun= sources with their run colour in every panel', () => {
+    mountComparison(fitLadder, comparator);
+    cy.get('[data-testid="power-fit-toggle"]').check();
+    cy.get(
+      '[data-testid="power-service-test-power-fit-plot"] circle.point[fill="var(--overlay-run-0)"]',
+    ).should('have.length', 2);
+    cy.get('[data-testid="power-service-test-power-fit-plot"] circle.point')
+      .not('[fill="var(--overlay-run-0)"]')
+      .should('have.length', 4);
+    cy.get('[data-testid="equal-service-toggle"]').check();
+    cy.get('[data-testid="equal-service-comparator"]')
+      .invoke('val')
+      .should('contain', OVERLAY_RUN_URL);
+    // The selects are screen-only; exported images name the pair instead.
+    for (const pair of ['equal-service-pair', 'matched-concurrency-pair']) {
+      cy.get(`[data-testid="${pair}"]`)
+        .should('not.be.visible')
+        .and(
+          'have.text',
+          'Baseline: B200 (SGLang) · 2026-09-23 → Comparator: B300 (SGLang) · 2026-09-23',
+        );
+    }
+    cy.get('[data-testid="matched-concurrency-row-8"]').should('exist');
+  });
+});
diff --git a/packages/app/cypress/component/power-timeline.cy.tsx b/packages/app/cypress/component/power-timeline.cy.tsx
index 7df453db1..224d618d6 100644
--- a/packages/app/cypress/component/power-timeline.cy.tsx
+++ b/packages/app/cypress/component/power-timeline.cy.tsx
@@ -2,13 +2,17 @@ import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.share
 import { useState } from 'react';
 
 import type { GpuPowerSeries, GpuPowerSeriesResponse } from '@/components/gpu-power/power-series';
+import { InferenceContextsProvider } from '@/components/inference/InferenceContext';
 import PowerTimeline from '@/components/inference/ui/PowerTimeline';
 import type { InferenceData } from '@/components/inference/types';
+import { traceKeyForPoint } from '@/components/inference/utils/powerTimeline';
 import { Model, Precision, Sequence } from '@/lib/data-mappings';
 import { overlayRunColor } from '@/lib/overlay-run-style';
+import { computeToggle } from '@/lib/toggle-set';
 
 import {
   createMockHardwareConfig,
+  createMockInferenceContextValues,
   createMockInferenceData,
   createMockUnofficialRunContext,
 } from '../support/mock-data';
@@ -91,6 +95,7 @@ const Y_LABEL = 'Measured Average Power per Chip over Time (W)';
 
 function providerOverrides(
   unofficial: Parameters<typeof createMockUnofficialRunContext>[0] = {},
+  activeHwTypes?: readonly string[],
 ): Parameters<typeof mountWithProviders>[1] {
   return {
     inference: {
@@ -98,7 +103,7 @@ function providerOverrides(
       selectedSequence: Sequence.EightK_OneK,
       selectedYAxisMetric: 'y_measuredPowerTimeline',
       hardwareConfig: hwConfig,
-      activeHwTypes: new Set(HW_TYPES),
+      activeHwTypes: new Set(activeHwTypes ?? HW_TYPES),
       hwTypesWithData: new Set(HW_TYPES),
     },
     unofficial,
@@ -110,6 +115,7 @@ function mountTimeline(
   options: {
     overlay?: Parameters<typeof PowerTimeline>[0]['overlayData'];
     unofficial?: Parameters<typeof createMockUnofficialRunContext>[0];
+    activeHwTypes?: readonly string[];
   } = {},
 ) {
   mountWithProviders(
@@ -123,7 +129,7 @@ function mountTimeline(
         />
       </div>
     </PathnameContext.Provider>,
-    providerOverrides(options.unofficial),
+    providerOverrides(options.unofficial, options.activeHwTypes),
   );
 }
 
@@ -148,6 +154,44 @@ function GrowingTimeline() {
   );
 }
 
+const overlayResponse = (traces: GpuPowerSeries[]): GpuPowerSeriesResponse => ({
+  runInfo: {
+    ...response.runInfo,
+    id: Number(OVERLAY_RUN_ID),
+    url: OVERLAY_RUN_URL,
+  },
+  series: traces,
+});
+
+const overlayData = (data: InferenceData[]) => ({
+  data,
+  hardwareConfig: hwConfig,
+  label: 'powerx-timeline',
+  runUrl: OVERLAY_RUN_URL,
+});
+
+/** Context overrides for one loaded `?unofficialrun=` whose overlay legend shows `hw`. */
+function overlayRun(hw: string): Parameters<typeof createMockUnofficialRunContext>[0] {
+  return {
+    isUnofficialRun: true,
+    unofficialRunInfos: [
+      {
+        id: Number(OVERLAY_RUN_ID),
+        name: 'powerx-timeline',
+        branch: 'powerx-timeline',
+        sha: 'abc000',
+        createdAt: '2026-09-12T00:00:00Z',
+        url: OVERLAY_RUN_URL,
+        conclusion: 'success',
+        status: 'completed',
+        isNonMainBranch: true,
+      },
+    ],
+    runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
+    activeOverlayHwTypes: new Set([hw]),
+  };
+}
+
 const svg = () => cy.get('[data-testid="power-timeline-chart-svg"]');
 
 describe('PowerTimeline', () => {
@@ -160,44 +204,16 @@ describe('PowerTimeline', () => {
   it('colours overlay-run traces by run and honours the overlay hardware filter', () => {
     const overlayPoint = measuredPoint('h200', 16, 500, {
       run_url: OVERLAY_RUN_URL,
-      power_audit: {
-        source: `power_validation_${resultName('h200', 16)}.json`,
-        ...WINDOW,
-      },
     });
-    const overlayResponse: GpuPowerSeriesResponse = {
-      runInfo: { ...response.runInfo, id: Number(OVERLAY_RUN_ID), url: OVERLAY_RUN_URL },
-      series: [series('h200', 16, 500)],
-    };
-    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('official');
+    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, {
+      body: response,
+    }).as('official');
     cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
-      body: overlayResponse,
+      body: overlayResponse([series('h200', 16, 500)]),
     }).as('overlay');
     mountTimeline([measuredPoint('b200', 16, 700)], {
-      overlay: {
-        data: [overlayPoint],
-        hardwareConfig: hwConfig,
-        label: 'powerx-timeline',
-        runUrl: OVERLAY_RUN_URL,
-      },
-      unofficial: createMockUnofficialRunContext({
-        isUnofficialRun: true,
-        unofficialRunInfos: [
-          {
-            id: Number(OVERLAY_RUN_ID),
-            name: 'powerx-timeline',
-            branch: 'powerx-timeline',
-            sha: 'abc000',
-            createdAt: '2026-09-12T00:00:00Z',
-            url: OVERLAY_RUN_URL,
-            conclusion: 'success',
-            status: 'completed',
-            isNonMainBranch: true,
-          },
-        ],
-        runIndexByUrl: { [OVERLAY_RUN_URL]: 0, [OVERLAY_RUN_ID]: 0 },
-        activeOverlayHwTypes: new Set(['h200']),
-      }),
+      overlay: overlayData([overlayPoint]),
+      unofficial: createMockUnofficialRunContext(overlayRun('h200')),
     });
     cy.wait(['@official', '@overlay']);
 
@@ -216,10 +232,16 @@ describe('PowerTimeline', () => {
 
   it('joins a run that arrives after mount without a hook-shape warning', () => {
     const secondResponse: GpuPowerSeriesResponse = {
-      runInfo: { ...response.runInfo, id: Number(SECOND_RUN_ID), url: SECOND_RUN_URL },
+      runInfo: {
+        ...response.runInfo,
+        id: Number(SECOND_RUN_ID),
+        url: SECOND_RUN_URL,
+      },
       series: [series('h100', 16, 500)],
     };
-    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, { body: response }).as('first');
+    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, {
+      body: response,
+    }).as('first');
     cy.intercept('POST', `/api/gpu-metrics?runId=${SECOND_RUN_ID}*`, {
       body: secondResponse,
     }).as('second');
@@ -241,4 +263,120 @@ describe('PowerTimeline', () => {
       expect(shapeWarnings, JSON.stringify(shapeWarnings)).to.have.length(0);
     });
   });
+
+  it('marks overlay traces in the same-load summary with their run colour', () => {
+    const overlayPoint = measuredPoint('h200', 16, 500, {
+      run_url: OVERLAY_RUN_URL,
+    });
+    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, {
+      body: response,
+    }).as('official');
+    cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+      body: overlayResponse([series('h200', 16, 500)]),
+    }).as('overlay');
+    mountTimeline([measuredPoint('b200', 16, 700)], {
+      overlay: overlayData([overlayPoint]),
+      unofficial: createMockUnofficialRunContext(overlayRun('h200')),
+    });
+    cy.wait(['@official', '@overlay']);
+    cy.get(
+      `[data-testid="power-timeline-summary-trace"][data-trace="${traceKeyForPoint(overlayPoint)}"]`,
+    )
+      .should('contain.text', 'unofficial')
+      .find('th > span')
+      .first()
+      .should('have.attr', 'style')
+      .and('contain', overlayRunColor(0));
+  });
+
+  it('follows the date comparison series: colours, legend toggles and labels', () => {
+    const EARLIER_RUN_ID = '34600000001';
+    const EARLIER_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${EARLIER_RUN_ID}`;
+    const DATES = ['2026-09-11', '2026-09-12'];
+    const ALL_SERIES = new Set(DATES.map((date) => `${date}_b200`));
+    cy.intercept('POST', `/api/gpu-metrics?runId=${EARLIER_RUN_ID}*`, {
+      body: {
+        runInfo: {
+          ...response.runInfo,
+          id: Number(EARLIER_RUN_ID),
+          url: EARLIER_RUN_URL,
+        },
+        series: [series('b200', 16, 600)],
+      },
+    }).as('earlier');
+    cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, {
+      body: response,
+    }).as('later');
+
+    function DateComparison() {
+      const [activeDates, setActiveDates] = useState(new Set(ALL_SERIES));
+      const value = createMockInferenceContextValues({
+        selectedModel: Model.DeepSeek_V4_Pro,
+        selectedSequence: Sequence.EightK_OneK,
+        selectedYAxisMetric: 'y_measuredPowerTimeline',
+        hardwareConfig: hwConfig,
+        activeHwTypes: new Set(HW_TYPES),
+        hwTypesWithData: new Set(HW_TYPES),
+        selectedGPUs: ['b200'],
+        selectedDates: DATES,
+        selectedDateRange: { startDate: '', endDate: '' },
+        activeDates,
+        toggleActiveDate: (id: string) =>
+          setActiveDates((prev) => computeToggle(prev, id, ALL_SERIES)),
+      });
+      return (
+        <InferenceContextsProvider data={value} filters={value} display={value} actions={value}>
+          <div style={{ width: 1100, height: 700 }}>
+            <PowerTimeline
+              chartId="power-timeline-test"
+              comparison
+              data={[
+                measuredPoint('b200', 16, 600, {
+                  date: DATES[0],
+                  run_url: EARLIER_RUN_URL,
+                }),
+                measuredPoint('b200', 16, 700, { date: DATES[1] }),
+              ]}
+              yLabel="Measured Average Power per Chip over Time (W)"
+            />
+          </div>
+        </InferenceContextsProvider>
+      );
+    }
+    mountWithProviders(
+      <PathnameContext.Provider value="/inference">
+        <DateComparison />
+      </PathnameContext.Provider>,
+      { unofficial: {} },
+    );
+    cy.wait(['@earlier', '@later']);
+
+    // One legend row per compared date, under the hardware, as in GPUGraph.
+    cy.get('[data-testid="chart-legend"] .gpu-legend-title').should('have.text', 'B200');
+    cy.get('[data-testid="chart-legend"] label').then(($labels) => {
+      const rows = $labels.toArray().map((label) => label.textContent?.trim());
+      expect(rows).to.include.members(DATES);
+    });
+    svg().within(() => {
+      cy.get('path.power-trace[data-segment="window"]').then(($paths) => {
+        expect($paths).to.have.length(2);
+        const strokes = new Set($paths.toArray().map((path) => path.getAttribute('stroke')));
+        expect(strokes.size, 'each date has its own colour').to.equal(2);
+      });
+      cy.get('text.power-trace-label').then(($labels) => {
+        expect($labels.toArray().map((label) => label.textContent)).to.have.members(
+          DATES.map((date) => `${date} c16`),
+        );
+      });
+    });
+
+    // Soloing the later date removes the earlier date's trace.
+    cy.get('[data-testid="chart-legend"] label').contains(DATES[1]).click();
+    svg().within(() => {
+      cy.get('path.power-trace[data-segment="window"]')
+        .should('have.length', 1)
+        .and('have.attr', 'data-trace-key', `${RUN_ID}:${resultName('b200', 16)}`);
+      cy.get('text.power-trace-label').should('have.length', 1).and('have.text', 'c16');
+    });
+  });
 });
diff --git a/packages/app/cypress/component/scatter-graph.cy.tsx b/packages/app/cypress/component/scatter-graph.cy.tsx
index fac02fad5..3a06cb262 100644
--- a/packages/app/cypress/component/scatter-graph.cy.tsx
+++ b/packages/app/cypress/component/scatter-graph.cy.tsx
@@ -2880,13 +2880,6 @@ describe('Power envelopes', () => {
       .should('have.length', 3)
       .each(($point) => cy.wrap($point).should('have.css', 'opacity', '1'));
     cy.get('#scatter-show-all-measurements').should('not.exist');
-    cy.get('[data-testid="measured-power-summary"]')
-      .should('contain.text', 'Showing 3 of 4 measured points')
-      .and('contain.text', '1/2 historical');
-    cy.get('#power-sweep .dot-group')
-      .filter((_, element) => element.style.opacity !== '0')
-      .find('.legacy-power-ring')
-      .should('have.length', 1);
     cy.get('#power-sweep .dot-group')
       .filter((_, element) => element.style.opacity === '0')
       .should('have.css', 'pointer-events', 'none');
@@ -2898,11 +2891,6 @@ describe('Power envelopes', () => {
           .should('have.length', 4)
           .each(($point) => cy.wrap($point).should('have.css', 'opacity', '1'));
         cy.get('#power-sweep .roofline-path').should('have.attr', 'd', boundary);
-        cy.get('[data-testid="measured-power-summary"]').should(
-          'contain.text',
-          'Showing 4 of 4 measured points',
-        );
-        cy.get('#power-sweep .legacy-power-ring').should('have.length', 2);
         cy.get('#scatter-show-all-measurements').should('not.exist');
         cy.get('#scatter-hide-non-optimal').click({ force: true });
         cy.get('#power-sweep .dot-group')
@@ -2925,7 +2913,6 @@ describe('Power envelopes', () => {
     cy.contains('button', 'Energy').click();
     cy.get('#scatter-hide-non-optimal').should('have.attr', 'data-state', 'checked');
     cy.get('#power-sweep .roofline-path[data-curve-kind="pareto"]').should('have.length', 1);
-    cy.get('[data-testid="power-curve-description"]').should('not.exist');
     cy.get('#scatter-show-all-measurements').should('not.exist');
   });
 
diff --git a/packages/app/cypress/e2e/certified-power-filter.cy.ts b/packages/app/cypress/e2e/certified-power-filter.cy.ts
index 30098dbff..d5cd54b52 100644
--- a/packages/app/cypress/e2e/certified-power-filter.cy.ts
+++ b/packages/app/cypress/e2e/certified-power-filter.cy.ts
@@ -114,12 +114,9 @@ describe('Validated vs historical measured power', () => {
     });
   });
 
-  it('rings legacy points on a measured axis and filters them via Quick Filters', () => {
+  it('filters validated and historical measured points via Quick Filters', () => {
     visitCertifiedPowerChart();
 
-    cy.get('.legacy-power-ring').should('not.exist');
-    cy.get('[data-testid="legacy-power-key"]').should('not.exist');
-
     cy.get('[data-testid="yaxis-metric-selector"]').click('right');
     cy.contains('[data-slot="select-item"]', 'Measured Power')
       .scrollIntoView()
@@ -127,16 +124,8 @@ describe('Validated vs historical measured power', () => {
       .click();
     cy.get('[data-slot="select-content"]').should('not.exist');
 
-    cy.get('[data-testid="measured-power-summary"]')
-      .should('contain.text', 'Showing 2 of 6 measured points')
-      .and('contain.text', '1/3 validated')
-      .and('contain.text', '1/3 historical')
-      .and('contain.text', 'Best per SKU and Optimal Only are enabled');
-
-    cy.get('.dot-group[data-hw-key^="b200"] .legacy-power-ring').should('exist');
-    cy.get('.dot-group[data-hw-key^="mi300x"] .legacy-power-ring').should('not.exist');
-    cy.get('[data-testid="legacy-power-key"]').should('be.visible');
-    cy.screenshot('legacy-power-rings', { capture: 'viewport' });
+    cy.get('.dot-group[data-hw-key^="b200"]').should('exist');
+    cy.get('.dot-group[data-hw-key^="mi300x"]').should('exist');
 
     cy.get('[data-testid="scatter-quick-filters"]').click();
     cy.get('[data-testid="quick-filters-dialog"]').should('be.visible');
@@ -152,8 +141,6 @@ describe('Validated vs historical measured power', () => {
     cy.get('[data-testid="quick-filters-selected-count"]').should('contain.text', '1 selected');
     cy.get('.dot-group[data-hw-key^="b200"]').should('not.exist');
     cy.get('.dot-group[data-hw-key^="mi300x"]').should('exist');
-    cy.get('.legacy-power-ring').should('not.exist');
-    cy.get('[data-testid="legacy-power-key"]').should('not.exist');
     cy.get('[data-testid="inference-chart-display"] svg').should('exist');
     cy.screenshot('certified-only-filter', { capture: 'viewport' });
 
@@ -165,8 +152,7 @@ describe('Validated vs historical measured power', () => {
       'false',
     );
     cy.get('[data-testid="quick-filters-dialog"]').contains('button', 'Done').click();
-    cy.get('.dot-group[data-hw-key^="b200"] .legacy-power-ring').should('exist');
-    cy.get('[data-testid="legacy-power-key"]').should('be.visible');
+    cy.get('.dot-group[data-hw-key^="b200"]').should('exist');
   });
 
   it('restores a shared i_power=certified link with the toggle pre-selected', () => {
@@ -177,7 +163,6 @@ describe('Validated vs historical measured power', () => {
 
     cy.get('.dot-group[data-hw-key^="mi300x"]').should('exist');
     cy.get('.dot-group[data-hw-key^="b200"]').should('not.exist');
-    cy.get('[data-testid="legacy-power-key"]').should('not.exist');
 
     cy.get('[data-testid="scatter-quick-filters"]').click();
     cy.get('[data-testid="quick-filter-power-certified"]').should(
@@ -202,10 +187,6 @@ describe('Validated vs historical measured power', () => {
     cy.get('#scatter-hide-non-optimal').should('have.attr', 'data-state', 'checked');
     cy.get('#scatter-show-all-measurements').should('not.exist');
     visiblePowerPoints().should('have.length', 4);
-    cy.get('[data-testid="measured-power-summary"]').should(
-      'contain.text',
-      'Showing 4 of 6 measured points',
-    );
 
     // Let the initial ResizeObserver update reach the SVG before saving geometry.
     cy.get<SVGSVGElement>('[data-testid="d3-chart-svg"]').should(($svg) => {
@@ -239,7 +220,6 @@ describe('Validated vs historical measured power', () => {
 
         cy.get('#scatter-hide-non-optimal').click();
         visiblePowerPoints().should('have.length', 4);
-        visiblePowerPoints().find('.legacy-power-ring').should('have.length', 2);
         cy.get<SVGPathElement>('.roofline-path').should(($current) => {
           expect(Array.from($current, (curve) => curve.getAttribute('d'))).to.deep.equal(geometry);
         });
diff --git a/packages/app/cypress/e2e/inference-chart.cy.ts b/packages/app/cypress/e2e/inference-chart.cy.ts
index bd8946401..3f00279c4 100644
--- a/packages/app/cypress/e2e/inference-chart.cy.ts
+++ b/packages/app/cypress/e2e/inference-chart.cy.ts
@@ -1,3 +1,4 @@
+import type { InferenceData } from '@/components/inference/types';
 import {
   interceptVrPublicationData,
   VR_FIXTURE_DATE,
@@ -54,8 +55,8 @@ const boundaryRows = (runUrl: string | null) =>
   }));
 
 function interceptMeasuredComparison(
-  official = measuredRows(null),
-  overlay = measuredRows(OVERLAY_RUN_URL),
+  official: object[] = measuredRows(null),
+  overlay: object[] = measuredRows(OVERLAY_RUN_URL),
 ) {
   cy.intercept('GET', '/api/v1/availability', { body: official.slice(0, 1) });
   cy.intercept('GET', '/api/v1/benchmarks*', { body: official });
@@ -107,11 +108,14 @@ function assertVisibleMeasuredValues(selector: string, expected: number[]) {
 
 describe('Inference Chart', () => {
   before(() => {
+    cy.intercept('GET', '/api/v1/availability').as('chartAvailability');
+    cy.intercept('GET', '/api/v1/benchmarks*').as('chartBenchmarks');
     cy.viewport(1440, 900);
     cy.window().then((win) => {
       win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
     });
     cy.visit('/inference');
+    cy.wait(['@chartAvailability', '@chartBenchmarks']);
   });
 
   it('renders the inference chart display wrapper', () => {
@@ -580,7 +584,9 @@ describe('AgentX replaces a complete curve while preserving an unofficial compar
   });
 });
 
-it('hydrates a direct PowerX metric link and shows availability for the selected workload', () => {
+it('hydrates a direct PowerX metric link', () => {
+  cy.intercept('GET', '/api/v1/availability').as('powerLinkAvailability');
+  cy.intercept('GET', '/api/v1/benchmarks*').as('powerLinkBenchmarks');
   cy.viewport(1440, 900);
   cy.visit('/inference/qwen-3-5?i_seq=8k%2F1k&i_prec=fp8&i_metric=y_measuredPowerPercentTdp', {
     onBeforeLoad(win) {
@@ -589,6 +595,7 @@ it('hydrates a direct PowerX metric link and shows availability for the selected
       cy.spy(win.console, 'error').as('powerLinkConsoleErrors');
     },
   });
+  cy.wait(['@powerLinkAvailability', '@powerLinkBenchmarks']);
   cy.get('[data-testid="yaxis-metric-selector"]').should('contain', 'Measured Power');
   cy.get('[data-testid="measured-power-display"]').should('contain', 'TDP');
   cy.get('[data-testid="measured-power-statistic-average"]').should(
@@ -596,17 +603,6 @@ it('hydrates a direct PowerX metric link and shows availability for the selected
     'aria-pressed',
     'true',
   );
-  cy.get('[data-testid="power-metric-availability"]').should(
-    'contain',
-    'Current workload and hardware selection',
-  );
-  cy.contains('summary', 'Availability of all measured metrics').click();
-  cy.get('[data-testid="power-metric-availability"]').within(() => {
-    cy.contains('button', 'Measured P75 Fleet Power per Chip').should('contain', '/');
-    cy.contains('button', 'Measured Joules per Output Token').click();
-  });
-  cy.get('[data-testid="yaxis-metric-selector"]').should('contain', 'Measured Energy');
-  cy.get('[data-testid="measured-energy-denominator"]').should('contain', 'Output');
   cy.get('@powerLinkConsoleErrors').should('not.be.calledWithMatch', /hydrat/i);
 });
 
@@ -637,6 +633,29 @@ it('replots measured settings for official and unofficial data and preserves ove
   assertMeasuredValues('.dot-group', [2, 3, 4, 5]);
 });
 
+it('says when chosen chip configs report no measured power, and plots them on other metrics', () => {
+  // The config has benchmarks but no power telemetry, like GB200/GB300 NVL72 on DSR1 8K/1K.
+  interceptMeasuredComparison(singleTurnRows(null), []);
+  cy.viewport(1440, 900);
+  cy.visit(
+    '/inference?g_model=DeepSeek-V4-Pro&i_seq=1k%2F1k&i_prec=fp4&i_metric=y_measuredAvgPower&i_gpus=b300_sglang',
+    { onBeforeLoad: unlockAgenticGate },
+  );
+  cy.get('[data-testid="gpu-multiselect"]').should('contain', 'B300 (SGLang)');
+  cy.get('[data-testid="scatter-empty-state"]')
+    .should('have.attr', 'data-reason', 'selection')
+    .and('contain', 'No measured GPU power is reported for this selection.');
+  cy.get('[data-testid="yaxis-metric-selector"]').click('right');
+  cy.contains('[data-slot="select-item"]', /^Token Throughput per Chip/u)
+    .scrollIntoView()
+    .click();
+  cy.get('[data-testid="scatter-empty-state"]').should('not.exist');
+  cy.get('[data-testid="inference-chart-display"] svg .dot-group').should(
+    'have.length.at.least',
+    1,
+  );
+});
+
 it('uses Optimal Only to filter power boundary dots without replacing official or overlay curves', () => {
   interceptMeasuredComparison(boundaryRows(null), boundaryRows(OVERLAY_RUN_URL));
   cy.viewport(1440, 900);
@@ -693,7 +712,6 @@ it('uses Optimal Only to filter power boundary dots without replacing official o
   cy.get('[data-testid="chart-figure"] h2').should('contain', 'Measured Joules per Output Token');
   cy.get('#scatter-hide-non-optimal').should('have.attr', 'data-state', 'checked');
   cy.get('#scatter-show-all-measurements').should('not.exist');
-  cy.get('[data-testid="power-curve-description"]').should('not.exist');
   assertVisibleMeasuredValues('.dot-group', [2, 4, 5]);
   assertVisibleMeasuredValues('.unofficial-overlay-pt', [3, 5, 6]);
   cy.get(curves)
@@ -826,3 +844,75 @@ describe('VR default date preference', () => {
     assertVrDate(VR_LATEST_FIXTURE_DATE);
   });
 });
+
+const withTp4 = (rows: ReturnType<typeof boundaryRows>) => [
+  ...rows,
+  ...rows.map((row) => ({
+    ...row,
+    id: row.id + 10000,
+    prefill_tp: 4,
+    decode_tp: 4,
+    num_prefill_gpu: 4,
+    num_decode_gpu: 4,
+  })),
+];
+
+const assertObservedLoads = (expected: number[]) => {
+  for (const selector of ['.dot-group', '.unofficial-overlay-pt']) {
+    cy.get<SVGElement & { __data__: InferenceData }>(
+      `[data-testid="inference-chart-display"] svg ${selector}`,
+    ).should(($points) => {
+      expect($points).to.have.length(expected.length);
+      expect([...$points].map((element) => element.__data__.x).sort((a, b) => a - b)).to.deep.equal(
+        expected,
+      );
+      for (const element of $points) expect(getComputedStyle(element).opacity).to.equal('1');
+    });
+  }
+};
+
+describe('Date comparison with unofficial runs', () => {
+  for (const [axis, xMode] of [
+    ['interactivity', ''],
+    ['concurrency', '&i_xmode=concurrency'],
+  ]) {
+    // Every measurement is shown (i_optimal=0), so both runs plot all four loads.
+    it(`keeps ?unofficialrun= overlays on the ${axis} date comparison`, () => {
+      interceptMeasuredComparison();
+      cy.viewport(1440, 900);
+      cy.visit(
+        `/inference?g_model=DeepSeek-V4-Pro&unofficialrun=${OVERLAY_RUN_ID}&i_seq=1k%2F1k&i_prec=fp4&i_metric=y_measuredAvgPower&i_gpus=b300_sglang&i_dstart=${SINGLE_TURN_DATE}&i_dend=${SINGLE_TURN_DATE}&i_optimal=0${xMode}`,
+        { onBeforeLoad: unlockAgenticGate },
+      );
+      cy.wait('@measuredOverlay');
+      cy.get('[data-testid="gpu-graph"]').should('exist');
+      cy.get('[data-testid="scatter-graph"]').should('not.exist');
+      assertMeasuredValues('.dot-group', [450, 460, 470, 480]);
+      assertMeasuredValues('.unofficial-overlay-pt', [450, 460, 470, 480]);
+      cy.get('[aria-label="Dismiss measured-comparison"]').click();
+      cy.get('[data-testid="gpu-graph"] .unofficial-overlay-pt').should('not.exist');
+      assertMeasuredValues('.dot-group', [450, 460, 470, 480]);
+    });
+  }
+});
+
+describe('Observed concurrency and exact topology', () => {
+  it('applies the exact-topology filter to official and ?unofficialrun= overlay loads', () => {
+    const officialRun = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/800001';
+    const officialBase = boundaryRows(null).map((row) => ({ ...row, run_url: officialRun }));
+    const overlayBase = boundaryRows(OVERLAY_RUN_URL);
+    interceptMeasuredComparison(withTp4(officialBase), withTp4(overlayBase));
+    cy.viewport(1440, 900);
+    cy.visit(
+      `/inference?g_model=DeepSeek-V4-Pro&unofficialrun=${OVERLAY_RUN_ID}&i_seq=1k%2F1k&i_prec=fp4&i_metric=y_measuredAvgPower&i_xmode=concurrency&i_optimal=1&i_best=1`,
+      { onBeforeLoad: unlockAgenticGate },
+    );
+    cy.wait('@measuredOverlay');
+    assertObservedLoads([1, 1, 2, 2, 8, 8, 48, 48]);
+    cy.get('[data-testid="scatter-quick-filters"]').click();
+    cy.contains('[data-testid="quick-filter-topology-options"] button', /GPU=?4.*TP=?4/u).click();
+    cy.get('body').type('{esc}');
+    cy.get('[data-testid="quick-filters-dialog"]').should('not.exist');
+    assertObservedLoads([1, 2, 8, 48]);
+  });
+});
diff --git a/packages/app/cypress/e2e/powerx-compare.cy.ts b/packages/app/cypress/e2e/powerx-compare.cy.ts
new file mode 100644
index 000000000..921bbab3c
--- /dev/null
+++ b/packages/app/cypress/e2e/powerx-compare.cy.ts
@@ -0,0 +1,213 @@
+import { assertShareLinkParams } from '../support/share-link';
+
+// The PowerX article panels inside the gated Measured Energy group.
+// Deterministic disaggregated rows carry validated whole-deployment and
+// per-role telemetry; the overlay run adds H200 rows.
+
+const MODEL = 'dsv4';
+const DATE = '2026-09-01';
+const OVERLAY_RUN_ID = '31415926535';
+const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
+
+/**
+ * conc, interactivity (tok/s/user), output tok/s per GPU, measured W per GPU,
+ * prefill W per GPU, decode W per GPU, J per output token, decode J per output token.
+ * Input tokens outnumber output tokens 8:1, so J/in = J/out ÷ 8 and the prefill
+ * pool's J/in reconstructs to J/out − decode J/out on the output-token axis.
+ */
+const CONFIGS: [number, number, number, number, number, number, number, number][] = [
+  [16, 90, 200, 500, 800, 400, 2.4, 1.6],
+  [64, 60, 400, 600, 820, 450, 1.6, 1],
+  [256, 30, 800, 700, 840, 500, 1, 0.6],
+];
+const TOKEN_RATIO = 8;
+
+let rowId = 990000;
+const rows = (runUrl: string | null, hardware: 'b200' | 'h200') =>
+  CONFIGS.map(([conc, intvty, outputTput, watts, prefillWatts, decodeWatts, jOut, decodeJOut]) => ({
+    id: runUrl ? 0 : rowId++,
+    hardware,
+    framework: 'dynamo-sglang',
+    model: MODEL,
+    precision: 'fp4',
+    spec_method: 'none',
+    disagg: true,
+    is_multinode: true,
+    prefill_tp: 4,
+    decode_tp: 4,
+    num_prefill_gpu: 4,
+    num_decode_gpu: 4,
+    isl: 8192,
+    osl: 1024,
+    conc,
+    offload_mode: 'off',
+    benchmark_type: 'single_turn',
+    image: 'dynamo:test',
+    metrics: {
+      median_intvty: intvty,
+      median_itl: 1 / intvty,
+      median_e2el: 20,
+      median_ttft: 0.5,
+      tput_per_gpu: outputTput * 9,
+      output_tput_per_gpu: outputTput,
+      input_tput_per_gpu: outputTput * 8,
+      power_valid: 1,
+      power_metric_schema_version: 2,
+      avg_power_w: watts,
+      avg_total_gpu_power_w: watts * 8,
+      prefill_avg_power_w: prefillWatts,
+      decode_avg_power_w: decodeWatts,
+      joules_per_output_token: jOut,
+      joules_per_input_token: jOut / TOKEN_RATIO,
+      prefill_joules_per_input_token: (jOut - decodeJOut) / TOKEN_RATIO,
+      decode_joules_per_output_token: decodeJOut,
+    },
+    workers: null,
+    date: DATE,
+    run_url: runUrl,
+  }));
+
+const availability = [
+  {
+    model: MODEL,
+    isl: 8192,
+    osl: 1024,
+    precision: 'fp4',
+    hardware: 'b200',
+    framework: 'dynamo-sglang',
+    spec_method: 'none',
+    disagg: true,
+    benchmark_type: 'single_turn',
+    date: DATE,
+  },
+];
+
+/** Official rows; their run URL makes them one source, as ingested runs do. */
+function interceptRows(officialRunUrl: string) {
+  const official = rows(null, 'b200').map((row) => ({ ...row, run_url: officialRunUrl }));
+  cy.intercept('GET', '/api/v1/availability', { body: availability }).as('availability');
+  cy.intercept('GET', '/api/v1/benchmarks*', { body: official }).as('benchmarks');
+  cy.intercept('GET', '/api/v1/workflow-info*', {
+    body: { runs: [], changelogs: [], configs: [] },
+  });
+}
+
+/** Overlay rows 10% cheaper per token than the official rows, so they own the frontier. */
+function interceptCheaperOverlayRows() {
+  const cheaper = rows(OVERLAY_RUN_URL, 'h200').map((row) => ({
+    ...row,
+    metrics: {
+      ...row.metrics,
+      joules_per_output_token: row.metrics.joules_per_output_token * 0.9,
+      joules_per_input_token: row.metrics.joules_per_input_token * 0.9,
+    },
+  }));
+  cy.intercept('GET', '/api/unofficial-run*', {
+    body: {
+      runInfos: [
+        {
+          id: OVERLAY_RUN_ID,
+          name: 'powerx-panels',
+          branch: 'powerx-panels',
+          sha: 'abc000',
+          createdAt: `${DATE}T00:00:00Z`,
+          url: OVERLAY_RUN_URL,
+          conclusion: 'success',
+          status: 'completed',
+          isNonMainBranch: true,
+        },
+      ],
+      benchmarks: cheaper,
+      evaluations: [],
+    },
+  }).as('unofficialRun');
+}
+
+function visitChart(extraParams: string, officialRunUrl: string) {
+  interceptRows(officialRunUrl);
+  cy.visit(`/inference?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4${extraParams}`, {
+    onBeforeLoad(win) {
+      win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
+      win.localStorage.setItem('inferencex-feature-gate', '1');
+    },
+  });
+  cy.wait(['@availability', '@benchmarks']);
+  cy.get('[data-testid="inference-chart-display"]').should('exist');
+  cy.get('[data-testid="chart-figure"]').should('have.length.at.least', 1);
+}
+
+// The article panels under a measured chart: load-matched rows, the role group,
+// the power-vs-output fit and the frontier's provenance, each for official rows
+// and a `?unofficialrun=` overlay together.
+describe('PowerX article panels', () => {
+  const PANELS = '&i_servicecompare=1&i_roleshare=1&i_powerfit=1&i_frontier=1';
+  const OFFICIAL_RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27182818284';
+  const OVERLAY_COLOR = 'var(--overlay-run-0)';
+
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message === 'ResizeObserver loop completed with undelivered notifications.') {
+        return false;
+      }
+    });
+  });
+
+  it('reproduces matched-load, role, fit and frontier panels for official and overlay rows', () => {
+    interceptCheaperOverlayRows();
+    visitChart(
+      `&unofficialrun=${OVERLAY_RUN_ID}&i_metric=y_measuredJPerOutputToken${PANELS}`,
+      OFFICIAL_RUN_URL,
+    );
+    cy.wait('@unofficialRun');
+
+    // Official B200 against the overlay H200 at each observed concurrency.
+    for (const [conc] of CONFIGS) {
+      cy.get(`[data-testid="matched-concurrency-row-${conc}"]`).should(($row) => {
+        const text = $row.text().replaceAll('−', '-');
+        expect(text).to.include('-10.0%').and.include('W/GPU +0.0%');
+      });
+    }
+
+    // Role power: prefill and decode W/GPU for both sources; the overlay in its run colour.
+    cy.get('[data-testid="chart-0-role-power-plot"] circle.point').should(
+      'have.length',
+      CONFIGS.length * 4,
+    );
+    cy.get(`[data-testid="chart-0-role-power-plot"] circle.point[fill="${OVERLAY_COLOR}"]`).should(
+      'have.length',
+      CONFIGS.length * 2,
+    );
+    cy.get('[data-testid="chart-0-role-share-plot"] circle.point').should(
+      'have.length',
+      CONFIGS.length * 2,
+    );
+
+    // Output per allocated GPU is output per decode GPU × 4 ÷ 8: 100, 200 and 400 tok/s.
+    // W/GPU 500, 600, 700 → P0 450 W, m 0.643 J/token, R² 0.964.
+    cy.get('[data-testid="power-fit-row"]').should('have.length', 2);
+    cy.get('[data-testid="power-fit-row"]')
+      .filter(':contains("B200")')
+      .should('contain.text', '450')
+      .and('contain.text', '45% · 1,000 W')
+      .and('contain.text', '0.643')
+      .and('contain.text', '0.964')
+      .and('contain.text', '100.0–400.0');
+    cy.get('[data-testid="power-fit-row"]')
+      .filter(':contains("H200")')
+      .should('contain.text', '64% · 700 W');
+
+    // The cheaper overlay rows own the frontier; each lists its run.
+    cy.get('[data-testid="frontier-points-row"]')
+      .should('have.length', CONFIGS.length)
+      .each(($row) => {
+        expect($row.text()).to.include('unofficial');
+        expect($row.find('a').attr('href')).to.eq(OVERLAY_RUN_URL);
+      });
+    assertShareLinkParams({
+      i_servicecompare: '1',
+      i_roleshare: '1',
+      i_powerfit: '1',
+      i_frontier: '1',
+    });
+  });
+});
diff --git a/packages/app/cypress/e2e/powerx-timeline.cy.ts b/packages/app/cypress/e2e/powerx-timeline.cy.ts
new file mode 100644
index 000000000..1a624390f
--- /dev/null
+++ b/packages/app/cypress/e2e/powerx-timeline.cy.ts
@@ -0,0 +1,198 @@
+import { assertShareLinkParams } from '../support/share-link';
+
+// The Measured Power "Timeline" display (`y_measuredPowerTimeline`) restores its
+// shared view on a `?unofficialrun=` trace. Intercepted rows carry the
+// `power_audit.source` / `run_url` provenance that names each point's
+// `gpu_metrics_*` artifact; `/api/gpu-metrics?series=power` returns matching
+// one-second series.
+
+const MODEL = 'dsv4';
+const DATE = '2026-09-01';
+const RUN_ID = '34716669498';
+const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
+const OVERLAY_RUN_ID = '31415926535';
+const OVERLAY_RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${OVERLAY_RUN_ID}`;
+const START_MS = Date.UTC(2026, 8, 1, 20, 0, 0);
+
+/** conc, interactivity (tok/s/user), output tok/s per GPU, measured W per GPU */
+const CONFIGS: [number, number, number, number][] = [
+  [16, 90, 200, 500],
+  [64, 60, 400, 600],
+  [256, 30, 800, 700],
+];
+
+const resultName = (hardware: string, conc: number) =>
+  `dsv4_8k1k_fp4_sglang_tp8-pp1-dcp1-pcp1-ep1-dpafalse_disagg-false_spec-none_conc${conc}_${hardware}-host-0123456789abcdef0123`;
+
+let rowId = 980000;
+const rows = (runUrl: string, hardware: 'b200' | 'h200') =>
+  CONFIGS.map(([conc, intvty, outputTput, watts]) => ({
+    id: hardware === 'b200' ? rowId++ : 0,
+    hardware,
+    framework: 'sglang',
+    model: MODEL,
+    precision: 'fp4',
+    spec_method: 'none',
+    disagg: false,
+    is_multinode: false,
+    prefill_tp: 8,
+    decode_tp: 8,
+    num_prefill_gpu: 8,
+    num_decode_gpu: 8,
+    isl: 8192,
+    osl: 1024,
+    conc,
+    offload_mode: 'off',
+    benchmark_type: 'single_turn',
+    image: 'sglang:test',
+    metrics: {
+      median_intvty: intvty,
+      median_itl: 1 / intvty,
+      median_e2el: 20,
+      median_ttft: 0.5,
+      tput_per_gpu: outputTput * 9,
+      output_tput_per_gpu: outputTput,
+      input_tput_per_gpu: outputTput * 8,
+      power_valid: 1,
+      power_metric_schema_version: 2,
+      avg_power_w: watts,
+      avg_total_gpu_power_w: watts * 8,
+      joules_per_output_token: watts / outputTput,
+    },
+    workers: null,
+    power_audit: {
+      source: `power_validation_${resultName(hardware, conc)}.json`,
+      sample_count: 160,
+      window_start_unix: (START_MS + 40_000) / 1000,
+      window_end_unix: (START_MS + 60_000) / 1000,
+      observed_gpu_ids: ['0', '1', '2', '3', '4', '5', '6', '7'],
+    },
+    date: DATE,
+    run_url: runUrl,
+  }));
+
+const seriesFor = (hardware: string, runUrl: string, runId: string) => ({
+  runInfo: {
+    id: Number(runId),
+    name: 'Run Sweep',
+    branch: hardware === 'b200' ? 'main' : 'powerx-timeline',
+    sha: 'abc123',
+    createdAt: `${DATE}T20:00:00Z`,
+    url: runUrl,
+    conclusion: 'success',
+    status: 'completed',
+  },
+  series: CONFIGS.map((config) => {
+    const [conc] = config;
+    const watts = config[3];
+    const t = Array.from({ length: 61 }, (_, i) => i);
+    return {
+      artifact: `gpu_metrics_${resultName(hardware, conc)}`,
+      startMs: START_MS,
+      bucketSeconds: 1,
+      gpus: [0, 1],
+      t,
+      power: [0, 1].map((gpu) => t.map((second) => (second >= 40 ? watts + gpu : 150 + gpu))),
+    };
+  }),
+});
+
+const availability = [
+  {
+    model: MODEL,
+    isl: 8192,
+    osl: 1024,
+    precision: 'fp4',
+    hardware: 'b200',
+    framework: 'sglang',
+    spec_method: 'none',
+    disagg: false,
+    benchmark_type: 'single_turn',
+    date: DATE,
+  },
+];
+
+function interceptRows() {
+  cy.intercept('GET', '/api/v1/availability', { body: availability }).as('availability');
+  cy.intercept('GET', '/api/v1/benchmarks*', { body: rows(RUN_URL, 'b200') }).as('benchmarks');
+  cy.intercept('GET', '/api/v1/workflow-info*', {
+    body: { runs: [], changelogs: [], configs: [] },
+  });
+  cy.intercept('POST', `/api/gpu-metrics?runId=${RUN_ID}*`, {
+    body: seriesFor('b200', RUN_URL, RUN_ID),
+  }).as('series');
+}
+
+function interceptOverlay() {
+  cy.intercept('GET', '/api/unofficial-run*', {
+    body: {
+      runInfos: [
+        {
+          id: OVERLAY_RUN_ID,
+          name: 'powerx-timeline',
+          branch: 'powerx-timeline',
+          sha: 'abc000',
+          createdAt: `${DATE}T00:00:00Z`,
+          url: OVERLAY_RUN_URL,
+          conclusion: 'success',
+          status: 'completed',
+          isNonMainBranch: true,
+        },
+      ],
+      benchmarks: rows(OVERLAY_RUN_URL, 'h200'),
+      evaluations: [],
+    },
+  }).as('unofficialRun');
+  cy.intercept('POST', `/api/gpu-metrics?runId=${OVERLAY_RUN_ID}*`, {
+    body: seriesFor('h200', OVERLAY_RUN_URL, OVERLAY_RUN_ID),
+  }).as('overlaySeries');
+}
+
+function visitChart(extraParams: string) {
+  interceptRows();
+  cy.visit(`/inference?g_model=DeepSeek-V4-Pro&i_seq=8k/1k&i_prec=fp4${extraParams}`, {
+    onBeforeLoad(win) {
+      win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
+      win.localStorage.setItem('inferencex-feature-gate', '1');
+    },
+  });
+  cy.wait(['@availability', '@benchmarks']);
+  cy.get('[data-testid="inference-chart-display"]').should('exist');
+}
+
+describe('PowerX measured power timeline', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message === 'ResizeObserver loop completed with undelivered notifications.') {
+        return false;
+      }
+    });
+  });
+
+  it('restores the shared serving-window view and focus on an unofficial trace', () => {
+    interceptOverlay();
+    const focus = `${OVERLAY_RUN_ID}:${resultName('h200', 64)}`;
+    visitChart(
+      `&i_metric=y_measuredPowerTimeline&unofficialrun=${OVERLAY_RUN_ID}&i_ptaxis=serving&i_ptlines=gpu&i_ptwindow=window&i_ptfocus=${encodeURIComponent(focus)}`,
+    );
+    cy.wait(['@series', '@unofficialRun', '@overlaySeries']);
+    cy.get('[data-testid="power-timeline-focus"]').should('contain.text', 'c64');
+    cy.get('[data-testid="power-timeline-per-gpu"]').should('have.attr', 'data-state', 'checked');
+    cy.get('[data-testid="power-timeline-window-only"]').should(
+      'have.attr',
+      'data-state',
+      'checked',
+    );
+    cy.get('path.power-trace[data-segment="full"]').should('not.exist');
+    cy.get('path.power-trace[data-run-index="0"][data-segment="window"]').should('exist');
+    assertShareLinkParams({
+      i_metric: 'y_measuredPowerTimeline',
+      i_ptaxis: 'serving',
+      i_ptlines: 'gpu',
+      i_ptwindow: 'window',
+      i_ptfocus: focus,
+    });
+    cy.get('[data-testid="power-timeline-focus-clear"]').click();
+    assertShareLinkParams({ i_ptfocus: null, i_ptlines: 'gpu', i_ptwindow: 'window' });
+  });
+});
diff --git a/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts b/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts
index 114b1e2c0..4aba05b46 100644
--- a/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts
+++ b/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts
@@ -140,12 +140,12 @@ describe('X-Axis Mode Toggle (inference chart)', () => {
     interceptDerivedAgenticMetrics();
   });
 
-  it('defaults to Interactivity and offers all four full names in one axis dropdown', () => {
+  it('defaults to Interactivity and offers every full name in one axis dropdown', () => {
     cy.get('[data-testid="scenario-selector"]').should('contain.text', 'Agentic');
     cy.get('[data-testid="x-axis-mode-selector"]').should('contain.text', 'Interactivity');
     cy.get('[data-testid="x-axis-mode-buttons"]').should('not.exist');
     openXAxisMenu();
-    cy.get('[role="grid"] [data-select-option]').should('have.length', 4);
+    cy.get('[role="grid"] [data-select-option]').should('have.length', 5);
     cy.get('[data-testid="x-axis-mode-e2e-normalized-interactivity"]')
       .should('have.text', 'E2E Normalized Interactivity')
       .and('have.attr', 'aria-pressed', 'false');
@@ -479,11 +479,12 @@ describe('Label defaults for fixed-sequence scenarios', () => {
     cy.get('[data-testid="chart-figure"] h2').should('contain.text', 'Time To First Token');
   });
 
-  it('offers only the three supported axes for fixed sequences', () => {
+  it('offers only the four supported axes for fixed sequences', () => {
     interceptFixedSequenceData();
     cy.visit('/inference?i_seq=8k%2F1k');
     openXAxisMenu();
-    cy.get('[role="grid"] [data-select-option]').should('have.length', 3);
+    cy.get('[role="grid"] [data-select-option]').should('have.length', 4);
+    cy.get('[data-testid="x-axis-mode-concurrency"]').should('be.visible');
     cy.get('[data-testid="x-axis-mode-interactivity"]').should('be.visible');
     cy.get('[data-testid="x-axis-mode-e2e"]').should('be.visible');
     cy.get('[data-testid="x-axis-mode-ttft"]').should('be.visible');
@@ -586,8 +587,8 @@ const expectCoordinates = (selector: string, expected: number[]) => {
   });
 };
 const expectInteractivity = () => {
-  cy.get('#chart-0 .x-axis-label').should('have.text', 'Interactivity (tok/s/user)');
-  cy.get('[data-testid="chart-figure"] h2').should('contain.text', 'vs. Interactivity');
+  cy.get('#chart-0 .x-axis-label').should('have.text', 'Median Interactivity (tok/s/user)');
+  cy.get('[data-testid="chart-figure"] h2').should('contain.text', 'vs. Median Interactivity');
   expectCoordinates('.dot-group', [80, 40, 20]);
   expectCoordinates('.unofficial-overlay-pt', [60, 30]);
 };
diff --git a/packages/app/cypress/support/mock-data.ts b/packages/app/cypress/support/mock-data.ts
index 733d04e49..5fffbf9f2 100644
--- a/packages/app/cypress/support/mock-data.ts
+++ b/packages/app/cypress/support/mock-data.ts
@@ -91,11 +91,13 @@ export function createMockHardwareConfig(): HardwareConfig {
 // ---------------------------------------------------------------------------
 
 export function createMockChartDefinition(overrides?: Partial<ChartDefinition>): ChartDefinition {
+  const chartType = overrides?.chartType ?? 'e2e';
+  const x = overrides?.x ?? (chartType === 'interactivity' ? 'median_intvty' : 'median_e2el');
   return {
-    chartType: 'e2e',
+    chartType,
     heading: 'End-to-End Latency vs Throughput',
-    x: 'conc' as keyof AggDataEntry,
-    x_label: 'Concurrency',
+    x,
+    x_label: chartType === 'interactivity' ? 'Interactivity' : 'End-to-end Latency (s)',
     y: 'mean_e2el' as keyof AggDataEntry,
     y_label: 'Mean E2E Latency (ms)',
     y_tpPerGpu: 'tput_per_gpu',
@@ -103,8 +105,9 @@ export function createMockChartDefinition(overrides?: Partial<ChartDefinition>):
     y_tpPerGpu_title: 'Throughput per Chip',
     y_tpPerGpu_roofline: 'upper_right',
     ...overrides,
-    x_scale_field: overrides?.x_scale_field ?? String(overrides?.x ?? 'conc'),
-    x_labelZh: overrides?.x_labelZh ?? '并发数',
+    x_scale_field: overrides?.x_scale_field ?? String(x),
+    x_labelZh:
+      overrides?.x_labelZh ?? (chartType === 'interactivity' ? '交互性' : '端到端延迟（s）'),
   };
 }
 
@@ -224,6 +227,8 @@ export function createMockInferenceContextValues(
     openRouterPricingError: null,
     setTokenRevenuePriceSource: namedStub('setTokenRevenuePriceSource'),
     selectedPercentile: 'p90',
+    fixedSequenceStatistic: 'median',
+    setFixedSequenceStatistic: namedStub('setFixedSequenceStatistic'),
     setSelectedPercentile: namedStub('setSelectedPercentile'),
     selectedXAxisMetric: null,
     setSelectedXAxisMetric: namedStub('setSelectedXAxisMetric'),
@@ -241,6 +246,7 @@ export function createMockInferenceContextValues(
     setQuickFilterDeployment: namedStub('setQuickFilterDeployment'),
     setQuickFilterSpec: namedStub('setQuickFilterSpec'),
     setQuickFilterPower: namedStub('setQuickFilterPower'),
+    setQuickFilterTopologies: namedStub('setQuickFilterTopologies'),
     isLegendExpanded: true,
     setIsLegendExpanded: namedStub('setIsLegendExpanded'),
     hideNonOptimal: false,
diff --git a/packages/app/cypress/support/share-link.ts b/packages/app/cypress/support/share-link.ts
new file mode 100644
index 000000000..29081a970
--- /dev/null
+++ b/packages/app/cypress/support/share-link.ts
@@ -0,0 +1,20 @@
+/**
+ * The address bar is stripped clean after load (share-link state lives in the
+ * in-memory store), so the Share popover is where share-link state must land.
+ * Asserts several parameters in one popover round trip; a `null` expectation
+ * means the parameter must be absent (stripped as a default).
+ */
+export function assertShareLinkParams(expected: Record<string, string | null>): void {
+  cy.get('[data-testid="share-button"]').first().click();
+  cy.get('[data-testid="share-url-input"]')
+    .invoke('val')
+    .should((value) => {
+      const params = new URL(String(value)).searchParams;
+      for (const [key, param] of Object.entries(expected)) {
+        expect(params.get(key), `${key} in the share link`).to.eq(param);
+      }
+    });
+  // The link field is read-only, so dismiss the popover from the document.
+  cy.get('body').type('{esc}');
+  cy.get('[data-testid="share-url-input"]').should('not.exist');
+}
diff --git a/packages/app/src/app/api/gpu-metrics/route.ts b/packages/app/src/app/api/gpu-metrics/route.ts
index b9f351d66..db31ce21c 100644
--- a/packages/app/src/app/api/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.ts
@@ -93,8 +93,6 @@ const MAX_REQUEST_BYTES = 256 * 1024;
 
 export type GpuMetricsSource = 'database' | 'github';
 
-export type GpuMetricsArtifactPayload = GpuMetricsArtifact;
-
 export interface GpuMetricsRouteResponse extends GpuPowerApiResponse {
   source: GpuMetricsSource;
   artifactNames?: string[];
@@ -147,9 +145,10 @@ interface GithubGpuMetricsResponse extends Omit<GpuMetricsRouteResponse, 'artifa
   bundleSeries: GpuPowerSeries[];
 }
 
-type TelemetryJob =
-  | { kind: 'csv'; artifact: GithubArtifact }
-  | { kind: 'bundle'; artifact: GithubArtifact };
+interface TelemetryJob {
+  kind: 'csv' | 'bundle';
+  artifact: GithubArtifact;
+}
 
 type TelemetryResult =
   | { kind: 'csv'; parsed: GithubArtifactPayload }
@@ -319,9 +318,9 @@ function powerSeriesResponse(
  * listing filter so both sources answer the same request the same way.
  */
 function filterArtifactsByPrefix(
-  artifacts: GpuMetricsArtifactPayload[],
+  artifacts: GpuMetricsArtifact[],
   prefix: string | null,
-): GpuMetricsArtifactPayload[] {
+): GpuMetricsArtifact[] {
   if (prefix === null) return artifacts;
   const wanted = `${ARTIFACT_PREFIX}${prefix}`;
   return artifacts.filter((artifact) => {
@@ -566,10 +565,9 @@ async function readGpuMetrics(
         ),
       ];
       for (const missing of incomplete) {
-        const incompleteArtifact = missing.artifact;
-        const live = artifacts.find((artifact) => artifact.name === incompleteArtifact);
+        const live = artifacts.find((artifact) => artifact.name === missing.artifact);
         const inventory = stored?.artifacts.find(
-          (artifact) => artifact.series?.artifactName === incompleteArtifact,
+          (artifact) => artifact.series?.artifactName === missing.artifact,
         )?.series?.sidecars.seriesInventory;
         // A matching name alone cannot prove that missing hosts/samples recovered.
         // Bundle cuts do not retain the raw inventory, so known-incomplete bundles
diff --git a/packages/app/src/app/api/v1/views/inference/route.test.ts b/packages/app/src/app/api/v1/views/inference/route.test.ts
index ae78ce0f3..03077bf42 100644
--- a/packages/app/src/app/api/v1/views/inference/route.test.ts
+++ b/packages/app/src/app/api/v1/views/inference/route.test.ts
@@ -1,6 +1,12 @@
 import { NextRequest } from 'next/server';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
+import {
+  buildEqualServiceComparison,
+  getEqualServiceSources,
+} from '@/components/inference/utils/equal-service-comparison';
+import { buildInferenceSeries } from '@/lib/views-api/series';
+import { Sequence } from '@/lib/data-mappings';
 import type { BenchmarkRow } from '@/lib/api';
 
 const { mockGetLatestBenchmarks, mockGetBenchmarksForRun, mockUnofficialRun, mockGetDb } =
@@ -96,6 +102,157 @@ beforeEach(() => {
 });
 
 describe('GET /api/v1/views/inference', () => {
+  it('calculates equal-service panels from observed points before frontier pruning with endpoint provenance', async () => {
+    const rows = ['h200', 'mi300x'].flatMap((hardware, index) =>
+      [20, 60].map((x, position) =>
+        makeRow({
+          hardware,
+          conc: position + 1,
+          metrics: {
+            ...makeRow().metrics,
+            median_intvty: x,
+            avg_power_w: 200 + 200 * position + 50 * index,
+            output_tput_per_gpu: 100 + 100 * position + 50 * index,
+            joules_per_output_token: 4 - 2 * position - index,
+            power_valid: 1,
+            power_metric_schema_version: 2,
+          },
+        }),
+      ),
+    );
+    mockGetLatestBenchmarks.mockResolvedValue(rows);
+    const projected = buildInferenceSeries(rows, {
+      sequence: Sequence.EightK_OneK,
+      percentile: 'p90',
+      precisions: ['fp8'],
+      metricConfigKey: 'y_measuredAvgPower',
+      xmode: 'interactivity',
+      xmetric: 'p90_ttft',
+      gpus: [],
+      quickFilters: { vendors: [], frameworks: [], deployment: [], spec: [], power: [] },
+      optimal: true,
+      best: true,
+    });
+    const sources = getEqualServiceSources(projected.observedPoints);
+    const expected = buildEqualServiceComparison(projected.observedPoints, {
+      baseline: sources[0].key,
+      comparator: sources[1].key,
+      target: 40,
+      xField: 'median_intvty',
+    });
+    const response = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=measuredAvgPower&serviceCompare=true&serviceTarget=40',
+      ),
+    );
+    const body = await response.json();
+    expect(response.status).toBe(200);
+    expect(body.serviceSources).toEqual(sources);
+    expect(body.equalServiceComparison.metrics.meanWattsPerGpu.changePercent).toBeCloseTo(100 / 6);
+    expect(body.equalServiceComparison.metrics.outputTokensPerSecond.changePercent).toBeCloseTo(
+      100 / 3,
+    );
+    expect(body.equalServiceComparison.metrics.joulesPerOutputToken.changePercent).toBeCloseTo(
+      -100 / 3,
+    );
+    for (const [metric, values] of Object.entries(expected.metrics)) {
+      expect(body.equalServiceComparison.metrics[metric].changePercent).toBe(values.changePercent);
+      expect(body.equalServiceComparison.metrics[metric].baseline.value).toBe(
+        values.baseline?.value,
+      );
+    }
+    expect(
+      body.equalServiceComparison.metrics.meanWattsPerGpu.baseline.endpoints.map(
+        (endpoint: { point: { id: number } }) => endpoint.point.id,
+      ),
+    ).toEqual(rows.slice(0, 2).map((row) => row.id));
+    expect(
+      body.equalServiceComparison.metrics.meanWattsPerGpu.baseline.endpoints[0].point.runUrl,
+    ).toBe(rows[0].run_url);
+    expect(body).not.toHaveProperty('observedPoints');
+    expect(body.equalServiceCurve).toHaveLength(2);
+  });
+
+  it('includes unofficial sources and validated role shares using one output-token denominator', async () => {
+    const row = makeRow({
+      hardware: 'gb200',
+      framework: 'trt',
+      disagg: true,
+      num_prefill_gpu: 4,
+      num_decode_gpu: 4,
+      prefill_num_workers: 1,
+      decode_num_workers: 1,
+      metrics: {
+        ...makeRow().metrics,
+        avg_power_w: 400,
+        power_valid: 1,
+        power_metric_schema_version: 2,
+        joules_per_input_token: 1,
+        joules_per_output_token: 8,
+        prefill_joules_per_input_token: 0.4,
+        decode_joules_per_output_token: 4.8,
+      },
+    });
+    mockGetLatestBenchmarks.mockResolvedValue([row]);
+    mockUnofficialRun.mockImplementation(() =>
+      Response.json({
+        benchmarks: [{ ...row, id: 999, run_url: 'https://github.com/org/repo/actions/runs/999' }],
+        evaluations: [],
+      }),
+    );
+    const response = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=measuredAvgPower&serviceCompare=true&roleShare=true&unofficialrun=999',
+      ),
+    );
+    const body = await response.json();
+    expect(response.status).toBe(200);
+    expect(body.serviceSources).toHaveLength(2);
+    expect(body.roleEnergyShares).toHaveLength(2);
+    expect(
+      body.roleEnergyShares
+        .map((item: { point: { id: number } }) => item.point.id)
+        .sort((a: number, b: number) => a - b),
+    ).toEqual([row.id, 999].sort((a, b) => a - b));
+    for (const share of body.roleEnergyShares) {
+      expect(share).toMatchObject({
+        prefill: 3.2,
+        decode: 4.8,
+        total: 8,
+        prefillShare: 40,
+        decodeShare: 60,
+      });
+    }
+    expect(body.overlays[0]).not.toHaveProperty('observedPoints');
+  });
+
+  it('resolves the fixed-sequence statistic and rejects unknown values', async () => {
+    mockGetLatestBenchmarks.mockResolvedValue([
+      makeRow({ metrics: { ...makeRow().metrics, mean_tpot: 0.025, mean_intvty: 99 } }),
+    ]);
+    const response = await GET(
+      request('/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&xstat=mean'),
+    );
+    const body = await response.json();
+    expect(body.params.xstat).toBe('mean');
+    expect(body.xAxis).toMatchObject({ field: 'mean_tpot_intvty', statistic: 'mean' });
+    expect(body.series[0].points[0].x).toBe(40);
+    const diagnostic = await GET(
+      request(
+        '/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu&xstat=mean&xmode=concurrency',
+      ),
+    );
+    const diagnosticBody = await diagnostic.json();
+    expect(diagnosticBody.params.xstat).toBeNull();
+    expect(diagnosticBody.xAxis.statistic).toBeNull();
+    const invalid = await GET(
+      request('/api/v1/views/inference?model=DeepSeek-R1-0528&xstat=average'),
+    );
+    expect(invalid.status).toBe(400);
+    const invalidBody = await invalid.json();
+    expect(invalidBody.param).toBe('xstat');
+  });
+
   it('returns chart-ready series with resolved params for the default selection', async () => {
     const res = await GET(
       request('/api/v1/views/inference?model=DeepSeek-R1-0528&metric=tpPerGpu'),
diff --git a/packages/app/src/app/api/v1/views/inference/route.ts b/packages/app/src/app/api/v1/views/inference/route.ts
index 14c3f61a1..8ae6f0d7d 100644
--- a/packages/app/src/app/api/v1/views/inference/route.ts
+++ b/packages/app/src/app/api/v1/views/inference/route.ts
@@ -1,7 +1,29 @@
 import { GET as derived } from '@/app/api/v1/derived-agentic-metrics/route';
 import { preferVrDefaultRun, VR_DEFAULT_RUN } from '@/components/inference/default-run-preference';
 import { NORMALIZED_TOKEN_REVENUE_PRICING } from '@/components/inference/token-revenue';
-import type { TokenRevenuePricing } from '@/components/inference/types';
+import {
+  buildEqualServiceComparison,
+  equalServiceSourceKey,
+  getEqualServiceComparisonCurve,
+  getEqualServiceSources,
+  getPrefillSharePoints,
+  getRolePoints,
+  type EqualServiceComparison,
+  type EqualServiceEstimate,
+} from '@/components/inference/utils/equal-service-comparison';
+import {
+  buildMatchedConcurrencyTable,
+  type MatchedConcurrencySide,
+  type MatchedConcurrencyTable,
+} from '@/components/inference/utils/matched-concurrency';
+import { buildPowerFits } from '@/components/inference/utils/power-fit';
+import { resolveServiceField } from '@/components/inference/utils/resolveXAxisField';
+import { pointTopologyKey } from '@/components/inference/utils/topology-filter';
+import type {
+  InferenceData,
+  AggDataEntry,
+  TokenRevenuePricing,
+} from '@/components/inference/types';
 import type { DerivedAgenticMetricMap } from '@/hooks/api/use-derived-agentic-metrics';
 import { fetchOpenRouterPricing } from '@/hooks/api/use-openrouter-pricing';
 import type { TcoBasis } from '@/lib/constants';
@@ -16,6 +38,7 @@ import {
 import { ViewsApiParamError, runViewsRoute } from '@/lib/views-api/errors';
 import {
   parseNumberMap,
+  parseNumberParam,
   validateParams as validateViewParams,
   parseBoolParam,
   parseDateParam,
@@ -91,6 +114,7 @@ interface InferenceViewParams {
   readonly precisionsExplicit: boolean;
   readonly metric: string;
   readonly xmode: SeriesXMode;
+  readonly xstat: 'mean' | 'median';
   readonly xmetric: string;
   readonly percentile: string;
   readonly date?: string;
@@ -105,6 +129,7 @@ interface InferenceViewParams {
   readonly best: boolean;
   readonly tcoBasis: TcoBasis;
   readonly power: readonly ('certified' | 'legacy')[];
+  readonly topologies: readonly string[];
   readonly allPoints: boolean;
   readonly userCosts: Record<string, number>;
   readonly userPowers: Record<string, number>;
@@ -146,6 +171,7 @@ function buildView(
     precisions: resolvedPrecisions,
     metricConfigKey: parseMetricParam(params.metric),
     xmode: params.xmode,
+    fixedSequenceStatistic: params.xstat,
     xmetric: params.xmetric,
     gpus: params.gpus,
     quickFilters: {
@@ -156,6 +182,7 @@ function buildView(
       // Measured-power tier pills are a dashboard-only affordance; the API
       // returns every row regardless of power certification, like the default view.
       power: [...params.power],
+      topologies: [...params.topologies],
     },
     optimal: params.optimal,
     best: params.best,
@@ -170,7 +197,7 @@ function buildView(
   return { resolvedPrecisions, result };
 }
 
-function csvRows(data: InferenceViewData) {
+function csvRows(data: { result: Pick<InferenceSeriesResult, 'series'> }) {
   return data.result.series.flatMap((entry) =>
     entry.points.map((point) => ({
       hwKey: entry.hwKey,
@@ -184,6 +211,7 @@ function csvRows(data: InferenceViewData) {
       x: point.x,
       y: point.y,
       concurrency: point.concurrency,
+      topologyKey: point.topologyKey,
       tp: point.tp,
       date: point.date,
       runId: point.runId ?? '',
@@ -196,6 +224,63 @@ function csvRows(data: InferenceViewData) {
   );
 }
 
+/** Keep public endpoint provenance without serializing internal chart objects. */
+function observedPointIdentity(point: InferenceData) {
+  return {
+    id: point.id ?? null,
+    sourceKey: equalServiceSourceKey(point),
+    hwKey: point.hwKey,
+    precision: point.precision,
+    concurrency: point.conc,
+    topologyKey: pointTopologyKey(point),
+    date: point.actualDate ?? point.date,
+    runUrl: point.run_url ?? null,
+    recipeFingerprint: point.recipe_fingerprint ?? null,
+    image: point.image ?? null,
+  };
+}
+
+function publicServiceComparison(comparison: EqualServiceComparison) {
+  const estimate = (value: EqualServiceEstimate | null) =>
+    value === null
+      ? null
+      : {
+          ...value,
+          endpoints: value.endpoints.map(({ point, ...endpoint }) => ({
+            ...endpoint,
+            point: observedPointIdentity(point),
+          })),
+        };
+  return {
+    ...comparison,
+    metrics: Object.fromEntries(
+      Object.entries(comparison.metrics).map(([key, metric]) => [
+        key,
+        { ...metric, baseline: estimate(metric.baseline), comparator: estimate(metric.comparator) },
+      ]),
+    ),
+  };
+}
+
+function publicMatchedSide(side: MatchedConcurrencySide) {
+  if (side.status === 'observed')
+    return { status: side.status, values: side.values, point: observedPointIdentity(side.point) };
+  if (side.status === 'ambiguous')
+    return { status: side.status, points: side.points.map(observedPointIdentity) };
+  return side;
+}
+
+function publicMatchedConcurrency(table: MatchedConcurrencyTable) {
+  return {
+    ...table,
+    rows: table.rows.map((row) => ({
+      ...row,
+      baseline: publicMatchedSide(row.baseline),
+      comparator: publicMatchedSide(row.comparator),
+    })),
+  };
+}
+
 export function GET(request: NextRequest) {
   return runViewsRoute('inference', async () => {
     validateViewParams(request.nextUrl.searchParams, VIEW_QUERY_PARAMS['inference']);
@@ -217,6 +302,7 @@ export function GET(request: NextRequest) {
       requestedXMode === 'e2e-normalized-interactivity' && sequence !== Sequence.AgenticTraces
         ? 'interactivity'
         : requestedXMode;
+    const xstat = parseEnumParam(search.get('xstat'), 'xstat', ['mean', 'median'], 'median');
     const xmetric = parseEnumParam(search.get('xmetric'), 'xmetric', XMETRIC_VALUES, 'p90_ttft');
     const percentile = parseEnumParam(
       search.get('percentile'),
@@ -231,15 +317,41 @@ export function GET(request: NextRequest) {
     const frameworks = parseFrameworkFamiliesParam(search.get('frameworks'));
     const deployment = parseDeploymentParam(search.get('deployment'));
     const spec = parseSpecModesParam(search.get('spec'));
-    const optimal = parseBoolParam(search.get('optimal'), 'optimal', true);
-    const best = parseBoolParam(
+    const requestedOptimal = parseBoolParam(search.get('optimal'), 'optimal', true);
+    const requestedBest = parseBoolParam(
       search.get('best'),
       'best',
       !isBestPerSkuDefaultOff(displayName as Model, sequence),
     );
     const format = parseFormatParam(search.get('format'));
+    const serviceCompare = parseBoolParam(search.get('serviceCompare'), 'serviceCompare', false);
+    const roleShare = parseBoolParam(search.get('roleShare'), 'roleShare', false);
+    const powerFit = parseBoolParam(search.get('powerFit'), 'powerFit', false);
+    const requestedServiceBaseline = search.get('serviceBaseline');
+    const requestedServiceComparator = search.get('serviceComparator');
+    const serviceTarget = search.has('serviceTarget')
+      ? parseNumberParam(search.get('serviceTarget'), 'serviceTarget', 0, { min: Number.MIN_VALUE })
+      : null;
+    if (serviceTarget !== null && serviceTarget <= 0)
+      throw new ViewsApiParamError('serviceTarget', 'serviceTarget must be positive');
+    if (format === 'csv' && (serviceCompare || roleShare || powerFit))
+      throw new ViewsApiParamError(
+        'format',
+        'Equal-service, role-share and power-fit panels require format=json',
+      );
     const tcoBasis = parseTcoBasisParam(search.get('tcoBasis'));
     const power = parseListParam(search.get('power'), 'power', POWER_TIER_ORDER);
+    // Topology keys are opaque values returned by this view, not case-folded names.
+    const topologies = [
+      ...new Set(
+        (search.get('topologies') ?? '')
+          .split(',')
+          .map((key) => key.trim())
+          .filter(Boolean),
+      ),
+    ].toSorted();
+    const optimal = xmode === 'concurrency' ? false : requestedOptimal;
+    const best = xmode === 'concurrency' ? false : requestedBest;
     const allPoints = parseBoolParam(search.get('allPoints'), 'allPoints', false);
     const userCosts = parseNumberMap(search.get('userCosts'), 'userCosts');
     const userPowers = parseNumberMap(search.get('userPowers'), 'userPowers');
@@ -265,6 +377,7 @@ export function GET(request: NextRequest) {
       precisionsExplicit: precisions.length > 0,
       metric,
       xmode,
+      xstat,
       xmetric,
       percentile,
       ...(date ? { date } : {}),
@@ -278,6 +391,7 @@ export function GET(request: NextRequest) {
       best,
       tcoBasis,
       power,
+      topologies,
       allPoints,
       userCosts,
       userPowers,
@@ -326,10 +440,16 @@ export function GET(request: NextRequest) {
         await getCachedBenchmarks([...dbModelKeys], VR_DEFAULT_RUN.date, true),
       );
     const data = await project(rows, params);
+    const observedPoints = [...data.result.observedPoints];
+    // Service/role panels pool every scope's observed points; the payload omits them.
+    const collectObserved = ({ observedPoints: points, ...result }: InferenceSeriesResult) => {
+      observedPoints.push(...points);
+      return result;
+    };
     const comparisons = await Promise.all(
       scopes.map(async (scope) => {
         const comparison = await project(await fetchRows(scope.params), scope.params);
-        return { entry: scope.entry, ...comparison.result };
+        return { entry: scope.entry, ...collectObserved(comparison.result) };
       }),
     );
     const overlayRows = await unofficialRows(request);
@@ -339,16 +459,80 @@ export function GET(request: NextRequest) {
           overlayRows.filter((row) => row.run_url === url),
           params,
         );
-        return { runUrl: url, ...overlay.result };
+        return { runUrl: url, ...collectObserved(overlay.result) };
       }),
     );
 
+    const serviceSources = serviceCompare ? getEqualServiceSources(observedPoints) : [];
+    const serviceBaseline = requestedServiceBaseline ?? serviceSources[0]?.key ?? '';
+    const serviceComparator = requestedServiceComparator ?? serviceSources[1]?.key ?? '';
+    const serviceOptions = {
+      baseline: serviceBaseline,
+      comparator: serviceComparator,
+      xField: data.result.xAxis.field as keyof AggDataEntry,
+    };
+    const servicePanels = serviceCompare
+      ? {
+          serviceSources,
+          equalServiceComparison:
+            serviceTarget === null
+              ? null
+              : publicServiceComparison(
+                  buildEqualServiceComparison(observedPoints, {
+                    ...serviceOptions,
+                    target: serviceTarget,
+                  }),
+                ),
+          equalServiceCurve: getEqualServiceComparisonCurve(observedPoints, serviceOptions).map(
+            publicServiceComparison,
+          ),
+          matchedConcurrency: publicMatchedConcurrency(
+            buildMatchedConcurrencyTable(observedPoints, {
+              baseline: serviceBaseline,
+              comparator: serviceComparator,
+              // The dashboard reads streaming speed at the selected statistic.
+              interactivityField: resolveServiceField('median_intvty', {
+                isAgentic: sequence === Sequence.AgenticTraces,
+                percentile,
+                fixedSequenceStatistic: xstat,
+              }),
+            }),
+          ),
+        }
+      : {};
+    const rolePanel = roleShare
+      ? {
+          roleEnergyShares: getPrefillSharePoints(observedPoints, serviceOptions.xField).map(
+            ({ point, ...energy }) => ({
+              ...energy,
+              point: observedPointIdentity(point),
+              decodeShare: 100 - energy.prefillShare,
+            }),
+          ),
+          rolePoints: getRolePoints(observedPoints, serviceOptions.xField).map(
+            ({ point, ...role }) => ({ ...role, point: observedPointIdentity(point) }),
+          ),
+        }
+      : {};
+    const fitPanel = powerFit
+      ? {
+          powerFits: buildPowerFits(observedPoints).map(({ observations, ...fit }) => ({
+            ...fit,
+            observations: observations.map(({ point, ...observation }) => ({
+              ...observation,
+              point: observedPointIdentity(point),
+            })),
+          })),
+        }
+      : {};
+
     const resolvedParams = {
       model: displayName,
       sequence: sequence as string,
       precisions: data.resolvedPrecisions,
       metric,
       xmode,
+      xstat: sequence === Sequence.AgenticTraces || xmode === 'concurrency' ? null : xstat,
       xmetric,
       percentile,
       date: date ?? null,
@@ -358,6 +542,7 @@ export function GET(request: NextRequest) {
       frameworks,
       deployment,
       spec,
+      topologies,
       optimal,
       best,
       format,
@@ -369,6 +554,12 @@ export function GET(request: NextRequest) {
       priceSource,
       dates,
       unofficialrun: search.get('unofficialrun') ?? null,
+      serviceCompare,
+      serviceBaseline: serviceCompare ? serviceBaseline : null,
+      serviceComparator: serviceCompare ? serviceComparator : null,
+      serviceTarget: serviceCompare ? serviceTarget : null,
+      roleShare,
+      powerFit,
     };
 
     if (format === 'csv') {
@@ -396,6 +587,9 @@ export function GET(request: NextRequest) {
       comparisons,
       overlays,
       pricing,
+      ...servicePanels,
+      ...rolePanel,
+      ...fitPanel,
     });
   });
 }
diff --git a/packages/app/src/app/api/v1/views/options/route.ts b/packages/app/src/app/api/v1/views/options/route.ts
index 90bde1be0..a1e766c22 100644
--- a/packages/app/src/app/api/v1/views/options/route.ts
+++ b/packages/app/src/app/api/v1/views/options/route.ts
@@ -152,6 +152,7 @@ function buildOptionsPayload() {
     specMethods: [...SPEC_METHOD_KEYS].toSorted(),
     percentiles: PERCENTILE_OPTIONS,
     xAxisModes: X_AXIS_MODES,
+    fixedSequenceStatistics: ['median', 'mean'],
     scaleModes: ['auto', 'linear', 'log'],
     metrics,
     quickFilters: {
@@ -190,6 +191,10 @@ function buildOptionsPayload() {
       metric: DEFAULT_METRIC_CONFIG_KEY,
       percentile: 'p90',
       xmode: 'interactivity',
+      xstat: 'median',
+      serviceCompare: false,
+      roleShare: false,
+      powerFit: false,
       xmetric: 'p90_ttft',
       scale: 'auto',
       precisions: 'auto',
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.ts b/packages/app/src/components/gpu-power/power-audit-bundle.ts
index 063972401..1af01a960 100644
--- a/packages/app/src/components/gpu-power/power-audit-bundle.ts
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.ts
@@ -130,22 +130,20 @@ function asRole(value: unknown): GpuPowerRole | undefined {
   return value === 'prefill' || value === 'decode' ? value : undefined;
 }
 
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
 function parseJsonObject(text: string | undefined): Record<string, unknown> | null {
   if (text === undefined) return null;
   try {
     const parsed: unknown = JSON.parse(text);
-    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
-      ? (parsed as Record<string, unknown>)
-      : null;
+    return isRecord(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
 function manifestSlot(hostname: string, gpuIndex: number): string {
   return `${hostname}#${gpuIndex}`;
 }
@@ -266,7 +264,7 @@ export function cutPowerAuditBundle(
   const manifest = parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY));
   const contextFiles = [...files]
     .filter(([name]) => isContextEntry(name))
-    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    .sort(([a], [b]) => compareText(a, b));
   const smiFiles = [...files]
     .filter(([name]) => isSmiCsv(name))
     .map(([name, text]) => {
@@ -287,13 +285,7 @@ export function cutPowerAuditBundle(
   if (samplesText === undefined) return [];
   const { samples, devices } = parseSamples(samplesText);
   if (samples.length === 0) return [];
-  return cutPowerAuditSamples(
-    artifact,
-    samples,
-    devices,
-    validations,
-    parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY)),
-  );
+  return cutPowerAuditSamples(artifact, samples, devices, validations, manifest);
 }
 
 /** Apply bundle window cuts to the richer SMI CSVs without requiring DCGM UUID sidecars. */
diff --git a/packages/app/src/components/gpu-power/power-series.ts b/packages/app/src/components/gpu-power/power-series.ts
index 8ff75fabb..0f98d1e80 100644
--- a/packages/app/src/components/gpu-power/power-series.ts
+++ b/packages/app/src/components/gpu-power/power-series.ts
@@ -51,6 +51,8 @@ export interface GpuPowerSeries {
 }
 
 export interface GpuPowerSeriesResponse {
+  /** Where the route read the series: the ingested digest or the run's GitHub artifacts. */
+  source?: 'database' | 'github';
   runInfo: GpuPowerRunInfo;
   series: GpuPowerSeries[];
   /** Coverage of requested validation identities only, never the full run/sweep. */
diff --git a/packages/app/src/components/gpu-power/stored-power-series.ts b/packages/app/src/components/gpu-power/stored-power-series.ts
index 964d44812..80dfb6b96 100644
--- a/packages/app/src/components/gpu-power/stored-power-series.ts
+++ b/packages/app/src/components/gpu-power/stored-power-series.ts
@@ -3,15 +3,12 @@ import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-
 import {
   cutPowerAuditSamples,
   cutPowerAuditCsvs,
+  isRecord,
   type PowerAuditDevice,
   type PowerAuditSample,
 } from './power-audit-bundle';
 import { bucketPowerFiles, type GpuPowerSeries } from './power-series';
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
 export class StoredTelemetryIncompleteError extends Error {
   readonly artifact: string;
 
diff --git a/packages/app/src/components/gpu-power/types.ts b/packages/app/src/components/gpu-power/types.ts
index 6c82d5616..90ebeb75b 100644
--- a/packages/app/src/components/gpu-power/types.ts
+++ b/packages/app/src/components/gpu-power/types.ts
@@ -200,17 +200,18 @@ export function getAvailableMetrics(data: GpuMetricRow[]): GpuMetricConfig[] {
   return ALL_METRIC_OPTIONS.filter((m) => data.some((row) => Number.isFinite(row[m.key])));
 }
 
-/**
- * Detect GPU SKU from an artifact name and return its TDP in watts.
- * Artifact names look like: gpu_metrics_dsr1_1k8k_fp8_sglang_tp8_..._h200-nb_0
- */
 /** TDP for a known hardware key, e.g. the benchmark point's own `hardware`. */
 export function tdpForHardware(hardware: string | undefined): { sku: string; tdp: number } | null {
   const key = hardware?.toLowerCase();
-  const entry = key ? HW_REGISTRY[key] : undefined;
-  return entry ? { sku: key!.toUpperCase(), tdp: entry.tdp } : null;
+  if (!key) return null;
+  const entry = HW_REGISTRY[key];
+  return entry ? { sku: key.toUpperCase(), tdp: entry.tdp } : null;
 }
 
+/**
+ * Detect GPU SKU from an artifact name and return its TDP in watts.
+ * Artifact names look like: gpu_metrics_dsr1_1k8k_fp8_sglang_tp8_..._h200-nb_0
+ */
 export function detectTdpFromArtifactName(
   artifactName: string,
 ): { sku: string; tdp: number } | null {
diff --git a/packages/app/src/components/inference/InferenceContext.tsx b/packages/app/src/components/inference/InferenceContext.tsx
index 206c9fd47..109de2fb1 100644
--- a/packages/app/src/components/inference/InferenceContext.tsx
+++ b/packages/app/src/components/inference/InferenceContext.tsx
@@ -58,6 +58,7 @@ import {
 } from '@/hooks/useChartContext';
 import { useUrlState } from '@/hooks/useUrlState';
 import { serializePerfRulers } from '@/lib/d3-chart/layers/perf-ruler';
+import type { FixedSequenceStatistic } from '@/components/inference/utils/resolveXAxisField';
 import { parsePowerCompare } from '@/components/inference/utils/power-compare';
 import {
   PERSISTED_PERF_RULER_CHART_ID,
@@ -203,9 +204,12 @@ export function resolveE2eXAxisMetric(
   mode: XAxisMode,
   sequence: Parameters<typeof sequenceKind>[0],
   percentile: string,
+  fixedSequenceStatistic: FixedSequenceStatistic = 'median',
 ): string | null {
   if (mode === 'ttft') {
-    return sequenceKind(sequence) === 'agentic' ? `${percentile}_ttft` : 'median_ttft';
+    return sequenceKind(sequence) === 'agentic'
+      ? `${percentile}_ttft`
+      : `${fixedSequenceStatistic}_ttft`;
   }
   if (mode === 'e2e') return null;
   return requestedMetric;
@@ -478,6 +482,13 @@ export function InferenceProvider({
     xAxisModeFromUrlRef.current = true;
     setRequestedXAxisMode(mode);
   }, []);
+  const [fixedSequenceStatistic, setFixedSequenceStatistic] =
+    useState<FixedSequenceStatistic>('median');
+  useEffect(() => {
+    setFixedSequenceStatistic(getUrlParam('i_mstat') === 'mean' ? 'mean' : 'median');
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   // Latency percentile applied to the chart x-axis for agentic scenarios.
   // Values: 'p90' | 'p99'. Non-agentic charts ignore.
   const [selectedPercentile, setSelectedPercentile] = useState<string>(
@@ -488,6 +499,7 @@ export function InferenceProvider({
     selectedXAxisMode,
     effectiveSequence,
     selectedPercentile,
+    fixedSequenceStatistic,
   );
   const [scaleType, setScaleType] = useState<'auto' | 'linear' | 'log'>(
     () => (getUrlParam('i_scale') as 'auto' | 'linear' | 'log') || 'auto',
@@ -526,8 +538,9 @@ export function InferenceProvider({
   const [quickFilterDeployment, setQuickFilterDeployment] = useState<DeploymentMode[]>([]);
   const [quickFilterSpec, setQuickFilterSpec] = useState<SpecMode[]>([]);
   const [quickFilterPower, setQuickFilterPower] = useState<PowerTier[]>([]);
+  const [quickFilterTopologies, setQuickFilterTopologies] = useState<string[]>([]);
   useEffect(() => {
-    const parse = (key: 'i_vendor' | 'i_fw' | 'i_disagg' | 'i_spec' | 'i_power') => {
+    const parse = (key: 'i_vendor' | 'i_fw' | 'i_disagg' | 'i_spec' | 'i_power' | 'i_topology') => {
       const v = getUrlParam(key);
       return v ? v.split(',').filter(Boolean) : [];
     };
@@ -538,11 +551,13 @@ export function InferenceProvider({
     const deployment = parseDeploymentModes(parse('i_disagg'));
     const spec = parse('i_spec') as SpecMode[];
     const power = parsePowerTiers(parse('i_power'));
+    const topologies = parse('i_topology');
     if (vendors.length > 0) setQuickFilterVendors(vendors);
     if (frameworks.length > 0) setQuickFilterFrameworks(frameworks);
     if (deployment.length > 0) setQuickFilterDeployment(deployment);
     if (spec.length > 0) setQuickFilterSpec(spec);
     if (power.length > 0) setQuickFilterPower(power);
+    if (topologies.length > 0) setQuickFilterTopologies(topologies);
   }, [getUrlParam, setQuickFilterFrameworks]);
   const quickFilters = useMemo<QuickFilters>(
     () => ({
@@ -551,6 +566,7 @@ export function InferenceProvider({
       deployment: quickFilterDeployment,
       spec: quickFilterSpec,
       power: quickFilterPower,
+      topologies: quickFilterTopologies,
     }),
     [
       quickFilterVendors,
@@ -558,6 +574,7 @@ export function InferenceProvider({
       quickFilterDeployment,
       quickFilterSpec,
       quickFilterPower,
+      quickFilterTopologies,
     ],
   );
   // Historical Trends hides Quick Filters, so never apply invisible selections there.
@@ -786,6 +803,7 @@ export function InferenceProvider({
       !hasExplicitRunSelection &&
       selectedRunDateRev === 0,
     powerCompare,
+    fixedSequenceStatistic,
   );
 
   // For GPU comparison date picker — use shared availability data from global filters
@@ -1603,6 +1621,7 @@ export function InferenceProvider({
       i_metric: selectedYAxisMetric,
       i_revenue: usesTokenSalePricing(selectedYAxisMetric) ? tokenRevenuePriceSource : 'normalized',
       i_pctl: selectedPercentile,
+      i_mstat: fixedSequenceStatistic,
       i_gpus: selectedGPUs.join(','),
       i_dates: selectedDates.join(','),
       i_dstart: selectedDateRange.startDate,
@@ -1634,6 +1653,7 @@ export function InferenceProvider({
       i_disagg: quickFilterDeployment.join(','),
       i_spec: quickFilterSpec.join(','),
       i_power: quickFilterPower.join(','),
+      i_topology: quickFilterTopologies.join(','),
       i_rulers: iRulersStr,
       i_pcompare: powerCompare === 'none' ? '' : powerCompare,
     },
@@ -1643,6 +1663,7 @@ export function InferenceProvider({
       selectedXAxisMetric,
       selectedE2eXAxisMetric,
       selectedXAxisMode,
+      fixedSequenceStatistic,
       scaleType,
       selectedGPUs,
       selectedDates,
@@ -1667,6 +1688,7 @@ export function InferenceProvider({
       quickFilterDeployment,
       quickFilterSpec,
       quickFilterPower,
+      quickFilterTopologies,
       iRulersStr,
       powerCompare,
     ],
@@ -1883,6 +1905,7 @@ export function InferenceProvider({
       selectedXAxisMetric,
       selectedE2eXAxisMetric,
       selectedXAxisMode,
+      fixedSequenceStatistic,
       scaleType,
       powerCompare,
       isLegendExpanded,
@@ -1909,6 +1932,7 @@ export function InferenceProvider({
       selectedXAxisMetric,
       selectedE2eXAxisMetric,
       selectedXAxisMode,
+      fixedSequenceStatistic,
       scaleType,
       powerCompare,
       isLegendExpanded,
@@ -1942,6 +1966,7 @@ export function InferenceProvider({
     setSelectedYAxisMetric: setSelectedYAxisMetricAndClear,
     setTokenRevenuePriceSource,
     setSelectedPercentile,
+    setFixedSequenceStatistic,
     setSelectedXAxisMetric,
     setSelectedXAxisMode: handleSetXAxisMode,
     setScaleType,
@@ -1951,6 +1976,7 @@ export function InferenceProvider({
     setQuickFilterDeployment,
     setQuickFilterSpec,
     setQuickFilterPower,
+    setQuickFilterTopologies,
     setIsLegendExpanded,
     setHideNonOptimal,
     setShowAllMeasurements,
diff --git a/packages/app/src/components/inference/agentic-point/overlay-sources.ts b/packages/app/src/components/inference/agentic-point/overlay-sources.ts
index 029274f25..377df2e76 100644
--- a/packages/app/src/components/inference/agentic-point/overlay-sources.ts
+++ b/packages/app/src/components/inference/agentic-point/overlay-sources.ts
@@ -1,5 +1,4 @@
 import type { TraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
-import type { Locale } from '@/lib/i18n';
 
 /** One server-metric series that can be drawn over the chip telemetry chart. */
 export interface OverlaySource {
@@ -77,7 +76,3 @@ export function availableOverlaySources(
   if (!metrics) return [];
   return OVERLAY_SOURCES.filter((source) => source.points(metrics).length > 0);
 }
-
-export function overlaySourceLabel(source: OverlaySource, locale: Locale): string {
-  return source.label[locale];
-}
diff --git a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
index 7d56ef9a2..f850c431f 100644
--- a/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
+++ b/packages/app/src/components/inference/agentic-point/power-telemetry-view.tsx
@@ -34,7 +34,7 @@ import {
 import { useGpuMetricsPoint, type GpuMetricSeries } from '@/hooks/api/use-gpu-metrics-point';
 import { useTraceServerMetrics } from '@/hooks/api/use-trace-server-metrics';
 
-import { availableOverlaySources, overlaySourceLabel } from './overlay-sources';
+import { availableOverlaySources } from './overlay-sources';
 import { track } from '@/lib/analytics';
 import { useLocale } from '@/lib/use-locale';
 
@@ -199,7 +199,7 @@ export function PowerTelemetryView({ id, enabled, hardware, serverMetricsEnabled
       ? serverMetrics.startNs / 1e6
       : new Date(selectedSeries.startedAt).getTime();
     return {
-      label: overlaySourceLabel(overlaySource, locale),
+      label: overlaySource.label[locale],
       unit: overlaySource.unit,
       color: overlaySource.color,
       points: toAbsoluteMs(overlaySource.points(serverMetrics), originMs),
@@ -367,7 +367,7 @@ export function PowerTelemetryView({ id, enabled, hardware, serverMetricsEnabled
                   <SelectItem value="none">{t.overlayNone}</SelectItem>
                   {overlaySources.map((source) => (
                     <SelectItem key={source.key} value={source.key}>
-                      {overlaySourceLabel(source, locale)} ({source.unit})
+                      {source.label[locale]} ({source.unit})
                     </SelectItem>
                   ))}
                 </SelectContent>
diff --git a/packages/app/src/components/inference/agentic-point/use-detail-view.ts b/packages/app/src/components/inference/agentic-point/use-detail-view.ts
index b08b3a868..cbdd7a43d 100644
--- a/packages/app/src/components/inference/agentic-point/use-detail-view.ts
+++ b/packages/app/src/components/inference/agentic-point/use-detail-view.ts
@@ -6,14 +6,11 @@ import { useClientSearchParams } from '@/hooks/useClientSearch';
 import { track } from '@/lib/analytics';
 import { replaceClientSearch } from '@/lib/client-navigation';
 
-export type DetailView = 'point' | 'timeline' | 'power' | 'aggregates' | 'logs';
+const DETAIL_VIEWS = ['point', 'timeline', 'power', 'aggregates', 'logs'] as const;
+export type DetailView = (typeof DETAIL_VIEWS)[number];
 
 const isDetailView = (value: string | null): value is DetailView =>
-  value === 'point' ||
-  value === 'timeline' ||
-  value === 'power' ||
-  value === 'aggregates' ||
-  value === 'logs';
+  (DETAIL_VIEWS as readonly string[]).includes(value ?? '');
 
 /** URL-persisted detail view (`?view=`; per-point is the unadorned default). */
 export function useDetailView(): [DetailView, (nextView: DetailView) => void] {
diff --git a/packages/app/src/components/inference/axis-metric-explanations.ts b/packages/app/src/components/inference/axis-metric-explanations.ts
index 5ce643e70..dbfd38030 100644
--- a/packages/app/src/components/inference/axis-metric-explanations.ts
+++ b/packages/app/src/components/inference/axis-metric-explanations.ts
@@ -187,11 +187,11 @@ function provisionedJoules(tokenType: TokenType): MetricExplanation {
 /** Validation-status note appended to every Measured Energy explanation. */
 const MEASURED_TIER_NOTE_EN =
   ' Validated points passed the current PowerX telemetry checks. Historical points are real ' +
-  "older measurements but lack the information needed to confirm today's method; a dotted ring " +
-  'marks them. Filter either status under Quick Filters → Measured Power.';
+  "older measurements but lack the information needed to confirm today's method. Filter either " +
+  'status under Quick Filters → Measured Power.';
 const MEASURED_TIER_NOTE_ZH =
-  '已验证数据点通过了当前 PowerX 遥测检查。历史数据点来自真实的旧版测量，但缺少按当前方法完成验证所需的信息；' +
-  '图表以虚线圆环标记这类数据点。可在快捷筛选的“实测功耗”中按测量状态筛选。';
+  '已验证数据点通过了当前 PowerX 遥测检查。历史数据点来自真实的旧版测量，但缺少按当前方法完成验证所需的信息。' +
+  '可在快捷筛选的“实测功耗”中按测量状态筛选。';
 
 type MeasuredPhase = 'run' | 'prefill' | 'decode';
 
@@ -548,9 +548,15 @@ export const METRIC_EXPLANATIONS: Record<MetricKey, MetricExplanation> = {
  * the percentile prefix. Mirrors the branch logic in `resolveXAxisField` plus
  * the derived agentic x-axis mode handled in `ChartDisplay`.
  */
-export type XAxisKind = 'interactivity' | 'e2eLatency' | 'ttft' | 'e2eNormalizedInteractivity';
+export type XAxisKind =
+  | 'concurrency'
+  | 'interactivity'
+  | 'e2eLatency'
+  | 'ttft'
+  | 'e2eNormalizedInteractivity';
 
 export const X_AXIS_KINDS: readonly XAxisKind[] = [
+  'concurrency',
   'interactivity',
   'e2eLatency',
   'ttft',
@@ -567,11 +573,18 @@ export interface XAxisExplanation {
 }
 
 const zhPctl = (pctl: string | null): string =>
-  pctl === null ? '' : pctl === 'Median' ? '中位' : `${pctl} `;
+  pctl === null ? '' : pctl === 'Median' ? '中位' : pctl === 'Mean' ? '平均' : `${pctl} `;
 
 const enPctl = (pctl: string | null): string => (pctl === null ? '' : `${pctl} `);
 
 export const X_AXIS_EXPLANATIONS: Record<XAxisKind, XAxisExplanation> = {
+  concurrency: {
+    name: { en: () => 'Concurrency', zh: () => '并发数' },
+    description: {
+      en: 'The configured number of concurrent requests in each observed benchmark. This is a load setting, not a higher-is-better score. All observed load points are retained; lines only connect the same serving topology and run.',
+      zh: '每个实测基准配置的并发请求数。这是负载设置，不是越高越好的性能分数。保留全部实测负载点，连线仅连接同一服务拓扑、同一次运行的数据。',
+    },
+  },
   interactivity: {
     name: {
       en: (pctl) => `${enPctl(pctl)}Interactivity (tok/s/user)`,
@@ -581,7 +594,8 @@ export const X_AXIS_EXPLANATIONS: Record<XAxisKind, XAxisExplanation> = {
       en:
         'Interactivity is the rate at which a single user receives generated tokens while the ' +
         'model streams its answer — how quickly new words appear on screen. Higher values feel ' +
-        'snappier; operators trade it against batch throughput.',
+        'snappier; operators trade it against batch throughput. For fixed-sequence Mean, the rate ' +
+        'is 1 divided by mean TPOT in seconds, not the arithmetic mean of per-request rates.',
       zh:
         '交互性（interactivity）指模型流式输出回答时，单个用户接收生成 token 的速率——' +
         '即新内容出现在屏幕上的快慢。数值越高体验越流畅；运营方需要在交互性与批量吞吐量之间权衡。',
@@ -655,6 +669,7 @@ export function resolveXAxisKind(
     isDerivedNormalizedInteractivity: boolean;
   },
 ): XAxisKind {
+  if (opts.xAxisField === 'conc') return 'concurrency';
   if (opts.isDerivedNormalizedInteractivity) return 'e2eNormalizedInteractivity';
   if (opts.xAxisField.endsWith('ttft')) return 'ttft';
   return chartType === 'e2e' ? 'e2eLatency' : 'interactivity';
@@ -663,9 +678,11 @@ export function resolveXAxisKind(
 /**
  * Extract the percentile word from a resolved x-axis label (e.g.
  * "P90 Time To First Token (s)" → "P90"). The chart pipelines always render
- * the percentile prefix in this English form, including on /zh pages.
+ * percentiles in English; fixed-sequence statistics are localized on /zh.
  */
 export function xAxisPercentileFromLabel(xAxisLabel: string): string | null {
+  if (xAxisLabel.startsWith('平均')) return 'Mean';
+  if (xAxisLabel.startsWith('中位')) return 'Median';
   const match = /^(?<pctl>Median|Mean|P\d+(?:\.\d+)?)\s/iu.exec(xAxisLabel);
   if (!match?.groups?.pctl) return null;
   const pctl = match.groups.pctl;
diff --git a/packages/app/src/components/inference/hooks/chart-data-core.ts b/packages/app/src/components/inference/hooks/chart-data-core.ts
index 0851b8040..45d7499aa 100644
--- a/packages/app/src/components/inference/hooks/chart-data-core.ts
+++ b/packages/app/src/components/inference/hooks/chart-data-core.ts
@@ -12,9 +12,15 @@ import { supportsChartTokenMetric, type TokenMetricType } from '@/lib/supplement
  * Chart x-axis variant selected by the dropdown in the Chart panel. The
  * inference provider and ChartDisplay import this single definition.
  */
-export type XAxisMode = 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity';
+export type XAxisMode =
+  | 'ttft'
+  | 'e2e'
+  | 'interactivity'
+  | 'e2e-normalized-interactivity'
+  | 'concurrency';
 
 export const X_AXIS_MODES: readonly XAxisMode[] = [
+  'concurrency',
   'ttft',
   'e2e',
   'interactivity',
@@ -115,7 +121,7 @@ const X_LABEL_STAT_PREFIX_RE = /^(?:Median|Mean|P75|P90|P95|P99(?:\.9)?)\b\s*/iu
  * existing leading statistic word (e.g. the TTFT override's "P90 Time To
  * First Token (s)") or prefixes the percentile when the configured label has
  * none (e.g. "Interactivity (tok/s/user)" → "P90 Interactivity (tok/s/user)").
- * Only call for agentic sequences — fixed-seq labels must stay untouched.
+ * Also used for the explicit Mean/Median labels on fixed-sequence service axes.
  */
 export function applyAgenticPercentileToXLabel(label: string, pctlWord: string): string {
   return X_LABEL_STAT_PREFIX_RE.test(label)
diff --git a/packages/app/src/components/inference/hooks/useChartData.ts b/packages/app/src/components/inference/hooks/useChartData.ts
index 791b14be6..3401a6002 100644
--- a/packages/app/src/components/inference/hooks/useChartData.ts
+++ b/packages/app/src/components/inference/hooks/useChartData.ts
@@ -41,7 +41,10 @@ import {
   EMPTY_QUICK_FILTERS,
   type QuickFilters,
 } from '@/components/inference/utils/quickFilters';
-import { resolveXAxisField } from '@/components/inference/utils/resolveXAxisField';
+import {
+  resolveXAxisField,
+  type FixedSequenceStatistic,
+} from '@/components/inference/utils/resolveXAxisField';
 import { benchmarkQueryOptions, useBenchmarks } from '@/hooks/api/use-benchmarks';
 import type { BenchmarkRow } from '@/lib/api';
 import { benchmarkCurveDate, dedupeAgenticHistoryRuns } from '@/lib/benchmark-run-selection';
@@ -120,6 +123,7 @@ export function useChartData(
   allowDefaultRunPreference = false,
   /** Sibling boundary / role series appended to a gated power metric (`i_pcompare`). */
   powerCompare: PowerCompare = 'none',
+  fixedSequenceStatistic: FixedSequenceStatistic = 'median',
 ) {
   // When the selected date is the latest available, use '' (empty string) to match
   // the initial no-date query key, reusing the eagerly-fetched benchmarks from the
@@ -358,19 +362,24 @@ export function useChartData(
           isAgentic,
           percentile: selectedPercentile,
           xAxisMode: selectedXAxisMode,
+          fixedSequenceStatistic,
         });
         const naturalX = resolved.naturalX as keyof AggDataEntry;
         const xAxisField = resolved.xAxisField as keyof AggDataEntry;
         const { isTtftOverride } = resolved;
 
         const ttftPctl = isTtftOverride ? xAxisField.replace(/_ttft$/u, '') : 'p90';
-        const ttftPctlWord = ttftPctl === 'median' ? 'Median' : ttftPctl.toUpperCase();
+        const ttftPctlWord =
+          ttftPctl === 'median' ? 'Median' : ttftPctl === 'mean' ? 'Mean' : ttftPctl.toUpperCase();
         const ttftLabel = `${ttftPctlWord} Time To First Token (s)`;
         const ttftLabelZh = `${ttftPctlWord} 首 token 延迟 (s)`;
 
         let xAxisLabel = chartDef.x_label;
         let xAxisLabelZh = chartDef.x_labelZh;
-        if (resolved.branch === 'user-input-override') {
+        if (resolved.branch === 'concurrency') {
+          xAxisLabel = 'Concurrency';
+          xAxisLabelZh = '并发数';
+        } else if (resolved.branch === 'user-input-override') {
           const labelKey = `${selectedYAxisMetric}_x_label` as keyof ChartDefinition;
           const labelZhKey = `${selectedYAxisMetric}_x_labelZh` as keyof ChartDefinition;
           if (effectiveXMetric === chartDef[`${selectedYAxisMetric}_x` as keyof ChartDefinition]) {
@@ -402,7 +411,9 @@ export function useChartData(
           : selectedXAxisMode === undefined
             ? (chartDef[headingKey] as string) || chartDef.heading
             : chartDef.heading;
-        if (isAgentic) {
+        if (resolved.branch === 'concurrency') {
+          chartHeading = 'vs. Concurrency';
+        } else if (isAgentic) {
           const pctlWord = selectedPercentile.toUpperCase();
           xAxisLabel = applyAgenticPercentileToXLabel(xAxisLabel, pctlWord);
           xAxisLabelZh = applyAgenticPercentileToXLabel(xAxisLabelZh, pctlWord);
@@ -410,6 +421,22 @@ export function useChartData(
             /^(?<vsPrefix>vs\.\s+)(?:(?:Median|Mean|P75|P90|P95|P99(?:\.9)?)\s+)?/iu,
             `$1${pctlWord} `,
           );
+        } else {
+          const word = xAxisField.startsWith('mean_')
+            ? 'Mean'
+            : xAxisField.startsWith('median_')
+              ? 'Median'
+              : xAxisField.split('_')[0].toUpperCase();
+          const wordZh = word === 'Mean' ? '平均' : '中位';
+          xAxisLabel = applyAgenticPercentileToXLabel(xAxisLabel, word);
+          xAxisLabelZh = applyAgenticPercentileToXLabel(xAxisLabelZh, word).replace(
+            /^(?:Mean|Median)\s+/u,
+            wordZh,
+          );
+          chartHeading = chartHeading.replace(
+            /^(?<vsPrefix>vs\.\s+)(?:(?:Median|Mean|P75|P90|P95|P99(?:\.9)?)\s+)?/iu,
+            `$1${word} `,
+          );
         }
 
         // The x-axis is "flipped" only when the good-direction reverses
@@ -422,11 +449,13 @@ export function useChartData(
           xAxisField !== naturalX && !(chartDef.chartType === 'e2e' && isTtftOverride);
 
         const rooflineOverrides: Partial<ChartDefinition> = {};
-        if (xAxisFlipped) {
+        if (xAxisFlipped || resolved.branch === 'concurrency') {
           for (const key of Object.keys(chartDef) as (keyof ChartDefinition)[]) {
             if (typeof key === 'string' && key.endsWith('_roofline')) {
               const dir = chartDef[key] as string | undefined;
-              if (dir && dir in FLIP_MAP) {
+              if (resolved.branch === 'concurrency') {
+                (rooflineOverrides as any)[key] = undefined;
+              } else if (dir && dir in FLIP_MAP) {
                 (rooflineOverrides as any)[key] = flipRooflineDirection(dir as RooflineDirection);
               }
             }
@@ -489,6 +518,7 @@ export function useChartData(
       selectedXAxisMetric,
       selectedE2eXAxisMetric,
       selectedPercentile,
+      fixedSequenceStatistic,
       selectedSequence,
       tokenRevenuePriceSource,
     ],
diff --git a/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx b/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx
index 88412ce51..4318fa12c 100644
--- a/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx
+++ b/packages/app/src/components/inference/hooks/useChartData.x-axis-wiring.test.tsx
@@ -7,6 +7,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { BenchmarkRow } from '@/lib/api';
 import { Model, Sequence } from '@/lib/data-mappings';
 import { resolveScatterXAxisScale } from '@/components/inference/utils/x-axis-scale';
+import { processOverlayChartData } from '@/components/inference/utils';
+import { transformBenchmarkRows } from '@/lib/benchmark-transform';
 import { buildReplayTimeline } from '@/components/inference/replay/buildReplayTimeline';
 
 const mocks = vi.hoisted(() => ({
@@ -107,9 +109,11 @@ let result: ReturnType<typeof useChartData> | undefined;
 function Probe({
   mode,
   energy = false,
+  statistic = 'median',
   metric = energy ? 'y_measuredPrefillJPerInputToken' : 'y_inputTputPerGpu',
 }: {
   mode?: XAxisMode;
+  statistic?: 'mean' | 'median';
   energy?: boolean;
   metric?: string;
 }) {
@@ -135,6 +139,15 @@ function Probe({
     undefined,
     undefined,
     mode,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    statistic,
   );
   return null;
 }
@@ -154,6 +167,47 @@ afterEach(() => {
 });
 
 describe('useChartData x-axis scale wiring', () => {
+  it.each([
+    ['interactivity', 'interactivity', 'mean_tpot_intvty', 25, 'Mean Interactivity'],
+    ['ttft', 'e2e', 'mean_ttft', 8, 'Mean Time To First Token'],
+    ['e2e', 'e2e', 'mean_e2el', 30, 'Mean End-to-end Latency'],
+  ] as const)(
+    'keeps official, overlay and replay mean %s numerically aligned',
+    (mode, chartType, field, expectedX, label) => {
+      mocks.rows[0].metrics = {
+        ...mocks.rows[0].metrics,
+        mean_tpot: 0.04,
+        mean_intvty: 777,
+        mean_ttft: 8,
+        mean_e2el: 30,
+      };
+      mocks.rows[1].metrics = { ...mocks.rows[1].metrics, mean_intvty: 888 };
+      act(() => root.render(<Probe mode={mode} statistic="mean" metric="y_tpPerGpu" />));
+      const graph = result!.graphs.find((g) => g.chartDefinition.chartType === chartType)!;
+      expect(graph.chartDefinition.x_scale_field).toBe(field);
+      expect(graph.chartDefinition.x_label).toContain(label);
+      expect(graph.chartDefinition.heading).toContain(label);
+      expect(graph.data.map((point) => point.x)).toEqual([expectedX]);
+      expect(graph.data[0].mean_intvty).toBe(777);
+      const { chartData } = transformBenchmarkRows(mocks.rows);
+      const overlay = processOverlayChartData(
+        chartData[chartType === 'interactivity' ? 0 : 1],
+        chartType,
+        'y_tpPerGpu',
+        null,
+        {
+          selectedXAxisMode: mode,
+          fixedSequenceStatistic: 'mean',
+        },
+      );
+      expect(overlay.map((point) => point.x)).toEqual([expectedX]);
+      const replay = buildReplayTimeline(mocks.rows, graph.chartDefinition, 'y_tpPerGpu', null, [
+        'fp8',
+      ]);
+      expect(replay.configs.map((series) => series.template.x)).toEqual([expectedX]);
+    },
+  );
+
   it.each([
     ['interactivity', 'interactivity', 'median_intvty'],
     ['ttft', 'e2e', 'median_ttft'],
@@ -204,8 +258,8 @@ describe('useChartData x-axis scale wiring', () => {
     ]);
     expect(energyGraph?.chartDefinition).toMatchObject({
       x_scale_field: 'median_intvty',
-      x_label: 'Interactivity (tok/s/user)',
-      heading: 'vs. Interactivity',
+      x_label: 'Median Interactivity (tok/s/user)',
+      heading: 'vs. Median Interactivity',
       y_measuredPrefillJPerInputToken_roofline: 'lower_right',
     });
     if (!energyGraph) throw new Error('useChartData did not produce the interactivity graph');
@@ -252,8 +306,8 @@ describe('useChartData x-axis scale wiring', () => {
     expect(graph?.data.map((point) => point.x)).toEqual([12, 12]);
     expect(graph?.chartDefinition).toMatchObject({
       x_scale_field: 'median_e2el',
-      x_label: 'End-to-end Latency (s)',
-      heading: 'vs. End-to-end Latency',
+      x_label: 'Median End-to-end Latency (s)',
+      heading: 'vs. Median End-to-end Latency',
     });
   });
 
diff --git a/packages/app/src/components/inference/hooks/useComparisonSeries.ts b/packages/app/src/components/inference/hooks/useComparisonSeries.ts
new file mode 100644
index 000000000..23df41ecc
--- /dev/null
+++ b/packages/app/src/components/inference/hooks/useComparisonSeries.ts
@@ -0,0 +1,129 @@
+'use client';
+
+import { useMemo } from 'react';
+import { useTheme } from 'next-themes';
+
+import { useInferenceDisplay, useInferenceFilters } from '@/components/inference/InferenceContext';
+import {
+  buildRunNumbering,
+  comparisonEntrySortValue,
+  resolveComparisonEntries,
+} from '@/components/inference/utils/comparisonEntry';
+import { useThemeColors } from '@/hooks/useThemeColors';
+import { getModelSortIndex } from '@/lib/constants';
+import { generateGpuDateColors, generateHighContrastGpuDateColors } from '@/lib/dynamic-colors';
+
+/** One (comparison entry, chip config) series of the date comparison view. */
+export interface ComparisonSeries {
+  date: string;
+  hwKey: string;
+  /** `${date}_${hwKey}`: the key of the `activeDates` toggle set. */
+  id: string;
+  color: string;
+}
+
+/**
+ * Series, run numbers and colours of the date comparison view. GPUGraph and
+ * the Power Timeline share them so one (date, chip config) pair reads the
+ * same in both displays.
+ */
+export function useComparisonSeries(providedRunNumbering?: Map<string, number>) {
+  const { selectedGPUs, selectedDateRange, selectedDates } = useInferenceFilters();
+  const { highContrast } = useInferenceDisplay();
+  const { resolvedTheme } = useTheme();
+
+  // Shared date+GPU pairs. `dates` holds comparison-series entries (plain dates
+  // and/or specific-run entries); a same-day range endpoint is dropped when that
+  // date also has run entries (resolveComparisonEntries), then sorted earliest →
+  // latest so a day's runs read #1 → #N.
+  const gpuDatePairs = useMemo(() => {
+    const deduplicated = resolveComparisonEntries(selectedDates, selectedDateRange);
+    deduplicated.sort((a, b) => {
+      const [ta, ia] = comparisonEntrySortValue(a);
+      const [tb, ib] = comparisonEntrySortValue(b);
+      return ta - tb || ia - ib;
+    });
+    const sortedGPUs = [...selectedGPUs].toSorted(
+      (a, b) => getModelSortIndex(a) - getModelSortIndex(b) || a.localeCompare(b),
+    );
+    return { dates: deduplicated, sortedGPUs };
+  }, [selectedDateRange, selectedDates, selectedGPUs]);
+
+  // Run numbers for legend/line labels. Prefer the stable numbering passed by
+  // the parent (shared with the changelog, so labels match it and removed runs
+  // leave a gap); fall back to gap-free numbering of the on-chart series.
+  const runNumbering = useMemo(
+    () => providedRunNumbering ?? buildRunNumbering(gpuDatePairs.dates),
+    [providedRunNumbering, gpuDatePairs.dates],
+  );
+
+  const graphIdentifiers = useMemo(() => {
+    const ids: string[] = [];
+    gpuDatePairs.sortedGPUs.forEach((gpu) =>
+      gpuDatePairs.dates.forEach((date) => ids.push(`${date}_${gpu}`)),
+    );
+    return ids;
+  }, [gpuDatePairs]);
+
+  // High contrast keys off the GPU (not `date_gpu`) so each hardware config
+  // gets exactly one hue; the dates within a config are separated by the
+  // lightness ramp built below rather than by unrelated hues.
+  const { resolveColor, getCssColor } = useThemeColors({
+    highContrast,
+    identifiers: graphIdentifiers,
+    hcKeys: gpuDatePairs.sortedGPUs,
+  });
+
+  // Dynamic GPU×date color map
+  const gpuDateColorMap = useMemo(() => {
+    const { dates, sortedGPUs } = gpuDatePairs;
+    if (sortedGPUs.length === 0 || dates.length === 0) return {};
+    const theme = resolvedTheme === 'dark' || resolvedTheme === 'minecraft' ? 'dark' : 'light';
+    return generateGpuDateColors(sortedGPUs, dates.length, theme);
+  }, [gpuDatePairs, resolvedTheme]);
+
+  // High-contrast GPU×date color map: one iwanthue hue per GPU, ramped across
+  // the compared dates so a config's runs stay recognisably the same color
+  // while still reading oldest → newest.
+  const hcGpuDateColorMap = useMemo(() => {
+    const { dates, sortedGPUs } = gpuDatePairs;
+    if (!highContrast || sortedGPUs.length === 0 || dates.length === 0) return {};
+    const theme = resolvedTheme === 'dark' || resolvedTheme === 'minecraft' ? 'dark' : 'light';
+    const baseColors: Record<string, string> = {};
+    for (const gpu of sortedGPUs) baseColors[gpu] = getCssColor(resolveColor(gpu));
+    return generateHighContrastGpuDateColors(baseColors, dates.length, theme);
+  }, [gpuDatePairs, highContrast, resolvedTheme, resolveColor, getCssColor]);
+
+  const allGraphs = useMemo(() => {
+    const { dates, sortedGPUs } = gpuDatePairs;
+    const result: ComparisonSeries[] = [];
+    sortedGPUs.forEach((gpu) => {
+      dates.forEach((date, dateIndex) => {
+        const id = `${date}_${gpu}`;
+        const compositeKey = `${dateIndex}_${gpu}`;
+        const dynamicColor = gpuDateColorMap[compositeKey];
+        result.push({
+          date,
+          hwKey: gpu,
+          id,
+          color: highContrast
+            ? hcGpuDateColorMap[compositeKey] || getCssColor(resolveColor(gpu))
+            : dynamicColor || 'var(--foreground)',
+        });
+      });
+    });
+    return result;
+  }, [gpuDatePairs, gpuDateColorMap, hcGpuDateColorMap, highContrast, resolveColor, getCssColor]);
+
+  const paletteIdentity = useMemo(
+    () =>
+      [
+        resolvedTheme ?? 'system',
+        highContrast ? 'high-contrast' : 'standard',
+        ...allGraphs.map(({ id, color }) => `${id}:${color}`),
+      ].join('|'),
+    [resolvedTheme, highContrast, allGraphs],
+  );
+
+  return { gpuDatePairs, runNumbering, allGraphs, paletteIdentity, resolveColor, getCssColor };
+}
diff --git a/packages/app/src/components/inference/hooks/usePowerTraceAction.ts b/packages/app/src/components/inference/hooks/usePowerTraceAction.ts
new file mode 100644
index 000000000..09b559126
--- /dev/null
+++ b/packages/app/src/components/inference/hooks/usePowerTraceAction.ts
@@ -0,0 +1,56 @@
+'use client';
+
+import { useCallback, type RefObject } from 'react';
+
+import { useInferenceActions } from '@/components/inference/InferenceContext';
+import type { InferenceData } from '@/components/inference/types';
+import {
+  POWER_TIMELINE_METRIC_KEY,
+  requestPowerTraceFocus,
+  traceKeyForPoint,
+} from '@/components/inference/utils/powerTimeline';
+import { track } from '@/lib/analytics';
+import type { D3ChartHandle } from '@/lib/d3-chart/D3Chart/types';
+
+/**
+ * "View power trace" on a pinned tooltip (official or overlay point): the
+ * same-tab click stays in-page — remember which trace to emphasise, switch
+ * the metric to the Timeline display, and let the anchor's href keep
+ * serving open-in-new-tab. Listeners are attached per pin because the
+ * tooltip HTML is replaced on every pin.
+ */
+export function usePowerTraceAction(chartRef: RefObject<D3ChartHandle | null>) {
+  const { setSelectedYAxisMetric } = useInferenceActions();
+  return useCallback(
+    (tooltipEl: HTMLElement, d: InferenceData, overlay: boolean) => {
+      const action = tooltipEl.querySelector('[data-action="view-power-trace"]');
+      const traceKey = traceKeyForPoint(d);
+      if (!action || !traceKey) return;
+      action.addEventListener('click', (actionEvent) => {
+        actionEvent.stopPropagation();
+        // Modifier / auxiliary clicks keep the anchor's own behaviour: the
+        // href opens this chart's timeline in a new tab or window.
+        const mouse = actionEvent as MouseEvent;
+        if (
+          mouse.button !== 0 ||
+          mouse.metaKey ||
+          mouse.ctrlKey ||
+          mouse.shiftKey ||
+          mouse.altKey
+        ) {
+          return;
+        }
+        actionEvent.preventDefault();
+        requestPowerTraceFocus(traceKey);
+        chartRef.current?.dismissTooltip();
+        setSelectedYAxisMetric(POWER_TIMELINE_METRIC_KEY);
+        track('inference_power_trace_opened', {
+          hwKey: String(d.hwKey),
+          conc: d.conc,
+          overlay,
+        });
+      });
+    },
+    [chartRef, setSelectedYAxisMetric],
+  );
+}
diff --git a/packages/app/src/components/inference/metric-registry.ts b/packages/app/src/components/inference/metric-registry.ts
index 9687c561d..ee81252d4 100644
--- a/packages/app/src/components/inference/metric-registry.ts
+++ b/packages/app/src/components/inference/metric-registry.ts
@@ -654,8 +654,7 @@ export interface MetricControlGroup {
 /**
  * The runner-telemetry y-axes in the "Measured Energy" control group.
  * Exported (and referenced by the group below, so the two cannot drift) for
- * consumers that treat measured axes specially — the legacy-power point ring,
- * tooltip tier line, and footer legend key.
+ * consumers that treat measured axes specially, such as the tooltip tier line.
  */
 export const MEASURED_ENERGY_METRIC_CONFIG_KEYS = [
   'y_measuredPrefillAvgPower',
@@ -698,7 +697,7 @@ export function isRoleLocalMeasuredEnergyConfigKey(configKey: string): boolean {
  * utility modeled) that share the gated Measured Energy group and its
  * Boundary select. They are kept out of `MEASURED_ENERGY_METRIC_CONFIG_KEYS`
  * on purpose: spec constants and model output carry no telemetry tier, so the
- * legacy-power ring, tier tooltip line, and footer key do not apply to them.
+ * tier tooltip line does not apply to them.
  */
 export const POWER_BASIS_METRIC_CONFIG_KEYS = [
   'y_gpuProvisionedWatts',
diff --git a/packages/app/src/components/inference/types.ts b/packages/app/src/components/inference/types.ts
index cebfb7336..0062297c3 100644
--- a/packages/app/src/components/inference/types.ts
+++ b/packages/app/src/components/inference/types.ts
@@ -6,6 +6,8 @@ import type { Model, Sequence } from '@/lib/data-mappings';
 import type { PowerTier } from '@/lib/power-tier';
 import type { SystemPowerEstimate } from '@/lib/modeled-system-power';
 import type { MetricKey } from './metric-registry';
+import type { FixedSequenceStatistic } from './utils/resolveXAxisField';
+import type { XAxisMode } from './hooks/chart-data-core';
 import type { PowerBasis } from '@/lib/power-basis';
 
 export type { WorkerPower };
@@ -88,6 +90,8 @@ export interface AggDataEntry {
   'p99.9_ttft': number;
   mean_tpot: number;
   mean_intvty: number;
+  /** Reciprocal of finite positive mean TPOT (seconds), not raw mean_intvty. */
+  mean_tpot_intvty?: number;
   median_tpot: number;
   median_intvty: number;
   std_tpot: number;
@@ -641,6 +645,8 @@ export interface QuickFilters {
   spec: SpecMode[];
   /** Measured-power certification tiers (see `@/lib/power-tier`). */
   power: PowerTier[];
+  /** Exact allocation and parallelism identities; absent means no constraint. */
+  topologies?: string[];
 }
 
 /**
@@ -710,9 +716,10 @@ export interface InferenceDisplayContextType {
   openRouterPricingLoading: boolean;
   openRouterPricingError: string | null;
   selectedPercentile: string;
+  fixedSequenceStatistic: FixedSequenceStatistic;
   selectedXAxisMetric: string | null;
   selectedE2eXAxisMetric: string | null;
-  selectedXAxisMode: 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity';
+  selectedXAxisMode: XAxisMode;
   scaleType: 'auto' | 'linear' | 'log';
   /** Comparison series overlaid on a gated power metric (`i_pcompare`). */
   powerCompare: PowerCompare;
@@ -754,10 +761,9 @@ export interface InferenceActionsContextType {
   setSelectedYAxisMetric: (metric: string) => void;
   setTokenRevenuePriceSource: (source: TokenRevenuePriceSource) => void;
   setSelectedPercentile: (percentile: string) => void;
+  setFixedSequenceStatistic: (statistic: FixedSequenceStatistic) => void;
   setSelectedXAxisMetric: (metric: string | null) => void;
-  setSelectedXAxisMode: (
-    mode: 'ttft' | 'e2e' | 'interactivity' | 'e2e-normalized-interactivity',
-  ) => void;
+  setSelectedXAxisMode: (mode: XAxisMode) => void;
   setScaleType: (type: 'auto' | 'linear' | 'log') => void;
   setPowerCompare: (mode: PowerCompare) => void;
   setQuickFilterVendors: (vendors: string[]) => void;
@@ -765,6 +771,7 @@ export interface InferenceActionsContextType {
   setQuickFilterDeployment: (modes: DeploymentMode[]) => void;
   setQuickFilterSpec: (modes: SpecMode[]) => void;
   setQuickFilterPower: (tiers: PowerTier[]) => void;
+  setQuickFilterTopologies: (topologies: string[]) => void;
   setIsLegendExpanded: (expanded: boolean) => void;
   setHideNonOptimal: (hide: boolean) => void;
   setShowAllMeasurements: (show: boolean) => void;
diff --git a/packages/app/src/components/inference/ui/ActiveQuickFilters.tsx b/packages/app/src/components/inference/ui/ActiveQuickFilters.tsx
index 2160444ee..a8f1eda3b 100644
--- a/packages/app/src/components/inference/ui/ActiveQuickFilters.tsx
+++ b/packages/app/src/components/inference/ui/ActiveQuickFilters.tsx
@@ -34,6 +34,7 @@ export function ActiveQuickFilters() {
     else if (category === 'deployment')
       actions.setQuickFilterDeployment(values as DeploymentMode[]);
     else if (category === 'spec') actions.setQuickFilterSpec(values as SpecMode[]);
+    else if (category === 'topologies') actions.setQuickFilterTopologies(values);
     else actions.setQuickFilterPower(values as PowerTier[]);
   };
 
@@ -56,7 +57,7 @@ export function ActiveQuickFilters() {
           onClick={() => {
             setCategory(
               category,
-              quickFilters[category].filter((item) => item !== value),
+              (quickFilters[category] ?? []).filter((item) => item !== value),
             );
             track('inference_quick_filter_removed', { category, value, source: 'result_summary' });
           }}
diff --git a/packages/app/src/components/inference/ui/ChartControls.tsx b/packages/app/src/components/inference/ui/ChartControls.tsx
index 726a6918c..16e03f4c7 100644
--- a/packages/app/src/components/inference/ui/ChartControls.tsx
+++ b/packages/app/src/components/inference/ui/ChartControls.tsx
@@ -58,7 +58,6 @@ import {
 import { useOpenDropdown } from '@/hooks/useOpenDropdown';
 import { ModelArchitectureInfoLink } from './ModelArchitectureInfoLink';
 import { MetricExplanation } from './MetricExplanation';
-import { PowerMetricAvailability } from './PowerMetricAvailability';
 import { MeasuredMetricControls } from './MeasuredMetricControls';
 import {
   changeMeasuredMetricConfig,
@@ -565,29 +564,15 @@ export default function ChartControls({
                   noResultsLabel={locale === 'zh' ? '无结果' : undefined}
                   clearSearchLabel={locale === 'zh' ? '清除搜索' : undefined}
                 />
-                {mounted && !getMeasuredMetricConfig(selectedYAxisMetric) && (
-                  <PowerMetricAvailability
-                    metric={selectedYAxisMetric}
-                    onSelect={handleYAxisMetricChange}
-                  />
-                )}
               </div>
 
               {mounted && getMeasuredMetricConfig(selectedYAxisMetric) && (
-                <>
-                  <MeasuredMetricControls
-                    metric={selectedYAxisMetric}
-                    onChange={handleYAxisMetricChange}
-                    compare={powerCompare}
-                    onCompareChange={setPowerCompare}
-                  />
-                  <div className="col-span-full">
-                    <PowerMetricAvailability
-                      metric={selectedYAxisMetric}
-                      onSelect={handleYAxisMetricChange}
-                    />
-                  </div>
-                </>
+                <MeasuredMetricControls
+                  metric={selectedYAxisMetric}
+                  onChange={handleYAxisMetricChange}
+                  compare={powerCompare}
+                  onCompareChange={setPowerCompare}
+                />
               )}
 
               {tcoVisible && (
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index 7bb22f900..cfc859e7f 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -7,7 +7,6 @@ import { BarChart3, Table2 } from 'lucide-react';
 import chartDefinitions, {
   costTierLabel,
   costTierOptionLabel,
-  isMeasuredEnergyConfigKey,
   isModeledSystemPowerConfigKey,
   metricCostTier,
   tokenMetricTypeForConfigKey,
@@ -31,6 +30,7 @@ import {
 } from '@/components/inference/InferenceContext';
 import { useGlobalFilterSelection } from '@/components/GlobalFilterContext';
 import type {
+  AggDataEntry,
   ChartDefinition,
   HardwareConfig,
   InferenceData,
@@ -45,11 +45,13 @@ import {
   makeRunComparisonEntry,
 } from '@/components/inference/utils/comparisonEntry';
 import { dataRunsForDate } from '@/components/inference/utils/runEnumeration';
+import { resolveServiceField } from '@/components/inference/utils/resolveXAxisField';
 import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
 import { bestSeriesPerSku } from '@/components/inference/utils/best-series-per-sku';
 import InferenceTable from '@/components/inference/ui/InferenceTable';
 import ScatterGraph from '@/components/inference/ui/ScatterGraph';
 import PowerTimeline from '@/components/inference/ui/PowerTimeline';
+import PowerServiceComparison from '@/components/inference/ui/PowerServiceComparison';
 import { Card } from '@/components/ui/card';
 import { ChartButtons } from '@/components/ui/chart-buttons';
 import { ShareButton } from '@/components/ui/share-button';
@@ -98,7 +100,6 @@ import { ATOM_FOOTNOTE_MARKER, AtomEngineFootnote } from '@/components/ui/atom-e
 import { AgenticOptimizationNote } from '@/components/inference/ui/AgenticOptimizationNote';
 import { CacheReuseLink } from '@/components/inference/ui/CacheReuseLink';
 import { OffloadHaloLegendKey } from '@/components/inference/ui/OffloadHaloLegendKey';
-import { LegacyPowerLegendKey } from '@/components/inference/ui/LegacyPowerLegendKey';
 import { ActiveQuickFilters } from '@/components/inference/ui/ActiveQuickFilters';
 import { ResultContext } from '@/components/ui/result-context';
 import { ModelLogo } from '@/components/ui/model-logo';
@@ -213,7 +214,9 @@ function zhHeading(configured: string): string {
   const subjectZh = match?.groups && HEADING_SUBJECT_ZH[match.groups.subject];
   if (!subjectZh) return configured;
   const pctl = match.groups?.pctl;
-  return `vs. ${pctl ? `${pctl} ` : ''}${subjectZh}`;
+  const statisticZh =
+    pctl === 'Mean' ? '平均' : pctl === 'Median' ? '中位' : pctl ? `${pctl} ` : '';
+  return `vs. ${statisticZh}${subjectZh}`;
 }
 
 /** Presentation and data plumbing for trace-derived agentic x-axis modes. */
@@ -312,6 +315,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     selectedXAxisMetric,
     selectedE2eXAxisMetric,
     selectedPercentile,
+    fixedSequenceStatistic,
     selectedXAxisMode,
     tokenRevenuePricing,
     showLineLabels,
@@ -319,13 +323,13 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
   } = useInferenceDisplay();
   const { setSelectedDates, setSelectedDatesFromRunExpansion, setIsLegendExpanded } =
     useInferenceActions();
+  const selectedMeasuredConfig = getMeasuredMetricConfig(selectedYAxisMetric);
   // The metric key carries the power boundary; the caption discloses it for
   // the derived boundaries (there is no separate URL param).
-  const selectedPowerBasis = getMeasuredMetricConfig(selectedYAxisMetric)?.basis;
+  const selectedPowerBasis = selectedMeasuredConfig?.basis;
   // The Measured Power "Timeline" display swaps the scatter body for the
   // per-second telemetry traces (PowerTimeline); table view and captions are
   // unchanged because the metric key aliases the measured average.
-  const selectedMeasuredConfig = getMeasuredMetricConfig(selectedYAxisMetric);
   const isPowerTimeline =
     selectedMeasuredConfig?.family === 'power' && selectedMeasuredConfig.display === 'timeline';
   const selectedBenchmarkType: 'single_turn' | 'agentic_traces' =
@@ -488,6 +492,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
         {
           isAgentic,
           selectedPercentile,
+          fixedSequenceStatistic,
           tcoBasis,
           selectedXAxisMode,
           powerCompare,
@@ -540,6 +545,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     selectedXAxisMetric,
     selectedE2eXAxisMetric,
     selectedPercentile,
+    fixedSequenceStatistic,
     powerCompare,
     selectedXAxisMode,
     tokenRevenuePricing,
@@ -687,6 +693,25 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     },
     [selectedPrecisions, quickFilters, selectedOfficialHwTypes, scopedActiveOverlayHwTypes],
   );
+  // Date comparison (GPUGraph, Timeline): official rows follow the per-date
+  // legend toggles instead of the scatter hardware selection, and unofficial
+  // runs keep the overlay hardware selection. Boundary / role siblings are a
+  // same-run comparison, so neither side draws them here.
+  const visibleDateComparisonRows = useCallback(
+    (officialRows: InferenceData[], overlay: OverlayData | null | undefined) => ({
+      officialRows: officialRows.filter(
+        (point) =>
+          !point.powerVariant &&
+          selectedPrecisions.includes(point.precision) &&
+          matchesQuickFilters(point, quickFilters) &&
+          activeDates.has(`${point.date}_${point.hwKey}`),
+      ),
+      overlayRows: visibleComparisonRows([], overlay).overlayRows.filter(
+        (point) => !point.powerVariant,
+      ),
+    }),
+    [selectedPrecisions, quickFilters, activeDates, visibleComparisonRows],
+  );
 
   if (!loading && error) {
     console.error(error);
@@ -730,6 +755,12 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
   }, [effectiveGraphs, selectedXAxisMode]);
 
   const isAgenticSequence = sequenceKind(selectedSequence) === 'agentic';
+  // Streaming speed at the selected statistic, read by the load-matched PowerX rows.
+  const serviceInteractivityField = resolveServiceField('median_intvty', {
+    isAgentic: isAgenticSequence,
+    percentile: selectedPercentile,
+    fixedSequenceStatistic,
+  });
   const residentPointIds = useMemo(() => {
     if (!isAgenticSequence) return [] as number[];
     const ids = new Set<number>();
@@ -783,7 +814,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
   const derivedSpec = useDerivedXAxis ? DERIVED_X_MODE_SPECS[selectedXAxisMode] : undefined;
 
   const renderableGraphs = useMemo(() => {
-    if (!isAgenticSequence) return visibleGraphs;
+    if (!isAgenticSequence || selectedXAxisMode === 'concurrency') return visibleGraphs;
     if (!derivedMetrics) {
       // Legacy AgentX axes can still render transient/non-persisted rows, which
       // have no ids to request.
@@ -833,6 +864,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
     isAgenticSequence,
     derivedSpec,
     derivedTargetIds.length,
+    selectedXAxisMode,
     visibleGraphs,
     derivedMetrics,
     selectedYAxisMetric,
@@ -872,38 +904,33 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
             const isTimelineMode = Boolean(
               selectedDateRange.startDate && selectedDateRange.endDate && selectedGPUs.length > 0,
             );
-            const replayAvailable = getViewMode(graphIndex) === 'chart' && !isTimelineMode;
+            const replayAvailable =
+              getViewMode(graphIndex) === 'chart' &&
+              !isTimelineMode &&
+              selectedXAxisMode !== 'concurrency';
             // Chart-level notices: the KV-offload halo
             // key, the agentic optimization note, and the ATOM engine
             // footnote. Detected from the same data the chart plots —
             // official points plus any loaded unofficial-run overlay for
             // this chart type — so they moved out of the legend without
             // changing when they appear.
-            // GPU/date comparison renders GPUGraph, which plots official
-            // points only — skip the unofficial overlay there so the footer
-            // can't advertise a halo or ATOM series that isn't on the chart.
+            // GPU/date comparison renders GPUGraph, which plots the loaded
+            // unofficial runs next to the compared dates on every x-axis.
             const isGpuComparison =
               selectedGPUs.length > 0 &&
               ((selectedDateRange.startDate && selectedDateRange.endDate) ||
                 selectedDates.length > 0);
-            const footerOverlay = isGpuComparison
-              ? undefined
-              : selectUnofficialOverlayForMode(
-                  selectedXAxisMode,
-                  graph.chartDefinition.chartType,
-                  overlayDataByChartType,
-                );
+            const footerOverlay = selectUnofficialOverlayForMode(
+              selectedXAxisMode,
+              graph.chartDefinition.chartType,
+              overlayDataByChartType,
+            );
             const footerPoints = [
               ...graph.data,
               ...(footerOverlay?.data ?? []),
               ...(footerOverlay?.clippedData ?? []).map((entry) => entry.point),
             ];
             const hasOffloadHalo = footerPoints.some((point) => point.offload_mode === 'on');
-            // Legacy-power rings render only on Measured Energy axes, so the
-            // key follows the same gate to never advertise an absent ring.
-            const hasLegacyPowerPoints =
-              isMeasuredEnergyConfigKey(selectedYAxisMetric) &&
-              footerPoints.some((point) => point.power_tier === 'legacy');
             const hasAtomSeries = footerPoints.some(
               (point) =>
                 point.framework !== undefined &&
@@ -913,14 +940,13 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
             // here as the footer's last block rather than in the chart subtitle,
             // keeping the result-context header compact.
             const footerNotices =
-              hasOffloadHalo || hasLegacyPowerPoints || isAgenticSequence || hasAtomSeries ? (
+              hasOffloadHalo || isAgenticSequence || hasAtomSeries ? (
                 <>
                   <div
                     data-testid="chart-status-notes"
                     className="flex flex-wrap items-center gap-x-5 gap-y-2"
                   >
                     {hasOffloadHalo && <OffloadHaloLegendKey />}
-                    {hasLegacyPowerPoints && <LegacyPowerLegendKey />}
                     {isAgenticSequence && <AgenticOptimizationNote />}
                     {isAgenticSequence && !minimalChrome && <CacheReuseLink />}
                     {hasAtomSeries && (
@@ -986,9 +1012,6 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                           : undefined
                       }
                       onExportCsv={() => {
-                        const candidateVisibleData = isTimelineMode
-                          ? graph.data.filter((d) => activeDates.has(`${d.date}_${d.hwKey}`))
-                          : graph.data;
                         const overlay = selectUnofficialOverlayForMode(
                           selectedXAxisMode,
                           graph.chartDefinition.chartType,
@@ -997,9 +1020,9 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                         const {
                           officialRows: visibleData,
                           overlayRows: visibleOverlayRowsForExport,
-                        } = isTimelineMode
-                          ? { officialRows: candidateVisibleData, overlayRows: [] }
-                          : visibleComparisonRows(candidateVisibleData, overlay);
+                        } = isGpuComparison
+                          ? visibleDateComparisonRows(graph.data, overlay)
+                          : visibleComparisonRows(graph.data, overlay);
                         const { headers, rows } = inferenceChartToCsv(
                           visibleData,
                           graph.model,
@@ -1053,6 +1076,12 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                               {(() => {
                                 // The timeline's x axis is time, not the scatter x metric.
                                 if (isPowerTimeline) return null;
+                                if (selectedXAxisMode === 'concurrency')
+                                  return locale === 'zh' ? '与并发数的关系' : 'vs. Concurrency';
+                                if (!isAgenticSequence) {
+                                  const heading = String(graph.chartDefinition.heading);
+                                  return locale === 'zh' ? zhHeading(heading) : heading;
+                                }
                                 const xField = graph.chartDefinition.x_scale_field;
                                 if (xField?.endsWith('_ttft')) {
                                   const percentile = xField.replace(/_ttft$/u, '');
@@ -1222,10 +1251,9 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                               ],
                             }
                           : overlay;
-                        const { officialRows, overlayRows } = visibleComparisonRows(
-                          tableOfficialData,
-                          tableOverlay,
-                        );
+                        const { officialRows, overlayRows } = isGpuComparison
+                          ? visibleDateComparisonRows(tableOfficialData, tableOverlay)
+                          : visibleComparisonRows(tableOfficialData, tableOverlay);
                         return (
                           <>
                             {chartCaption}
@@ -1262,6 +1290,8 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                                 locale,
                               )}
                               caption={chartCaption}
+                              comparison={Boolean(isGpuComparison)}
+                              runNumbering={runNumbering}
                             />
                           </div>
                         );
@@ -1278,6 +1308,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                           yLabel={metricLabel(graph.chartDefinition, selectedYAxisMetric, locale)}
                           chartDefinition={graph.chartDefinition}
                           caption={chartCaption}
+                          overlayData={footerOverlay ?? undefined}
                           runNumbering={runNumbering}
                         />
                       ) : (
@@ -1303,6 +1334,30 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                         </div>
                       );
                     })()}
+                    {selectedMeasuredConfig &&
+                      !isPowerTimeline &&
+                      getViewMode(graphIndex) !== 'table' &&
+                      (() => {
+                        const overlay = selectUnofficialOverlayForMode(
+                          selectedXAxisMode,
+                          graph.chartDefinition.chartType,
+                          overlayDataByChartType,
+                        );
+                        const { officialRows, overlayRows } = isGpuComparison
+                          ? visibleDateComparisonRows(graph.data, overlay)
+                          : visibleComparisonRows(graph.data, overlay);
+                        return (
+                          <PowerServiceComparison
+                            chartId={`chart-${graphIndex}`}
+                            contextLabel={`${getModelLabel(selectedModel)} · ${getSequenceLabel(selectedSequence)}`}
+                            data={[...officialRows, ...overlayRows]}
+                            overlayData={overlayRows}
+                            xField={graph.chartDefinition.x_scale_field as keyof AggDataEntry}
+                            xLabel={resolvedXLabel}
+                            interactivityField={serviceInteractivityField}
+                          />
+                        );
+                      })()}
                     <ChartNotices chartId={`chart-${graphIndex}`} notices={footerNotices} />
                     {replayAvailable && !minimalChrome && (
                       <ReplayLauncher
diff --git a/packages/app/src/components/inference/ui/FrontierPointsPanel.tsx b/packages/app/src/components/inference/ui/FrontierPointsPanel.tsx
new file mode 100644
index 000000000..3c2e6aa0a
--- /dev/null
+++ b/packages/app/src/components/inference/ui/FrontierPointsPanel.tsx
@@ -0,0 +1,173 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { Heading } from '@/components/ui/heading';
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
+import { exportToCsv } from '@/lib/csv-export';
+import { overlayRunColor, overlayRunIndex } from '@/lib/overlay-run-style';
+import { useLocale } from '@/lib/use-locale';
+import type { InferenceData } from '../types';
+import { FRONTIER_EXPORT_HEADERS, frontierExportRow } from '../utils/frontier-points';
+import { runAttemptFromUrl, runIdFromUrl } from '../utils/powerTimeline';
+import { pointTopologyKey, topologyLabel } from '../utils/topology-filter';
+
+const STRINGS = {
+  en: {
+    title: 'Frontier points',
+    hardware: 'Hardware',
+    config: 'Configuration',
+    concurrency: 'Conc.',
+    run: 'Run',
+    date: 'Date',
+    attempt: (attempt: number) => `attempt ${attempt}`,
+    unofficial: 'unofficial',
+    noRun: 'No run recorded',
+  },
+  zh: {
+    title: '前沿点',
+    hardware: '硬件',
+    config: '配置',
+    concurrency: '并发',
+    run: '运行',
+    date: '日期',
+    attempt: (attempt: number) => `第 ${attempt} 次尝试`,
+    unofficial: '非官方',
+    noRun: '未记录运行',
+  },
+};
+
+const number = d3.format(',.4~g');
+
+export default function FrontierPointsPanel({
+  chartId,
+  eligible,
+  frontier,
+  xLabel,
+  yLabel,
+  overlayPoints,
+  hardwareLabel,
+  hardwareColor,
+}: {
+  chartId: string;
+  /** Observations that competed: the chart's visible, frontier-eligible points. */
+  eligible: readonly InferenceData[];
+  frontier: readonly InferenceData[];
+  xLabel: string;
+  yLabel: string;
+  overlayPoints: readonly InferenceData[];
+  hardwareLabel: (point: InferenceData) => string;
+  hardwareColor: (point: InferenceData) => string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const { runIndexByUrl } = useUnofficialRun();
+  const overlaySet = useMemo(() => new Set(overlayPoints), [overlayPoints]);
+  const topologies = useMemo(() => [...new Set(eligible.map(pointTopologyKey))], [eligible]);
+  const sectionId = `${chartId}-frontier-points`;
+  const colorOf = (point: InferenceData) =>
+    overlaySet.has(point)
+      ? overlayRunColor(overlayRunIndex(point.run_url, runIndexByUrl))
+      : hardwareColor(point);
+
+  const exportCsv = () => {
+    exportToCsv(
+      'InferenceX_frontier_points',
+      [...FRONTIER_EXPORT_HEADERS, 'unofficial'],
+      frontier.map((point) => [...frontierExportRow(point), overlaySet.has(point)]),
+      [`x: ${xLabel}`, `y: ${yLabel}`],
+    );
+  };
+
+  return (
+    <section
+      id={sectionId}
+      className="mt-4 min-w-0 space-y-3 border-t pt-4"
+      data-testid="frontier-points-panel"
+    >
+      <Heading as="h3" level="card">
+        {t.title}
+      </Heading>
+      <div className="max-h-96 min-w-0 overflow-auto">
+        <table
+          className="w-full min-w-[48rem] table-fixed break-words text-left text-sm"
+          data-testid="frontier-points-table"
+        >
+          <thead className="sticky top-0 bg-background align-bottom">
+            <tr>
+              <th className="w-1/5 p-2">{t.hardware}</th>
+              <th className="w-1/4 p-2">{t.config}</th>
+              <th className="w-16 p-2">{t.concurrency}</th>
+              <th className="p-2">{xLabel}</th>
+              <th className="p-2">{yLabel}</th>
+              <th className="p-2">{t.run}</th>
+              <th className="w-24 p-2">{t.date}</th>
+            </tr>
+          </thead>
+          <tbody>
+            {frontier.map((point, index) => {
+              const runId = runIdFromUrl(point.run_url);
+              const attempt = runAttemptFromUrl(point.run_url);
+              return (
+                <tr
+                  key={`${point.id ?? index}:${point.run_url ?? ''}`}
+                  className="border-t"
+                  data-testid="frontier-points-row"
+                >
+                  <th className="p-2 align-top font-normal">
+                    <span style={{ color: colorOf(point) }}>● </span>
+                    {hardwareLabel(point)}
+                    {overlaySet.has(point) && (
+                      <span className="block text-xs text-muted-foreground">{t.unofficial}</span>
+                    )}
+                  </th>
+                  <td className="p-2 align-top">
+                    {[
+                      point.framework,
+                      point.precision.toUpperCase(),
+                      topologyLabel(pointTopologyKey(point), locale, topologies),
+                    ]
+                      .filter(Boolean)
+                      .join(' · ')}
+                  </td>
+                  <td className="p-2 align-top">{point.conc}</td>
+                  <td className="p-2 align-top">{number(point.x)}</td>
+                  <td className="p-2 align-top">{number(point.y)}</td>
+                  <td className="p-2 align-top">
+                    {point.run_url && runId ? (
+                      <a
+                        href={point.run_url}
+                        target="_blank"
+                        rel="noopener noreferrer"
+                        className="underline decoration-dotted"
+                      >
+                        {`run ${runId}`}
+                      </a>
+                    ) : (
+                      <span className="text-muted-foreground">{t.noRun}</span>
+                    )}
+                    {attempt !== null && (
+                      <span className="block text-xs text-muted-foreground">
+                        {t.attempt(attempt)}
+                      </span>
+                    )}
+                  </td>
+                  <td className="p-2 align-top">{point.actualDate ?? point.date}</td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </table>
+      </div>
+      <ChartButtons
+        chartId={sectionId}
+        analyticsPrefix="frontier_points"
+        hideZoomReset
+        hideImageExport
+        onExportCsv={exportCsv}
+      />
+    </section>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/GPUGraph.tsx b/packages/app/src/components/inference/ui/GPUGraph.tsx
index ac17588d9..ce2e49416 100644
--- a/packages/app/src/components/inference/ui/GPUGraph.tsx
+++ b/packages/app/src/components/inference/ui/GPUGraph.tsx
@@ -9,7 +9,6 @@ import { rememberChartStateInUrl } from '@/lib/url-state';
 import * as d3 from 'd3';
 import dynamic from 'next/dynamic';
 import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
-import { useTheme } from 'next-themes';
 
 import {
   useInferenceActions,
@@ -20,17 +19,21 @@ import {
 import ChartLegend from '@/components/ui/chart-legend';
 import { Button } from '@/components/ui/button';
 import { OFFICIAL_PREVIEW_SERIES } from '@/components/official-preview-notice';
-import { getHardwareConfig, getModelSortIndex, hardwareKeyMatchesAnyBase } from '@/lib/constants';
-import { getInferenceHardwareConfig } from '@/lib/inference-labels';
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
+import { getHardwareConfig, hardwareKeyMatchesAnyBase } from '@/lib/constants';
+import {
+  getInferenceHardwareConfig,
+  getInferenceRunLabel,
+  getOverlayLineLabel,
+} from '@/lib/inference-labels';
 import { getChartWatermark, Sequence } from '@/lib/data-mappings';
-import { generateGpuDateColors, generateHighContrastGpuDateColors } from '@/lib/dynamic-colors';
 import { useLocale } from '@/lib/use-locale';
 import { formatNumber, getDisplayLabel, updateRepoUrl } from '@/lib/utils';
-import { useThemeColors } from '@/hooks/useThemeColors';
 import { perfRulerAxisMetricKey, usePerfRulerAxisReset } from '@/hooks/usePerfRulerAxisReset';
 import { useTraceAvailability } from '@/hooks/api/use-trace-availability';
 import { useLogAvailability } from '@/hooks/api/use-log-availability';
 import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import { CHART_TYPE, px } from '@/lib/d3-chart/typography';
 import type {
   CustomLayerConfig,
   D3ChartHandle,
@@ -43,8 +46,20 @@ import {
   applyNormalState,
   formatLargeNumber,
   getShapeKeyForPrecision,
+  HIT_AREA_RADIUS,
   logTickFormat,
 } from '@/lib/chart-rendering';
+import { computeTooltipPosition } from '@/lib/d3-chart/layers/scatter-points';
+import {
+  attachOverlayXMarkerHandlers,
+  overlayMarkerPosition,
+  xMarkerPath,
+} from '@/lib/d3-chart/overlay-x-marker';
+import {
+  overlayRooflineDasharray,
+  overlayRunColor,
+  overlayRunIndex,
+} from '@/lib/overlay-run-style';
 import type { ParetoDirection } from '@/lib/chart-utils';
 import {
   chartFrontier,
@@ -58,13 +73,15 @@ import type {
   InferenceData,
   ScatterGraphProps,
 } from '@/components/inference/types';
+import { comparisonEntryLabel } from '@/components/inference/utils/comparisonEntry';
+import { groupConcurrencySeries } from '@/components/inference/utils/concurrency-series';
+import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
 import {
-  buildRunNumbering,
-  comparisonEntryLabel,
-  comparisonEntrySortValue,
-  resolveComparisonEntries,
-} from '@/components/inference/utils/comparisonEntry';
-import { generateGPUGraphTooltipContent } from '@/components/inference/utils/tooltipUtils';
+  generateGPUGraphTooltipContent,
+  generateOverlayTooltipContent,
+} from '@/components/inference/utils/tooltipUtils';
+import { useComparisonSeries } from '@/components/inference/hooks/useComparisonSeries';
+import { usePowerTraceAction } from '@/components/inference/hooks/usePowerTraceAction';
 import { pointLabelText } from '@/components/inference/ui/point-label';
 import { scatterPointConfigId } from '@/components/inference/utils/point-identity';
 import {
@@ -73,7 +90,6 @@ import {
 } from '@/components/inference/utils/knownIssueAnnotations';
 import { matchKnownConfigIssues, pointMatchesIssue } from '@/lib/known-issues';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
-import { renderLegacyPowerRing } from '@/components/inference/utils/legacy-power-marker';
 import {
   isMeasuredEnergyConfigKey,
   isRoleLocalMeasuredEnergyConfigKey,
@@ -98,10 +114,6 @@ import {
   type PerfRulerRenderEntry,
   type PerfRulerState,
 } from '@/lib/d3-chart/layers/perf-ruler';
-import {
-  countPowerTiers,
-  MeasuredPowerSummary,
-} from '@/components/inference/ui/MeasuredPowerSummary';
 import {
   keepPointLabelsInPlot,
   parallelismLabelBoxes,
@@ -129,10 +141,14 @@ const FixedSequenceLogDialog = dynamic(() =>
 const CHART_MARGIN = { top: 24, right: 10, bottom: 60, left: 60 };
 
 // Roofline paths in this chart carry the class `roofline-<key>` where key is
-// `${date}_${hwKey}_${precision}` (see `renderRooflines`). The perf ruler
-// identifies curves by that class token.
+// `${seriesId}_${precision}` (see `renderRooflines`); a concurrency sweep adds
+// a `__<segment>` suffix. The perf ruler identifies curves by that class token.
 const ROOFLINE_CLASS_PREFIX = 'roofline-';
 
+// Series id of an unofficial run: `overlay-run<index>_<hwKey>`. Official series
+// ids are `${date}_${hwKey}`, the `activeDates` key.
+const OVERLAY_SERIES_PREFIX = 'overlay-run';
+
 // Scales as currently drawn: the base render scales rescaled through the
 // active zoom transform (identity when the chart is not zoomed).
 const currentZoomRenderContext = (svg: SVGSVGElement, ctx: RenderContext): RenderContext => {
@@ -149,11 +165,14 @@ const currentZoomRenderContext = (svg: SVGSVGElement, ctx: RenderContext): Rende
 // both dimensions of the GPU comparison view are legible on the chart,
 // not only the legend. Falls back to the raw hwKey if the config
 // lookup misses (legacy data).
-function labelTextFor(pts: InferenceData[], numbering: Map<string, number>): string {
+function hardwareLabelFor(pts: InferenceData[]): string {
   const hwKey = String(pts[0].hwKey);
   const cfg = getInferenceHardwareConfig(hwKey, pts[0].model, pts);
-  const hwLabel = cfg ? getDisplayLabel(cfg) : hwKey;
-  return `${hwLabel} • ${comparisonEntryLabel(String(pts[0].date), numbering)}`;
+  return cfg ? getDisplayLabel(cfg) : hwKey;
+}
+
+function labelTextFor(pts: InferenceData[], numbering: Map<string, number>): string {
+  return `${hardwareLabelFor(pts)} • ${comparisonEntryLabel(String(pts[0].date), numbering)}`;
 }
 
 const GPU_STRINGS = {
@@ -164,10 +183,6 @@ const GPU_STRINGS = {
     showAllMeasurements: 'Show all measurements',
     powerBoundaryInfo:
       'Show only points on the upper measured power boundary. Turn off to show all measurements; the boundary stays the same. This is a power-load boundary, not an energy-efficiency frontier.',
-    powerCurves:
-      'Smooth lines trace the upper power boundary across tested configurations. Dots are measured; lines are interpolated, not efficiency frontiers.',
-    powerOptimal:
-      'A power Pareto frontier can contain a single point. Turn off Optimal Only to show the upper power boundary.',
     labels: 'Labels',
     parallelismLabels: 'Parallelism Labels',
     concurrencyLabels: '# Concurrent Sessions',
@@ -182,6 +197,9 @@ const GPU_STRINGS = {
     noDataHint: 'Please change the model, sequence, precision, date range or chip selection.',
     noRoleEnergyDataHint:
       'This dataset does not report role-level prefill/decode energy. Choose a different model, scenario, precision, date, or measured-energy metric.',
+    noMeasuredDataHint:
+      'No measured GPU power is reported for this selection. Choose other chip configs, or a different model, scenario, precision or date.',
+    unofficialTitle: (branch: string) => `UNOFFICIAL: ${branch}`,
   },
   zh: {
     logScale: '对数缩放',
@@ -190,9 +208,6 @@ const GPU_STRINGS = {
     showAllMeasurements: '显示全部测量点',
     powerBoundaryInfo:
       '仅显示实测功率上边界上的点。关闭后显示全部测量点，边界曲线保持不变。这是功率负载边界，不是能效前沿。',
-    powerCurves:
-      '平滑曲线勾勒各测试配置的功耗上边界。数据点来自实测，曲线通过插值得到，不代表能效 Pareto 前沿。',
-    powerOptimal: '功耗的 Pareto 前沿可能只有一个点。关闭“仅最优”即可查看功耗上边界。',
     labels: '标签',
     parallelismLabels: '并行配置标签',
     concurrencyLabels: '并发会话数',
@@ -207,6 +222,9 @@ const GPU_STRINGS = {
     noDataHint: '请调整模型、序列长度、精度、日期范围或芯片选项。',
     noRoleEnergyDataHint:
       '当前数据集未提供 Prefill/Decode 各角色的能耗数据。请选择其他模型、场景、精度、日期或实测能耗指标。',
+    noMeasuredDataHint:
+      '当前选择没有实测 GPU 功耗数据。请选择其他芯片配置，或更换模型、场景、精度或日期。',
+    unofficialTitle: (branch: string) => `非官方：${branch}`,
   },
 } as const;
 
@@ -219,6 +237,7 @@ const GPUGraph = React.memo(
     yLabel,
     chartDefinition,
     caption,
+    overlayData,
     runNumbering: providedRunNumbering,
   }: ScatterGraphProps) => {
     const { hardwareConfig } = useInferenceData();
@@ -264,6 +283,7 @@ const GPUGraph = React.memo(
       setQuickFilterDeployment,
       setQuickFilterSpec,
       setQuickFilterPower,
+      setQuickFilterTopologies,
     } = useInferenceActions();
     const locale = useLocale();
     const featureGateUnlocked = useFeatureGate();
@@ -272,20 +292,26 @@ const GPUGraph = React.memo(
     const showPowerTelemetryRef = useRef(showPowerTelemetry);
     showPowerTelemetryRef.current = showPowerTelemetry;
     const legendT = GPU_STRINGS[locale];
-    const frontierDirection = chartDefinition[
-      `${selectedYAxisMetric}_roofline` as keyof ChartDefinition
-    ] as ParetoDirection | undefined;
+    // The Concurrency axis plots observed load sweeps: no frontier, power
+    // envelope or perf ruler, same as ScatterGraph.
+    const isConcurrencyAxis = chartDefinition.x_scale_field === 'conc';
+    const frontierDirection = isConcurrencyAxis
+      ? undefined
+      : (chartDefinition[`${selectedYAxisMetric}_roofline` as keyof ChartDefinition] as
+          | ParetoDirection
+          | undefined);
     const hideNonOptimal = Boolean(frontierDirection) && savedHideNonOptimal;
     const powerCurveMetric = isPowerCurveMetric(selectedYAxisMetric);
     const isMeasuredPowerAxis = isMeasuredPowerCurveMetric(selectedYAxisMetric);
-    const powerEnvelopeMode = powerCurveMetric && (isMeasuredPowerAxis || !hideNonOptimal);
+    const powerEnvelopeMode =
+      !isConcurrencyAxis && powerCurveMetric && (isMeasuredPowerAxis || !hideNonOptimal);
     const showAllMeasurements = isMeasuredPowerAxis ? !hideNonOptimal : savedShowAllMeasurements;
-    const isMeasuredEnergyAxis = isMeasuredEnergyConfigKey(selectedYAxisMetric);
     const noDataHint = isRoleLocalMeasuredEnergyConfigKey(selectedYAxisMetric)
       ? legendT.noRoleEnergyDataHint
-      : legendT.noDataHint;
+      : isMeasuredEnergyConfigKey(selectedYAxisMetric)
+        ? legendT.noMeasuredDataHint
+        : legendT.noDataHint;
     const ephemeralUrlState = useEphemeralUrlState();
-    const { resolvedTheme } = useTheme();
     const chartRef = useRef<D3ChartHandle>(null);
     const [quickFiltersOpen, setQuickFiltersOpen] = useState(false);
     // A framework lock (embed routes) is not a user filter, so it is not counted.
@@ -294,6 +320,7 @@ const GPUGraph = React.memo(
       (lockedFrameworks ? 0 : quickFilters.frameworks.length) +
       quickFilters.deployment.length +
       quickFilters.power.length +
+      (quickFilters.topologies?.length ?? 0) +
       (selectedSequence === Sequence.AgenticTraces ? 0 : quickFilters.spec.length);
     const clearQuickFilters = useCallback(() => {
       setQuickFilterVendors([]);
@@ -301,37 +328,49 @@ const GPUGraph = React.memo(
       setQuickFilterDeployment([]);
       setQuickFilterSpec([]);
       setQuickFilterPower([]);
+      setQuickFilterTopologies([]);
     }, [
       setQuickFilterVendors,
       setQuickFilterFrameworks,
       setQuickFilterDeployment,
       setQuickFilterSpec,
       setQuickFilterPower,
+      setQuickFilterTopologies,
     ]);
 
-    // Shared date+GPU pairs. `dates` holds comparison-series entries (plain dates
-    // and/or specific-run entries); a same-day range endpoint is dropped when that
-    // date also has run entries (resolveComparisonEntries), then sorted earliest →
-    // latest so a day's runs read #1 → #N.
-    const gpuDatePairs = useMemo(() => {
-      const deduplicated = resolveComparisonEntries(selectedDates, selectedDateRange);
-      deduplicated.sort((a, b) => {
-        const [ta, ia] = comparisonEntrySortValue(a);
-        const [tb, ib] = comparisonEntrySortValue(b);
-        return ta - tb || ia - ib;
-      });
-      const sortedGPUs = [...selectedGPUs].toSorted(
-        (a, b) => getModelSortIndex(a) - getModelSortIndex(b) || a.localeCompare(b),
-      );
-      return { dates: deduplicated, sortedGPUs };
-    }, [selectedDateRange, selectedDates, selectedGPUs]);
-
-    // Run numbers for legend/line labels. Prefer the stable numbering passed by
-    // the parent (shared with the changelog, so labels match it and removed runs
-    // leave a gap); fall back to gap-free numbering of the on-chart series.
-    const runNumbering = useMemo(
-      () => providedRunNumbering ?? buildRunNumbering(gpuDatePairs.dates),
-      [providedRunNumbering, gpuDatePairs.dates],
+    const { runNumbering, allGraphs, paletteIdentity, resolveColor, getCssColor } =
+      useComparisonSeries(providedRunNumbering);
+
+    // Unofficial runs stay on this chart as their own (run, chip config)
+    // series in the run's colour, next to the compared dates. Same gates as
+    // ScatterGraph: precision, quick filters and overlay hardware selection;
+    // dismissing a run removes its rows from `overlayData`.
+    const { runIndexByUrl, unofficialRunInfos, activeOverlayHwTypes } = useUnofficialRun();
+    const overlayPoints = useMemo(
+      () =>
+        (overlayData?.data ?? []).filter(
+          (point) =>
+            // Boundary / role siblings are a same-run comparison (see ChartDisplay).
+            !point.powerVariant &&
+            selectedPrecisions.includes(point.precision) &&
+            matchesQuickFilters(point, quickFilters) &&
+            activeOverlayHwTypes.has(String(point.hwKey)),
+        ),
+      [overlayData, selectedPrecisions, quickFilters, activeOverlayHwTypes],
+    );
+    const overlayPointSet = useMemo(() => new Set(overlayPoints), [overlayPoints]);
+    const overlayRunOf = useCallback(
+      (point: InferenceData) => overlayRunIndex(point.run_url ?? null, runIndexByUrl),
+      [runIndexByUrl],
+    );
+    const overlaySeriesId = useCallback(
+      (point: InferenceData) => `${OVERLAY_SERIES_PREFIX}${overlayRunOf(point)}_${point.hwKey}`,
+      [overlayRunOf],
+    );
+    const seriesIdOf = useCallback(
+      (point: InferenceData) =>
+        overlayPointSet.has(point) ? overlaySeriesId(point) : `${point.date}_${point.hwKey}`,
+      [overlayPointSet, overlaySeriesId],
     );
 
     // Removing a series from the legend should also drop it from the comparison
@@ -351,94 +390,24 @@ const GPUGraph = React.memo(
       [selectedGPUs, selectedDates, setSelectedDates, removeActiveDate],
     );
 
-    const graphIdentifiers = useMemo(() => {
-      const ids: string[] = [];
-      gpuDatePairs.sortedGPUs.forEach((gpu) =>
-        gpuDatePairs.dates.forEach((date) => ids.push(`${date}_${gpu}`)),
-      );
-      return ids;
-    }, [gpuDatePairs]);
-
-    // High contrast keys off the GPU (not `date_gpu`) so each hardware config
-    // gets exactly one hue; the dates within a config are separated by the
-    // lightness ramp built below rather than by unrelated hues.
-    const { resolveColor, getCssColor } = useThemeColors({
-      highContrast,
-      identifiers: graphIdentifiers,
-      hcKeys: gpuDatePairs.sortedGPUs,
-    });
-
-    // Dynamic GPU×date color map
-    const gpuDateColorMap = useMemo(() => {
-      const { dates, sortedGPUs } = gpuDatePairs;
-      if (sortedGPUs.length === 0 || dates.length === 0) return {};
-      const theme = resolvedTheme === 'dark' || resolvedTheme === 'minecraft' ? 'dark' : 'light';
-      return generateGpuDateColors(sortedGPUs, dates.length, theme);
-    }, [gpuDatePairs, resolvedTheme]);
-
-    // High-contrast GPU×date color map: one iwanthue hue per GPU, ramped across
-    // the compared dates so a config's runs stay recognisably the same color
-    // while still reading oldest → newest.
-    const hcGpuDateColorMap = useMemo(() => {
-      const { dates, sortedGPUs } = gpuDatePairs;
-      if (!highContrast || sortedGPUs.length === 0 || dates.length === 0) return {};
-      const theme = resolvedTheme === 'dark' || resolvedTheme === 'minecraft' ? 'dark' : 'light';
-      const baseColors: Record<string, string> = {};
-      for (const gpu of sortedGPUs) baseColors[gpu] = getCssColor(resolveColor(gpu));
-      return generateHighContrastGpuDateColors(baseColors, dates.length, theme);
-    }, [gpuDatePairs, highContrast, resolvedTheme, resolveColor, getCssColor]);
-
-    const allGraphs = useMemo(() => {
-      const { dates, sortedGPUs } = gpuDatePairs;
-      const result: { date: string; color: string; hwKey: string; id: string }[] = [];
-      sortedGPUs.forEach((gpu) => {
-        dates.forEach((date, dateIndex) => {
-          const id = `${date}_${gpu}`;
-          const compositeKey = `${dateIndex}_${gpu}`;
-          const dynamicColor = gpuDateColorMap[compositeKey];
-          result.push({
-            date,
-            hwKey: gpu,
-            id,
-            color: highContrast
-              ? hcGpuDateColorMap[compositeKey] || getCssColor(resolveColor(gpu))
-              : dynamicColor || 'var(--foreground)',
-          });
-        });
+    const groupedData = useMemo(() => {
+      const groups: Record<string, InferenceData[]> = {};
+      const add = (point: InferenceData) => {
+        const key = `${seriesIdOf(point)}_${point.precision}`;
+        (groups[key] ??= []).push(point);
+      };
+      data.forEach((point) => {
+        if (selectedPrecisions.includes(point.precision)) add(point);
       });
-      return result;
-    }, [gpuDatePairs, gpuDateColorMap, hcGpuDateColorMap, highContrast, resolveColor, getCssColor]);
-
-    const paletteIdentity = useMemo(
-      () =>
-        [
-          resolvedTheme ?? 'system',
-          highContrast ? 'high-contrast' : 'standard',
-          ...allGraphs.map(({ id, color }) => `${id}:${color}`),
-        ].join('|'),
-      [resolvedTheme, highContrast, allGraphs],
-    );
-
-    const groupedData = useMemo(
-      () =>
-        data.reduce(
-          (acc, point) => {
-            if (!selectedPrecisions.includes(point.precision)) return acc;
-            const key = `${point.date}_${point.hwKey}_${point.precision}`;
-            if (!acc[key]) acc[key] = [];
-            acc[key].push(point);
-            return acc;
-          },
-          {} as Record<string, InferenceData[]>,
-        ),
-      [data, selectedPrecisions],
-    );
+      overlayPoints.forEach(add);
+      return groups;
+    }, [data, selectedPrecisions, overlayPoints, seriesIdOf]);
 
     // Track which date+GPU combos have actual data points
     const idsWithData = useMemo(() => {
       const ids = new Set<string>();
       for (const key of Object.keys(groupedData)) {
-        // key = "date_hwKey_precision" — strip last segment
+        // key = "seriesId_precision" — strip last segment
         const lastUnderscore = key.lastIndexOf('_');
         ids.add(key.slice(0, lastUnderscore));
       }
@@ -456,6 +425,17 @@ const GPUGraph = React.memo(
     }, [groupedData, frontierDirection]);
 
     const rooflines = useMemo(() => {
+      // One path per observed load sweep, never joined across runs or
+      // topologies (see groupConcurrencySeries).
+      if (isConcurrencyAxis) {
+        const result: Record<string, InferenceData[]> = {};
+        for (const [key, points] of Object.entries(groupedData)) {
+          for (const [segment, sweep] of groupConcurrencySeries(points)) {
+            result[`${key}__${encodeURIComponent(segment)}`] = sweep;
+          }
+        }
+        return result;
+      }
       if (!powerEnvelopeMode) return paretoRooflines;
       const result: Record<string, InferenceData[]> = {};
       for (const [key, points] of Object.entries(groupedData)) {
@@ -467,6 +447,7 @@ const GPUGraph = React.memo(
       }
       return result;
     }, [
+      isConcurrencyAxis,
       powerEnvelopeMode,
       groupedData,
       paretoRooflines,
@@ -474,54 +455,60 @@ const GPUGraph = React.memo(
       selectedYAxisMetric,
     ]);
 
+    const boundaryKeyOf = useCallback(
+      (p: InferenceData) => `${seriesIdOf(p)}_${p.precision}-${p.x}-${p.y}`,
+      [seriesIdOf],
+    );
     const boundaryPointKeys = useMemo(() => {
       const keys = new Set<string>();
-      Object.values(rooflines).forEach((pts) =>
-        pts.forEach((p) => keys.add(`${p.date}_${p.hwKey}_${p.precision}-${p.x}-${p.y}`)),
-      );
+      Object.values(rooflines).forEach((pts) => pts.forEach((p) => keys.add(boundaryKeyOf(p))));
       return keys;
-    }, [rooflines]);
+    }, [rooflines, boundaryKeyOf]);
 
+    // Unofficial runs are not date series: the `activeDates` toggles leave them on.
     const activeData = useMemo(
       () =>
         Object.values(groupedData)
           .flat()
-          .filter((p) => activeDates.has(`${p.date}_${p.hwKey}`)),
-      [groupedData, activeDates],
+          .filter((p) => overlayPointSet.has(p) || activeDates.has(`${p.date}_${p.hwKey}`)),
+      [groupedData, activeDates, overlayPointSet],
     );
 
     const filteredData = useMemo(() => {
       if (hideNonOptimal || (powerEnvelopeMode && !showAllMeasurements))
-        return activeData.filter((p) =>
-          boundaryPointKeys.has(`${p.date}_${p.hwKey}_${p.precision}-${p.x}-${p.y}`),
-        );
+        return activeData.filter((p) => boundaryPointKeys.has(boundaryKeyOf(p)));
       return activeData;
-    }, [activeData, hideNonOptimal, powerEnvelopeMode, showAllMeasurements, boundaryPointKeys]);
+    }, [
+      activeData,
+      hideNonOptimal,
+      powerEnvelopeMode,
+      showAllMeasurements,
+      boundaryPointKeys,
+      boundaryKeyOf,
+    ]);
+    // Official points join the scatter layer; unofficial ones draw as X markers.
+    const officialPoints = useMemo(
+      () => filteredData.filter((point) => !overlayPointSet.has(point)),
+      [filteredData, overlayPointSet],
+    );
+    const visibleOverlayPoints = useMemo(
+      () => filteredData.filter((point) => overlayPointSet.has(point)),
+      [filteredData, overlayPointSet],
+    );
 
     // Keep domains fixed so revealing off-boundary dots cannot move power curves.
     const scaleData = powerEnvelopeMode ? activeData : filteredData;
 
-    const powerTierCounts = useMemo(
-      () => ({
-        total: countPowerTiers(
-          data.filter((point) => selectedPrecisions.includes(point.precision)),
-        ),
-        visible: countPowerTiers(filteredData),
-      }),
-      [data, filteredData, selectedPrecisions],
-    );
-
-    // GPU comparison currently renders official DB-backed points only. Unofficial
-    // overlays have no benchmark_results id or persisted trace, so they cannot
-    // open the dedicated per-point charts route.
+    // Only official DB-backed points have a benchmark_results id, a persisted
+    // trace and logs; unofficial overlays cannot open those routes.
     const agenticIds = useMemo(
       () =>
-        filteredData.flatMap((point) =>
+        officialPoints.flatMap((point) =>
           point.benchmark_type === 'agentic_traces' && isPersistedBenchmarkId(point.id)
             ? [point.id]
             : [],
         ),
-      [filteredData],
+      [officialPoints],
     );
     const { data: traceAvailability } = useTraceAvailability(agenticIds);
     const traceAvailabilityRef = useRef(traceAvailability);
@@ -530,8 +517,8 @@ const GPUGraph = React.memo(
     // Log availability applies to every persisted official point in the
     // comparison, including fixed-sequence runs.
     const persistedPointIds = useMemo(
-      () => filteredData.flatMap((point) => (isPersistedBenchmarkId(point.id) ? [point.id] : [])),
-      [filteredData],
+      () => officialPoints.flatMap((point) => (isPersistedBenchmarkId(point.id) ? [point.id] : [])),
+      [officialPoints],
     );
     const { data: logAvailability } = useLogAvailability(persistedPointIds);
     const logAvailabilityRef = useRef(logAvailability);
@@ -539,10 +526,10 @@ const GPUGraph = React.memo(
     const [fixedLogPointId, setFixedLogPointId] = useState<number | null>(null);
     const [powerTelemetryPoint, setPowerTelemetryPoint] = useState<InferenceData | null>(null);
 
-    // Warning annotations for visible series with known upstream issues —
-    // same treatment the scatter view gets, applied to the date-comparison view.
-    // Lines here are colored per (gpu, date) pair, so take the first active
-    // pair's color as the series swatch.
+    // Warning annotations for visible series (official and unofficial) with
+    // known upstream issues — same treatment the scatter view gets. Lines here
+    // are colored per (gpu, date) pair, so take the first active pair's color
+    // as the series swatch. Official-preview notices follow official data only.
     const knownIssueAnnotations = useMemo((): KnownIssueAnnotation[] => {
       const annotations: KnownIssueAnnotation[] = matchKnownConfigIssues(
         modelLabel,
@@ -562,7 +549,7 @@ const GPUGraph = React.memo(
         };
       });
       for (const previewConfig of OFFICIAL_PREVIEW_SERIES) {
-        const previewPoints = filteredData.filter((point) =>
+        const previewPoints = officialPoints.filter((point) =>
           hardwareKeyMatchesAnyBase(String(point.hwKey), previewConfig.baseGpuKeys),
         );
         if (previewPoints.length === 0) continue;
@@ -584,7 +571,16 @@ const GPUGraph = React.memo(
         });
       }
       return annotations;
-    }, [modelLabel, filteredData, allGraphs, activeDates, resolveColor, getCssColor, locale]);
+    }, [
+      modelLabel,
+      filteredData,
+      officialPoints,
+      allGraphs,
+      activeDates,
+      resolveColor,
+      getCssColor,
+      locale,
+    ]);
 
     const knownIssueLayer = useMemo(
       () =>
@@ -629,13 +625,16 @@ const GPUGraph = React.memo(
       return [yMin, yExtent[1] * 1.05] as [number, number];
     }, [scaleData, logScale]);
 
+    const pointIdentity = useCallback(
+      (point: InferenceData) =>
+        overlayPointSet.has(point)
+          ? `overlay:${overlaySeriesId(point)}:${scatterPointConfigId(point)}`
+          : `${point.date}:${scatterPointConfigId(point)}`,
+      [overlayPointSet, overlaySeriesId],
+    );
     const dataIdentity = useMemo(
-      () =>
-        filteredData
-          .map((point) => `${point.date}:${scatterPointConfigId(point)}`)
-          .toSorted()
-          .join('|'),
-      [filteredData],
+      () => filteredData.map(pointIdentity).toSorted().join('|'),
+      [filteredData, pointIdentity],
     );
     // Tooltip-only trace availability is deliberately excluded from chart
     // identity; the long-lived D3 content callback reads its latest value via
@@ -649,9 +648,7 @@ const GPUGraph = React.memo(
           powerEnvelopeMode ? 'power-envelope' : 'pareto-curves',
           `linear:${xExtent.join(',')}`,
           `${logScale ? 'log' : 'linear'}:${yDomain.join(',')}`,
-          ...filteredData.map(
-            (point) => `${point.date}:${scatterPointConfigId(point)}:${point.x}:${point.y}`,
-          ),
+          ...filteredData.map((point) => `${pointIdentity(point)}:${point.x}:${point.y}`),
         ]
           .toSorted()
           .join('|'),
@@ -664,18 +661,20 @@ const GPUGraph = React.memo(
         logScale,
         yDomain,
         filteredData,
+        pointIdentity,
       ],
     );
 
-    // Color resolver for points/rooflines
+    // Color resolver for points/rooflines; an unofficial run keeps its run color.
     const getColor = useMemo(
       () => (d: InferenceData) => {
+        if (overlayPointSet.has(d)) return overlayRunColor(overlayRunOf(d));
         const graphIndex = allGraphs.findIndex(
           ({ date, hwKey }) => d.date === date && d.hwKey === hwKey,
         );
         return graphIndex === -1 ? '#6b7280' : allGraphs[graphIndex].color;
       },
-      [allGraphs],
+      [allGraphs, overlayPointSet, overlayRunOf],
     );
 
     const getRooflineColor = useMemo(
@@ -689,9 +688,21 @@ const GPUGraph = React.memo(
     const isRooflineVisible = useMemo(
       () => (key: string) => {
         const point = rooflines[key]?.[0];
-        return point !== undefined && activeDates.has(`${point.date}_${point.hwKey}`);
+        if (point === undefined) return false;
+        return overlayPointSet.has(point) || activeDates.has(`${point.date}_${point.hwKey}`);
+      },
+      [activeDates, rooflines, overlayPointSet],
+    );
+
+    // Unofficial-run curves keep the run's dash, as in ScatterGraph.
+    const getRooflineDasharray = useCallback(
+      (key: string) => {
+        const point = rooflines[key]?.[0];
+        return point && overlayPointSet.has(point)
+          ? overlayRooflineDasharray(overlayRunOf(point))
+          : null;
       },
-      [activeDates, rooflines],
+      [rooflines, overlayPointSet, overlayRunOf],
     );
 
     // ── Line labels (date along each roofline) ──
@@ -707,16 +718,32 @@ const GPUGraph = React.memo(
         >();
         for (const [key, points] of Object.entries(rooflines)) {
           if (points.length < 2 || !isRooflineVisible(key)) continue;
-          const graphId = `${points[0].date}_${points[0].hwKey}`;
+          const graphId = seriesIdOf(points[0]);
           const previous = bestByGraph.get(graphId);
           if (!previous || points.length > previous.points.length) {
             bestByGraph.set(graphId, { key, graphId, points });
           }
         }
+        // Runs drawing the same hardware need a run tag on their pills.
+        const overlayRunsByHw = new Map<string, Set<number>>();
+        for (const { points } of bestByGraph.values()) {
+          if (!overlayPointSet.has(points[0])) continue;
+          const hwKey = String(points[0].hwKey);
+          const runs = overlayRunsByHw.get(hwKey) ?? new Set<number>();
+          overlayRunsByHw.set(hwKey, runs.add(overlayRunOf(points[0])));
+        }
+        const overlayLabelFor = (points: InferenceData[]) => {
+          const info = unofficialRunInfos[overlayRunOf(points[0])];
+          const hardwareLabel = hardwareLabelFor(points);
+          const sharesHardware = (overlayRunsByHw.get(String(points[0].hwKey))?.size ?? 0) > 1;
+          return info ? getOverlayLineLabel(hardwareLabel, info, sharesHardware) : hardwareLabel;
+        };
         return [...bestByGraph.values()].map(({ key, graphId, points }) => ({
           key,
           seriesId: graphId,
-          label: labelTextFor(points, runNumbering),
+          label: overlayPointSet.has(points[0])
+            ? overlayLabelFor(points)
+            : labelTextFor(points, runNumbering),
           color: getRooflineColor(key),
           points,
         }));
@@ -787,19 +814,25 @@ const GPUGraph = React.memo(
       chartDefinition.chartType,
       runNumbering,
       paletteIdentity,
+      seriesIdOf,
+      overlayPointSet,
+      overlayRunOf,
+      unofficialRunInfos,
     ]);
 
     // ── Perf ruler (opt-in: click two curves, drag the ruler to any iso-x) ──
     // Same curve-to-curve ISO-X semantics as ScatterGraph, applied to the
     // date/chip comparison view: each measurement is two rendered roofline
-    // paths (class tokens `roofline-<date>_<hwKey>_<precision>`) plus an
-    // iso-x stored in DATA space so it survives zoom (axis-metric changes
-    // clear rulers; see usePerfRulerAxisReset).
+    // paths (class tokens `roofline-<seriesId>_<precision>`) plus an iso-x
+    // stored in DATA space so it survives zoom (axis-metric changes clear
+    // rulers; see usePerfRulerAxisReset).
     // Any two curves may be paired — two dates of the same chip config, two
-    // chip configs on the same date, or a mix — which is the point of this
-    // view: quantify the multiple between comparison series at a glance.
+    // chip configs on the same date, an unofficial run, or a mix — which is
+    // the point of this view: quantify the multiple between comparison series
+    // at a glance. Load sweeps on the Concurrency axis have no ruler.
     const [savedPerfRulerMode, setPerfRulerMode] = useState(false);
-    const perfRulerMode = savedPerfRulerMode && (!powerEnvelopeMode || isMeasuredPowerAxis);
+    const perfRulerMode =
+      savedPerfRulerMode && !isConcurrencyAxis && (!powerEnvelopeMode || isMeasuredPowerAxis);
     const [perfRulerState, setPerfRulerState] = useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
     // Changing the x- or y-axis metric clears every ruler: the curves are
     // redrawn in different units, so a ruler that persisted would measure a
@@ -886,15 +919,15 @@ const GPUGraph = React.memo(
     const perfRulerCurveClickRef = useRef(handlePerfRulerCurveClick);
     perfRulerCurveClickRef.current = handlePerfRulerCurveClick;
 
-    // A point click selects its (date, chip, precision) curve at that point's
-    // x, including when the measurement itself is off the power boundary.
+    // A point click selects its (series, precision) curve at that point's x,
+    // including when the measurement itself is off the power boundary.
     // Ruler-mode clicks measure INSTEAD of pinning the tooltip, so drop the
     // pin the shared click handler applied just before this callback ran.
     const handlePerfRulerPointClick = useCallback(
       (point: InferenceData) => {
         const ctx = perfRulerDrawCtxRef.current;
         if (!ctx) return;
-        const curve = `${ROOFLINE_CLASS_PREFIX}${point.date}_${String(point.hwKey)}_${point.precision}`;
+        const curve = `${ROOFLINE_CLASS_PREFIX}${seriesIdOf(point)}_${point.precision}`;
         // Single-point series render no roofline path — nothing to measure.
         if (ctx.zoomGroup.select(`.${CSS.escape(curve)}`).empty()) return;
         setPerfRulerState((prev) =>
@@ -903,7 +936,7 @@ const GPUGraph = React.memo(
         chartRef.current?.dismissTooltip();
         chartRef.current?.hideTooltip();
       },
-      [clampPerfRulerIsoXToOverlap],
+      [clampPerfRulerIsoXToOverlap, seriesIdOf],
     );
 
     // Read by the long-lived D3 click closure in the tooltip config, which is
@@ -1192,11 +1225,16 @@ const GPUGraph = React.memo(
       rooflines,
     ]);
 
-    // Dismiss tooltip when pinned point's combo is hidden
+    // Dismiss tooltip when pinned point's series is hidden
     useEffect(() => {
-      const pp = chartRef.current?.getPinnedPoint() as InferenceData | null;
-      if (pp && !activeDates.has(`${pp.date}_${pp.hwKey}`)) chartRef.current?.dismissTooltip();
-    }, [activeDates]);
+      const handle = chartRef.current;
+      const pp = handle?.getPinnedPoint() as InferenceData | null;
+      if (!pp) return;
+      const visible = handle?.getPinnedPointIsOverlay()
+        ? activeOverlayHwTypes.has(String(pp.hwKey))
+        : activeDates.has(`${pp.date}_${pp.hwKey}`);
+      if (!visible) handle?.dismissTooltip();
+    }, [activeDates, activeOverlayHwTypes]);
 
     // Dismiss on filter changes
     useEffect(() => {
@@ -1208,6 +1246,169 @@ const GPUGraph = React.memo(
       selectedDates,
       selectedDateRange,
       showAllMeasurements,
+      overlayData,
+    ]);
+
+    // One legend group per unofficial run (grouped legends split on the first
+    // word of `name`), one row per chip config the run draws. Runs are
+    // dismissed from the banner, not the legend.
+    const overlayLegendItems = useMemo(() => {
+      const bySeries = new Map<string, InferenceData[]>();
+      for (const point of overlayPoints) {
+        const id = overlaySeriesId(point);
+        bySeries.set(id, [...(bySeries.get(id) ?? []), point]);
+      }
+      return [...bySeries].map(([id, points]) => {
+        const runIndex = overlayRunOf(points[0]);
+        const info = unofficialRunInfos[runIndex];
+        const branch = info?.branch || (info ? `run ${info.id}` : id);
+        return {
+          name: `unofficial-run-${info?.id ?? runIndex} ${points[0].hwKey}`,
+          hw: id,
+          label: getInferenceRunLabel(`✕ ${hardwareLabelFor(points)}`, points),
+          color: overlayRunColor(runIndex),
+          title: legendT.unofficialTitle(branch),
+          isActive: true,
+          isRemovable: false,
+          onClick: () => {},
+        };
+      });
+    }, [overlayPoints, overlaySeriesId, overlayRunOf, unofficialRunInfos, legendT]);
+
+    // ── Unofficial-run points: ScatterGraph's X markers in the run color. The
+    // run curves go through the roofline layer; index keys let repeated
+    // observations of one config all draw. ──
+    const attachPowerTraceAction = usePowerTraceAction(chartRef);
+    const overlayPointsLayer: CustomLayerConfig = useMemo(() => {
+      const updateLabels = (zoomGroup: d3.Selection<SVGGElement, unknown, null, undefined>) => {
+        zoomGroup
+          .selectAll<SVGGElement, InferenceData>('.unofficial-overlay-pt')
+          .each(function (d) {
+            const lines = pointLabelText(d, useAdvancedLabels, showConcurrencyLabels).split('\n');
+            d3.select(this)
+              .selectAll<SVGTextElement, boolean>('.overlay-label')
+              .data([true])
+              .join('text')
+              .attr('class', 'overlay-label')
+              .attr('text-anchor', 'middle')
+              .attr('font-size', px(CHART_TYPE.dataLabel))
+              .attr('font-weight', '700')
+              .attr('pointer-events', 'none')
+              .style('fill', 'var(--foreground)')
+              .style('display', showPointLabels ? '' : 'none')
+              .selectAll<SVGTSpanElement, string>('tspan')
+              .data(lines)
+              .join('tspan')
+              .attr('x', 0)
+              .attr('dy', (_line, i) =>
+                i === 0 ? `${-(1 + (lines.length - 1) * 1.1)}em` : '1.1em',
+              )
+              .text((line) => line);
+          });
+      };
+      return {
+        type: 'custom',
+        key: 'overlay-points',
+        displayIdentity: `labels:${showPointLabels}`,
+        render: (zoomGroup, ctx) => {
+          const xScale = ctx.xScale as ContinuousScale;
+          const yScale = ctx.yScale as ContinuousScale;
+          const marks = zoomGroup
+            .selectAll<SVGGElement, InferenceData>('.unofficial-overlay-pt')
+            .data(visibleOverlayPoints, (_d, i) => String(i))
+            .join((enter) => {
+              const g = enter.append('g').attr('class', 'unofficial-overlay-pt');
+              g.append('circle')
+                .attr('r', HIT_AREA_RADIUS)
+                .attr('fill', 'transparent')
+                .attr('cursor', 'pointer');
+              g.append('path')
+                .attr('class', 'visible-shape overlay-x')
+                .attr('d', xMarkerPath(5, 0.7))
+                .attr('fill', 'none')
+                .attr('stroke-width', 2.5)
+                .attr('stroke-linecap', 'round')
+                .attr('cursor', 'pointer');
+              return g;
+            });
+          marks.attr('transform', (d) => `translate(${xScale(d.x)},${yScale(d.y)})`);
+          marks.select('.overlay-x').attr('stroke', (d) => overlayRunColor(overlayRunOf(d)));
+          marks.each(function (d) {
+            renderOffloadHalo(d3.select(this), d, overlayRunColor(overlayRunOf(d)));
+          });
+          updateLabels(zoomGroup);
+
+          const container = ctx.layout.svg.node()!.parentElement as HTMLDivElement;
+          const tooltip = d3.select(ctx.tooltipElement);
+          attachOverlayXMarkerHandlers(marks, {
+            markerSelector: '.overlay-x',
+            normalPath: xMarkerPath(5, 0.7),
+            hoverPath: xMarkerPath(7, 0.7),
+            tooltip,
+            handle: chartRef.current,
+            content: (point, pinned) =>
+              overlayData
+                ? generateOverlayTooltipContent({
+                    data: point,
+                    isPinned: pinned,
+                    xLabel,
+                    yLabel,
+                    selectedYAxisMetric,
+                    hardwareConfig: overlayData.hardwareConfig,
+                    overlayData,
+                    locale,
+                  })
+                : '',
+            position: (event) => {
+              const [mouseX, mouseY] = d3.pointer(event, container);
+              return computeTooltipPosition(mouseX, mouseY, tooltip, container);
+            },
+            rulers: {
+              show: (point, marker) => {
+                const position = overlayMarkerPosition(marker) ?? {
+                  x: xScale(point.x),
+                  y: yScale(point.y),
+                };
+                zoomGroup.select('.ruler-group').style('display', 'block');
+                zoomGroup.select('.vertical-ruler').attr('x1', position.x).attr('x2', position.x);
+                zoomGroup.select('.horizontal-ruler').attr('y1', position.y).attr('y2', position.y);
+              },
+              hide: () => zoomGroup.select('.ruler-group').style('display', 'none'),
+            },
+            onClick: (point) => {
+              const ruler = perfRulerRef.current;
+              const event = { hw: String(point.hwKey), x: point.x, y: point.y, overlay: true };
+              if (ruler.mode) {
+                track('gpu_timeseries_data_point_clicked', { ...event, perfRuler: true });
+                ruler.onPointClick(point);
+                return;
+              }
+              track('gpu_timeseries_data_point_clicked', event);
+              attachPowerTraceAction(ctx.tooltipElement, point, true);
+            },
+          });
+        },
+        onDisplayUpdate: updateLabels,
+        onZoom: (zoomGroup, ctx) => {
+          const xScale = ctx.newXScale as ContinuousScale;
+          const yScale = ctx.newYScale as ContinuousScale;
+          zoomGroup
+            .selectAll<SVGGElement, InferenceData>('.unofficial-overlay-pt')
+            .attr('transform', (d) => `translate(${xScale(d.x)},${yScale(d.y)})`);
+        },
+      };
+    }, [
+      visibleOverlayPoints,
+      overlayRunOf,
+      overlayData,
+      showPointLabels,
+      useAdvancedLabels,
+      showConcurrencyLabels,
+      xLabel,
+      yLabel,
+      selectedYAxisMetric,
+      locale,
+      attachPowerTraceAction,
     ]);
 
     // Hover dimming animates via the inline `transition: opacity 150ms ease`
@@ -1215,29 +1416,35 @@ const GPUGraph = React.memo(
     // d3 `.transition()` here would re-write opacity every animation frame,
     // each write restarting the CSS transition (transitionrun/cancel per node
     // per frame). Same rationale as ScatterGraph's hover handlers.
-    const handleLegendHover = useCallback((seriesId: string) => {
-      const svg = chartRef.current?.getSvgElement?.();
-      if (!svg) return;
-      const root = d3.select(svg);
-      root
-        .selectAll<SVGGElement, InferenceData>('.dot-group')
-        .style('opacity', (d) => (`${d.date}_${d.hwKey}` === seriesId ? 1 : 0.15));
-      root.selectAll<SVGPathElement, unknown>('.roofline-path').style('opacity', function () {
-        const point = (d3.select(this).datum() as { points: InferenceData[] } | null)?.points[0];
-        const series = point ? `${point.date}_${point.hwKey}` : '';
-        return series === seriesId ? null : '0.15';
-      });
-    }, []);
+    const handleLegendHover = useCallback(
+      (seriesId: string) => {
+        const svg = chartRef.current?.getSvgElement?.();
+        if (!svg) return;
+        const root = d3.select(svg);
+        root
+          .selectAll<SVGGElement, InferenceData>('.dot-group')
+          .style('opacity', (d) => (`${d.date}_${d.hwKey}` === seriesId ? 1 : 0.15));
+        root
+          .selectAll<SVGGElement, InferenceData>('.unofficial-overlay-pt')
+          .style('opacity', (d) => (overlaySeriesId(d) === seriesId ? 1 : 0.15));
+        root.selectAll<SVGPathElement, unknown>('.roofline-path').style('opacity', function () {
+          const point = (d3.select(this).datum() as { points: InferenceData[] } | null)?.points[0];
+          const series = point ? seriesIdOf(point) : '';
+          return series === seriesId ? null : '0.15';
+        });
+      },
+      [overlaySeriesId, seriesIdOf],
+    );
 
     const handleLegendHoverEnd = useCallback(() => {
       const svg = chartRef.current?.getSvgElement?.();
       if (!svg) return;
       const root = d3.select(svg);
-      root.selectAll('.dot-group').style('opacity', null);
+      root.selectAll('.dot-group, .unofficial-overlay-pt').style('opacity', null);
       root.selectAll('.roofline-path').style('opacity', null);
     }, []);
 
-    if (data.length === 0) {
+    if (data.length === 0 && overlayPoints.length === 0) {
       return (
         <div className="relative w-full p-3">
           <div className="flex flex-col items-center justify-center min-h-100 text-center">
@@ -1287,33 +1494,12 @@ const GPUGraph = React.memo(
         dataIdentity={dataIdentity}
         metricIdentity={metricIdentity}
         displayIdentity={`${showPointLabels}:${paletteIdentity}:${selectedPrecisions.join(',')}`}
-        data={filteredData}
+        data={officialPoints}
         margin={CHART_MARGIN}
         watermark={getChartWatermark()}
         testId="gpu-graph"
         grabCursor={true}
-        caption={
-          isMeasuredEnergyAxis || powerCurveMetric ? (
-            <>
-              {caption}
-              {isMeasuredEnergyAxis && (
-                <MeasuredPowerSummary
-                  total={powerTierCounts.total}
-                  visible={powerTierCounts.visible}
-                  bestPerSku={false}
-                  optimalOnly={hideNonOptimal}
-                />
-              )}
-              {powerCurveMetric && (
-                <p data-testid="power-curve-description" className="text-muted-foreground text-sm">
-                  {powerEnvelopeMode ? legendT.powerCurves : legendT.powerOptimal}
-                </p>
-              )}
-            </>
-          ) : (
-            caption
-          )
-        }
+        caption={caption}
         xScale={{ type: 'linear', domain: xExtent, nice: true }}
         yScale={{ type: logScale ? 'log' : 'linear', domain: yDomain, nice: true }}
         xAxis={{
@@ -1334,13 +1520,15 @@ const GPUGraph = React.memo(
             config: {
               getColor: getRooflineColor,
               isVisible: isRooflineVisible,
-              curve: d3.curveMonotoneX,
+              getDasharray: getRooflineDasharray,
+              // Load sweeps join measured points; they are not fitted curves.
+              curve: isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX,
             },
           },
           {
             type: 'scatter',
             key: 'points',
-            data: filteredData,
+            data: officialPoints,
             config: {
               getColor,
               hideLabels: !showPointLabels,
@@ -1357,6 +1545,7 @@ const GPUGraph = React.memo(
             },
             keyFn: (point) => `${point.date}:${scatterPointConfigId(point)}`,
           },
+          overlayPointsLayer,
           lineLabelLayer,
           perfRulerLayer,
           knownIssueLayer,
@@ -1482,6 +1671,7 @@ const GPUGraph = React.memo(
                 });
               });
             }
+            attachPowerTraceAction(tooltipEl, d, false);
             // Pinning updates D3Chart's React state. GPU comparison rebuilds
             // several inline layer configs on that render, whose cleanup can
             // briefly hide the otherwise-pinned portal tooltip. Restore its
@@ -1525,21 +1715,15 @@ const GPUGraph = React.memo(
           // CSS transitions for smooth opacity animation on legend hover —
           // the hover handlers write opacity once and let these animate.
           ctx.layout.zoomGroup
-            .selectAll('.dot-group, .roofline-path')
+            .selectAll('.dot-group, .unofficial-overlay-pt, .roofline-path')
             .style('transition', 'opacity 150ms ease');
 
-          // Decorations stay inside the point group, so normal zoom transforms
-          // carry them without a separate update pass.
+          // The offload halo stays inside the point group, so normal zoom
+          // transforms carry it without a separate update pass.
           ctx.layout.zoomGroup
             .selectAll<SVGGElement, InferenceData>('.dot-group')
             .each(function (point) {
               renderOffloadHalo(d3.select(this), point, 'var(--foreground)');
-              renderLegacyPowerRing(
-                d3.select(this),
-                point,
-                isMeasuredEnergyAxis,
-                'var(--foreground)',
-              );
             });
         }}
         legendElement={
@@ -1550,20 +1734,23 @@ const GPUGraph = React.memo(
             onItemHover={handleLegendHover}
             onItemHoverEnd={handleLegendHoverEnd}
             onItemRemove={handleLegendRemove}
-            legendItems={allGraphs
-              .filter(({ id }) => idsWithData.has(id))
-              .map(({ date, color, hwKey, id }) => ({
-                name: `${hwKey} ${comparisonEntryLabel(date, runNumbering)}`,
-                hw: id,
-                label: comparisonEntryLabel(date, runNumbering),
-                color,
-                title: getDisplayLabel(getHardwareConfig(hwKey, modelLabel)),
-                isActive: activeDates.has(id),
-                onClick: () => {
-                  toggleActiveDate(id);
-                  track('interactivity_date_toggled', { date, hw: hwKey });
-                },
-              }))}
+            legendItems={[
+              ...overlayLegendItems,
+              ...allGraphs
+                .filter(({ id }) => idsWithData.has(id))
+                .map(({ date, color, hwKey, id }) => ({
+                  name: `${hwKey} ${comparisonEntryLabel(date, runNumbering)}`,
+                  hw: id,
+                  label: comparisonEntryLabel(date, runNumbering),
+                  color,
+                  title: getDisplayLabel(getHardwareConfig(hwKey, modelLabel)),
+                  isActive: activeDates.has(id),
+                  onClick: () => {
+                    toggleActiveDate(id);
+                    track('interactivity_date_toggled', { date, hw: hwKey });
+                  },
+                })),
+            ]}
             isLegendExpanded={isLegendExpanded}
             onExpandedChange={(expanded) => {
               setIsLegendExpanded(expanded);
@@ -1663,7 +1850,7 @@ const GPUGraph = React.memo(
                   if (c && !showPointLabels) setShowPointLabels(true);
                 },
               },
-              ...(powerEnvelopeMode && !isMeasuredPowerAxis
+              ...(isConcurrencyAxis || (powerEnvelopeMode && !isMeasuredPowerAxis)
                 ? []
                 : [
                     {
diff --git a/packages/app/src/components/inference/ui/LegacyPowerLegendKey.tsx b/packages/app/src/components/inference/ui/LegacyPowerLegendKey.tsx
deleted file mode 100644
index 3050638f6..000000000
--- a/packages/app/src/components/inference/ui/LegacyPowerLegendKey.tsx
+++ /dev/null
@@ -1,51 +0,0 @@
-import { POINT_SIZE } from '@/lib/chart-rendering';
-import { useLocale } from '@/lib/use-locale';
-
-// Nested outside the KV-offload halo (POINT_SIZE + 4, '3 2' dashes) with a
-// dotted dasharray so both decorations stay legible on one point.
-export const LEGACY_POWER_RING_RADIUS = POINT_SIZE + 7;
-export const LEGACY_POWER_RING_STROKE_WIDTH = 1.5;
-export const LEGACY_POWER_RING_DASHARRAY = '1 3';
-
-const STRINGS = {
-  en: 'Historical measurement (not validated under the current method)',
-  zh: '历史测量（尚未按当前方法验证）',
-} as const;
-
-/**
- * Key for the dotted ring drawn around measured-axis points whose power
- * telemetry predates the producer validation contract (`power_tier ===
- * 'legacy'`). Rendered in the axis-metric info footer below the chart (the
- * footer is `no-export`, so downloaded PNGs carry only the ring itself).
- */
-export function LegacyPowerLegendKey() {
-  const locale = useLocale();
-
-  return (
-    <div
-      data-testid="legacy-power-key"
-      className="inline-flex max-w-full items-center gap-2 text-xs leading-5 text-muted-foreground"
-    >
-      <svg
-        width="16"
-        height="16"
-        viewBox="0 0 24 24"
-        className="shrink-0"
-        style={{ maxWidth: 16 }}
-        aria-hidden="true"
-      >
-        <circle cx="12" cy="12" r={POINT_SIZE} fill="currentColor" opacity="0.45" />
-        <circle
-          cx="12"
-          cy="12"
-          r={LEGACY_POWER_RING_RADIUS}
-          fill="none"
-          stroke="currentColor"
-          strokeWidth={LEGACY_POWER_RING_STROKE_WIDTH}
-          strokeDasharray={LEGACY_POWER_RING_DASHARRAY}
-        />
-      </svg>
-      <span className="min-w-0 leading-tight">{STRINGS[locale]}</span>
-    </div>
-  );
-}
diff --git a/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx b/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
new file mode 100644
index 000000000..f535542a2
--- /dev/null
+++ b/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
@@ -0,0 +1,211 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { Heading } from '@/components/ui/heading';
+import { exportToCsv } from '@/lib/csv-export';
+import { useLocale } from '@/lib/use-locale';
+import type { AggDataEntry, InferenceData } from '../types';
+import {
+  buildMatchedConcurrencyTable,
+  type MatchedConcurrencySide,
+} from '../utils/matched-concurrency';
+
+const STRINGS = {
+  en: {
+    title: 'Matched concurrency (load diagnostic)',
+    concurrency: 'Concurrency',
+    baseline: 'Baseline',
+    comparator: 'Comparator',
+    change: 'Change',
+    energy: 'J/output token',
+    speed: 'tok/s/user',
+    power: 'W/GPU',
+    missing: 'Not measured',
+    ambiguous: (count: number) => `${count} conflicting observations; none selected`,
+    metricMissing: 'Energy not reported',
+    energyChange: 'GPU energy',
+    empty: 'Neither source has an observation with a positive concurrency.',
+    unavailable: 'Choose two different available sources.',
+  },
+  zh: {
+    title: '相同并发下的对照（负载诊断）',
+    concurrency: '并发数',
+    baseline: '基准',
+    comparator: '对比对象',
+    change: '变化',
+    energy: 'J/输出 token',
+    speed: 'tok/s/user',
+    power: 'W/GPU',
+    missing: '未测量',
+    ambiguous: (count: number) => `${count} 个观测值相互冲突，均未采用`,
+    metricMissing: '未报告能耗',
+    energyChange: 'GPU 能耗',
+    empty: '两个数据源都没有并发数为正的观测值。',
+    unavailable: '请选择两个不同且可用的数据源。',
+  },
+};
+
+const joules = d3.format(',.3f');
+const watts = d3.format(',.0f');
+const speed = d3.format(',.1f');
+const signed = d3.format('+.1f');
+const percent = (value: number | null) => (value === null ? '—' : `${signed(value)}%`);
+const sideColumns = (side: MatchedConcurrencySide) =>
+  side.status === 'observed'
+    ? [
+        side.status,
+        side.values.joulesPerOutputToken,
+        side.values.meanWattsPerGpu,
+        side.values.interactivity,
+        side.point.id ?? null,
+        side.point.run_url ?? null,
+      ]
+    : [side.status, null, null, null, null, null];
+
+export default function MatchedConcurrencyTable({
+  chartId,
+  data,
+  baseline,
+  comparator,
+  interactivityField,
+  sourceLabel,
+}: {
+  chartId: string;
+  data: InferenceData[];
+  baseline: string;
+  comparator: string;
+  interactivityField: keyof AggDataEntry;
+  sourceLabel: (key: string) => string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const table = useMemo(
+    () => buildMatchedConcurrencyTable(data, { baseline, comparator, interactivityField }),
+    [data, baseline, comparator, interactivityField],
+  );
+  const cell = (side: MatchedConcurrencySide) => {
+    if (side.status === 'missing')
+      return <span className="text-muted-foreground">{t.missing}</span>;
+    if (side.status === 'ambiguous')
+      return <span className="text-muted-foreground">{t.ambiguous(side.points.length)}</span>;
+    const { joulesPerOutputToken, meanWattsPerGpu, interactivity } = side.values;
+    return (
+      <>
+        <strong>
+          {joulesPerOutputToken === null ? t.metricMissing : joules(joulesPerOutputToken)}
+        </strong>
+        <span className="block text-xs text-muted-foreground">
+          {meanWattsPerGpu === null ? '—' : watts(meanWattsPerGpu)} {t.power} ·{' '}
+          {interactivity === null ? '—' : speed(interactivity)} {t.speed}
+        </span>
+      </>
+    );
+  };
+  const sectionId = `${chartId}-matched-concurrency`;
+  const exportCsv = () => {
+    exportToCsv(
+      `InferenceX_matched_concurrency`,
+      [
+        'concurrency',
+        ...['baseline', 'comparator'].flatMap((prefix) => [
+          `${prefix}_status`,
+          `${prefix}_j_per_output_token`,
+          `${prefix}_w_per_gpu`,
+          `${prefix}_${String(interactivityField)}`,
+          `${prefix}_point_id`,
+          `${prefix}_run_url`,
+        ]),
+        'change_j_per_output_token_pct',
+        'change_w_per_gpu_pct',
+        'change_interactivity_pct',
+      ],
+      table.rows.map((row) => [
+        row.concurrency,
+        ...sideColumns(row.baseline),
+        ...sideColumns(row.comparator),
+        row.changePercent.joulesPerOutputToken,
+        row.changePercent.meanWattsPerGpu,
+        row.changePercent.interactivity,
+      ]),
+      [`baseline: ${sourceLabel(baseline)}`, `comparator: ${sourceLabel(comparator)}`],
+    );
+  };
+  return (
+    <section id={sectionId} className="min-w-0 space-y-3" data-testid="matched-concurrency-panel">
+      <Heading as="h3" level="card">
+        {t.title}
+      </Heading>
+      <p className="export-only hidden break-words text-sm" data-testid="matched-concurrency-pair">
+        {t.baseline}: {sourceLabel(baseline)} → {t.comparator}: {sourceLabel(comparator)}
+      </p>
+      {table.reason ? (
+        <p className="text-sm text-muted-foreground">{t.unavailable}</p>
+      ) : table.rows.length === 0 ? (
+        <p className="text-sm text-muted-foreground">{t.empty}</p>
+      ) : (
+        <div className="min-w-0 overflow-x-auto">
+          <table
+            className="w-full min-w-[34rem] table-fixed break-words text-left text-sm"
+            data-testid="matched-concurrency-table"
+          >
+            <thead>
+              <tr>
+                <th className="w-28 whitespace-nowrap p-2">{t.concurrency}</th>
+                <th className="p-2">
+                  {t.baseline}
+                  <span className="block text-xs font-normal text-muted-foreground">
+                    {t.energy}
+                  </span>
+                </th>
+                <th className="p-2">
+                  {t.comparator}
+                  <span className="block text-xs font-normal text-muted-foreground">
+                    {t.energy}
+                  </span>
+                </th>
+                <th className="p-2">
+                  {t.change}
+                  <span className="block text-xs font-normal text-muted-foreground">
+                    {t.energyChange}
+                  </span>
+                </th>
+              </tr>
+            </thead>
+            <tbody>
+              {table.rows.map((row) => (
+                <tr
+                  key={row.concurrency}
+                  className="border-t"
+                  data-testid={`matched-concurrency-row-${row.concurrency}`}
+                >
+                  <th className="p-2 font-medium">{row.concurrency}</th>
+                  <td className="p-2 align-top">{cell(row.baseline)}</td>
+                  <td className="p-2 align-top">{cell(row.comparator)}</td>
+                  <td className="p-2 align-top">
+                    <strong>{percent(row.changePercent.joulesPerOutputToken)}</strong>
+                    <span className="block text-xs text-muted-foreground">
+                      {t.power} {percent(row.changePercent.meanWattsPerGpu)} · {t.speed}{' '}
+                      {percent(row.changePercent.interactivity)}
+                    </span>
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      )}
+      <div className="max-h-0 overflow-hidden">
+        <div id={`${sectionId}-export`} className="p-4" />
+      </div>
+      <ChartButtons
+        chartId={sectionId}
+        analyticsPrefix="matched_concurrency"
+        hideZoomReset
+        onExportCsv={table.rows.length > 0 ? exportCsv : undefined}
+      />
+    </section>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
index 0373fc5bd..d2d585611 100644
--- a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
+++ b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
@@ -23,8 +23,6 @@ const STRINGS = {
     basis: 'Boundary',
     basisHelp:
       'Where power is counted. GPU measured: runner telemetry from the GPU boards. GPU provisioned: rated TDP per GPU. Utility provisioned: all-in provisioned utility power per GPU. Utility modeled: measured GPU power carried through the modeled chassis to the utility meter with PUE. Points without a value for the chosen boundary are omitted, never replaced with an estimate.',
-    basisHint:
-      'Derived boundaries report average power per chip across all GPUs, and whole-deployment joules per output token. Changing another setting returns to GPU measured.',
     scope: 'Scope',
     scopeHelp:
       'All GPUs measures the whole deployment. Prefill and decode select only GPUs serving that role.',
@@ -35,7 +33,6 @@ const STRINGS = {
     statisticHelp:
       'P75 and P90 are time-weighted percentiles of synchronized fleet power, divided by chip count. They are available for all GPUs only.',
     average: 'Average',
-    roleHint: 'Prefill and decode power support Average only.',
     display: 'Display',
     displayHelp:
       'Power per chip in watts, average power as a percentage of chip TDP, or the per-second telemetry timeline behind the average. Percent of TDP and Timeline are available for the all-GPU average only.',
@@ -56,15 +53,11 @@ const STRINGS = {
     compareNone: 'Off',
     compareBoundaries: 'All boundaries',
     compareRoles: 'Prefill vs decode',
-    compareUnavailable:
-      'The comparison is paused for this setting: it needs the whole-deployment average W/chip or J per output token.',
   },
   zh: {
     basis: '功耗边界',
     basisHelp:
       '选择功耗的计量边界。GPU 实测：来自 GPU 板卡的运行器遥测；GPU 额定：每 GPU 的额定 TDP；全电源配置：每 GPU 的全电源配置（all-in）市电功率；数据中心建模：将 GPU 实测功耗经机箱功耗模型推算至市电侧并计入 PUE。所选边界缺少数值的数据点将被省略，不会用估算值替代。',
-    basisHint:
-      '推导边界提供全部 GPU 的平均每芯片功率，以及整个部署的每输出 token 能耗；更改其他设置将返回 GPU 实测。',
     scope: '统计范围',
     scopeHelp: '全部 GPU 对应整个部署；预填充和解码仅统计承担相应任务的 GPU。',
     all: '全部 GPU',
@@ -74,7 +67,6 @@ const STRINGS = {
     statisticHelp:
       'P75 和 P90 是同步采样的集群总功率按时间加权得到的分位数，再除以芯片数。仅支持全部 GPU。',
     average: '平均值',
-    roleHint: '预填充和解码功率仅支持平均值。',
     display: '显示方式',
     displayHelp:
       '显示单芯片功率（瓦）、平均功率占芯片 TDP 的百分比，或平均值背后的逐秒遥测时间线。TDP 百分比和时间线仅支持全部 GPU 的平均功率。',
@@ -94,7 +86,6 @@ const STRINGS = {
     compareNone: '关闭',
     compareBoundaries: '全部边界',
     compareRoles: '预填充 vs 解码',
-    compareUnavailable: '当前设置下对比已暂停：需要整个部署的平均 W/芯片或每输出 token 能耗。',
   },
 } as const;
 
@@ -119,13 +110,10 @@ export function MeasuredMetricControls({
     boundaries: t.compareBoundaries,
     roles: t.compareRoles,
   };
-  const compareActive = compare !== 'none';
-  const compareApplies = powerCompareAvailable(metric, compare);
   const change = (next: MeasuredMetricConfigChange) =>
     onChange(changeMeasuredMetricConfig(metric, next));
   const basisId = `measured-${config.family}-basis`;
   const scopeId = `measured-${config.family}-scope`;
-  const derivedBasis = config.basis !== 'gpu-measured';
   const roleScope =
     config.family === 'energy'
       ? config.denominator === 'input'
@@ -282,9 +270,6 @@ export function MeasuredMetricControls({
               </SelectContent>
             </Select>
           </div>
-          {config.scope !== 'all' && (
-            <p className="col-span-full text-xs text-muted-foreground">{t.roleHint}</p>
-          )}
         </>
       ) : (
         <div className="flex min-w-0 flex-col gap-1.5">
@@ -349,22 +334,6 @@ export function MeasuredMetricControls({
           </Select>
         </div>
       )}
-      {derivedBasis && (
-        <p
-          className="col-span-full text-xs text-muted-foreground"
-          data-testid="measured-basis-hint"
-        >
-          {t.basisHint}
-        </p>
-      )}
-      {compareActive && !compareApplies && (
-        <p
-          className="col-span-full text-xs text-muted-foreground"
-          data-testid="measured-compare-hint"
-        >
-          {t.compareUnavailable}
-        </p>
-      )}
     </div>
   );
 }
diff --git a/packages/app/src/components/inference/ui/MeasuredPowerSummary.tsx b/packages/app/src/components/inference/ui/MeasuredPowerSummary.tsx
deleted file mode 100644
index dfbbf68c6..000000000
--- a/packages/app/src/components/inference/ui/MeasuredPowerSummary.tsx
+++ /dev/null
@@ -1,117 +0,0 @@
-'use client';
-
-import type { InferenceData } from '@/components/inference/types';
-import { useLocale } from '@/lib/use-locale';
-
-export interface PowerTierCounts {
-  certified: number;
-  legacy: number;
-}
-
-export function countPowerTiers(points: readonly InferenceData[]): PowerTierCounts {
-  const counts: PowerTierCounts = { certified: 0, legacy: 0 };
-  for (const point of points) {
-    if (point.power_tier === 'certified') counts.certified += 1;
-    else if (point.power_tier === 'legacy') counts.legacy += 1;
-  }
-  return counts;
-}
-
-const STRINGS = {
-  en: {
-    validated: 'validated',
-    historical: 'historical',
-    single: (shown: number, total: number, tier: string) =>
-      `Showing ${shown} of ${total} ${tier} measurements.`,
-    combined: (
-      shown: number,
-      total: number,
-      validatedShown: number,
-      validatedTotal: number,
-      historicalShown: number,
-      historicalTotal: number,
-    ) =>
-      `Showing ${shown} of ${total} measured points: ${validatedShown}/${validatedTotal} validated · ${historicalShown}/${historicalTotal} historical.`,
-    bestPerSku: 'Best per SKU',
-    optimalOnly: 'Optimal Only',
-    controlsEnabled: (controls: string) =>
-      `${controls} ${controls.includes(' and ') ? 'are' : 'is'} enabled.`,
-    reducedBySelections: 'Chart selections are hiding some points.',
-  },
-  zh: {
-    validated: '已验证',
-    historical: '历史',
-    single: (shown: number, total: number, tier: string) =>
-      `当前显示 ${shown}/${total} 个${tier}测量数据点。`,
-    combined: (
-      shown: number,
-      total: number,
-      validatedShown: number,
-      validatedTotal: number,
-      historicalShown: number,
-      historicalTotal: number,
-    ) =>
-      `当前显示 ${shown}/${total} 个实测数据点：已验证 ${validatedShown}/${validatedTotal} · 历史 ${historicalShown}/${historicalTotal}。`,
-    bestPerSku: '每个 SKU 仅显示最佳配置',
-    optimalOnly: '仅最优',
-    controlsEnabled: (controls: string) => `已启用：${controls}。`,
-    reducedBySelections: '当前图表选项隐藏了部分数据点。',
-  },
-} as const;
-
-function joinControls(controls: string[], locale: 'en' | 'zh'): string {
-  if (controls.length < 2) return controls[0] ?? '';
-  return locale === 'zh' ? controls.join('、') : controls.join(' and ');
-}
-
-export function MeasuredPowerSummary({
-  total,
-  visible,
-  bestPerSku,
-  optimalOnly,
-}: {
-  total: PowerTierCounts;
-  visible: PowerTierCounts;
-  bestPerSku: boolean;
-  optimalOnly: boolean;
-}) {
-  const locale = useLocale();
-  const t = STRINGS[locale];
-  const totalCount = total.certified + total.legacy;
-  const visibleCount = visible.certified + visible.legacy;
-  if (totalCount === 0) return null;
-
-  const summary =
-    total.certified > 0 && total.legacy > 0
-      ? t.combined(
-          visibleCount,
-          totalCount,
-          visible.certified,
-          total.certified,
-          visible.legacy,
-          total.legacy,
-        )
-      : total.certified > 0
-        ? t.single(visible.certified, total.certified, t.validated)
-        : t.single(visible.legacy, total.legacy, t.historical);
-
-  const controls: string[] = [];
-  if (bestPerSku) controls.push(t.bestPerSku);
-  if (optimalOnly) controls.push(t.optimalOnly);
-  const reduction =
-    visibleCount >= totalCount
-      ? null
-      : controls.length > 0
-        ? t.controlsEnabled(joinControls(controls, locale))
-        : t.reducedBySelections;
-
-  return (
-    <div
-      data-testid="measured-power-summary"
-      className="no-export mt-2 flex flex-wrap gap-x-1 px-1 text-2xs leading-relaxed text-muted-foreground"
-    >
-      <span>{summary}</span>
-      {reduction && <span>{reduction}</span>}
-    </div>
-  );
-}
diff --git a/packages/app/src/components/inference/ui/PowerFitPanel.tsx b/packages/app/src/components/inference/ui/PowerFitPanel.tsx
new file mode 100644
index 000000000..deab9eb45
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerFitPanel.tsx
@@ -0,0 +1,224 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { Heading } from '@/components/ui/heading';
+import { exportToCsv } from '@/lib/csv-export';
+import { useLocale } from '@/lib/use-locale';
+import { escapeHtml } from '@/lib/utils';
+import type { InferenceData } from '../types';
+import { buildPowerFits, MIN_FIT_POINTS } from '../utils/power-fit';
+import { PowerPanelPlot, type PanelLine, type PanelMarker } from './PowerPanelPlot';
+
+const STRINGS = {
+  en: {
+    title: 'Power versus output rate (least-squares fit)',
+    xAxis: 'Output rate (tok/s per allocated GPU)',
+    yAxis: 'Mean GPU power (W/GPU)',
+    source: 'Source',
+    intercept: 'P₀ (W/GPU)',
+    tdpShare: 'P₀ ÷ TDP',
+    slope: 'm (J/output token)',
+    rSquared: 'R²',
+    points: 'Points',
+    range: 'Fitted range (tok/s/GPU)',
+    tooFew: (count: number) =>
+      `Not fitted: needs ${MIN_FIT_POINTS} distinct output rates, has ${count}.`,
+    flat: 'Undefined: power did not vary',
+    empty: 'No validated measured power with a known output rate is available for these filters.',
+  },
+  zh: {
+    title: '功耗与输出速率（最小二乘拟合）',
+    xAxis: '输出速率（每个已分配 GPU 的 tok/s）',
+    yAxis: '平均 GPU 功耗（W/GPU）',
+    source: '数据源',
+    intercept: 'P₀（W/GPU）',
+    tdpShare: 'P₀ ÷ TDP',
+    slope: 'm（J/输出 token）',
+    rSquared: 'R²',
+    points: '点数',
+    range: '拟合范围（tok/s/GPU）',
+    tooFew: (count: number) =>
+      `未拟合：需要 ${MIN_FIT_POINTS} 个不同的输出速率，当前只有 ${count} 个。`,
+    flat: '无定义：功耗没有变化',
+    empty: '当前筛选条件下没有同时具备有效实测功耗和已知输出速率的数据。',
+  },
+};
+
+const watts = d3.format(',.0f');
+const joules = d3.format(',.3f');
+const rate = d3.format(',.1f');
+const share = d3.format('.0%');
+const rSquared = d3.format('.3f');
+const EXTENSION_DASH = '4 4';
+
+export default function PowerFitPanel({
+  chartId,
+  data,
+  contextLabel,
+  colorOf,
+}: {
+  chartId: string;
+  data: InferenceData[];
+  contextLabel?: string;
+  colorOf: (sourceKey: string) => string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const fits = useMemo(() => buildPowerFits(data, locale), [data, locale]);
+  const sectionId = `${chartId}-power-fit`;
+
+  const markers: PanelMarker[] = fits.flatMap(({ source, observations }) =>
+    observations.map((observation) => ({
+      x: observation.x,
+      y: observation.y,
+      key: source.key,
+      tooltip: [
+        `<strong>${escapeHtml(source.label)}</strong>`,
+        `c${observation.point.conc} · ${rate(observation.x)} tok/s/GPU`,
+        `${watts(observation.y)} W/GPU`,
+      ].join('<br/>'),
+    })),
+  );
+  // Line keys become SVG class names, so they index the source rather than embed its key.
+  const lines: PanelLine[] = fits.flatMap(({ source, fit }, index) => {
+    if (!fit) return [];
+    const at = (x: number) => ({ x, y: fit.intercept + fit.slope * x });
+    const color = colorOf(source.key);
+    return [
+      { key: `source${index}-fit`, color, points: [at(fit.xMin), at(fit.xMax)] },
+      ...(fit.xMin > 0
+        ? [
+            {
+              key: `source${index}-extension`,
+              color,
+              dash: EXTENSION_DASH,
+              points: [at(0), at(fit.xMin)],
+            },
+          ]
+        : []),
+    ];
+  });
+
+  const exportCsv = () => {
+    exportToCsv(
+      'InferenceX_power_fit',
+      [
+        'source',
+        'p0_w_per_gpu',
+        'tdp_w',
+        'p0_over_tdp',
+        'm_j_per_output_token',
+        'r_squared',
+        'n',
+        'x_min_tok_s_per_gpu',
+        'x_max_tok_s_per_gpu',
+        'status',
+      ],
+      fits.map((entry) => {
+        const { fit, tdpWatts } = entry;
+        return [
+          entry.source.label,
+          fit?.intercept ?? null,
+          tdpWatts,
+          fit && tdpWatts ? fit.intercept / tdpWatts : null,
+          fit?.slope ?? null,
+          fit?.rSquared ?? null,
+          entry.observations.length,
+          fit?.xMin ?? null,
+          fit?.xMax ?? null,
+          entry.reason ?? 'fitted',
+        ];
+      }),
+      contextLabel ? [contextLabel] : [],
+    );
+  };
+
+  return (
+    <section id={sectionId} className="min-w-0 space-y-3" data-testid="power-fit-panel">
+      <Heading as="h3" level="card">
+        {t.title}
+      </Heading>
+      <p className="export-only hidden text-sm text-muted-foreground">{contextLabel}</p>
+      {fits.length === 0 ? (
+        <p className="py-6 text-sm text-muted-foreground">{t.empty}</p>
+      ) : (
+        <>
+          <PowerPanelPlot
+            chartId={sectionId}
+            markers={markers}
+            lines={lines}
+            markerColor={colorOf}
+            xLabel={t.xAxis}
+            yLabel={t.yAxis}
+            height={360}
+          />
+          <div className="min-w-0 overflow-x-auto">
+            <table
+              className="w-full min-w-[40rem] table-fixed break-words text-left text-sm"
+              data-testid="power-fit-table"
+            >
+              <thead>
+                <tr>
+                  <th className="w-2/5 p-2">{t.source}</th>
+                  <th className="p-2">{t.intercept}</th>
+                  <th className="p-2">{t.tdpShare}</th>
+                  <th className="p-2">{t.slope}</th>
+                  <th className="p-2">{t.rSquared}</th>
+                  <th className="p-2">{t.points}</th>
+                  <th className="p-2">{t.range}</th>
+                </tr>
+              </thead>
+              <tbody>
+                {fits.map((entry) => {
+                  const { fit, source, tdpWatts } = entry;
+                  return (
+                    <tr key={source.key} className="border-t" data-testid="power-fit-row">
+                      <th className="p-2 align-top font-normal">
+                        <span style={{ color: colorOf(source.key) }}>● </span>
+                        <span className="break-all">{source.label}</span>
+                      </th>
+                      {fit ? (
+                        <>
+                          <td className="p-2 align-top">{watts(fit.intercept)}</td>
+                          <td className="p-2 align-top">
+                            {tdpWatts
+                              ? `${share(fit.intercept / tdpWatts)} · ${watts(tdpWatts)} W`
+                              : '—'}
+                          </td>
+                          <td className="p-2 align-top">{joules(fit.slope)}</td>
+                          <td className="p-2 align-top">
+                            {fit.rSquared === null ? t.flat : rSquared(fit.rSquared)}
+                          </td>
+                          <td className="p-2 align-top">{fit.n}</td>
+                          <td className="p-2 align-top">
+                            {rate(fit.xMin)}–{rate(fit.xMax)}
+                          </td>
+                        </>
+                      ) : (
+                        <td className="p-2 align-top text-muted-foreground" colSpan={6}>
+                          {t.tooFew(new Set(entry.observations.map((o) => o.x)).size)}
+                        </td>
+                      )}
+                    </tr>
+                  );
+                })}
+              </tbody>
+            </table>
+          </div>
+          <div className="max-h-0 overflow-hidden">
+            <div id={`${sectionId}-export`} className="p-4" />
+          </div>
+          <ChartButtons
+            chartId={sectionId}
+            analyticsPrefix="power_fit"
+            hideZoomReset
+            onExportCsv={exportCsv}
+          />
+        </>
+      )}
+    </section>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx b/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
deleted file mode 100644
index cad29732b..000000000
--- a/packages/app/src/components/inference/ui/PowerMetricAvailability.tsx
+++ /dev/null
@@ -1,378 +0,0 @@
-'use client';
-
-import { useMemo } from 'react';
-import { useInferenceData, useInferenceFilters } from '../InferenceContext';
-import {
-  isMeasuredEnergyConfigKey,
-  isPowerBasisConfigKey,
-  metricOptionTitle,
-  POWER_BASIS_METRIC_CONFIG_KEYS,
-  type MetricKey,
-} from '../metric-registry';
-import { getMeasuredMetricConfig } from '../measured-metric-config';
-import type { InferenceData } from '../types';
-import { powerBasisNormalization } from '@/lib/power-basis';
-import { matchesQuickFilters } from '../utils/quickFilters';
-import {
-  powerMetricAvailability,
-  powerMetricState,
-  type PowerAvailabilityState,
-} from '../utils/power-metric-availability';
-import { useUnofficialRun } from '@/components/unofficial-run-provider';
-import { hardwareKeyMatchesAnyBase } from '@/lib/constants';
-import { useLocale } from '@/lib/use-locale';
-import { track } from '@/lib/analytics';
-
-const STRINGS = {
-  en: {
-    title: 'PowerX availability',
-    scope:
-      'Current workload and hardware selection, before Optimal Only. Includes visible unofficial runs.',
-    loading: 'Updating measurement availability…',
-    none: 'No benchmark points match this selection.',
-    summary: (available: number, total: number) =>
-      `${available} of ${total} points have this metric`,
-    labels: {
-      strict: 'Validated · schema 2',
-      validated: 'Validated · other or missing schema',
-      unverified: 'No validation verdict',
-      invalid: 'Validation failed',
-      inapplicable: 'No separate worker pools',
-      ambiguous: 'Whole-deployment energy schema unavailable',
-      missing: 'Metric not reported',
-    },
-    basisLabels: {
-      available: 'Value available',
-      noSpec: 'No published spec for this hardware',
-      noThroughput: 'No output throughput reported',
-      noNormalization: 'Whole-deployment GPU count unavailable for this disaggregated row',
-      noTelemetry: 'No validated GPU telemetry',
-      invalid: 'Validation failed',
-      modelWorkload: 'Chassis model covers 8K / 1K only',
-      modelHardware: 'Hardware not in the chassis power model',
-      modelUnsupported: 'Chassis model unsupported for this deployment',
-    },
-    note: 'A missing verdict does not establish age or validity. Prefill/decode metrics measure separate worker pools. Missing values are never replaced with zero or TDP estimates.',
-    all: 'Availability of all measured metrics',
-    evidence: 'Selected metric: source details',
-    run: 'Source run',
-  },
-  zh: {
-    title: 'PowerX 指标可用性',
-    scope: '按当前工作负载与硬件选择统计，不受“仅最优”影响，包含已显示的非官方运行。',
-    loading: '正在更新指标可用性…',
-    none: '当前选择没有匹配的基准测试数据点。',
-    summary: (available: number, total: number) =>
-      `${total} 个数据点中有 ${available} 个提供此指标`,
-    labels: {
-      strict: '已验证 · schema 2',
-      validated: '已验证 · 其他或未标注 schema',
-      unverified: '未提供验证结论',
-      invalid: '验证失败',
-      inapplicable: '无独立 worker 池',
-      ambiguous: '缺少整个部署的能耗 schema',
-      missing: '未提供此指标',
-    },
-    basisLabels: {
-      available: '有数值',
-      noSpec: '该硬件没有公开的规格参数',
-      noThroughput: '未报告输出吞吐量',
-      noNormalization: '无法确定该分离式部署的 GPU 总数',
-      noTelemetry: '没有已验证的 GPU 遥测',
-      invalid: '验证失败',
-      modelWorkload: '机箱功耗模型仅覆盖 8K / 1K',
-      modelHardware: '硬件不在机箱功耗模型范围内',
-      modelUnsupported: '机箱功耗模型不支持此部署',
-    },
-    note: '缺少验证结论不能判断数据新旧或有效性。prefill/decode 指标仅衡量独立 worker 池。缺失值不会被替换为零或 TDP 估算值。',
-    all: '所有实测指标的可用性',
-    evidence: '当前指标的来源详情',
-    run: '来源运行',
-  },
-} as const;
-
-/**
- * Why a point lacks a derived power boundary (lib/power-basis.ts). Provisioned
- * boundaries are spec constants, so their watts exist for any registered
- * hardware and their energy additionally needs output throughput plus, for
- * disaggregated rows, the whole-deployment GPU count that
- * `powerBasisNormalization` recovers only for fixed-sequence runs with integer
- * prefill/decode counts. The modeled boundary is measured telemetry carried
- * through the chassis model, so it inherits the telemetry verdict and the
- * model's own unsupported reasons.
- */
-export type PowerBasisAvailabilityState =
-  | 'available'
-  | 'noSpec'
-  | 'noThroughput'
-  | 'noNormalization'
-  | 'noTelemetry'
-  | 'invalid'
-  | 'modelWorkload'
-  | 'modelHardware'
-  | 'modelUnsupported';
-
-const POWER_BASIS_AVAILABILITY_STATES: readonly PowerBasisAvailabilityState[] = [
-  'available',
-  'noSpec',
-  'noThroughput',
-  'noNormalization',
-  'noTelemetry',
-  'invalid',
-  'modelWorkload',
-  'modelHardware',
-  'modelUnsupported',
-];
-
-const hasFiniteValue = (point: InferenceData, key: MetricKey): boolean => {
-  const value = point[key];
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'y' in value &&
-    typeof value.y === 'number' &&
-    Number.isFinite(value.y)
-  );
-};
-
-export function powerBasisState(
-  point: InferenceData,
-  configKey: string,
-): PowerBasisAvailabilityState {
-  const key = configKey.replace(/^y_/u, '') as MetricKey;
-  if (hasFiniteValue(point, key)) return 'available';
-  const config = getMeasuredMetricConfig(configKey);
-  if (config?.basis === 'utility-modeled') {
-    if (point.power_valid === 0) return 'invalid';
-    const model = point.modeledSystemPower;
-    if (model?.status === 'unsupported') {
-      if (model.reason === 'workload') return 'modelWorkload';
-      if (model.reason === 'hardware') return 'modelHardware';
-      if (model.reason === 'telemetry') return 'noTelemetry';
-      return 'modelUnsupported';
-    }
-    // A supported model without a plotted value means B1 is absent (B4 follows B1).
-    return 'noTelemetry';
-  }
-  // Provisioned energy needs the watts sibling plus the whole-deployment
-  // normalization; the same helper that withheld the value says which half is
-  // missing, so the explanation cannot drift from the formula.
-  const wattsKey = (
-    config?.basis === 'gpu-provisioned' ? 'gpuProvisionedWatts' : 'utilityProvisionedWatts'
-  ) satisfies MetricKey;
-  if (!hasFiniteValue(point, wattsKey)) return 'noSpec';
-  const perGpu = point.output_tput_per_gpu;
-  if (typeof perGpu !== 'number' || !Number.isFinite(perGpu) || perGpu <= 0) return 'noThroughput';
-  // Throughput exists, so only the disaggregated GPU count can be missing.
-  // Chart points may lack the counts an aggregate entry always has; an
-  // unknown count is exactly the "unavailable" case the helper reports.
-  const { allocatedGpus } = powerBasisNormalization({
-    output_tput_per_gpu: perGpu,
-    disagg: point.disagg ?? false,
-    benchmark_type: point.benchmark_type,
-    num_prefill_gpu: point.num_prefill_gpu ?? Number.NaN,
-    num_decode_gpu: point.num_decode_gpu ?? Number.NaN,
-  });
-  return allocatedGpus === null ? 'noNormalization' : 'noThroughput';
-}
-
-function powerBasisAvailability(points: readonly InferenceData[], metric: string) {
-  const counts = Object.fromEntries(
-    POWER_BASIS_AVAILABILITY_STATES.map((state) => [state, 0]),
-  ) as Record<PowerBasisAvailabilityState, number>;
-  for (const point of points) counts[powerBasisState(point, metric)]++;
-  return { metric, counts, available: counts.available, total: points.length };
-}
-
-export function PowerMetricAvailabilityPanel({
-  points,
-  metric,
-  onSelect,
-  loading = false,
-}: {
-  points: readonly InferenceData[];
-  metric: string;
-  onSelect: (metric: string) => void;
-  loading?: boolean;
-}) {
-  const locale = useLocale();
-  const t = STRINGS[locale];
-  const availability = useMemo(
-    () => [
-      ...powerMetricAvailability(points),
-      ...POWER_BASIS_METRIC_CONFIG_KEYS.map((key) => powerBasisAvailability(points, key)),
-    ],
-    [points],
-  );
-  const selected = availability.find((entry) => entry.metric === metric);
-  if (!selected) return null;
-  const isBasis = isPowerBasisConfigKey(metric);
-  const stateOf = (point: InferenceData) =>
-    isBasis ? powerBasisState(point, metric) : powerMetricState(point, metric);
-  // The two dictionaries overlap on `invalid`; the selected metric, not the
-  // key, decides which copy applies so the measured strings stay untouched.
-  const labelOf = (state: PowerAvailabilityState | PowerBasisAvailabilityState) =>
-    isBasis
-      ? t.basisLabels[state as PowerBasisAvailabilityState]
-      : t.labels[state as PowerAvailabilityState];
-  const sources = new Map<
-    string,
-    {
-      point: InferenceData;
-      state: PowerAvailabilityState | PowerBasisAvailabilityState;
-      count: number;
-    }
-  >();
-  for (const point of points) {
-    const state = stateOf(point);
-    if (state === 'strict' || state === 'available') continue;
-    const key = JSON.stringify([point.hwKey, point.run_url, state, point.power_invalid_reasons]);
-    const group = sources.get(key);
-    if (group) group.count++;
-    else sources.set(key, { point, state, count: 1 });
-  }
-  return (
-    <div
-      data-testid="power-metric-availability"
-      className="space-y-2 text-xs text-muted-foreground"
-    >
-      <p className="font-medium text-foreground">
-        {t.title}:{' '}
-        {loading
-          ? t.loading
-          : points.length > 0
-            ? t.summary(selected.available, selected.total)
-            : t.none}
-      </p>
-      {!loading && (
-        <>
-          <p>{t.scope}</p>
-          <p>
-            {Object.entries(selected.counts)
-              .filter(([, count]) => count > 0)
-              .map(
-                ([state, count]) =>
-                  `${labelOf(state as PowerAvailabilityState | PowerBasisAvailabilityState)}: ${count}`,
-              )
-              .join(' · ')}
-          </p>
-          <details
-            onToggle={(event) => {
-              if (event.currentTarget.open) track('inference_power_availability_opened');
-            }}
-          >
-            <summary className="cursor-pointer">{t.all}</summary>
-            <ul className="mt-2 space-y-1">
-              {availability.map((entry) => (
-                <li key={entry.metric}>
-                  <button
-                    type="button"
-                    className="text-left underline underline-offset-2"
-                    onClick={() => onSelect(entry.metric)}
-                  >
-                    {metricOptionTitle(entry.metric.slice(2) as MetricKey, locale)}:{' '}
-                    {entry.available}/{entry.total}
-                  </button>
-                </li>
-              ))}
-            </ul>
-            <p className="mt-2">{t.note}</p>
-          </details>
-          {sources.size > 0 && (
-            <details>
-              <summary className="cursor-pointer">{t.evidence}</summary>
-              <ul className="mt-2 max-h-48 space-y-2 overflow-auto">
-                {[...sources.values()].map(({ point, state, count }, index) => (
-                  <li key={index}>
-                    {point.hwKey}: {labelOf(state)} ({count})
-                    {point.power_invalid_reasons?.length
-                      ? ` · ${point.power_invalid_reasons.join(', ')}`
-                      : ''}
-                    {point.power_audit?.source ? ` · ${point.power_audit.source}` : ''}
-                    {point.run_url &&
-                      /^https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/actions\/runs\/\d+(?:\/attempts\/\d+)?$/u.test(
-                        point.run_url,
-                      ) && (
-                        <>
-                          {' '}
-                          ·{' '}
-                          <a
-                            href={point.run_url}
-                            target="_blank"
-                            rel="noreferrer"
-                            className="underline"
-                          >
-                            {t.run}
-                          </a>
-                        </>
-                      )}
-                  </li>
-                ))}
-              </ul>
-            </details>
-          )}
-        </>
-      )}
-    </div>
-  );
-}
-
-/** Reuse pre-metric rows, including overlays: absent power must not erase its own explanation. */
-export function PowerMetricAvailability({
-  metric,
-  onSelect,
-}: {
-  metric: string;
-  onSelect: (metric: string) => void;
-}) {
-  const { selectionPoints = [], loading, refreshing } = useInferenceData();
-  const {
-    selectedModel,
-    selectedSequence,
-    selectedPrecisions,
-    activeHwTypes,
-    quickFilters,
-    compareGpuPair,
-  } = useInferenceFilters();
-  const { getOverlayData, activeOverlayHwTypes, isUnofficialRun, localOfficialOverride } =
-    useUnofficialRun();
-  const points = useMemo(() => {
-    const officialHw = isUnofficialRun ? (localOfficialOverride ?? activeHwTypes) : activeHwTypes;
-    const official = selectionPoints.filter(
-      (point) =>
-        selectedPrecisions.includes(point.precision) && officialHw.has(String(point.hwKey)),
-    );
-    const overlay = getOverlayData?.(selectedModel, selectedSequence, 'interactivity')?.data ?? [];
-    return [
-      ...official,
-      ...overlay.filter(
-        (point) =>
-          selectedPrecisions.includes(point.precision) &&
-          activeOverlayHwTypes.has(String(point.hwKey)) &&
-          matchesQuickFilters(point, quickFilters) &&
-          (!compareGpuPair || hardwareKeyMatchesAnyBase(String(point.hwKey), compareGpuPair)),
-      ),
-    ];
-  }, [
-    selectionPoints,
-    selectedPrecisions,
-    activeHwTypes,
-    getOverlayData,
-    selectedModel,
-    selectedSequence,
-    activeOverlayHwTypes,
-    isUnofficialRun,
-    localOfficialOverride,
-    quickFilters,
-    compareGpuPair,
-  ]);
-  if (!isMeasuredEnergyConfigKey(metric) && !isPowerBasisConfigKey(metric)) return null;
-  return (
-    <PowerMetricAvailabilityPanel
-      points={points}
-      metric={metric}
-      onSelect={onSelect}
-      loading={loading || refreshing}
-    />
-  );
-}
diff --git a/packages/app/src/components/inference/ui/PowerPanelPlot.tsx b/packages/app/src/components/inference/ui/PowerPanelPlot.tsx
new file mode 100644
index 000000000..595200cd3
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerPanelPlot.tsx
@@ -0,0 +1,196 @@
+'use client';
+
+import * as d3 from 'd3';
+
+import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import type { CustomLayerConfig, LayerConfig } from '@/lib/d3-chart/D3Chart/types';
+import type { ContinuousScale } from '@/lib/d3-chart/types';
+
+/** One observed or derived value drawn as a marker. */
+export interface PanelMarker {
+  x: number;
+  y: number;
+  /** Series identity; the colour comes from `markerColor(key)`. */
+  key: string;
+  selected?: boolean;
+  /** Tooltip HTML; callers escape any source text. */
+  tooltip?: string;
+}
+
+/**
+ * A polyline drawn beneath the markers (series connections, fit lines). A
+ * non-finite y breaks the line; it never bridges a missing value.
+ */
+export interface PanelLine {
+  key: string;
+  points: { x: number; y: number }[];
+  color: string;
+  dash?: string;
+}
+
+const MARGIN = { top: 20, right: 18, bottom: 64, left: 65 };
+const compactNumber = d3.format('~g');
+const compact = (value: d3.AxisDomain) => compactNumber(Number(value));
+
+/** d3's log labelling: the 1× and 2× steps of each decade get labels, other ticks stay bare. */
+function logTickFormat(domain: [number, number]) {
+  const format = d3.scaleLog().domain(domain).tickFormat(5, '~g');
+  return (value: d3.AxisDomain) => format(Number(value));
+}
+
+function logDomain(values: number[]): [number, number] {
+  const positive = values.filter((value) => value > 0 && Number.isFinite(value));
+  if (positive.length === 0) return [1, 10];
+  const min = Math.min(...positive);
+  const max = Math.max(...positive);
+  return min === max ? [min / 2, max * 2] : [min / 1.25, max * 1.25];
+}
+
+/** Observed x range; a single value widens from zero so the marker is not on an edge. */
+function linearXDomain(values: number[]): [number, number] {
+  const finite = values.filter(Number.isFinite);
+  if (finite.length === 0) return [0, 1];
+  const min = Math.min(...finite);
+  const max = Math.max(...finite);
+  return min === max ? [0, max * 1.05 || 1] : [min, max];
+}
+
+/** Values plus zero and the reference, padded by a tenth of the span; never below zero for non-negative data. */
+function linearYDomain(values: number[], include: number[]): [number, number] {
+  const finite = [...values, ...include].filter(Number.isFinite);
+  const min = Math.min(...finite);
+  const max = Math.max(...finite);
+  const pad = (max - min || 1) * 0.1;
+  return [min >= 0 ? 0 : min - pad, max + pad];
+}
+
+/**
+ * Small D3 plot shared by the PowerX comparison panels: markers, optional
+ * connecting or fitted lines, and one dashed reference value (0 %, 50 %…).
+ * Log axes drop non-positive values instead of clamping them.
+ */
+export function PowerPanelPlot({
+  chartId,
+  markers,
+  lines = [],
+  markerColor,
+  xLabel,
+  yLabel,
+  reference = null,
+  xLog = false,
+  yLog = false,
+  xDomain,
+  yDomain,
+  xTickValues,
+  height = 320,
+}: {
+  chartId: string;
+  markers: PanelMarker[];
+  lines?: PanelLine[];
+  markerColor: (key: string) => string;
+  xLabel: string;
+  yLabel: string;
+  reference?: number | null;
+  xLog?: boolean;
+  yLog?: boolean;
+  xDomain?: [number, number];
+  yDomain?: [number, number];
+  /** Explicit x ticks, e.g. the observed concurrencies of a load sweep. */
+  xTickValues?: number[];
+  height?: number;
+}) {
+  const visible = (point: { x: number; y: number }) =>
+    Number.isFinite(point.x) &&
+    Number.isFinite(point.y) &&
+    (!xLog || point.x > 0) &&
+    (!yLog || point.y > 0);
+  const drawn = markers.filter(visible);
+  const drawnLines = lines.filter((line) => line.points.filter(visible).length > 1);
+  const everything = [...drawn, ...drawnLines.flatMap((line) => line.points.filter(visible))];
+  const xs = everything.map((point) => point.x);
+  const ys = everything.map((point) => point.y);
+  const x = xDomain ?? (xLog ? logDomain(xs) : linearXDomain(xs));
+  const y =
+    yDomain ??
+    (yLog ? logDomain(ys) : linearYDomain(ys, reference === null ? [0] : [0, reference]));
+  const colors = Object.fromEntries(drawnLines.map((line) => [line.key, line.color]));
+  const dashes = Object.fromEntries(drawnLines.map((line) => [line.key, line.dash ?? '']));
+  const drawReference: NonNullable<CustomLayerConfig['render']> = (group, ctx) => {
+    const scale = (ctx.renderedYScale ?? ctx.yScale) as ContinuousScale;
+    group
+      .selectAll('line')
+      .data(reference === null ? [] : [reference])
+      .join('line')
+      .attr('x1', 0)
+      .attr('x2', ctx.width)
+      .attr('y1', (value) => scale(value))
+      .attr('y2', (value) => scale(value))
+      .attr('stroke', 'currentColor')
+      .attr('stroke-dasharray', '5,4')
+      .attr('opacity', 0.6);
+  };
+  const layers: LayerConfig<PanelMarker>[] = [
+    { type: 'custom', key: 'reference', render: drawReference },
+    {
+      type: 'line',
+      key: 'lines',
+      lines: Object.fromEntries(drawnLines.map((line) => [line.key, line.points])),
+      config: {
+        curve: d3.curveLinear,
+        getColor: (key) => colors[key],
+        getStrokeDasharray: (key) => dashes[key] || 'none',
+        isDefined: visible,
+      },
+    },
+    {
+      type: 'point',
+      key: 'markers',
+      data: drawn,
+      config: {
+        getCx: () => 0,
+        getCy: () => 0,
+        getX: (point) => point.x,
+        getY: (point) => point.y,
+        getRadius: (point) => (point.selected ? 6 : 3),
+        getColor: (point) => markerColor(point.key),
+      },
+    },
+  ];
+  const hasTooltips = drawn.some((point) => point.tooltip);
+  return (
+    <D3Chart<PanelMarker>
+      chartId={`${chartId}-plot`}
+      data={drawn}
+      height={height}
+      testId={`${chartId}-plot`}
+      watermark="logo"
+      zoom={{ enabled: false }}
+      grabCursor={false}
+      instructions=""
+      margin={MARGIN}
+      xScale={{ type: xLog ? 'log' : 'linear', domain: x, nice: !xLog }}
+      yScale={{ type: yLog ? 'log' : 'linear', domain: y, nice: !yLog }}
+      xAxis={{
+        label: xLabel,
+        tickCount: 4,
+        ...(xTickValues ? { tickValues: xTickValues, tickFormat: compact } : {}),
+      }}
+      yAxis={{
+        label: yLabel,
+        tickCount: 5,
+        ...(yLog ? { tickFormat: logTickFormat(y) } : {}),
+      }}
+      layers={layers}
+      {...(hasTooltips
+        ? {
+            tooltip: {
+              rulerType: 'none' as const,
+              content: (point: PanelMarker) =>
+                `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md">${point.tooltip ?? ''}</div>`,
+              attachToLayer: 2,
+            },
+          }
+        : {})}
+    />
+  );
+}
diff --git a/packages/app/src/components/inference/ui/PowerRoleGroup.tsx b/packages/app/src/components/inference/ui/PowerRoleGroup.tsx
new file mode 100644
index 000000000..e8ce4cef6
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerRoleGroup.tsx
@@ -0,0 +1,321 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { Heading } from '@/components/ui/heading';
+import { exportToCsv } from '@/lib/csv-export';
+import { useLocale } from '@/lib/use-locale';
+import { escapeHtml } from '@/lib/utils';
+import type { AggDataEntry, InferenceData } from '../types';
+import {
+  getRolePoints,
+  type EqualServiceSource,
+  type RolePoint,
+} from '../utils/equal-service-comparison';
+import { powerVariantDash } from '../utils/power-compare';
+import { PowerPanelPlot, type PanelLine, type PanelMarker } from './PowerPanelPlot';
+
+type RoleSeriesKey = 'prefill' | 'decode' | 'total';
+type RolePanelId = 'power' | 'local-energy' | 'output-energy' | 'share';
+
+const STRINGS = {
+  en: {
+    title: 'Prefill and decode roles',
+    empty: 'No validated prefill/decode telemetry is available for these filters.',
+    panelEmpty: 'These observations do not report this role figure.',
+    roles: { prefill: 'Prefill', decode: 'Decode', total: 'Prefill + decode' },
+    panels: {
+      power: {
+        title: 'Mean GPU power by role',
+        axis: 'Mean GPU power (W/GPU)',
+        note: 'Mean board power per GPU inside each pool over the validated window.',
+        units: { prefill: 'W/GPU', decode: 'W/GPU', total: 'W/GPU' },
+      },
+      'local-energy': {
+        title: 'Role-local GPU energy',
+        axis: 'GPU energy (J/token, log)',
+        note: 'Prefill: prefill-pool joules ÷ input tokens. Decode: decode-pool joules ÷ output tokens. The denominators differ, so these two are not added.',
+        units: { prefill: 'J/input token', decode: 'J/output token', total: 'J/output token' },
+      },
+      'output-energy': {
+        title: 'GPU energy per output token by role',
+        axis: 'GPU energy (J/output token, log)',
+        note: 'Prefill energy restated per output token with the same window’s input:output token ratio, so prefill + decode is the request total.',
+        units: { prefill: 'J/output token', decode: 'J/output token', total: 'J/output token' },
+      },
+      share: {
+        title: 'Prefill energy share',
+        axis: 'Prefill energy share (%)',
+        note: 'Share = prefill ÷ (prefill + decode), both per output token. The dashed line marks 50%.',
+        units: { prefill: '%', decode: '%', total: '%' },
+      },
+    } satisfies Record<
+      RolePanelId,
+      { title: string; axis: string; note: string; units: Record<RoleSeriesKey, string> }
+    >,
+  },
+  zh: {
+    title: '预填充与解码角色',
+    empty: '当前筛选条件下没有经过验证的预填充 / 解码遥测数据。',
+    panelEmpty: '这些观测值没有报告该角色指标。',
+    roles: { prefill: '预填充', decode: '解码', total: '预填充 + 解码' },
+    panels: {
+      power: {
+        title: '各角色的平均 GPU 功耗',
+        axis: '平均 GPU 功耗（W/GPU）',
+        note: '有效测量窗口内各 GPU 池中每个 GPU 的平均板卡功耗。',
+        units: { prefill: 'W/GPU', decode: 'W/GPU', total: 'W/GPU' },
+      },
+      'local-energy': {
+        title: '各角色按本池 token 计的 GPU 能耗',
+        axis: 'GPU 能耗（J/token，对数）',
+        note: '预填充：预填充池焦耳数 ÷ 输入 token 数。解码：解码池焦耳数 ÷ 输出 token 数。两者分母不同，因此不相加。',
+        units: { prefill: 'J/输入 token', decode: 'J/输出 token', total: 'J/输出 token' },
+      },
+      'output-energy': {
+        title: '各角色每输出 token 的 GPU 能耗',
+        axis: 'GPU 能耗（J/输出 token，对数）',
+        note: '用同一窗口的输入:输出 token 比，把预填充能耗换算为每输出 token，因此预填充 + 解码等于整个请求的能耗。',
+        units: { prefill: 'J/输出 token', decode: 'J/输出 token', total: 'J/输出 token' },
+      },
+      share: {
+        title: '预填充能耗占比',
+        axis: '预填充能耗占比（%）',
+        note: '占比 = 预填充 ÷（预填充 + 解码），两者都按输出 token 计。虚线标记 50%。',
+        units: { prefill: '%', decode: '%', total: '%' },
+      },
+    } satisfies Record<
+      RolePanelId,
+      { title: string; axis: string; note: string; units: Record<RoleSeriesKey, string> }
+    >,
+  },
+};
+
+const PANELS: {
+  id: RolePanelId;
+  series: { role: RoleSeriesKey; value: (point: RolePoint) => number | null }[];
+  yLog?: boolean;
+  reference?: number;
+  yDomain?: [number, number];
+  /** Share points stay unconnected: each is one observed configuration. */
+  connect: boolean;
+}[] = [
+  {
+    id: 'power',
+    series: [
+      { role: 'prefill', value: (point) => point.prefillWattsPerGpu },
+      { role: 'decode', value: (point) => point.decodeWattsPerGpu },
+    ],
+    connect: true,
+  },
+  {
+    id: 'local-energy',
+    series: [
+      { role: 'prefill', value: (point) => point.prefillJoulesPerInputToken },
+      { role: 'decode', value: (point) => point.decodeJoulesPerOutputToken },
+    ],
+    yLog: true,
+    connect: true,
+  },
+  {
+    id: 'output-energy',
+    series: [
+      { role: 'prefill', value: (point) => point.energy?.prefill ?? null },
+      { role: 'decode', value: (point) => point.energy?.decode ?? null },
+      { role: 'total', value: (point) => point.energy?.total ?? null },
+    ],
+    yLog: true,
+    connect: true,
+  },
+  {
+    id: 'share',
+    series: [{ role: 'prefill', value: (point) => point.energy?.prefillShare ?? null }],
+    reference: 50,
+    yDomain: [0, 100],
+    connect: false,
+  },
+];
+const ROLE_DASH: Record<RoleSeriesKey, string> = {
+  prefill: powerVariantDash({ kind: 'role', id: 'prefill' }),
+  decode: powerVariantDash({ kind: 'role', id: 'decode' }),
+  total: '',
+};
+const value = d3.format(',.4~g');
+
+export default function PowerRoleGroup({
+  chartId,
+  data,
+  xField,
+  xLabel,
+  contextLabel,
+  sources,
+  colorOf,
+}: {
+  chartId: string;
+  data: InferenceData[];
+  xField: keyof AggDataEntry;
+  xLabel: string;
+  contextLabel?: string;
+  sources: EqualServiceSource[];
+  colorOf: (sourceKey: string) => string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const points = useMemo(() => getRolePoints(data, xField), [data, xField]);
+  const label = (key: string) => sources.find((source) => source.key === key)?.label ?? key;
+  const isConcurrency = xField === 'conc';
+  const concurrencies = isConcurrency ? [...new Set(points.map((point) => point.x))] : undefined;
+  const sectionId = `${chartId}-roles`;
+
+  const panel = (definition: (typeof PANELS)[number]) => {
+    const copy = t.panels[definition.id];
+    const plotId = `${chartId}-role-${definition.id}`;
+    const markers: PanelMarker[] = definition.series.flatMap(({ role, value: read }) =>
+      points.flatMap((point) => {
+        const y = read(point);
+        return y === null
+          ? []
+          : [
+              {
+                x: point.x,
+                y,
+                key: point.sourceKey,
+                tooltip: [
+                  `<strong>${escapeHtml(label(point.sourceKey))}</strong>`,
+                  `${escapeHtml(xLabel)}: ${value(point.x)} · c${point.point.conc}`,
+                  `${t.roles[role]}: ${value(y)} ${copy.units[role]}`,
+                ].join('<br/>'),
+              },
+            ];
+      }),
+    );
+    // Line keys become SVG class names, so they index the source rather than embed its key.
+    const lines: PanelLine[] = definition.connect
+      ? definition.series.flatMap(({ role, value: read }) =>
+          [...new Set(points.map((point) => point.sourceKey))].map((sourceKey, index) => ({
+            key: `source${index}-${role}`,
+            color: colorOf(sourceKey),
+            dash: ROLE_DASH[role],
+            points: points
+              .filter((point) => point.sourceKey === sourceKey)
+              .map((point) => ({ x: point.x, y: read(point) ?? Number.NaN })),
+          })),
+        )
+      : [];
+    return (
+      <figure key={definition.id} className="min-w-0 space-y-1">
+        <figcaption className="text-sm font-medium">{copy.title}</figcaption>
+        {markers.length > 0 ? (
+          <PowerPanelPlot
+            chartId={plotId}
+            markers={markers}
+            lines={lines}
+            markerColor={colorOf}
+            xLabel={xLabel}
+            yLabel={copy.axis}
+            reference={definition.reference ?? null}
+            xLog={isConcurrency}
+            yLog={definition.yLog}
+            yDomain={definition.yDomain}
+            xTickValues={concurrencies}
+            height={300}
+          />
+        ) : (
+          <p className="py-6 text-sm text-muted-foreground" data-testid={`${plotId}-empty`}>
+            {t.panelEmpty}
+          </p>
+        )}
+        <p className="text-xs text-muted-foreground">{copy.note}</p>
+      </figure>
+    );
+  };
+
+  const exportCsv = () => {
+    exportToCsv(
+      'InferenceX_prefill_decode_roles',
+      [
+        'source',
+        String(xField),
+        'concurrency',
+        'point_id',
+        'run_url',
+        'prefill_w_per_gpu',
+        'decode_w_per_gpu',
+        'prefill_j_per_input_token',
+        'decode_j_per_output_token',
+        'prefill_j_per_output_token',
+        'total_j_per_output_token',
+        'prefill_energy_share_pct',
+      ],
+      points.map((point) => [
+        label(point.sourceKey),
+        point.x,
+        point.point.conc,
+        point.point.id ?? null,
+        point.point.run_url ?? null,
+        point.prefillWattsPerGpu,
+        point.decodeWattsPerGpu,
+        point.prefillJoulesPerInputToken,
+        point.decodeJoulesPerOutputToken,
+        point.energy?.prefill ?? null,
+        point.energy?.total ?? null,
+        point.energy?.prefillShare ?? null,
+      ]),
+      contextLabel ? [contextLabel] : [],
+    );
+  };
+
+  const shownSources = sources.filter((source) =>
+    points.some((point) => point.sourceKey === source.key),
+  );
+  return (
+    <section id={sectionId} className="min-w-0 space-y-3" data-testid="prefill-share-panel">
+      <Heading as="h3" level="card">
+        {t.title}
+      </Heading>
+      <p className="export-only hidden text-sm text-muted-foreground">{contextLabel}</p>
+      {points.length > 0 ? (
+        <>
+          <div className="flex flex-wrap gap-x-5 gap-y-2 text-sm">
+            {shownSources.map((source) => (
+              <span key={source.key} className="min-w-0 break-all">
+                <span style={{ color: colorOf(source.key) }}>● </span>
+                {source.label}
+              </span>
+            ))}
+            {(['prefill', 'decode', 'total'] as const).map((role) => (
+              <span key={role} className="inline-flex items-center gap-2">
+                <svg width="28" height="10" aria-hidden="true">
+                  <line
+                    x1="0"
+                    x2="28"
+                    y1="5"
+                    y2="5"
+                    stroke="currentColor"
+                    strokeWidth="2"
+                    strokeDasharray={ROLE_DASH[role] || undefined}
+                  />
+                </svg>
+                {t.roles[role]}
+              </span>
+            ))}
+          </div>
+          <div className="grid min-w-0 gap-6 lg:grid-cols-2">{PANELS.map(panel)}</div>
+          <div className="max-h-0 overflow-hidden">
+            <div id={`${sectionId}-export`} className="p-4" />
+          </div>
+          <ChartButtons
+            chartId={sectionId}
+            analyticsPrefix="power_roles"
+            hideZoomReset
+            onExportCsv={exportCsv}
+          />
+        </>
+      ) : (
+        <p className="py-6 text-sm text-muted-foreground">{t.empty}</p>
+      )}
+    </section>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
new file mode 100644
index 000000000..4324ff1c8
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
@@ -0,0 +1,478 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { ChartButtons } from '@/components/ui/chart-buttons';
+import { Heading } from '@/components/ui/heading';
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
+import { useThemeColors } from '@/hooks/useThemeColors';
+import { useUrlState } from '@/hooks/useUrlState';
+import { track } from '@/lib/analytics';
+import { overlayRunColor, overlayRunIndex } from '@/lib/overlay-run-style';
+import { useLocale } from '@/lib/use-locale';
+import type { AggDataEntry, InferenceData } from '../types';
+import {
+  buildEqualServiceComparison,
+  equalServiceSourceKey,
+  getEqualServiceComparisonCurve,
+  getEqualServiceSources,
+  observedPoints,
+  type EqualServiceEstimate,
+  type EqualServiceReason,
+} from '../utils/equal-service-comparison';
+import MatchedConcurrencyTable from './MatchedConcurrencyTable';
+import PowerFitPanel from './PowerFitPanel';
+import { PowerPanelPlot } from './PowerPanelPlot';
+import PowerRoleGroup from './PowerRoleGroup';
+
+const STRINGS = {
+  en: {
+    compare: 'Compare at the same speed / latency',
+    roles: 'Prefill / decode roles',
+    fit: 'Power vs output-rate fit',
+    baseline: 'Baseline',
+    comparator: 'Comparator',
+    target: 'Target',
+    change: 'Change',
+    title: 'Power, throughput and energy at the same service point',
+    concurrency:
+      'Concurrency is a load diagnostic, not equal service. Select interactivity, TTFT or end-to-end latency for the equal-service comparison; the table below pairs observations at each concurrency.',
+    metric: 'Metric',
+    empty: 'No comparable points in the selected sources’ overlapping range.',
+    measured: 'Observed',
+    interpolated: 'Interpolated',
+    observation: 'Observation',
+    meanWattsPerGpu: 'Mean GPU power (W/GPU)',
+    outputTokensPerSecond: 'Deployment output (tok/s)',
+    joulesPerOutputToken: 'GPU energy (J/output token)',
+    percent: 'Comparator change (%)',
+    unavailable: 'Unavailable',
+  },
+  zh: {
+    compare: '在相同速度 / 延迟下比较',
+    roles: '预填充 / 解码角色',
+    fit: '功耗与输出速率拟合',
+    baseline: '基准',
+    comparator: '对比对象',
+    target: '目标值',
+    change: '变化',
+    title: '相同服务指标下的功耗、吞吐量与能耗',
+    concurrency:
+      '并发数用于分析负载，并不代表相同服务水平。相同服务水平的比较请选择交互性、首 token 延迟或端到端延迟；下表按各并发数配对观测值。',
+    metric: '指标',
+    empty: '所选数据源的重叠范围内没有可比较的数据。',
+    measured: '实测',
+    interpolated: '插值',
+    observation: '观测点',
+    meanWattsPerGpu: '平均 GPU 功耗（W/GPU）',
+    outputTokensPerSecond: '部署输出吞吐量（tok/s）',
+    joulesPerOutputToken: 'GPU 能耗（J/输出 token）',
+    percent: '对比对象变化（%）',
+    unavailable: '不可用',
+  },
+};
+const REASONS: Record<EqualServiceReason, [string, string]> = {
+  'unsupported-axis': ['Select a service axis.', '请选择服务指标横轴。'],
+  'invalid-target': ['Enter a positive finite target.', '请输入有效的正数目标值。'],
+  'same-source': ['Choose two different sources.', '请选择两个不同的数据源。'],
+  'unknown-source': [
+    'A selected source is unavailable under these filters.',
+    '当前筛选条件下找不到所选数据源。',
+  ],
+  'out-of-range': ['Target is outside a source range.', '目标值超出数据源范围。'],
+  'ambiguous-x': [
+    'Conflicting observations at the same X; no value selected.',
+    '相同横轴值有冲突的观测数据，未选择数值。',
+  ],
+  'missing-metric': ['A required observation is missing this metric.', '所需观测点缺少该指标。'],
+};
+const METRICS = ['meanWattsPerGpu', 'outputTokensPerSecond', 'joulesPerOutputToken'] as const;
+const DASHES = ['', '6,4', '2,3'];
+const number = d3.format(',.4~g');
+const percent = d3.format('+.2f');
+
+function PanelToggle({
+  checked,
+  onChange,
+  label,
+  testId,
+  event,
+}: {
+  checked: boolean;
+  onChange: (checked: boolean) => void;
+  label: string;
+  testId: string;
+  event: string;
+}) {
+  return (
+    <label className="flex items-center gap-2">
+      <input
+        type="checkbox"
+        checked={checked}
+        onChange={(e) => {
+          onChange(e.target.checked);
+          track(event, { enabled: e.target.checked });
+        }}
+        data-testid={testId}
+      />
+      {label}
+    </label>
+  );
+}
+
+/**
+ * PowerX analysis panels under a measured-power chart: equal-service and
+ * matched-concurrency comparisons, the prefill/decode role group and the
+ * power-vs-output-rate fit. Every panel reads the chart's visible official and
+ * `?unofficialrun=` rows; overlay sources take their run's legend colour.
+ */
+export default function PowerServiceComparison({
+  data,
+  overlayData = [],
+  xField,
+  xLabel,
+  interactivityField,
+  chartId,
+  contextLabel,
+}: {
+  data: InferenceData[];
+  /** The subset of `data` loaded from unofficial runs. */
+  overlayData?: readonly InferenceData[];
+  xField: keyof AggDataEntry;
+  xLabel: string;
+  /** Streaming-speed field at the selected statistic, for load-matched rows. */
+  interactivityField: keyof AggDataEntry;
+  chartId: string;
+  contextLabel?: string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const { getUrlParam, setUrlParams } = useUrlState();
+  const { runIndexByUrl } = useUnofficialRun();
+  const [enabled, setEnabled] = useState(() => getUrlParam('i_servicecompare') === '1');
+  const [roleShare, setRoleShare] = useState(() => getUrlParam('i_roleshare') === '1');
+  const [powerFit, setPowerFit] = useState(() => getUrlParam('i_powerfit') === '1');
+  const [baseline, setBaseline] = useState(() => getUrlParam('i_servicebase') ?? '');
+  const [comparator, setComparator] = useState(() => getUrlParam('i_servicepeer') ?? '');
+  const [target, setTarget] = useState(() => getUrlParam('i_servicetarget') ?? '');
+  const sources = useMemo(() => getEqualServiceSources(data, locale), [data, locale]);
+  const base = baseline || sources[0]?.key || '';
+  const peer = comparator || sources[1]?.key || '';
+  const previousAxis = useRef(xField);
+  useEffect(() => {
+    if (previousAxis.current !== xField) {
+      previousAxis.current = xField;
+      setTarget('');
+      setUrlParams({ i_servicetarget: '' });
+    }
+  }, [xField, setUrlParams]);
+  useEffect(() => {
+    setUrlParams({
+      i_servicecompare: enabled ? '1' : '0',
+      i_roleshare: roleShare ? '1' : '0',
+      i_powerfit: powerFit ? '1' : '0',
+      i_servicebase: enabled ? base : baseline,
+      i_servicepeer: enabled ? peer : comparator,
+      i_servicetarget: target,
+    });
+  }, [enabled, roleShare, powerFit, base, peer, baseline, comparator, target, setUrlParams]);
+  const curve = useMemo(
+    () =>
+      enabled
+        ? getEqualServiceComparisonCurve(data, {
+            baseline: base,
+            comparator: peer,
+            xField,
+          })
+        : [],
+    [enabled, data, base, peer, xField],
+  );
+  const comparison = useMemo(
+    () =>
+      enabled && target.trim()
+        ? buildEqualServiceComparison(data, {
+            baseline: base,
+            comparator: peer,
+            xField,
+            target: Number(target),
+          })
+        : null,
+    [enabled, data, base, peer, xField, target],
+  );
+  const { resolveColor } = useThemeColors({
+    highContrast: true,
+    identifiers: [...METRICS, ...sources.map((s) => s.key)],
+  });
+  const metricColors = Object.fromEntries(METRICS.map((key) => [key, resolveColor(key)]));
+  const overlaySourceKeys = useMemo(
+    () => new Map(observedPoints(overlayData).map((p) => [equalServiceSourceKey(p), p.run_url])),
+    [overlayData],
+  );
+  const colorOf = useCallback(
+    (key: string) =>
+      overlaySourceKeys.has(key)
+        ? overlayRunColor(overlayRunIndex(overlaySourceKeys.get(key), runIndexByUrl))
+        : resolveColor(key),
+    [overlaySourceKeys, runIndexByUrl, resolveColor],
+  );
+  const sourceLabel = (key: string) =>
+    sources.find((source) => source.key === key)?.label ?? t.unavailable;
+  // The percentage of interpolated raw values is not linear in X. Include the
+  // exact selected target as a knot so its plotted marker agrees with the table.
+  const plottedCurve =
+    comparison && Object.values(comparison.metrics).some((metric) => metric.changePercent !== null)
+      ? [...curve.filter((row) => row.target !== comparison.target), comparison].sort(
+          (a, b) => a.target - b.target,
+        )
+      : curve;
+  const plotPoints = METRICS.flatMap((key) =>
+    plottedCurve.map((row) => ({
+      key,
+      x: row.target,
+      y: row.metrics[key].changePercent ?? NaN,
+      selected: row.target === comparison?.target,
+    })),
+  );
+  const reason = (value?: EqualServiceReason) =>
+    value ? REASONS[value][locale === 'zh' ? 1 : 0] : t.unavailable;
+  const estimate = (value: EqualServiceEstimate | null) =>
+    value ? (
+      <>
+        <strong>{number(value.value)}</strong>
+        <span className="block text-xs text-muted-foreground">
+          {value.interpolated ? t.interpolated : t.measured}
+        </span>
+        <span className="block text-xs text-muted-foreground">
+          {value.endpoints
+            .map(
+              (endpoint) =>
+                `${t.observation} ${endpoint.point.id ?? '—'}: ${number(endpoint.x)} · c${endpoint.point.conc}`,
+            )
+            .join(' → ')}
+        </span>
+      </>
+    ) : (
+      '—'
+    );
+  const selectClass = 'w-full min-w-0 rounded-md border bg-background p-2 text-sm';
+  const sourceSelect = (
+    value: string,
+    onChange: (value: string) => void,
+    label: string,
+    testId: string,
+    role: 'baseline' | 'comparator',
+  ) => (
+    <label className="min-w-0 space-y-1 text-sm">
+      <span>{label}</span>
+      <select
+        className={selectClass}
+        aria-label={label}
+        data-testid={testId}
+        value={value}
+        onChange={(event) => {
+          onChange(event.target.value);
+          track('inference_equal_service_source_changed', { role });
+        }}
+      >
+        {!sources.some((source) => source.key === value) && (
+          <option value={value}>{t.unavailable}</option>
+        )}
+        {sources.map((source) => (
+          <option key={source.key} value={source.key}>
+            {source.label}
+          </option>
+        ))}
+      </select>
+    </label>
+  );
+  return (
+    <div className="mt-6 min-w-0 space-y-4 border-t pt-4" data-testid="power-service-comparison">
+      <div className="no-export flex flex-wrap gap-4 text-sm">
+        <PanelToggle
+          checked={enabled}
+          onChange={setEnabled}
+          label={t.compare}
+          testId="equal-service-toggle"
+          event="inference_equal_service_toggled"
+        />
+        <PanelToggle
+          checked={roleShare}
+          onChange={setRoleShare}
+          label={t.roles}
+          testId="role-share-toggle"
+          event="inference_power_roles_toggled"
+        />
+        <PanelToggle
+          checked={powerFit}
+          onChange={setPowerFit}
+          label={t.fit}
+          testId="power-fit-toggle"
+          event="inference_power_fit_toggled"
+        />
+      </div>
+      {enabled && (
+        <>
+          <div className="no-export grid min-w-0 gap-3 md:grid-cols-2">
+            {sourceSelect(base, setBaseline, t.baseline, 'equal-service-baseline', 'baseline')}
+            {sourceSelect(
+              peer,
+              setComparator,
+              t.comparator,
+              'equal-service-comparator',
+              'comparator',
+            )}
+          </div>
+          {xField === 'conc' ? (
+            <p
+              className="text-sm text-muted-foreground"
+              data-testid="equal-service-concurrency-note"
+            >
+              {t.concurrency}
+            </p>
+          ) : (
+            <section
+              id={`${chartId}-service`}
+              className="min-w-0 space-y-3"
+              data-testid="equal-service-panel"
+            >
+              <Heading as="h3" level="card">
+                {t.title}
+              </Heading>
+              <p className="export-only hidden text-sm text-muted-foreground">{contextLabel}</p>
+              {/* The source selects are no-export, so exported images name the pair here. */}
+              <p
+                className="export-only hidden break-words text-sm"
+                data-testid="equal-service-pair"
+              >
+                {t.baseline}: {sourceLabel(base)} → {t.comparator}: {sourceLabel(peer)}
+              </p>
+              <div className="flex flex-wrap gap-x-5 gap-y-2 text-sm">
+                {METRICS.map((key, index) => (
+                  <span key={key} className="inline-flex items-center gap-2">
+                    <svg width="28" height="10" aria-hidden="true">
+                      <line
+                        x1="0"
+                        x2="28"
+                        y1="5"
+                        y2="5"
+                        stroke={metricColors[key]}
+                        strokeWidth="2"
+                        strokeDasharray={DASHES[index]}
+                      />
+                    </svg>
+                    {t[key]}
+                  </span>
+                ))}
+              </div>
+              {plotPoints.some((p) => Number.isFinite(p.y)) ? (
+                <PowerPanelPlot
+                  chartId={`${chartId}-service`}
+                  markers={plotPoints.filter((p) => Number.isFinite(p.y))}
+                  lines={METRICS.map((key, index) => ({
+                    key,
+                    color: metricColors[key],
+                    dash: DASHES[index],
+                    points: plotPoints.filter((p) => p.key === key),
+                  }))}
+                  markerColor={(key) => metricColors[key]}
+                  xLabel={xLabel}
+                  yLabel={t.percent}
+                  reference={0}
+                  height={360}
+                />
+              ) : (
+                <p className="py-6 text-sm text-muted-foreground">{t.empty}</p>
+              )}
+              <div className="max-h-0 overflow-hidden">
+                <div id={`${chartId}-service-export`} className="p-4" />
+              </div>
+              <ChartButtons
+                chartId={`${chartId}-service`}
+                analyticsPrefix="equal_service"
+                hideZoomReset
+              />
+              <label className="no-export block max-w-lg space-y-1 text-sm">
+                {t.target} · {xLabel}
+                <input
+                  className={selectClass}
+                  type="number"
+                  min="0"
+                  step="any"
+                  value={target}
+                  onChange={(e) => setTarget(e.target.value)}
+                  data-testid="equal-service-target"
+                />
+              </label>
+              {comparison && (
+                <div className="min-w-0">
+                  <table
+                    className="w-full table-fixed break-words text-left text-sm"
+                    data-testid="equal-service-table"
+                  >
+                    <caption className="mb-2 text-left">
+                      {xLabel}: {number(comparison.target)}
+                    </caption>
+                    <thead>
+                      <tr>
+                        <th className="p-2">{t.metric}</th>
+                        <th className="p-2">{t.baseline}</th>
+                        <th className="p-2">{t.comparator}</th>
+                        <th className="p-2">{t.change}</th>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {METRICS.map((key) => (
+                        <tr className="border-t" key={key} data-testid={`equal-service-${key}`}>
+                          <th className="p-2 font-medium">{t[key]}</th>
+                          <td className="p-2 align-top">
+                            {estimate(comparison.metrics[key].baseline)}
+                          </td>
+                          <td className="p-2 align-top">
+                            {estimate(comparison.metrics[key].comparator)}
+                          </td>
+                          <td className="p-2 align-top">
+                            {comparison.metrics[key].changePercent === null
+                              ? reason(comparison.metrics[key].reason)
+                              : `${percent(comparison.metrics[key].changePercent!)}%`}
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                </div>
+              )}
+            </section>
+          )}
+          <MatchedConcurrencyTable
+            chartId={chartId}
+            data={data}
+            baseline={base}
+            comparator={peer}
+            interactivityField={interactivityField}
+            sourceLabel={sourceLabel}
+          />
+        </>
+      )}
+      {roleShare && (
+        <PowerRoleGroup
+          chartId={chartId}
+          data={data}
+          xField={xField}
+          xLabel={xLabel}
+          contextLabel={contextLabel}
+          sources={sources}
+          colorOf={colorOf}
+        />
+      )}
+      {powerFit && (
+        <PowerFitPanel
+          chartId={chartId}
+          data={data}
+          contextLabel={contextLabel}
+          colorOf={colorOf}
+        />
+      )}
+    </div>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/PowerTimeline.tsx b/packages/app/src/components/inference/ui/PowerTimeline.tsx
index 45ccecf58..3c6f2bd8f 100644
--- a/packages/app/src/components/inference/ui/PowerTimeline.tsx
+++ b/packages/app/src/components/inference/ui/PowerTimeline.tsx
@@ -13,7 +13,9 @@
  * (`components/gpu-power/power-series.ts`).
  *
  * One trace per config, coloured by hardware (official) or by run (unofficial
- * overlay). The validated measurement window is emphasized; the rest of the
+ * overlay); in date comparison, official traces take the GPUGraph colour and
+ * legend toggle of their (date, hardware) series. The validated measurement
+ * window is emphasized; the rest of the
  * job (server start, warmup) is drawn faint. Rated TDP is a dashed reference
  * per hardware; the all-in provisioned line is opt-in because it would halve
  * the vertical resolution of the traces.
@@ -35,11 +37,14 @@ import {
   type GpuPowerSeries,
   type GpuPowerSeriesResponse,
 } from '@/components/gpu-power/power-series';
+import { useComparisonSeries } from '@/components/inference/hooks/useComparisonSeries';
+import { comparisonEntryLabel } from '@/components/inference/utils/comparisonEntry';
 import ChartLegend, { type LegendSwitchConfig } from '@/components/ui/chart-legend';
 import { SegmentedToggle } from '@/components/ui/segmented-toggle';
 import { useUnofficialRun } from '@/components/unofficial-run-provider';
 import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
 import { useThemeColors } from '@/hooks/useThemeColors';
+import { useUrlState } from '@/hooks/useUrlState';
 import { track } from '@/lib/analytics';
 import { computeToggle } from '@/lib/toggle-set';
 import { getModelSortIndex } from '@/lib/constants';
@@ -59,25 +64,30 @@ import {
 } from '../InferenceContext';
 import type { InferenceData, OverlayData } from '../types';
 import { powerVariantDash } from '../utils/power-compare';
+import PowerTimelineSummary from './PowerTimelineSummary';
 import {
   allGpuPool,
   consumePowerTraceFocus,
   groupPoolsBySize,
+  hasPowerTimelineWindow,
+  parsePowerTimelineParams,
+  powerTimelineSampleX,
   joinPowerTimeline,
   planPowerTimelineRequests,
   prioritizeRun,
   prioritizeRuns,
   referenceLabelSlots,
+  stackTraceLabels,
   runIdFromUrl,
   traceConfigLabel,
   traceKeyRunId,
   tracePools,
   windowPhase,
-  type MissingTrace,
-  type MissingTraceReason,
   type PoolSizeGroup,
   type PowerPool,
   type PowerPoolRole,
+  type PowerTimelineAxis,
+  type PowerTimelineLines,
   type PowerTimelineRequest,
   type PowerTimelineTrace,
   type WindowPhase,
@@ -89,16 +99,25 @@ export const POWER_TIMELINE_MAX_RUNS = 4;
 const HIT_POINTS_PER_TRACE = 200;
 /** Above this many visible traces the `c<conc>` end labels would only overlap. */
 const MAX_LABELED_TRACES = 40;
-/** Up to this many undrawn configs are named individually; beyond, per hardware. */
-const MAX_LISTED_MISSING = 8;
 const CHART_HEIGHT = 600;
 const MARGIN = { top: 24, right: 84, bottom: 60, left: 64 };
 
 const STRINGS = {
   en: {
     timeAxis: 'Time axis',
+    concurrency: 'Concurrency',
+    allConcurrencies: 'All',
     wall: 'Wall clock (UTC)',
-    elapsed: 'Since start',
+    elapsed: 'Since telemetry start',
+    serving: 'Since serving start',
+    xServing: 'Time since serving-window start (s)',
+    windowOnly: 'Validated window only',
+    windowOnlyHelp:
+      'Show only retained samples inside each recorded validated serving window. Traces without valid window bounds are omitted.',
+    missingWindow: (count: number) =>
+      `${count} trace${count === 1 ? '' : 's'} omitted: no valid serving-window bounds.`,
+    missingFocus:
+      'The selected trace is unavailable for these filters or has no retained telemetry.',
     xWall: 'Time (UTC)',
     xElapsed: 'Time since telemetry start (m:ss)',
     perGpu: 'One line per GPU',
@@ -112,17 +131,6 @@ const STRINGS = {
     loading: (runs: number) =>
       `Loading GPU telemetry for ${runs} run${runs === 1 ? '' : 's'}… (may take a minute)`,
     loadError: (runId: string, message: string) => `Run ${runId}: ${message}`,
-    missing: (missing: number, total: number) =>
-      `${missing} of ${total} measured configs have no telemetry trace and are not drawn.`,
-    missingReason: {
-      'no-source': (count: number) =>
-        `${count} predate per-config telemetry provenance in the benchmark row`,
-      'no-run': (count: number) => `${count} carry no workflow run`,
-      'run-not-fetched': (count: number) => `${count} come from runs that were not loaded`,
-      'not-in-run': (count: number) =>
-        `${count} have no gpu_metrics artifact or power-audit bundle in their run (expired, or another collector)`,
-    } satisfies Record<MissingTraceReason, (count: number) => string>,
-    missingUndrawn: 'Not drawn',
     noTraces:
       'No telemetry traces for the visible hardware. Enable a series in the legend or choose another date.',
     noArtifacts:
@@ -130,10 +138,6 @@ const STRINGS = {
     droppedRuns: (runs: number) =>
       `Telemetry from ${runs} more run${runs === 1 ? '' : 's'} was not loaded (limit ${POWER_TIMELINE_MAX_RUNS} runs per chart).`,
     telemetry: 'Telemetry',
-    method:
-      'One-second means of per-GPU board power (nvidia-smi / amd-smi, or DCGM on Slurm / Dynamo runs) over the whole benchmark job; the emphasized segment is the validated window behind the measured average. Dashed lines: rated TDP per hardware from the hardware registry.',
-    methodPools:
-      'In pool mode each line is the summed power of one worker-role pool (prefill or decode GPUs) and the dashed references are pool size × rated TDP.',
     instructions:
       'Shift+Scroll to zoom horizontally · Drag to pan · Double-click to reset · Click a point to pin tooltip',
     dismiss: 'Click elsewhere to dismiss',
@@ -167,8 +171,16 @@ const STRINGS = {
   },
   zh: {
     timeAxis: '时间轴',
+    concurrency: '并发数',
+    allConcurrencies: '全部',
     wall: '实际时刻（UTC）',
-    elapsed: '相对起点',
+    elapsed: '距遥测起点',
+    serving: '距服务窗口起点',
+    xServing: '距服务窗口开始的时间（秒）',
+    windowOnly: '仅显示有效测量窗口',
+    windowOnlyHelp: '仅显示已记录的有效服务窗口内保留的采样点；缺少有效窗口边界的曲线不绘制。',
+    missingWindow: (count: number) => `${count} 条曲线缺少有效服务窗口边界，未绘制。`,
+    missingFocus: '所选曲线不符合当前筛选条件，或没有保留的遥测数据。',
     xWall: '时间（UTC）',
     xElapsed: '距遥测开始的时间（分:秒）',
     perGpu: '每个 GPU 一条线',
@@ -181,25 +193,11 @@ const STRINGS = {
       '按硬件注册表中每 GPU 的全电源配置（all-in）市电功率绘制虚线参考（SemiAnalysis 数据中心行业模型）。默认关闭，因为它会压缩曲线的纵向分辨率。',
     loading: (runs: number) => `正在加载 ${runs} 个运行的 GPU 遥测数据……（可能需要约一分钟）`,
     loadError: (runId: string, message: string) => `运行 ${runId}：${message}`,
-    missing: (missing: number, total: number) =>
-      `${total} 个有实测值的配置中有 ${missing} 个没有遥测曲线，未绘制。`,
-    missingReason: {
-      'no-source': (count: number) => `${count} 个的基准测试行早于按配置记录的遥测来源`,
-      'no-run': (count: number) => `${count} 个没有工作流运行信息`,
-      'run-not-fetched': (count: number) => `${count} 个来自未加载的运行`,
-      'not-in-run': (count: number) =>
-        `${count} 个在其运行中没有 gpu_metrics 产物或 power-audit 数据包（产物已过期，或使用其他采集器）`,
-    } satisfies Record<MissingTraceReason, (count: number) => string>,
-    missingUndrawn: '未绘制',
     noTraces: '当前可见硬件没有遥测曲线。请在图例中启用一个系列或选择其他日期。',
     noArtifacts: '这些数据点早于按配置上传的遥测产物，因此没有可用的时间线。',
     droppedRuns: (runs: number) =>
       `另有 ${runs} 个运行的遥测数据未加载（每张图表最多 ${POWER_TIMELINE_MAX_RUNS} 个运行）。`,
     telemetry: '遥测来源',
-    method:
-      '整个基准测试任务期间每个 GPU 板卡功耗（nvidia-smi / amd-smi，Slurm / Dynamo 运行为 DCGM）的一秒平均值；加粗段为实测平均值所依据的有效测量窗口。虚线：硬件注册表中各硬件的额定 TDP。',
-    methodPools:
-      '在 GPU 池模式下，每条线是一个 worker 角色池（预填充或解码 GPU）的功耗总和，虚线参考为池内 GPU 数量 × 额定 TDP。',
     instructions: 'Shift+滚轮横向缩放 · 拖动平移 · 双击重置 · 点击数据点固定提示框',
     dismiss: '点击其他区域关闭',
     phase: {
@@ -232,8 +230,8 @@ const STRINGS = {
   },
 } as const;
 
-type XMode = 'wall' | 'elapsed';
-type LineMode = 'mean' | 'gpu' | 'pool';
+type XMode = PowerTimelineAxis;
+type LineMode = PowerTimelineLines;
 
 interface TimelineSample {
   trace: PowerTimelineTrace;
@@ -263,6 +261,8 @@ interface TracePath {
   id: string;
   traceKey: string;
   hwKey: string;
+  /** Date comparison: the official trace's `${date}_${hwKey}` legend series. */
+  series?: string;
   overlayIndex: number | null;
   color: string;
   segment: 'full' | 'window';
@@ -291,6 +291,7 @@ interface TraceLabel {
   id: string;
   traceKey: string;
   hwKey: string;
+  series?: string;
   pool?: PowerPoolRole;
   color: string;
   text: string;
@@ -310,6 +311,10 @@ export interface PowerTimelineProps {
   overlayData?: OverlayData;
   yLabel: string;
   caption?: React.ReactNode;
+  /** Date comparison: official traces follow the per-date legend series. */
+  comparison?: boolean;
+  /** Run numbers shared with the comparison changelog and GPUGraph legend. */
+  runNumbering?: Map<string, number>;
 }
 
 async function fetchPowerSeries(
@@ -346,10 +351,21 @@ const formatUtcDate = d3.utcFormat('%Y-%m-%d');
 /** Pool sums run to thousands of watts; group the digits. */
 const formatWatts = d3.format(',.0f');
 
+/** Rough advance of one label character at the data-label size. */
+const LABEL_CHAR_WIDTH = 6.5;
+
 function baseHardware(hwKey: string): string {
   return hwKey.split('_')[0];
 }
 
+function runIdsOf(points: readonly InferenceData[]): Set<string> {
+  return new Set(
+    points
+      .map((point) => runIdFromUrl(point.run_url))
+      .filter((runId): runId is string => runId !== null),
+  );
+}
+
 /**
  * The pools a trace draws in pool mode: its worker-role pools, or every GPU as
  * one pool when the collector assigned no roles (a single-node trace then shows
@@ -394,10 +410,9 @@ function tracePaths(
   overlayIndex: number | null,
   xMode: XMode,
   lineMode: LineMode,
+  windowOnly: boolean,
 ): TracePath[] {
   const { series } = trace;
-  const xOf = (column: number) =>
-    xMode === 'wall' ? bucketTimeMs(series, column) : series.t[column] - series.t[0];
   const rows = traceRows(series, lineMode);
   const faint = lineMode === 'gpu' ? 0.22 : 0.32;
   const strong = lineMode === 'gpu' ? 0.85 : 1;
@@ -407,22 +422,25 @@ function tracePaths(
     const full: TracePoint[] = [];
     const window: TracePoint[] = [];
     row.values.forEach((value, column) => {
-      const point = { x: xOf(column), y: value };
+      const x = powerTimelineSampleX(trace, column, xMode, windowOnly);
+      if (x === null) return;
+      const point = { x, y: value };
       full.push(point);
       if (windowPhase(trace, bucketTimeMs(series, column)) === 'window') window.push(point);
     });
-    paths.push({
-      id: `${trace.key}:${row.id}:full`,
-      traceKey: trace.key,
-      hwKey: trace.point.hwKey,
-      overlayIndex,
-      color,
-      segment: 'full',
-      width: widths[0],
-      opacity: faint,
-      points: full,
-      pool: row.pool,
-    });
+    if (!windowOnly && full.length > 1)
+      paths.push({
+        id: `${trace.key}:${row.id}:full`,
+        traceKey: trace.key,
+        hwKey: trace.point.hwKey,
+        overlayIndex,
+        color,
+        segment: 'full',
+        width: widths[0],
+        opacity: faint,
+        points: full,
+        pool: row.pool,
+      });
     if (window.length > 1) {
       paths.push({
         id: `${trace.key}:${row.id}:window`,
@@ -451,14 +469,15 @@ function traceSamples(
   overlayIndex: number | null,
   xMode: XMode,
   lineMode: LineMode,
+  windowOnly: boolean,
 ): TimelineSample[] {
   const { series } = trace;
   if (lineMode !== 'pool') {
     const rows = series.power.map((_, row) => row);
-    return sampleRows(trace, color, overlayIndex, xMode, rows, undefined);
+    return sampleRows(trace, color, overlayIndex, xMode, windowOnly, rows, undefined);
   }
   return drawnPools(series).flatMap((pool) =>
-    sampleRows(trace, color, overlayIndex, xMode, pool.rows, {
+    sampleRows(trace, color, overlayIndex, xMode, windowOnly, pool.rows, {
       role: pool.role,
       gpuCount: pool.rows.length,
     }),
@@ -470,12 +489,15 @@ function sampleRows(
   color: string,
   overlayIndex: number | null,
   xMode: XMode,
+  windowOnly: boolean,
   rows: readonly number[],
   pool: TimelineSample['pool'],
 ): TimelineSample[] {
   const { series } = trace;
   const samples: TimelineSample[] = [];
   for (let column = 0; column < series.t.length; column++) {
+    const x = powerTimelineSampleX(trace, column, xMode, windowOnly);
+    if (x === null) continue;
     let sum = 0;
     let count = 0;
     let min = Number.POSITIVE_INFINITY;
@@ -497,7 +519,7 @@ function sampleRows(
       overlayIndex,
       column,
       timeMs,
-      x: xMode === 'wall' ? timeMs : series.t[column] - series.t[0],
+      x,
       y: pool ? sum : sum / count,
       min,
       max,
@@ -544,7 +566,7 @@ function drawTraces(
     .attr('data-trace-key', (path) => path.traceKey)
     .attr('data-hw', (path) => path.hwKey)
     .attr('data-segment', (path) => path.segment)
-    .attr('data-run-index', (path) => (path.overlayIndex === null ? null : path.overlayIndex))
+    .attr('data-run-index', (path) => path.overlayIndex)
     .attr('data-pool', (path) => path.pool ?? null)
     .attr('stroke-dasharray', (path) => (path.pool ? poolDash(path.pool) : null))
     .attr('stroke', (path) => path.color)
@@ -553,11 +575,17 @@ function drawTraces(
     .attr('d', (path) => line(path.points));
 }
 
+function isHighlighted(mark: TracePath | TraceLabel, highlight: string): boolean {
+  return highlight === mark.hwKey || highlight === mark.traceKey || highlight === mark.series;
+}
+
 function traceOpacity(path: TracePath, highlight: string | null): number {
   if (highlight === null) return path.opacity;
-  return highlight === path.hwKey || highlight === path.traceKey
-    ? Math.min(1, path.opacity + 0.15)
-    : path.opacity * 0.15;
+  return isHighlighted(path, highlight) ? Math.min(1, path.opacity + 0.15) : path.opacity * 0.15;
+}
+
+function labelOpacity(label: TraceLabel, highlight: string | null): number {
+  return highlight === null || isHighlighted(label, highlight) ? 1 : 0.2;
 }
 
 function drawLabels(
@@ -585,20 +613,26 @@ function drawLabels(
     .attr('data-hw', (label) => label.hwKey)
     .attr('data-pool', (label) => label.pool ?? null)
     .attr('fill', (label) => label.color)
-    .attr('opacity', (label) =>
-      highlight === null || highlight === label.hwKey || highlight === label.traceKey ? 1 : 0.2,
-    )
-    .text((label) => label.text)
-    .each(function (label) {
-      const x = xScale(label.x);
-      const y = yScale(label.y);
-      // Sit just past the last sample; flip inside the plot near the right edge.
-      const overflow = x + 6 + label.text.length * 6.5 > plotWidth;
-      d3.select(this)
-        .attr('text-anchor', overflow ? 'end' : 'start')
-        .attr('x', overflow ? x - 6 : x + 6)
-        .attr('y', y);
-    });
+    .attr('opacity', (label) => labelOpacity(label, highlight))
+    .text((label) => label.text);
+  // Sit just past the last sample; flip inside the plot near the right edge.
+  const boxes = model.labels.map((label) => {
+    const x = xScale(label.x);
+    const width = label.text.length * LABEL_CHAR_WIDTH;
+    const flip = x + 6 + width > plotWidth;
+    const left = flip ? x - 6 - width : x + 6;
+    return { flip, left, right: left + width, y: yScale(label.y) };
+  });
+  const rows = stackTraceLabels(boxes, CHART_TYPE.dataLabel + 2);
+  const byId = new Map(model.labels.map((label, index) => [label.id, index]));
+  group.selectAll<SVGTextElement, TraceLabel>('text.power-trace-label').each(function (label) {
+    const index = byId.get(label.id)!;
+    const box = boxes[index];
+    d3.select(this)
+      .attr('text-anchor', box.flip ? 'end' : 'start')
+      .attr('x', box.flip ? box.right : box.left)
+      .attr('y', rows[index]);
+  });
 }
 
 function drawReferenceLines(
@@ -638,46 +672,23 @@ function drawReferenceLines(
   });
 }
 
-/** Reasons, then the undrawn configs (named when few, counted per hardware when many). */
-function describeMissing(
-  missing: readonly MissingTrace[],
-  t: (typeof STRINGS)[keyof typeof STRINGS],
-  hardwareLabel: (point: InferenceData) => string,
-): string {
-  const reasons = new Map<MissingTraceReason, number>();
-  for (const { reason } of missing) reasons.set(reason, (reasons.get(reason) ?? 0) + 1);
-  const reasonText = [...reasons.entries()]
-    .map(([reason, count]) => t.missingReason[reason](count))
-    .join('; ');
-  let list: string;
-  if (missing.length <= MAX_LISTED_MISSING) {
-    list = missing
-      .map(({ point }) => `${hardwareLabel(point)} ${traceConfigLabel(point)}`)
-      .join(' · ');
-  } else {
-    const perHardware = new Map<string, number>();
-    for (const { point } of missing) {
-      const label = hardwareLabel(point);
-      perHardware.set(label, (perHardware.get(label) ?? 0) + 1);
-    }
-    list = [...perHardware.entries()].map(([label, count]) => `${label} ×${count}`).join(' · ');
-  }
-  return `${reasonText}. ${t.missingUndrawn}: ${list}`;
-}
-
 export default function PowerTimeline({
   chartId,
   data,
   overlayData,
   yLabel,
   caption,
+  comparison = false,
+  runNumbering: providedRunNumbering,
 }: PowerTimelineProps) {
   const locale = useLocale();
   const t = STRINGS[locale];
   const { hardwareConfig, hwTypesWithData } = useInferenceData();
-  const { activeHwTypes, selectedPrecisions, quickFilters } = useInferenceFilters();
+  const { activeHwTypes, selectedPrecisions, quickFilters, activeDates } = useInferenceFilters();
   const { isLegendExpanded, highContrast } = useInferenceDisplay();
-  const { setBestPerSku, toggleHwType, setIsLegendExpanded } = useInferenceActions();
+  const { setBestPerSku, toggleHwType, setIsLegendExpanded, toggleActiveDate } =
+    useInferenceActions();
+  const { allGraphs: comparisonSeries, runNumbering } = useComparisonSeries(providedRunNumbering);
   const {
     unofficialRunInfos,
     runIndexByUrl,
@@ -686,14 +697,35 @@ export default function PowerTimeline({
     setUnifiedOverlaySelection,
   } = useUnofficialRun();
 
-  const [xModeChoice, setXModeChoice] = useState<XMode | null>(null);
-  const [lineMode, setLineMode] = useState<LineMode>('mean');
-  const [showUtility, setShowUtility] = useState(false);
+  const { getUrlParam, setUrlParams } = useUrlState();
+  const [initialView] = useState(() =>
+    parsePowerTimelineParams({
+      i_ptaxis: getUrlParam('i_ptaxis'),
+      i_ptlines: getUrlParam('i_ptlines'),
+      i_ptwindow: getUrlParam('i_ptwindow'),
+      i_ptfocus: getUrlParam('i_ptfocus'),
+      i_ptutility: getUrlParam('i_ptutility'),
+      i_ptconc: getUrlParam('i_ptconc'),
+    }),
+  );
+  const [xModeChoice, setXModeChoice] = useState<XMode | null>(initialView.axis);
+  const [lineMode, setLineMode] = useState<LineMode>(initialView.lines);
+  const [windowOnly, setWindowOnly] = useState(initialView.windowOnly);
+  const [showUtility, setShowUtility] = useState(initialView.utility);
   const [highlight, setHighlight] = useState<string | null>(null);
   /** Trace a "View power trace" deep link asked for, once the join has produced it. */
-  const [focusKey, setFocusKey] = useState<string | null>(null);
+  const [focusKey, setFocusKey] = useState<string | null>(initialView.focus);
   /** The deep-link request, read once on mount; `undefined` until read, `null` once honoured. */
   const requestedFocusRef = useRef<string | null | undefined>(undefined);
+  // The deep-link request is read once, before planning, so its run is fetched
+  // even when the chart spans more runs than the cap.
+  if (requestedFocusRef.current === undefined) {
+    requestedFocusRef.current = consumePowerTraceFocus();
+  }
+  /** One load across hardware (e.g. GB200 and GB300 at c4); a deep link names its own trace. */
+  const [concurrency, setConcurrency] = useState<number | null>(() =>
+    requestedFocusRef.current ? null : initialView.concurrency,
+  );
 
   // The chart's point list still carries every precision, quick-filtered rows
   // and rows without a validated average (ScatterGraph applies those gates at
@@ -712,10 +744,21 @@ export default function PowerTimeline({
     [overlayData, plotsHere],
   );
   const overlayPointSet = useMemo(() => new Set<InferenceData>(overlayPoints), [overlayPoints]);
-  const allPoints = useMemo(
-    () => [...measuredData, ...overlayPoints],
+  const concurrencyOptions = useMemo(
+    () =>
+      [...new Set([...measuredData, ...overlayPoints].map((point) => point.conc))]
+        .filter((conc) => Number.isSafeInteger(conc) && conc > 0)
+        .toSorted((a, b) => a - b),
     [measuredData, overlayPoints],
   );
+  // Filtering before planning keeps the run cap for the runs that hold this load.
+  const allPoints = useMemo(
+    () =>
+      [...measuredData, ...overlayPoints].filter(
+        (point) => concurrency === null || point.conc === concurrency,
+      ),
+    [measuredData, overlayPoints, concurrency],
+  );
 
   const hwKeysInData = useMemo(
     () =>
@@ -733,32 +776,39 @@ export default function PowerTimeline({
     hcKeys: stableHcKeys,
   });
 
-  // ── Telemetry fetch: one request per workflow run ──────────────────────────
   const requests = useMemo(() => planPowerTimelineRequests(allPoints), [allPoints]);
-  // The deep-link request is read once, before planning, so its run is fetched
-  // even when the chart spans more runs than the cap.
-  if (requestedFocusRef.current === undefined) {
-    requestedFocusRef.current = consumePowerTraceFocus();
-  }
-  const focusRunRef = useRef(traceKeyRunId(requestedFocusRef.current));
-  // Overlay runs were requested explicitly (`?unofficialrun=`), so they take
-  // the cap's slots before official runs; the deep-linked run still goes first.
-  const overlayRunIds = useMemo(
-    () =>
-      new Set(
-        overlayPoints
-          .map((point) => runIdFromUrl(point.run_url))
-          .filter((runId): runId is string => runId !== null),
-      ),
-    [overlayPoints],
+  const focusRun = traceKeyRunId(requestedFocusRef.current ?? focusKey);
+  // Same visibility source as ScatterGraph: an overlay session may hold a
+  // local official selection that has not been written back to the filters.
+  // Date comparison instead shows the (date, hardware) series toggled on in
+  // the legend, as GPUGraph does.
+  const officialHwTypes = localOfficialOverride ?? activeHwTypes;
+  const comparisonSeriesOf = useCallback(
+    (point: InferenceData) =>
+      comparison && !overlayPointSet.has(point) ? `${point.date}_${point.hwKey}` : undefined,
+    [comparison, overlayPointSet],
+  );
+  const isShown = useCallback(
+    (point: InferenceData) => {
+      if (overlayPointSet.has(point)) return activeOverlayHwTypes.has(point.hwKey);
+      const series = comparisonSeriesOf(point);
+      return series ? activeDates.has(series) : officialHwTypes.has(point.hwKey);
+    },
+    [overlayPointSet, activeOverlayHwTypes, comparisonSeriesOf, activeDates, officialHwTypes],
   );
+  // Overlay runs were requested explicitly (`?unofficialrun=`), so they take
+  // the cap's slots before official runs; runs the legend shows go before runs
+  // it hides entirely, so hiding hardware makes room for the pair compared.
+  // The deep-linked run still goes first.
+  const overlayRunIds = useMemo(() => runIdsOf(overlayPoints), [overlayPoints]);
+  const shownRunIds = useMemo(() => runIdsOf(allPoints.filter(isShown)), [allPoints, isShown]);
   const fetchedRequests = useMemo(
     () =>
-      prioritizeRun(prioritizeRuns(requests, overlayRunIds), focusRunRef.current).slice(
-        0,
-        POWER_TIMELINE_MAX_RUNS,
-      ),
-    [requests, overlayRunIds],
+      prioritizeRun(
+        prioritizeRuns(prioritizeRuns(requests, overlayRunIds), shownRunIds),
+        focusRun,
+      ).slice(0, POWER_TIMELINE_MAX_RUNS),
+    [requests, overlayRunIds, shownRunIds, focusRun],
   );
   const droppedRuns = requests.length - fetchedRequests.length;
   // React Query structurally shares the combined result, so `resolved` keeps
@@ -818,20 +868,30 @@ export default function PowerTimeline({
     });
   }, [loadingRuns, responses.size, traces.length, missing.length]);
 
-  // ── Visible traces and their colours ────────────────────────────────────────
+  const comparisonColors = useMemo(
+    () => new Map(comparisonSeries.map((series) => [series.id, series.color])),
+    [comparisonSeries],
+  );
   const colorForTrace = useCallback(
     (trace: PowerTimelineTrace): { color: string; overlayIndex: number | null } => {
       if (overlayPointSet.has(trace.point)) {
         const index = overlayRunIndex(trace.point.run_url ?? null, runIndexByUrl);
         return { color: overlayRunColor(index), overlayIndex: index };
       }
-      return { color: getCssColor(resolveColor(trace.point.hwKey)), overlayIndex: null };
+      const series = comparisonSeriesOf(trace.point);
+      const color =
+        (series && comparisonColors.get(series)) ?? getCssColor(resolveColor(trace.point.hwKey));
+      return { color, overlayIndex: null };
     },
-    [overlayPointSet, runIndexByUrl, getCssColor, resolveColor],
+    [
+      overlayPointSet,
+      runIndexByUrl,
+      comparisonSeriesOf,
+      comparisonColors,
+      getCssColor,
+      resolveColor,
+    ],
   );
-  // Same visibility source as ScatterGraph: an overlay session may hold a
-  // local official selection that has not been written back to the filters.
-  const officialHwTypes = localOfficialOverride ?? activeHwTypes;
   // With an overlay loaded the chart reads localOfficialOverride, so a legend
   // click must write the unified selection the way ScatterGraph does; the
   // context's toggleHwType would change activeHwTypes with no visible effect.
@@ -859,13 +919,8 @@ export default function PowerTimeline({
     ],
   );
   const visibleTraces = useMemo(
-    () =>
-      traces.filter((trace) =>
-        overlayPointSet.has(trace.point)
-          ? activeOverlayHwTypes.has(trace.point.hwKey)
-          : officialHwTypes.has(trace.point.hwKey),
-      ),
-    [traces, overlayPointSet, activeOverlayHwTypes, officialHwTypes],
+    () => traces.filter((trace) => isShown(trace.point)),
+    [traces, isShown],
   );
   // Focus follows visibility: hiding the focused hardware in the legend lifts
   // the dimming and the chip instead of dimming everything with nothing lit.
@@ -881,22 +936,74 @@ export default function PowerTimeline({
   );
   const xMode: XMode = xModeChoice ?? (visibleRunCount <= 1 ? 'wall' : 'elapsed');
 
-  // The pools switch is offered only where a visible trace carries worker roles;
-  // pool mode left without one would draw deployment totals with no way back.
+  // Retain a shared pool choice while data loads; keep its switch available even
+  // if the current selection has no role-tagged trace, so it can be turned off.
   const hasPools = useMemo(
     () => visibleTraces.some((trace) => tracePools(trace.series).length > 0),
     [visibleTraces],
   );
   useEffect(() => {
-    if (lineMode === 'pool' && !hasPools && visibleTraces.length > 0) setLineMode('mean');
-  }, [lineMode, hasPools, visibleTraces.length]);
+    setUrlParams({
+      i_ptaxis: xModeChoice ?? '',
+      i_ptlines: lineMode === 'mean' ? '' : lineMode,
+      i_ptwindow: windowOnly ? 'window' : '',
+      i_ptfocus: focusKey ?? '',
+      i_ptutility: showUtility ? '1' : '',
+      i_ptconc: concurrency === null ? '' : String(concurrency),
+    });
+  }, [xModeChoice, lineMode, windowOnly, focusKey, showUtility, concurrency, setUrlParams]);
+
+  const missingWindows =
+    windowOnly || xMode === 'serving'
+      ? visibleTraces.filter((trace) => !hasPowerTimelineWindow(trace)).length
+      : 0;
+
+  const hardwareLabel = useCallback(
+    (point: InferenceData): string => {
+      const config = overlayPointSet.has(point)
+        ? overlayData?.hardwareConfig[point.hwKey]
+        : hardwareConfig[point.hwKey];
+      return config ? getDisplayLabel(config) : point.hwKey;
+    },
+    [overlayPointSet, overlayData, hardwareConfig],
+  );
+  const entryLabel = useCallback(
+    (point: InferenceData) => comparisonEntryLabel(String(point.date), runNumbering),
+    [runNumbering],
+  );
+  /** Hardware, plus the compared date or run of an official trace in date comparison. */
+  const seriesLabel = useCallback(
+    (point: InferenceData): string =>
+      comparisonSeriesOf(point)
+        ? `${hardwareLabel(point)} · ${entryLabel(point)}`
+        : hardwareLabel(point),
+    [comparisonSeriesOf, hardwareLabel, entryLabel],
+  );
 
   const model = useMemo<DrawModel>(() => {
     const paths: TracePath[] = [];
     const labels: TraceLabel[] = [];
+    // Two platforms at one load share `c4`; name the hardware so the end labels differ.
+    const bases = new Set(visibleTraces.map((trace) => baseHardware(trace.point.hwKey)));
+    const hardwarePrefix = (trace: PowerTimelineTrace) => {
+      if (bases.size < 2) return '';
+      const base = baseHardware(trace.point.hwKey);
+      return `${HW_REGISTRY[base]?.label ?? base.toUpperCase()} `;
+    };
+    // Several compared dates share `c4` as well; name the date or run too.
+    const entries = new Set(
+      visibleTraces
+        .filter((trace) => comparisonSeriesOf(trace.point))
+        .map((trace) => trace.point.date),
+    );
+    const entryPrefix = (trace: PowerTimelineTrace) =>
+      entries.size > 1 && comparisonSeriesOf(trace.point) ? `${entryLabel(trace.point)} ` : '';
     for (const trace of visibleTraces) {
       const { color, overlayIndex } = colorForTrace(trace);
-      const tracePathSet = tracePaths(trace, color, overlayIndex, xMode, lineMode);
+      const series = comparisonSeriesOf(trace.point);
+      const tracePathSet = tracePaths(trace, color, overlayIndex, xMode, lineMode, windowOnly).map(
+        (path) => ({ ...path, series }),
+      );
       paths.push(...tracePathSet);
       if (visibleTraces.length > MAX_LABELED_TRACES) continue;
       // One end label per trace; per pool in pool mode, so the role reads off the line.
@@ -917,26 +1024,38 @@ export default function PowerTimeline({
           id: group.pool ? `${trace.key}:${group.pool}` : trace.key,
           traceKey: trace.key,
           hwKey: trace.point.hwKey,
+          series,
           pool: group.pool,
           color,
-          text: group.pool
-            ? `c${trace.point.conc} · ${t.poolShort[group.pool]}`
-            : `c${trace.point.conc}`,
+          text: `${entryPrefix(trace)}${hardwarePrefix(trace)}${
+            group.pool
+              ? `c${trace.point.conc} · ${t.poolShort[group.pool]}`
+              : `c${trace.point.conc}`
+          }`,
           x: last.x,
           y: last.y,
         });
       }
     }
     return { paths, labels };
-  }, [visibleTraces, colorForTrace, xMode, lineMode, t]);
+  }, [
+    visibleTraces,
+    colorForTrace,
+    comparisonSeriesOf,
+    entryLabel,
+    xMode,
+    lineMode,
+    windowOnly,
+    t,
+  ]);
 
   const samples = useMemo(
     () =>
       visibleTraces.flatMap((trace) => {
         const { color, overlayIndex } = colorForTrace(trace);
-        return traceSamples(trace, color, overlayIndex, xMode, lineMode);
+        return traceSamples(trace, color, overlayIndex, xMode, lineMode, windowOnly);
       }),
-    [visibleTraces, colorForTrace, xMode, lineMode],
+    [visibleTraces, colorForTrace, xMode, lineMode, windowOnly],
   );
 
   // Rated references: per hardware in mean / per-GPU modes; per (hardware,
@@ -993,12 +1112,10 @@ export default function PowerTimeline({
     return lines;
   }, [visibleTraces, colorForTrace, showUtility, lineMode, t]);
 
-  // ── Scales ─────────────────────────────────────────────────────────────────
   const xDomain = useMemo<[number, number]>(() => {
     let min = Number.POSITIVE_INFINITY;
     let max = Number.NEGATIVE_INFINITY;
     for (const path of model.paths) {
-      if (path.segment !== 'full') continue;
       for (const point of path.points) {
         if (point.x < min) min = point.x;
         if (point.x > max) max = point.x;
@@ -1007,8 +1124,9 @@ export default function PowerTimeline({
     if (!Number.isFinite(min) || !Number.isFinite(max)) {
       return xMode === 'wall' ? [Date.UTC(2026, 0, 1), Date.UTC(2026, 0, 1, 0, 10)] : [0, 600];
     }
+    if (xMode === 'serving' && windowOnly) min = Math.min(0, min);
     return min === max ? [min, max + (xMode === 'wall' ? 60_000 : 60)] : [min, max];
-  }, [model.paths, xMode]);
+  }, [model.paths, xMode, windowOnly]);
   const yDomain = useMemo<[number, number]>(() => {
     let max = 0;
     for (const path of model.paths) {
@@ -1020,6 +1138,7 @@ export default function PowerTimeline({
 
   const xTickFormat = useMemo(() => {
     if (xMode === 'elapsed') return (value: d3.AxisDomain) => formatElapsed(Number(value));
+    if (xMode === 'serving') return (value: d3.AxisDomain) => d3.format('~g')(Number(value));
     const span = xDomain[1] - xDomain[0];
     const crossesDate = formatUtcDate(new Date(xDomain[0])) !== formatUtcDate(new Date(xDomain[1]));
     const format = d3.utcFormat(
@@ -1029,7 +1148,6 @@ export default function PowerTimeline({
       format(value instanceof Date ? value : new Date(Number(value)));
   }, [xMode, xDomain]);
 
-  // ── Layers ─────────────────────────────────────────────────────────────────
   const highlightRef = useRef(activeHighlight);
   highlightRef.current = activeHighlight;
   const layers = useMemo<LayerConfig<TimelineSample>[]>(
@@ -1118,27 +1236,11 @@ export default function PowerTimeline({
         .attr('opacity', (path) => traceOpacity(path, activeHighlight));
       root
         .selectAll<SVGTextElement, TraceLabel>('text.power-trace-label')
-        .attr('opacity', (label) =>
-          activeHighlight === null ||
-          activeHighlight === label.hwKey ||
-          activeHighlight === label.traceKey
-            ? 1
-            : 0.2,
-        );
+        .attr('opacity', (label) => labelOpacity(label, activeHighlight));
     },
     [activeHighlight],
   );
 
-  const hardwareLabel = useCallback(
-    (point: InferenceData): string => {
-      const config = overlayPointSet.has(point)
-        ? overlayData?.hardwareConfig[point.hwKey]
-        : hardwareConfig[point.hwKey];
-      return config ? getDisplayLabel(config) : point.hwKey;
-    },
-    [overlayPointSet, overlayData, hardwareConfig],
-  );
-
   const tooltipContent = useCallback(
     (sample: TimelineSample, isPinned: boolean) => {
       const { trace } = sample;
@@ -1149,7 +1251,11 @@ export default function PowerTimeline({
       const elapsed = formatElapsed((sample.timeMs - trace.series.startMs) / 1000);
       const clock = `${formatUtcClock(new Date(sample.timeMs))} UTC`;
       const time =
-        xMode === 'wall' ? `${clock} · +${elapsed} ${t.sinceStart}` : `+${elapsed} · ${clock}`;
+        xMode === 'serving'
+          ? `${sample.x.toFixed(1)} s · ${t.serving} · ${clock}`
+          : xMode === 'wall'
+            ? `${clock} · +${elapsed} ${t.sinceStart}`
+            : `+${elapsed} · ${clock}`;
       const colon = locale === 'zh' ? '：' : ':';
       const validated = point.measuredAvgPower?.y;
       const { pool } = sample;
@@ -1169,7 +1275,7 @@ export default function PowerTimeline({
         <div class="text-muted-foreground">${t.gpus(sample.gpuCount)} · ${t.min} ${sample.min.toFixed(1)} W · ${t.max} ${sample.max.toFixed(1)} W</div>`;
       return `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md backdrop-blur-sm" style="min-width: 210px; user-select: ${isPinned ? 'text' : 'none'}">
         ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
-        <div class="font-semibold mb-1" style="color: ${sample.color}">${hardwareLabel(point)} · ${traceConfigLabel(point)}${
+        <div class="font-semibold mb-1" style="color: ${sample.color}">${seriesLabel(point)} · ${traceConfigLabel(point)}${
           overlayInfo ? ` · ✕ ${overlayInfo.branch || `run ${overlayInfo.id}`}` : ''
         }</div>
         <div class="text-muted-foreground">${time}</div>
@@ -1182,10 +1288,9 @@ export default function PowerTimeline({
         }
       </div>`;
     },
-    [unofficialRunInfos, xMode, t, locale, hardwareLabel],
+    [unofficialRunInfos, xMode, t, locale, seriesLabel],
   );
 
-  // ── Legend ─────────────────────────────────────────────────────────────────
   const legendItems = useMemo(() => {
     const overlayItems =
       overlayData && unofficialRunInfos.length > 0
@@ -1200,7 +1305,9 @@ export default function PowerTimeline({
                 name: `✕ unofficial-run-${info.id}`,
                 label: `✕ ${branch}`,
                 color: overlayRunColor(index),
-                title: `${t.unofficialRun}: ${branch}`,
+                // The comparison legend groups on the name's first word: one
+                // "Unofficial run" group over every run.
+                title: comparison ? t.unofficialRun : `${t.unofficialRun}: ${branch}`,
                 isHighlighted: true,
                 hw: `overlay-run-${info.id}`,
                 isActive: true,
@@ -1228,6 +1335,27 @@ export default function PowerTimeline({
             })
             .filter((item): item is NonNullable<typeof item> => item !== null)
         : [];
+    if (comparison) {
+      // GPUGraph's comparison legend: one row per (date, hardware) series with
+      // a trace candidate, grouped by hardware.
+      const seriesWithData = new Set(measuredData.map((point) => `${point.date}_${point.hwKey}`));
+      const comparisonItems = comparisonSeries
+        .filter(({ id }) => seriesWithData.has(id))
+        .map(({ date, hwKey, id, color }) => ({
+          name: `${hwKey} ${comparisonEntryLabel(date, runNumbering)}`,
+          label: comparisonEntryLabel(date, runNumbering),
+          color,
+          title: hardwareConfig[hwKey] ? getDisplayLabel(hardwareConfig[hwKey]) : hwKey,
+          hw: id,
+          isActive: activeDates.has(id),
+          onClick: () => {
+            toggleActiveDate(id);
+            track('interactivity_date_toggled', { date, hw: hwKey, view: 'power_timeline' });
+          },
+          tooltip: null,
+        }));
+      return [...overlayItems, ...comparisonItems];
+    }
     const officialItems = hwKeysInData
       .filter((key) => hwTypesWithData.has(key) && hardwareConfig[key])
       .map((key) => {
@@ -1259,6 +1387,12 @@ export default function PowerTimeline({
     officialHwTypes,
     handleToggleHwType,
     t,
+    comparison,
+    comparisonSeries,
+    measuredData,
+    runNumbering,
+    activeDates,
+    toggleActiveDate,
   ]);
 
   // Per-GPU and pools are two views of the same lines, so either switch turns
@@ -1276,7 +1410,7 @@ export default function PowerTimeline({
       infoTooltip: t.perGpuHelp,
     },
   ];
-  if (hasPools) {
+  if (hasPools || lineMode === 'pool') {
     switches.push({
       id: 'power-timeline-pools',
       label: t.pools,
@@ -1285,20 +1419,34 @@ export default function PowerTimeline({
       infoTooltip: t.poolsHelp,
     });
   }
-  switches.push({
-    id: 'power-timeline-utility',
-    label: t.utilityLines,
-    checked: showUtility,
-    onCheckedChange: (checked) => {
-      setShowUtility(checked);
-      track('inference_power_timeline_utility_toggled', { enabled: checked });
+  switches.push(
+    {
+      id: 'power-timeline-window-only',
+      label: t.windowOnly,
+      checked: windowOnly,
+      onCheckedChange: (checked) => {
+        setWindowOnly(checked);
+        track('inference_power_timeline_window_changed', { windowOnly: checked });
+      },
+      infoTooltip: t.windowOnlyHelp,
     },
-    infoTooltip: t.utilityHelp,
-  });
+    {
+      id: 'power-timeline-utility',
+      label: t.utilityLines,
+      checked: showUtility,
+      onCheckedChange: (checked) => {
+        setShowUtility(checked);
+        track('inference_power_timeline_utility_toggled', { enabled: checked });
+      },
+      infoTooltip: t.utilityHelp,
+    },
+  );
 
   const legendElement = (
     <ChartLegend
       variant="sidebar"
+      grouped={comparison}
+      disableActiveSort={comparison}
       legendItems={legendItems}
       isLegendExpanded={isLegendExpanded}
       onExpandedChange={(expanded) => {
@@ -1325,6 +1473,27 @@ export default function PowerTimeline({
       className="flex flex-wrap items-center justify-end gap-2 pb-1"
       data-testid="power-timeline-toolbar"
     >
+      <label className="flex items-center gap-2 text-xs text-muted-foreground">
+        {t.concurrency}
+        <select
+          className="rounded-md border bg-background px-2 py-1 text-xs text-foreground"
+          data-testid="power-timeline-concurrency"
+          value={concurrency ?? ''}
+          onChange={(event) => {
+            const value = event.target.value === '' ? null : Number(event.target.value);
+            setConcurrency(value);
+            track('inference_power_timeline_concurrency_changed', { concurrency: value });
+          }}
+        >
+          <option value="">{t.allConcurrencies}</option>
+          {concurrency !== null && !concurrencyOptions.includes(concurrency) && (
+            <option value={concurrency}>{`c${concurrency}`}</option>
+          )}
+          {concurrencyOptions.map((conc) => (
+            <option key={conc} value={conc}>{`c${conc}`}</option>
+          ))}
+        </select>
+      </label>
       <span className="text-xs text-muted-foreground">{t.timeAxis}</span>
       <SegmentedToggle<XMode>
         value={xMode}
@@ -1333,6 +1502,7 @@ export default function PowerTimeline({
         options={[
           { value: 'wall', label: t.wall, testId: 'power-timeline-axis-wall' },
           { value: 'elapsed', label: t.elapsed, testId: 'power-timeline-axis-elapsed' },
+          { value: 'serving', label: t.serving, testId: 'power-timeline-axis-serving' },
         ]}
         onValueChange={(mode) => {
           setXModeChoice(mode);
@@ -1346,11 +1516,12 @@ export default function PowerTimeline({
   if (loadingRuns > 0) emptyMessage = t.loading(loadingRuns);
   else if (!hasAnyArtifact) emptyMessage = t.noArtifacts;
   else if (visibleTraces.length === 0) emptyMessage = t.noTraces;
+  else if (missingWindows === visibleTraces.length) emptyMessage = t.missingWindow(missingWindows);
 
   return (
     <div className="relative flex flex-col gap-2" data-testid="power-timeline">
       <D3Chart<TimelineSample>
-        key={`${chartId}-${xMode}-${lineMode}`}
+        key={`${chartId}-${xMode}-${lineMode}-${windowOnly}`}
         chartId={chartId}
         data={samples}
         height={CHART_HEIGHT}
@@ -1366,7 +1537,7 @@ export default function PowerTimeline({
         }
         yScale={{ type: 'linear', domain: yDomain, nice: true }}
         xAxis={{
-          label: xMode === 'wall' ? t.xWall : t.xElapsed,
+          label: xMode === 'wall' ? t.xWall : xMode === 'serving' ? t.xServing : t.xElapsed,
           tickValues: (scale) => {
             const timeScale = scale as
               | d3.ScaleTime<number, number>
@@ -1429,7 +1600,7 @@ export default function PowerTimeline({
           >
             <span>
               {t.focused(
-                `${hardwareLabel(focusedTrace.point)} · ${traceConfigLabel(focusedTrace.point)}`,
+                `${seriesLabel(focusedTrace.point)} · ${traceConfigLabel(focusedTrace.point)}`,
               )}
             </span>
             <button
@@ -1445,18 +1616,15 @@ export default function PowerTimeline({
             </button>
           </p>
         )}
+        {focusKey && !focusedTrace && loadingRuns === 0 && (
+          <p data-testid="power-timeline-focus-missing">{t.missingFocus}</p>
+        )}
         {errors.map(({ request, error }) => (
           <p key={request.runId} className="text-destructive" role="alert">
             {t.loadError(request.runId, error.message)}
           </p>
         ))}
         {droppedRuns > 0 && <p>{t.droppedRuns(droppedRuns)}</p>}
-        {loadingRuns === 0 && missing.length > 0 && traces.length > 0 && (
-          <p data-testid="power-timeline-missing">
-            {t.missing(missing.length, traces.length + missing.length)}{' '}
-            {describeMissing(missing, t, hardwareLabel)}
-          </p>
-        )}
         {runInfos.length > 0 && (
           <p data-testid="power-timeline-source">
             {t.telemetry}:{' '}
@@ -1476,9 +1644,16 @@ export default function PowerTimeline({
             ))}
           </p>
         )}
-        <p>{t.method}</p>
-        {hasPools && <p>{t.methodPools}</p>}
       </div>
+      {loadingRuns === 0 && visibleTraces.length > 0 && (
+        <PowerTimelineSummary
+          traces={visibleTraces}
+          responses={responses}
+          colorOf={(trace) => colorForTrace(trace).color}
+          hardwareLabel={seriesLabel}
+          isOverlay={(point) => overlayPointSet.has(point)}
+        />
+      )}
     </div>
   );
 }
diff --git a/packages/app/src/components/inference/ui/PowerTimelineSummary.tsx b/packages/app/src/components/inference/ui/PowerTimelineSummary.tsx
new file mode 100644
index 000000000..41e49ccef
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerTimelineSummary.tsx
@@ -0,0 +1,189 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
+
+import type { GpuPowerSeriesResponse } from '@/components/gpu-power/power-series';
+import { useLocale } from '@/lib/use-locale';
+import type { InferenceData } from '../types';
+import {
+  allGpuPool,
+  runAttemptFromUrl,
+  summarizeTraceWindow,
+  telemetryNameForPoint,
+  traceConfigLabel,
+  tracePools,
+  type PowerPoolRole,
+  type PowerTimelineTrace,
+} from '../utils/powerTimeline';
+
+const STRINGS = {
+  en: {
+    title: 'Validated-window summary',
+    trace: 'Hardware · config',
+    run: 'Run · telemetry source',
+    window: 'Window (s)',
+    pool: 'Pool · GPUs',
+    validated: 'Validated average (W/GPU)',
+    peak: 'Peak 1-s pool power (W)',
+    poolTdp: 'Pool TDP (W)',
+    pools: { all: 'All GPUs', prefill: 'Prefill', decode: 'Decode' } satisfies Record<
+      PowerPoolRole,
+      string
+    >,
+    source: { database: 'database', github: 'GitHub artifact fallback' },
+    attempt: (attempt: number) => `attempt ${attempt}`,
+    unofficial: 'unofficial',
+    noWindow: 'Not recorded',
+  },
+  zh: {
+    title: '有效测量窗口汇总',
+    trace: '硬件 · 配置',
+    run: '运行 · 遥测来源',
+    window: '窗口（秒）',
+    pool: 'GPU 池 · GPU 数',
+    validated: '有效窗口平均值（W/GPU）',
+    peak: '池功耗 1 秒峰值（W）',
+    poolTdp: '池 TDP（W）',
+    pools: { all: '全部 GPU', prefill: '预填充', decode: '解码' } satisfies Record<
+      PowerPoolRole,
+      string
+    >,
+    source: { database: '数据库', github: 'GitHub 产物回退' },
+    attempt: (attempt: number) => `第 ${attempt} 次尝试`,
+    unofficial: '非官方',
+    noWindow: '未记录',
+  },
+};
+
+const watts = d3.format(',.0f');
+const seconds = d3.format(',.0f');
+
+const validatedWatts = (point: InferenceData, role: PowerPoolRole) =>
+  (role === 'prefill'
+    ? point.measuredPrefillAvgPower
+    : role === 'decode'
+      ? point.measuredDecodeAvgPower
+      : point.measuredAvgPower
+  )?.y ?? null;
+
+/**
+ * Per-trace provenance behind the Timeline curves: which run and telemetry file
+ * each trace came from, the validated window length, and per pool its GPU
+ * count, the row's validated average, the drawn peak and the rated pool TDP.
+ */
+export default function PowerTimelineSummary({
+  traces,
+  responses,
+  colorOf,
+  hardwareLabel,
+  isOverlay,
+}: {
+  traces: readonly PowerTimelineTrace[];
+  responses: ReadonlyMap<string, GpuPowerSeriesResponse>;
+  colorOf: (trace: PowerTimelineTrace) => string;
+  hardwareLabel: (point: InferenceData) => string;
+  isOverlay: (point: InferenceData) => boolean;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const rows = useMemo(
+    () =>
+      traces.map((trace) => ({
+        trace,
+        summary: summarizeTraceWindow(trace, [
+          allGpuPool(trace.series),
+          ...tracePools(trace.series),
+        ]),
+      })),
+    [traces],
+  );
+  return (
+    <section className="min-w-0 space-y-2 px-1" data-testid="power-timeline-summary">
+      <h3 className="text-sm font-medium">{t.title}</h3>
+      <div className="max-h-96 min-w-0 overflow-auto">
+        <table className="w-full min-w-[48rem] table-fixed break-words text-left text-xs">
+          <thead className="sticky top-0 bg-background">
+            <tr>
+              <th className="w-1/5 p-2">{t.trace}</th>
+              <th className="w-1/4 p-2">{t.run}</th>
+              <th className="p-2">{t.window}</th>
+              <th className="p-2">{t.pool}</th>
+              <th className="p-2">{t.validated}</th>
+              <th className="p-2">{t.peak}</th>
+              <th className="p-2">{t.poolTdp}</th>
+            </tr>
+          </thead>
+          {rows.map(({ trace, summary }) => {
+            const { point } = trace;
+            const attempt = runAttemptFromUrl(point.run_url);
+            const name = telemetryNameForPoint(point);
+            const source = responses.get(trace.runId)?.source;
+            const tdp = HW_REGISTRY[point.hwKey.split('_')[0]]?.tdp ?? 0;
+            return (
+              <tbody
+                key={trace.key}
+                className="border-t"
+                data-testid="power-timeline-summary-trace"
+                data-trace={trace.key}
+              >
+                {summary.pools.map((pool, index) => {
+                  const validated = validatedWatts(point, pool.role);
+                  return (
+                    <tr key={pool.role} data-testid={`power-timeline-summary-${pool.role}`}>
+                      {index === 0 && (
+                        <>
+                          <th className="p-2 align-top font-normal" rowSpan={summary.pools.length}>
+                            <span style={{ color: colorOf(trace) }}>● </span>
+                            {hardwareLabel(point)}
+                            <span className="block text-muted-foreground">
+                              {traceConfigLabel(point)}
+                              {isOverlay(point) ? ` · ${t.unofficial}` : ''}
+                            </span>
+                          </th>
+                          <td className="p-2 align-top" rowSpan={summary.pools.length}>
+                            <a
+                              href={point.run_url}
+                              target="_blank"
+                              rel="noopener noreferrer"
+                              className="underline decoration-dotted"
+                            >
+                              {`run ${trace.runId}`}
+                            </a>
+                            {attempt === null ? '' : ` · ${t.attempt(attempt)}`}
+                            <span className="block break-all text-muted-foreground">
+                              {name ? `power_validation_${name}.json` : '—'}
+                              {source ? ` · ${t.source[source]}` : ''}
+                            </span>
+                          </td>
+                          <td className="p-2 align-top" rowSpan={summary.pools.length}>
+                            {summary.windowSeconds === null
+                              ? t.noWindow
+                              : seconds(summary.windowSeconds)}
+                          </td>
+                        </>
+                      )}
+                      <td className="p-2 align-top">
+                        {t.pools[pool.role]} · {pool.gpuCount}
+                      </td>
+                      <td className="p-2 align-top">
+                        {validated === null ? '—' : watts(validated)}
+                      </td>
+                      <td className="p-2 align-top">
+                        {pool.peakWatts === null ? '—' : watts(pool.peakWatts)}
+                      </td>
+                      <td className="p-2 align-top">
+                        {tdp > 0 ? watts(tdp * pool.gpuCount) : '—'}
+                      </td>
+                    </tr>
+                  );
+                })}
+              </tbody>
+            );
+          })}
+        </table>
+      </div>
+    </section>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/QuickFiltersDialog.tsx b/packages/app/src/components/inference/ui/QuickFiltersDialog.tsx
index 198b25d93..62daecad5 100644
--- a/packages/app/src/components/inference/ui/QuickFiltersDialog.tsx
+++ b/packages/app/src/components/inference/ui/QuickFiltersDialog.tsx
@@ -7,6 +7,7 @@ import { OptionInfo } from '@/components/ui/option-info';
 import type { DeploymentMode, SpecMode } from '@/components/inference/types';
 import type { PowerTier } from '@/lib/power-tier';
 import { FRAMEWORK_FAMILIES } from '@/components/inference/utils/quickFilters';
+import { topologyLabel } from '@/components/inference/utils/topology-filter';
 
 import {
   useInferenceActions,
@@ -56,6 +57,9 @@ const STRINGS = {
     specHelp:
       'MTP groups runs with speculative decoding enabled, including methods such as EAGLE. STP groups standard decoding without speculative decoding. Available only for fixed-sequence benchmarks.',
     power: 'Measured Power',
+    topology: 'Topology',
+    topologyHelp:
+      'Keep one GPU allocation and parallelism configuration across its observed concurrency sweep. This does not match software versions or fill missing measurements.',
     certified: 'Validated',
     legacyTier: 'Historical',
     validatedTitle: 'Validated measurement',
@@ -97,6 +101,9 @@ const STRINGS = {
     specHelp:
       'MTP 组包含启用投机解码的运行，也包括 EAGLE 等方法；STP 组为未启用投机解码的标准解码运行。该筛选仅适用于固定序列长度基准测试。',
     power: '实测功耗',
+    topology: '拓扑',
+    topologyHelp:
+      '按 GPU 分配和并行配置保留整条已测并发曲线。此筛选不会匹配软件版本，也不会补造缺失数据。',
     certified: '已验证',
     legacyTier: '历史测量',
     validatedTitle: '已验证测量',
@@ -151,6 +158,7 @@ export function QuickFiltersDialog({
     setQuickFilterDeployment,
     setQuickFilterSpec,
     setQuickFilterPower,
+    setQuickFilterTopologies,
   } = useInferenceActions();
   const { selectedSequence, quickFilters, lockedFrameworks } = useInferenceFilters();
   const { availableQuickFilters } = useInferenceData();
@@ -160,6 +168,7 @@ export function QuickFiltersDialog({
     framework: <p>{t.frameworkHelp}</p>,
     deployment: <p>{t.deploymentHelp}</p>,
     spec: <p>{t.specHelp}</p>,
+    topology: <p>{t.topologyHelp}</p>,
     power: (
       <>
         <div>
@@ -186,9 +195,12 @@ export function QuickFiltersDialog({
     label: framework.label,
     available: availableQuickFilters.frameworks.includes(framework.key),
   }));
+  const topologyKeys = [
+    ...new Set([...(availableQuickFilters.topologies ?? []), ...(quickFilters.topologies ?? [])]),
+  ];
 
   const groups: {
-    key: 'vendor' | 'framework' | 'deployment' | 'spec' | 'power';
+    key: 'vendor' | 'framework' | 'deployment' | 'spec' | 'power' | 'topology';
     label: string;
     options: readonly { value: string; label: string; available: boolean }[];
     selected: readonly string[];
@@ -254,6 +266,16 @@ export function QuickFiltersDialog({
       })),
       selected: quickFilters.power,
     },
+    {
+      key: 'topology',
+      label: t.topology,
+      options: topologyKeys.map((value) => ({
+        value,
+        label: topologyLabel(value, locale, topologyKeys),
+        available: (availableQuickFilters.topologies ?? []).includes(value),
+      })),
+      selected: quickFilters.topologies ?? [],
+    },
   ];
 
   const selectedCount = groups.reduce((count, group) => count + group.selected.length, 0);
@@ -261,26 +283,29 @@ export function QuickFiltersDialog({
   // Every option is a visible toggle: one tap adds or removes it, no dropdown
   // to open first. Empty selection in a group means "all".
   const handleToggle = (
-    category: 'vendor' | 'framework' | 'deployment' | 'spec' | 'power',
+    category: 'vendor' | 'framework' | 'deployment' | 'spec' | 'power' | 'topology',
     value: string,
   ) => {
     const previous: readonly string[] =
-      category === 'vendor'
-        ? quickFilters.vendors
-        : category === 'framework'
-          ? quickFilters.frameworks
-          : category === 'deployment'
-            ? quickFilters.deployment
-            : category === 'power'
-              ? quickFilters.power
-              : quickFilters.spec;
+      category === 'topology'
+        ? (quickFilters.topologies ?? [])
+        : category === 'vendor'
+          ? quickFilters.vendors
+          : category === 'framework'
+            ? quickFilters.frameworks
+            : category === 'deployment'
+              ? quickFilters.deployment
+              : category === 'power'
+                ? quickFilters.power
+                : quickFilters.spec;
     const values = toggleValue(previous, value);
     track('inference_quick_filter_toggled', {
       category,
       value,
       active: values.includes(value),
     });
-    if (category === 'vendor') setQuickFilterVendors(values);
+    if (category === 'topology') setQuickFilterTopologies(values);
+    else if (category === 'vendor') setQuickFilterVendors(values);
     else if (category === 'framework') setQuickFilterFrameworks(values);
     else if (category === 'deployment') setQuickFilterDeployment(values as DeploymentMode[]);
     else if (category === 'power') setQuickFilterPower(values as PowerTier[]);
@@ -293,6 +318,7 @@ export function QuickFiltersDialog({
     setQuickFilterDeployment([]);
     setQuickFilterSpec([]);
     setQuickFilterPower([]);
+    setQuickFilterTopologies([]);
     track('inference_quick_filters_cleared', { source: 'dialog' });
   };
 
@@ -366,7 +392,10 @@ export function QuickFiltersDialog({
                 role="group"
                 aria-labelledby={`quick-filter-${group.key}-label`}
                 data-testid={`quick-filter-${group.key}-options`}
-                className="flex flex-wrap gap-2"
+                className={cn(
+                  'flex min-w-0 flex-wrap gap-2',
+                  group.key === 'topology' && 'max-h-56 overflow-y-auto overscroll-contain pr-1',
+                )}
               >
                 {group.options.map((option) => {
                   const active = group.selected.includes(option.value);
@@ -382,6 +411,8 @@ export function QuickFiltersDialog({
                       title={disabled ? t.noData : undefined}
                       className={cn(
                         'rounded-full font-normal',
+                        group.key === 'topology' &&
+                          'h-auto min-h-9 max-w-full whitespace-normal break-words rounded-lg py-2 text-left md:h-auto',
                         active && 'bg-brand hover:bg-brand/90',
                       )}
                       data-testid={`quick-filter-${group.key}-${option.value}`}
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.decoration.test.tsx b/packages/app/src/components/inference/ui/ScatterGraph.decoration.test.tsx
index 8e0a422cf..19f0543c7 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.decoration.test.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.decoration.test.tsx
@@ -4,7 +4,6 @@ import { act } from 'react';
 import { describe, expect, it, vi } from 'vitest';
 
 import type { InferenceData } from '@/components/inference/types';
-import { renderLegacyPowerRing } from '@/components/inference/utils/legacy-power-marker';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
 
 import {
@@ -130,41 +129,6 @@ describe('ScatterGraph toggle decoration', () => {
     unmount();
   });
 
-  it('rings legacy-power points only on Measured Energy axes', () => {
-    const legacy = {
-      ...point('h100', 'fp8', 10, 100, 1),
-      power_tier: 'legacy',
-    } as InferenceData;
-    const certified = {
-      ...point('h100', 'fp8', 20, 200, 2),
-      power_tier: 'certified',
-    } as InferenceData;
-    const tierless = point('h100', 'fp8', 40, 400, 4);
-
-    inferenceState.current = {
-      ...baseInferenceState(),
-      selectedYAxisMetric: 'y_measuredAvgPower',
-    };
-    const measured = mountChart({ data: [legacy, certified, tierless] });
-    const groups = dotGroups(measured.container);
-
-    expect(groups[0].querySelector('.legacy-power-ring')).not.toBeNull();
-    expect(groups[1].querySelector('.legacy-power-ring')).toBeNull();
-    expect(groups[2].querySelector('.legacy-power-ring')).toBeNull();
-    // The legend key lives in ChartDisplay's axis-metric footer, not the chart.
-    expect(measured.container.querySelector('[data-testid="legacy-power-key"]')).toBeNull();
-    measured.unmount();
-
-    // Non-measured axis: the same legacy point renders without a ring.
-    inferenceState.current = {
-      ...baseInferenceState(),
-      selectedYAxisMetric: 'y',
-    };
-    const throughput = mountChart({ data: [legacy, certified, tierless] });
-    expect(throughput.container.querySelectorAll('.legacy-power-ring')).toHaveLength(0);
-    throughput.unmount();
-  });
-
   it('reads current trace availability without changing metric identity', () => {
     const agenticPoint = {
       ...point('h100', 'fp8', 20, 200, 2),
@@ -466,41 +430,32 @@ function recordCount(root: Node, run: () => void): number {
   return count;
 }
 
-const offloaded = { offload_mode: 'on', power_tier: 'legacy' } as InferenceData;
+const offloaded = { offload_mode: 'on' } as InferenceData;
 
-describe('point decoration rings', () => {
-  it('draw the offload halo and legacy-power ring', () => {
+describe('offload halo decoration', () => {
+  it('draws the offload halo', () => {
     const group = pointGroup();
     renderOffloadHalo(group, offloaded, 'red');
-    renderLegacyPowerRing(group, offloaded, true, 'red');
 
     expect(group.select('.offload-halo').attr('stroke')).toBe('red');
     expect(group.select('.offload-halo').attr('stroke-dasharray')).toBe('3 2');
-    expect(group.select('.legacy-power-ring').attr('stroke-dasharray')).toBe('1 3');
   });
 
-  it('write nothing when re-rendered with the same state', () => {
+  it('writes nothing when re-rendered with the same state', () => {
     const group = pointGroup();
     renderOffloadHalo(group, offloaded, 'red');
-    renderLegacyPowerRing(group, offloaded, true, 'red');
 
-    expect(
-      recordCount(group.node()!, () => {
-        renderOffloadHalo(group, offloaded, 'red');
-        renderLegacyPowerRing(group, offloaded, true, 'red');
-      }),
-    ).toBe(0);
+    expect(recordCount(group.node()!, () => renderOffloadHalo(group, offloaded, 'red'))).toBe(0);
   });
 
-  it('restyle and remove on real changes', () => {
+  it('restyles and removes on real changes', () => {
     const group = pointGroup();
     renderOffloadHalo(group, offloaded, 'red');
-    renderLegacyPowerRing(group, offloaded, true, 'red');
 
     renderOffloadHalo(group, offloaded, 'blue');
-    renderLegacyPowerRing(group, offloaded, false, 'blue');
-
     expect(group.select('.offload-halo').attr('stroke')).toBe('blue');
-    expect(group.select('.legacy-power-ring').empty()).toBe(true);
+
+    renderOffloadHalo(group, { offload_mode: 'off' } as InferenceData, 'blue');
+    expect(group.select('.offload-halo').empty()).toBe(true);
   });
 });
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.overlay.test.tsx b/packages/app/src/components/inference/ui/ScatterGraph.overlay.test.tsx
index 13f930f08..22d68c48a 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.overlay.test.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.overlay.test.tsx
@@ -214,17 +214,7 @@ describe('ScatterGraph unofficial overlays', () => {
         const visible = showAllMeasurements || datum.x !== 20;
         expect(group.style.opacity).toBe(visible ? '1' : '0');
         expect(group.style.pointerEvents).toBe(visible ? 'auto' : 'none');
-        expect(Boolean(group.querySelector('.legacy-power-ring'))).toBe(
-          datum.power_tier === 'legacy',
-        );
       }
-      expect(
-        container.querySelector('[data-testid="measured-power-summary"]')?.textContent,
-      ).toContain(
-        showAllMeasurements
-          ? 'Showing 9 of 9 measured points: 3/3 validated · 6/6 historical.'
-          : 'Showing 6 of 9 measured points: 3/3 validated · 3/6 historical.',
-      );
       expect(curves.map((curve) => curve.getAttribute('d'))).toEqual(paths);
       expect(axes.map((axis) => axis.innerHTML)).toEqual(axisGeometry);
       expect(groups.map((group) => group.getAttribute('transform'))).toEqual(positions);
@@ -233,38 +223,6 @@ describe('ScatterGraph unofficial overlays', () => {
     unmount();
   });
 
-  it('includes unofficial measured points in the validated/historical coverage summary', () => {
-    const runUrl = 'https://github.com/o/r/actions/runs/123';
-    const overlayPoints = [
-      { ...point('h100', 'fp8', 30, 300, 2), power_tier: 'certified', run_url: runUrl },
-      { ...point('h100', 'fp8', 35, 350, 4), power_tier: 'legacy', run_url: runUrl },
-    ] as InferenceData[];
-    inferenceState.current = {
-      ...baseInferenceState(),
-      selectedYAxisMetric: 'y_measuredJPerOutputToken',
-    };
-    overlayState.current = {
-      ...baseOverlayState(),
-      isUnofficialRun: true,
-      activeOverlayHwTypes: new Set(['h100']),
-      allOverlayHwTypes: new Set(['h100']),
-      runIndexByUrl: { [runUrl]: 0 },
-      unofficialRunInfos: [{ id: '123', branch: 'test-branch', url: runUrl }],
-    };
-
-    const { container, unmount } = mountChart({
-      overlayData: {
-        data: overlayPoints,
-        hardwareConfig: HARDWARE_CONFIG,
-      } as unknown as Parameters<typeof ScatterGraph>[0]['overlayData'],
-    });
-
-    expect(
-      container.querySelector('[data-testid="measured-power-summary"]')?.textContent,
-    ).toContain('Showing 2 of 2 measured points: 1/1 validated · 1/1 historical.');
-    unmount();
-  });
-
   it('keeps unofficial-run overlay markers rendered through official toggles', () => {
     const overlayPoints = [point('h100', 'fp8', 30, 300, 2), point('h100', 'fp8', 35, 350, 4)].map(
       (p) => ({ ...p, run_url: 'https://github.com/o/r/actions/runs/123' }),
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 318e2dce8..2716396c5 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -136,11 +136,7 @@ import {
   generateOverlayTooltipContent,
   generateTooltipContent,
 } from '@/components/inference/utils/tooltipUtils';
-import {
-  POWER_TIMELINE_METRIC_KEY,
-  requestPowerTraceFocus,
-  traceKeyForPoint,
-} from '@/components/inference/utils/powerTimeline';
+import { usePowerTraceAction } from '@/components/inference/hooks/usePowerTraceAction';
 import { QuickFiltersDialog } from '@/components/inference/ui/QuickFiltersDialog';
 import { ScatterEmptyState } from '@/components/inference/ui/ScatterEmptyState';
 import {
@@ -162,18 +158,15 @@ import {
   powerVariantLabel,
   powerVariantsInData,
 } from '@/components/inference/utils/power-compare';
+import FrontierPointsPanel from '@/components/inference/ui/FrontierPointsPanel';
 import LegendPointsDialog from '@/components/inference/ui/LegendPointsDialog';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
-import { renderLegacyPowerRing } from '@/components/inference/utils/legacy-power-marker';
-import {
-  countPowerTiers,
-  MeasuredPowerSummary,
-} from '@/components/inference/ui/MeasuredPowerSummary';
 import {
   isMeasuredEnergyConfigKey,
   isRoleLocalMeasuredEnergyConfigKey,
 } from '@/components/inference/metric-registry';
 import { buildLegendPointsRows } from '@/components/inference/utils/legend-points-table';
+import { groupConcurrencySeries } from '@/components/inference/utils/concurrency-series';
 import { resolveScatterXAxisScale } from '@/components/inference/utils/x-axis-scale';
 import { pointLabelText } from './point-label';
 import {
@@ -290,7 +283,7 @@ const VARIANT_DASH_BY_ID = new Map<string, string>(
 
 const LINE_LABEL_RAISE = ['.line-label'] as const;
 /** Decorations sit above the visible shape, which a precision toggle may replace. */
-const POINT_DECORATION_RAISE = ['.offload-halo', '.legacy-power-ring'] as const;
+const POINT_DECORATION_RAISE = ['.offload-halo'] as const;
 
 /** Rebuilds and zoom frames re-sync every gradient stop; skip unchanged writes. */
 function syncGradientStop(this: SVGStopElement, stop: { offset: number; color: string }): void {
@@ -452,6 +445,8 @@ const pointCountEn = (count: number) => `${count} ${count === 1 ? 'point' : 'poi
 
 const SCATTER_STRINGS = {
   en: {
+    concurrencyCurves:
+      'Dots are observed loads. Straight segments connect only matching topology, recipe and run; repeated loads remain separate markers. Concurrency is not a higher-is-better score.',
     logScale: 'Log Scale',
     optimalOnly: 'Optimal Only',
     paretoFrontier: 'Pareto Frontier',
@@ -461,10 +456,6 @@ const SCATTER_STRINGS = {
     optimalInfo: 'Optimal points form the Pareto frontier for the selected axes.',
     powerBoundaryInfo:
       'Show only points on the upper measured power boundary. Turn off to show all measurements; the boundary stays the same. This is a power-load boundary, not an energy-efficiency frontier.',
-    powerCurves:
-      'Smooth lines trace the upper power boundary across tested configurations. Dots are measured; lines are interpolated, not efficiency frontiers.',
-    powerOptimal:
-      'A power Pareto frontier can contain a single point. Turn off Optimal Only to show the upper power boundary.',
     labels: 'Labels',
     highContrast: 'High Contrast',
     parallelismLabels: 'Parallelism Labels',
@@ -484,12 +475,16 @@ const SCATTER_STRINGS = {
     noDataHint: 'Please change the model, sequence, precision, date range or chip selection.',
     noRoleEnergyDataHint:
       'This dataset does not report role-level prefill/decode energy. Choose a different model, scenario, precision, date, or measured-energy metric.',
+    noMeasuredDataHint:
+      'No measured GPU power is reported for this selection. Choose other chip configs, or a different model, scenario, precision or date.',
     unofficialTitle: (branch: string) => `UNOFFICIAL: ${branch}`,
     unofficialRun: 'UNOFFICIAL RUN',
     branch: 'Branch',
     viewWorkflow: 'View workflow run',
   },
   zh: {
+    concurrencyCurves:
+      '点表示实测负载；直线段仅连接相同拓扑、配方和运行的数据，重复负载保留为独立点。并发数不是越高越好的分数。',
     logScale: '对数缩放',
     optimalOnly: '仅最优',
     paretoFrontier: 'Pareto 前沿',
@@ -499,9 +494,6 @@ const SCATTER_STRINGS = {
     optimalInfo: '最优点构成当前所选坐标轴的 Pareto 前沿。',
     powerBoundaryInfo:
       '仅显示实测功率上边界上的点。关闭后显示全部测量点，边界曲线保持不变。这是功率负载边界，不是能效前沿。',
-    powerCurves:
-      '平滑曲线勾勒各测试配置的功耗上边界。数据点来自实测，曲线通过插值得到，不代表能效 Pareto 前沿。',
-    powerOptimal: '功耗的 Pareto 前沿可能只有一个点。关闭“仅最优”即可查看功耗上边界。',
     labels: '标签',
     highContrast: '高对比度',
     parallelismLabels: '并行配置标签',
@@ -521,6 +513,8 @@ const SCATTER_STRINGS = {
     noDataHint: '请调整模型、序列长度、精度、日期范围或芯片选项。',
     noRoleEnergyDataHint:
       '当前数据集未提供 Prefill/Decode 各角色的能耗数据。请选择其他模型、场景、精度、日期或实测能耗指标。',
+    noMeasuredDataHint:
+      '当前选择没有实测 GPU 功耗数据。请选择其他芯片配置，或更换模型、场景、精度或日期。',
     unofficialTitle: (branch: string) => `非官方：${branch}`,
     unofficialRun: '非官方运行',
     branch: '分支',
@@ -601,22 +595,26 @@ const ScatterGraph = React.memo(
       setQuickFilterDeployment,
       setQuickFilterSpec,
       setQuickFilterPower,
-      setSelectedYAxisMetric,
+      setQuickFilterTopologies,
     } = useInferenceActions();
-    const paretoDirection = chartDefinition[`${selectedYAxisMetric}_roofline`] as
-      | ParetoDirection
-      | undefined;
+    const isConcurrencyAxis = chartDefinition.x_scale_field === 'conc';
+    const paretoDirection = (
+      isConcurrencyAxis ? undefined : chartDefinition[`${selectedYAxisMetric}_roofline`]
+    ) as ParetoDirection | undefined;
     const hideNonOptimal = preferOptimalOnly && Boolean(paretoDirection);
     const isPowerAxis = isPowerCurveMetric(selectedYAxisMetric);
     const isMeasuredPowerAxis = isMeasuredPowerCurveMetric(selectedYAxisMetric);
     // Measured power describes the load sweep. Keep its boundary fixed while
     // Optimal Only changes marker visibility, as on the other scatter charts.
-    const showPowerEnvelope = isPowerAxis && (isMeasuredPowerAxis || !hideNonOptimal);
+    const showPowerEnvelope =
+      !isConcurrencyAxis && isPowerAxis && (isMeasuredPowerAxis || !hideNonOptimal);
     const showAllMeasurements = isMeasuredPowerAxis ? !hideNonOptimal : savedShowAllMeasurements;
-    const supportsGradientLabels = !showPowerEnvelope || isMeasuredPowerAxis;
+    const supportsGradientLabels =
+      !isConcurrencyAxis && (!showPowerEnvelope || isMeasuredPowerAxis);
     const showGradientLabels = preferGradientLabels && supportsGradientLabels;
     const groupDisplayedPoints = useCallback(
       (points: InferenceData[]) => {
+        if (isConcurrencyAxis) return groupConcurrencySeries(points);
         const groups = groupPointsByDate(points);
         if (showPowerEnvelope) {
           for (const [date, samples] of groups) {
@@ -632,7 +630,7 @@ const ScatterGraph = React.memo(
         }
         return groups;
       },
-      [showPowerEnvelope, chartDefinition.chartType, selectedYAxisMetric],
+      [isConcurrencyAxis, showPowerEnvelope, chartDefinition.chartType, selectedYAxisMetric],
     );
     const locale = useLocale();
     const featureGateUnlocked = useFeatureGate();
@@ -648,9 +646,6 @@ const ScatterGraph = React.memo(
     const ephemeralUrlState = useEphemeralUrlState();
     const costLimit = chartDefinition.y_cost_limit ?? 0;
     const latencyLimit = chartDefinition.y_latency_limit ?? 0;
-    // Legacy-power rings decorate points only while a Measured Energy y-axis
-    // is selected (see legacy-power-marker.ts).
-    const isMeasuredEnergyAxis = isMeasuredEnergyConfigKey(selectedYAxisMetric);
 
     const {
       isUnofficialRun,
@@ -919,7 +914,7 @@ const ScatterGraph = React.memo(
       return result;
     }, [groupedData, selectedYAxisMetric, chartDefinition]);
 
-    const displayedRooflines = showPowerEnvelope ? groupedData : rooflines;
+    const displayedRooflines = isConcurrencyAxis || showPowerEnvelope ? groupedData : rooflines;
 
     const powerEnvelopePointKeys = useMemo(() => {
       const keys = new Set<string>();
@@ -968,8 +963,13 @@ const ScatterGraph = React.memo(
       return false;
     }, [data]);
     const buildPointId = useCallback(
-      (point: InferenceData) => scatterPointJoinId(point, distinguishPointDates),
-      [distinguishPointDates],
+      (point: InferenceData) => {
+        const configId = scatterPointJoinId(point, distinguishPointDates);
+        return isConcurrencyAxis
+          ? `${configId}|observation-${point.id ?? data.indexOf(point)}|run-${point.run_url ?? ''}`
+          : configId;
+      },
+      [isConcurrencyAxis, data, distinguishPointDates],
     );
 
     // filteredData: visible points only (for scale domain calculation)
@@ -1217,7 +1217,7 @@ const ScatterGraph = React.memo(
       [overlayGroups, paretoDirection],
     );
     const displayedOverlayRooflines = useMemo(() => {
-      if (!showPowerEnvelope) return overlayRooflines;
+      if (!showPowerEnvelope && !isConcurrencyAxis) return overlayRooflines;
       return Object.fromEntries(
         Object.entries(overlayGroups).flatMap(([key, group]) =>
           [...groupDisplayedPoints(group.points)].map(([segment, points]) => [
@@ -1226,7 +1226,13 @@ const ScatterGraph = React.memo(
           ]),
         ),
       );
-    }, [showPowerEnvelope, overlayRooflines, overlayGroups, groupDisplayedPoints]);
+    }, [
+      isConcurrencyAxis,
+      showPowerEnvelope,
+      overlayRooflines,
+      overlayGroups,
+      groupDisplayedPoints,
+    ]);
 
     // Overlay counterpart of `optimalPointKeys`: the points on any overlay
     // run's drawn roofline (already e2e-restricted for agentic non-e2e modes).
@@ -1313,43 +1319,7 @@ const ScatterGraph = React.memo(
     const [fixedLogPointId, setFixedLogPointId] = useState<number | null>(null);
     const [powerTelemetryPoint, setPowerTelemetryPoint] = useState<InferenceData | null>(null);
 
-    // "View power trace" on a pinned tooltip (official or overlay point): the
-    // same-tab click stays in-page — remember which trace to emphasise, switch
-    // the metric to the Timeline display, and let the anchor's href keep
-    // serving open-in-new-tab. Listeners are attached per pin because the
-    // tooltip HTML is replaced on every pin.
-    const attachPowerTraceAction = useCallback(
-      (tooltipEl: HTMLElement, d: InferenceData, overlay: boolean) => {
-        const action = tooltipEl.querySelector('[data-action="view-power-trace"]');
-        const traceKey = traceKeyForPoint(d);
-        if (!action || !traceKey) return;
-        action.addEventListener('click', (actionEvent) => {
-          actionEvent.stopPropagation();
-          // Modifier / auxiliary clicks keep the anchor's own behaviour: the
-          // href opens this chart's timeline in a new tab or window.
-          const mouse = actionEvent as MouseEvent;
-          if (
-            mouse.button !== 0 ||
-            mouse.metaKey ||
-            mouse.ctrlKey ||
-            mouse.shiftKey ||
-            mouse.altKey
-          ) {
-            return;
-          }
-          actionEvent.preventDefault();
-          requestPowerTraceFocus(traceKey);
-          chartRef.current?.dismissTooltip();
-          setSelectedYAxisMetric(POWER_TIMELINE_METRIC_KEY);
-          track('inference_power_trace_opened', {
-            hwKey: String(d.hwKey),
-            conc: d.conc,
-            overlay,
-          });
-        });
-      },
-      [setSelectedYAxisMetric],
-    );
+    const attachPowerTraceAction = usePowerTraceAction(chartRef);
 
     // --- Legend points table (per-series drill-down opened from the legend) ---
     const [pointsTableTarget, setPointsTableTarget] = useState<LegendPointsTarget | null>(null);
@@ -1360,6 +1330,7 @@ const ScatterGraph = React.memo(
       (lockedFrameworks ? 0 : quickFilters.frameworks.length) +
       quickFilters.deployment.length +
       quickFilters.power.length +
+      (quickFilters.topologies?.length ?? 0) +
       (selectedSequence === Sequence.AgenticTraces ? 0 : quickFilters.spec.length);
     const clearQuickFilters = useCallback(() => {
       setQuickFilterVendors([]);
@@ -1367,12 +1338,14 @@ const ScatterGraph = React.memo(
       setQuickFilterDeployment([]);
       if (selectedSequence !== Sequence.AgenticTraces) setQuickFilterSpec([]);
       setQuickFilterPower([]);
+      setQuickFilterTopologies([]);
     }, [
       setQuickFilterVendors,
       setQuickFilterFrameworks,
       setQuickFilterDeployment,
       setQuickFilterSpec,
       setQuickFilterPower,
+      setQuickFilterTopologies,
       selectedSequence,
     ]);
 
@@ -1563,7 +1536,11 @@ const ScatterGraph = React.memo(
     const metricIdentity = useMemo(
       () =>
         [
-          showPowerEnvelope ? 'power-envelopes' : 'pareto-curves',
+          isConcurrencyAxis
+            ? 'observed-load'
+            : showPowerEnvelope
+              ? 'power-envelopes'
+              : 'pareto-curves',
           useAdvancedLabels ? 'advanced-labels' : 'basic-labels',
           showConcurrencyLabels ? 'conc-labels' : 'no-conc-labels',
           selectedYAxisMetric,
@@ -1581,6 +1558,7 @@ const ScatterGraph = React.memo(
           .toSorted()
           .join('|'),
       [
+        isConcurrencyAxis,
         showPowerEnvelope,
         selectedYAxisMetric,
         useAdvancedLabels,
@@ -1676,6 +1654,25 @@ const ScatterGraph = React.memo(
       () => frontierHardwareKeys(globalParetoPoints, globalFrontier),
       [globalParetoPoints, globalFrontier],
     );
+    // PowerX provenance of the drawn frontier: the same points, listed with their runs.
+    const showFrontierPoints =
+      showParetoFrontier &&
+      globalFrontier.length > 0 &&
+      !minimalChrome &&
+      getMeasuredMetricConfig(selectedYAxisMetric) !== undefined;
+    const frontierHardwareLabel = useCallback(
+      (point: InferenceData) => {
+        const config = processedOverlayData.includes(point)
+          ? overlayData?.hardwareConfig[point.hwKey]
+          : hardwareConfig[point.hwKey];
+        return config ? getDisplayLabel(config) : point.hwKey;
+      },
+      [processedOverlayData, overlayData, hardwareConfig],
+    );
+    const frontierHardwareColor = useCallback(
+      (point: InferenceData) => getCssColor(resolveColor(point.hwKey)),
+      [getCssColor, resolveColor],
+    );
     const applyParetoFadeRef = useRef<(group: RenderContext['layout']['zoomGroup']) => void>(
       () => {},
     );
@@ -1863,31 +1860,6 @@ const ScatterGraph = React.memo(
       hiddenPowerVariants,
     ]);
 
-    const powerTierCounts = useMemo(() => {
-      // Comparison clones re-plot the same measurements; count each once.
-      const officialTotal = pointsData.filter(
-        (point) => !point.powerVariant && selectedPrecisions.includes(point.precision),
-      );
-      const overlayTotal = processedOverlayData.filter(
-        (point) => !point.powerVariant && selectedPrecisions.includes(point.precision),
-      );
-      const officialVisible = officialTotal.filter(isPointVisible);
-      const overlayVisible = overlayTotal.filter(
-        (point) => activeOverlayHwTypes.has(String(point.hwKey)) && isOverlayPointVisible(point),
-      );
-      return {
-        total: countPowerTiers([...officialTotal, ...overlayTotal]),
-        visible: countPowerTiers([...officialVisible, ...overlayVisible]),
-      };
-    }, [
-      pointsData,
-      processedOverlayData,
-      selectedPrecisions,
-      isPointVisible,
-      activeOverlayHwTypes,
-      isOverlayPointVisible,
-    ]);
-
     // --- Legend hover highlight ---
     const isRooflineVisible = useCallback(
       (el: SVGElement) => {
@@ -1968,7 +1940,8 @@ const ScatterGraph = React.memo(
         persistedRulers !== undefined &&
         (persistedRulers.pending !== null || persistedRulers.state.rulers.length > 0),
     );
-    const perfRulerMode = preferPerfRulerMode && (!showPowerEnvelope || isMeasuredPowerAxis);
+    const perfRulerMode =
+      !isConcurrencyAxis && preferPerfRulerMode && (!showPowerEnvelope || isMeasuredPowerAxis);
     const [localPerfRulerState, setLocalPerfRulerState] =
       useState<PerfRulerState>(EMPTY_PERF_RULER_STATE);
     const perfRulerState = persistedRulers ? persistedRulers.state : localPerfRulerState;
@@ -2634,6 +2607,13 @@ const ScatterGraph = React.memo(
 
     // --- Layers ---
     const layers = useMemo((): LayerConfig<InferenceData>[] => {
+      // Observed-load segments join exact measurements; every other curve is smoothed.
+      const lineCurve = isConcurrencyAxis ? d3.curveLinear : d3.curveMonotoneX;
+      const curveKind = isConcurrencyAxis
+        ? 'observed-load'
+        : showPowerEnvelope
+          ? 'power-envelope'
+          : 'pareto';
       // Line-label identity of one drawn series under a power comparison
       // (`i_pcompare`): the base series keeps the hardware key, so pinned
       // anchors and hover hooks keep working; a sibling is `<hw>::<variant>`.
@@ -2677,7 +2657,7 @@ const ScatterGraph = React.memo(
             .line<InferenceData>()
             .x((d) => xScale(d.x))
             .y((d) => yScale(d.y))
-            .curve(d3.curveMonotoneX);
+            .curve(lineCurve);
 
           // Ensure rooflines layer exists before dot-groups
           let rooflinesLayer = zoomGroup.select<SVGGElement>('.rooflines-layer');
@@ -2779,7 +2759,7 @@ const ScatterGraph = React.memo(
             )
             .join('path')
             .attr('class', (d) => `roofline-path roofline-${d.key}`)
-            .attr('data-curve-kind', showPowerEnvelope ? 'power-envelope' : 'pareto')
+            .attr('data-curve-kind', curveKind)
             .attr('data-hw-key', (d) => d.hw)
             .attr('data-precision', (d) => d.precision)
             .attr('data-power-variant', (d) => d.variant || null)
@@ -2878,7 +2858,7 @@ const ScatterGraph = React.memo(
               (exit) => exit.remove(),
             )
             .attr('data-seg-key', (d) => d.segKey)
-            .attr('data-curve-kind', showPowerEnvelope ? 'power-envelope' : 'pareto')
+            .attr('data-curve-kind', curveKind)
             .attr('data-hw-key', (d) => d.hw)
             .attr('data-precision', (d) => d.precision)
             .attr('transform', (d) => `translate(${d.x},${d.y})`)
@@ -3171,7 +3151,7 @@ const ScatterGraph = React.memo(
             .line<InferenceData>()
             .x((d) => newXScale(d.x))
             .y((d) => newYScale(d.y))
-            .curve(d3.curveMonotoneX);
+            .curve(lineCurve);
 
           // Update roofline paths — must split per-date so the zoom redraw
           // matches the per-date sub-paths created in the initial render.
@@ -3401,7 +3381,7 @@ const ScatterGraph = React.memo(
                 .line<InferenceData>()
                 .x((d) => xScale(d.x))
                 .y((d) => yScale(d.y))
-                .curve(d3.curveMonotoneX);
+                .curve(lineCurve);
 
               interface OvEntry {
                 key: string;
@@ -3434,7 +3414,7 @@ const ScatterGraph = React.memo(
                 .data(ovEntries, (d) => d.key)
                 .join('path')
                 .attr('class', (d) => `overlay-roofline-path overlay-roofline-${d.key}`)
-                .attr('data-curve-kind', showPowerEnvelope ? 'power-envelope' : 'pareto')
+                .attr('data-curve-kind', curveKind)
                 .attr('fill', 'none')
                 .attr('stroke', (d) => d.stroke)
                 .attr('stroke-width', 2)
@@ -3497,15 +3477,14 @@ const ScatterGraph = React.memo(
                   overlayRunColor(overlayRunIndex(d.run_url ?? null, runIndexByUrl)),
                 );
 
-              // Match official points: KV offload and the measured-axis
-              // legacy-power ring are the only persistent point decorations.
-              // Decode method remains in the tooltip.
+              // Match official points: KV offload is the only persistent point
+              // decoration. Decode method remains in the tooltip.
               overlayPoints.each(function (d) {
-                const overlayStroke = overlayRunColor(
-                  overlayRunIndex(d.run_url ?? null, runIndexByUrl),
+                renderOffloadHalo(
+                  d3.select(this),
+                  d,
+                  overlayRunColor(overlayRunIndex(d.run_url ?? null, runIndexByUrl)),
                 );
-                renderOffloadHalo(d3.select(this), d, overlayStroke);
-                renderLegacyPowerRing(d3.select(this), d, isMeasuredEnergyAxis, overlayStroke);
               });
 
               updateOverlayLabels(zoomGroup);
@@ -3588,7 +3567,7 @@ const ScatterGraph = React.memo(
                 .line<InferenceData>()
                 .x((d) => newXScale(d.x))
                 .y((d) => newYScale(d.y))
-                .curve(d3.curveMonotoneX);
+                .curve(lineCurve);
 
               Object.entries(displayedOverlayRooflines).forEach(([key, group]) => {
                 if (group.points.length < 2) return;
@@ -3676,7 +3655,7 @@ const ScatterGraph = React.memo(
             .line<InferenceData>()
             .x((point) => xScale(point.x))
             .y((point) => yScale(point.y))
-            .curve(d3.curveMonotoneX);
+            .curve(lineCurve);
           const continuationPath = group
             .select<SVGPathElement>('.overflow-continuation-line')
             .attr('d', lineGenerator(entry.points) ?? '')
@@ -3817,6 +3796,7 @@ const ScatterGraph = React.memo(
       // existing DOM when it changes. Only data/structure changes recreate
       // the layers (and with them, the full chart render).
     }, [
+      isConcurrencyAxis,
       displayedRooflines,
       paretoHighlightLayer,
       groupDisplayedPoints,
@@ -3846,7 +3826,6 @@ const ScatterGraph = React.memo(
       yLabel,
       selectedYAxisMetric,
       powerCompareBaseId,
-      isMeasuredEnergyAxis,
       chartDefinition,
       locale,
       drawPerfRuler,
@@ -3870,10 +3849,8 @@ const ScatterGraph = React.memo(
         zoomGroup.selectAll('.dot-group').style('transition', 'opacity 150ms ease');
 
         // Offload halo: dashed ring on every point that used KV offload (Pareto or not).
-        // Legacy-power ring: dotted ring on unvalidated telemetry, measured axes only.
         zoomGroup.selectAll<SVGGElement, InferenceData>('.dot-group').each(function (d) {
           renderOffloadHalo(d3.select(this), d, 'var(--foreground)');
-          renderLegacyPowerRing(d3.select(this), d, isMeasuredEnergyAxis, 'var(--foreground)');
         });
 
         avoidPointLabelCollisions(zoomGroup);
@@ -3903,9 +3880,6 @@ const ScatterGraph = React.memo(
         optimalPointKeys,
         getCssColor,
         resolveColor,
-        // A metric-only change must re-run the decoration pass so legacy-power
-        // rings appear/disappear with the Measured Energy axis selection.
-        isMeasuredEnergyAxis,
       ],
     );
 
@@ -4239,8 +4213,12 @@ const ScatterGraph = React.memo(
       <ScatterEmptyState
         reason={emptyReason}
         description={
-          emptyReason === 'selection' && isRoleLocalMeasuredEnergyConfigKey(selectedYAxisMetric)
-            ? legendT.noRoleEnergyDataHint
+          emptyReason === 'selection'
+            ? isRoleLocalMeasuredEnergyConfigKey(selectedYAxisMetric)
+              ? legendT.noRoleEnergyDataHint
+              : isMeasuredEnergyConfigKey(selectedYAxisMetric)
+                ? legendT.noMeasuredDataHint
+                : undefined
             : undefined
         }
         onShowChips={() => {
@@ -4267,7 +4245,11 @@ const ScatterGraph = React.memo(
           <QuickFiltersDialog
             open={quickFiltersOpen}
             onOpenChange={setQuickFiltersOpen}
-            bestPerSku={{ checked: bestPerSku, onCheckedChange: handleBestPerSkuChange }}
+            bestPerSku={
+              isConcurrencyAxis
+                ? undefined
+                : { checked: bestPerSku, onCheckedChange: handleBestPerSkuChange }
+            }
           />
         </div>
       );
@@ -4291,14 +4273,14 @@ const ScatterGraph = React.memo(
           testId="scatter-graph"
           grabCursor={true}
           caption={
-            isPowerAxis ? (
+            isConcurrencyAxis ? (
               <>
                 {caption}
                 <p
-                  data-testid="power-curve-description"
+                  data-testid="concurrency-curve-description"
                   className="mt-2 text-2xs text-muted-foreground"
                 >
-                  {showPowerEnvelope ? legendT.powerCurves : legendT.powerOptimal}
+                  {legendT.concurrencyCurves}
                 </p>
               </>
             ) : (
@@ -4573,7 +4555,7 @@ const ScatterGraph = React.memo(
                     track('latency_line_labels_toggled', { enabled: checked });
                   },
                 },
-                ...(showPowerEnvelope && !isMeasuredPowerAxis
+                ...(isConcurrencyAxis || (showPowerEnvelope && !isMeasuredPowerAxis)
                   ? []
                   : [
                       {
@@ -4659,18 +4641,14 @@ const ScatterGraph = React.memo(
             />
           }
         />
-        {isMeasuredEnergyAxis && (
-          <MeasuredPowerSummary
-            total={powerTierCounts.total}
-            visible={powerTierCounts.visible}
-            bestPerSku={bestPerSku}
-            optimalOnly={hideNonOptimal}
-          />
-        )}
         <QuickFiltersDialog
           open={quickFiltersOpen}
           onOpenChange={setQuickFiltersOpen}
-          bestPerSku={{ checked: bestPerSku, onCheckedChange: handleBestPerSkuChange }}
+          bestPerSku={
+            isConcurrencyAxis
+              ? undefined
+              : { checked: bestPerSku, onCheckedChange: handleBestPerSkuChange }
+          }
         />
         {pointsTable && (
           <LegendPointsDialog
@@ -4692,6 +4670,18 @@ const ScatterGraph = React.memo(
             }
           />
         )}
+        {showFrontierPoints && (
+          <FrontierPointsPanel
+            chartId={chartId}
+            eligible={globalParetoPoints}
+            frontier={globalFrontier}
+            xLabel={xLabel}
+            yLabel={yLabel}
+            overlayPoints={processedOverlayData}
+            hardwareLabel={frontierHardwareLabel}
+            hardwareColor={frontierHardwareColor}
+          />
+        )}
         {powerTelemetryPoint === null ? null : (
           <PowerTelemetryDialog
             key={powerTelemetryPoint.id}
diff --git a/packages/app/src/components/inference/ui/XAxisModeSelector.tsx b/packages/app/src/components/inference/ui/XAxisModeSelector.tsx
index 70bfb757f..418b48fae 100644
--- a/packages/app/src/components/inference/ui/XAxisModeSelector.tsx
+++ b/packages/app/src/components/inference/ui/XAxisModeSelector.tsx
@@ -10,6 +10,7 @@ import { SearchableSelect } from '@/components/ui/searchable-select';
 import { X_AXIS_EXPLANATIONS, type XAxisKind } from '../axis-metric-explanations';
 import { isAgenticOnlyXAxisMode, type XAxisMode } from '../hooks/useChartData';
 import { useLocale } from '@/lib/use-locale';
+import type { FixedSequenceStatistic } from '../utils/resolveXAxisField';
 import { NormalizedInteractivityHelpLink } from './NormalizedInteractivityHelpLink';
 
 const X_AXIS_OPTIONS: { value: XAxisMode; kind: XAxisKind; label: string; labelZh: string }[] = [
@@ -19,6 +20,7 @@ const X_AXIS_OPTIONS: { value: XAxisMode; kind: XAxisKind; label: string; labelZ
     label: 'E2E Normalized Interactivity',
     labelZh: '端到端归一化交互性',
   },
+  { value: 'concurrency', kind: 'concurrency', label: 'Concurrency', labelZh: '并发数' },
   { value: 'interactivity', kind: 'interactivity', label: 'Interactivity', labelZh: '交互性' },
   { value: 'e2e', kind: 'e2eLatency', label: 'E2E Latency', labelZh: '端到端延迟' },
   { value: 'ttft', kind: 'ttft', label: 'TTFT', labelZh: 'TTFT' },
@@ -27,17 +29,31 @@ const X_AXIS_OPTIONS: { value: XAxisMode; kind: XAxisKind; label: string; labelZ
 const STRINGS = {
   en: {
     label: 'X-Axis Metric',
-    help: 'Choose the horizontal axis: Interactivity, end-to-end latency, or Time To First Token (TTFT). Agentic scenarios also offer E2E Normalized Interactivity.',
+    statistic: 'Service Statistic',
+    mean: 'Mean',
+    median: 'Median',
+    statisticHelp:
+      'Mean interactivity is 1 ÷ mean time per output token (TPOT, in seconds), not the arithmetic mean of per-request token rates. Mean TTFT and E2E use their reported means; unavailable measurements are omitted. Median uses the reported median for each metric.',
+    help: 'Choose the horizontal axis: Concurrency, Interactivity, end-to-end latency, or Time To First Token (TTFT). Agentic scenarios also offer E2E Normalized Interactivity.',
   },
   zh: {
     label: 'X 轴指标',
-    help: '选择横轴指标：交互性、端到端延迟或首 token 延迟（TTFT）。Agentic 场景还支持端到端归一化交互性。',
+    statistic: '服务指标统计量',
+    mean: '平均值',
+    median: '中位数',
+    statisticHelp:
+      '平均交互性 = 1 ÷ 平均每输出 token 耗时（TPOT，单位为秒），不是逐请求 token 速率的算术平均值。平均 TTFT 和端到端延迟使用各自上报的平均值；缺失的数据点不显示。中位数选项使用各指标上报的中位数。',
+    help: '选择横轴指标：并发数、交互性、端到端延迟或首 token 延迟（TTFT）。Agentic 场景还支持端到端归一化交互性。',
   },
 } as const;
 
 export function XAxisModeSelector() {
-  const { selectedXAxisMode: value, selectedPercentile } = useInferenceDisplay();
-  const { setSelectedXAxisMode } = useInferenceActions();
+  const {
+    selectedXAxisMode: value,
+    selectedPercentile,
+    fixedSequenceStatistic,
+  } = useInferenceDisplay();
+  const { setSelectedXAxisMode, setFixedSequenceStatistic } = useInferenceActions();
   const { selectedSequence } = useInferenceFilters();
   const isAgentic = selectedSequence === Sequence.AgenticTraces;
   const [mounted, setMounted] = useState(false);
@@ -51,45 +67,82 @@ export function XAxisModeSelector() {
 
   return (
     <TooltipProvider delayDuration={0}>
-      <div
-        className={`flex w-full min-w-0 flex-col space-y-1.5 ${isAgentic ? 'max-w-72' : 'max-w-44'}`}
-      >
-        <LabelWithTooltip htmlFor="x-axis-mode-select" label={t.label} tooltip={t.help} />
-        <SearchableSelect
-          value={value}
-          triggerId="x-axis-mode-select"
-          triggerTestId="x-axis-mode-selector"
-          placeholder={t.label}
-          initialLabel={locale === 'zh' ? '交互性' : 'Interactivity'}
-          searchable={false}
-          onValueChange={(mode) => {
-            setSelectedXAxisMode(mode as XAxisMode);
-            track('latency_x_axis_mode_selected', { mode });
-          }}
-          groups={[
-            {
-              label: '',
-              options: options.map(({ value: option, kind, label, labelZh }) => ({
-                value: option,
-                label: locale === 'zh' ? labelZh : label,
-                testId: `x-axis-mode-${option}`,
-                help: (
-                  <>
-                    <p className="text-xs">
-                      {X_AXIS_EXPLANATIONS[kind].name[locale](
-                        isAgentic ? selectedPercentile.toUpperCase() : null,
+      <div className="flex w-full flex-wrap gap-4">
+        <div
+          className={`flex w-full min-w-0 flex-col space-y-1.5 ${isAgentic ? 'max-w-72' : 'max-w-44'}`}
+        >
+          <LabelWithTooltip htmlFor="x-axis-mode-select" label={t.label} tooltip={t.help} />
+          <SearchableSelect
+            value={value}
+            triggerId="x-axis-mode-select"
+            triggerTestId="x-axis-mode-selector"
+            placeholder={t.label}
+            initialLabel={locale === 'zh' ? '交互性' : 'Interactivity'}
+            searchable={false}
+            onValueChange={(mode) => {
+              setSelectedXAxisMode(mode as XAxisMode);
+              track('latency_x_axis_mode_selected', { mode });
+            }}
+            groups={[
+              {
+                label: '',
+                options: options.map(({ value: option, kind, label, labelZh }) => ({
+                  value: option,
+                  label: locale === 'zh' ? labelZh : label,
+                  testId: `x-axis-mode-${option}`,
+                  help: (
+                    <>
+                      <p className="text-xs">
+                        {X_AXIS_EXPLANATIONS[kind].name[locale](
+                          isAgentic
+                            ? selectedPercentile.toUpperCase()
+                            : fixedSequenceStatistic === 'mean'
+                              ? 'Mean'
+                              : 'Median',
+                        )}
+                      </p>
+                      <p>{X_AXIS_EXPLANATIONS[kind].description[locale]}</p>
+                      {isAgenticOnlyXAxisMode(option) && (
+                        <NormalizedInteractivityHelpLink locale={locale} />
                       )}
-                    </p>
-                    <p>{X_AXIS_EXPLANATIONS[kind].description[locale]}</p>
-                    {isAgenticOnlyXAxisMode(option) && (
-                      <NormalizedInteractivityHelpLink locale={locale} />
-                    )}
-                  </>
-                ),
-              })),
-            },
-          ]}
-        />
+                    </>
+                  ),
+                })),
+              },
+            ]}
+          />
+        </div>
+        {mounted && !isAgentic && value !== 'concurrency' && (
+          <div className="flex w-full max-w-44 min-w-0 flex-col space-y-1.5">
+            <LabelWithTooltip
+              htmlFor="fixed-sequence-statistic-select"
+              label={t.statistic}
+              tooltip={t.statisticHelp}
+            />
+            <SearchableSelect
+              value={fixedSequenceStatistic}
+              triggerId="fixed-sequence-statistic-select"
+              triggerTestId="fixed-sequence-statistic-selector"
+              placeholder={t.statistic}
+              searchable={false}
+              onValueChange={(statistic) => {
+                setFixedSequenceStatistic(statistic as FixedSequenceStatistic);
+                track('latency_service_statistic_selected', { statistic });
+              }}
+              groups={[
+                {
+                  label: '',
+                  options: (['median', 'mean'] as const).map((statistic) => ({
+                    value: statistic,
+                    label: t[statistic],
+                    testId: `fixed-sequence-statistic-${statistic}`,
+                    help: <p>{t.statisticHelp}</p>,
+                  })),
+                },
+              ]}
+            />
+          </div>
+        )}
       </div>
     </TooltipProvider>
   );
diff --git a/packages/app/src/components/inference/utils.test.ts b/packages/app/src/components/inference/utils.test.ts
index f1560a7fb..2b07210fb 100644
--- a/packages/app/src/components/inference/utils.test.ts
+++ b/packages/app/src/components/inference/utils.test.ts
@@ -226,6 +226,27 @@ describe('processOverlayChartData', () => {
     expect(result.clippedData).toEqual([]);
   });
 
+  it('retains exact concurrency in unofficial overlays regardless of latency or optimization stamps', () => {
+    const points = [1, 4, 128].map((conc) => ({
+      ...prefillEnergyPoint(68, 120),
+      conc,
+      isOnNormalizedInteractivityFrontier: false,
+    }));
+    const result = processOverlayChartDataWithClipping(
+      points,
+      'e2e',
+      'y_measuredPrefillJPerInputToken',
+      'p90_ttft',
+      { isAgentic: false, selectedPercentile: 'p90', selectedXAxisMode: 'concurrency' },
+    );
+    expect(result.data.map((point) => [point.x, point.y])).toEqual([
+      [1, 0.2],
+      [4, 0.2],
+      [128, 0.2],
+    ]);
+    expect(result.clippedData).toEqual([]);
+  });
+
   it('uses median TTFT for fixed-sequence overlays in TTFT mode and omits missing measurements', () => {
     const result = processOverlayChartDataWithClipping(
       [prefillEnergyPoint(68, 1.5), prefillEnergyPoint(55)],
diff --git a/packages/app/src/components/inference/utils.ts b/packages/app/src/components/inference/utils.ts
index 1794cd585..f459b5639 100644
--- a/packages/app/src/components/inference/utils.ts
+++ b/packages/app/src/components/inference/utils.ts
@@ -6,7 +6,10 @@ import { getGpuSpecs, type TcoBasis } from '@/lib/constants';
  */
 
 import chartDefinitions from '@/components/inference/metric-registry';
-import { resolveXAxisField } from '@/components/inference/utils/resolveXAxisField';
+import {
+  resolveXAxisField,
+  type FixedSequenceStatistic,
+} from '@/components/inference/utils/resolveXAxisField';
 import { remapInferencePoint } from '@/lib/chart-utils';
 import { expandPowerCompareSeries } from '@/components/inference/utils/power-compare';
 
@@ -103,6 +106,9 @@ export function partitionChartDataByLimits(
   selectedYAxisMetric: string,
   options: { isTtftX: boolean; isAgentic: boolean },
 ): ProcessedChartData {
+  if (chartDefinition.x_scale_field === 'conc') {
+    return { data: data.filter((point) => Number.isFinite(point.x)), clippedData: [] };
+  }
   const costLimitApplies =
     selectedYAxisMetric.includes('cost') &&
     selectedYAxisMetric !== 'y_costUser' &&
@@ -150,6 +156,7 @@ export function processOverlayChartData(
     isAgentic?: boolean;
     selectedPercentile?: string;
     selectedXAxisMode?: XAxisMode;
+    fixedSequenceStatistic?: FixedSequenceStatistic;
     restrictToNormalizedFrontier?: boolean;
     tcoBasis?: TcoBasis;
     powerCompare?: PowerCompare;
@@ -177,6 +184,7 @@ export function processOverlayChartDataWithClipping(
     isAgentic?: boolean;
     selectedPercentile?: string;
     selectedXAxisMode?: XAxisMode;
+    fixedSequenceStatistic?: FixedSequenceStatistic;
     restrictToNormalizedFrontier?: boolean;
     tcoBasis?: TcoBasis;
     /** Sibling boundary / role series, mirroring the official path in useChartData. */
@@ -226,6 +234,7 @@ export function processOverlayChartDataWithClipping(
     isAgentic,
     percentile: selectedPercentile,
     xAxisMode: options?.selectedXAxisMode,
+    fixedSequenceStatistic: options?.fixedSequenceStatistic,
   });
 
   // The latency limit targets overload outliers on the TTFT axis only; skip it
@@ -251,8 +260,13 @@ export function processOverlayChartDataWithClipping(
     }
   }
 
-  return partitionChartDataByLimits(processedData, chartDef, selectedYAxisMetric, {
-    isTtftX,
-    isAgentic,
-  });
+  return partitionChartDataByLimits(
+    processedData,
+    { ...chartDef, x_scale_field: xAxisField },
+    selectedYAxisMetric,
+    {
+      isTtftX,
+      isAgentic,
+    },
+  );
 }
diff --git a/packages/app/src/components/inference/utils/concurrency-series.ts b/packages/app/src/components/inference/utils/concurrency-series.ts
new file mode 100644
index 000000000..94d46e18a
--- /dev/null
+++ b/packages/app/src/components/inference/utils/concurrency-series.ts
@@ -0,0 +1,36 @@
+import type { InferenceData } from '../types';
+import { pointTopologyKey } from './topology-filter';
+
+/** Observed load sweeps, never a Pareto frontier or an envelope. */
+export function groupConcurrencySeries(
+  points: readonly InferenceData[],
+): Map<string, InferenceData[]> {
+  const groups = new Map<string, InferenceData[]>();
+  for (const [index, point] of points.entries()) {
+    // Unknown provenance cannot establish a controlled sweep. Keep its marker.
+    const run = point.run_url || `unknown-run-${index}`;
+    const key = JSON.stringify([
+      point.hwKey,
+      point.precision,
+      point.date,
+      run,
+      pointTopologyKey(point),
+      point.recipe_fingerprint ?? null,
+      point.powerVariant?.id ?? null,
+    ]);
+    const group = groups.get(key);
+    if (group) group.push(point);
+    else groups.set(key, [point]);
+  }
+  const segments = new Map<string, InferenceData[]>();
+  for (const [key, group] of groups) {
+    const sorted = group.toSorted((a, b) => a.x - b.x);
+    if (new Set(sorted.map((point) => point.x)).size === sorted.length) {
+      segments.set(key, sorted);
+    } else {
+      // Repeats at the same load are distinct observations, not a fitted mean.
+      sorted.forEach((point, index) => segments.set(`${key}:${index}`, [point]));
+    }
+  }
+  return segments;
+}
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
new file mode 100644
index 000000000..1cc0dffe6
--- /dev/null
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
@@ -0,0 +1,165 @@
+import { describe, expect, it } from 'vitest';
+import type { InferenceData } from '../types';
+import {
+  buildEqualServiceComparison,
+  equalServiceSourceKey,
+  getEqualServiceSources,
+} from './equal-service-comparison';
+
+const metric = (y: number) => ({ y, roof: false });
+function point(overrides: Partial<InferenceData> = {}): InferenceData {
+  return {
+    x: 20,
+    y: 500,
+    hwKey: 'b200_sglang',
+    date: '2026-09-23',
+    tp: 4,
+    physicalChips: 4,
+    precision: 'fp8',
+    conc: 8,
+    run_url: 'https://example.invalid/runs/1',
+    model: 'qwen3.5',
+    benchmark_type: 'single_turn',
+    isl: 8192,
+    osl: 1024,
+    decode_tp: 4,
+    mean_intvty: 20,
+    output_tput_per_gpu: 50,
+    measuredAvgPower: metric(400),
+    measuredJPerOutputToken: metric(10),
+    tpPerGpu: metric(50),
+    tpPerMw: metric(50),
+    costh: metric(1),
+    costr: metric(1),
+    costhi: metric(1),
+    costri: metric(1),
+    ...overrides,
+  };
+}
+const a = [
+  point({ id: 1 }),
+  point({
+    id: 2,
+    mean_intvty: 60,
+    conc: 1,
+    measuredAvgPower: metric(800),
+    output_tput_per_gpu: 150,
+    measuredJPerOutputToken: metric(30),
+  }),
+];
+const b = [
+  point({
+    id: 3,
+    hwKey: 'b300_sglang',
+    run_url: 'https://example.invalid/runs/2',
+    measuredAvgPower: metric(800),
+    output_tput_per_gpu: 100,
+    measuredJPerOutputToken: metric(8),
+  }),
+  point({
+    id: 4,
+    hwKey: 'b300_sglang',
+    run_url: 'https://example.invalid/runs/2',
+    mean_intvty: 60,
+    conc: 1,
+    measuredAvgPower: metric(1000),
+    output_tput_per_gpu: 200,
+    measuredJPerOutputToken: metric(16),
+  }),
+];
+const options = {
+  baseline: equalServiceSourceKey(a[0]),
+  comparator: equalServiceSourceKey(b[0]),
+  target: 40,
+  xField: 'mean_intvty' as const,
+};
+
+describe('equal-service comparison', () => {
+  it('interpolates each raw quantity first, retains endpoints, and uses one percentage sign convention', () => {
+    const result = buildEqualServiceComparison([...a, ...b], options);
+    expect(result.metrics.meanWattsPerGpu).toMatchObject({
+      baseline: { value: 600, interpolated: true },
+      comparator: { value: 900 },
+      changePercent: 50,
+    });
+    expect(result.metrics.outputTokensPerSecond).toMatchObject({
+      baseline: { value: 400 },
+      comparator: { value: 600 },
+      changePercent: 50,
+    });
+    expect(result.metrics.joulesPerOutputToken).toMatchObject({
+      baseline: { value: 20 },
+      comparator: { value: 12 },
+      changePercent: -40,
+    });
+    expect(
+      result.metrics.meanWattsPerGpu.baseline?.endpoints.map(({ point: p }) => [
+        p.id,
+        p.conc,
+        p.run_url,
+      ]),
+    ).toEqual([
+      [1, 8, a[0].run_url],
+      [2, 1, a[1].run_url],
+    ]);
+    // Interpolating the endpoint percentages instead would incorrectly give 62.5%.
+    expect(result.metrics.meanWattsPerGpu.changePercent).not.toBe(62.5);
+  });
+
+  it('does not skip a missing interior measurement or turn it into zero', () => {
+    const gap = point({ id: 5, mean_intvty: 40, measuredAvgPower: undefined });
+    const result = buildEqualServiceComparison([...a, gap, ...b], { ...options, target: 50 });
+    expect(result.metrics.meanWattsPerGpu).toMatchObject({
+      baseline: null,
+      changePercent: null,
+      reason: 'missing-metric',
+    });
+    expect(result.metrics.outputTokensPerSecond.changePercent).not.toBeNull();
+  });
+
+  it('scales aggregate output by physical chips, but PD output by decode GPUs only', () => {
+    const aggregate = point({ physicalChips: 8, tp: 2 });
+    const pd = point({
+      hwKey: 'gb200',
+      disagg: true,
+      physicalChips: 8,
+      num_prefill_gpu: 4,
+      num_decode_gpu: 4,
+    });
+    const result = buildEqualServiceComparison([aggregate, pd], {
+      ...options,
+      baseline: equalServiceSourceKey(aggregate),
+      comparator: equalServiceSourceKey(pd),
+      target: 20,
+    });
+    expect(result.metrics.outputTokensPerSecond).toMatchObject({
+      baseline: { value: 400 },
+      comparator: { value: 200 },
+      changePercent: -50,
+    });
+    const invalid = { ...pd, num_decode_gpu: 0 };
+    expect(
+      buildEqualServiceComparison([aggregate, invalid], {
+        ...options,
+        baseline: equalServiceSourceKey(aggregate),
+        comparator: equalServiceSourceKey(invalid),
+        target: 20,
+      }).metrics.outputTokensPerSecond.reason,
+    ).toBe('missing-metric');
+  });
+
+  it('labels sources by hardware and date, adding only the details that tell them apart', () => {
+    const sources = getEqualServiceSources([
+      point({ id: 1 }),
+      point({ id: 2, physicalChips: 8, decode_tp: 8 }),
+      point({ id: 3, run_url: 'https://example.invalid/runs/3' }),
+      point({ id: 4, hwKey: 'b300_sglang', run_url: 'https://example.invalid/runs/2' }),
+    ]);
+    expect(sources.map((source) => source.label)).toEqual([
+      'B200 (SGLang) · 2026-09-23 · Single-node · GPU4 · TP4 · EP? · Run #1',
+      'B200 (SGLang) · 2026-09-23 · Single-node · GPU8 · TP8 · EP?',
+      'B200 (SGLang) · 2026-09-23 · Single-node · GPU4 · TP4 · EP? · Run #3',
+      'B300 (SGLang) · 2026-09-23',
+    ]);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.ts b/packages/app/src/components/inference/utils/equal-service-comparison.ts
new file mode 100644
index 000000000..a4f2fefa6
--- /dev/null
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.ts
@@ -0,0 +1,356 @@
+import type { AggDataEntry, InferenceData } from '../types';
+import { chipCounts } from '@/lib/chip-counts';
+import { getHardwareConfig } from '@/lib/constants';
+import { isPositive, powerBasisNormalization } from '@/lib/power-basis';
+import { getDisplayLabel } from '@/lib/utils';
+import { runIdFromUrl } from './powerTimeline';
+import { reconstructedRoleEnergy, type ReconstructedRoleEnergy } from './role-energy';
+import { pointTopologyKey, topologyLabel } from './topology-filter';
+
+export interface EqualServiceSource {
+  key: string;
+  label: string;
+}
+export interface EqualServiceEstimate {
+  value: number;
+  interpolated: boolean;
+  endpoints: { x: number; value: number; point: InferenceData }[];
+}
+export type EqualServiceReason =
+  | 'unsupported-axis'
+  | 'invalid-target'
+  | 'same-source'
+  | 'unknown-source'
+  | 'out-of-range'
+  | 'ambiguous-x'
+  | 'missing-metric';
+export interface EqualServiceMetric {
+  baseline: EqualServiceEstimate | null;
+  comparator: EqualServiceEstimate | null;
+  /** Comparator change relative to baseline; negative energy means less energy. */
+  changePercent: number | null;
+  reason?: EqualServiceReason;
+}
+export interface EqualServiceOptions {
+  baseline: string;
+  comparator: string;
+  target: number;
+  xField: keyof AggDataEntry;
+}
+export interface EqualServiceComparison {
+  target: number;
+  xField: keyof AggDataEntry;
+  baseline: EqualServiceSource | null;
+  comparator: EqualServiceSource | null;
+  reason?: EqualServiceReason;
+  metrics: Record<
+    'meanWattsPerGpu' | 'outputTokensPerSecond' | 'joulesPerOutputToken',
+    EqualServiceMetric
+  >;
+}
+const serviceAxis = (field: string) =>
+  field === 'mean_tpot_intvty' ||
+  /^(?:mean|median|p\d+(?:\.\d+)?)_(?:intvty|tpot|ttft|e2el|itl)$/u.test(field);
+/** A positive finite reading, or null: a missing value is never zero. */
+export const positiveOrNull = (value: unknown): number | null => (isPositive(value) ? value : null);
+/** Measured rows only: hidden rows and power-comparison clones are never sources. */
+export const observedPoints = (points: readonly InferenceData[]) =>
+  points.filter((point) => !point.hidden && !point.powerVariant);
+
+/** Concurrency is excluded; unknown run identity must never join distinct rows. */
+export function equalServiceSourceKey(point: InferenceData): string {
+  const attempt = 'run_attempt' in point ? point.run_attempt : null;
+  return JSON.stringify([
+    point.hwKey,
+    point.model ?? null,
+    point.framework ?? null,
+    point.precision,
+    point.benchmark_type ?? null,
+    point.isl ?? null,
+    point.osl ?? null,
+    point.actualDate ?? point.date,
+    point.run_url || `unknown-run-point-${point.id ?? JSON.stringify(point)}`,
+    attempt,
+    pointTopologyKey(point),
+    point.recipe_fingerprint ?? null,
+    point.image ?? null,
+    point.mtp ?? null,
+    point.spec_decoding ?? null,
+    point.kv_offloading ?? null,
+    point.kv_offload_backend ?? null,
+    point.kv_offload_backend_version ?? null,
+    point.kv_p2p_transfer ?? null,
+    point.router_name ?? null,
+    point.router_version ?? null,
+    point.power_audit?.producer_sha ?? null,
+    point.power_audit?.exporter_image_sha256 ?? null,
+  ]);
+}
+
+const SOURCE_LABEL_WORDS = {
+  en: {
+    point: 'Point',
+    run: (id: string) => `Run #${id}`,
+    attempt: (attempt: unknown) => `Attempt ${attempt}`,
+    recipe: 'Recipe',
+  },
+  zh: {
+    point: '数据点',
+    run: (id: string) => `运行 #${id}`,
+    attempt: (attempt: unknown) => `第 ${attempt} 次尝试`,
+    recipe: '配方',
+  },
+};
+
+/**
+ * Hardware and date, plus only the details that tell otherwise identical
+ * sources apart, in this order; the opaque key stays the exact identity.
+ */
+function sourceLabels(points: readonly InferenceData[], locale: 'en' | 'zh'): string[] {
+  const words = SOURCE_LABEL_WORDS[locale];
+  const details: ((point: InferenceData, group: readonly InferenceData[]) => string | null)[] = [
+    (point) => point.precision.toUpperCase(),
+    (point, group) => topologyLabel(pointTopologyKey(point), locale, group.map(pointTopologyKey)),
+    (point) => {
+      const runId = runIdFromUrl(point.run_url);
+      return runId ? words.run(runId) : null;
+    },
+    (point) => ('run_attempt' in point ? words.attempt(point.run_attempt) : null),
+    (point) =>
+      point.recipe_fingerprint ? `${words.recipe} ${point.recipe_fingerprint.slice(0, 8)}` : null,
+    (point) => point.image ?? null,
+    (point) => `${words.point} ${point.id ?? '?'}`,
+  ];
+  const labels = points.map((point) => {
+    const hardware = getHardwareConfig(point.hwKey);
+    return [
+      hardware.name === 'unknown' ? point.hwKey : getDisplayLabel(hardware),
+      point.actualDate ?? point.date,
+    ].join(' · ');
+  });
+  for (const detail of details) {
+    const groups = new Map<string, number[]>();
+    labels.forEach((label, index) => groups.set(label, [...(groups.get(label) ?? []), index]));
+    for (const indices of groups.values()) {
+      if (indices.length < 2) continue;
+      const group = indices.map((index) => points[index]);
+      const values = group.map((point) => detail(point, group));
+      if (new Set(values).size < 2) continue;
+      indices.forEach((index, position) => {
+        if (values[position]) labels[index] += ` · ${values[position]}`;
+      });
+    }
+  }
+  return labels;
+}
+
+/** Labels are English by default: the read-only API has no locale. */
+export function getEqualServiceSources(
+  points: readonly InferenceData[],
+  locale: 'en' | 'zh' = 'en',
+): EqualServiceSource[] {
+  const sources = [
+    ...new Map(observedPoints(points).map((point) => [equalServiceSourceKey(point), point])),
+  ].sort(([a], [b]) => a.localeCompare(b));
+  const labels = sourceLabels(
+    sources.map(([, point]) => point),
+    locale,
+  );
+  return sources.map(([key], index) => ({ key, label: labels[index] }));
+}
+
+function deploymentOutput(point: InferenceData): number | undefined {
+  if (!isPositive(point.output_tput_per_gpu)) return undefined;
+  if (point.disagg) {
+    return (
+      powerBasisNormalization({
+        output_tput_per_gpu: point.output_tput_per_gpu,
+        disagg: true,
+        benchmark_type: point.benchmark_type,
+        num_prefill_gpu: point.num_prefill_gpu ?? 0,
+        num_decode_gpu: point.num_decode_gpu ?? 0,
+      }).totalOutputTokPerSec ?? undefined
+    );
+  }
+  const count = chipCounts(point, false).physical;
+  return isPositive(count) && Number.isSafeInteger(count)
+    ? point.output_tput_per_gpu * count
+    : undefined;
+}
+/** The measured quantities every service panel compares, read from one point. */
+export const serviceMetricValue = {
+  meanWattsPerGpu: (point: InferenceData) => point.measuredAvgPower?.y,
+  outputTokensPerSecond: deploymentOutput,
+  joulesPerOutputToken: (point: InferenceData) => point.measuredJPerOutputToken?.y,
+};
+
+function estimate(
+  points: readonly InferenceData[],
+  field: keyof AggDataEntry,
+  target: number,
+  quantity: (point: InferenceData) => number | undefined,
+): { estimate: EqualServiceEstimate | null; reason?: EqualServiceReason } {
+  const rows = points
+    .flatMap((point) => {
+      const x = point[field];
+      return isPositive(x) ? [{ point, x, value: quantity(point) }] : [];
+    })
+    .sort((a, b) => a.x - b.x || (a.point.id ?? 0) - (b.point.id ?? 0));
+  const xs = [...new Set(rows.map((row) => row.x))];
+  if (xs.length === 0 || target < xs[0] || target > xs.at(-1)!)
+    return { estimate: null, reason: 'out-of-range' };
+  const upper = xs.findIndex((x) => x >= target);
+  const brackets = xs[upper] === target ? [target] : [xs[upper - 1], xs[upper]];
+  const endpoints: EqualServiceEstimate['endpoints'] = [];
+  for (const x of brackets) {
+    const matches = rows.filter((row) => row.x === x);
+    if (matches.some((row) => !Object.is(row.value, matches[0].value)))
+      return { estimate: null, reason: 'ambiguous-x' };
+    for (const row of matches) {
+      if (!isPositive(row.value)) return { estimate: null, reason: 'missing-metric' };
+      endpoints.push({ ...row, value: row.value });
+    }
+  }
+  const left = endpoints[0],
+    right = endpoints.at(-1)!;
+  const value =
+    brackets.length === 1
+      ? left.value
+      : left.value + (right.value - left.value) * ((target - left.x) / (right.x - left.x));
+  return isPositive(value)
+    ? { estimate: { value, interpolated: brackets.length === 2, endpoints } }
+    : { estimate: null, reason: 'missing-metric' };
+}
+
+/** Numerical linear interpolation of raw quantities, then ratios; never extrapolation. */
+export function buildEqualServiceComparison(
+  points: readonly InferenceData[],
+  options: EqualServiceOptions,
+): EqualServiceComparison {
+  const { baseline, comparator, target, xField } = options;
+  const sources = getEqualServiceSources(points);
+  const sourceA = sources.find((source) => source.key === baseline) ?? null;
+  const sourceB = sources.find((source) => source.key === comparator) ?? null;
+  let reason: EqualServiceReason | undefined;
+  if (!serviceAxis(xField)) reason = 'unsupported-axis';
+  else if (!isPositive(target)) reason = 'invalid-target';
+  else if (baseline === comparator) reason = 'same-source';
+  else if (!sourceA || !sourceB) reason = 'unknown-source';
+  const rows = observedPoints(points);
+  const a = rows.filter((point) => equalServiceSourceKey(point) === baseline);
+  const b = rows.filter((point) => equalServiceSourceKey(point) === comparator);
+  const compare = (quantity: (point: InferenceData) => number | undefined): EqualServiceMetric => {
+    if (reason) return { baseline: null, comparator: null, changePercent: null, reason };
+    const left = estimate(a, xField, target, quantity);
+    const right = estimate(b, xField, target, quantity);
+    const change =
+      left.estimate && right.estimate
+        ? 100 * (right.estimate.value / left.estimate.value - 1)
+        : null;
+    return {
+      baseline: left.estimate,
+      comparator: right.estimate,
+      changePercent: change !== null && Number.isFinite(change) ? change : null,
+      ...(left.reason || right.reason ? { reason: left.reason ?? right.reason } : {}),
+    };
+  };
+  return {
+    target,
+    xField,
+    baseline: sourceA,
+    comparator: sourceB,
+    ...(reason ? { reason } : {}),
+    metrics: {
+      meanWattsPerGpu: compare(serviceMetricValue.meanWattsPerGpu),
+      outputTokensPerSecond: compare(serviceMetricValue.outputTokensPerSecond),
+      joulesPerOutputToken: compare(serviceMetricValue.joulesPerOutputToken),
+    },
+  };
+}
+
+/** Knots are observed X values within both source ranges, not a fitted hardware model. */
+export function getEqualServiceComparisonCurve(
+  points: readonly InferenceData[],
+  options: Omit<EqualServiceOptions, 'target'>,
+): EqualServiceComparison[] {
+  if (!serviceAxis(options.xField) || options.baseline === options.comparator) return [];
+  const xs = (key: string) =>
+    observedPoints(points)
+      .filter((point) => equalServiceSourceKey(point) === key)
+      .map((point) => point[options.xField])
+      .filter(isPositive);
+  const a = xs(options.baseline),
+    b = xs(options.comparator);
+  if (a.length === 0 || b.length === 0) return [];
+  const lower = Math.max(Math.min(...a), Math.min(...b));
+  const upper = Math.min(Math.max(...a), Math.max(...b));
+  return [...new Set([...a, ...b])]
+    .filter((x) => x >= lower && x <= upper)
+    .sort((x, y) => x - y)
+    .map((target) => buildEqualServiceComparison(points, { ...options, target }));
+}
+
+export function getPrefillSharePoints(
+  points: readonly InferenceData[],
+  xField: keyof AggDataEntry,
+) {
+  if (!serviceAxis(xField) && xField !== 'conc') return [];
+  return observedPoints(points)
+    .flatMap((point) => {
+      const x = point[xField];
+      const energy = reconstructedRoleEnergy(point);
+      return isPositive(x) && energy
+        ? [{ x, sourceKey: equalServiceSourceKey(point), point, ...energy }]
+        : [];
+    })
+    .sort((a, b) => a.sourceKey.localeCompare(b.sourceKey) || a.x - b.x);
+}
+
+export interface RolePoint {
+  x: number;
+  sourceKey: string;
+  point: InferenceData;
+  /** Mean board W/GPU inside each pool (role-local). */
+  prefillWattsPerGpu: number | null;
+  decodeWattsPerGpu: number | null;
+  /** Role-local energy: each pool's joules over its own token count. */
+  prefillJoulesPerInputToken: number | null;
+  decodeJoulesPerOutputToken: number | null;
+  /** Both pools on the output-token denominator, when reconstructable. */
+  energy: ReconstructedRoleEnergy | null;
+}
+
+/**
+ * Validated disaggregated rows with any role measurement (PowerX Figures
+ * 12–14). Pool-local denominators stay separate from the additive
+ * output-token reconstruction; a missing figure is null, never zero.
+ */
+export function getRolePoints(
+  points: readonly InferenceData[],
+  xField: keyof AggDataEntry,
+): RolePoint[] {
+  if (!serviceAxis(xField) && xField !== 'conc') return [];
+  return observedPoints(points)
+    .flatMap((point): RolePoint[] => {
+      const x = point[xField];
+      if (!point.disagg || !isPositive(x)) return [];
+      const role: RolePoint = {
+        x,
+        sourceKey: equalServiceSourceKey(point),
+        point,
+        prefillWattsPerGpu: positiveOrNull(point.measuredPrefillAvgPower?.y),
+        decodeWattsPerGpu: positiveOrNull(point.measuredDecodeAvgPower?.y),
+        prefillJoulesPerInputToken: positiveOrNull(point.measuredPrefillJPerInputToken?.y),
+        decodeJoulesPerOutputToken: positiveOrNull(point.measuredDecodeJPerOutputToken?.y),
+        energy: reconstructedRoleEnergy(point) ?? null,
+      };
+      const measured =
+        role.prefillWattsPerGpu !== null ||
+        role.decodeWattsPerGpu !== null ||
+        role.prefillJoulesPerInputToken !== null ||
+        role.decodeJoulesPerOutputToken !== null ||
+        role.energy !== null;
+      return measured ? [role] : [];
+    })
+    .sort((a, b) => a.sourceKey.localeCompare(b.sourceKey) || a.x - b.x);
+}
diff --git a/packages/app/src/components/inference/utils/frontier-points.ts b/packages/app/src/components/inference/utils/frontier-points.ts
new file mode 100644
index 000000000..8af690d21
--- /dev/null
+++ b/packages/app/src/components/inference/utils/frontier-points.ts
@@ -0,0 +1,44 @@
+import type { InferenceData } from '../types';
+import { runAttemptFromUrl, runIdFromUrl } from './powerTimeline';
+import { pointTopologyKey } from './topology-filter';
+
+/**
+ * CSV export of a cross-platform frontier (PowerX Figure 16): the chart's own
+ * global non-dominated set, one row per observation with its provenance.
+ * Stable export columns: identity first, then plotted coordinates and provenance.
+ */
+export const FRONTIER_EXPORT_HEADERS = [
+  'hardware',
+  'framework',
+  'precision',
+  'topology',
+  'concurrency',
+  'x',
+  'y',
+  'date',
+  'run_url',
+  'run_id',
+  'run_attempt',
+  'recipe_fingerprint',
+  'image',
+  'point_id',
+] as const;
+
+export function frontierExportRow(point: InferenceData): (string | number | null)[] {
+  return [
+    point.hwKey,
+    point.framework ?? null,
+    point.precision,
+    pointTopologyKey(point),
+    point.conc,
+    point.x,
+    point.y,
+    point.actualDate ?? point.date,
+    point.run_url ?? null,
+    runIdFromUrl(point.run_url),
+    runAttemptFromUrl(point.run_url),
+    point.recipe_fingerprint ?? null,
+    point.image ?? null,
+    point.id ?? null,
+  ];
+}
diff --git a/packages/app/src/components/inference/utils/legacy-power-marker.ts b/packages/app/src/components/inference/utils/legacy-power-marker.ts
deleted file mode 100644
index 43be6f4c8..000000000
--- a/packages/app/src/components/inference/utils/legacy-power-marker.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import type * as d3 from 'd3';
-
-import type { InferenceData } from '@/components/inference/types';
-import { setAttrIfChanged } from '@/lib/d3-chart/chart-update';
-import {
-  LEGACY_POWER_RING_DASHARRAY,
-  LEGACY_POWER_RING_RADIUS,
-  LEGACY_POWER_RING_STROKE_WIDTH,
-} from '@/components/inference/ui/LegacyPowerLegendKey';
-
-/**
- * Dotted ring flagging measured-power telemetry without a producer validation
- * verdict (`power_tier === 'legacy'`). Drawn only while a Measured Energy
- * y-axis is selected; the join-on-empty-data pattern removes the ring when the
- * axis changes or the point's tier is not legacy.
- */
-export function renderLegacyPowerRing(
-  group: d3.Selection<SVGGElement, InferenceData, null, undefined>,
-  point: InferenceData,
-  isMeasuredAxis: boolean,
-  stroke: string,
-): void {
-  group
-    .selectAll<SVGCircleElement, boolean>('.legacy-power-ring')
-    .data(isMeasuredAxis && point.power_tier === 'legacy' ? [true] : [])
-    .join('circle')
-    // Every chart render re-syncs every point; skip unchanged writes.
-    .each(function () {
-      setAttrIfChanged(this, 'class', 'legacy-power-ring');
-      setAttrIfChanged(this, 'r', String(LEGACY_POWER_RING_RADIUS));
-      setAttrIfChanged(this, 'fill', 'none');
-      setAttrIfChanged(this, 'stroke', stroke);
-      setAttrIfChanged(this, 'stroke-width', String(LEGACY_POWER_RING_STROKE_WIDTH));
-      setAttrIfChanged(this, 'stroke-dasharray', LEGACY_POWER_RING_DASHARRAY);
-      setAttrIfChanged(this, 'opacity', '0.9');
-      setAttrIfChanged(this, 'pointer-events', 'none');
-    });
-}
diff --git a/packages/app/src/components/inference/utils/matched-concurrency.test.ts b/packages/app/src/components/inference/utils/matched-concurrency.test.ts
new file mode 100644
index 000000000..e6fb61279
--- /dev/null
+++ b/packages/app/src/components/inference/utils/matched-concurrency.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import type { InferenceData } from '../types';
+import { equalServiceSourceKey } from './equal-service-comparison';
+import { buildMatchedConcurrencyTable } from './matched-concurrency';
+
+const metric = (y: number) => ({ y, roof: false });
+function point(overrides: Partial<InferenceData> = {}): InferenceData {
+  return {
+    x: 100,
+    y: 1,
+    hwKey: 'b200_sglang',
+    date: '2026-09-18',
+    tp: 4,
+    physicalChips: 4,
+    precision: 'fp8',
+    conc: 1,
+    run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/35317697106/attempts/1',
+    model: 'Qwen-3.5-397B-A17B',
+    benchmark_type: 'single_turn',
+    isl: 8192,
+    osl: 1024,
+    decode_tp: 4,
+    output_tput_per_gpu: 50,
+    tpPerGpu: metric(50),
+    tpPerMw: metric(50),
+    costh: metric(1),
+    costr: metric(1),
+    costhi: metric(1),
+    costri: metric(1),
+    ...overrides,
+  };
+}
+// PowerX Figure 6 values (B200 / MI355X, TP4, three-dispatch means).
+const b200 = (conc: number, joules: number, watts: number, speed: number, id: number) =>
+  point({
+    id,
+    conc,
+    mean_tpot_intvty: speed,
+    measuredJPerOutputToken: metric(joules),
+    measuredAvgPower: metric(watts),
+  });
+const mi355x = (conc: number, joules: number, watts: number, speed: number, id: number) =>
+  point({
+    id,
+    conc,
+    hwKey: 'mi355x_sglang',
+    run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/33348766792/attempts/2',
+    mean_tpot_intvty: speed,
+    measuredJPerOutputToken: metric(joules),
+    measuredAvgPower: metric(watts),
+  });
+const baseline = [b200(1, 9.065, 402, 186.9, 1), b200(4, 3.87, 507, 141.2, 2)];
+const comparator = [mi355x(1, 13.271, 412, 128.1, 11), mi355x(128, 1.311, 869, 22.1, 12)];
+const options = {
+  baseline: equalServiceSourceKey(baseline[0]),
+  comparator: equalServiceSourceKey(comparator[0]),
+  interactivityField: 'mean_tpot_intvty' as const,
+};
+
+describe('matched-concurrency table', () => {
+  it('pairs observed rows by concurrency with one signed change convention', () => {
+    const table = buildMatchedConcurrencyTable([...baseline, ...comparator], options);
+    expect(table.reason).toBeUndefined();
+    expect(table.rows.map((row) => row.concurrency)).toEqual([1, 4, 128]);
+    const [first] = table.rows;
+    expect(first.baseline).toMatchObject({
+      status: 'observed',
+      values: { joulesPerOutputToken: 9.065, meanWattsPerGpu: 402, interactivity: 186.9 },
+    });
+    expect(first.changePercent.joulesPerOutputToken).toBeCloseTo(46.4, 1);
+    expect(first.changePercent.meanWattsPerGpu).toBeCloseTo(2.49, 2);
+    expect(first.changePercent.interactivity).toBeCloseTo(-31.46, 2);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/matched-concurrency.ts b/packages/app/src/components/inference/utils/matched-concurrency.ts
new file mode 100644
index 000000000..41d97e868
--- /dev/null
+++ b/packages/app/src/components/inference/utils/matched-concurrency.ts
@@ -0,0 +1,128 @@
+import type { AggDataEntry, InferenceData } from '../types';
+import {
+  equalServiceSourceKey,
+  getEqualServiceSources,
+  observedPoints,
+  positiveOrNull,
+  serviceMetricValue,
+  type EqualServiceSource,
+} from './equal-service-comparison';
+
+/**
+ * Pairs two sources' observations at the same concurrency (PowerX Figures 6,
+ * 7 and 9). Matched load is a diagnostic next to the equal-service comparison,
+ * not a replacement: the two sources usually serve different speeds at one
+ * concurrency. Nothing is interpolated, averaged or carried between rows.
+ */
+export const MATCHED_CONCURRENCY_METRICS = [
+  'joulesPerOutputToken',
+  'meanWattsPerGpu',
+  'interactivity',
+] as const;
+export type MatchedConcurrencyMetric = (typeof MATCHED_CONCURRENCY_METRICS)[number];
+export type MatchedConcurrencyValues = Record<MatchedConcurrencyMetric, number | null>;
+
+export type MatchedConcurrencySide =
+  | { status: 'observed'; point: InferenceData; values: MatchedConcurrencyValues }
+  | { status: 'missing' }
+  /** Several observations of one source at one load disagree; none is chosen. */
+  | { status: 'ambiguous'; points: InferenceData[] };
+
+export interface MatchedConcurrencyRow {
+  concurrency: number;
+  baseline: MatchedConcurrencySide;
+  comparator: MatchedConcurrencySide;
+  /** `100 × (comparator ÷ baseline − 1)`; null unless both values were observed. */
+  changePercent: MatchedConcurrencyValues;
+}
+
+export type MatchedConcurrencyReason = 'same-source' | 'unknown-source';
+
+export interface MatchedConcurrencyTable {
+  baseline: EqualServiceSource | null;
+  comparator: EqualServiceSource | null;
+  /** Streaming-speed field read for the `interactivity` column (selected statistic). */
+  interactivityField: keyof AggDataEntry;
+  reason?: MatchedConcurrencyReason;
+  rows: MatchedConcurrencyRow[];
+}
+
+const NO_CHANGE: MatchedConcurrencyValues = {
+  joulesPerOutputToken: null,
+  meanWattsPerGpu: null,
+  interactivity: null,
+};
+
+function values(point: InferenceData, field: keyof AggDataEntry): MatchedConcurrencyValues {
+  return {
+    joulesPerOutputToken: positiveOrNull(serviceMetricValue.joulesPerOutputToken(point)),
+    meanWattsPerGpu: positiveOrNull(serviceMetricValue.meanWattsPerGpu(point)),
+    interactivity: positiveOrNull(point[field]),
+  };
+}
+
+function side(points: readonly InferenceData[], field: keyof AggDataEntry): MatchedConcurrencySide {
+  if (points.length === 0) return { status: 'missing' };
+  const first = values(points[0], field);
+  const agree = points.every((point) => {
+    const other = values(point, field);
+    return MATCHED_CONCURRENCY_METRICS.every((key) => Object.is(other[key], first[key]));
+  });
+  return agree
+    ? { status: 'observed', point: points[0], values: first }
+    : { status: 'ambiguous', points: [...points] };
+}
+
+export function buildMatchedConcurrencyTable(
+  points: readonly InferenceData[],
+  options: { baseline: string; comparator: string; interactivityField: keyof AggDataEntry },
+): MatchedConcurrencyTable {
+  const { baseline, comparator, interactivityField } = options;
+  const sources = getEqualServiceSources(points);
+  const sourceA = sources.find((source) => source.key === baseline) ?? null;
+  const sourceB = sources.find((source) => source.key === comparator) ?? null;
+  const table = { baseline: sourceA, comparator: sourceB, interactivityField };
+  if (baseline === comparator) return { ...table, reason: 'same-source', rows: [] };
+  if (!sourceA || !sourceB) return { ...table, reason: 'unknown-source', rows: [] };
+
+  const byConcurrency = (key: string) => {
+    const groups = new Map<number, InferenceData[]>();
+    for (const point of observedPoints(points)) {
+      if (equalServiceSourceKey(point) !== key || !Number.isSafeInteger(point.conc)) continue;
+      if (point.conc <= 0) continue;
+      const group = groups.get(point.conc);
+      if (group) group.push(point);
+      else groups.set(point.conc, [point]);
+    }
+    return groups;
+  };
+  const a = byConcurrency(baseline);
+  const b = byConcurrency(comparator);
+  const rows = [...new Set([...a.keys(), ...b.keys()])]
+    .toSorted((x, y) => x - y)
+    .map((concurrency): MatchedConcurrencyRow => {
+      const left = side(a.get(concurrency) ?? [], interactivityField);
+      const right = side(b.get(concurrency) ?? [], interactivityField);
+      if (left.status !== 'observed' || right.status !== 'observed') {
+        return { concurrency, baseline: left, comparator: right, changePercent: NO_CHANGE };
+      }
+      const change = (key: MatchedConcurrencyMetric) => {
+        const before = left.values[key];
+        const after = right.values[key];
+        if (before === null || after === null) return null;
+        const percent = 100 * (after / before - 1);
+        return Number.isFinite(percent) ? percent : null;
+      };
+      return {
+        concurrency,
+        baseline: left,
+        comparator: right,
+        changePercent: {
+          joulesPerOutputToken: change('joulesPerOutputToken'),
+          meanWattsPerGpu: change('meanWattsPerGpu'),
+          interactivity: change('interactivity'),
+        },
+      };
+    });
+  return { ...table, rows };
+}
diff --git a/packages/app/src/components/inference/utils/power-fit.test.ts b/packages/app/src/components/inference/utils/power-fit.test.ts
new file mode 100644
index 000000000..b4968f5c1
--- /dev/null
+++ b/packages/app/src/components/inference/utils/power-fit.test.ts
@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import type { InferenceData } from '../types';
+import { buildPowerFits, ordinaryLeastSquares } from './power-fit';
+
+const metric = (y: number) => ({ y, roof: false });
+function point(overrides: Partial<InferenceData> = {}): InferenceData {
+  return {
+    x: 100,
+    y: 1,
+    hwKey: 'h200_sglang',
+    date: '2026-09-18',
+    tp: 8,
+    physicalChips: 8,
+    precision: 'fp8',
+    conc: 1,
+    run_url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/28719990565/attempts/1',
+    model: 'Qwen-3.5-397B-A17B',
+    benchmark_type: 'single_turn',
+    isl: 8192,
+    osl: 1024,
+    decode_tp: 8,
+    output_tput_per_gpu: 50,
+    tpPerGpu: metric(50),
+    tpPerMw: metric(50),
+    costh: metric(1),
+    costr: metric(1),
+    costhi: metric(1),
+    costri: metric(1),
+    ...overrides,
+  };
+}
+const ladder = (throughputs: number[], watts: (x: number) => number, base = {}) =>
+  throughputs.map((x, index) =>
+    point({
+      id: index + 1,
+      conc: 2 ** index,
+      output_tput_per_gpu: x,
+      measuredAvgPower: metric(watts(x)),
+      ...base,
+    }),
+  );
+
+describe('ordinaryLeastSquares', () => {
+  it('reports R² below one for scattered observations', () => {
+    const fit = ordinaryLeastSquares([
+      { x: 1, y: 2 },
+      { x: 2, y: 3 },
+      { x: 3, y: 7 },
+    ]);
+    // Least squares: slope 2.5, intercept -1, residuals (0.5, -1, 0.5) → SSres 1.5, SStot 14.
+    expect(fit!.slope).toBeCloseTo(2.5, 12);
+    expect(fit!.intercept).toBeCloseTo(-1, 12);
+    expect(fit!.rSquared).toBeCloseTo(1 - 1.5 / 14, 12);
+  });
+});
+
+describe('buildPowerFits', () => {
+  it('fits disaggregated sources on output per allocated GPU', () => {
+    const gb200 = ladder([100, 300, 500], () => 0, {
+      hwKey: 'gb200_dynamo-sglang',
+      disagg: true,
+      num_prefill_gpu: 4,
+      num_decode_gpu: 4,
+    }).map((entry) => ({
+      ...entry,
+      measuredAvgPower: metric(307 + 0.7 * (entry.output_tput_per_gpu! / 2)),
+    }));
+    const [fit] = buildPowerFits(gb200);
+    expect(fit.observations.map((observation) => observation.x)).toEqual([50, 150, 250]);
+    expect(fit.fit!.intercept).toBeCloseTo(307, 9);
+    expect(fit.fit!.slope).toBeCloseTo(0.7, 9);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/power-fit.ts b/packages/app/src/components/inference/utils/power-fit.ts
new file mode 100644
index 000000000..80877c0ba
--- /dev/null
+++ b/packages/app/src/components/inference/utils/power-fit.ts
@@ -0,0 +1,125 @@
+import type { InferenceData } from '../types';
+import { getGpuSpecs } from '@/lib/constants';
+import { isPositive, powerBasisNormalization } from '@/lib/power-basis';
+import {
+  equalServiceSourceKey,
+  getEqualServiceSources,
+  observedPoints,
+  type EqualServiceSource,
+} from './equal-service-comparison';
+
+/**
+ * Serving-regime power model per source (PowerX Figure 15): an ordinary
+ * least-squares line `W/GPU = P0 + m × output tok/s per GPU` through one
+ * source's measured load points. `P0` is the fit's zero-throughput intercept,
+ * not measured idle power; `m` is marginal GPU energy per output token in
+ * joules. The fit describes only the observed throughput range.
+ */
+
+/** Distinct throughputs a line needs before its intercept and R² mean anything. */
+export const MIN_FIT_POINTS = 3;
+
+export interface LinearFit {
+  /** `P0`, W/GPU at zero output rate (extrapolated). */
+  intercept: number;
+  /** `m`, J per output token (W per output tok/s/GPU). */
+  slope: number;
+  /** Null when every observation draws the same power (no variance to explain). */
+  rSquared: number | null;
+  n: number;
+  xMin: number;
+  xMax: number;
+}
+
+export function ordinaryLeastSquares(pairs: readonly { x: number; y: number }[]): LinearFit | null {
+  const n = pairs.length;
+  if (n === 0) return null;
+  const xMean = pairs.reduce((sum, pair) => sum + pair.x, 0) / n;
+  const yMean = pairs.reduce((sum, pair) => sum + pair.y, 0) / n;
+  let sxx = 0;
+  let sxy = 0;
+  let syy = 0;
+  for (const { x, y } of pairs) {
+    sxx += (x - xMean) ** 2;
+    sxy += (x - xMean) * (y - yMean);
+    syy += (y - yMean) ** 2;
+  }
+  if (!(sxx > 0)) return null;
+  const slope = sxy / sxx;
+  const intercept = yMean - slope * xMean;
+  const residual = pairs.reduce((sum, { x, y }) => sum + (y - (intercept + slope * x)) ** 2, 0);
+  return {
+    intercept,
+    slope,
+    rSquared: syy > 0 ? 1 - residual / syy : null,
+    n,
+    xMin: Math.min(...pairs.map((pair) => pair.x)),
+    xMax: Math.max(...pairs.map((pair) => pair.x)),
+  };
+}
+
+/**
+ * Whole-deployment output tokens/s divided by every allocated GPU, so a
+ * disaggregated deployment's prefill GPUs share the output they enable and its
+ * mean W/GPU (averaged over all GPUs) sits on the same basis.
+ */
+export function outputRatePerAllocatedGpu(point: InferenceData): number | undefined {
+  if (!isPositive(point.output_tput_per_gpu)) return undefined;
+  const { allocatedGpus, totalOutputTokPerSec } = powerBasisNormalization({
+    output_tput_per_gpu: point.output_tput_per_gpu,
+    disagg: Boolean(point.disagg),
+    benchmark_type: point.benchmark_type,
+    num_prefill_gpu: point.num_prefill_gpu ?? 0,
+    num_decode_gpu: point.num_decode_gpu ?? 0,
+  });
+  return isPositive(allocatedGpus) && isPositive(totalOutputTokPerSec)
+    ? totalOutputTokPerSec / allocatedGpus
+    : undefined;
+}
+
+export interface PowerFitObservation {
+  /** Output tok/s per allocated GPU. */
+  x: number;
+  /** Measured mean GPU-board W/GPU. */
+  y: number;
+  point: InferenceData;
+}
+
+export interface PowerFit {
+  source: EqualServiceSource;
+  /** Rated board TDP per GPU from the hardware registry, to read `P0 ÷ TDP`; null when unknown. */
+  tdpWatts: number | null;
+  observations: PowerFitObservation[];
+  fit: LinearFit | null;
+  reason?: 'too-few-points';
+}
+
+/** One fit per equal-service source that has any measured observation. */
+export function buildPowerFits(
+  points: readonly InferenceData[],
+  locale: 'en' | 'zh' = 'en',
+): PowerFit[] {
+  const rows = observedPoints(points);
+  return getEqualServiceSources(points, locale).flatMap((source): PowerFit[] => {
+    const observations = rows
+      .filter((point) => equalServiceSourceKey(point) === source.key)
+      .flatMap((point) => {
+        const x = outputRatePerAllocatedGpu(point);
+        const y = point.measuredAvgPower?.y;
+        return isPositive(x) && isPositive(y) ? [{ x, y, point }] : [];
+      })
+      .toSorted((a, b) => a.x - b.x || (a.point.id ?? 0) - (b.point.id ?? 0));
+    if (observations.length === 0) return [];
+    const tdp = getGpuSpecs(observations[0].point.hwKey).tdp;
+    const tdpWatts = isPositive(tdp) ? tdp : null;
+    const fit =
+      new Set(observations.map((observation) => observation.x)).size >= MIN_FIT_POINTS
+        ? ordinaryLeastSquares(observations)
+        : null;
+    return [
+      fit
+        ? { source, tdpWatts, observations, fit }
+        : { source, tdpWatts, observations, fit: null, reason: 'too-few-points' },
+    ];
+  });
+}
diff --git a/packages/app/src/components/inference/utils/power-metric-availability.test.ts b/packages/app/src/components/inference/utils/power-metric-availability.test.ts
deleted file mode 100644
index d63c225ce..000000000
--- a/packages/app/src/components/inference/utils/power-metric-availability.test.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { InferenceData } from '../types';
-import { powerMetricAvailability, powerMetricState } from './power-metric-availability';
-import { createMockInferenceData } from '../../../../cypress/support/mock-data';
-
-function point(overrides: Partial<InferenceData> = {}) {
-  return createMockInferenceData(overrides);
-}
-describe('PowerX availability', () => {
-  it('separates strict, validated unversioned, no verdict, invalid and missing without hiding zero', () => {
-    const values = { measuredAvgPower: { y: 0, roof: false } };
-    const rows = [
-      point({ ...values, power_valid: 1, power_metric_schema_version: 2 }),
-      point({ ...values, power_valid: 1 }),
-      point(values),
-      point({ power_valid: 0, ...values }),
-      point(),
-    ];
-    expect(
-      powerMetricAvailability(rows).find((row) => row.metric === 'y_measuredAvgPower'),
-    ).toMatchObject({
-      available: 3,
-      total: 5,
-      counts: { strict: 1, validated: 1, unverified: 1, invalid: 1, missing: 1 },
-    });
-  });
-  it('retains real role metrics while distinguishing shared pools and ambiguous old deployment energy', () => {
-    expect(powerMetricState(point(), 'y_measuredPrefillAvgPower')).toBe('inapplicable');
-    expect(
-      powerMetricState(
-        point({
-          disagg: true,
-          power_valid: 1,
-          power_metric_schema_version: 2,
-          measuredPrefillJPerInputToken: { y: 2, roof: false },
-        }),
-        'y_measuredPrefillJPerInputToken',
-      ),
-    ).toBe('strict');
-    expect(
-      powerMetricState(point({ disagg: true, power_valid: 1 }), 'y_measuredJPerInputToken'),
-    ).toBe('ambiguous');
-  });
-  it('counts the actual conversion and percentile fields independently', () => {
-    const rows = [
-      point({
-        power_valid: 1,
-        power_metric_schema_version: 2,
-        measuredWhPerSuccessfulQuery: { y: 1, roof: false },
-        measuredPowerPercentTdp: { y: 40, roof: false },
-      }),
-    ];
-    const byMetric = Object.fromEntries(
-      powerMetricAvailability(rows).map((row) => [row.metric, row.available]),
-    );
-    expect(byMetric.y_measuredWhPerSuccessfulQuery).toBe(1);
-    expect(byMetric.y_measuredPowerPercentTdp).toBe(1);
-    expect(byMetric.y_measuredP75Power).toBe(0);
-    expect(byMetric.y_measuredP90Power).toBe(0);
-  });
-});
diff --git a/packages/app/src/components/inference/utils/power-metric-availability.ts b/packages/app/src/components/inference/utils/power-metric-availability.ts
deleted file mode 100644
index 6a2e7882f..000000000
--- a/packages/app/src/components/inference/utils/power-metric-availability.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { MEASURED_ENERGY_METRIC_CONFIG_KEYS, isMetricKey } from '../metric-registry';
-import type { InferenceData } from '../types';
-
-export const POWER_AVAILABILITY_STATES = [
-  'strict',
-  'validated',
-  'unverified',
-  'invalid',
-  'inapplicable',
-  'ambiguous',
-  'missing',
-] as const;
-export type PowerAvailabilityState = (typeof POWER_AVAILABILITY_STATES)[number];
-export type PowerAvailabilityCounts = Record<PowerAvailabilityState, number>;
-const ROLE_METRICS = new Set([
-  'y_measuredPrefillAvgPower',
-  'y_measuredDecodeAvgPower',
-  'y_measuredPrefillJPerInputToken',
-  'y_measuredDecodeJPerOutputToken',
-]);
-const WHOLE_ENERGY_METRICS = new Set([
-  'y_measuredJPerInputToken',
-  'y_measuredJPerOutputToken',
-  'y_measuredJPerTotalToken',
-  'y_measuredJPerSuccessfulQuery',
-  'y_measuredWhPerSuccessfulQuery',
-]);
-
-/** Uses the chart's actual admitted field, so conversions and semantic gates agree. */
-export function powerMetricState(point: InferenceData, configKey: string): PowerAvailabilityState {
-  if (ROLE_METRICS.has(configKey) && !point.disagg) return 'inapplicable';
-  if (point.power_valid === 0) return 'invalid';
-  const key = configKey.replace(/^y_/u, '');
-  const value = isMetricKey(key) ? point[key] : undefined;
-  if (
-    value &&
-    typeof value === 'object' &&
-    'y' in value &&
-    typeof value.y === 'number' &&
-    Number.isFinite(value.y)
-  ) {
-    if (point.power_valid === 1)
-      return point.power_metric_schema_version === 2 ? 'strict' : 'validated';
-    return 'unverified';
-  }
-  if (
-    WHOLE_ENERGY_METRICS.has(configKey) &&
-    point.disagg &&
-    point.power_metric_schema_version !== 2
-  )
-    return 'ambiguous';
-  return 'missing';
-}
-
-export function powerMetricAvailability(points: readonly InferenceData[]) {
-  return [...MEASURED_ENERGY_METRIC_CONFIG_KEYS].map((metric) => {
-    const counts = Object.fromEntries(
-      POWER_AVAILABILITY_STATES.map((state) => [state, 0]),
-    ) as PowerAvailabilityCounts;
-    for (const point of points) counts[powerMetricState(point, metric)]++;
-    return {
-      metric,
-      counts,
-      available: counts.strict + counts.validated + counts.unverified,
-      total: points.length,
-    };
-  });
-}
diff --git a/packages/app/src/components/inference/utils/powerCurves.ts b/packages/app/src/components/inference/utils/powerCurves.ts
index 13ac7209e..7c251acbc 100644
--- a/packages/app/src/components/inference/utils/powerCurves.ts
+++ b/packages/app/src/components/inference/utils/powerCurves.ts
@@ -34,10 +34,7 @@ export function isPowerCurveMetric(metric: string): boolean {
  * Pareto behaviour.
  */
 export function isMeasuredPowerCurveMetric(metric: string): boolean {
-  return (
-    isPowerCurveMetric(metric) &&
-    (metric !== 'y_modeledChassisPowerPerGpu' || isPowerBasisConfigKey(metric))
-  );
+  return isPowerCurveMetric(metric) && metric !== 'y_modeledChassisPowerPerGpu';
 }
 
 /**
diff --git a/packages/app/src/components/inference/utils/powerTimeline.test.ts b/packages/app/src/components/inference/utils/powerTimeline.test.ts
index 409a74ad1..083ed100d 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.test.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.test.ts
@@ -1,6 +1,73 @@
 import { describe, expect, it } from 'vitest';
 
-import { prioritizeRuns } from './powerTimeline';
+import type { InferenceData } from '@/components/inference/types';
+
+import {
+  prioritizeRuns,
+  summarizeTraceWindow,
+  tracePools,
+  type PowerTimelineTrace,
+} from './powerTimeline';
+
+const RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34716669498';
+const NAME_B =
+  'qwen3.5_8k1k_fp8_dynamo-sglang_prefill-tp4-pp1-dcp1-pcp1-ep1-dpfalse-nw1_decode-tp4-5b35252b29d80b104d11_sa-bench_isl_8192_osl_1024_conc1_gpus_8_ctx_4_gen_4';
+
+function point(overrides: Partial<InferenceData>): InferenceData {
+  return {
+    x: 1,
+    y: 1,
+    hwKey: 'b200_sglang',
+    tp: 4,
+    conc: 16,
+    precision: 'fp8',
+    date: '2026-09-12',
+    run_url: RUN_URL,
+    ...overrides,
+  } as InferenceData;
+}
+
+describe('summarizeTraceWindow', () => {
+  // Two prefill and two decode GPUs; the window holds buckets 1–3 (t = 11..13 s).
+  const pooled: PowerTimelineTrace = {
+    key: `34716669498:${NAME_B}`,
+    point: point({ disagg: true, conc: 4 }),
+    runId: '34716669498',
+    series: {
+      artifact: `power_audit_${NAME_B}`,
+      startMs: 1_000_000,
+      bucketSeconds: 1,
+      gpus: [0, 1, 2, 3],
+      t: [10, 11, 12, 13, 14],
+      power: [
+        [900, 250, 260, 270, 900],
+        [900, 250, null, 270, 900],
+        [900, 400, 410, 420, 900],
+        [900, 400, 410, 420, 900],
+      ],
+      devices: [
+        { id: 'a/0', role: 'prefill' },
+        { id: 'a/1', role: 'prefill' },
+        { id: 'b/0', role: 'decode' },
+        { id: 'b/1', role: 'decode' },
+      ],
+    },
+    windowStartMs: 1_011_000,
+    windowEndMs: 1_013_500,
+  };
+
+  it('reports window length and each pool’s peak summed bucket inside the window', () => {
+    const summary = summarizeTraceWindow(pooled, tracePools(pooled.series));
+    expect(summary.windowSeconds).toBe(2.5);
+    expect(summary.bucketSeconds).toBe(1);
+    // The 900 W buckets sit outside the window; bucket 2 lacks one prefill GPU,
+    // so it is a gap, not a 260 W dip.
+    expect(summary.pools).toEqual([
+      { role: 'prefill', gpuCount: 2, peakWatts: 540 },
+      { role: 'decode', gpuCount: 2, peakWatts: 840 },
+    ]);
+  });
+});
 
 describe('prioritizeRuns', () => {
   const requests = ['1', '2', '3', '4', '5'].map((runId) => ({
diff --git a/packages/app/src/components/inference/utils/powerTimeline.ts b/packages/app/src/components/inference/utils/powerTimeline.ts
index cff71ac26..0a7a22254 100644
--- a/packages/app/src/components/inference/utils/powerTimeline.ts
+++ b/packages/app/src/components/inference/utils/powerTimeline.ts
@@ -13,10 +13,12 @@
  * Nothing is matched by hardware or concurrency; points whose telemetry is
  * missing (expired artifact, another collector) are reported, not guessed.
  */
-import type {
-  GpuPowerRole,
-  GpuPowerSeries,
-  GpuPowerSeriesResponse,
+import {
+  bucketTimeMs,
+  sumPowerAt,
+  type GpuPowerRole,
+  type GpuPowerSeries,
+  type GpuPowerSeriesResponse,
 } from '@/components/gpu-power/power-series';
 import type { InferenceData } from '@/components/inference/types';
 
@@ -56,6 +58,12 @@ export function runIdFromUrl(url: string | null | undefined): string | null {
   return url?.match(/\/runs\/(?<runId>\d+)/u)?.groups?.runId ?? null;
 }
 
+/** Attempt number from a `/runs/<id>/attempts/<n>` URL; null when the URL names none. */
+export function runAttemptFromUrl(url: string | null | undefined): number | null {
+  const attempt = url?.match(/\/runs\/\d+\/attempts\/(?<attempt>\d+)/u)?.groups?.attempt;
+  return attempt ? Number(attempt) : null;
+}
+
 export function longestCommonPrefix(values: readonly string[]): string {
   if (values.length === 0) return '';
   let prefix = values[0];
@@ -154,6 +162,58 @@ export interface PowerTimelineTrace {
   windowEndMs: number | null;
 }
 
+export type PowerTimelineAxis = 'wall' | 'elapsed' | 'serving';
+export type PowerTimelineLines = 'mean' | 'gpu' | 'pool';
+
+/** URL input is optional: an omitted axis retains the existing per-run default. */
+export function parsePowerTimelineParams(params: {
+  i_ptaxis?: string;
+  i_ptlines?: string;
+  i_ptwindow?: string;
+  i_ptfocus?: string;
+  i_ptutility?: string;
+  i_ptconc?: string;
+}) {
+  return {
+    axis: (['wall', 'elapsed', 'serving'].includes(params.i_ptaxis ?? '')
+      ? params.i_ptaxis
+      : null) as PowerTimelineAxis | null,
+    lines: (params.i_ptlines === 'gpu' || params.i_ptlines === 'pool'
+      ? params.i_ptlines
+      : 'mean') as PowerTimelineLines,
+    windowOnly: params.i_ptwindow === 'window',
+    focus:
+      params.i_ptfocus && /^[1-9]\d*:[\w.-]+$/u.test(params.i_ptfocus) ? params.i_ptfocus : null,
+    utility: params.i_ptutility === '1',
+    concurrency: /^[1-9]\d{0,5}$/u.test(params.i_ptconc ?? '') ? Number(params.i_ptconc) : null,
+  };
+}
+
+export function hasPowerTimelineWindow(trace: PowerTimelineTrace): boolean {
+  return (
+    trace.windowStartMs !== null &&
+    trace.windowEndMs !== null &&
+    Number.isFinite(trace.windowStartMs) &&
+    Number.isFinite(trace.windowEndMs) &&
+    trace.windowEndMs > trace.windowStartMs
+  );
+}
+
+/** Filter and position retained buckets only; never infer a missing serving origin. */
+export function powerTimelineSampleX(
+  trace: PowerTimelineTrace,
+  column: number,
+  axis: PowerTimelineAxis,
+  windowOnly: boolean,
+): number | null {
+  const timeMs = bucketTimeMs(trace.series, column);
+  if ((axis === 'serving' || windowOnly) && !hasPowerTimelineWindow(trace)) return null;
+  if (windowOnly && windowPhase(trace, timeMs) !== 'window') return null;
+  if (axis === 'wall') return timeMs;
+  const origin = axis === 'serving' ? trace.windowStartMs! : bucketTimeMs(trace.series, 0);
+  return (timeMs - origin) / 1000;
+}
+
 /**
  * Why a validated point has no trace:
  * - `no-source`: the row predates `power_audit.source` (older schema), so no
@@ -233,9 +293,9 @@ function unixSecondsToMs(seconds: number | undefined): number | null {
 export type WindowPhase = 'before' | 'window' | 'after' | 'unknown';
 
 export function windowPhase(trace: PowerTimelineTrace, timeMs: number): WindowPhase {
-  if (trace.windowStartMs === null || trace.windowEndMs === null) return 'unknown';
-  if (timeMs < trace.windowStartMs) return 'before';
-  if (timeMs > trace.windowEndMs) return 'after';
+  if (!hasPowerTimelineWindow(trace)) return 'unknown';
+  if (timeMs < trace.windowStartMs!) return 'before';
+  if (timeMs > trace.windowEndMs!) return 'after';
   return 'window';
 }
 
@@ -248,8 +308,6 @@ export function traceConfigLabel(point: InferenceData): string {
   return parts.join(' · ');
 }
 
-// ── Worker-role pools ────────────────────────────────────────────────────────
-
 export type PowerPoolRole = GpuPowerRole | 'all';
 
 export interface PowerPool {
@@ -318,17 +376,97 @@ export function referenceLabelSlots(lines: readonly { watts: number }[]): number
   });
 }
 
+/**
+ * Rows for end-of-line trace labels in pixel space: a label whose box overlaps
+ * one already placed (both ranges intersect) moves one `rowHeight` below it,
+ * top anchors first, so pools ending at the same watts do not overprint.
+ * Returns each label's y in input order.
+ */
+export function stackTraceLabels(
+  labels: readonly { left: number; right: number; y: number }[],
+  rowHeight: number,
+): number[] {
+  const ys = labels.map((label) => label.y);
+  const placed: { left: number; right: number; y: number }[] = [];
+  const order = labels.map((_, index) => index).toSorted((a, b) => labels[a].y - labels[b].y);
+  for (const index of order) {
+    const { left, right } = labels[index];
+    let y = ys[index];
+    // Each move strictly lowers the label, so this ends within `placed.length` passes.
+    let moved = true;
+    while (moved) {
+      moved = false;
+      for (const other of placed) {
+        if (left < other.right && other.left < right && Math.abs(y - other.y) < rowHeight) {
+          y = other.y + rowHeight;
+          moved = true;
+        }
+      }
+    }
+    ys[index] = y;
+    placed.push({ left, right, y });
+  }
+  return ys;
+}
+
 /** Every GPU of the series as one pool. */
 export function allGpuPool(series: Pick<GpuPowerSeries, 'power'>): PowerPool {
   return { role: 'all', rows: series.power.map((_, row) => row) };
 }
 
+export interface TracePoolSummary {
+  role: PowerPoolRole;
+  gpuCount: number;
+  /** Highest drawn one-second pool sum inside the window; null when none was complete. */
+  peakWatts: number | null;
+}
+
+export interface TraceWindowSummary {
+  /** Recorded validated serving-window length, or null when bounds are missing. */
+  windowSeconds: number | null;
+  bucketSeconds: number;
+  pools: TracePoolSummary[];
+}
+
+/**
+ * What a Timeline reader needs next to the curves: the validated window's
+ * length and, per pool, its GPU count and the peak of the drawn pool line
+ * inside the window. A bucket missing a pool device is a gap in the line, so
+ * it is skipped. Averages are not recomputed: the benchmark row's validated
+ * figures stay the only means.
+ */
+export function summarizeTraceWindow(
+  trace: PowerTimelineTrace,
+  pools: readonly PowerPool[],
+): TraceWindowSummary {
+  const hasWindow = hasPowerTimelineWindow(trace);
+  const columns = hasWindow
+    ? trace.series.t
+        .map((_, column) => column)
+        .filter((column) => windowPhase(trace, bucketTimeMs(trace.series, column)) === 'window')
+    : [];
+  return {
+    windowSeconds: hasWindow ? (trace.windowEndMs! - trace.windowStartMs!) / 1000 : null,
+    bucketSeconds: trace.series.bucketSeconds,
+    pools: pools.map((pool) => {
+      const sums = columns
+        .map((column) => sumPowerAt(trace.series, pool.rows, column))
+        .filter((value): value is number => value !== null);
+      return {
+        role: pool.role,
+        gpuCount: pool.rows.length,
+        peakWatts: sums.length > 0 ? Math.max(...sums) : null,
+      };
+    }),
+  };
+}
+
 // ── Deep link from a pinned scatter tooltip ─────────────────────────────────
 //
 // "View power trace" on a pinned tooltip switches the metric to the Timeline
 // display; the timeline mounts afterwards and reads the requested trace here
-// so it can emphasise that config. Module state rather than URL state: the
-// focus is a one-shot gesture, and the share link stays `i_metric` alone.
+// so it can emphasise that config. The one-shot gesture takes precedence over
+// restored URL focus; the mounted timeline then persists it with its view state.
 
 let pendingFocus: string | null = null;
 
diff --git a/packages/app/src/components/inference/utils/quick-filter-summary.ts b/packages/app/src/components/inference/utils/quick-filter-summary.ts
index ba6b3bbac..e843dc9af 100644
--- a/packages/app/src/components/inference/utils/quick-filter-summary.ts
+++ b/packages/app/src/components/inference/utils/quick-filter-summary.ts
@@ -1,5 +1,6 @@
 import type { QuickFilters } from '../types';
 import { FRAMEWORK_FAMILIES } from './quickFilters';
+import { topologyLabel } from './topology-filter';
 
 const LABELS = {
   en: {
@@ -8,6 +9,7 @@ const LABELS = {
     deployment: 'Deployment',
     spec: 'Spec Decoding',
     power: 'Measured Power',
+    topologies: 'Topology',
     'single-node': 'Single-node',
     'multi-node': 'Multi-node',
     disagg: 'Disaggregated',
@@ -22,6 +24,7 @@ const LABELS = {
     deployment: '部署模式',
     spec: '投机解码',
     power: '实测功耗',
+    topologies: '拓扑',
     'single-node': '单节点',
     'multi-node': '多节点聚合',
     disagg: '分离式',
@@ -37,14 +40,16 @@ export function quickFilterSummary(filters: QuickFilters, locale: 'en' | 'zh', a
   const labels = LABELS[locale];
   return (Object.keys(filters) as (keyof QuickFilters)[]).flatMap((category) => {
     if (agentic && category === 'spec') return [];
-    return filters[category].map((value) => ({
+    return (filters[category] ?? []).map((value) => ({
       category,
       value,
       categoryLabel: labels[category],
       label:
-        category === 'frameworks'
-          ? (FRAMEWORK_FAMILIES.find((family) => family.key === value)?.label ?? value)
-          : (labels[value as keyof typeof labels] ?? value),
+        category === 'topologies'
+          ? topologyLabel(value, locale)
+          : category === 'frameworks'
+            ? (FRAMEWORK_FAMILIES.find((family) => family.key === value)?.label ?? value)
+            : (labels[value as keyof typeof labels] ?? value),
     }));
   });
 }
diff --git a/packages/app/src/components/inference/utils/quickFilters.test.ts b/packages/app/src/components/inference/utils/quickFilters.test.ts
index 82490d6f0..15c4ae01a 100644
--- a/packages/app/src/components/inference/utils/quickFilters.test.ts
+++ b/packages/app/src/components/inference/utils/quickFilters.test.ts
@@ -72,7 +72,7 @@ describe('computeAvailableQuickFilters', () => {
         power_tier: 'certified',
       }),
     ];
-    expect(computeAvailableQuickFilters(points)).toEqual({
+    expect(computeAvailableQuickFilters(points)).toMatchObject({
       vendors: ['NVIDIA', 'AMD'],
       frameworks: ['vllm', 'trt', 'atom'],
       deployment: ['single-node', 'multi-node', 'disagg'],
@@ -85,7 +85,7 @@ describe('computeAvailableQuickFilters', () => {
     const points = [
       point({ hwKey: 'h100_vllm', framework: 'vllm', disagg: false, spec_decoding: 'none' }),
     ];
-    expect(computeAvailableQuickFilters(points)).toEqual({
+    expect(computeAvailableQuickFilters(points)).toMatchObject({
       vendors: ['NVIDIA'],
       frameworks: ['vllm'],
       deployment: ['single-node'],
@@ -112,6 +112,7 @@ describe('computeAvailableQuickFilters', () => {
       deployment: [],
       spec: [],
       power: [],
+      topologies: [],
     });
   });
 });
diff --git a/packages/app/src/components/inference/utils/quickFilters.ts b/packages/app/src/components/inference/utils/quickFilters.ts
index 479b06d9b..50513bb82 100644
--- a/packages/app/src/components/inference/utils/quickFilters.ts
+++ b/packages/app/src/components/inference/utils/quickFilters.ts
@@ -9,6 +9,7 @@ import type {
 } from '@/components/inference/types';
 import { frameworkFamily } from '@/lib/framework-family';
 import type { PowerTier } from '@/lib/power-tier';
+import { pointTopologyKey } from './topology-filter';
 
 export type { AvailableQuickFilters, DeploymentMode, PowerTier, QuickFilters, SpecMode };
 
@@ -64,6 +65,7 @@ export function computeAvailableQuickFilters(
 ): AvailableQuickFilters {
   const vendors = new Set<string>();
   const frameworks = new Set<string>();
+  const topologies = new Set<string>();
   let hasSingleNode = false;
   let hasMultiNode = false;
   let hasDisagg = false;
@@ -72,6 +74,7 @@ export function computeAvailableQuickFilters(
   let hasCertified = false;
   let hasLegacy = false;
   for (const p of points) {
+    topologies.add(pointTopologyKey(p));
     const vendor = pointVendor(String(p.hwKey));
     if (vendor) vendors.add(vendor);
     const fam = frameworkFamily(p.framework);
@@ -98,6 +101,7 @@ export function computeAvailableQuickFilters(
     deployment,
     spec,
     power: POWER_TIER_ORDER.filter((tier) => (tier === 'certified' ? hasCertified : hasLegacy)),
+    topologies: [...topologies].toSorted(),
   };
 }
 
@@ -108,7 +112,8 @@ export function quickFiltersActive(f: QuickFilters): boolean {
     f.frameworks.length > 0 ||
     f.deployment.length > 0 ||
     f.spec.length > 0 ||
-    f.power.length > 0
+    f.power.length > 0 ||
+    (f.topologies?.length ?? 0) > 0
   );
 }
 
@@ -159,6 +164,7 @@ export function parsePowerTiers(values: readonly string[]): PowerTier[] {
 
 /** Whether a single data point satisfies every active quick-filter category. */
 export function matchesQuickFilters(point: InferenceData, f: QuickFilters): boolean {
+  if (f.topologies?.length && !f.topologies.includes(pointTopologyKey(point))) return false;
   if (f.vendors.length > 0) {
     const vendor = pointVendor(String(point.hwKey));
     if (!vendor || !f.vendors.includes(vendor)) return false;
diff --git a/packages/app/src/components/inference/utils/resolveXAxisField.ts b/packages/app/src/components/inference/utils/resolveXAxisField.ts
index 282b778a7..06b48aa10 100644
--- a/packages/app/src/components/inference/utils/resolveXAxisField.ts
+++ b/packages/app/src/components/inference/utils/resolveXAxisField.ts
@@ -17,8 +17,11 @@ import { withPercentile } from '@/lib/benchmark-transform';
 import type { AggDataEntry, ChartDefinition } from '../types';
 import type { XAxisMode } from '../hooks/useChartData';
 
+export type FixedSequenceStatistic = 'mean' | 'median';
+
 /** Which rung of the branch ladder chose the x field (drives label choice). */
 export type XAxisBranch =
+  | 'concurrency'
   | 'natural'
   | 'user-input-override'
   | 'config-input-override'
@@ -34,15 +37,31 @@ export interface ResolvedXAxis {
   branch: XAxisBranch;
 }
 
+/**
+ * A service-metric field at the selected statistic: the percentile for agentic
+ * rows, mean or median for fixed sequences. Fixed-sequence mean interactivity
+ * is reciprocal mean TPOT, never the raw arithmetic-mean interactivity field.
+ */
+export function resolveServiceField(
+  field: string,
+  opts: { isAgentic: boolean; percentile: string; fixedSequenceStatistic?: FixedSequenceStatistic },
+): keyof AggDataEntry {
+  const { isAgentic, percentile, fixedSequenceStatistic = 'median' } = opts;
+  const resolved = withPercentile(field, isAgentic ? percentile : fixedSequenceStatistic);
+  return (
+    !isAgentic && resolved === 'mean_intvty' ? 'mean_tpot_intvty' : resolved
+  ) as keyof AggDataEntry;
+}
+
 /**
  * Resolve the x-axis data field for a chart definition + metric selection.
  *
  * Rules, in order:
  * - The global x-axis mode takes precedence over legacy per-input-metric
- *   overrides. TTFT uses median for fixed-sequence runs.
+ *   overrides. Fixed-sequence service axes use the selected mean/median statistic.
  * - Natural x = the chart's latency metric at the selected percentile for
- *   agentic, forced to median for fixed-seq, where percentile-specific
- *   columns are not guaranteed to exist.
+ *   agentic, mean or median for fixed-sequence. Mean interactivity uses
+ *   reciprocal mean TPOT, never the raw arithmetic-mean interactivity field.
  * - Without a global mode, input metrics on the interactivity chart override x to a TTFT column:
  *   the user-picked metric for fixed-seq (the manual dropdown is hidden in
  *   agentic mode), else the config default.
@@ -58,13 +77,16 @@ export function resolveXAxisField(
   chartDef: ChartDefinition,
   selectedYAxisMetric: string,
   effectiveXMetric: string | null,
-  opts: { isAgentic: boolean; percentile: string; xAxisMode?: XAxisMode },
+  opts: {
+    isAgentic: boolean;
+    percentile: string;
+    xAxisMode?: XAxisMode;
+    fixedSequenceStatistic?: FixedSequenceStatistic;
+  },
 ): ResolvedXAxis {
   const { isAgentic, percentile, xAxisMode } = opts;
-  const naturalX = withPercentile(
-    chartDef.x,
-    isAgentic ? percentile : 'median',
-  ) as keyof AggDataEntry;
+  const serviceField = (field: string) => resolveServiceField(field, opts);
+  const naturalX = serviceField(chartDef.x);
 
   const metricTitle =
     (chartDef[`${selectedYAxisMetric}_title` as keyof ChartDefinition] as string) || '';
@@ -77,11 +99,11 @@ export function resolveXAxisField(
   let xAxisField: keyof AggDataEntry = naturalX;
   let branch: XAxisBranch = 'natural';
   if (xAxisMode !== undefined) {
-    if (xAxisMode === 'ttft' && chartDef.chartType === 'e2e') {
-      xAxisField = withPercentile(
-        'median_ttft',
-        isAgentic ? percentile : 'median',
-      ) as keyof AggDataEntry;
+    if (xAxisMode === 'concurrency') {
+      xAxisField = 'conc';
+      branch = 'concurrency';
+    } else if (xAxisMode === 'ttft' && chartDef.chartType === 'e2e') {
+      xAxisField = serviceField('median_ttft');
       branch = 'e2e-ttft-override';
     }
   } else if (
@@ -101,7 +123,7 @@ export function resolveXAxisField(
     branch = 'e2e-ttft-override';
   }
 
-  if (isAgentic) {
+  if (isAgentic && xAxisMode !== 'concurrency') {
     xAxisField = withPercentile(xAxisField, percentile) as keyof AggDataEntry;
   }
 
diff --git a/packages/app/src/components/inference/utils/role-energy.ts b/packages/app/src/components/inference/utils/role-energy.ts
index 89e6b37f2..53d719dd0 100644
--- a/packages/app/src/components/inference/utils/role-energy.ts
+++ b/packages/app/src/components/inference/utils/role-energy.ts
@@ -1,3 +1,5 @@
+import { isPositive } from '@/lib/power-basis';
+
 /**
  * Reconstructs how a disaggregated deployment's request energy splits between
  * its prefill and decode pools (PowerX Figure 7).
@@ -36,9 +38,6 @@ export interface ReconstructedRoleEnergy {
   prefillShare: number;
 }
 
-const positive = (value: unknown): value is number =>
-  typeof value === 'number' && Number.isFinite(value) && value > 0;
-
 export function reconstructedRoleEnergy(
   entry: RoleEnergyInput,
 ): ReconstructedRoleEnergy | undefined {
@@ -49,12 +48,12 @@ export function reconstructedRoleEnergy(
   const output = entry.joules_per_output_token;
   const prefill = entry.prefill_joules_per_input_token;
   const decode = entry.decode_joules_per_output_token;
-  if (!positive(input) || !positive(output) || !positive(prefill) || !positive(decode)) {
+  if (!isPositive(input) || !isPositive(output) || !isPositive(prefill) || !isPositive(decode)) {
     return undefined;
   }
   const prefillPerOutputToken = prefill * (output / input);
   const total = prefillPerOutputToken + decode;
-  if (!positive(prefillPerOutputToken) || !positive(total)) return undefined;
+  if (!isPositive(prefillPerOutputToken) || !isPositive(total)) return undefined;
   return {
     prefill: prefillPerOutputToken,
     decode,
diff --git a/packages/app/src/components/inference/utils/tooltipUtils.ts b/packages/app/src/components/inference/utils/tooltipUtils.ts
index 2ae288497..254fa83d5 100644
--- a/packages/app/src/components/inference/utils/tooltipUtils.ts
+++ b/packages/app/src/components/inference/utils/tooltipUtils.ts
@@ -962,6 +962,7 @@ export const generateGPUGraphTooltipContent = (config: TooltipConfig): string =>
         hasLogData: Boolean(hasLog),
         point: d,
         showPowerTelemetry: config.showPowerTelemetry,
+        powerTraceMetric: selectedYAxisMetric,
         locale,
       })}
     </div>
diff --git a/packages/app/src/components/inference/utils/topology-filter.test.ts b/packages/app/src/components/inference/utils/topology-filter.test.ts
new file mode 100644
index 000000000..abd9eb195
--- /dev/null
+++ b/packages/app/src/components/inference/utils/topology-filter.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+
+import type { InferenceData } from '@/components/inference/types';
+
+import { pointTopologyKey, topologyLabel } from './topology-filter';
+
+describe('topologyLabel', () => {
+  it('spells out offload modes beside compact parallelism tokens', () => {
+    const base = { physicalChips: 8, decode_tp: 8, decode_ep: 1, offload_mode: 'off' };
+    const keys = [base, { ...base, offload_mode: 'on' }].map((point) =>
+      pointTopologyKey(point as InferenceData),
+    );
+    expect(keys.map((key) => topologyLabel(key, 'en', keys))).toEqual([
+      'Single-node · GPU8 · TP8 · EP1 · offload off',
+      'Single-node · GPU8 · TP8 · EP1 · offload on',
+    ]);
+  });
+});
diff --git a/packages/app/src/components/inference/utils/topology-filter.ts b/packages/app/src/components/inference/utils/topology-filter.ts
new file mode 100644
index 000000000..23a4c5e19
--- /dev/null
+++ b/packages/app/src/components/inference/utils/topology-filter.ts
@@ -0,0 +1,83 @@
+import type { InferenceData } from '../types';
+import { meaningfulParallelismSize } from './parallelism-label';
+
+function topologyValue(value: number | boolean | undefined) {
+  return value === undefined || value === null || !Number.isFinite(Number(value))
+    ? '?'
+    : Number(value);
+}
+
+/** Load is deliberately excluded: a topology filter retains its whole concurrency sweep. */
+export function pointTopologyKey(point: InferenceData): string {
+  const fields: [string, number | boolean | undefined][] = [
+    ['GPU', point.physicalChips ?? point.tp],
+    ['DP', point.dp],
+    ['TP', point.decode_tp],
+    ['EP', point.decode_ep ?? point.ep],
+    ['PP', point.decode_pp ?? point.pp],
+    [
+      'DCP',
+      point.disagg
+        ? point.decode_dcp_size
+        : (meaningfulParallelismSize(point.prefill_dcp_size, point.decode_dcp_size) ??
+          point.decode_dcp_size ??
+          point.prefill_dcp_size),
+    ],
+    [
+      'PCP',
+      point.disagg
+        ? point.decode_pcp_size
+        : (meaningfulParallelismSize(point.prefill_pcp_size, point.decode_pcp_size) ??
+          point.decode_pcp_size ??
+          point.prefill_pcp_size),
+    ],
+    ['DPA', point.decode_dp_attention ?? point.dp_attention],
+  ];
+  if (point.disagg)
+    fields.push(
+      ['P-GPU', point.num_prefill_gpu],
+      ['D-GPU', point.num_decode_gpu],
+      ['P-workers', point.prefill_num_workers],
+      ['D-workers', point.decode_num_workers],
+      ['P-TP', point.prefill_tp],
+      ['P-EP', point.prefill_ep],
+      ['P-PP', point.prefill_pp],
+      ['P-DCP', point.prefill_dcp_size],
+      ['P-PCP', point.prefill_pcp_size],
+      ['P-DPA', point.prefill_dp_attention],
+    );
+  const mode = point.disagg ? 'PD' : point.is_multinode ? 'Multi' : 'Single';
+  return [
+    mode,
+    ...fields.map(([key, v]) => `${key}=${topologyValue(v)}`),
+    `offload=${point.offload_mode ?? '?'}`,
+  ].join('|');
+}
+
+/** Values stay human-readable in share links and exported filter metadata. */
+export function topologyLabel(
+  key: string,
+  locale: 'en' | 'zh',
+  availableKeys?: readonly string[],
+): string {
+  const [mode, ...parts] = key.split('|');
+  const modes =
+    locale === 'zh'
+      ? { PD: '分离式', Multi: '多节点', Single: '单节点' }
+      : { PD: 'Disaggregated', Multi: 'Multi-node', Single: 'Single-node' };
+  // Hide shared detail, never a difference: defaults and unknowns distinguish options too.
+  const peers = availableKeys?.filter((sibling) => sibling.split('|')[0] === mode);
+  const visible = parts.filter((part) => {
+    const name = part.split('=')[0];
+    return (
+      ['GPU', 'TP', 'EP', 'P-GPU', 'D-GPU', 'P-TP', 'P-EP'].includes(name) ||
+      !peers?.length ||
+      !peers.every((sibling) => sibling.split('|').includes(part))
+    );
+  });
+  // Numbers and unknowns join their name (TP4, DP?); word values need a space (offload off).
+  return [
+    modes[mode as keyof typeof modes] ?? mode,
+    ...visible.map((part) => part.replace(/=(?=\p{L})/u, ' ').replace('=', '')),
+  ].join(' · ');
+}
diff --git a/packages/app/src/components/inference/utils/x-axis-scale.ts b/packages/app/src/components/inference/utils/x-axis-scale.ts
index 205c803ae..9b089a60b 100644
--- a/packages/app/src/components/inference/utils/x-axis-scale.ts
+++ b/packages/app/src/components/inference/utils/x-axis-scale.ts
@@ -18,6 +18,7 @@ export function resolveScatterXAxisScale({
   xAxisField,
   scaleType,
 }: ResolveScatterXAxisScaleOptions): ScatterXAxisScale {
+  if (xAxisField === 'conc') return 'linear';
   if (selectedYAxisMetric !== 'y_inputTputPerGpu') return 'linear';
   if (scaleType === 'linear') return 'linear';
   if (scaleType === 'log') return extent[0] > 0 ? 'log' : 'linear';
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 70c72a16b..8e94b1394 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -139,7 +139,7 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'published-read',
     operationId: 'get-inference-view',
-    sourceSha256: 'de9192086b27e530ad6b1ece082b4989b3a9771a78195ae9f6d1c3899519588f',
+    sourceSha256: 'bafac08dbe6e6e4b75dd15987e79f84b514f3e93351149ad44b296f6dd2a9662',
   },
   {
     source: 'src/app/api/v1/views/options/route.ts',
@@ -147,7 +147,7 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'published-read',
     operationId: 'get-view-options',
-    sourceSha256: '79571c3e6faf5af977c1afc9c29ebd6c1bfeb54ccf389711fa49668466fb58f4',
+    sourceSha256: 'ceba9504cfc50cb37748c9455f22dca9813789eb0148da740b24678bb540fb27',
   },
   {
     source: 'src/app/api/v1/views/overview/route.ts',
@@ -278,7 +278,7 @@ export const apiRouteCatalog = [
       en: 'UI-only PowerX raw/series=power read: DB-first with artifact fallback, separate host/GPU identities and adjacent CSV context timezone normalization. GET has no expected identities and reports sourceCoverage unknown. Healthy stored windows survive fallback; known-incomplete CSVs require retained file/sample inventory and known-incomplete bundles require re-ingest. DB failures return 503 DATABASE_UNAVAILABLE; unresolved stored gaps return 503 STORED_TELEMETRY_INCOMPLETE. Responses use no-store. This is not a stable public API.',
       zh: '仅供 PowerX 界面读取原始遥测或 series=power：优先 DB，缺失时回退产物，保留主机/GPU 身份，并按相邻 CSV context 规范化时区。GET 没有预期身份清单，sourceCoverage 为 unknown。回退保留健康存储窗口；已知不完整 CSV 须满足文件/样本清单，已知不完整 bundle 须重新 ingest。数据库故障返回 503 DATABASE_UNAVAILABLE，未恢复的存储缺口返回 503 STORED_TELEMETRY_INCOMPLETE。响应使用 no-store，不作为稳定公开 API。',
     },
-    sourceSha256: '80fd8ea1d462b2d47d42411d8361db72802943a94c7ffb91879244c69ef2c693',
+    sourceSha256: 'c1e279231b7ecee8e8cbff89dd9104c5b5f5bfd9e73528308e8f8f7ed2324e50',
   },
   {
     source: 'src/app/api/gpu-metrics/route.ts',
@@ -289,7 +289,7 @@ export const apiRouteCatalog = [
       en: 'Read-only Timeline transport with runId, series=power and optional prefix in the query; JSON sources contains 1–1000 validation basenames with RESULT_FILENAME up to 200 ASCII letters/digits/dot/underscore/hyphen, matching prefix. Invalid input returns 400; bodies over 256 KiB return 413. Fully covered DB reads skip GitHub; missing identities fall back and merge by validation source, preserving stored sibling windows. Offline GitHub preserves healthy DB series with incomplete sourceCoverage. Coverage describes only requested identities, never whole-run/sample completeness. The GET no-store/error/inventory guarantees also apply. UI-owned, excluded from the stable public API.',
       zh: 'Timeline 只读传输：查询参数为 runId、series=power 和可选 prefix；JSON sources 含 1–1000 个验证文件 basename，RESULT_FILENAME 最长 200 个 ASCII 字母/数字/点/下划线/连字符，且须匹配 prefix。输入错误返回 400，正文超过 256 KiB 返回 413。DB 已覆盖请求时跳过 GitHub，否则按缺失身份回退，以 validation source 为键合并，并保留已存储的同 bundle 兄弟窗口。GitHub 离线仍返回健康 DB 序列，sourceCoverage 标记 incomplete。覆盖仅针对请求身份，不代表整次 run 或样本完整性。沿用 GET 的 no-store、错误和清单约束；属于界面接口，不纳入稳定公开 API。',
     },
-    sourceSha256: '80fd8ea1d462b2d47d42411d8361db72802943a94c7ffb91879244c69ef2c693',
+    sourceSha256: 'c1e279231b7ecee8e8cbff89dd9104c5b5f5bfd9e73528308e8f8f7ed2324e50',
   },
   {
     source: 'src/app/api/openapi.json/route.ts',
@@ -843,6 +843,54 @@ export interface ApiContractSourceDigest {
  * touching a route module. Digest changes require an explicit documentation review.
  */
 export const apiContractSourceDigests = [
+  {
+    source: 'src/components/inference/utils/resolveXAxisField.ts',
+    sourceSha256: '4783579c7b3c1a21b91968cb03e9c35a57a85251f4992cb5667a855ba7c77497',
+    reviewArea: {
+      en: 'Shared service-axis resolution: fixed-sequence mean/median, reciprocal mean TPOT, and AgentX percentile isolation.',
+      zh: '共用服务轴解析：固定长度工作负载 mean/median、mean TPOT 的倒数，以及 AgentX 独立的分位数选择。',
+    },
+  },
+  {
+    source: 'src/components/inference/utils/equal-service-comparison.ts',
+    sourceSha256: '9a7989e04f0228983f5f1069b8e35e221d85561bd95fdfd1ba9e4210f42bb0c1',
+    reviewArea: {
+      en: 'Source-scoped equal-service interpolation, comparator-relative changes, endpoint provenance, prefill share projection and role points.',
+      zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源、prefill 占比视图以及各角色数据点。',
+    },
+  },
+  {
+    source: 'src/components/inference/utils/matched-concurrency.ts',
+    sourceSha256: 'db81deeff9e6ff64f607b71751d18acc59626f43fecbe037145e3a55c4fe959f',
+    reviewArea: {
+      en: 'Same-concurrency pairing of two exact sources: missing and conflicting observations, signed comparator-relative changes, no interpolation.',
+      zh: '两个完整来源在相同并发下的配对：缺失与冲突观测、相对基准的带符号变化，不做插值。',
+    },
+  },
+  {
+    source: 'src/components/inference/utils/power-fit.ts',
+    sourceSha256: 'a1e30d09648b74897e283b67a4e63e2591a485ed0f92e00acbe606b75967444a',
+    reviewArea: {
+      en: 'Per-source least-squares power fit on output per allocated GPU: intercept, marginal J/token, R², fitted range and registry TDP.',
+      zh: '按来源对每个已分配 GPU 的输出做最小二乘功耗拟合：截距、边际 J/token、R²、拟合范围与注册表 TDP。',
+    },
+  },
+  {
+    source: 'src/components/inference/utils/role-energy.ts',
+    sourceSha256: '36b1ceda97af99731482ed815167a660f1619ab94c2956afe11cf72d58fa5380',
+    reviewArea: {
+      en: 'Validated prefill/decode energy reconstruction and shares on a common output-token denominator.',
+      zh: '使用统一 output token 分母的已验证 prefill/decode 能耗重建与占比。',
+    },
+  },
+  {
+    source: 'src/lib/benchmark-transform.ts',
+    sourceSha256: '21f1fe4d63737c74efb2251a64f79eef1b5e9c565769be9b4fb500b1fa4ecc89',
+    reviewArea: {
+      en: 'Raw benchmark means and derived reciprocal mean-TPOT interactivity used by Dashboard and read-only views.',
+      zh: '仪表板和只读视图共用的原始 benchmark 均值与 mean TPOT 倒数形式的 interactivity。',
+    },
+  },
   {
     source: '../db/src/etl/power-audit-validations.ts',
     sourceSha256: '44a607747b79d038bb8f4e53590efba689d376c143f50a5d750d3552faa0c442',
@@ -853,7 +901,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/gpu-power/power-audit-bundle.ts',
-    sourceSha256: '96aa2ed60692116d5b5219b90b562fdc8143b63359bd917bbc91812ffaf274a8',
+    sourceSha256: '21607a0bc3795c545d7f84bb7af2558624a8d1e054e7c92b9203ae94825d1804',
     reviewArea: {
       en: 'Artifact Timeline validation windows, strict nested AgentX result identity, adjacent context selection, timezone normalization and device identity semantics.',
       zh: '产物 Timeline 验证窗口、严格匹配的嵌套 AgentX result 身份、相邻 context 选择、时区规范化及设备身份语义。',
@@ -869,7 +917,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/gpu-power/types.ts',
-    sourceSha256: 'e8c5460821f5d8228bcf8b7dd087abe14e29a8e220e1d8bcd75112fb5ead1baa',
+    sourceSha256: '207d56219a78a44603bff5d61ca9017caa37ab1a6973792793a2ce2122f5475c',
     reviewArea: {
       en: 'GPU telemetry units, missing values, timestamp deduplication, and full-record live statistics definitions.',
       zh: 'GPU 遥测单位、缺失值、时间戳去重，以及实时产物全记录统计的定义。',
@@ -931,7 +979,7 @@ export const apiContractSourceDigests = [
 
   {
     source: 'src/components/inference/hooks/chart-data-core.ts',
-    sourceSha256: '0c86987ed025557172a8d020144ca462be1ecac880d53b7d929f93a617086c33',
+    sourceSha256: '8601c33f6979541786362276697e4d4a21278de1d57b50d31f705391b5da041d',
     reviewArea: {
       en: 'Dashboard read-only selector and calculation parity.',
       zh: '仪表板只读接口的选择项与计算一致性。',
@@ -985,7 +1033,7 @@ export const apiContractSourceDigests = [
 
   {
     source: 'src/lib/views-api/series.ts',
-    sourceSha256: 'b5ebddee9d9ea6b85a8fdab2cf8fcc50bbf05e0fa10564987698abd38a6d4488',
+    sourceSha256: '9974fe5166ac847f4b9284eda8a901ee0f9c8b432567ef184890453c715d2f4f',
     reviewArea: {
       en: 'Dashboard read-only selector and calculation parity.',
       zh: '仪表板只读接口的选择项与计算一致性。',
@@ -994,7 +1042,7 @@ export const apiContractSourceDigests = [
 
   {
     source: 'src/lib/views-api/registry.ts',
-    sourceSha256: '2f787cabdb65a3549eb2fbd1ce7d3929dd5e5b18d7f34fce1fd7af26100b7954',
+    sourceSha256: '9f07c3bae5ec76f47b562143d52632dd186f132cd0e117848a0fa1d7d018f3ea',
     reviewArea: {
       en: 'Dashboard read-only selector and calculation parity.',
       zh: '仪表板只读接口的选择项与计算一致性。',
diff --git a/packages/app/src/lib/benchmark-transform.ts b/packages/app/src/lib/benchmark-transform.ts
index f1712e306..ab974f8d4 100644
--- a/packages/app/src/lib/benchmark-transform.ts
+++ b/packages/app/src/lib/benchmark-transform.ts
@@ -199,6 +199,9 @@ export function rowToAggDataEntry(row: BenchmarkRow): AggDataEntry {
     p99_tpot: m.p99_tpot ?? 0,
     'p99.9_tpot': m['p99.9_tpot'] ?? 0,
     mean_intvty: m.mean_intvty ?? 0,
+    ...(typeof m.mean_tpot === 'number' && Number.isFinite(m.mean_tpot) && m.mean_tpot > 0
+      ? { mean_tpot_intvty: 1 / m.mean_tpot }
+      : {}),
     median_intvty: m.median_intvty ?? 0,
     std_intvty: m.std_intvty ?? 0,
     p75_intvty: m.p75_intvty ?? 0,
diff --git a/packages/app/src/lib/chart-utils.ts b/packages/app/src/lib/chart-utils.ts
index 78b62b2d8..a1ae03ac2 100644
--- a/packages/app/src/lib/chart-utils.ts
+++ b/packages/app/src/lib/chart-utils.ts
@@ -11,7 +11,6 @@ import type {
   AggDataEntry,
   ChartDefinition,
   InferenceData,
-  PowerBasisFieldKey,
   YAxisMetricKey,
 } from '@/components/inference/types';
 import {
@@ -292,13 +291,8 @@ export function buildAvailabilityHwKey(
   return hwKey;
 }
 
-// Power-boundary fields are derived here before the registry exposes them as
-// axes; the union collapses once METRIC_REGISTRY carries the same keys. The
-// reconstructed prefill energy is a comparison-only series (never an axis).
-export type DerivedMetricKey =
-  | BenchmarkMetricKey
-  | PowerBasisFieldKey
-  | 'reconstructedPrefillJPerOutputToken';
+// The reconstructed prefill energy is a comparison-only series (never an axis).
+export type DerivedMetricKey = BenchmarkMetricKey | 'reconstructedPrefillJPerOutputToken';
 export type DerivedChartFields = Pick<InferenceData, DerivedMetricKey>;
 
 const chartMetric = (y: number): { y: number; roof: boolean } => ({ y, roof: false });
@@ -553,6 +547,9 @@ function buildMeasuredPowerChartFields(
   entry: AggDataEntry,
   tdpWatts: number,
 ): MeasuredPowerChartFields {
+  // Prefill energy on the output-token axis, so the roles comparison can
+  // stack it against the decode pool (PowerX Figure 7).
+  const roleEnergy = reconstructedRoleEnergy(entry);
   return {
     // The timeline axis aliases the validated average: the point set (and
     // its table row) is the same, only the chart body changes.
@@ -591,14 +588,7 @@ function buildMeasuredPowerChartFields(
     ...(typeof entry.decode_joules_per_output_token === 'number'
       ? { measuredDecodeJPerOutputToken: chartMetric(entry.decode_joules_per_output_token) }
       : {}),
-    // Prefill energy on the output-token axis, so the roles comparison can
-    // stack it against the decode pool (PowerX Figure 7).
-    ...(() => {
-      const roleEnergy = reconstructedRoleEnergy(entry);
-      return roleEnergy
-        ? { reconstructedPrefillJPerOutputToken: chartMetric(roleEnergy.prefill) }
-        : {};
-    })(),
+    ...(roleEnergy ? { reconstructedPrefillJPerOutputToken: chartMetric(roleEnergy.prefill) } : {}),
     ...(typeof entry.joules_per_successful_query === 'number'
       ? {
           measuredJPerSuccessfulQuery: chartMetric(entry.joules_per_successful_query),
@@ -623,14 +613,21 @@ export function remapInferencePoint(
   const metric = point[metricKey];
   const xCandidate = (point as Partial<AggDataEntry>)[xAxisField];
   // Absent TTFT values are zero-filled by the row transform. Neither that
-  // sentinel nor an unrelated fallback coordinate is a latency measurement.
-  const missingTtft =
-    xAxisField.endsWith('_ttft') && (typeof xCandidate !== 'number' || xCandidate <= 0);
+  // sentinel nor an unrelated fallback coordinate is a latency measurement;
+  // the same holds for concurrency and the mean service fields.
+  const requiresMeasuredValue =
+    xAxisField === 'conc' ||
+    xAxisField.endsWith('_ttft') ||
+    xAxisField === 'mean_e2el' ||
+    xAxisField === 'mean_tpot_intvty';
+  const missingMeasuredValue =
+    requiresMeasuredValue &&
+    (typeof xCandidate !== 'number' || !Number.isFinite(xCandidate) || xCandidate <= 0);
   return {
     ...point,
-    x: missingTtft ? NaN : typeof xCandidate === 'number' ? xCandidate : point.x,
+    x: missingMeasuredValue ? NaN : typeof xCandidate === 'number' ? xCandidate : point.x,
     y: metric?.y ?? point.y,
-    roof: metric?.roof ?? false,
+    roof: xAxisField === 'conc' ? false : (metric?.roof ?? false),
   };
 }
 
diff --git a/packages/app/src/lib/d3-chart/layers/rooflines.test.ts b/packages/app/src/lib/d3-chart/layers/rooflines.test.ts
index 409cc1f50..170158964 100644
--- a/packages/app/src/lib/d3-chart/layers/rooflines.test.ts
+++ b/packages/app/src/lib/d3-chart/layers/rooflines.test.ts
@@ -19,7 +19,12 @@ vi.mock('d3', async () => {
   };
 });
 
-import { renderRooflines, updateRooflinesOnZoom, type RooflineConfig } from './rooflines';
+import {
+  renderRooflines,
+  updateRooflinesForDisplay,
+  updateRooflinesOnZoom,
+  type RooflineConfig,
+} from './rooflines';
 
 // ── Fixtures ─────────────────────────────────────────────────────────
 
@@ -201,6 +206,31 @@ describe('renderRooflines', () => {
     }
   });
 
+  it('dashes each curve from getDasharray and keeps the dashes on display updates', () => {
+    const group = createMockGroup();
+    const { xScale, yScale } = makeScales();
+    // A null dash is a solid curve even when a chart-wide dash is also set.
+    const config = makeConfig({
+      strokeDasharray: '5,3',
+      getDasharray: (key) => (key === 'modelB' ? '2 3' : null),
+    });
+    const dashes = () =>
+      Object.fromEntries(
+        group
+          .selectAll('.roofline-path')
+          .elements.map((el) => [el.attrs['class'], el.attrs['stroke-dasharray']]),
+      );
+    const expected = {
+      'roofline-path roofline-modelA': null,
+      'roofline-path roofline-modelB': '2 3',
+    };
+
+    renderRooflines(group as any, SAMPLE_ROOFLINES, xScale, yScale, config);
+    expect(dashes()).toEqual(expected);
+    updateRooflinesForDisplay(group as any, config);
+    expect(dashes()).toEqual(expected);
+  });
+
   it('does not set strokeDasharray when not specified', () => {
     const group = createMockGroup();
     const { xScale, yScale } = makeScales();
diff --git a/packages/app/src/lib/d3-chart/layers/rooflines.ts b/packages/app/src/lib/d3-chart/layers/rooflines.ts
index c97b880cc..b58d0adb7 100644
--- a/packages/app/src/lib/d3-chart/layers/rooflines.ts
+++ b/packages/app/src/lib/d3-chart/layers/rooflines.ts
@@ -8,9 +8,15 @@ export interface RooflineConfig {
   isVisible?: (key: string) => boolean;
   strokeWidth?: number;
   strokeDasharray?: string;
+  /** Per-curve dash pattern; `null` draws a solid line. Takes precedence over `strokeDasharray`. */
+  getDasharray?: (key: string) => string | null;
   curve?: d3.CurveFactory;
 }
 
+function dasharrayFor(config: RooflineConfig, key: string): string | null {
+  return config.getDasharray ? config.getDasharray(key) : (config.strokeDasharray ?? null);
+}
+
 interface RooflineEntry<T> {
   key: string;
   points: T[];
@@ -27,7 +33,14 @@ export function renderRooflines<T extends { x: number; y: number }>(
   yScale: ContinuousScale,
   config: RooflineConfig,
 ): void {
-  const { getColor, getOpacity, isVisible, strokeWidth = 2, strokeDasharray } = config;
+  const {
+    getColor,
+    getOpacity,
+    isVisible,
+    strokeWidth = 2,
+    strokeDasharray,
+    getDasharray,
+  } = config;
   const lineGenerator = d3
     .line<T>()
     .x((d) => xScale(d.x))
@@ -60,7 +73,9 @@ export function renderRooflines<T extends { x: number; y: number }>(
     .attr('stroke-width', strokeWidth)
     .attr('d', (d) => lineGenerator(d.points) ?? '');
 
-  if (strokeDasharray) {
+  if (getDasharray) {
+    merged.attr('stroke-dasharray', (d) => getDasharray(d.key));
+  } else if (strokeDasharray) {
     merged.attr('stroke-dasharray', strokeDasharray);
   }
 
@@ -78,12 +93,12 @@ export function updateRooflinesForDisplay(
   zoomGroup: d3.Selection<SVGGElement, unknown, null, undefined>,
   config: RooflineConfig,
 ): void {
-  const { getColor, getOpacity, strokeWidth = 2, strokeDasharray } = config;
+  const { getColor, getOpacity, strokeWidth = 2 } = config;
   zoomGroup
     .selectAll<SVGPathElement, RooflineEntry<{ x: number; y: number }>>('.roofline-path')
     .attr('stroke', (d) => getColor(d.key))
     .attr('stroke-width', strokeWidth)
-    .attr('stroke-dasharray', strokeDasharray ?? null)
+    .attr('stroke-dasharray', (d) => dasharrayFor(config, d.key))
     .each(function (d) {
       const opacity = getOpacity?.(d.key);
       if (opacity !== undefined) d3.select(this).style('opacity', opacity);
diff --git a/packages/app/src/lib/inference-labels.ts b/packages/app/src/lib/inference-labels.ts
index 7854d7d41..b5cbccba4 100644
--- a/packages/app/src/lib/inference-labels.ts
+++ b/packages/app/src/lib/inference-labels.ts
@@ -40,7 +40,6 @@ export function inferenceFrameworkLabelOverride(
   return override && Date.now() < override.expiresAt ? override.label : undefined;
 }
 
-/** Keep unofficial-run identity/markers while making its special engine visible. */
 /** Leads every unofficial-run label, in line labels and legend rows alike. */
 export const OVERLAY_LABEL_MARKER = '✕ ';
 const RUN_TAG_MAX = 20;
@@ -83,6 +82,7 @@ export function getOverlayLineLabel(
   return `${OVERLAY_LABEL_MARKER}${hardwareLabel}${sharesHardware ? overlayRunTag(run) : ''}`;
 }
 
+/** Keep unofficial-run identity/markers while making its special engine visible. */
 export function getInferenceRunLabel(
   label: string,
   points: readonly (RunProvenance & { framework?: string })[],
diff --git a/packages/app/src/lib/power-basis.ts b/packages/app/src/lib/power-basis.ts
index 034eeca2d..256e63f2a 100644
--- a/packages/app/src/lib/power-basis.ts
+++ b/packages/app/src/lib/power-basis.ts
@@ -75,31 +75,33 @@ export interface PowerBasisInput {
 
 export type PowerBasisValues = Record<PowerBasisFieldKey, number | null>;
 
-const positive = (value: unknown): value is number =>
+export const isPositive = (value: unknown): value is number =>
   typeof value === 'number' && Number.isFinite(value) && value > 0;
-const count = (value: unknown): value is number => positive(value) && Number.isSafeInteger(value);
-const orNull = (value: number): number | null => (positive(value) ? value : null);
+const count = (value: unknown): value is number => isPositive(value) && Number.isSafeInteger(value);
+const orNull = (value: number): number | null => (isPositive(value) ? value : null);
 
 /**
  * Derives the B2–B4 boundary values from plain numbers. Any unavailable input
  * yields `null` for the values that depend on it and leaves the rest intact.
  */
 export function computePowerBasisFields(input: PowerBasisInput): PowerBasisValues {
-  const tdp = positive(input.tdpWatts) ? input.tdpWatts : null;
-  const utility = positive(input.utilityWatts) ? input.utilityWatts : null;
-  const measuredWatts = positive(input.measuredWatts) ? input.measuredWatts : null;
-  const measuredJ = positive(input.measuredJPerOutputToken) ? input.measuredJPerOutputToken : null;
+  const tdp = isPositive(input.tdpWatts) ? input.tdpWatts : null;
+  const utility = isPositive(input.utilityWatts) ? input.utilityWatts : null;
+  const measuredWatts = isPositive(input.measuredWatts) ? input.measuredWatts : null;
+  const measuredJ = isPositive(input.measuredJPerOutputToken)
+    ? input.measuredJPerOutputToken
+    : null;
   // B4 is B1 carried out to the utility meter, so it follows B1's availability:
   // no measured watts, no modeled boundary (B3 ≥ B4 ≥ B1 needs its anchor).
   const modeled =
-    measuredWatts !== null && positive(input.modeledFacilityWattsPerGpu)
+    measuredWatts !== null && isPositive(input.modeledFacilityWattsPerGpu)
       ? input.modeledFacilityWattsPerGpu
       : null;
 
   // Provisioned energy: GPU-seconds spent per output token by the whole
   // deployment (N_alloc ÷ total tok/s) × W per GPU = J per output token.
   const gpuSecondsPerOutputToken =
-    positive(input.allocatedGpus) && positive(input.totalOutputTokPerSec)
+    isPositive(input.allocatedGpus) && isPositive(input.totalOutputTokPerSec)
       ? input.allocatedGpus / input.totalOutputTokPerSec
       : null;
   const provisionedEnergy = (watts: number | null) =>
@@ -154,7 +156,7 @@ export function powerBasisNormalization(
 ): Pick<PowerBasisInput, 'allocatedGpus' | 'totalOutputTokPerSec'> {
   const perGpu = entry.output_tput_per_gpu;
   const unavailable = { allocatedGpus: null, totalOutputTokPerSec: null };
-  if (!positive(perGpu)) return unavailable;
+  if (!isPositive(perGpu)) return unavailable;
   if (!entry.disagg) return { allocatedGpus: 1, totalOutputTokPerSec: perGpu };
   if (entry.benchmark_type !== 'single_turn') return unavailable;
   const prefill = entry.num_prefill_gpu;
@@ -178,7 +180,7 @@ export function modeledFacilityWattsPerGpu(
 ): number | null {
   const model = entry.modeledSystemPower;
   if (model?.status !== 'supported') return null;
-  if (!positive(model.deploymentFacilityWatts) || !count(model.gpuCount)) return null;
+  if (!isPositive(model.deploymentFacilityWatts) || !count(model.gpuCount)) return null;
   return orNull(model.deploymentFacilityWatts / model.gpuCount);
 }
 
@@ -196,7 +198,7 @@ export function buildPowerBasisChartFields(
 ): PowerBasisChartFields {
   const values = computePowerBasisFields({
     tdpWatts: specs.tdp ?? null,
-    utilityWatts: positive(specs.power) ? specs.power * 1000 : null,
+    utilityWatts: isPositive(specs.power) ? specs.power * 1000 : null,
     ...powerBasisNormalization(entry),
     measuredWatts: entry.avg_power_w ?? null,
     measuredJPerOutputToken: entry.joules_per_output_token ?? null,
diff --git a/packages/app/src/lib/url-state.ts b/packages/app/src/lib/url-state.ts
index 78755aa95..d75f4e736 100644
--- a/packages/app/src/lib/url-state.ts
+++ b/packages/app/src/lib/url-state.ts
@@ -30,6 +30,13 @@ const URL_STATE_KEYS = [
   // Token-revenue sale-price source: normalized $1/M or live OpenRouter catalog.
   'i_revenue',
   'i_pctl',
+  'i_mstat',
+  'i_servicecompare',
+  'i_servicebase',
+  'i_servicepeer',
+  'i_servicetarget',
+  'i_roleshare',
+  'i_powerfit',
   'i_xmetric',
   'i_e2e_xmetric',
   'i_xmode',
@@ -63,6 +70,14 @@ const URL_STATE_KEYS = [
   'i_spec',
   // Measured-power certification tiers ('certified' / 'legacy', comma-joined).
   'i_power',
+  'i_topology',
+  'i_ptlines',
+  'i_ptaxis',
+  'i_ptwindow',
+  'i_ptfocus',
+  'i_ptutility',
+  // Power Timeline concurrency filter: one positive integer, empty = every load.
+  'i_ptconc',
   // Completed Perf Rulers on the primary inference chart: `isoX|curveA|curveB`
   // entries joined by `;` (see serializePerfRulers in d3-chart/layers/perf-ruler).
   'i_rulers',
@@ -156,6 +171,13 @@ export const PARAM_DEFAULTS: Record<UrlStateKey, string> = {
   i_metric: DEFAULT_Y_AXIS_METRIC,
   i_revenue: 'normalized',
   i_pctl: 'p90',
+  i_mstat: 'median',
+  i_servicecompare: '0',
+  i_servicebase: '',
+  i_servicepeer: '',
+  i_servicetarget: '',
+  i_roleshare: '0',
+  i_powerfit: '0',
   i_xmetric: 'p90_ttft',
   i_e2e_xmetric: 'p90_ttft',
   i_xmode: '',
@@ -183,6 +205,13 @@ export const PARAM_DEFAULTS: Record<UrlStateKey, string> = {
   i_disagg: '',
   i_spec: '',
   i_power: '',
+  i_topology: '',
+  i_ptlines: '',
+  i_ptaxis: '',
+  i_ptwindow: '',
+  i_ptfocus: '',
+  i_ptutility: '',
+  i_ptconc: '',
   i_rulers: '',
   i_pcompare: '',
   i_overview_current: '',
diff --git a/packages/app/src/lib/views-api/docs/extensions.ts b/packages/app/src/lib/views-api/docs/extensions.ts
index 150861156..f3d988a70 100644
--- a/packages/app/src/lib/views-api/docs/extensions.ts
+++ b/packages/app/src/lib/views-api/docs/extensions.ts
@@ -129,6 +129,10 @@ const PARAMETER_NOTES: Record<string, [string, string]> = {
     'Comma-separated certified and/or legacy power tiers. Omit for all tiers.',
     '以逗号分隔的 certified、legacy 功率数据等级。省略时选择全部等级。',
   ],
+  topologies: [
+    'Comma-separated exact topology keys from the Dashboard topology selector or view point topologyKey. Filters allocation and parallelism without filtering concurrency; omitted means all. Preserve the keys verbatim. Unknown keys return no matching points.',
+    '逗号分隔的精确拓扑键，取自仪表盘拓扑选择器或数据点的 topologyKey。按 GPU 分配和并行配置筛选，保留全部已测并发；省略时不限制拓扑。原样使用这些键，未知键不会匹配数据点。',
+  ],
   allPoints: [
     'Boolean, default false. Include points clipped by dashboard limits; optimal and best still apply independently.',
     '布尔值，默认为 false。包括被图表范围裁剪的数据点；optimal 和 best 仍独立生效。',
@@ -422,14 +426,14 @@ export const operations: ApiOperation[] = Object.entries(NEW_VIEWS).map(
           view === 'video'
             ? ' Only already published artifacts are read. Cell, phase, slot and GPU-basis choices select result evidence and normalized serving rates; x/y/cost/workload filters produce computed tradeoff points. Local bundles and arbitrary URLs are excluded. Responses are no-store.'
             : view === 'gpu-metrics'
-              ? ' Telemetry reads stored DB series first and falls back to GitHub artifacts when storage is absent. Responses use private, no-store; an upstream database failure remains HTTP 503 rather than an empty dataset. File/host series retain separate identities. Full-record statistics include startup and warmup and use current-version stored per-GPU digests; a current empty or missing metric digest stays empty. Outdated or unversioned digests are recomputed read-only from retained DB samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. Statistics expose the selected metric values without the storage-only metric column. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings.'
+              ? ' Telemetry reads stored DB series first and falls back to GitHub artifacts when storage is absent. Responses use private, no-store; an upstream database failure remains HTTP 503 rather than an empty dataset. File/host series retain separate identities. Full-record statistics include startup and warmup and use current-version stored per-GPU digests; a current empty or missing metric digest stays empty. Outdated or unversioned digests are recomputed read-only from retained DB samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. Statistics expose the selected metric values without the storage-only metric column. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings. This endpoint projects the raw GPU-metrics explorer, not the inference Power Timeline. Timeline role/window evidence comes from its existing series=power read plus benchmark power_audit. Timeline i_ptaxis, i_ptlines, i_ptwindow, i_ptfocus and i_ptutility share fields control client rendering only and are not accepted here; they do not change raw telemetry or full-record statistics.'
               : ''
         }`,
         `只读${zh}，使用仪表板的数据读取和计算函数。未知或重复查询键返回 400；响应包含解析后的参数，保留缺失数据。仅影响样式的控件不作为 API 参数。${
           view === 'video'
             ? ' 仅读取已发布产物。cell、阶段、slot 和 GPU 口径选择对应结果证据，并计算 serving 归一化速率；x/y、成本及工作负载筛选生成权衡图数据点。不读取本地数据包或任意 URL。响应不缓存。'
             : view === 'gpu-metrics'
-              ? ' 遥测优先读取数据库中已存储的序列；缺少存储数据时回退到 GitHub 产物。响应使用 private, no-store；上游数据库故障保留 HTTP 503，不作为空数据返回。各文件、主机的序列身份独立保留。全记录统计包含服务启动与 warmup，已有数据使用当前算法版本的每 GPU 统计摘要；当前摘要为空或缺少所选指标时仍返回空统计数组。旧版本或无版本摘要从保留的 DB 样本只读重算。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。统计项只包含所选指标的数值，不返回数据库内部的 metric 字段。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。'
+              ? ' 遥测优先读取数据库中已存储的序列；缺少存储数据时回退到 GitHub 产物。响应使用 private, no-store；上游数据库故障保留 HTTP 503，不作为空数据返回。各文件、主机的序列身份独立保留。全记录统计包含服务启动与 warmup，已有数据使用当前算法版本的每 GPU 统计摘要；当前摘要为空或缺少所选指标时仍返回空统计数组。旧版本或无版本摘要从保留的 DB 样本只读重算。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。统计项只包含所选指标的数值，不返回数据库内部的 metric 字段。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。 本接口投影原始 GPU-metrics 浏览器，不是推理页的 Power Timeline。时间线通过现有 series=power 读取和基准测试 power_audit 获取角色与窗口证据；i_ptaxis、i_ptlines、i_ptwindow、i_ptfocus 和 i_ptutility 分享字段仅控制客户端显示，本接口不接受这些参数。它们不改变原始遥测或全记录统计。'
               : ''
         }`,
       ),
diff --git a/packages/app/src/lib/views-api/docs/inference.ts b/packages/app/src/lib/views-api/docs/inference.ts
index 3bca9a30b..7dc330dde 100644
--- a/packages/app/src/lib/views-api/docs/inference.ts
+++ b/packages/app/src/lib/views-api/docs/inference.ts
@@ -21,7 +21,13 @@ import {
 
 const VIEWS_GROUP: ApiOperation['group'] = 'views';
 
-const X_MODE_ENUM = ['interactivity', 'ttft', 'e2e', 'e2e-normalized-interactivity'] as const;
+const X_MODE_ENUM = [
+  'interactivity',
+  'ttft',
+  'e2e',
+  'e2e-normalized-interactivity',
+  'concurrency',
+] as const;
 
 const parameters: readonly ApiParameter[] = [
   {
@@ -82,12 +88,24 @@ const parameters: readonly ApiParameter[] = [
     required: false,
     type: 'enum',
     description: text(
-      'X-axis mode. e2e-normalized-interactivity uses persisted derived AgentX metrics; points without eligible derived values are omitted.',
-      'X 轴模式。e2e-normalized-interactivity 使用已持久化的 AgentX 派生指标；没有合格派生值的数据点不参与此视图。',
+      'X-axis mode. concurrency uses observed load levels, with no interpolation or optimization ranking; optimal and best resolve to false. e2e-normalized-interactivity uses persisted derived AgentX metrics; points without eligible derived values are omitted.',
+      'X 轴模式。concurrency 使用实测并发值，不插值、不作优化排名；optimal 和 best 均解析为 false。e2e-normalized-interactivity 使用已持久化的 AgentX 派生指标；没有合格派生值的数据点不参与此视图。',
     ),
     schema: { type: 'string', enum: X_MODE_ENUM, default: 'interactivity' },
     example: 'e2e',
   },
+  {
+    name: 'xstat',
+    location: 'query',
+    required: false,
+    type: 'enum',
+    description: text(
+      'Fixed-sequence service-axis statistic: median (default) or mean. Mean streaming speed is 1 / mean TPOT, not the arithmetic mean of per-request speeds. Mean TTFT and E2E use their recorded mean fields. Missing values are omitted, never replaced with median. Ignored for AgentX and concurrency; params.xstat then resolves to null and xAxis.statistic records the effective percentile or null.',
+      '固定长度工作负载服务轴的统计量：median（默认）或 mean。Mean streaming speed 为 1 / mean TPOT，不是各请求速度的算术平均；mean TTFT 和 E2E 使用各自记录的均值。缺失时不回退到 median。AgentX 和 concurrency 不使用此参数，params.xstat 为 null，xAxis.statistic 返回实际分位数或 null。',
+    ),
+    schema: { type: 'string', enum: ['mean', 'median'], default: 'median' },
+    example: 'mean',
+  },
   {
     name: 'xmetric',
     location: 'query',
@@ -197,14 +215,86 @@ const parameters: readonly ApiParameter[] = [
     schema: { type: 'boolean' },
     example: 'true',
   },
+  {
+    name: 'serviceCompare',
+    location: 'query',
+    required: false,
+    type: 'boolean',
+    description: text(
+      'Include source options, equal-service percentage curves, an optional target comparison and the same-concurrency diagnostic table (matchedConcurrency), using the same helpers as the dashboard. Uses scoped observed points before frontier/best pruning. JSON only.',
+      '返回来源选项、同等服务条件下的百分比对比曲线、可选目标值对比，以及相同并发下的诊断表（matchedConcurrency）；复用仪表板计算逻辑，使用筛选后、前沿和 best 筛选前的实测点。仅支持 JSON。',
+    ),
+    schema: { type: 'boolean', default: false },
+    example: 'true',
+  },
+  {
+    name: 'serviceBaseline',
+    location: 'query',
+    required: false,
+    type: 'string',
+    description: text(
+      'Exact baseline key from serviceSources. Omitted selects the first deterministic source; an unknown explicit key remains unavailable. Percent change is 100 × (comparator / baseline − 1).',
+      'serviceSources 中的完整基准来源键。省略时按确定性顺序选择首项；显式未知键保持不可用。变化百分比为 100 ×（对比值 / 基准值 − 1）。',
+    ),
+    schema: stringSchema,
+    example: 'Exact key returned in serviceSources',
+  },
+  {
+    name: 'serviceComparator',
+    location: 'query',
+    required: false,
+    type: 'string',
+    description: text(
+      'Exact comparator key from serviceSources. Omitted selects the second deterministic source. Keys retain hardware, source run, recipe, topology and workload identity; never replace them with a hardware name.',
+      'serviceSources 中的完整对比来源键。省略时按确定性顺序选择第二项。来源键保留硬件、运行、配置配方、拓扑和工作负载标识，不能用硬件名称代替。',
+    ),
+    schema: stringSchema,
+    example: 'Exact key returned in serviceSources',
+  },
+  {
+    name: 'serviceTarget',
+    location: 'query',
+    required: false,
+    type: 'number',
+    description: text(
+      'Positive finite service-axis target: tok/s/user for streaming speed, seconds for TTFT/E2E. Omitted returns the curve and null target comparison. Numerical linear interpolation is bounded by each exact source; no extrapolation or interpolation across missing metric endpoints. Concurrency is unsupported.',
+      '有限正数服务轴目标：streaming speed 单位为 tok/s/user，TTFT/E2E 单位为秒。省略时返回曲线，目标值对比为 null。仅在各完整来源的实测范围内做数值线性插值，不外推、不跨越缺失指标端点。并发轴不适用。',
+    ),
+    schema: { type: 'number', minimum: Number.MIN_VALUE },
+    example: 40,
+  },
+  {
+    name: 'roleShare',
+    location: 'query',
+    required: false,
+    type: 'boolean',
+    description: text(
+      'Include validated disaggregated prefill/decode energy shares on one output-token denominator, plus rolePoints with each pool’s W/GPU and role-local energy. Uses same-window aggregate J/output ÷ J/input to convert prefill J/input; share denominator is reconstructed prefill + decode energy, not pool-local token counts. Missing/invalid data is omitted or null. JSON only.',
+      '返回通过验证的分离式 prefill/decode 能耗占比，统一使用 output token 分母；rolePoints 另含各池的 W/GPU 和按本池 token 计的能耗。用同窗口总 J/output ÷ J/input 将 prefill J/input 转换为 J/output；占比分母为重建的 prefill + decode 能耗，不使用各池独立的 token 数。缺失或无效的数据会被省略或返回 null，仅支持 JSON。',
+    ),
+    schema: { type: 'boolean', default: false },
+    example: 'true',
+  },
+  {
+    name: 'powerFit',
+    location: 'query',
+    required: false,
+    type: 'boolean',
+    description: text(
+      'Include one ordinary least-squares line per source: measured mean W/GPU = P0 + m × output tok/s per allocated GPU (disaggregated output spread over prefill and decode GPUs). P0 is the zero-output intercept, not measured idle power; m is marginal J/output token. Sources with fewer than 3 distinct output rates return observations with fit null. JSON only.',
+      '按数据源分别返回普通最小二乘拟合：实测平均 W/GPU = P0 + m × 每个已分配 GPU 的输出 tok/s（分离式部署的输出量均摊到 prefill 和 decode GPU）。P0 是零输出截距，不是实测空载功耗；m 是每个输出 token 的边际能耗（J）。不同输出速率少于 3 个的数据源返回观测点，fit 为 null。仅支持 JSON。',
+    ),
+    schema: { type: 'boolean', default: false },
+    example: 'true',
+  },
   {
     name: 'format',
     location: 'query',
     required: false,
     type: 'enum',
     description: text(
-      'Response encoding. csv returns one flat row per point.',
-      '响应编码。csv 为每个数据点返回一行平面数据。',
+      'Response encoding. csv returns one flat row per plotted point; serviceCompare, roleShare and powerFit panels require JSON and return 400 with CSV.',
+      '响应编码。csv 为每个图表点返回一行平面数据；serviceCompare、roleShare 和 powerFit 面板仅支持 JSON，与 CSV 同用时返回 400。',
     ),
     schema: { type: 'string', enum: ['json', 'csv'], default: 'json' },
     example: 'csv',
@@ -218,6 +308,7 @@ const pointSchema = objectSchema(
     x: numberSchema,
     y: numberSchema,
     concurrency: numberSchema,
+    topologyKey: stringSchema,
     tp: numberSchema,
     date: { type: 'string', format: 'date' },
     runId: integerSchema,
@@ -225,7 +316,7 @@ const pointSchema = objectSchema(
     bestPerSku: booleanSchema,
     metrics: { type: 'object', additionalProperties: numberSchema },
   },
-  ['x', 'y', 'concurrency', 'tp', 'date', 'frontier', 'bestPerSku', 'metrics'],
+  ['x', 'y', 'concurrency', 'topologyKey', 'tp', 'date', 'frontier', 'bestPerSku', 'metrics'],
 );
 
 const seriesSchema = objectSchema(
@@ -254,6 +345,79 @@ const seriesSchema = objectSchema(
   ],
 );
 
+const sourceSchema = objectSchema({ key: stringSchema, label: stringSchema }, ['key', 'label']);
+const identitySchema = objectSchema({
+  id: { type: ['integer', 'null'] },
+  sourceKey: stringSchema,
+  hwKey: stringSchema,
+  precision: stringSchema,
+  concurrency: numberSchema,
+  topologyKey: stringSchema,
+  date: stringSchema,
+  runUrl: { type: ['string', 'null'] },
+  recipeFingerprint: { type: ['string', 'null'] },
+  image: { type: ['string', 'null'] },
+});
+const estimateSchema = {
+  ...objectSchema({
+    value: numberSchema,
+    interpolated: booleanSchema,
+    endpoints: arraySchema(
+      objectSchema({ x: numberSchema, value: numberSchema, point: identitySchema }),
+    ),
+  }),
+  type: ['object', 'null'] as const,
+};
+const serviceMetricSchema = objectSchema({
+  baseline: estimateSchema,
+  comparator: estimateSchema,
+  changePercent: { type: ['number', 'null'] },
+  reason: stringSchema,
+});
+const comparisonSchema = objectSchema({
+  target: numberSchema,
+  xField: stringSchema,
+  baseline: { ...sourceSchema, type: ['object', 'null'] },
+  comparator: { ...sourceSchema, type: ['object', 'null'] },
+  reason: stringSchema,
+  metrics: objectSchema({
+    meanWattsPerGpu: { ...serviceMetricSchema, description: 'Mean measured GPU board W/GPU.' },
+    outputTokensPerSecond: {
+      ...serviceMetricSchema,
+      description:
+        'Whole-deployment output tokens/s; disaggregated GPU-count normalization preserves the workload denominator.',
+    },
+    joulesPerOutputToken: {
+      ...serviceMetricSchema,
+      description: 'Validated measured GPU joules per output token.',
+    },
+  }),
+});
+
+const nullableNumber = (description: string) => ({
+  type: ['number', 'null'] as const,
+  description,
+});
+const matchedValuesSchema = objectSchema({
+  joulesPerOutputToken: { type: ['number', 'null'] },
+  meanWattsPerGpu: { type: ['number', 'null'] },
+  interactivity: { type: ['number', 'null'] },
+});
+const matchedSideSchema = objectSchema(
+  {
+    status: {
+      type: 'string',
+      enum: ['observed', 'missing', 'ambiguous'],
+      description:
+        'observed: one agreeing observation; missing: none at this concurrency; ambiguous: conflicting observations, none chosen.',
+    },
+    values: matchedValuesSchema,
+    point: identitySchema,
+    points: arraySchema(identitySchema),
+  },
+  ['status'],
+);
+
 const responseSchema = objectSchema(
   {
     view: { type: 'string', enum: ['inference'] },
@@ -274,12 +438,17 @@ const responseSchema = objectSchema(
       },
       ['key', 'configKey', 'label', 'labelZh'],
     ),
-    xAxis: objectSchema({ mode: stringSchema, field: stringSchema, label: stringSchema }),
+    xAxis: objectSchema({
+      mode: stringSchema,
+      field: stringSchema,
+      label: stringSchema,
+      statistic: { type: ['string', 'null'] },
+    }),
     frontier: objectSchema({
       direction: {
         type: ['string', 'null'],
         description:
-          'Selected boundary direction. Measured-power gauges use upper_right for interactivity or upper_left for latency, independently of metric.direction.',
+          'Selected boundary direction; null for observed concurrency, which has no preferred direction. Measured-power gauges use upper_right for interactivity or upper_left for latency, independently of metric.direction.',
       },
       points: integerSchema,
     }),
@@ -291,6 +460,91 @@ const responseSchema = objectSchema(
     ),
     series: arraySchema(seriesSchema),
     count: integerSchema,
+    serviceSources: arraySchema(sourceSchema),
+    equalServiceComparison: { ...comparisonSchema, type: ['object', 'null'] },
+    equalServiceCurve: arraySchema(comparisonSchema),
+    roleEnergyShares: arraySchema(
+      objectSchema({
+        x: numberSchema,
+        sourceKey: stringSchema,
+        point: identitySchema,
+        prefill: { ...numberSchema, description: 'Prefill energy in J/output token.' },
+        decode: { ...numberSchema, description: 'Decode energy in J/output token.' },
+        total: {
+          ...numberSchema,
+          description: 'Reconstructed prefill + decode energy in J/output token.',
+        },
+        prefillShare: {
+          ...numberSchema,
+          description: 'Prefill percentage of reconstructed total.',
+        },
+        decodeShare: { ...numberSchema, description: 'Decode percentage of reconstructed total.' },
+      }),
+    ),
+    matchedConcurrency: objectSchema({
+      baseline: { ...sourceSchema, type: ['object', 'null'] },
+      comparator: { ...sourceSchema, type: ['object', 'null'] },
+      interactivityField: stringSchema,
+      reason: { type: 'string', enum: ['same-source', 'unknown-source'] },
+      rows: arraySchema(
+        objectSchema({
+          concurrency: integerSchema,
+          baseline: matchedSideSchema,
+          comparator: matchedSideSchema,
+          changePercent: {
+            ...matchedValuesSchema,
+            description:
+              '100 × (comparator / baseline − 1); null unless both values were observed.',
+          },
+        }),
+      ),
+    }),
+    rolePoints: arraySchema(
+      objectSchema({
+        x: numberSchema,
+        sourceKey: stringSchema,
+        point: identitySchema,
+        prefillWattsPerGpu: nullableNumber('Mean W/GPU inside the prefill pool.'),
+        decodeWattsPerGpu: nullableNumber('Mean W/GPU inside the decode pool.'),
+        prefillJoulesPerInputToken: nullableNumber('Prefill-pool joules per input token.'),
+        decodeJoulesPerOutputToken: nullableNumber('Decode-pool joules per output token.'),
+        energy: {
+          ...objectSchema({
+            prefill: numberSchema,
+            decode: numberSchema,
+            total: numberSchema,
+            prefillShare: numberSchema,
+          }),
+          type: ['object', 'null'],
+          description: 'Both pools on the output-token denominator (J/output token, share %).',
+        },
+      }),
+    ),
+    powerFits: arraySchema(
+      objectSchema({
+        source: sourceSchema,
+        tdpWatts: nullableNumber('Rated board TDP per GPU; P0 ÷ TDP = fit.intercept / tdpWatts.'),
+        fit: {
+          ...objectSchema({
+            intercept: { ...numberSchema, description: 'P0, W/GPU at zero output (extrapolated).' },
+            slope: { ...numberSchema, description: 'm, J per output token.' },
+            rSquared: { type: ['number', 'null'] },
+            n: integerSchema,
+            xMin: numberSchema,
+            xMax: numberSchema,
+          }),
+          type: ['object', 'null'],
+        },
+        reason: { type: 'string', enum: ['too-few-points'] },
+        observations: arraySchema(
+          objectSchema({
+            x: { ...numberSchema, description: 'Output tok/s per allocated GPU.' },
+            y: { ...numberSchema, description: 'Measured mean W/GPU.' },
+            point: identitySchema,
+          }),
+        ),
+      }),
+    ),
     pricing: { type: ['object', 'null'], additionalProperties: true },
     comparisons: arraySchema({ type: 'object', additionalProperties: true }),
     overlays: arraySchema({ type: 'object', additionalProperties: true }),
@@ -307,6 +561,7 @@ const responseExample = {
     precisions: ['fp8'],
     metric: 'y_tpPerGpu',
     xmode: 'interactivity',
+    xstat: 'median',
     xmetric: 'p90_ttft',
     percentile: 'p90',
     date: null,
@@ -316,9 +571,16 @@ const responseExample = {
     frameworks: [],
     deployment: [],
     spec: [],
+    topologies: [],
     optimal: true,
     best: true,
     format: 'json',
+    serviceCompare: false,
+    serviceBaseline: null,
+    serviceComparator: null,
+    serviceTarget: null,
+    roleShare: false,
+    powerFit: false,
   },
   metric: {
     key: 'tpPerGpu',
@@ -332,6 +594,7 @@ const responseExample = {
   xAxis: {
     mode: 'interactivity',
     field: 'median_intvty',
+    statistic: 'median',
     label: 'Median Interactivity (tok/s/user)',
   },
   frontier: { direction: 'upper_left', points: 14 },
@@ -352,6 +615,7 @@ const responseExample = {
           x: 12.5,
           y: 450.5,
           concurrency: 64,
+          topologyKey: 'Single|GPU=8|DP=?|TP=8|EP=1|PP=?|DCP=?|PCP=?|DPA=0|offload=off',
           tp: 8,
           date: '2026-08-20',
           runId: 12345678,
@@ -380,7 +644,7 @@ const responses: readonly ApiResponse[] = [
         mediaType: 'text/csv',
         schema: stringSchema,
         example:
-          'hwKey,gpu,framework,specMethod,label,vendor,deployment,kvOffload,x,y,concurrency,tp,date,runId,frontier,bestPerSku,metric_tpPerGpu\r\nh200_trt,h200,trt,none,H200 (TRTLLM),NVIDIA,single-node,false,12.5,450.5,64,8,2026-08-20,12345678,true,true,450.5',
+          'hwKey,gpu,framework,specMethod,label,vendor,deployment,kvOffload,x,y,concurrency,topologyKey,tp,date,runId,frontier,bestPerSku,metric_tpPerGpu\r\nh200_trt,h200,trt,none,H200 (TRTLLM),NVIDIA,single-node,false,12.5,450.5,64,Single|GPU=8|DP=?|TP=8|EP=1|PP=?|DCP=?|PCP=?|DPA=0|offload=off,8,2026-08-20,12345678,true,true,450.5',
       },
     ],
   },
diff --git a/packages/app/src/lib/views-api/docs/options.ts b/packages/app/src/lib/views-api/docs/options.ts
index bfd72e0be..6d7b24ec3 100644
--- a/packages/app/src/lib/views-api/docs/options.ts
+++ b/packages/app/src/lib/views-api/docs/options.ts
@@ -78,6 +78,7 @@ const responseSchema = objectSchema(
     specMethods: arraySchema(stringSchema),
     percentiles: arraySchema(stringSchema),
     xAxisModes: arraySchema(stringSchema),
+    fixedSequenceStatistics: arraySchema(stringSchema),
     scaleModes: arraySchema(stringSchema),
     metrics: arraySchema(
       objectSchema({
@@ -157,6 +158,7 @@ const responseExample = {
   specMethods: ['mtp', 'none'],
   percentiles: ['p75', 'p90'],
   xAxisModes: ['interactivity', 'ttft', 'e2e', 'e2e-normalized-interactivity'],
+  fixedSequenceStatistics: ['median', 'mean'],
   scaleModes: ['auto', 'linear', 'log'],
   metrics: [
     {
@@ -183,6 +185,10 @@ const responseExample = {
     metric: 'y_tokensPerDollarH',
     percentile: 'p90',
     xmode: 'interactivity',
+    xstat: 'median',
+    serviceCompare: false,
+    roleShare: false,
+    powerFit: false,
   },
 };
 
diff --git a/packages/app/src/lib/views-api/registry.ts b/packages/app/src/lib/views-api/registry.ts
index 754c216a5..26f23064d 100644
--- a/packages/app/src/lib/views-api/registry.ts
+++ b/packages/app/src/lib/views-api/registry.ts
@@ -139,6 +139,7 @@ export const VIEW_QUERY_PARAMS = {
     'vendors',
   ],
   inference: [
+    'topologies',
     'allPoints',
     'best',
     'date',
@@ -166,6 +167,13 @@ export const VIEW_QUERY_PARAMS = {
     'vendors',
     'xmetric',
     'xmode',
+    'xstat',
+    'serviceCompare',
+    'serviceBaseline',
+    'serviceComparator',
+    'serviceTarget',
+    'roleShare',
+    'powerFit',
   ],
   options: ['format'],
   overview: ['compare', 'engine', 'format', 'hwrows', 'models', 'ref', 'rows', 'tier'],
diff --git a/packages/app/src/lib/views-api/series.ts b/packages/app/src/lib/views-api/series.ts
index acdb88abe..54cc033e4 100644
--- a/packages/app/src/lib/views-api/series.ts
+++ b/packages/app/src/lib/views-api/series.ts
@@ -30,7 +30,11 @@ import {
   upperPowerEnvelope,
 } from '@/components/inference/utils/powerCurves';
 import { pointDeploymentMode, type QuickFilters } from '@/components/inference/utils/quickFilters';
-import { resolveXAxisField } from '@/components/inference/utils/resolveXAxisField';
+import { pointTopologyKey } from '@/components/inference/utils/topology-filter';
+import {
+  resolveXAxisField,
+  type FixedSequenceStatistic,
+} from '@/components/inference/utils/resolveXAxisField';
 import type { DerivedAgenticMetricMap } from '@/hooks/api/use-derived-agentic-metrics';
 import type { BenchmarkRow } from '@/lib/api';
 import { transformBenchmarkRows } from '@/lib/benchmark-transform';
@@ -61,7 +65,12 @@ import { hardwareLegendLabel, unitFromLabel } from '@/lib/views-api/legend';
 
 /** X-axis modes the API serves. `e2e-normalized-interactivity` is trace-derived
  * client-side and has no server-side data source, so it is not accepted here. */
-export type SeriesXMode = 'interactivity' | 'ttft' | 'e2e' | 'e2e-normalized-interactivity';
+export type SeriesXMode =
+  | 'interactivity'
+  | 'ttft'
+  | 'e2e'
+  | 'e2e-normalized-interactivity'
+  | 'concurrency';
 
 export interface InferenceSeriesOptions {
   readonly sequence: Sequence;
@@ -71,6 +80,8 @@ export interface InferenceSeriesOptions {
   readonly precisions: readonly string[];
   readonly metricConfigKey: MetricConfigKey;
   readonly xmode: SeriesXMode;
+  /** Fixed-sequence service-axis statistic; ignored for Agentic and concurrency. */
+  readonly fixedSequenceStatistic?: FixedSequenceStatistic;
   /** TTFT x metric override (e.g. `p90_ttft`); used by `ttft` mode and input metrics. */
   readonly xmetric: string;
   /** Explicit hwKey / bare-GPU selection; empty = all. */
@@ -94,6 +105,7 @@ export interface InferenceSeriesPoint {
   readonly x: number;
   readonly y: number;
   readonly concurrency: number;
+  readonly topologyKey: string;
   readonly tp: number;
   readonly date: string;
   readonly runId?: number;
@@ -130,7 +142,9 @@ export interface InferenceSeriesResult {
   readonly hardware: readonly { key: string; label: string; vendor?: string }[];
   readonly frontier: { direction: ParetoDirection | null; points: number };
   readonly metric: InferenceSeriesMetricMeta;
-  readonly xAxis: { mode: SeriesXMode; field: string; label: string };
+  readonly xAxis: { mode: SeriesXMode; field: string; label: string; statistic: string | null };
+  /** Scoped observed points before frontier/best-only pruning; not a public raw-row payload. */
+  readonly observedPoints: readonly InferenceData[];
   readonly count: number;
 }
 
@@ -171,16 +185,19 @@ function resolveXAxisLabel(
   effectiveXMetric: string | null,
   isAgentic: boolean,
   percentile: string,
+  xAxisField: string,
 ): string {
+  if (branch === 'concurrency') return 'Concurrency';
   let label = chartDef.x_label;
   if (branch === 'e2e-ttft-override') {
     const pctl = (effectiveXMetric ?? 'p90_ttft').replace(/_ttft$/u, '');
     const pctlWord = pctl === 'median' ? 'Median' : pctl.toUpperCase();
     label = `${pctlWord} Time To First Token (s)`;
   }
-  if (isAgentic) {
-    label = applyAgenticPercentileToXLabel(label, percentile.toUpperCase());
-  }
+  label = applyAgenticPercentileToXLabel(
+    label,
+    isAgentic ? percentile.toUpperCase() : xAxisField.startsWith('mean_') ? 'Mean' : 'Median',
+  );
   return label;
 }
 
@@ -221,6 +238,7 @@ export function buildInferenceSeries(
     isAgentic,
     percentile,
     xAxisMode: xmode,
+    fixedSequenceStatistic: options.fixedSequenceStatistic,
   });
 
   // 4. Precision + scope filters (GPU picks and vendor/framework/deployment/spec pills).
@@ -259,10 +277,15 @@ export function buildInferenceSeries(
   const remapped = scoped
     .filter((point) => metricKey in point && supportsPointTokenMetric(point, tokenType))
     .map((point) => remapInferencePoint(point, metricKey, resolved.xAxisField));
-  const partition = partitionChartDataByLimits(remapped, chartDef, metricConfigKey, {
-    isTtftX: resolved.xAxisField.endsWith('_ttft'),
-    isAgentic,
-  });
+  const partition = partitionChartDataByLimits(
+    remapped,
+    { ...chartDef, x_scale_field: resolved.xAxisField },
+    metricConfigKey,
+    {
+      isTtftX: resolved.xAxisField.endsWith('_ttft'),
+      isAgentic,
+    },
+  );
   let mapped = options.allPoints ? remapped : partition.data;
   if (xmode === 'e2e-normalized-interactivity')
     mapped = mapped.flatMap((point) => {
@@ -280,19 +303,24 @@ export function buildInferenceSeries(
     resolved.xAxisField !== resolved.naturalX &&
     !(chartDef.chartType === 'e2e' && resolved.isTtftOverride);
   const direction =
-    configuredDirection && xAxisFlipped
-      ? flipRooflineDirection(configuredDirection)
-      : (configuredDirection ?? null);
+    xmode === 'concurrency'
+      ? null
+      : configuredDirection && xAxisFlipped
+        ? flipRooflineDirection(configuredDirection)
+        : (configuredDirection ?? null);
 
   // 7. Frontier flags, scoped per (hwKey, precision, date) like ScatterGraph.
   // Measured power represents load demand, so retain its upper boundary.
   const isMeasuredPower = isMeasuredPowerCurveMetric(metricConfigKey);
   const maximizePowerX = chartDef.chartType !== 'e2e';
-  const frontierDirection = isMeasuredPower
-    ? maximizePowerX
-      ? 'upper_right'
-      : 'upper_left'
-    : direction;
+  const frontierDirection =
+    xmode === 'concurrency'
+      ? null
+      : isMeasuredPower
+        ? maximizePowerX
+          ? 'upper_right'
+          : 'upper_left'
+        : direction;
   const frontierPoints = new Set<InferenceData>();
   if (direction) {
     const frontierFn = paretoFrontForDirection(direction);
@@ -334,7 +362,10 @@ export function buildInferenceSeries(
     if (best && bestHwKeys.size > 0 && !seriesIsBest) continue;
 
     const allPoints = byHwKey.get(hwKey)!;
-    const kept = optimal ? allPoints.filter((point) => frontierPoints.has(point)) : allPoints;
+    const kept =
+      optimal && xmode !== 'concurrency'
+        ? allPoints.filter((point) => frontierPoints.has(point))
+        : allPoints;
     if (kept.length === 0) continue;
 
     const sample = kept[0];
@@ -363,6 +394,7 @@ export function buildInferenceSeries(
           x: point.x,
           y: point.y,
           concurrency: point.conc ?? 0,
+          topologyKey: pointTopologyKey(point),
           tp: point.tp ?? 0,
           date: point.date ?? '',
           ...(runIdFromUrl(point.run_url) === undefined
@@ -396,6 +428,12 @@ export function buildInferenceSeries(
     },
     xAxis: {
       mode: xmode,
+      statistic:
+        xmode === 'concurrency'
+          ? null
+          : isAgentic
+            ? percentile
+            : (options.fixedSequenceStatistic ?? 'median'),
       field:
         xmode === 'e2e-normalized-interactivity'
           ? `${percentile}_e2e_norm_intvty`
@@ -403,8 +441,16 @@ export function buildInferenceSeries(
       label:
         xmode === 'e2e-normalized-interactivity'
           ? `${percentile.toUpperCase()} E2E Normalized Interactivity (tok/s/user)`
-          : resolveXAxisLabel(chartDef, resolved.branch, effectiveXMetric, isAgentic, percentile),
+          : resolveXAxisLabel(
+              chartDef,
+              resolved.branch,
+              effectiveXMetric,
+              isAgentic,
+              percentile,
+              String(resolved.xAxisField),
+            ),
     },
+    observedPoints: mapped,
     count,
   };
 }
diff --git a/packages/app/timings.json b/packages/app/timings.json
index 2979c5996..df735201a 100644
--- a/packages/app/timings.json
+++ b/packages/app/timings.json
@@ -236,6 +236,14 @@
       "spec": "cypress/e2e/performance.cy.ts",
       "duration": 2377
     },
+    {
+      "spec": "cypress/e2e/powerx-timeline.cy.ts",
+      "duration": 4000
+    },
+    {
+      "spec": "cypress/e2e/powerx-compare.cy.ts",
+      "duration": 4000
+    },
     {
       "spec": "cypress/e2e/profit-estimator.cy.ts",
       "duration": 39450
diff --git a/packages/db/src/backfill-gpu-metrics.ts b/packages/db/src/backfill-gpu-metrics.ts
index cb898f0d8..fdab1e2da 100644
--- a/packages/db/src/backfill-gpu-metrics.ts
+++ b/packages/db/src/backfill-gpu-metrics.ts
@@ -77,6 +77,7 @@ import { repositoryFromRunUrl } from './lib/runtime-metadata-artifacts.js';
 
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 const GITHUB_RETENTION_DAYS = 90;
+const GITHUB_RETENTION_MS = GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000;
 const sql = createAdminSql({ noSsl: hasNoSslFlag(), max: 4, onnotice: () => {} });
 
 interface CandidateRun {
@@ -142,8 +143,7 @@ function parseFlags(): BackfillFlags {
 }
 
 function isWithinGithubRetention(date: string): boolean {
-  const ageMs = Date.now() - new Date(date).getTime();
-  return ageMs <= GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+  return Date.now() - new Date(date).getTime() <= GITHUB_RETENTION_MS;
 }
 
 async function loadCandidateRuns(
@@ -151,9 +151,7 @@ async function loadCandidateRuns(
   limit: number | null,
   force: boolean,
 ): Promise<CandidateRun[]> {
-  const cutoff = new Date(Date.now() - GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000)
-    .toISOString()
-    .slice(0, 10);
+  const cutoff = new Date(Date.now() - GITHUB_RETENTION_MS).toISOString().slice(0, 10);
   const since = flags.since ?? cutoff;
   const rows = await sql<CandidateRun[]>`
     select wr.id, wr.github_run_id, wr.run_attempt, wr.html_url, wr.date::text as date,
@@ -231,13 +229,13 @@ async function processPair(
     const matchedIds: number[] = [];
     const mappedPoints: { ids: number[]; identity: Record<string, unknown> }[] = [];
     for (const row of mappedRows) {
+      const identity = benchmarkPublicationIdentity(row);
       const ids = await findBenchmarkResultIds(sql, run, [row], (id) =>
-        uniqueFallbacks.set(stablePowerPointIdentity(benchmarkPublicationIdentity(row)), id),
+        uniqueFallbacks.set(stablePowerPointIdentity(identity), id),
       );
       if (ids.length === 0) throw new Error(`${pair.gpuMetrics.name}: no matching benchmark rows`);
       matchedIds.push(...ids);
-      if (row.benchmarkType === 'agentic_traces')
-        mappedPoints.push({ ids, identity: benchmarkPublicationIdentity(row) });
+      if (row.benchmarkType === 'agentic_traces') mappedPoints.push({ ids, identity });
     }
     const resultIds = [...new Set(matchedIds)];
     if (resultIds.length === 0) {
@@ -290,16 +288,14 @@ async function processPair(
       metadataUpdatedBenchmarkResultIds: ingested.metadataUpdatedBenchmarkResultIds,
     };
   } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
     if (pointKeys.length === 0)
       expectationErrors.push({
         benchmarkArtifact: pair.benchmarks.name,
         artifactNames: [pair.gpuMetrics.name],
-        error: error instanceof Error ? error.message : String(error),
+        error: message,
       });
-    for (const key of pointKeys) {
-      const observation = observations.get(key)!;
-      observation.error = error instanceof Error ? error.message : String(error);
-    }
+    for (const key of pointKeys) observations.get(key)!.error = message;
     console.error(`  ✗ run ${run.github_run_id} artifact ${pair.gpuMetrics.name}:`, error);
     return { kind: 'failed' };
   } finally {
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.ts b/packages/db/src/etl/gpu-metrics-artifacts.ts
index d101976e4..ca38bb55d 100644
--- a/packages/db/src/etl/gpu-metrics-artifacts.ts
+++ b/packages/db/src/etl/gpu-metrics-artifacts.ts
@@ -77,19 +77,20 @@ function isGpuMetricsCsvName(fileName: string): boolean {
   return !lower.includes('_identity') && !lower.includes('_energy_');
 }
 
-/** Recursively list every telemetry CSV under an extracted artifact root. */
-export function listGpuMetricsCsvFiles(root: string): GpuMetricsCsvFile[] {
+/** Recursively list the files under `root` whose POSIX-relative name passes `matches`. */
+function listFiles(
+  root: string,
+  matches: (fileName: string, baseName: string) => boolean,
+): GpuMetricsCsvFile[] {
   if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return [];
   const files: GpuMetricsCsvFile[] = [];
   const visit = (directory: string): void => {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
       const pathname = path.join(directory, entry.name);
       if (entry.isDirectory()) visit(pathname);
-      else if (entry.isFile() && isGpuMetricsCsvName(entry.name)) {
-        files.push({
-          fileName: path.relative(root, pathname).split(path.sep).join('/'),
-          path: pathname,
-        });
+      else if (entry.isFile()) {
+        const fileName = path.relative(root, pathname).split(path.sep).join('/');
+        if (matches(fileName, entry.name)) files.push({ fileName, path: pathname });
       }
     }
   };
@@ -97,30 +98,19 @@ export function listGpuMetricsCsvFiles(root: string): GpuMetricsCsvFile[] {
   return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
 }
 
+/** Recursively list every telemetry CSV under an extracted artifact root. */
+export function listGpuMetricsCsvFiles(root: string): GpuMetricsCsvFile[] {
+  return listFiles(root, (_fileName, baseName) => isGpuMetricsCsvName(baseName));
+}
+
 /** Every multinode power CSV under an extracted `power_audit_` root. */
 export function listMultinodePowerSampleFiles(root: string): GpuMetricsCsvFile[] {
-  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return [];
-  const files: GpuMetricsCsvFile[] = [];
-  const visit = (directory: string): void => {
-    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const pathname = path.join(directory, entry.name);
-      if (entry.isDirectory()) visit(pathname);
-      else if (entry.isFile()) {
-        const fileName = path.relative(root, pathname).split(path.sep).join('/');
-        if (isMultinodePowerSamplesPath(fileName)) files.push({ fileName, path: pathname });
-      }
-    }
-  };
-  visit(root);
-  return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
+  return listFiles(root, isMultinodePowerSamplesPath);
 }
 
 /** The producer manifest next to `samples.csv`; null when absent or malformed. */
 export function readMultinodePowerManifest(samplesPath: string): Record<string, unknown> | null {
-  const parsed = readJsonIfPresent(path.join(path.dirname(samplesPath), 'manifest.json'));
-  return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
-    ? (parsed as Record<string, unknown>)
-    : null;
+  return readJsonObjectIfPresent(path.join(path.dirname(samplesPath), 'manifest.json'));
 }
 
 /** Preserve window boundaries and role overrides before GitHub artifact expiry. */
@@ -167,6 +157,14 @@ function readJsonIfPresent(pathname: string): unknown | null {
   }
 }
 
+/** Like `readJsonIfPresent`, but only a plain JSON object counts as present. */
+function readJsonObjectIfPresent(pathname: string): Record<string, unknown> | null {
+  const parsed = readJsonIfPresent(pathname);
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+    ? (parsed as Record<string, unknown>)
+    : null;
+}
+
 /** `gpu,total_energy_consumption` two-column CSV → { "<gpu>": joules }. */
 export function parseEnergyCsv(text: string): Record<string, number> | null {
   const lines = text
@@ -217,11 +215,8 @@ export function readGpuMetricsSidecars(csvPath: string): GpuMetricsSidecars {
     )
     .sort();
   for (const entry of contextFiles) {
-    const parsed = readJsonIfPresent(path.join(dir, entry));
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
-      context = parsed as Record<string, unknown>;
-      break;
-    }
+    context = readJsonObjectIfPresent(path.join(dir, entry));
+    if (context) break;
   }
   const energyStartPath = path.join(dir, 'gpu_metrics_energy_start.csv');
   const energyEndPath = path.join(dir, 'gpu_metrics_energy_end.csv');
diff --git a/packages/db/src/etl/gpu-metrics-csv.ts b/packages/db/src/etl/gpu-metrics-csv.ts
index 35ec33e57..135fa5cef 100644
--- a/packages/db/src/etl/gpu-metrics-csv.ts
+++ b/packages/db/src/etl/gpu-metrics-csv.ts
@@ -139,7 +139,7 @@ export function parseAmdTimestamp(raw: string): number | null {
   return Number.isFinite(iso) ? iso : null;
 }
 
-function emptySample(timestampMs: number, gpuIndex: number): GpuMetricSample {
+export function emptySample(timestampMs: number, gpuIndex: number): GpuMetricSample {
   return {
     timestampMs,
     gpuIndex,
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
index a00fe9872..9e9acabbe 100644
--- a/packages/db/src/etl/gpu-metrics-ingest.ts
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -23,9 +23,6 @@ import {
 export { statMetricColumn } from '../lib/gpu-metric-stats.js';
 
 import type { Sql } from './db-utils.js';
-
-/** Either a pooled client or the transaction handle passed to `sql.begin` callbacks. */
-type TxLike = Sql | postgres.TransactionSql;
 import {
   computeGpuMetricStats,
   parseGpuMetricsCsv,
@@ -37,6 +34,7 @@ import {
 import {
   contextUtcOffsetMinutes,
   gpuMetricsArtifactSuffix,
+  isPowerAuditArtifact,
   listGpuMetricsCsvFiles,
   listMultinodePowerSampleFiles,
   readGpuMetricsSidecars,
@@ -48,6 +46,9 @@ import {
 import { multinodePowerVendor, parseMultinodePowerSamples } from './multinode-power-samples.js';
 import { recoveredPowerAudit } from './power-audit-validations.js';
 
+/** Either a pooled client or the transaction handle passed to `sql.begin` callbacks. */
+type TxLike = Sql | postgres.TransactionSql;
+
 /** Samples are streamed to Postgres in unnest batches of this many rows. */
 const SAMPLE_BATCH_SIZE = 5000;
 
@@ -82,6 +83,25 @@ export interface GpuMetricsIngestResult {
   metadataUpdatedBenchmarkResultIds: number[];
 }
 
+/** Dedupe, window and digest one CSV's samples; null when nothing usable remains. */
+function digestSeries(
+  base: Pick<PreparedGpuMetricSeries, 'fileName' | 'vendor' | 'csvSha256' | 'sidecars'>,
+  rawSamples: readonly GpuMetricSample[],
+): PreparedGpuMetricSeries | null {
+  const samples = uniqueSamples(rawSamples);
+  const summary = summarizeGpuMetricSamples(samples);
+  if (!summary) return null;
+  return {
+    ...base,
+    samples,
+    stats: computeGpuMetricStats(samples),
+    sampleIntervalS: summary.sampleIntervalS,
+    gpuCount: summary.gpuCount,
+    startedAtMs: summary.startedAtMs,
+    endedAtMs: summary.endedAtMs,
+  };
+}
+
 /**
  * One series per host from the multinode power bundle. The deployment-wide
  * CSV is hashed once, so every host series of one upload shares its source sha.
@@ -99,31 +119,26 @@ function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuM
     const vendor = multinodePowerVendor(manifest);
     const csvSha256 = createHash('sha256').update(csvText).digest('hex');
     for (const host of hosts) {
-      const samples = uniqueSamples(host.samples);
-      const summary = summarizeGpuMetricSamples(samples);
-      if (!summary) continue;
-      prepared.push({
-        fileName: `${file.fileName}#${host.hostname}`,
-        vendor,
-        csvSha256,
-        samples,
-        stats: computeGpuMetricStats(samples),
-        sampleIntervalS: summary.sampleIntervalS,
-        gpuCount: summary.gpuCount,
-        startedAtMs: summary.startedAtMs,
-        endedAtMs: summary.endedAtMs,
-        sidecars: {
-          context: manifest,
-          validations,
-          identity: Object.entries(host.gpuUuids).map(([index, uuid]) => ({
-            hostname: host.hostname,
-            gpu_index: Number(index),
-            gpu_uuid: uuid,
-          })),
-          energyStart: null,
-          energyEnd: null,
+      const series = digestSeries(
+        {
+          fileName: `${file.fileName}#${host.hostname}`,
+          vendor,
+          csvSha256,
+          sidecars: {
+            context: manifest,
+            validations,
+            identity: Object.entries(host.gpuUuids).map(([index, uuid]) => ({
+              hostname: host.hostname,
+              gpu_index: Number(index),
+              gpu_uuid: uuid,
+            })),
+            energyStart: null,
+            energyEnd: null,
+          },
         },
-      });
+        host.samples,
+      );
+      if (series) prepared.push(series);
     }
   }
   return prepared;
@@ -139,7 +154,7 @@ export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): Prepare
   for (const file of listGpuMetricsCsvFiles(artifact.artifactDir)) {
     const csvText = fs.readFileSync(file.path, 'utf8');
     const sidecars = readGpuMetricsSidecars(file.path);
-    if (artifact.artifactName.startsWith('power_audit_')) {
+    if (isPowerAuditArtifact(artifact.artifactName)) {
       sidecars.validations = readPowerAuditValidations(artifact.artifactDir, artifact.artifactName);
       const bundleFile = listMultinodePowerSampleFiles(artifact.artifactDir)[0];
       sidecars.powerManifest = bundleFile ? readMultinodePowerManifest(bundleFile.path) : null;
@@ -147,28 +162,22 @@ export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): Prepare
     const parsed = parseGpuMetricsCsv(csvText, {
       nvidiaUtcOffsetMinutes: contextUtcOffsetMinutes(sidecars.context),
     });
-    if (!parsed) {
-      unreadable.push(file.fileName);
-      continue;
-    }
-    const samples = uniqueSamples(parsed.samples);
-    const summary = summarizeGpuMetricSamples(samples);
-    if (!summary) {
+    const series =
+      parsed &&
+      digestSeries(
+        {
+          fileName: file.fileName,
+          vendor: parsed.vendor,
+          csvSha256: createHash('sha256').update(csvText).digest('hex'),
+          sidecars,
+        },
+        parsed.samples,
+      );
+    if (!series) {
       unreadable.push(file.fileName);
       continue;
     }
-    prepared.push({
-      fileName: file.fileName,
-      vendor: parsed.vendor,
-      csvSha256: createHash('sha256').update(csvText).digest('hex'),
-      samples,
-      stats: computeGpuMetricStats(samples),
-      sampleIntervalS: summary.sampleIntervalS,
-      gpuCount: summary.gpuCount,
-      startedAtMs: summary.startedAtMs,
-      endedAtMs: summary.endedAtMs,
-      sidecars,
-    });
+    prepared.push(series);
   }
   if (prepared.length > 0 && unreadable.length > 0) {
     throw new Error(
diff --git a/packages/db/src/etl/multinode-power-samples.ts b/packages/db/src/etl/multinode-power-samples.ts
index 9c711c4de..552588057 100644
--- a/packages/db/src/etl/multinode-power-samples.ts
+++ b/packages/db/src/etl/multinode-power-samples.ts
@@ -14,7 +14,12 @@
  * staging ("one CSV per node"). Pure module: no I/O.
  */
 
-import { splitCsvLine, type GpuMetricSample, type GpuMetricsVendor } from './gpu-metrics-csv.js';
+import {
+  emptySample,
+  splitCsvLine,
+  type GpuMetricSample,
+  type GpuMetricsVendor,
+} from './gpu-metrics-csv.js';
 
 export interface MultinodePowerHost {
   hostname: string;
@@ -32,27 +37,6 @@ export function isMultinodePowerSamplesPath(relativePath: string): boolean {
   return /^LOGS\/(?:[^/]+\/)*samples\.csv$/u.test(posix);
 }
 
-function powerOnlySample(timestampMs: number, gpuIndex: number, powerW: number): GpuMetricSample {
-  return {
-    timestampMs,
-    gpuIndex,
-    powerW,
-    temperatureC: null,
-    smClockMhz: null,
-    memClockMhz: null,
-    gpuUtilPct: null,
-    memUtilPct: null,
-    edgeTempC: null,
-    memTempC: null,
-    gfxVoltageMv: null,
-    socVoltageMv: null,
-    memVoltageMv: null,
-    fclkMhz: null,
-    socclkMhz: null,
-    mmActivityPct: null,
-  };
-}
-
 /**
  * Group the deployment-wide CSV by host. Returns null when the header is not
  * the multinode power schema; malformed rows are skipped. Hosts sort by name
@@ -90,7 +74,7 @@ export function parseMultinodePowerSamples(csvText: string): MultinodePowerHost[
       host = { hostname, samples: [], gpuUuids: {} };
       hosts.set(hostname, host);
     }
-    host.samples.push(powerOnlySample(Math.round(seconds * 1000), gpuIndex, powerW));
+    host.samples.push({ ...emptySample(Math.round(seconds * 1000), gpuIndex), powerW });
     const uuid = at(cells, 'gpu_uuid');
     if (uuid && !(gpuIndex in host.gpuUuids)) host.gpuUuids[gpuIndex] = uuid;
   }
diff --git a/packages/db/src/etl/power-audit-recovery.ts b/packages/db/src/etl/power-audit-recovery.ts
index 808be3ef7..3b1c2f5a2 100644
--- a/packages/db/src/etl/power-audit-recovery.ts
+++ b/packages/db/src/etl/power-audit-recovery.ts
@@ -19,16 +19,14 @@ export function createBenchmarkPowerAuditRecovery() {
     if (evidence) {
       const matches = Object.entries(evidence.validations).filter(([, validation]) => {
         const window = validation.selected_window;
-        if (
-          validation.result_file !== evidence.resultFile ||
-          !window ||
-          typeof window !== 'object' ||
-          Array.isArray(window) ||
-          !('concurrency' in window) ||
-          window.concurrency !== row.conc
-        )
-          return false;
-        return true;
+        return (
+          validation.result_file === evidence.resultFile &&
+          typeof window === 'object' &&
+          window !== null &&
+          !Array.isArray(window) &&
+          'concurrency' in window &&
+          window.concurrency === row.conc
+        );
       });
       // Ambiguous/missing evidence must not establish new provenance.
       if (matches.length !== 1) return row;
diff --git a/packages/db/src/etl/power-publication.ts b/packages/db/src/etl/power-publication.ts
index d4a0ba17c..0130956a1 100644
--- a/packages/db/src/etl/power-publication.ts
+++ b/packages/db/src/etl/power-publication.ts
@@ -49,11 +49,7 @@ export interface PowerPublicationManifest {
   points: PowerPublicationPoint[];
   /** Fatal: verify-power-publication exits non-zero when this is non-empty. */
   ingestErrors?: string[];
-  /**
-   * Non-fatal: PowerX telemetry digest failures. Surfaced in the verification
-   * receipt so they stay visible, but they never fail the ingest — the benchmark
-   * rows landed, and the artifact can be re-digested by the backfill.
-   */
+  /** Non-fatal PowerX telemetry digest failures; see `fatalPublicationErrors`. */
   telemetryWarnings?: string[];
   /** Attachment completeness, separate from benchmark/power publication validity. */
   telemetry?: TelemetryReceipt;
@@ -74,6 +70,7 @@ export interface PowerPublicationManifest {
     error?: string;
   };
 }
+
 /**
  * The errors that fail an ingest. `telemetryWarnings` is deliberately not among
  * them: a gpu_metrics digest failure costs one point's PowerX tab, while the
diff --git a/packages/db/src/etl/required-power-publication.ts b/packages/db/src/etl/required-power-publication.ts
index d8f995b8a..5794b29ec 100644
--- a/packages/db/src/etl/required-power-publication.ts
+++ b/packages/db/src/etl/required-power-publication.ts
@@ -475,7 +475,7 @@ function verifyPointEvidence(
         artifact.validation_state !== 'valid' ||
         typeof artifact.sha256 !== 'string' ||
         !/^[a-f0-9]{64}$/u.test(artifact.sha256) ||
-        createHash('sha256').update(file.contents).digest('hex') !== artifact.sha256
+        digest(file) !== artifact.sha256
       )
         throw new Error(`Required power: invalid artifact validation or hash ${relative}`);
       evidence.set(relative, file);
diff --git a/packages/db/src/ingest-ci-run.ts b/packages/db/src/ingest-ci-run.ts
index 351233bf9..ed4135fad 100644
--- a/packages/db/src/ingest-ci-run.ts
+++ b/packages/db/src/ingest-ci-run.ts
@@ -615,6 +615,8 @@ async function main(): Promise<void> {
       const parentDir = path.basename(path.dirname(file));
       const configKey = parentDir.replace(/^bmk_/u, '');
       const suffix = stripBmkAndAgenticPrefix(parentDir);
+      // Same pairing rule as server logs: `gpu_metrics_<key>` carries no
+      // `agentic_` prefix, so agentic points fall back to the bare suffix.
       const gpuMetricsArtifact =
         gpuMetricsArtifacts.get(configKey) ?? gpuMetricsArtifacts.get(suffix);
       let auditEvidence;
@@ -763,8 +765,6 @@ async function main(): Promise<void> {
                 tracker.recordDbError(`server_logs for ${configKey}`, error);
               }
             }
-            // Same pairing rule as server logs: `gpu_metrics_<key>` carries no
-            // `agentic_` prefix, so agentic points fall back to the bare suffix.
             if (gpuMetricsArtifact) {
               try {
                 const gpuMetricsStart = Date.now();
@@ -785,11 +785,9 @@ async function main(): Promise<void> {
                     `${ingested.seriesSkipped} unchanged (${elapsed(gpuMetricsStart)})`,
                 );
               } catch (error: any) {
-                // Non-fatal on purpose: this point's benchmark rows are already
-                // committed and only its telemetry tab is affected, and
-                // `admin:db:backfill-gpu-metrics --run <id>` can re-digest the
-                // artifact later. Recording it as a DB error instead would reach
-                // the publication manifest and fail the whole production ingest.
+                // Non-fatal on purpose (see `fatalPublicationErrors`): the rows are
+                // committed and `admin:db:backfill-gpu-metrics --run <id>` can
+                // re-digest the artifact. A DB error here would fail the ingest.
                 tracker.recordTelemetryError(`gpu_metrics for ${configKey}`, error);
                 for (const row of toInsert) {
                   const point = telemetryObservations.get(
diff --git a/packages/db/src/lib/backfill-benchmark-refresh.ts b/packages/db/src/lib/backfill-benchmark-refresh.ts
index 15d2d60f6..46eedcdea 100644
--- a/packages/db/src/lib/backfill-benchmark-refresh.ts
+++ b/packages/db/src/lib/backfill-benchmark-refresh.ts
@@ -121,8 +121,7 @@ export async function refreshBackfillBenchmarks(
     `;
     if (rows.length !== ids.length)
       throw new Error('Refresh receipt IDs do not belong to its run/attempt');
-    const changed = rows;
-    for (const row of changed) {
+    for (const row of rows) {
       const audit = row.power_audit;
       if (audit === null)
         throw new Error(
@@ -159,7 +158,7 @@ export async function refreshBackfillBenchmarks(
         points[0]!.power_audit = update.powerAudit;
     }
     save();
-    if (changed.length > 0) {
+    if (rows.length > 0) {
       phase = 'refresh latest_benchmarks';
       await refreshLatestBenchmarks(sql);
       phase = 'invalidate cache';
@@ -178,7 +177,7 @@ export async function refreshBackfillBenchmarks(
       )
         throw new Error('Invalid cache invalidation response');
       phase = 'verify benchmark API';
-      for (const model of new Set(changed.map((row) => row.model))) {
+      for (const model of new Set(rows.map((row) => row.model))) {
         const displayModel = DB_MODEL_TO_DISPLAY[model];
         if (!displayModel) throw new Error(`Unmapped public model: ${model}`);
         const url = new URL('/api/v1/benchmarks', endpoint);
@@ -197,7 +196,7 @@ export async function refreshBackfillBenchmarks(
         if (!api.ok) throw new Error(`HTTP ${api.status}`);
         const body: unknown = await api.json();
         if (!Array.isArray(body)) throw new Error('Invalid benchmark API response');
-        for (const row of changed.filter((entry) => entry.model === model)) {
+        for (const row of rows.filter((entry) => entry.model === model)) {
           const matches = body.filter((candidate) => {
             const raw = candidate?.id;
             const id =
diff --git a/packages/db/src/lib/backfill-runner.ts b/packages/db/src/lib/backfill-runner.ts
index 2051e493d..265cca382 100644
--- a/packages/db/src/lib/backfill-runner.ts
+++ b/packages/db/src/lib/backfill-runner.ts
@@ -166,11 +166,6 @@ export async function runCandidateIdBackfill(
   return true;
 }
 
-/**
- * jsonb parameter for a freshly computed value. `structuredClone` strips
- * class instances/prototypes so postgres.js serializes plain data only —
- * matches what the inline ingest path stores.
- */
 /**
  * List a candidate run's GitHub artifacts with transient-failure retry.
  * Returns `null` when GitHub no longer has the run at all, so a sweep over
@@ -190,6 +185,11 @@ export async function listBackfillRunArtifacts(
   }
 }
 
+/**
+ * jsonb parameter for a freshly computed value. `structuredClone` strips
+ * class instances/prototypes so postgres.js serializes plain data only —
+ * matches what the inline ingest path stores.
+ */
 export function jsonbParam(sql: Sql, value: unknown): ReturnType<Sql['json']> {
   return sql.json(structuredClone(value) as unknown as Parameters<typeof sql.json>[0]);
 }
diff --git a/packages/db/src/lib/telemetry-purge.ts b/packages/db/src/lib/telemetry-purge.ts
index 13b2b76dd..ef8b2d07a 100644
--- a/packages/db/src/lib/telemetry-purge.ts
+++ b/packages/db/src/lib/telemetry-purge.ts
@@ -28,8 +28,13 @@ export interface TelemetryPurgeCounts {
 
 export const NO_TELEMETRY: TelemetryPurgeCounts = { series: 0, samples: 0 };
 
+interface CountRow {
+  n: unknown;
+  samples: unknown;
+}
+
 /** `count`/`sum` come back as strings over the wire; `sum` is null on an empty set. */
-function toCounts(row: { n: unknown; samples: unknown } | undefined): TelemetryPurgeCounts {
+function toCounts(row: CountRow | undefined): TelemetryPurgeCounts {
   if (!row) return NO_TELEMETRY;
   return { series: Number(row.n ?? 0), samples: Number(row.samples ?? 0) };
 }
@@ -44,12 +49,12 @@ export async function countRunTelemetry(
   workflowRunIds: readonly number[],
 ): Promise<TelemetryPurgeCounts> {
   if (workflowRunIds.length === 0) return NO_TELEMETRY;
-  const [row] = await sql`
+  const [row] = await sql<CountRow[]>`
     SELECT count(*)::int AS n, coalesce(sum(sample_count), 0)::bigint AS samples
     FROM gpu_metric_series
     WHERE workflow_run_id = ANY(${[...workflowRunIds]})
   `;
-  return toCounts(row as { n: unknown; samples: unknown } | undefined);
+  return toCounts(row);
 }
 
 /**
@@ -62,7 +67,7 @@ export async function deleteRunTelemetry(
   workflowRunIds: readonly number[],
 ): Promise<TelemetryPurgeCounts> {
   if (workflowRunIds.length === 0) return NO_TELEMETRY;
-  const [row] = await sql`
+  const [row] = await sql<CountRow[]>`
     WITH deleted AS (
       DELETE FROM gpu_metric_series
       WHERE workflow_run_id = ANY(${[...workflowRunIds]})
@@ -70,7 +75,7 @@ export async function deleteRunTelemetry(
     )
     SELECT count(*)::int AS n, coalesce(sum(sample_count), 0)::bigint AS samples FROM deleted
   `;
-  return toCounts(row as { n: unknown; samples: unknown } | undefined);
+  return toCounts(row);
 }
 
 /**
@@ -83,7 +88,7 @@ export async function unlinkPointTelemetry(
   benchmarkResultIds: readonly number[],
 ): Promise<number> {
   if (benchmarkResultIds.length === 0) return 0;
-  const [row] = await sql`
+  const [row] = await sql<Pick<CountRow, 'n'>[]>`
     WITH deleted AS (
       DELETE FROM benchmark_result_gpu_metrics
       WHERE benchmark_result_id = ANY(${[...benchmarkResultIds]})
@@ -91,7 +96,7 @@ export async function unlinkPointTelemetry(
     )
     SELECT count(*)::int AS n FROM deleted
   `;
-  return Number((row as { n: unknown } | undefined)?.n ?? 0);
+  return Number(row?.n ?? 0);
 }
 
 /** One-line summary for preview and transcript output. */
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
index cc4767cb6..488fe0ca9 100644
--- a/packages/db/src/queries/gpu-metrics.ts
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -219,6 +219,20 @@ function toStatRow(raw: RawStatRow): GpuMetricStatRow {
   };
 }
 
+function groupBySeries<Raw extends { series_id: number | string }, Row>(
+  rows: readonly Raw[],
+  toRow: (raw: Raw) => Row,
+): Map<number, Row[]> {
+  const groups = new Map<number, Row[]>();
+  for (const raw of rows) {
+    const key = Number(raw.series_id);
+    const bucket = groups.get(key);
+    if (bucket) bucket.push(toRow(raw));
+    else groups.set(key, [toRow(raw)]);
+  }
+  return groups;
+}
+
 async function loadSeriesDetails(
   sql: DbClient,
   seriesRows: readonly RawSeriesRow[],
@@ -284,26 +298,16 @@ async function loadSeriesDetails(
     throw new TelemetrySnapshotChangedError(ids);
   }
 
-  const statsBySeries = new Map<number, GpuMetricStatRow[]>();
-  for (const raw of statRows) {
-    const key = Number(raw.series_id);
-    const bucket = statsBySeries.get(key);
-    if (bucket) bucket.push(toStatRow(raw));
-    else statsBySeries.set(key, [toStatRow(raw)]);
-  }
+  const statsBySeries = groupBySeries(statRows, toStatRow);
   const staleIds = new Set(
     seriesRows
       .filter((row) => row.stats_version !== GPU_STATS_VERSION)
       .map((row) => Number(row.id)),
   );
-  const staleSamples = new Map<number, RawSampleRow[]>();
-  for (const sample of sampleRows) {
-    const id = Number(sample.series_id);
-    if (!staleIds.has(id)) continue;
-    const rows = staleSamples.get(id) ?? [];
-    rows.push(sample);
-    staleSamples.set(id, rows);
-  }
+  const staleSamples = groupBySeries(
+    sampleRows.filter((sample) => staleIds.has(Number(sample.series_id))),
+    (sample) => sample,
+  );
   for (const row of seriesRows) {
     const id = Number(row.id);
     if (!staleIds.has(id)) continue;
@@ -322,13 +326,7 @@ async function loadSeriesDetails(
       })),
     );
   }
-  const samplesBySeries = new Map<number, GpuMetricSampleRow[]>();
-  for (const raw of sampleRows) {
-    const key = Number(raw.series_id);
-    const bucket = samplesBySeries.get(key);
-    if (bucket) bucket.push(toSampleRow(raw));
-    else samplesBySeries.set(key, [toSampleRow(raw)]);
-  }
+  const samplesBySeries = groupBySeries(sampleRows, toSampleRow);
 
   return seriesRows.map((row) => {
     const id = Number(row.id);
diff --git a/packages/db/src/verify-power-publication.ts b/packages/db/src/verify-power-publication.ts
index 41038b292..069608be4 100644
--- a/packages/db/src/verify-power-publication.ts
+++ b/packages/db/src/verify-power-publication.ts
@@ -101,8 +101,7 @@ try {
     status:
       errors.length > 0 ? 'failed' : manifest.points.length > 0 ? 'matched' : 'no_power_points',
     errors,
-    // Kept out of `errors` on purpose: a telemetry digest failure costs one
-    // point's PowerX tab, not its benchmark data, so it must not fail the ingest.
+    // Non-fatal by design; see `fatalPublicationErrors`.
     telemetryWarnings: manifest.telemetryWarnings ?? [],
     ...(manifest.telemetry ? { telemetry: manifest.telemetry } : {}),
   };
diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index 690397040..2979d5dbe 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -8,7 +8,7 @@
     "references/cli-contract.md": "fa44faa38d889b4fbdee5ba42752b47758ee3706fab150513bd4e6db87a86cb0",
     "references/cli.md": "96b228f34cb3600f4548f4dc84df8506531747286763c56ca834c77bee05e1eb",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "339ebf9e7b33e4d586c852452a42a8ccf020e7edc0427f434d51cd092e69486e",
+    "references/dashboard-views.md": "3ccdb82ffcf7f7d3295dba4b9bcd95339d7c9cbf260135a6370a923d23bb5b21",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/pareto.md": "1b4d2d163f982e3f2d97addce310789eae9c1e5badd82dd7501708c9e0385027",
     "references/powerx.md": "cf8adcc5dfe395c5fb659908819980a872475f862f22b723815af43d363cedad",
diff --git a/packages/skills/skills/inferencex-api/references/dashboard-views.md b/packages/skills/skills/inferencex-api/references/dashboard-views.md
index 81f123044..5d51d9bde 100644
--- a/packages/skills/skills/inferencex-api/references/dashboard-views.md
+++ b/packages/skills/skills/inferencex-api/references/dashboard-views.md
@@ -39,28 +39,28 @@ All paths below are relative to `/api/v1/views/`. The maintained exhaustive
 query-key list is in the app's OpenAPI contract. The following groups explain
 which controls belong together.
 
-| View                            | Selection and calculation                                                                                                                                                                                                                                 |
-| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `options`                       | Static registries and defaults, JSON only. Data-dependent run/config choices come from their own views.                                                                                                                                                   |
-| `inference`                     | Model, sequence, precisions, date/exact run, GPU/vendor/framework/deployment/spec/power filters; metric, xmode, xmetric, percentile, optimal/best/allPoints; TCO, custom costs/powers, pricing, unofficial runs, comparison dates/endpoints. JSON or CSV. |
-| `historical`                    | Model, sequence, target, metric, precisions, GPUs/vendors/frameworks/deployment, start/end, TCO and pricing. `extendToDate` labels synthetic extension, defaults to current UTC date. JSON or CSV.                                                        |
-| `calculator`                    | Model/sequence/run/date, precisions/GPUs, percentile, target/mode, token type, owning/renting cost, TCO, power budget, cost cap, hide-above-limit and public unofficial runs. JSON or CSV.                                                                |
-| `first-token`                   | Benchmark selection plus 1–8 positive TTFT caps in seconds, minimum interactivity, cost provider and token type. Shared dashboard winner selection.                                                                                                       |
-| `cache-reuse`                   | AgentX selection plus exact `config` from returned configurations. Cache-reuse curves retain official versus unofficial evidence.                                                                                                                         |
-| `profit-estimator`              | AgentX selection, comparison dates/runs, target, utilization, lab revenue share, list/OpenRouter/custom token prices, own/rent/custom chip costs, TCO and provisioned/modeled/compare power. USD/chip-hour.                                               |
-| `profit-estimator-per-gigawatt` | Same selectors; USD/GW-year basis and owning-cost default.                                                                                                                                                                                                |
-| `fleet`                         | Model/sequence/precision/GPUs, target/percentile, TCO/token type/cost provider, MW, input/output prices, ramp, cache discount, MTBI, recovery, horizon and metric. JSON or CSV.                                                                           |
-| `evaluation`                    | Model, task, date, precision and GPU selection; public unofficial runs remain separately labeled and independent of the official date cutoff. JSON or CSV.                                                                                                |
-| `reliability`                   | Rolling range, GPU selection and optional `asOf` date for reproducibility. JSON or CSV.                                                                                                                                                                   |
-| `gpu-specs`                     | Full hardware properties or selected metric ranking; table/radar/bar are renderings of these values. JSON or CSV.                                                                                                                                         |
-| `overview`                      | Models, model/hardware row limits, hardware tier, engine, comparison mode and reference. JSON or CSV.                                                                                                                                                     |
-| `rankings`                      | Ranking kind (model or chip), selected model/scenario and format. Use the exact values in OpenAPI.                                                                                                                                                        |
-| `compare`                       | GPU pairs, model/slug, scenario, tier selection and variant. JSON or CSV.                                                                                                                                                                                 |
-| `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                               |
-| `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                    |
-| `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                 |
-| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first telemetry; full-record statistics use stored digests. Responses are no-store.                 |
-| `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                    |
+| View                            | Selection and calculation                                                                                                                                                                                                                                                                                              |
+| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `options`                       | Static registries and defaults, JSON only. Data-dependent run/config choices come from their own views.                                                                                                                                                                                                                |
+| `inference`                     | Model, sequence, precisions, date/exact run, GPU/vendor/framework/deployment/spec/power filters; metric, xmode, xstat, xmetric, percentile, optimal/best/allPoints; equal-service sources/target, roleShare and powerFit; TCO, custom costs/powers, pricing, unofficial runs, comparison dates/endpoints. JSON or CSV. |
+| `historical`                    | Model, sequence, target, metric, precisions, GPUs/vendors/frameworks/deployment, start/end, TCO and pricing. `extendToDate` labels synthetic extension, defaults to current UTC date. JSON or CSV.                                                                                                                     |
+| `calculator`                    | Model/sequence/run/date, precisions/GPUs, percentile, target/mode, token type, owning/renting cost, TCO, power budget, cost cap, hide-above-limit and public unofficial runs. JSON or CSV.                                                                                                                             |
+| `first-token`                   | Benchmark selection plus 1–8 positive TTFT caps in seconds, minimum interactivity, cost provider and token type. Shared dashboard winner selection.                                                                                                                                                                    |
+| `cache-reuse`                   | AgentX selection plus exact `config` from returned configurations. Cache-reuse curves retain official versus unofficial evidence.                                                                                                                                                                                      |
+| `profit-estimator`              | AgentX selection, comparison dates/runs, target, utilization, lab revenue share, list/OpenRouter/custom token prices, own/rent/custom chip costs, TCO and provisioned/modeled/compare power. USD/chip-hour.                                                                                                            |
+| `profit-estimator-per-gigawatt` | Same selectors; USD/GW-year basis and owning-cost default.                                                                                                                                                                                                                                                             |
+| `fleet`                         | Model/sequence/precision/GPUs, target/percentile, TCO/token type/cost provider, MW, input/output prices, ramp, cache discount, MTBI, recovery, horizon and metric. JSON or CSV.                                                                                                                                        |
+| `evaluation`                    | Model, task, date, precision and GPU selection; public unofficial runs remain separately labeled and independent of the official date cutoff. JSON or CSV.                                                                                                                                                             |
+| `reliability`                   | Rolling range, GPU selection and optional `asOf` date for reproducibility. JSON or CSV.                                                                                                                                                                                                                                |
+| `gpu-specs`                     | Full hardware properties or selected metric ranking; table/radar/bar are renderings of these values. JSON or CSV.                                                                                                                                                                                                      |
+| `overview`                      | Models, model/hardware row limits, hardware tier, engine, comparison mode and reference. JSON or CSV.                                                                                                                                                                                                                  |
+| `rankings`                      | Ranking kind (model or chip), selected model/scenario and format. Use the exact values in OpenAPI.                                                                                                                                                                                                                     |
+| `compare`                       | GPU pairs, model/slug, scenario, tier selection and variant. JSON or CSV.                                                                                                                                                                                                                                              |
+| `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                                                                                            |
+| `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                                                                                 |
+| `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                                                                              |
+| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first raw-explorer projection; full-record statistics use stored digests. Not a serving-window/role-pool projection. Responses are no-store.                     |
+| `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                                                                                 |
 
 ## Interpretation and maintenance
 
@@ -85,6 +85,65 @@ envelope. `frontier.direction` describes that boundary; `metric.direction` retai
 the optimization direction used by `best=true`. Interpret the envelope as a load
 boundary, not evidence that those points are more energy efficient.
 
+Prefer equal-service comparisons for article-facing hardware analysis. Use
+`xstat=mean` only for fixed-sequence service axes when that statistic is intended:
+streaming speed then means **1 / mean TPOT**, not arithmetic mean request speed.
+TTFT/E2E use recorded means. Default is median; absent means are not replaced.
+AgentX still uses `percentile`; concurrency uses no statistic. Check resolved
+`params.xstat` and `xAxis.statistic`, not the requested parameter alone.
+
+`serviceCompare=true` returns exact opaque `serviceSources` keys, an
+`equalServiceCurve`, and an optional `equalServiceComparison` at `serviceTarget`.
+Use returned keys verbatim for `serviceBaseline` and `serviceComparator` via
+`URLSearchParams`; never substitute bare GPU names. Each `label` is display text
+(hardware and date, plus precision, topology or run only where two sources would
+otherwise look alike); select and join by `key`, never by label. Omitted keys select the first
+two sources; unknown explicit keys stay unavailable. Omitted target means no
+selected-target result. Targets are tok/s/user for streaming speed, seconds for
+TTFT/E2E. Concurrency is unsupported for equal-service interpolation.
+
+The same dashboard helper uses scoped observed points before frontier/best
+pruning, with no power-comparison clones. It interpolates raw quantities
+linearly only inside each exact source range, then reports signed
+`100 × (comparator / baseline − 1)`. Metrics are measured GPU W/GPU,
+whole-deployment output tokens/s, and validated GPU J/output token. Negative energy
+change means lower comparator energy. Preserve bracket endpoint identities,
+`interpolated`, missing reasons and nulls. Never call interpolated points new
+measurements or bridge different runs, recipes, topologies or missing endpoints.
+
+`serviceCompare=true` also returns `matchedConcurrency`: the two selected sources
+paired at each concurrency either observed. Sides are `observed`, `missing`, or
+`ambiguous` (disagreeing duplicates, none chosen); `changePercent` needs both
+observed. It is a same-load diagnostic: speeds usually differ, so never present it
+as an equal-service result.
+
+`roleShare=true` returns validated disaggregated prefill/decode J/output and their
+shares of reconstructed total energy. It converts prefill J/input using the
+same-window aggregate J/output-to-J/input ratio; it does not compare unlike token
+denominators. Missing roles are omitted. `rolePoints` adds per-observation role
+W/GPU, role-local J/input and J/output (different denominators, never add them)
+and the output-token reconstruction, with nulls for missing figures.
+
+`powerFit=true` returns `powerFits`: per source, an OLS line of measured mean W/GPU
+against output tok/s per allocated GPU, with `P₀`, slope `m` (J/output token), R²,
+n, x-range, registry `tdpWatts` and point identities. Fewer than three distinct
+rates return `fit: null`, `reason: "too-few-points"`. Call `P₀` an extrapolated
+intercept, not idle power, and do not read the line outside its x-range.
+
+These panels require JSON; enabling any with CSV returns 400. Existing CSV remains
+a plotted-point export.
+
+For exact-load comparisons, use `xmode=concurrency`. The response resolves
+`optimal=false` and `best=false`, retains every eligible observed load, and sets
+`frontier.direction=null`; concurrency is not a speed or quality preference.
+Filter `topologies` with one or more exact `point.topologyKey` values from a first
+response (encode with `URLSearchParams`). This selects the same GPU count,
+parallelism, role-pool split and offload mode across hardware without removing
+loads. Unknown metadata stays unknown, not equivalent to an explicit setting.
+Keep hardware, precision, recipe, run/date and software provenance separate;
+matching topology alone does not establish a controlled hardware comparison.
+Missing concurrency points must remain absent, not interpolated or extrapolated.
+
 Fleet lifecycle defaults (ramp, cached-input percent, MTBI, recovery) follow the
 dashboard's lifecycle panel; read the current values from `/api/v1/views/options`
 rather than hard-coding them.

From ca6899ff357da00b5966eafddd7f2dce76525eb9 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 13:57:21 -0700
Subject: [PATCH 079/103] fix: simplify PowerX labels and explanations
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Align the four boundary labels across the UI and views API, collapse detailed profit assumptions, retain modeling disclosures and document model regeneration.

中文：统一 PowerX 功耗名称并精简说明。同步 UI/API 标签，折叠利润估算假设，保留建模边界，补充模型更新步骤及浏览器回归。
---
 docs/dashboard-readonly-views.md              |  5 ++
 docs/powerx-system-power.md                   | 29 ++++++++
 .../component/measured-metric-controls.cy.tsx | 69 ++++++++++++++++++
 .../app/cypress/e2e/profit-estimator.cy.ts    | 34 +++++++--
 .../src/app/api/v1/views/extensions.test.ts   |  2 +-
 .../calculator/ProfitEstimatorDisplay.tsx     | 71 ++++++++++++++-----
 .../components/inference/ui/ChartDisplay.tsx  | 27 ++++---
 .../inference/ui/InferenceTable.test.ts       |  6 +-
 .../inference/ui/MeasuredMetricControls.tsx   | 23 ++++--
 packages/app/src/lib/api-route-catalog.ts     |  2 +-
 packages/app/src/lib/power-basis.ts           | 13 ++--
 .../lib/views-api/calculator-extensions.ts    |  5 +-
 .../app/src/lib/views-api/docs/extensions.ts  |  4 +-
 .../skills/inferencex-api/integrity.json      |  2 +-
 .../references/dashboard-views.md             |  7 ++
 15 files changed, 249 insertions(+), 50 deletions(-)
 create mode 100644 packages/app/cypress/component/measured-metric-controls.cy.tsx

diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 95b159ce8..2dc4d8e62 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -63,6 +63,11 @@ OperatorX is feature-gated in navigation and uses page-owned
 contract.
 Zoom, theme, axis scale, labels, media playback and report expansion are renderer
 state. GPU interactive downsampling does not alter returned raw data or statistics.
+Power boundary labels are GPU Level Measured, GPU Level Provisioned (TDP), All in
+Provisioned, and All in Measured. The last combines measured GPU power with modeled
+unmeasured components and PUE; it is not a wall-meter measurement. These labels and
+collapsed power-assumption/availability notes do not change metric IDs, API selectors,
+or calculations. Profit comparison `powerLabel` display text follows the same names.
 The GPU statistics table includes startup and warmup for all chips in the selected
 series, regardless of chip visibility. It is separate from serving-window power,
 J/token and selected-time-window calculations. Run telemetry is DB-first with an
diff --git a/docs/powerx-system-power.md b/docs/powerx-system-power.md
index 4eec8f70b..4775f66de 100644
--- a/docs/powerx-system-power.md
+++ b/docs/powerx-system-power.md
@@ -16,6 +16,28 @@ The pinned source currently identifies itself as **DRAFT / pending human
 verification**. Numerical parity establishes implementation equivalence, not
 empirical chassis calibration.
 
+## Updating the model for historical results
+
+Modeled power is derived from retained measurements when the browser or a shared
+views API transforms a benchmark row. Changing the model does not rewrite the
+original GPU measurements or require a per-run database backfill.
+
+1. Update `REVISION` in `packages/app/scripts/generate-system-power-reference.py`
+   to the intended clean Python model commit, and update the recorded assumptions
+   when required.
+2. Run that script with the path to the pinned model checkout to regenerate
+   `system-power-model.profiles.json` and `system-power-model.reference.json`.
+   If equations or load-dependent components changed, update the TypeScript
+   implementation too; regenerating constants alone is insufficient.
+3. Run the system-power model parity and admission tests, then deploy the app.
+   Existing browser sessions need the updated bundle. Derived API responses need
+   the normal authenticated cache invalidation or cache expiry; deployment alone
+   does not establish that every cached response uses the new revision.
+4. Regenerate frozen CSV/JSON exports separately. If the revised model needs
+   inputs that were never recorded, those rows stay unavailable until the input
+   gap is resolved. A new benchmark's power must not be attached to an older
+   benchmark's throughput.
+
 ## Boundary and assumptions
 
 The input is measured mean GPU power during a validated serving window. The
@@ -207,6 +229,13 @@ dropping that replicate.
 
 ## 中文说明
 
+模型结果在浏览器或共享 views API 转换 benchmark 数据时计算，不写回原始 GPU
+测量值。更新模型时，先修改生成脚本中的固定版本及相关假设，再生成 profiles 和
+reference JSON；如果公式或随负载变化的组件有改动，还需同步 TypeScript 实现。
+通过一致性及准入测试后部署，刷新浏览器，并使派生 API 缓存失效或等待其过期。
+冻结的 CSV/JSON 需另行导出。通常无需逐 run 回填数据库；若新模型需要历史记录中
+没有的输入，应保留不可用状态，也不能把新一轮测得的功耗配到旧吞吐结果上。
+
 PowerX 的系统功耗结果以实测 GPU 功率为输入，使用固定版本的功耗模型估算
 8-GPU 机箱的 AC 输入功率，再单独应用 PUE 得到设施功率估计。CPU 和 DRAM 利用率
 均假设为 20%；这些是模型参数，不是实测利用率。完整平台配置、源码版本和校验和
diff --git a/packages/app/cypress/component/measured-metric-controls.cy.tsx b/packages/app/cypress/component/measured-metric-controls.cy.tsx
new file mode 100644
index 000000000..1e1abf9ab
--- /dev/null
+++ b/packages/app/cypress/component/measured-metric-controls.cy.tsx
@@ -0,0 +1,69 @@
+import { useState } from 'react';
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+
+import { MeasuredMetricControls } from '@/components/inference/ui/MeasuredMetricControls';
+
+function Controls() {
+  const [metric, setMetric] = useState('y_measuredAvgPower');
+  return (
+    <div className="p-4">
+      <MeasuredMetricControls metric={metric} onChange={setMetric} />
+      <output data-testid="selected-metric">{metric}</output>
+    </div>
+  );
+}
+
+describe('Power boundary labels', () => {
+  for (const locale of ['en', 'zh'] as const) {
+    it(`keeps metric selection and the modeled-component note clear (${locale})`, () => {
+      const width = locale === 'en' ? 1280 : 390;
+      cy.viewport(width, 720);
+      cy.mount(
+        <PathnameContext.Provider value={locale === 'en' ? '/inference' : '/zh/inference'}>
+          <Controls />
+        </PathnameContext.Provider>,
+      );
+      const labels =
+        locale === 'en'
+          ? [
+              'GPU Level Measured',
+              'GPU Level Provisioned (TDP)',
+              'All in Provisioned',
+              'All in Measured',
+            ]
+          : ['GPU 实测功耗', 'GPU 额定功耗（TDP）', '整体预配功耗', '整体实测功耗'];
+      cy.get('[data-testid="all-in-measured-note"]').should('not.exist');
+      cy.get('[data-testid="measured-power-basis"]').click();
+      cy.get('[role="option"]').should(($options) => {
+        expect([...$options].map((option) => option.textContent?.trim())).to.deep.equal(labels);
+      });
+      cy.screenshot(`power-boundary-options-${locale}`, { overwrite: true });
+      cy.get('[role="option"][data-value="gpu-provisioned"]').click();
+      cy.get('[data-testid="selected-metric"]').should('have.text', 'y_gpuProvisionedWatts');
+      cy.get('[data-testid="measured-power-basis"]').click();
+      cy.get('[role="option"][data-value="utility-provisioned"]').click();
+      cy.get('[data-testid="selected-metric"]').should('have.text', 'y_utilityProvisionedWatts');
+      cy.get('[data-testid="measured-power-basis"]').click();
+      cy.get('[role="option"][data-value="utility-modeled"]').click();
+      cy.get('[role="option"]').should('not.exist');
+      cy.get('[data-testid="selected-metric"]').should('have.text', 'y_utilityModeledWatts');
+      cy.get('[data-testid="all-in-measured-note"]')
+        .should('be.visible')
+        .and(
+          'contain',
+          locale === 'en' ? 'unmeasured components are modeled' : '未实测的组件功耗由模型估算',
+        );
+      cy.get('[data-testid="measured-metric-controls"]').should(($controls) => {
+        const box = $controls[0].getBoundingClientRect();
+        expect(box.left).to.be.at.least(0);
+        expect(box.right).to.be.at.most(width);
+        expect($controls[0].scrollWidth).to.be.at.most($controls[0].clientWidth);
+      });
+      cy.screenshot(`power-boundary-note-${locale}`, { overwrite: true });
+      cy.get('[data-testid="measured-power-basis"]').click();
+      cy.get('[role="option"][data-value="gpu-measured"]').click();
+      cy.get('[data-testid="selected-metric"]').should('have.text', 'y_measuredAvgPower');
+      cy.get('[data-testid="all-in-measured-note"]').should('not.exist');
+    });
+  }
+});
diff --git a/packages/app/cypress/e2e/profit-estimator.cy.ts b/packages/app/cypress/e2e/profit-estimator.cy.ts
index e79faffcb..198338c8d 100644
--- a/packages/app/cypress/e2e/profit-estimator.cy.ts
+++ b/packages/app/cypress/e2e/profit-estimator.cy.ts
@@ -94,6 +94,18 @@ const chart = () => cy.get('[data-testid="profit-estimator-chart"]');
 const chartSvg = () => chart().find('svg').filter(':has(.chart-root)').first();
 const bars = () => chart().find('rect.bar');
 
+function assertDisclosureOpen(testId: string, open: boolean) {
+  cy.get<HTMLDetailsElement>(`[data-testid="${testId}"]`).should(($details) => {
+    expect($details[0].open, `${testId} native disclosure state`).to.equal(open);
+    const content = $details[0].querySelector('p');
+    expect(content, `${testId} content`).not.to.equal(null);
+    // Cypress visibility omits native closed-details rendering in some browsers.
+    if (content && typeof content.checkVisibility === 'function') {
+      expect(content.checkVisibility(), `${testId} browser visibility`).to.equal(open);
+    }
+  });
+}
+
 // Clear the preceding chart before each case changes the viewport.
 describe('Profit estimator power option', { testIsolation: true }, () => {
   for (const locale of ['en', 'zh'] as const) {
@@ -148,10 +160,24 @@ describe('Profit estimator power option', { testIsolation: true }, () => {
       cy.get('[data-testid="profit-power-unavailable"]')
         .should('contain', 'GB300')
         .and('contain', hardwareReason);
+      assertDisclosureOpen('profit-power-unavailable', false);
+      cy.get('[data-testid="profit-power-unavailable"] > summary').click();
+      assertDisclosureOpen('profit-power-unavailable', true);
+      cy.get('[data-testid="profit-power-unavailable"] > p').should('be.visible');
       cy.get('[data-testid="profit-power-note"]').should(
         'contain',
-        locale === 'en' ? 'partly idle server' : '部分 GPU 闲置',
+        locale === 'en' ? 'unmeasured components are modeled' : '未实测的组件功耗由模型估算',
       );
+      assertDisclosureOpen('profit-power-assumptions', false);
+      cy.get('[data-testid="profit-power-assumptions"] > summary').click();
+      assertDisclosureOpen('profit-power-assumptions', true);
+      cy.get('[data-testid="profit-power-assumptions"] > p')
+        .should('be.visible')
+        .and('contain', locale === 'en' ? 'partly idle server' : '部分 GPU 闲置');
+      cy.get('[data-testid="profit-power-assumptions"] > summary').click();
+      cy.get('[data-testid="profit-power-unavailable"] > summary').click();
+      assertDisclosureOpen('profit-power-assumptions', false);
+      assertDisclosureOpen('profit-power-unavailable', false);
       cy.get('[data-testid="profit-power-note"]').then(($note) => {
         const box = $note[0].getBoundingClientRect();
         expect(box.left).to.be.at.least(0);
@@ -285,7 +311,7 @@ describe('Profit estimator power option', { testIsolation: true }, () => {
     cy.get('#profit-target').should('have.value', '45');
     chart().find('text.revenue-label').should('have.length', 6);
     chart().should('contain', 'B200').and('contain', 'B300').and('contain', 'MI355X');
-    chart().should('contain', 'Measured + modeled').and('contain', 'Provisioned');
+    chart().should('contain', 'All in Measured').and('contain', 'All in Provisioned');
     cy.get('[data-testid="profit-power-unavailable"]').should('contain', 'GB300');
   });
 
@@ -297,7 +323,7 @@ describe('Profit estimator power option', { testIsolation: true }, () => {
       .invoke('text')
       .then((original) => {
         cy.get('#profit-power').click();
-        cy.get('[role="option"]').contains('Measured + modeled power').click();
+        cy.get('[role="option"]').contains('All in Measured').click();
         // These existing fixtures intentionally have throughput but no validated power.
         cy.get('[data-testid="profit-power-unavailable"]').should(
           'contain',
@@ -308,7 +334,7 @@ describe('Profit estimator power option', { testIsolation: true }, () => {
         cy.get('[data-testid="profit-price-source-selector"]').should('contain', 'Moonshot');
         cy.get('[data-testid="profit-estimator-chart"]').should('not.exist');
         cy.get('#profit-power').click();
-        cy.get('[role="option"]').contains('Provisioned power').click();
+        cy.get('[role="option"]').contains('All in Provisioned').click();
         bars().its('length').should('be.greaterThan', 0);
         chart().should('have.text', original);
       });
diff --git a/packages/app/src/app/api/v1/views/extensions.test.ts b/packages/app/src/app/api/v1/views/extensions.test.ts
index 99402904f..6e3722cf4 100644
--- a/packages/app/src/app/api/v1/views/extensions.test.ts
+++ b/packages/app/src/app/api/v1/views/extensions.test.ts
@@ -416,7 +416,7 @@ describe('new dashboard projections', () => {
         expect(output.skipped).toEqual([]);
         expect(output.rows.map((row: { powerLabel: string }) => row.powerLabel)).toEqual(
           powerBasis === 'compare'
-            ? ['Provisioned', 'Measured + modeled · Full-chassis extrapolation']
+            ? ['All in Provisioned', 'All in Measured · Full-chassis extrapolation']
             : ['Full-chassis extrapolation'],
         );
       }
diff --git a/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx b/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx
index eb6025cad..0db86a2aa 100644
--- a/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx
+++ b/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx
@@ -60,6 +60,7 @@ import { captionControlTriggerClassName, ResultContext } from '@/components/ui/r
 import { SearchableSelect } from '@/components/ui/searchable-select';
 import { Skeleton } from '@/components/ui/skeleton';
 import { TooltipProvider } from '@/components/ui/tooltip';
+import { ALL_IN_MEASURED_NOTE, POWER_BASIS_LABELS } from '@/lib/power-basis';
 import { useComparisonChangelogs } from '@/hooks/api/use-comparison-changelogs';
 import { useOpenRouterPricing } from '@/hooks/api/use-openrouter-pricing';
 import { useOpenDropdown } from '@/hooks/useOpenDropdown';
@@ -207,17 +208,20 @@ const STRINGS = {
     powerTooltip:
       'Change only the power budget used to scale the same benchmark result to one GW. Pricing, throughput, utilization and unit costs stay the same.',
     powerOptions: {
-      provisioned: 'Provisioned power',
-      modeled: 'Measured + modeled power',
+      provisioned: POWER_BASIS_LABELS['utility-provisioned'].en,
+      modeled: POWER_BASIS_LABELS['utility-modeled'].en,
       compare: 'Compare both',
     },
     powerBarLabels: {
-      provisioned: 'Provisioned',
-      modeled: 'Measured + modeled',
+      provisioned: POWER_BASIS_LABELS['utility-provisioned'].en,
+      modeled: POWER_BASIS_LABELS['utility-modeled'].en,
       extrapolated: 'Full-chassis extrapolation',
     },
-    powerPreview:
-      'PowerX estimate · Same target, throughput, pricing and unit costs. GPU power comes from the same serving-frontier points; power between them is estimated linearly. Server overhead is modeled, with PUE 1.3 and 10% headroom. Full-chassis extrapolation fills an eight-GPU server with replicas of the measured 1/2/4-GPU workload at the same per-GPU power and throughput; it does not measure a partly idle server. AgentX system power is not yet qualified.',
+    powerPreview: `${ALL_IN_MEASURED_NOTE.en} AgentX system power is not yet qualified.`,
+    powerDetailsLabel: 'Power assumptions',
+    powerDetails:
+      'GPU power is interpolated between the same throughput points. Includes PUE 1.3 and 10% headroom. Full-chassis extrapolation fills an eight-GPU server with replicas of the measured 1/2/4-GPU workload at the same per-GPU power and throughput; it does not measure a partly idle server.',
+    unavailableEstimates: (count: number) => `Unavailable estimates (${count})`,
     pricingGroup: 'Pricing Config',
     costProviderLabel: 'Cost Provider',
     costProviderTooltip:
@@ -329,13 +333,20 @@ const STRINGS = {
     powerTooltip:
       '仅更改将同一基准测试结果换算为每 GW 收益时采用的功耗预算。价格、吞吐量、利用率和单位成本保持不变。',
     powerOptions: {
-      provisioned: '预配功耗',
-      modeled: '实测 GPU + 系统功耗估算',
+      provisioned: POWER_BASIS_LABELS['utility-provisioned'].zh,
+      modeled: POWER_BASIS_LABELS['utility-modeled'].zh,
       compare: '对比两种估算方式',
     },
-    powerBarLabels: { provisioned: '预配功耗', modeled: '实测 + 估算', extrapolated: '整机外推' },
-    powerPreview:
-      'PowerX 估算 · 两种方式采用相同的目标交互性、吞吐量、价格和单位成本。GPU 功耗取自同一组性能前沿数据点，点间功耗采用线性估算。服务器开销由模型估算，PUE 为 1.3，功耗余量为 10%。整机外推假设在八卡服务器上部署多个相同的实测单卡、双卡或四卡实例，每卡功耗和吞吐量保持不变；它不代表部分 GPU 闲置时的整机实测功耗。AgentX 系统功耗模型尚未完成验证。',
+    powerBarLabels: {
+      provisioned: POWER_BASIS_LABELS['utility-provisioned'].zh,
+      modeled: POWER_BASIS_LABELS['utility-modeled'].zh,
+      extrapolated: '整机外推',
+    },
+    powerPreview: `${ALL_IN_MEASURED_NOTE.zh} AgentX 系统功耗模型尚未完成验证。`,
+    powerDetailsLabel: '功耗估算假设',
+    powerDetails:
+      'GPU 功耗在相同的吞吐量数据点间插值，计入 PUE 1.3 和 10% 功耗余量。整机外推假设八卡服务器部署多个相同的实测单卡、双卡或四卡实例，每卡功耗和吞吐量保持不变；它不代表部分 GPU 闲置时的整机实测功耗。',
+    unavailableEstimates: (count: number) => `无法估算（${count} 项）`,
     pricingGroup: '定价配置',
     costProviderLabel: '成本供应商',
     costProviderTooltip:
@@ -1383,15 +1394,37 @@ function ProfitEstimatorInner({
           )}
         </Heading>
         {powerControlsEnabled && (
-          <p className="mb-2 text-xs text-muted-foreground" data-testid="profit-power-note">
-            {t.powerLabel}: {t.powerOptions[powerBasis]}
-            {powerBasis !== 'provisioned' && <>. {t.powerPreview}</>}
-          </p>
+          <div className="mb-2 text-xs text-muted-foreground" data-testid="profit-power-note">
+            <p>
+              {t.powerLabel}: {t.powerOptions[powerBasis]}
+              {powerBasis !== 'provisioned' && <>. {t.powerPreview}</>}
+            </p>
+            {powerBasis !== 'provisioned' && (
+              <details className="mt-1" data-testid="profit-power-assumptions">
+                <summary
+                  className="cursor-pointer"
+                  onClick={() => track('profit_estimator_power_assumptions_toggled')}
+                >
+                  {t.powerDetailsLabel}
+                </summary>
+                <p className="mt-1">{t.powerDetails}</p>
+              </details>
+            )}
+          </div>
         )}
         {basis === 'gw-year' && powerBasis !== 'provisioned' && fullEstimate.skipped.length > 0 && (
-          <p className="mb-2 text-xs text-muted-foreground" data-testid="profit-power-unavailable">
-            {powerUnavailable}
-          </p>
+          <details
+            className="mb-2 text-xs text-muted-foreground"
+            data-testid="profit-power-unavailable"
+          >
+            <summary
+              className="cursor-pointer"
+              onClick={() => track('profit_estimator_power_unavailable_toggled')}
+            >
+              {t.unavailableEstimates(fullEstimate.skipped.length)}
+            </summary>
+            <p className="mt-1">{powerUnavailable}</p>
+          </details>
         )}
         <ResultContext
           locale={locale}
@@ -1523,7 +1556,7 @@ function ProfitEstimatorInner({
       ...(powerControlsEnabled
         ? [
             `${t.powerLabel}: ${t.powerOptions[powerBasis]}`,
-            ...(powerBasis === 'provisioned' ? [] : [t.powerPreview]),
+            ...(powerBasis === 'provisioned' ? [] : [t.powerPreview, t.powerDetails]),
           ]
         : []),
     ]);
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index cfc859e7f..146eb84f4 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -16,6 +16,7 @@ import { metricRowLabel } from '@/components/inference/axis-metric-explanations'
 import { getMeasuredMetricConfig } from '@/components/inference/measured-metric-config';
 import { AIR_COOLED_SYSTEM_PUE } from '@/lib/modeled-system-power';
 import { SYSTEM_POWER_MODEL_REVISION } from '@/lib/system-power-model';
+import { ALL_IN_MEASURED_NOTE } from '@/lib/power-basis';
 import {
   applyTokenRevenuePricing,
   cachedInputPricePerMillion,
@@ -146,15 +147,15 @@ const STRINGS = {
     noSystemPowerData:
       'No system-power estimates are available for this selection. Choose 8K / 1K with validated GPU telemetry, supported hardware, and known eight-GPU chassis placement. Measured GPU power remains available separately where telemetry exists.',
     noUtilityModeledData:
-      'No utility modeled values are available for this selection. The utility modeled boundary needs 8K / 1K, validated GPU telemetry, and hardware covered by the chassis power model (not NVL72 systems). Choose another boundary to keep the points.',
+      'No values are available for All in Measured in this selection. This boundary needs 8K / 1K, validated GPU telemetry, and hardware covered by the chassis power model (not NVL72 systems). Choose another boundary to keep the points.',
     // Boundary disclosures for the derived power axes (lib/power-basis.ts).
     // Formulas in words; constants named so a screenshot records its method.
     powerBasisAssumptions: {
       'gpu-provisioned':
-        'GPU provisioned boundary · Watts are the rated TDP per GPU from the hardware registry, so the power curve is flat per hardware. Joules per output token = TDP × allocated GPUs ÷ whole-deployment output tok/s; disaggregated configurations count prefill and decode GPUs together. Hardware without a published TDP is omitted.',
+        'GPU Level Provisioned (TDP) · Watts are the rated TDP per GPU from the hardware registry, so the power curve is flat per hardware. Joules per output token = TDP × allocated GPUs ÷ whole-deployment output tok/s; disaggregated configurations count prefill and decode GPUs together. Hardware without a published TDP is omitted.',
       'utility-provisioned':
-        'Utility provisioned boundary · Watts are the all-in provisioned utility power per GPU from the hardware registry (SemiAnalysis Datacenter Industry Model), so the power curve is flat per hardware. Joules per output token = all-in W × allocated GPUs ÷ whole-deployment output tok/s; disaggregated configurations count prefill and decode GPUs together, unlike the ungated All-in Provisioned J per Output Token, which divides per decode GPU.',
-      'utility-modeled': `Utility modeled boundary · Measured GPU power carried through the modeled chassis (CPU, DRAM, platform, PSU losses) to the utility meter: modeled chassis AC × PUE ${AIR_COOLED_SYSTEM_PUE} (air-cooled, applied once), divided by the measured GPUs; joules per output token scale measured joules by the same ratio. Chassis power model revision ${SYSTEM_POWER_MODEL_REVISION.slice(0, 7)}. Available for 8K / 1K with validated telemetry on supported hardware only; NVL72 systems (GB200, GB300) and points without values are omitted.`,
+        'All in Provisioned · Watts are the all-in provisioned utility power per GPU from the hardware registry (SemiAnalysis Datacenter Industry Model), so the power curve is flat per hardware. Joules per output token = all-in W × allocated GPUs ÷ whole-deployment output tok/s; disaggregated configurations count prefill and decode GPUs together, unlike the ungated All-in Provisioned J per Output Token, which divides per decode GPU.',
+      'utility-modeled': `All in Measured · Measured GPU power carried through the modeled chassis (CPU, DRAM, platform, PSU losses) to the utility meter: modeled chassis AC × PUE ${AIR_COOLED_SYSTEM_PUE} (air-cooled, applied once), divided by the measured GPUs; joules per output token scale measured joules by the same ratio. Chassis power model revision ${SYSTEM_POWER_MODEL_REVISION.slice(0, 7)}. Available for 8K / 1K with validated telemetry on supported hardware only; NVL72 systems (GB200, GB300) and points without values are omitted.`,
     },
     vsTtft: (word: string) => `vs. ${word} Time To First Token`,
     vsE2eLatency: (pctl?: string) =>
@@ -183,13 +184,13 @@ const STRINGS = {
     noSystemPowerData:
       '当前选择没有可用的系统功耗估算。请选择 8K / 1K 场景；估算仅覆盖 GPU 遥测已验证、硬件受支持、八卡机箱位置已知的运行。存在遥测数据时，仍可单独查看 GPU 实测功耗。',
     noUtilityModeledData:
-      '当前选择没有可用的数据中心建模数值。该边界需要 8K / 1K 场景、已验证的 GPU 遥测，且硬件在机箱功耗模型覆盖范围内（不含 NVL72 系统）。可切换到其他功耗边界以保留数据点。',
+      '当前选择没有可用的整体实测功耗数值。该边界需要 8K / 1K 场景、已验证的 GPU 遥测，且硬件在机箱功耗模型覆盖范围内（不含 NVL72 系统）。可切换到其他功耗边界以保留数据点。',
     powerBasisAssumptions: {
       'gpu-provisioned':
-        'GPU 额定边界 · 功率取硬件注册表中每 GPU 的额定 TDP，因此每种硬件的功率曲线为水平线。每输出 token 能耗 = TDP × 分配的 GPU 数 ÷ 整个部署的输出 tok/s；分离式配置将 prefill 与 decode GPU 一并计入。未公布 TDP 的硬件不绘制。',
+        'GPU 额定功耗（TDP）· 功率取硬件注册表中每 GPU 的额定 TDP，因此每种硬件的功率曲线为水平线。每输出 token 能耗 = TDP × 分配的 GPU 数 ÷ 整个部署的输出 tok/s；分离式配置将 prefill 与 decode GPU 一并计入。未公布 TDP 的硬件不绘制。',
       'utility-provisioned':
-        '全电源配置边界 · 功率取硬件注册表中每 GPU 的全电源配置（all-in）市电功率（来源：SemiAnalysis Datacenter Industry Model），因此每种硬件的功率曲线为水平线。每输出 token 能耗 = all-in 功率 × 分配的 GPU 数 ÷ 整个部署的输出 tok/s；分离式配置将 prefill 与 decode GPU 一并计入，这与未加门控的“每输出 token 全电源配置能耗”按 decode GPU 计算不同。',
-      'utility-modeled': `数据中心建模边界 · 将 GPU 实测功耗经机箱功耗模型（CPU、DRAM、平台开销、PSU 损耗）推算至市电侧：机箱交流功耗估算 × PUE ${AIR_COOLED_SYSTEM_PUE}（风冷，仅应用一次），再除以实测 GPU 数；每输出 token 能耗按同一比例放大实测能耗。机箱功耗模型版本 ${SYSTEM_POWER_MODEL_REVISION.slice(0, 7)}。仅适用于 8K / 1K、遥测已验证且硬件受支持的运行；NVL72 系统（GB200、GB300）及缺少数值的数据点不绘制。`,
+        '整体预配功耗 · 功率取硬件注册表中每 GPU 的全电源配置（all-in）市电功率（来源：SemiAnalysis Datacenter Industry Model），因此每种硬件的功率曲线为水平线。每输出 token 能耗 = all-in 功率 × 分配的 GPU 数 ÷ 整个部署的输出 tok/s；分离式配置将 prefill 与 decode GPU 一并计入，这与未加门控的“每输出 token 全电源配置能耗”按 decode GPU 计算不同。',
+      'utility-modeled': `整体实测功耗 · 将 GPU 实测功耗经机箱功耗模型（CPU、DRAM、平台开销、PSU 损耗）推算至市电侧：机箱交流功耗估算 × PUE ${AIR_COOLED_SYSTEM_PUE}（风冷，仅应用一次），再除以实测 GPU 数；每输出 token 能耗按同一比例放大实测能耗。机箱功耗模型版本 ${SYSTEM_POWER_MODEL_REVISION.slice(0, 7)}。仅适用于 8K / 1K、遥测已验证且硬件受支持的运行；NVL72 系统（GB200、GB300）及缺少数值的数据点不绘制。`,
     },
     vsTtft: (word: string) => `vs. ${word === 'Median' ? '中位' : word} 首 token 延迟（TTFT）`,
     vsE2eLatency: (pctl?: string) => (pctl ? `vs. ${pctl} 端到端延迟` : 'vs. 端到端延迟'),
@@ -1218,6 +1219,16 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                               {t.powerBasisAssumptions[selectedPowerBasis]}
                             </p>
                           )}
+                          {selectedPowerBasis &&
+                            powerCompare === 'boundaries' &&
+                            selectedPowerBasis !== 'utility-modeled' && (
+                              <p
+                                className="mb-2 text-xs text-muted-foreground"
+                                data-testid="power-compare-model-note"
+                              >
+                                {ALL_IN_MEASURED_NOTE[locale]}
+                              </p>
+                            )}
                           {isUnofficialRun &&
                             selectedXAxisMode === 'e2e-normalized-interactivity' && (
                               <p className="mb-2 text-xs text-muted-foreground">
diff --git a/packages/app/src/components/inference/ui/InferenceTable.test.ts b/packages/app/src/components/inference/ui/InferenceTable.test.ts
index 09294dddc..e40a43589 100644
--- a/packages/app/src/components/inference/ui/InferenceTable.test.ts
+++ b/packages/app/src/components/inference/ui/InferenceTable.test.ts
@@ -86,9 +86,9 @@ describe('InferenceTable sorting logic', () => {
               ['Prefill GPUs', '760'],
             ]
           : [
-              ['GPU measured', '708'],
-              ['GPU provisioned (TDP)', '1,400'],
-              ['Utility provisioned (all-in)', '1,920'],
+              ['GPU Level Measured', '708'],
+              ['GPU Level Provisioned (TDP)', '1,400'],
+              ['All in Provisioned', '1,920'],
             ],
       );
       expect(points.every((point) => point.measuredAvgPower?.y === 708.1)).toBe(true);
diff --git a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
index d2d585611..02cdf64c3 100644
--- a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
+++ b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
@@ -8,7 +8,12 @@ import {
   SelectValue,
 } from '@/components/ui/select';
 import { track } from '@/lib/analytics';
-import { POWER_BASES, POWER_BASIS_LABELS, type PowerBasis } from '@/lib/power-basis';
+import {
+  ALL_IN_MEASURED_NOTE,
+  POWER_BASES,
+  POWER_BASIS_LABELS,
+  type PowerBasis,
+} from '@/lib/power-basis';
 import { useLocale } from '@/lib/use-locale';
 import {
   changeMeasuredMetricConfig,
@@ -22,7 +27,7 @@ const STRINGS = {
   en: {
     basis: 'Boundary',
     basisHelp:
-      'Where power is counted. GPU measured: runner telemetry from the GPU boards. GPU provisioned: rated TDP per GPU. Utility provisioned: all-in provisioned utility power per GPU. Utility modeled: measured GPU power carried through the modeled chassis to the utility meter with PUE. Points without a value for the chosen boundary are omitted, never replaced with an estimate.',
+      'Choose GPU-only or all-in power, including server overhead and PUE. Provisioned values use rated capacity; measured values start from GPU telemetry. Points without the selected value are omitted.',
     scope: 'Scope',
     scopeHelp:
       'All GPUs measures the whole deployment. Prefill and decode select only GPUs serving that role.',
@@ -49,7 +54,7 @@ const STRINGS = {
       'Energy is shown in joules. Energy per successful query can also be shown in watt-hours.',
     compare: 'Compare',
     compareHelp:
-      'Overlay sibling series on the same points, in the hardware colour with a dash per series. All boundaries: GPU measured, GPU provisioned, utility provisioned and utility modeled. Prefill vs decode: each worker pool next to the whole deployment; on the energy axis the prefill pool is carried onto the output-token axis by the served input:output ratio. Available for the whole-deployment average W/chip and J per output token.',
+      'Compare power boundaries or prefill and decode on the same benchmark points. Role energy uses a common output-token denominator. Available for average W/chip and J per output token.',
     compareNone: 'Off',
     compareBoundaries: 'All boundaries',
     compareRoles: 'Prefill vs decode',
@@ -57,7 +62,7 @@ const STRINGS = {
   zh: {
     basis: '功耗边界',
     basisHelp:
-      '选择功耗的计量边界。GPU 实测：来自 GPU 板卡的运行器遥测；GPU 额定：每 GPU 的额定 TDP；全电源配置：每 GPU 的全电源配置（all-in）市电功率；数据中心建模：将 GPU 实测功耗经机箱功耗模型推算至市电侧并计入 PUE。所选边界缺少数值的数据点将被省略，不会用估算值替代。',
+      '选择仅统计 GPU，或计入服务器其他组件及 PUE 的整体功耗。预配值按额定容量计算，实测值以 GPU 遥测为基础。缺少所选数值的数据点不绘制。',
     scope: '统计范围',
     scopeHelp: '全部 GPU 对应整个部署；预填充和解码仅统计承担相应任务的 GPU。',
     all: '全部 GPU',
@@ -82,7 +87,7 @@ const STRINGS = {
     unitHelp: '能耗以焦耳显示；每个成功请求的能耗也可显示为瓦时。',
     compare: '对比',
     compareHelp:
-      '在同一批数据点上叠加同源系列：颜色仍按硬件区分，每个系列用不同虚线表示。全部边界：GPU 实测、GPU 额定、全电源配置、数据中心建模；预填充 vs 解码：各 worker 池与整个部署并列，能耗轴上的预填充能耗按实际服务的输入/输出 token 比折算到每输出 token。仅适用于整个部署的平均 W/芯片和每输出 token 能耗。',
+      '在同一批基准测试数据点上对比不同功耗边界，或预填充与解码。各角色的能耗统一按输出 token 归一化。支持平均 W/芯片和每输出 token 能耗。',
     compareNone: '关闭',
     compareBoundaries: '全部边界',
     compareRoles: '预填充 vs 解码',
@@ -334,6 +339,14 @@ export function MeasuredMetricControls({
           </Select>
         </div>
       )}
+      {(config.basis === 'utility-modeled' || compare === 'boundaries') && (
+        <p
+          className="col-span-full text-xs text-muted-foreground"
+          data-testid="all-in-measured-note"
+        >
+          {ALL_IN_MEASURED_NOTE[locale]}
+        </p>
+      )}
     </div>
   );
 }
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 8e94b1394..86c5e9286 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -1015,7 +1015,7 @@ export const apiContractSourceDigests = [
 
   {
     source: 'src/lib/views-api/calculator-extensions.ts',
-    sourceSha256: '0e2b050b483b505b9118336f6639594c8f82470e885c6356c4f2dc5790d39fec',
+    sourceSha256: '2bcd27b5f5fbea9dcd75b32f7ee88e1c92343bed3ff65a293fc9a8ff5ecf04c3',
     reviewArea: {
       en: 'Dashboard read-only selector and calculation parity.',
       zh: '仪表板只读接口的选择项与计算一致性。',
diff --git a/packages/app/src/lib/power-basis.ts b/packages/app/src/lib/power-basis.ts
index 256e63f2a..434720af2 100644
--- a/packages/app/src/lib/power-basis.ts
+++ b/packages/app/src/lib/power-basis.ts
@@ -28,10 +28,15 @@ export type PowerBasis = (typeof POWER_BASES)[number];
 export type PowerQuantity = 'watts' | 'energy';
 
 export const POWER_BASIS_LABELS: Record<PowerBasis, { en: string; zh: string }> = {
-  'gpu-measured': { en: 'GPU measured', zh: 'GPU 实测' },
-  'gpu-provisioned': { en: 'GPU provisioned (TDP)', zh: 'GPU 额定（TDP）' },
-  'utility-provisioned': { en: 'Utility provisioned (all-in)', zh: '全电源配置（all-in）' },
-  'utility-modeled': { en: 'Utility modeled (PUE)', zh: '数据中心建模（含 PUE）' },
+  'gpu-measured': { en: 'GPU Level Measured', zh: 'GPU 实测功耗' },
+  'gpu-provisioned': { en: 'GPU Level Provisioned (TDP)', zh: 'GPU 额定功耗（TDP）' },
+  'utility-provisioned': { en: 'All in Provisioned', zh: '整体预配功耗' },
+  'utility-modeled': { en: 'All in Measured', zh: '整体实测功耗' },
+};
+
+export const ALL_IN_MEASURED_NOTE = {
+  en: 'GPU power is measured; unmeasured components are modeled, with PUE included.',
+  zh: 'GPU 功耗来自实测；未实测的组件功耗由模型估算，并计入数据中心 PUE。',
 };
 
 /** InferenceData keys per derived basis and quantity. B1 lives on the measured* fields. */
diff --git a/packages/app/src/lib/views-api/calculator-extensions.ts b/packages/app/src/lib/views-api/calculator-extensions.ts
index e42b1b9f3..ba33414f7 100644
--- a/packages/app/src/lib/views-api/calculator-extensions.ts
+++ b/packages/app/src/lib/views-api/calculator-extensions.ts
@@ -16,6 +16,7 @@ import { fetchOpenRouterPricing } from '@/hooks/api/use-openrouter-pricing';
 import { cachedJson } from '@/lib/api-cache';
 import { getGpuSpecs } from '@/lib/constants';
 import { getOpenRouterModelId, Sequence, type Model } from '@/lib/data-mappings';
+import { POWER_BASIS_LABELS } from '@/lib/power-basis';
 import type { NextRequest } from 'next/server';
 import { runViewsRoute, ViewsApiParamError } from './errors';
 import {
@@ -206,8 +207,8 @@ export function calculatorExtension(view: CalculatorExtension, request: NextRequ
         powerBasis,
         target,
         {
-          provisioned: 'Provisioned',
-          modeled: 'Measured + modeled',
+          provisioned: POWER_BASIS_LABELS['utility-provisioned'].en,
+          modeled: POWER_BASIS_LABELS['utility-modeled'].en,
           extrapolated: 'Full-chassis extrapolation',
         },
       );
diff --git a/packages/app/src/lib/views-api/docs/extensions.ts b/packages/app/src/lib/views-api/docs/extensions.ts
index f3d988a70..b4ef43114 100644
--- a/packages/app/src/lib/views-api/docs/extensions.ts
+++ b/packages/app/src/lib/views-api/docs/extensions.ts
@@ -122,8 +122,8 @@ const PARAMETER_NOTES: Record<string, [string, string]> = {
     '模型许可或收入分成百分比，范围 0 至 100，默认值随模型变化。',
   ],
   powerBasis: [
-    'provisioned (default), modeled or compare. Modeled power requires eligible measured source rows; estimates extrapolated from partial-GPU measurements to a full chassis are identified by powerLabel. Missing coverage is not zero.',
-    'provisioned（默认）、modeled 或 compare。建模功耗需要符合条件的实测数据行；由部分 GPU 的实测数据外推到整机的估算，会通过 powerLabel 标明。缺失数据不按零处理。',
+    'provisioned (default, All in Provisioned), modeled (All in Measured) or compare. All in Measured uses measured GPU power plus modeled unmeasured components and PUE; it is not measured wall power. Eligible measured source rows are required; powerLabel identifies paired estimates and full-chassis extrapolation. Missing coverage is not zero.',
+    'provisioned（默认，整体预配功耗）、modeled（整体实测功耗）或 compare。整体实测功耗采用 GPU 实测值，加上未实测组件的功耗估算和 PUE，并非墙上电表读数。该估算需要符合条件的实测数据行；powerLabel 标明对比方式和整机外推。缺失数据不按零处理。',
   ],
   power: [
     'Comma-separated certified and/or legacy power tiers. Omit for all tiers.',
diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index 2979d5dbe..077eb9f5f 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -8,7 +8,7 @@
     "references/cli-contract.md": "fa44faa38d889b4fbdee5ba42752b47758ee3706fab150513bd4e6db87a86cb0",
     "references/cli.md": "96b228f34cb3600f4548f4dc84df8506531747286763c56ca834c77bee05e1eb",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "3ccdb82ffcf7f7d3295dba4b9bcd95339d7c9cbf260135a6370a923d23bb5b21",
+    "references/dashboard-views.md": "a0dbafddaadc073d3a8ae3c106495074ecc8133e3c63eaecf583bff7a89b69d5",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/pareto.md": "1b4d2d163f982e3f2d97addce310789eae9c1e5badd82dd7501708c9e0385027",
     "references/powerx.md": "cf8adcc5dfe395c5fb659908819980a872475f862f22b723815af43d363cedad",
diff --git a/packages/skills/skills/inferencex-api/references/dashboard-views.md b/packages/skills/skills/inferencex-api/references/dashboard-views.md
index 5d51d9bde..8535b05bd 100644
--- a/packages/skills/skills/inferencex-api/references/dashboard-views.md
+++ b/packages/skills/skills/inferencex-api/references/dashboard-views.md
@@ -85,6 +85,13 @@ envelope. `frontier.direction` describes that boundary; `metric.direction` retai
 the optimization direction used by `best=true`. Interpret the envelope as a load
 boundary, not evidence that those points are more energy efficient.
 
+The dashboard names its four boundaries GPU Level Measured, GPU Level Provisioned
+(TDP), All in Provisioned, and All in Measured. All in Measured combines measured
+GPU power with modeled unmeasured components and PUE; do not describe it as measured
+wall power. Metric IDs and API selector values are unchanged. Profit `powerBasis`
+still accepts `provisioned`, `modeled`, or `compare`; `powerLabel` is display text.
+Expanding assumptions or unavailable-estimate details does not change returned data.
+
 Prefer equal-service comparisons for article-facing hardware analysis. Use
 `xstat=mean` only for fixed-sequence service axes when that statistic is intended:
 streaming speed then means **1 / mean TPOT**, not arithmetic mean request speed.

From 2f982f8c2653a5a2d4d0860484596ba20e84eede Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 17:57:03 -0700
Subject: [PATCH 080/103] test: capture power menu after selection assertions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：在完成功耗选项交互断言后再截图，避免 Chrome 截图关闭下拉菜单影响后续验证。
---
 .../app/cypress/component/measured-metric-controls.cy.tsx    | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/packages/app/cypress/component/measured-metric-controls.cy.tsx b/packages/app/cypress/component/measured-metric-controls.cy.tsx
index 1e1abf9ab..c1d163ced 100644
--- a/packages/app/cypress/component/measured-metric-controls.cy.tsx
+++ b/packages/app/cypress/component/measured-metric-controls.cy.tsx
@@ -37,7 +37,6 @@ describe('Power boundary labels', () => {
       cy.get('[role="option"]').should(($options) => {
         expect([...$options].map((option) => option.textContent?.trim())).to.deep.equal(labels);
       });
-      cy.screenshot(`power-boundary-options-${locale}`, { overwrite: true });
       cy.get('[role="option"][data-value="gpu-provisioned"]').click();
       cy.get('[data-testid="selected-metric"]').should('have.text', 'y_gpuProvisionedWatts');
       cy.get('[data-testid="measured-power-basis"]').click();
@@ -64,6 +63,10 @@ describe('Power boundary labels', () => {
       cy.get('[role="option"][data-value="gpu-measured"]').click();
       cy.get('[data-testid="selected-metric"]').should('have.text', 'y_measuredAvgPower');
       cy.get('[data-testid="all-in-measured-note"]').should('not.exist');
+      // Finish selection assertions before a screenshot can dismiss the open Radix menu.
+      cy.get('[data-testid="measured-power-basis"]').click();
+      cy.get('[role="option"]').should('be.visible');
+      cy.screenshot(`power-boundary-options-${locale}`, { overwrite: true });
     });
   }
 });

From 36ceb86c9812a9802d7346200ef8e769a0a0ce23 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Wed, 30 Sep 2026 01:21:55 -0700
Subject: [PATCH 081/103] fix: trim profit power note and explain empty All in
 Measured charts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Drop the assumptions paragraph and disclosure from the profit chart header;
the Power Estimation tooltip and CSV captions keep the methodology. Show the
All in Measured requirements in the scatter empty state instead of the generic
hint, sharing one string with ChartDisplay.

中文：精简利润图表头部的功耗说明，只保留一行功耗估算方式；估算假设移入
Power Estimation 提示框并保留在 CSV 说明中。整体实测功耗无数据时，散点图
空态改为说明该边界的前提条件，与 ChartDisplay 共用同一文案。
---
 .../cypress/component/scatter-graph.cy.tsx    | 58 +++++++++++++++++++
 .../app/cypress/e2e/profit-estimator.cy.ts    | 18 ++----
 .../calculator/ProfitEstimatorDisplay.tsx     | 24 ++------
 .../components/inference/metric-registry.ts   |  5 ++
 .../components/inference/ui/ChartDisplay.tsx  |  8 +--
 .../components/inference/ui/ScatterGraph.tsx  | 10 +++-
 packages/app/src/lib/power-basis.ts           |  5 ++
 7 files changed, 86 insertions(+), 42 deletions(-)

diff --git a/packages/app/cypress/component/scatter-graph.cy.tsx b/packages/app/cypress/component/scatter-graph.cy.tsx
index 3a06cb262..7ab5903c7 100644
--- a/packages/app/cypress/component/scatter-graph.cy.tsx
+++ b/packages/app/cypress/component/scatter-graph.cy.tsx
@@ -465,6 +465,64 @@ describe('ScatterGraph', () => {
     );
   });
 
+  it('explains why All in Measured has no points', () => {
+    mountWithProviders(
+      <div style={{ width: 800, height: 600 }}>
+        <ScatterGraph
+          chartId="test-scatter-all-in-measured-empty"
+          modelLabel="Kimi K3"
+          data={[]}
+          xLabel="Interactivity"
+          yLabel="All in Measured Power per Chip"
+          chartDefinition={defaultChartDef}
+        />
+      </div>,
+      {
+        inference: {
+          hardwareConfig: hwConfig,
+          activeHwTypes: new Set(['b200_trt']),
+          hwTypesWithData: new Set(),
+          selectedYAxisMetric: 'y_utilityModeledWatts',
+        },
+        unofficial: {},
+      },
+    );
+
+    cy.contains('No values are available for All in Measured in this selection.').should(
+      'be.visible',
+    );
+    cy.contains('No measurements to plot for this selection.').should('not.exist');
+  });
+
+  it('localizes the All in Measured explanation', () => {
+    mountWithProviders(
+      <PathnameContext.Provider value="/zh/inference">
+        <div style={{ width: 375, height: 600 }}>
+          <ScatterGraph
+            chartId="test-scatter-all-in-measured-empty-zh"
+            modelLabel="Kimi K3"
+            data={[]}
+            xLabel="交互性"
+            yLabel="每芯片整体实测功耗"
+            chartDefinition={defaultChartDef}
+          />
+        </div>
+      </PathnameContext.Provider>,
+      {
+        inference: {
+          hardwareConfig: hwConfig,
+          activeHwTypes: new Set(['b200_trt']),
+          hwTypesWithData: new Set(),
+          selectedYAxisMetric: 'y_utilityModeledJPerOutputToken',
+        },
+        unofficial: {},
+      },
+    );
+
+    cy.contains('当前选择没有可用的整体实测功耗数值。').should('be.visible');
+    cy.contains('当前选择没有可绘制的测量数据。').should('not.exist');
+  });
+
   for (const selectedYAxisMetric of ['y_tpPerGpu', 'y_measuredPrefillJPerInputToken'] as const) {
     it(`offers targeted quick-filter recovery on ${selectedYAxisMetric} without changing model, precision or date`, () => {
       mountWithProviders(
diff --git a/packages/app/cypress/e2e/profit-estimator.cy.ts b/packages/app/cypress/e2e/profit-estimator.cy.ts
index 198338c8d..af804e346 100644
--- a/packages/app/cypress/e2e/profit-estimator.cy.ts
+++ b/packages/app/cypress/e2e/profit-estimator.cy.ts
@@ -109,7 +109,7 @@ function assertDisclosureOpen(testId: string, open: boolean) {
 // Clear the preceding chart before each case changes the viewport.
 describe('Profit estimator power option', { testIsolation: true }, () => {
   for (const locale of ['en', 'zh'] as const) {
-    it(`prices DeepSeek Flash partial chassis with visible assumptions and CSV labels (${locale})`, () => {
+    it(`prices DeepSeek Flash partial chassis with a one-line power note and CSV labels (${locale})`, () => {
       stubOpenRouter();
       cy.viewport(locale === 'en' ? 1280 : 393, 900);
       cy.intercept('GET', '/api/v1/benchmarks*', {
@@ -164,19 +164,11 @@ describe('Profit estimator power option', { testIsolation: true }, () => {
       cy.get('[data-testid="profit-power-unavailable"] > summary').click();
       assertDisclosureOpen('profit-power-unavailable', true);
       cy.get('[data-testid="profit-power-unavailable"] > p').should('be.visible');
-      cy.get('[data-testid="profit-power-note"]').should(
-        'contain',
-        locale === 'en' ? 'unmeasured components are modeled' : '未实测的组件功耗由模型估算',
-      );
-      assertDisclosureOpen('profit-power-assumptions', false);
-      cy.get('[data-testid="profit-power-assumptions"] > summary').click();
-      assertDisclosureOpen('profit-power-assumptions', true);
-      cy.get('[data-testid="profit-power-assumptions"] > p')
-        .should('be.visible')
-        .and('contain', locale === 'en' ? 'partly idle server' : '部分 GPU 闲置');
-      cy.get('[data-testid="profit-power-assumptions"] > summary').click();
+      cy.get('[data-testid="profit-power-note"]')
+        .should('contain', locale === 'en' ? 'All in Measured' : '整体实测功耗')
+        .and('not.contain', locale === 'en' ? 'unmeasured components' : '未实测的组件');
+      cy.get('[data-testid="profit-power-assumptions"]').should('not.exist');
       cy.get('[data-testid="profit-power-unavailable"] > summary').click();
-      assertDisclosureOpen('profit-power-assumptions', false);
       assertDisclosureOpen('profit-power-unavailable', false);
       cy.get('[data-testid="profit-power-note"]').then(($note) => {
         const box = $note[0].getBoundingClientRect();
diff --git a/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx b/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx
index 0db86a2aa..6c1be5d32 100644
--- a/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx
+++ b/packages/app/src/components/calculator/ProfitEstimatorDisplay.tsx
@@ -218,7 +218,6 @@ const STRINGS = {
       extrapolated: 'Full-chassis extrapolation',
     },
     powerPreview: `${ALL_IN_MEASURED_NOTE.en} AgentX system power is not yet qualified.`,
-    powerDetailsLabel: 'Power assumptions',
     powerDetails:
       'GPU power is interpolated between the same throughput points. Includes PUE 1.3 and 10% headroom. Full-chassis extrapolation fills an eight-GPU server with replicas of the measured 1/2/4-GPU workload at the same per-GPU power and throughput; it does not measure a partly idle server.',
     unavailableEstimates: (count: number) => `Unavailable estimates (${count})`,
@@ -343,7 +342,6 @@ const STRINGS = {
       extrapolated: '整机外推',
     },
     powerPreview: `${ALL_IN_MEASURED_NOTE.zh} AgentX 系统功耗模型尚未完成验证。`,
-    powerDetailsLabel: '功耗估算假设',
     powerDetails:
       'GPU 功耗在相同的吞吐量数据点间插值，计入 PUE 1.3 和 10% 功耗余量。整机外推假设八卡服务器部署多个相同的实测单卡、双卡或四卡实例，每卡功耗和吞吐量保持不变；它不代表部分 GPU 闲置时的整机实测功耗。',
     unavailableEstimates: (count: number) => `无法估算（${count} 项）`,
@@ -1394,23 +1392,9 @@ function ProfitEstimatorInner({
           )}
         </Heading>
         {powerControlsEnabled && (
-          <div className="mb-2 text-xs text-muted-foreground" data-testid="profit-power-note">
-            <p>
-              {t.powerLabel}: {t.powerOptions[powerBasis]}
-              {powerBasis !== 'provisioned' && <>. {t.powerPreview}</>}
-            </p>
-            {powerBasis !== 'provisioned' && (
-              <details className="mt-1" data-testid="profit-power-assumptions">
-                <summary
-                  className="cursor-pointer"
-                  onClick={() => track('profit_estimator_power_assumptions_toggled')}
-                >
-                  {t.powerDetailsLabel}
-                </summary>
-                <p className="mt-1">{t.powerDetails}</p>
-              </details>
-            )}
-          </div>
+          <p className="mb-2 text-xs text-muted-foreground" data-testid="profit-power-note">
+            {t.powerLabel}: {t.powerOptions[powerBasis]}
+          </p>
         )}
         {basis === 'gw-year' && powerBasis !== 'provisioned' && fullEstimate.skipped.length > 0 && (
           <details
@@ -1642,7 +1626,7 @@ function ProfitEstimatorInner({
                       <LabelWithTooltip
                         htmlFor="profit-power"
                         label={t.powerLabel}
-                        tooltip={t.powerTooltip}
+                        tooltip={`${t.powerTooltip} ${t.powerPreview} ${t.powerDetails}`}
                       />
                       <div data-testid="profit-power-selector">
                         <MultiSelect
diff --git a/packages/app/src/components/inference/metric-registry.ts b/packages/app/src/components/inference/metric-registry.ts
index ee81252d4..365e566e3 100644
--- a/packages/app/src/components/inference/metric-registry.ts
+++ b/packages/app/src/components/inference/metric-registry.ts
@@ -717,6 +717,11 @@ export function isPowerBasisConfigKey(configKey: string): boolean {
   return POWER_BASIS_METRIC_CONFIG_KEY_SET.has(configKey);
 }
 
+/** The two All in Measured (utility-modeled) axes; they alone need the chassis power model. */
+export function isAllInMeasuredConfigKey(configKey: string): boolean {
+  return configKey === 'y_utilityModeledWatts' || configKey === 'y_utilityModeledJPerOutputToken';
+}
+
 export const MODELED_SYSTEM_POWER_METRIC_CONFIG_KEY = 'y_modeledChassisPowerPerGpu';
 
 /** Whether a y-axis config key plots the modeled chassis AC power metric. */
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index 146eb84f4..eb8e0a6e3 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -16,7 +16,7 @@ import { metricRowLabel } from '@/components/inference/axis-metric-explanations'
 import { getMeasuredMetricConfig } from '@/components/inference/measured-metric-config';
 import { AIR_COOLED_SYSTEM_PUE } from '@/lib/modeled-system-power';
 import { SYSTEM_POWER_MODEL_REVISION } from '@/lib/system-power-model';
-import { ALL_IN_MEASURED_NOTE } from '@/lib/power-basis';
+import { ALL_IN_MEASURED_EMPTY, ALL_IN_MEASURED_NOTE } from '@/lib/power-basis';
 import {
   applyTokenRevenuePricing,
   cachedInputPricePerMillion,
@@ -146,8 +146,6 @@ const STRINGS = {
       'No benchmark data matches the current model, scenario, and filter selection. Adjust the filters above to see results.',
     noSystemPowerData:
       'No system-power estimates are available for this selection. Choose 8K / 1K with validated GPU telemetry, supported hardware, and known eight-GPU chassis placement. Measured GPU power remains available separately where telemetry exists.',
-    noUtilityModeledData:
-      'No values are available for All in Measured in this selection. This boundary needs 8K / 1K, validated GPU telemetry, and hardware covered by the chassis power model (not NVL72 systems). Choose another boundary to keep the points.',
     // Boundary disclosures for the derived power axes (lib/power-basis.ts).
     // Formulas in words; constants named so a screenshot records its method.
     powerBasisAssumptions: {
@@ -183,8 +181,6 @@ const STRINGS = {
     noChartData: '当前模型、场景与筛选条件下没有匹配的基准测试数据。请调整上方筛选条件查看结果。',
     noSystemPowerData:
       '当前选择没有可用的系统功耗估算。请选择 8K / 1K 场景；估算仅覆盖 GPU 遥测已验证、硬件受支持、八卡机箱位置已知的运行。存在遥测数据时，仍可单独查看 GPU 实测功耗。',
-    noUtilityModeledData:
-      '当前选择没有可用的整体实测功耗数值。该边界需要 8K / 1K 场景、已验证的 GPU 遥测，且硬件在机箱功耗模型覆盖范围内（不含 NVL72 系统）。可切换到其他功耗边界以保留数据点。',
     powerBasisAssumptions: {
       'gpu-provisioned':
         'GPU 额定功耗（TDP）· 功率取硬件注册表中每 GPU 的额定 TDP，因此每种硬件的功率曲线为水平线。每输出 token 能耗 = TDP × 分配的 GPU 数 ÷ 整个部署的输出 tok/s；分离式配置将 prefill 与 decode GPU 一并计入。未公布 TDP 的硬件不绘制。',
@@ -895,7 +891,7 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                 {isModeledSystemPowerConfigKey(selectedYAxisMetric)
                   ? t.noSystemPowerData
                   : selectedPowerBasis === 'utility-modeled'
-                    ? t.noUtilityModeledData
+                    ? ALL_IN_MEASURED_EMPTY[locale]
                     : t.noChartData}
               </p>
             </Card>,
diff --git a/packages/app/src/components/inference/ui/ScatterGraph.tsx b/packages/app/src/components/inference/ui/ScatterGraph.tsx
index 2716396c5..e23738e50 100644
--- a/packages/app/src/components/inference/ui/ScatterGraph.tsx
+++ b/packages/app/src/components/inference/ui/ScatterGraph.tsx
@@ -139,6 +139,7 @@ import {
 import { usePowerTraceAction } from '@/components/inference/hooks/usePowerTraceAction';
 import { QuickFiltersDialog } from '@/components/inference/ui/QuickFiltersDialog';
 import { ScatterEmptyState } from '@/components/inference/ui/ScatterEmptyState';
+import { ALL_IN_MEASURED_EMPTY } from '@/lib/power-basis';
 import {
   scatterPointConfigId,
   scatterPointJoinId,
@@ -162,6 +163,7 @@ import FrontierPointsPanel from '@/components/inference/ui/FrontierPointsPanel';
 import LegendPointsDialog from '@/components/inference/ui/LegendPointsDialog';
 import { renderOffloadHalo } from '@/components/inference/utils/offload-halo';
 import {
+  isAllInMeasuredConfigKey,
   isMeasuredEnergyConfigKey,
   isRoleLocalMeasuredEnergyConfigKey,
 } from '@/components/inference/metric-registry';
@@ -4216,9 +4218,11 @@ const ScatterGraph = React.memo(
           emptyReason === 'selection'
             ? isRoleLocalMeasuredEnergyConfigKey(selectedYAxisMetric)
               ? legendT.noRoleEnergyDataHint
-              : isMeasuredEnergyConfigKey(selectedYAxisMetric)
-                ? legendT.noMeasuredDataHint
-                : undefined
+              : isAllInMeasuredConfigKey(selectedYAxisMetric)
+                ? ALL_IN_MEASURED_EMPTY[locale]
+                : isMeasuredEnergyConfigKey(selectedYAxisMetric)
+                  ? legendT.noMeasuredDataHint
+                  : undefined
             : undefined
         }
         onShowChips={() => {
diff --git a/packages/app/src/lib/power-basis.ts b/packages/app/src/lib/power-basis.ts
index 434720af2..5b5f6e61b 100644
--- a/packages/app/src/lib/power-basis.ts
+++ b/packages/app/src/lib/power-basis.ts
@@ -39,6 +39,11 @@ export const ALL_IN_MEASURED_NOTE = {
   zh: 'GPU 功耗来自实测；未实测的组件功耗由模型估算，并计入数据中心 PUE。',
 };
 
+export const ALL_IN_MEASURED_EMPTY = {
+  en: 'No values are available for All in Measured in this selection. This boundary needs 8K / 1K, validated GPU telemetry, and hardware covered by the chassis power model (not NVL72 systems). Choose another boundary to keep the points.',
+  zh: '当前选择没有可用的整体实测功耗数值。该边界需要 8K / 1K 场景、已验证的 GPU 遥测，且硬件在机箱功耗模型覆盖范围内（不含 NVL72 系统）。可切换到其他功耗边界以保留数据点。',
+};
+
 /** InferenceData keys per derived basis and quantity. B1 lives on the measured* fields. */
 export const POWER_BASIS_FIELDS: Record<
   Exclude<PowerBasis, 'gpu-measured'>,

From a42d8818be082a1c2d619c025e4ceb9e6021c46f Mon Sep 17 00:00:00 2001
From: Wenyao Gao <105094497+edwingao28@users.noreply.github.com>
Date: Wed, 30 Sep 2026 09:32:28 -0700
Subject: [PATCH 082/103] fix: rename power-basis metric labels to the Boundary
 names (#1240)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The six derived power axes still surfaced as Utility Modeled, Utility
Provisioned and GPU Provisioned in the Table, export titles and API docs.
Use the Boundary select names (GPU Level Provisioned, All in Provisioned,
All in Measured) in EN/ZH labels, titles and axis explanations. Keys and
share links are unchanged.

中文：六个功耗边界指标在表格、导出标题和 API 文档中仍显示 Utility Modeled、
Utility Provisioned、GPU Provisioned。现将中英文标签、标题及坐标轴说明统一为
Boundary 选项名称（GPU Level Provisioned、整体预配功耗、整体实测功耗）；
指标 key 与分享链接不变。
---
 .../inference/axis-metric-explanations.ts     | 14 +++---
 .../components/inference/metric-registry.ts   | 47 +++++++++----------
 2 files changed, 30 insertions(+), 31 deletions(-)

diff --git a/packages/app/src/components/inference/axis-metric-explanations.ts b/packages/app/src/components/inference/axis-metric-explanations.ts
index dbfd38030..0307fc094 100644
--- a/packages/app/src/components/inference/axis-metric-explanations.ts
+++ b/packages/app/src/components/inference/axis-metric-explanations.ts
@@ -488,12 +488,12 @@ export const METRIC_EXPLANATIONS: Record<MetricKey, MetricExplanation> = {
         'a data center reserves for one accelerator including host, networking, cooling and ' +
         'power-conversion overheads. It is a flat value independent of the run.',
       zh:
-        '取硬件注册表中的每芯片全电源配置功耗：数据中心为单张加速器预留的电源侧容量，' +
+        '取硬件注册表中的每芯片整体预配功耗（all-in）：数据中心为单张加速器预留的电源侧容量，' +
         '包含主机、网络、散热与电源转换开销。该值为恒定值，与运行无关。',
     },
     formula: {
       en: 'W/GPU = all-in provisioned power per GPU (kW) × 1000',
-      zh: 'W/GPU = 每 GPU 全电源配置功耗（kW）× 1000',
+      zh: 'W/GPU = 每 GPU 整体预配功耗（kW）× 1000',
     },
   },
   utilityProvisionedJPerOutputToken: {
@@ -503,12 +503,12 @@ export const METRIC_EXPLANATIONS: Record<MetricKey, MetricExplanation> = {
         'allocated accelerator. It differs from the public All-in Provisioned J per Output Token ' +
         'metric only for disaggregated runs, where that metric normalizes by decode GPUs alone.',
       zh:
-        '在全电源配置边界下的每输出 token 能耗，按全部已分配加速器归一。' +
+        '在整体预配功耗边界下的每输出 token 能耗，按全部已分配加速器归一。' +
         '仅在分离式运行中与公开的 All-in Provisioned J per Output Token 指标不同，后者只按 decode GPU 归一。',
     },
     formula: {
       en: 'J/tok = all-in provisioned power per GPU (W) × allocated GPUs ÷ total output tokens per second',
-      zh: 'J/tok = 每 GPU 全电源配置功耗（W）× 已分配 GPU 数 ÷ 总输出 token 吞吐（tok/s）',
+      zh: 'J/tok = 每 GPU 整体预配功耗（W）× 已分配 GPU 数 ÷ 总输出 token 吞吐（tok/s）',
     },
   },
   utilityModeledWatts: {
@@ -518,7 +518,7 @@ export const METRIC_EXPLANATIONS: Record<MetricKey, MetricExplanation> = {
         'AC by the system power model and then multiplied once by PUE. Only hardware with a known ' +
         'eight-GPU chassis profile on 8k1k runs is supported; NVL72 systems show no value.',
       zh:
-        '每已分配加速器的数据中心建模功耗：先由系统功耗模型将 GPU 实测功耗换算为机箱交流功耗，再乘以一次 PUE。' +
+        '每已分配加速器的整体实测功耗：先由系统功耗模型将 GPU 实测功耗换算为机箱交流功耗，再乘以一次 PUE。' +
         '仅支持在 8k1k 运行中具有已知八卡机箱模型的硬件；NVL72 系统不显示数值。',
     },
     formula: {
@@ -533,12 +533,12 @@ export const METRIC_EXPLANATIONS: Record<MetricKey, MetricExplanation> = {
         'measured GPU energy equals the ratio of modeled facility power to measured GPU power. ' +
         'Missing where the system power model or validated measured power is unavailable.',
       zh:
-        '将实测每输出 token 能耗按建模的数据中心边界缩放，其与 GPU 实测能耗之比等于数据中心建模功耗与 GPU 实测功耗之比。' +
+        '将实测每输出 token 能耗按整体实测功耗边界缩放，其与 GPU 实测能耗之比等于整体实测功耗与 GPU 实测功耗之比。' +
         '系统功耗模型或通过验证的实测功耗缺失时不显示。',
     },
     formula: {
       en: 'J/tok = measured J per output token × modeled facility W per GPU ÷ measured W per GPU',
-      zh: 'J/tok = 实测每输出 token 能耗 × 每 GPU 数据中心建模功耗（W）÷ 每 GPU 实测功耗（W）',
+      zh: 'J/tok = 实测每输出 token 能耗 × 每 GPU 整体实测功耗（W）÷ 每 GPU 实测功耗（W）',
     },
   },
 };
diff --git a/packages/app/src/components/inference/metric-registry.ts b/packages/app/src/components/inference/metric-registry.ts
index ee81252d4..08a4e8934 100644
--- a/packages/app/src/components/inference/metric-registry.ts
+++ b/packages/app/src/components/inference/metric-registry.ts
@@ -408,56 +408,55 @@ export const METRIC_REGISTRY = {
   // telemetry, so the telemetry-only decorations must not treat them as such.
   gpuProvisionedWatts: {
     field: 'gpuProvisionedWatts.y',
-    label: 'GPU Provisioned Power per Chip (TDP, W)',
+    label: 'GPU Level Provisioned Power per Chip (TDP, W)',
     labelZh: '每芯片 GPU 额定功耗（TDP，W）',
-    title: 'GPU Provisioned Power per Chip (TDP)',
+    title: 'GPU Level Provisioned Power per Chip (TDP)',
     titleZh: '每芯片 GPU 额定功耗（TDP）',
     polarity: 'lower',
   },
   gpuProvisionedJPerOutputToken: {
     field: 'gpuProvisionedJPerOutputToken.y',
-    label: 'GPU Provisioned J per Output Token (TDP, J/tok)',
+    label: 'GPU Level Provisioned J per Output Token (TDP, J/tok)',
     labelZh: '每输出 token GPU 额定能耗（TDP，J/tok）',
-    title: 'GPU Provisioned Joules per Output Token (TDP)',
+    title: 'GPU Level Provisioned Joules per Output Token (TDP)',
     titleZh: '每输出 token GPU 额定焦耳能耗（TDP）',
     polarity: 'lower',
   },
   utilityProvisionedWatts: {
     field: 'utilityProvisionedWatts.y',
-    label: 'Utility Provisioned Power per Chip (all-in, W)',
-    labelZh: '每芯片全电源配置功耗（all-in，W）',
-    title: 'Utility Provisioned Power per Chip (all-in)',
-    titleZh: '每芯片全电源配置功耗（all-in）',
+    label: 'All in Provisioned Power per Chip (W)',
+    labelZh: '每芯片整体预配功耗（W）',
+    title: 'All in Provisioned Power per Chip',
+    titleZh: '每芯片整体预配功耗',
     polarity: 'lower',
   },
   // Unlike the ungated `jOutput`, which divides by output tokens per decode
   // GPU, this normalizes by every allocated GPU (prefill + decode).
   utilityProvisionedJPerOutputToken: {
     field: 'utilityProvisionedJPerOutputToken.y',
-    label: 'Utility Provisioned J per Output Token, all GPUs (all-in, J/tok)',
-    labelZh: '每输出 token 全电源配置能耗，按全部 GPU 归一（all-in，J/tok）',
-    title: 'Utility Provisioned Joules per Output Token, all GPUs (all-in)',
-    titleZh: '每输出 token 全电源配置焦耳能耗，按全部 GPU 归一（all-in）',
+    label: 'All in Provisioned J per Output Token, all GPUs (J/tok)',
+    labelZh: '每输出 token 整体预配能耗，按全部 GPU 归一（J/tok）',
+    title: 'All in Provisioned Joules per Output Token, all GPUs',
+    titleZh: '每输出 token 整体预配焦耳能耗，按全部 GPU 归一',
     polarity: 'lower',
   },
-  // zh vocabulary shared with the Boundary select, its help text and the chart
-  // caption: B3 “全电源配置” (as the ungated jOutput/jTotal already say for
-  // all-in), B4 “数据中心建模” (measured GPU power carried through the chassis
-  // model to the utility meter).
+  // Names follow POWER_BASIS_LABELS (lib/power-basis.ts) so the Table, export
+  // titles and API docs read the same as the Boundary select: All in Provisioned
+  // / 整体预配功耗 and All in Measured / 整体实测功耗.
   utilityModeledWatts: {
     field: 'utilityModeledWatts.y',
-    label: 'Utility Modeled Power per Chip (PUE, W)',
-    labelZh: '每芯片数据中心建模功耗（含 PUE，W）',
-    title: 'Utility Modeled Power per Chip (PUE)',
-    titleZh: '每芯片数据中心建模功耗（含 PUE）',
+    label: 'All in Measured Power per Chip (W)',
+    labelZh: '每芯片整体实测功耗（W）',
+    title: 'All in Measured Power per Chip',
+    titleZh: '每芯片整体实测功耗',
     polarity: 'lower',
   },
   utilityModeledJPerOutputToken: {
     field: 'utilityModeledJPerOutputToken.y',
-    label: 'Utility Modeled J per Output Token (PUE, J/tok)',
-    labelZh: '每输出 token 数据中心建模能耗（含 PUE，J/tok）',
-    title: 'Utility Modeled Joules per Output Token (PUE)',
-    titleZh: '每输出 token 数据中心建模焦耳能耗（含 PUE）',
+    label: 'All in Measured J per Output Token (J/tok)',
+    labelZh: '每输出 token 整体实测能耗（J/tok）',
+    title: 'All in Measured Joules per Output Token',
+    titleZh: '每输出 token 整体实测焦耳能耗',
     polarity: 'lower',
   },
 } as const satisfies Record<string, MetricDefinition>;

From 9c15d605781a3100b3666e47a16a470410ec7ce7 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Wed, 30 Sep 2026 12:29:54 -0700
Subject: [PATCH 083/103] fix: plot role panels on trace-derived P75/P90 axes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In e2e-normalized-interactivity mode the chart's X field is p75_e2e_norm_intvty or p90_e2e_norm_intvty, whose values live only on point.x. getRolePoints and getPrefillSharePoints rejected the field and read point[xField], so the Prefill/Decode panels went empty although role telemetry existed. Role panels now accept the derived axes and read point.x; equal-service interpolation keeps reporting unsupported-axis there. Views API shares the helper. Catalog digest and docs updated.

中文：在端到端归一化交互性模式下，图表横轴字段为 p75/p90_e2e_norm_intvty，其值只存在于 point.x。角色面板此前拒绝该字段并读取 point[xField]，导致有角色遥测时 Prefill/Decode 面板仍为空。现在角色面板接受派生横轴并读取 point.x；等服务插值在这些横轴上仍返回 unsupported-axis。views API 复用同一 helper；已更新 catalog 摘要与文档。
---
 docs/dashboard-readonly-views.md              |  8 +++-
 docs/powerx-permanent-view.md                 |  3 ++
 .../utils/equal-service-comparison.test.ts    | 40 ++++++++++++++++++-
 .../utils/equal-service-comparison.ts         | 17 ++++++--
 packages/app/src/lib/api-route-catalog.ts     |  2 +-
 5 files changed, 62 insertions(+), 8 deletions(-)

diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 06606c503..85c805ed0 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -177,7 +177,9 @@ visible.
 `roleShare=true` returns `roleEnergyShares` and `rolePoints` through the same shared
 role helper. Each role point carries prefill and decode mean W/GPU, role-local
 prefill J/input and decode J/output, and the output-token reconstruction below;
-any missing figure is null.
+any missing figure is null. Role points follow the response's `xAxis.field`, including
+the derived `p75_e2e_norm_intvty` / `p90_e2e_norm_intvty` axes; `equalServiceComparison`
+does not interpolate on those axes.
 Validated disaggregated prefill J/input is multiplied by same-window aggregate
 J/output ÷ J/input, then compared with decode J/output. The percentage denominator
 is reconstructed prefill + decode energy on one output-token basis. Missing or
@@ -255,7 +257,9 @@ GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全
 该并发数下有观测即列出一行；每侧为 `observed`、`missing`，或同一负载下观测值不一致时的
 `ambiguous`（全部列出、不选其一）；仅当两侧都有观测时才计算变化百分比。同一并发下两者
 的服务速度通常不同，因此该表只作诊断，不替代同等服务对比。`roleShare=true` 另返回
-`rolePoints`（各角色 W/GPU、按本池 token 计的能耗及按输出 token 重建的能耗）。
+`rolePoints`（各角色 W/GPU、按本池 token 计的能耗及按输出 token 重建的能耗）。角色数据点沿用
+响应的 `xAxis.field`，包括派生的 `p75_e2e_norm_intvty` / `p90_e2e_norm_intvty` 横轴；
+`equalServiceComparison` 不在这些横轴上插值。
 `powerFit=true` 返回 `powerFits`：每个数据源以最小二乘法拟合平均 W/GPU 与每个已分配
 GPU 的输出 tok/s，给出 `P₀`、`m`（J/输出 token）、R²、点数、拟合范围和注册表 TDP；
 不同输出速率少于 3 个时不拟合。`P₀` 是外推截距，不是实测空载功耗。这些面板只支持
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 5eb147658..4c730b37e 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -307,6 +307,9 @@ and colour overlay sources with `overlayRunColor`.
 | 15           | Least-squares fit of mean W/GPU against output tok/s per allocated GPU: points, line, dashed extension to zero, P₀, P₀ ÷ TDP, m, R², n, range | _Power vs output-rate fit_ (`i_powerfit=1`)                                                             | `utils/power-fit.ts`                                   |
 | 16           | Frontier points: the drawn cross-platform frontier and each point's run and attempt                                                           | Legend _Pareto frontier_ (`i_frontier`) on a measured metric                                            | `utils/frontier-points.ts`                             |
 
+- **Role group** follows the chart's X axis, including the trace-derived P75/P90 E2E-normalized
+  interactivity axes (their values live on `point.x`); equal-service interpolation stays limited
+  to observed service fields and reports `unsupported-axis` there.
 - **Same concurrency** pairs only observations; nothing is interpolated. A side missing at a
   load reads _Not measured_. Disagreeing duplicates of one source read as ambiguous, with none
   chosen. % change needs both sides. Same load usually means different speed, so the table
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
index b3b60a28c..a29d0b472 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
@@ -1,9 +1,11 @@
 import { describe, expect, it } from 'vitest';
-import type { InferenceData } from '../types';
+import type { AggDataEntry, InferenceData } from '../types';
 import {
   buildEqualServiceComparison,
   equalServiceSourceKey,
   getEqualServiceSources,
+  getPrefillSharePoints,
+  getRolePoints,
 } from './equal-service-comparison';
 
 const metric = (y: number) => ({ y, roof: false });
@@ -196,4 +198,40 @@ describe('equal-service comparison', () => {
       'B300 (SGLang) · 2026-09-23 · Run #8',
     ]);
   });
+
+  it('plots role panels on the trace-derived P75/P90 axes from point.x without interpolating on them', () => {
+    const role = (overrides: Partial<InferenceData>) =>
+      point({
+        disagg: true,
+        num_prefill_gpu: 4,
+        num_decode_gpu: 4,
+        power_valid: 1,
+        power_metric_schema_version: 2,
+        joules_per_input_token: 1,
+        joules_per_output_token: 8,
+        prefill_joules_per_input_token: 0.4,
+        decode_joules_per_output_token: 4.8,
+        measuredPrefillAvgPower: metric(300),
+        measuredDecodeAvgPower: metric(500),
+        ...overrides,
+      });
+    // The chart and the views API both store the derived value on `x` only.
+    const rows = [
+      role({ id: 1, x: 31.2 }),
+      role({ id: 2, x: 24.8, conc: 16 }),
+      role({ id: 3, x: 28, hwKey: 'b300_sglang', run_url: 'https://example.invalid/runs/2' }),
+    ];
+    const derived = 'p90_e2e_norm_intvty' as keyof AggDataEntry;
+    expect(getRolePoints(rows, derived).map((row) => row.x)).toEqual([24.8, 31.2, 28]);
+    expect(getPrefillSharePoints(rows, derived).map((row) => row.x)).toEqual([24.8, 31.2, 28]);
+    expect(getRolePoints(rows, 'p75_e2e_norm_intvty' as keyof AggDataEntry)).toHaveLength(3);
+    expect(
+      buildEqualServiceComparison(rows, {
+        baseline: equalServiceSourceKey(rows[0]),
+        comparator: equalServiceSourceKey(rows[2]),
+        target: 28,
+        xField: derived,
+      }).reason,
+    ).toBe('unsupported-axis');
+  });
 });
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.ts b/packages/app/src/components/inference/utils/equal-service-comparison.ts
index 0fdf19744..3cb58c7e6 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.ts
@@ -51,6 +51,15 @@ export interface EqualServiceComparison {
 const serviceAxis = (field: string) =>
   field === 'mean_tpot_intvty' ||
   /^(?:mean|median|p\d+(?:\.\d+)?)_(?:intvty|tpot|ttft|e2el|itl)$/u.test(field);
+/**
+ * Trace-derived agentic axes (`p75_e2e_norm_intvty`, `p90_e2e_norm_intvty`)
+ * live only on `point.x`; no row field carries that name. The role panels
+ * plot observations, so they accept them; equal-service interpolation keeps
+ * its observed-field policy and reports `unsupported-axis`.
+ */
+const derivedAxis = (field: string) => /^p\d+_e2e_norm_intvty$/u.test(field);
+const roleAxisValue = (point: InferenceData, xField: keyof AggDataEntry) =>
+  derivedAxis(xField) ? point.x : point[xField];
 /** A positive finite reading, or null: a missing value is never zero. */
 export const positiveOrNull = (value: unknown): number | null => (isPositive(value) ? value : null);
 /** Measured rows only: hidden rows and power-comparison clones are never sources. */
@@ -318,10 +327,10 @@ export function getPrefillSharePoints(
   points: readonly InferenceData[],
   xField: keyof AggDataEntry,
 ) {
-  if (!serviceAxis(xField) && xField !== 'conc') return [];
+  if (!serviceAxis(xField) && xField !== 'conc' && !derivedAxis(xField)) return [];
   return observedPoints(points)
     .flatMap((point) => {
-      const x = point[xField];
+      const x = roleAxisValue(point, xField);
       const energy = reconstructedRoleEnergy(point);
       return isPositive(x) && energy
         ? [{ x, sourceKey: equalServiceSourceKey(point), point, ...energy }]
@@ -353,10 +362,10 @@ export function getRolePoints(
   points: readonly InferenceData[],
   xField: keyof AggDataEntry,
 ): RolePoint[] {
-  if (!serviceAxis(xField) && xField !== 'conc') return [];
+  if (!serviceAxis(xField) && xField !== 'conc' && !derivedAxis(xField)) return [];
   return observedPoints(points)
     .flatMap((point): RolePoint[] => {
-      const x = point[xField];
+      const x = roleAxisValue(point, xField);
       if (!point.disagg || !isPositive(x)) return [];
       const role: RolePoint = {
         x,
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 661de2677..bacb18303 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -853,7 +853,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/inference/utils/equal-service-comparison.ts',
-    sourceSha256: '8341fe0a94e5ddefebc70938514bd7f128aa16aeb22a7aef5863f02ef383ab25',
+    sourceSha256: '9da8ffb9df5b1df9bca9a2d155e32a9dbb1599edb87093afda1c4dd6cfe973b2',
     reviewArea: {
       en: 'Source-scoped equal-service interpolation, comparator-relative changes, endpoint provenance, prefill share projection and role points.',
       zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源、prefill 占比视图以及各角色数据点。',

From c2085d93142ac8a77e7f35bde87539a33f954a56 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Wed, 30 Sep 2026 12:31:38 -0700
Subject: [PATCH 084/103] fix: pin the equal-service comparison pair once
 Compare is on
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The resolved default baseline and comparator were written to the URL but never into state, so base and peer kept tracking sources[0] and sources[1]. Adding an unofficial overlay or changing a filter re-sorted the sources and silently retargeted the equal-service and matched-concurrency panels, while a reload of the same share URL kept the original pair. The pair is now pinned into state when Compare turns on. The component spec resets the module-scoped URL store first, because the previous test's selection would otherwise pre-pin the mount.

中文：对比模式下解析出的默认基准与对比对象只写入了 URL，没有写入 state，base/peer 仍跟随 sources[0]/[1]。加入非正式 run 叠加或更改筛选会重排 sources，悄悄改变等服务与匹配并发面板的对比对象，而重新加载同一分享链接却保持原对。现在开启对比时把该对固定进 state。组件测试先重置模块级 URL store，否则上一用例的选择会预先固定本次挂载。
---
 .../component/power-service-comparison.cy.tsx | 49 +++++++++++++++++++
 .../inference/ui/PowerServiceComparison.tsx   |  8 +++
 2 files changed, 57 insertions(+)

diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
index e1ab4eb39..1b1cbf380 100644
--- a/packages/app/cypress/component/power-service-comparison.cy.tsx
+++ b/packages/app/cypress/component/power-service-comparison.cy.tsx
@@ -1,7 +1,9 @@
 import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+import { useState } from 'react';
 
 import type { InferenceData } from '@/components/inference/types';
 import PowerServiceComparison from '@/components/inference/ui/PowerServiceComparison';
+import { writeUrlParams } from '@/lib/url-state';
 
 import { createMockInferenceData } from '../support/mock-data';
 import { mountWithProviders } from '../support/test-utils';
@@ -81,6 +83,32 @@ function mountComparison(points: InferenceData[], overlay: InferenceData[]) {
   );
 }
 
+// Its key sorts ahead of the B200 baseline, so an unpinned pair would jump to it.
+const laterSource = point({
+  id: 40,
+  hwKey: 'b100_sglang',
+  run_url: 'https://example.invalid/runs/900000003',
+  measuredAvgPower: metric(600),
+});
+function PinnedComparisonHarness() {
+  const [extra, setExtra] = useState<InferenceData[]>([]);
+  return (
+    <PathnameContext.Provider value="/inference">
+      <button type="button" data-testid="add-source" onClick={() => setExtra([laterSource])}>
+        add source
+      </button>
+      <PowerServiceComparison
+        data={[...fitLadder, ...comparator, ...extra]}
+        overlayData={comparator}
+        xField="mean_tpot_intvty"
+        xLabel="Mean interactivity (output tok/s/user)"
+        interactivityField="mean_tpot_intvty"
+        chartId="power-service-pin"
+      />
+    </PathnameContext.Provider>
+  );
+}
+
 describe('PowerServiceComparison', () => {
   beforeEach(() => {
     cy.on('uncaught:exception', (error) => {
@@ -112,4 +140,25 @@ describe('PowerServiceComparison', () => {
     }
     cy.get('[data-testid="matched-concurrency-row-8"]').should('exist');
   });
+
+  it('keeps the compared pair when a new source sorts ahead of the baseline', () => {
+    // The URL-state store is module-scoped and outlives the previous test's
+    // Compare selection, which would otherwise pre-pin this mount.
+    writeUrlParams({ i_servicecompare: '0', i_servicebase: '', i_servicepeer: '' });
+    mountWithProviders(<PinnedComparisonHarness />, {
+      inference: {},
+      unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } },
+    });
+    cy.get('[data-testid="equal-service-toggle"]').check();
+    cy.get('[data-testid="equal-service-baseline"]').invoke('val').should('contain', 'b200_sglang');
+    cy.get('[data-testid="equal-service-comparator"]')
+      .invoke('val')
+      .should('contain', OVERLAY_RUN_URL);
+    cy.get('[data-testid="add-source"]').click();
+    cy.get('[data-testid="equal-service-baseline"] option').should('have.length', 3);
+    cy.get('[data-testid="equal-service-baseline"]').invoke('val').should('contain', 'b200_sglang');
+    cy.get('[data-testid="equal-service-comparator"]')
+      .invoke('val')
+      .should('contain', OVERLAY_RUN_URL);
+  });
 });
diff --git a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
index 4324ff1c8..6cc67231b 100644
--- a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
+++ b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
@@ -159,6 +159,14 @@ export default function PowerServiceComparison({
   const sources = useMemo(() => getEqualServiceSources(data, locale), [data, locale]);
   const base = baseline || sources[0]?.key || '';
   const peer = comparator || sources[1]?.key || '';
+  // Compare pins the resolved pair in state: otherwise an added overlay run or
+  // a filter change re-sorts `sources` and silently retargets the panels,
+  // while reloading the share URL would keep the original pair.
+  useEffect(() => {
+    if (!enabled) return;
+    if (!baseline && sources[0]) setBaseline(sources[0].key);
+    if (!comparator && sources[1]) setComparator(sources[1].key);
+  }, [enabled, baseline, comparator, sources]);
   const previousAxis = useRef(xField);
   useEffect(() => {
     if (previousAxis.current !== xField) {

From 10fad530b9b63217a5b3e0d4b43c4e7ef6c2833d Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Wed, 30 Sep 2026 12:37:08 -0700
Subject: [PATCH 085/103] test: match the measured power family by exact option
 text
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Since the Boundary renames, 'All in Measured Power per Chip (W)' also matches the 'Measured Power' search, so the single-match assertion failed in English while Chinese passed. The spec now asserts that exactly one option displays the family name and that it is the pressed P75 key.

中文：边界名称重命名后，'All in Measured Power per Chip (W)' 也会匹配 'Measured Power' 搜索，英文用例的单一匹配断言因此失败而中文通过。现改为断言恰好一个选项显示该族名称，且它是已选中的 P75 指标。
---
 .../component/inference-chart-controls.cy.tsx       | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/packages/app/cypress/component/inference-chart-controls.cy.tsx b/packages/app/cypress/component/inference-chart-controls.cy.tsx
index 6407da9f7..3ddb08726 100644
--- a/packages/app/cypress/component/inference-chart-controls.cy.tsx
+++ b/packages/app/cypress/component/inference-chart-controls.cy.tsx
@@ -475,11 +475,14 @@ describe('Inference ChartControls grouped measured metrics', () => {
         expect(values).to.include('y_measuredPowerTimeline');
       });
       cy.get(`input[aria-label="${searchLabel}"]`).clear().type(power);
-      cy.get('[data-select-option]')
-        .should('have.length', 1)
-        .and('have.text', power)
-        .and('have.attr', 'data-value', 'y_measuredP75Power')
-        .and('have.attr', 'aria-pressed', 'true');
+      // 'All in Measured Power per Chip' also contains the family name; only
+      // the family option may display exactly that name.
+      cy.get('[data-select-option]').should(($options) => {
+        const exact = [...$options].filter((option) => option.textContent?.trim() === power);
+        expect(exact).to.have.length(1);
+        expect(exact[0].dataset.value).to.equal('y_measuredP75Power');
+        expect(exact[0].getAttribute('aria-pressed')).to.equal('true');
+      });
       cy.get('[data-testid="option-help-y_measuredP75Power"]').should('exist');
       cy.get(`input[aria-label="${searchLabel}"]`).clear().type(energy);
       cy.get('[data-select-option]')

From ff989ca619b910aeaebeaa180498cc961c13526b Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Wed, 30 Sep 2026 12:57:26 -0700
Subject: [PATCH 086/103] fix: pin the comparison pair only when Compare is
 toggled
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A share link that pre-enables Compare receives its rows in any order; the
overlay run can land before the official rows, and pinning that first source
in an effect fixed both sides on it, so the matched-load panel rendered no
rows (powerx-compare.cy.ts on #1228). Pin the visible pair when the user turns
Compare on; the URL sync still records the resolved keys for reloads.

中文：通过分享链接预先开启对比时，数据行到达顺序不定，overlay run 可能先于
官方数据行到达；在 effect 中固定首个 source 会让基准与对比对象指向同一
source，等负载面板因此没有任何行（#1228 上的 powerx-compare.cy.ts）。改为在
用户打开对比时固定当前可见的一对；URL 同步仍记录解析后的键，刷新后可恢复。
---
 .../component/power-service-comparison.cy.tsx | 46 +++++++++++++++----
 .../inference/ui/PowerServiceComparison.tsx   | 25 ++++++----
 2 files changed, 52 insertions(+), 19 deletions(-)

diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
index 1b1cbf380..ac529fff8 100644
--- a/packages/app/cypress/component/power-service-comparison.cy.tsx
+++ b/packages/app/cypress/component/power-service-comparison.cy.tsx
@@ -90,15 +90,21 @@ const laterSource = point({
   run_url: 'https://example.invalid/runs/900000003',
   measuredAvgPower: metric(600),
 });
-function PinnedComparisonHarness() {
+function PinnedComparisonHarness({
+  initial,
+  added,
+}: {
+  initial: InferenceData[];
+  added: InferenceData[];
+}) {
   const [extra, setExtra] = useState<InferenceData[]>([]);
   return (
     <PathnameContext.Provider value="/inference">
-      <button type="button" data-testid="add-source" onClick={() => setExtra([laterSource])}>
+      <button type="button" data-testid="add-source" onClick={() => setExtra(added)}>
         add source
       </button>
       <PowerServiceComparison
-        data={[...fitLadder, ...comparator, ...extra]}
+        data={[...initial, ...extra]}
         overlayData={comparator}
         xField="mean_tpot_intvty"
         xLabel="Mean interactivity (output tok/s/user)"
@@ -114,6 +120,9 @@ describe('PowerServiceComparison', () => {
     cy.on('uncaught:exception', (error) => {
       if (error.message.includes('ResizeObserver loop')) return false;
     });
+    // The URL-state store is module-scoped and outlives the previous test's
+    // Compare selection, which would otherwise pre-pin the next mount.
+    writeUrlParams({ i_servicecompare: '0', i_servicebase: '', i_servicepeer: '' });
   });
 
   it('colours ?unofficialrun= sources with their run colour in every panel', () => {
@@ -142,13 +151,13 @@ describe('PowerServiceComparison', () => {
   });
 
   it('keeps the compared pair when a new source sorts ahead of the baseline', () => {
-    // The URL-state store is module-scoped and outlives the previous test's
-    // Compare selection, which would otherwise pre-pin this mount.
-    writeUrlParams({ i_servicecompare: '0', i_servicebase: '', i_servicepeer: '' });
-    mountWithProviders(<PinnedComparisonHarness />, {
-      inference: {},
-      unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } },
-    });
+    mountWithProviders(
+      <PinnedComparisonHarness initial={[...fitLadder, ...comparator]} added={[laterSource]} />,
+      {
+        inference: {},
+        unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } },
+      },
+    );
     cy.get('[data-testid="equal-service-toggle"]').check();
     cy.get('[data-testid="equal-service-baseline"]').invoke('val').should('contain', 'b200_sglang');
     cy.get('[data-testid="equal-service-comparator"]')
@@ -161,4 +170,21 @@ describe('PowerServiceComparison', () => {
       .invoke('val')
       .should('contain', OVERLAY_RUN_URL);
   });
+
+  it('resolves a share link that pre-enables Compare as its rows arrive', () => {
+    // The overlay run can land before the official rows; pinning that first
+    // source would fix both sides on it.
+    writeUrlParams({ i_servicecompare: '1' });
+    mountWithProviders(<PinnedComparisonHarness initial={comparator} added={fitLadder} />, {
+      inference: {},
+      unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } },
+    });
+    cy.get('[data-testid="equal-service-baseline"]').invoke('val').should('contain', OVERLAY_RUN_URL);
+    cy.get('[data-testid="add-source"]').click();
+    cy.get('[data-testid="equal-service-baseline"]').invoke('val').should('contain', 'b200_sglang');
+    cy.get('[data-testid="equal-service-comparator"]')
+      .invoke('val')
+      .should('contain', OVERLAY_RUN_URL);
+    cy.get('[data-testid="matched-concurrency-row-8"]').should('exist');
+  });
 });
diff --git a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
index 6cc67231b..cc7c8dcc0 100644
--- a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
+++ b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
@@ -159,14 +159,21 @@ export default function PowerServiceComparison({
   const sources = useMemo(() => getEqualServiceSources(data, locale), [data, locale]);
   const base = baseline || sources[0]?.key || '';
   const peer = comparator || sources[1]?.key || '';
-  // Compare pins the resolved pair in state: otherwise an added overlay run or
-  // a filter change re-sorts `sources` and silently retargets the panels,
-  // while reloading the share URL would keep the original pair.
-  useEffect(() => {
-    if (!enabled) return;
-    if (!baseline && sources[0]) setBaseline(sources[0].key);
-    if (!comparator && sources[1]) setComparator(sources[1].key);
-  }, [enabled, baseline, comparator, sources]);
+  // Turning Compare on pins the pair the user sees: otherwise an added overlay
+  // run or a filter change re-sorts `sources` and silently retargets the panels.
+  // A share link that pre-enables Compare keeps resolving dynamically, because
+  // its rows arrive in any order (an overlay can land before the official rows)
+  // and pinning mid-load would fix both sides on the same source. The URL sync
+  // below records the resolved keys, so a reload restores the pair explicitly.
+  const toggleCompare = useCallback(
+    (checked: boolean) => {
+      setEnabled(checked);
+      if (!checked) return;
+      if (!baseline && sources[0]) setBaseline(sources[0].key);
+      if (!comparator && sources[1]) setComparator(sources[1].key);
+    },
+    [baseline, comparator, sources],
+  );
   const previousAxis = useRef(xField);
   useEffect(() => {
     if (previousAxis.current !== xField) {
@@ -299,7 +306,7 @@ export default function PowerServiceComparison({
       <div className="no-export flex flex-wrap gap-4 text-sm">
         <PanelToggle
           checked={enabled}
-          onChange={setEnabled}
+          onChange={toggleCompare}
           label={t.compare}
           testId="equal-service-toggle"
           event="inference_equal_service_toggled"

From fbf41938632501e408557051dacb0bdc6725aa76 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Wed, 30 Sep 2026 13:03:54 -0700
Subject: [PATCH 087/103] chore: format the comparison component spec
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：格式化对比组件用例（oxfmt）。
---
 .../app/cypress/component/power-service-comparison.cy.tsx     | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
index ac529fff8..48614a637 100644
--- a/packages/app/cypress/component/power-service-comparison.cy.tsx
+++ b/packages/app/cypress/component/power-service-comparison.cy.tsx
@@ -179,7 +179,9 @@ describe('PowerServiceComparison', () => {
       inference: {},
       unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } },
     });
-    cy.get('[data-testid="equal-service-baseline"]').invoke('val').should('contain', OVERLAY_RUN_URL);
+    cy.get('[data-testid="equal-service-baseline"]')
+      .invoke('val')
+      .should('contain', OVERLAY_RUN_URL);
     cy.get('[data-testid="add-source"]').click();
     cy.get('[data-testid="equal-service-baseline"]').invoke('val').should('contain', 'b200_sglang');
     cy.get('[data-testid="equal-service-comparator"]')

From 0effb5d95034807be1577462b1a002c0637c2ce8 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 088/103] chore: add PowerX admin scripts and dependencies
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Register the migrate, verify and telemetry backfill admin scripts and pull in the
PGlite and Blob fixture dependencies the new DB and API tests use.

中文：注册 migrate、verify 与遥测 backfill 管理脚本，并引入新 DB/API 测试所需的 PGlite 与 Blob fixture 依赖。
---
 bun.lock                  | 1 +
 package.json              | 1 +
 packages/app/package.json | 1 +
 packages/db/package.json  | 1 +
 4 files changed, 4 insertions(+)

diff --git a/bun.lock b/bun.lock
index 29d749498..ea567a09d 100644
--- a/bun.lock
+++ b/bun.lock
@@ -69,6 +69,7 @@
       },
       "devDependencies": {
         "@bahmutov/cypress-esbuild-preprocessor": "^2.2.8",
+        "@electric-sql/pglite": "^0.5.8",
         "@mdx-js/mdx": "^3.1.1",
         "@tailwindcss/postcss": "^4.3.3",
         "@types/adm-zip": "^0.5.8",
diff --git a/package.json b/package.json
index ba63caaca..0849c661e 100644
--- a/package.json
+++ b/package.json
@@ -44,6 +44,7 @@
     "admin:db:migrate:collectivex": "bun run --cwd packages/db db:migrate:collectivex",
     "admin:db:apply-overrides": "bun run --cwd packages/db db:apply-overrides",
     "admin:db:backfill-full-response-interactivity": "bun run --cwd packages/db db:backfill-full-response-interactivity",
+    "admin:db:backfill-gpu-metrics": "bun run --cwd packages/db db:backfill-gpu-metrics",
     "admin:db:backfill-server-log-files": "bun run --cwd packages/db db:backfill-server-log-files",
     "admin:db:reset": "bun run --cwd packages/db db:reset",
     "admin:db:verify": "bun run --cwd packages/db db:verify",
diff --git a/packages/app/package.json b/packages/app/package.json
index 3ee80be32..dbc291ffe 100644
--- a/packages/app/package.json
+++ b/packages/app/package.json
@@ -83,6 +83,7 @@
   },
   "devDependencies": {
     "@bahmutov/cypress-esbuild-preprocessor": "^2.2.8",
+    "@electric-sql/pglite": "^0.5.8",
     "@mdx-js/mdx": "^3.1.1",
     "@tailwindcss/postcss": "^4.3.3",
     "@types/adm-zip": "^0.5.8",
diff --git a/packages/db/package.json b/packages/db/package.json
index ba2589286..4ef2fe986 100644
--- a/packages/db/package.json
+++ b/packages/db/package.json
@@ -27,6 +27,7 @@
     "db:backfill-atom-kv-capacity": "bun --env-file=../../.env src/backfill-atom-kv-capacity.ts",
     "db:backfill-chart-series": "bun --env-file=../../.env src/backfill-chart-series.ts",
     "db:backfill-dataset-stats": "bun --env-file=../../.env src/backfill-dataset-stats.ts",
+    "db:backfill-gpu-metrics": "bun --env-file=../../.env src/backfill-gpu-metrics.ts",
     "db:backfill-full-response-interactivity": "bun --env-file=../../.env src/backfill-full-response-interactivity.ts",
     "db:backfill-request-timeline": "bun --env-file=../../.env src/backfill-request-timeline.ts",
     "db:backfill-runtime-metadata": "bun --env-file=../../.env src/backfill-runtime-metadata.ts",

From afa7e8694e7d90e8c216227ba88d7aca0d65ecfe Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 089/103] feat(db): add telemetry schema and stats version
 column
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Migration 016 stores one series per (run, artifact, CSV) with full-resolution samples,
per-GPU statistics and benchmark point links; 017 adds stats_version so digests can be
upgraded without rescanning samples. verify-db and the shared table constants cover the new tables.

中文：迁移 016 按 (run, artifact, CSV) 存储序列、全分辨率样本、每 GPU 统计及 benchmark 点链接；017 增加 stats_version 以便升级摘要而无需重扫样本。verify-db 与共享表名常量覆盖新表。
---
 packages/constants/src/tables.ts              |  4 +
 packages/db/migrations/016_gpu_metrics.sql    | 99 +++++++++++++++++++
 .../017_gpu_metric_stats_version.sql          |  3 +
 packages/db/src/lib/gpu-metric-stats.ts       | 61 ++++++++++++
 packages/db/src/verify-db.ts                  |  3 +
 5 files changed, 170 insertions(+)
 create mode 100644 packages/db/migrations/016_gpu_metrics.sql
 create mode 100644 packages/db/migrations/017_gpu_metric_stats_version.sql
 create mode 100644 packages/db/src/lib/gpu-metric-stats.ts

diff --git a/packages/constants/src/tables.ts b/packages/constants/src/tables.ts
index 684f310bc..d1bcd6a0b 100644
--- a/packages/constants/src/tables.ts
+++ b/packages/constants/src/tables.ts
@@ -5,6 +5,10 @@ export const TABLE_NAMES = {
   agenticTraceReplay: 'agentic_trace_replay',
   benchmarkResults: 'benchmark_results',
   serverLogs: 'server_logs',
+  gpuMetricSeries: 'gpu_metric_series',
+  gpuMetricSamples: 'gpu_metric_samples',
+  gpuMetricGpuStats: 'gpu_metric_gpu_stats',
+  benchmarkResultGpuMetrics: 'benchmark_result_gpu_metrics',
   runStats: 'run_stats',
   evalResults: 'eval_results',
   evalSamples: 'eval_samples',
diff --git a/packages/db/migrations/016_gpu_metrics.sql b/packages/db/migrations/016_gpu_metrics.sql
new file mode 100644
index 000000000..8c3f52ac5
--- /dev/null
+++ b/packages/db/migrations/016_gpu_metrics.sql
@@ -0,0 +1,99 @@
+-- PowerX telemetry digest.
+--
+-- The producer samples nvidia-smi / amd-smi once per second for the lifetime
+-- of every benchmark job and uploads the CSV as a `gpu_metrics_<suffix>`
+-- artifact next to `bmk_<suffix>`. Until now the app downloaded and parsed
+-- those artifacts from GitHub on every page view, and lost them entirely once
+-- GitHub's 90-day artifact retention expired. These tables move that work to
+-- ingest time: raw samples are kept at full resolution, per-GPU summary
+-- statistics are digested once, and each benchmark point is linked to the
+-- series that was recorded while it ran.
+
+create table gpu_metric_series (
+  id              bigserial   primary key,
+  workflow_run_id bigint      not null references workflow_runs(id) on delete cascade,
+  -- Full GitHub artifact name, including the runner-pool/attempt suffix.
+  artifact_name   text        not null,
+  -- Artifact name with the gpu_metrics_ prefix removed; pairs with bmk_<key>.
+  config_key      text        not null,
+  -- CSV path relative to the extracted artifact root (multinode uploads can
+  -- carry one CSV per serving node).
+  file_name       text        not null,
+  vendor          text        not null,
+  csv_sha256      text        not null,
+  sample_interval_s real,
+  sample_count    integer     not null,
+  gpu_count       smallint    not null,
+  started_at      timestamptz not null,
+  ended_at        timestamptz not null,
+  -- Parsed sidecars: gpu_metrics_context.json, gpu_metrics_identity.*,
+  -- gpu_metrics_energy_{start,end}.csv. Kept verbatim for provenance.
+  sidecars        jsonb       not null default '{}'::jsonb,
+  ingested_at     timestamptz not null default now(),
+
+  constraint gpu_metric_series_vendor_known check (vendor in ('nvidia', 'amd')),
+  constraint gpu_metric_series_artifact_nonempty check (artifact_name <> ''),
+  constraint gpu_metric_series_file_nonempty check (file_name <> ''),
+  constraint gpu_metric_series_sample_count_non_neg check (sample_count >= 0),
+  constraint gpu_metric_series_gpu_count_non_neg check (gpu_count >= 0),
+  constraint gpu_metric_series_window_ordered check (ended_at >= started_at),
+  constraint gpu_metric_series_unique unique (workflow_run_id, artifact_name, file_name)
+);
+
+create index gpu_metric_series_run_idx on gpu_metric_series (workflow_run_id);
+
+-- One row per (GPU, sample). Vendor-specific columns stay null when the
+-- collector does not report them. `real` keeps the row narrow; the source
+-- telemetry has at most three significant decimals.
+create table gpu_metric_samples (
+  series_id       bigint      not null references gpu_metric_series(id) on delete cascade,
+  gpu_index       smallint    not null,
+  sampled_at      timestamptz not null,
+  power_w         real,
+  temperature_c   real,
+  sm_clock_mhz    real,
+  mem_clock_mhz   real,
+  gpu_util_pct    real,
+  mem_util_pct    real,
+  edge_temp_c     real,
+  mem_temp_c      real,
+  gfx_voltage_mv  real,
+  soc_voltage_mv  real,
+  mem_voltage_mv  real,
+  fclk_mhz        real,
+  socclk_mhz      real,
+  mm_activity_pct real,
+
+  primary key (series_id, gpu_index, sampled_at)
+);
+
+-- Ingest-time digest so readers never rescan samples for summary cards.
+create table gpu_metric_gpu_stats (
+  series_id     bigint   not null references gpu_metric_series(id) on delete cascade,
+  gpu_index     smallint not null,
+  metric        text     not null,
+  sample_count  integer  not null,
+  min_value     real     not null,
+  max_value     real     not null,
+  mean_value    real     not null,
+  median_value  real     not null,
+  p95_value     real     not null,
+  p99_value     real     not null,
+  stddev_value  real     not null,
+
+  constraint gpu_metric_gpu_stats_metric_nonempty check (metric <> ''),
+  constraint gpu_metric_gpu_stats_sample_count_positive check (sample_count > 0),
+  primary key (series_id, gpu_index, metric)
+);
+
+-- Benchmark point ↔ telemetry series. A point can reference several series
+-- when a multinode artifact ships one CSV per node.
+create table benchmark_result_gpu_metrics (
+  benchmark_result_id bigint not null references benchmark_results(id) on delete cascade,
+  series_id           bigint not null references gpu_metric_series(id) on delete cascade,
+
+  primary key (benchmark_result_id, series_id)
+);
+
+create index benchmark_result_gpu_metrics_series_idx
+  on benchmark_result_gpu_metrics (series_id);
diff --git a/packages/db/migrations/017_gpu_metric_stats_version.sql b/packages/db/migrations/017_gpu_metric_stats_version.sql
new file mode 100644
index 000000000..68f7104b3
--- /dev/null
+++ b/packages/db/migrations/017_gpu_metric_stats_version.sql
@@ -0,0 +1,3 @@
+-- Zero means unversioned, not computed by the current algorithm.
+ALTER TABLE gpu_metric_series
+  ADD COLUMN IF NOT EXISTS stats_version integer NOT NULL DEFAULT 0;
diff --git a/packages/db/src/lib/gpu-metric-stats.ts b/packages/db/src/lib/gpu-metric-stats.ts
new file mode 100644
index 000000000..63bd4ec2a
--- /dev/null
+++ b/packages/db/src/lib/gpu-metric-stats.ts
@@ -0,0 +1,61 @@
+import {
+  computeGpuMetricStats,
+  type GpuMetricSample,
+  type GpuMetricStats,
+} from '../etl/gpu-metrics-csv';
+
+/** Bump whenever full-record digest definitions change. Independent of serving-window metrics. */
+export const GPU_STATS_VERSION = 1;
+
+export const STAT_METRIC_COLUMN = {
+  powerW: 'power_w',
+  temperatureC: 'temperature_c',
+  smClockMhz: 'sm_clock_mhz',
+  memClockMhz: 'mem_clock_mhz',
+  gpuUtilPct: 'gpu_util_pct',
+  memUtilPct: 'mem_util_pct',
+  edgeTempC: 'edge_temp_c',
+  memTempC: 'mem_temp_c',
+  gfxVoltageMv: 'gfx_voltage_mv',
+  socVoltageMv: 'soc_voltage_mv',
+  memVoltageMv: 'mem_voltage_mv',
+  fclkMhz: 'fclk_mhz',
+  socclkMhz: 'socclk_mhz',
+  mmActivityPct: 'mm_activity_pct',
+} as const satisfies Record<GpuMetricStats['metric'], string>;
+
+/** Stored metric names use the column spelling so SQL readers need no mapping. */
+export function statMetricColumn(metric: GpuMetricStats['metric']): string {
+  return STAT_METRIC_COLUMN[metric];
+}
+
+export type StoredGpuMetricSample = {
+  gpu_index: number;
+  sampled_at: string | Date;
+} & Record<(typeof STAT_METRIC_COLUMN)[keyof typeof STAT_METRIC_COLUMN], number | null>;
+
+/** Preserve nulls: chart adapters intentionally zero-fill power, digest inputs must not. */
+export function computeStoredGpuMetricStats(
+  rows: readonly StoredGpuMetricSample[],
+): GpuMetricStats[] {
+  return computeGpuMetricStats(
+    rows.map((row): GpuMetricSample => ({
+      timestampMs: new Date(row.sampled_at).getTime(),
+      gpuIndex: Number(row.gpu_index),
+      powerW: row.power_w,
+      temperatureC: row.temperature_c,
+      smClockMhz: row.sm_clock_mhz,
+      memClockMhz: row.mem_clock_mhz,
+      gpuUtilPct: row.gpu_util_pct,
+      memUtilPct: row.mem_util_pct,
+      edgeTempC: row.edge_temp_c,
+      memTempC: row.mem_temp_c,
+      gfxVoltageMv: row.gfx_voltage_mv,
+      socVoltageMv: row.soc_voltage_mv,
+      memVoltageMv: row.mem_voltage_mv,
+      fclkMhz: row.fclk_mhz,
+      socclkMhz: row.socclk_mhz,
+      mmActivityPct: row.mm_activity_pct,
+    })),
+  );
+}
diff --git a/packages/db/src/verify-db.ts b/packages/db/src/verify-db.ts
index 1f4d51edd..3ab8f805c 100644
--- a/packages/db/src/verify-db.ts
+++ b/packages/db/src/verify-db.ts
@@ -50,6 +50,9 @@ async function verify(): Promise<void> {
     TABLE_NAMES.evalResults,
     TABLE_NAMES.evalSamples,
     TABLE_NAMES.changelogEntries,
+    TABLE_NAMES.gpuMetricSeries,
+    TABLE_NAMES.gpuMetricSamples,
+    TABLE_NAMES.benchmarkResultGpuMetrics,
   ];
   for (const t of tables) {
     const [{ n }] = await sql`select count(*)::int as n from ${sql(t)}`;

From 96bcf06323f7dde091863b7ea266cbae9046d41c Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 090/103] feat(etl): digest gpu_metrics and power_audit
 artifacts at ingest
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Parse NVIDIA/AMD CSVs and multinode power_audit bundles into series, samples and
statistics, replace a changed series atomically under a row lock, and count telemetry
failures separately so they never fail the benchmark ingest.

中文：在 ingest 时把 NVIDIA/AMD CSV 与多节点 power_audit 包解析为序列、样本和统计，在行锁内原子替换变更的序列，遥测失败单独计数、不影响 benchmark 入库。
---
 docs/fixtures/powerx-reingest/README.md       |  34 ++
 docs/fixtures/powerx-reingest/nvidia.csv      |  25 +
 packages/db/src/etl/benchmark-mapper.ts       |   2 +-
 packages/db/src/etl/gpu-metrics-artifacts.ts  | 275 +++++++++++
 packages/db/src/etl/gpu-metrics-csv.test.ts   |  84 ++++
 packages/db/src/etl/gpu-metrics-csv.ts        | 385 +++++++++++++++
 .../db/src/etl/gpu-metrics-ingest.test.ts     | 416 ++++++++++++++++
 packages/db/src/etl/gpu-metrics-ingest.ts     | 451 ++++++++++++++++++
 packages/db/src/etl/ingest-summary.ts         |   1 +
 .../db/src/etl/multinode-power-samples.ts     | 114 +++++
 .../db/src/etl/power-audit-recovery.test.ts   |  61 +++
 packages/db/src/etl/power-audit-recovery.ts   |  42 ++
 .../src/etl/power-audit-validations.test.ts   |  67 +++
 .../db/src/etl/power-audit-validations.ts     | 125 +++++
 packages/db/src/etl/skip-tracker.test.ts      |   1 +
 packages/db/src/etl/skip-tracker.ts           |  33 ++
 packages/db/src/ingest-ci-run.test.ts         |  42 ++
 packages/db/src/ingest-ci-run.ts              | 184 ++++++-
 packages/db/src/ingest-gcs-backup.ts          |  10 +-
 packages/db/src/lib/artifact-retry.ts         |  13 +
 packages/db/src/lib/github-artifacts.test.ts  |   1 -
 packages/db/src/lib/github-artifacts.ts       |  46 +-
 packages/db/src/prepare-ci-artifacts.ts       |  11 +
 23 files changed, 2398 insertions(+), 25 deletions(-)
 create mode 100644 docs/fixtures/powerx-reingest/README.md
 create mode 100644 docs/fixtures/powerx-reingest/nvidia.csv
 create mode 100644 packages/db/src/etl/gpu-metrics-artifacts.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-csv.test.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-csv.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-ingest.test.ts
 create mode 100644 packages/db/src/etl/gpu-metrics-ingest.ts
 create mode 100644 packages/db/src/etl/multinode-power-samples.ts
 create mode 100644 packages/db/src/etl/power-audit-recovery.test.ts
 create mode 100644 packages/db/src/etl/power-audit-recovery.ts
 create mode 100644 packages/db/src/etl/power-audit-validations.test.ts
 create mode 100644 packages/db/src/etl/power-audit-validations.ts

diff --git a/docs/fixtures/powerx-reingest/README.md b/docs/fixtures/powerx-reingest/README.md
new file mode 100644
index 000000000..6df4caba2
--- /dev/null
+++ b/docs/fixtures/powerx-reingest/README.md
@@ -0,0 +1,34 @@
+# Retained telemetry for re-ingest recovery
+
+`nvidia.csv` contains unchanged readings from the public InferenceX B200/Qwen3.5
+run [34175132645, attempt 1](https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645/attempts/1).
+Tests read these committed bytes; no artifact download is required.
+
+Retain original line 1 and lines 2898–2921, joined with LF and a final LF: three
+consecutive samples of all eight GPUs, 24 rows / 1,901 bytes. Headers, units,
+timestamps and values are unchanged. The CSV contains no hostnames or UUIDs, so
+no identity anonymization was needed. The original collector version and timezone
+are unknown.
+
+The UTC context, collector labels, identity sidecars, local benchmark rows and
+repair offsets used by tests are **constructed test inputs**. They do not describe
+a correction to the original run. No original energy/quality claim is attached to
+this cropped fragment. It proves retained-format parsing and recovery through the
+consumer, not GPU collection reliability or serving-window qualification.
+
+Fixed checks come directly from the retained rows: GPU 0 has
+`380.42, 336.61, 337.18 W`; with the explicit UTC test context the range is
+`2026-09-08T07:20:19.279Z`–`2026-09-08T07:20:21.279Z`. Its sample mean is
+`351.4033333333333 W`. Production parsers/statistics functions must not generate
+test expectations.
+
+Run the recovery check from `packages/app`:
+
+```sh
+bun node_modules/vitest/vitest.mjs run src/app/api/v1/gpu-metrics-point/route.test.ts
+```
+
+The test uses PGlite, the production parser/ingest/query/cache/point handler, and
+the real Blob SDK with a local HTTP transport. It checks live revisions for
+successful and missing responses, then refreshes a missing point, shared links and
+timezone/identity repairs without purging.
diff --git a/docs/fixtures/powerx-reingest/nvidia.csv b/docs/fixtures/powerx-reingest/nvidia.csv
new file mode 100644
index 000000000..62113072c
--- /dev/null
+++ b/docs/fixtures/powerx-reingest/nvidia.csv
@@ -0,0 +1,25 @@
+timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]
+2026/09/08 07:20:19.279, 0, 380.42 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 1, 392.58 W, 43, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 2, 375.45 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 3, 384.71 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 4, 379.91 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 5, 388.18 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 6, 374.34 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:19.279, 7, 379.36 W, 41, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 0, 336.61 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 1, 346.06 W, 43, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 2, 333.34 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 3, 344.15 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 4, 337.25 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 5, 342.84 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 6, 335.00 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:20.279, 7, 335.78 W, 41, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 0, 337.18 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 1, 345.05 W, 43, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 2, 340.15 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 3, 344.63 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 4, 337.94 W, 36, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 5, 342.85 W, 42, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 6, 334.88 W, 37, 1965 MHz, 3996 MHz, 100 %, 9 %
+2026/09/08 07:20:21.279, 7, 336.11 W, 41, 1965 MHz, 3996 MHz, 100 %, 9 %
diff --git a/packages/db/src/etl/benchmark-mapper.ts b/packages/db/src/etl/benchmark-mapper.ts
index 060b39412..d63a4a49a 100644
--- a/packages/db/src/etl/benchmark-mapper.ts
+++ b/packages/db/src/etl/benchmark-mapper.ts
@@ -148,7 +148,7 @@ export interface PowerAudit {
   max_sample_gap_s?: number;
   producer_sha?: string | null;
   exporter_image_sha256?: string | null;
-  /** Relative path within the source run artifact bundle. */
+  /** Validation filename; nested AgentX documents use a canonical filename alias. */
   source?: string;
   /** Producer device identifiers; not necessarily physical UUIDs on older traces. */
   observed_gpu_ids?: string[];
diff --git a/packages/db/src/etl/gpu-metrics-artifacts.ts b/packages/db/src/etl/gpu-metrics-artifacts.ts
new file mode 100644
index 000000000..d101976e4
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-artifacts.ts
@@ -0,0 +1,275 @@
+/**
+ * Filesystem discovery for `gpu_metrics_<suffix>` artifacts.
+ *
+ * Layout uploaded by the producer (`benchmark-tmpl.yml` "Upload GPU metrics"):
+ *   gpu_metrics.csv                         fixed-sequence jobs
+ *   results/gpu_metrics.csv                 AgentX jobs (per-concurrency)
+ *   results/gpu_metrics*.csv                multinode staging, one CSV per node
+ *   gpu_metrics*_context.json               collector context (timestamp zone …)
+ *   gpu_metrics_identity.{json,csv}         SKU / UUID / driver per GPU
+ *   gpu_metrics_energy_{start,end}.csv      amd-smi energy counters
+ *
+ * Multinode jobs (`benchmark-multinode-tmpl.yml`) upload no `gpu_metrics_`
+ * artifact; their telemetry travels inside `power_audit_<suffix>`:
+ *   LOGS/power/samples.csv                  deployment-wide DCGM power, one row per (host, GPU, s)
+ *   LOGS/power/manifest.json                producer, source metric, cadence
+ * Single-node jobs upload a `power_audit_` bundle too, so it only stands in
+ * for a point when no `gpu_metrics_<suffix>` sibling exists.
+ *
+ * `eval_gpu_metrics_<suffix>` (eval-only jobs) is deliberately ignored: those
+ * jobs produce no benchmark point to attach the telemetry to.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+
+import { isMultinodePowerSamplesPath } from './multinode-power-samples.js';
+import {
+  isPowerAuditValidationEntry,
+  normalizePowerAuditValidations,
+} from './power-audit-validations.js';
+
+export const GPU_METRICS_ARTIFACT_PREFIX = 'gpu_metrics_';
+export const POWER_AUDIT_ARTIFACT_PREFIX = 'power_audit_';
+
+export interface GpuMetricsArtifact {
+  artifactName: string;
+  artifactDir: string;
+}
+
+export interface GpuMetricsCsvFile {
+  /** POSIX-style path relative to the artifact root. */
+  fileName: string;
+  path: string;
+}
+
+export interface GpuMetricsSidecars {
+  context: Record<string, unknown> | null;
+  /** Audit documents keyed by canonical source; nested documents retain original path/hash. */
+  validations?: Record<string, Record<string, unknown>>;
+  /** Expected stored files and deduplicated row counts from this one artifact. */
+  seriesInventory?: { fileName: string; sampleCount: number }[];
+  /** Bundle manifest when the preferred CSV has its own collector context. */
+  powerManifest?: Record<string, unknown> | null;
+  identity: unknown | null;
+  energyStart: Record<string, number> | null;
+  energyEnd: Record<string, number> | null;
+}
+
+/** Return the shared suffix that pairs a telemetry artifact with bmk[_agentic]_<suffix>. */
+export function gpuMetricsArtifactSuffix(artifactName: string): string | null {
+  for (const prefix of [GPU_METRICS_ARTIFACT_PREFIX, POWER_AUDIT_ARTIFACT_PREFIX]) {
+    if (artifactName.startsWith(prefix)) return artifactName.slice(prefix.length);
+  }
+  return null;
+}
+
+/** The nvidia-smi/amd-smi CSV carries clocks, utilization and temperature; the power bundle only power. */
+export function isPowerAuditArtifact(artifactName: string): boolean {
+  return artifactName.startsWith(POWER_AUDIT_ARTIFACT_PREFIX);
+}
+
+function isGpuMetricsCsvName(fileName: string): boolean {
+  const lower = fileName.toLowerCase();
+  if (!lower.startsWith('gpu_metrics') || !lower.endsWith('.csv')) return false;
+  // Sidecars share the prefix but are not time series.
+  return !lower.includes('_identity') && !lower.includes('_energy_');
+}
+
+/** Recursively list every telemetry CSV under an extracted artifact root. */
+export function listGpuMetricsCsvFiles(root: string): GpuMetricsCsvFile[] {
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return [];
+  const files: GpuMetricsCsvFile[] = [];
+  const visit = (directory: string): void => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const pathname = path.join(directory, entry.name);
+      if (entry.isDirectory()) visit(pathname);
+      else if (entry.isFile() && isGpuMetricsCsvName(entry.name)) {
+        files.push({
+          fileName: path.relative(root, pathname).split(path.sep).join('/'),
+          path: pathname,
+        });
+      }
+    }
+  };
+  visit(root);
+  return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
+}
+
+/** Every multinode power CSV under an extracted `power_audit_` root. */
+export function listMultinodePowerSampleFiles(root: string): GpuMetricsCsvFile[] {
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return [];
+  const files: GpuMetricsCsvFile[] = [];
+  const visit = (directory: string): void => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const pathname = path.join(directory, entry.name);
+      if (entry.isDirectory()) visit(pathname);
+      else if (entry.isFile()) {
+        const fileName = path.relative(root, pathname).split(path.sep).join('/');
+        if (isMultinodePowerSamplesPath(fileName)) files.push({ fileName, path: pathname });
+      }
+    }
+  };
+  visit(root);
+  return files.toSorted((a, b) => a.fileName.localeCompare(b.fileName));
+}
+
+/** The producer manifest next to `samples.csv`; null when absent or malformed. */
+export function readMultinodePowerManifest(samplesPath: string): Record<string, unknown> | null {
+  const parsed = readJsonIfPresent(path.join(path.dirname(samplesPath), 'manifest.json'));
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+    ? (parsed as Record<string, unknown>)
+    : null;
+}
+
+/** Preserve window boundaries and role overrides before GitHub artifact expiry. */
+export function readPowerAuditValidations(
+  root: string,
+  artifactName = path.basename(root),
+): Record<string, Record<string, unknown>> {
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) return {};
+  const files = new Map<string, string>();
+  const read = (name: string) => {
+    const file = path.join(root, name);
+    if (isPowerAuditValidationEntry(name) && fs.existsSync(file) && fs.statSync(file).isFile()) {
+      files.set(name, fs.readFileSync(file, 'utf8'));
+    }
+  };
+  for (const name of fs.readdirSync(root).sort()) {
+    read(name);
+  }
+  const agentic = path.join(root, 'LOGS', 'agentic');
+  if (fs.existsSync(agentic) && fs.statSync(agentic).isDirectory()) {
+    for (const entry of fs.readdirSync(agentic, { withFileTypes: true })) {
+      const match = /^conc_(?<concurrency>[1-9]\d*)$/u.exec(entry.name);
+      if (!entry.isDirectory() || !match) continue;
+      read(`LOGS/agentic/${entry.name}/power_validation.json`);
+      read(`LOGS/power/windows/agentic_power_concurrency_${match.groups!.concurrency}.json`);
+    }
+  }
+  const validations = normalizePowerAuditValidations(artifactName, files);
+  for (const validation of validations.values()) {
+    if (typeof validation.validation_path !== 'string') continue;
+    const original = files.get(validation.validation_path);
+    if (original !== undefined)
+      validation.validation_sha256 = createHash('sha256').update(original).digest('hex');
+  }
+  return Object.fromEntries(validations);
+}
+
+function readJsonIfPresent(pathname: string): unknown | null {
+  if (!fs.existsSync(pathname)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(pathname, 'utf8')) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+/** `gpu,total_energy_consumption` two-column CSV → { "<gpu>": joules }. */
+export function parseEnergyCsv(text: string): Record<string, number> | null {
+  const lines = text
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  if (lines.length <= 1) return null;
+  const out: Record<string, number> = {};
+  for (const line of lines.slice(1)) {
+    const [gpu, value] = line.split(',');
+    const parsed = Number.parseFloat(value ?? '');
+    if (gpu !== undefined && gpu !== '' && Number.isFinite(parsed)) out[gpu.trim()] = parsed;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+
+/** Identity CSV (nvidia-smi) → array of column objects; JSON identity passes through. */
+function readIdentity(csvDir: string): unknown | null {
+  const json = readJsonIfPresent(path.join(csvDir, 'gpu_metrics_identity.json'));
+  if (json !== null) return json;
+  const csvPath = path.join(csvDir, 'gpu_metrics_identity.csv');
+  if (!fs.existsSync(csvPath)) return null;
+  const lines = fs
+    .readFileSync(csvPath, 'utf8')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+  if (lines.length <= 1) return null;
+  const header = lines[0]!.split(',').map((h) => h.trim());
+  return lines.slice(1).map((line) => {
+    const cells = line.split(',').map((c) => c.trim());
+    return Object.fromEntries(header.map((key, i) => [key, cells[i] ?? '']));
+  });
+}
+
+/**
+ * Sidecars live next to the CSV they describe. The context file is either
+ * `gpu_metrics_context.json` or `<result>_gpu_metrics_context.json`.
+ */
+export function readGpuMetricsSidecars(csvPath: string): GpuMetricsSidecars {
+  const dir = path.dirname(csvPath);
+  let context: Record<string, unknown> | null = null;
+  // Match live ZIP reads even when filesystem/central-directory orders differ.
+  const contextFiles = fs
+    .readdirSync(dir)
+    .filter(
+      (entry) => entry.toLowerCase().endsWith('_context.json') && entry.includes('gpu_metrics'),
+    )
+    .sort();
+  for (const entry of contextFiles) {
+    const parsed = readJsonIfPresent(path.join(dir, entry));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      context = parsed as Record<string, unknown>;
+      break;
+    }
+  }
+  const energyStartPath = path.join(dir, 'gpu_metrics_energy_start.csv');
+  const energyEndPath = path.join(dir, 'gpu_metrics_energy_end.csv');
+  return {
+    context,
+    identity: readIdentity(dir),
+    energyStart: fs.existsSync(energyStartPath)
+      ? parseEnergyCsv(fs.readFileSync(energyStartPath, 'utf8'))
+      : null,
+    energyEnd: fs.existsSync(energyEndPath)
+      ? parseEnergyCsv(fs.readFileSync(energyEndPath, 'utf8'))
+      : null,
+  };
+}
+
+/**
+ * Collector clock offset in minutes east of UTC, from the context sidecar.
+ * The producer writes `{"timestamp_timezone":"UTC"}`; anything else that is
+ * not a fixed `±HH:MM` offset is treated as UTC because nvidia-smi timestamps
+ * carry no zone of their own.
+ */
+export function contextUtcOffsetMinutes(context: Record<string, unknown> | null): number {
+  const zone = context?.timestamp_timezone;
+  if (typeof zone !== 'string') return 0;
+  const match = /^(?<sign>[+-])(?<h>\d{2}):?(?<m>\d{2})$/u.exec(zone.trim());
+  if (!match?.groups) return 0;
+  const minutes = Number(match.groups.h) * 60 + Number(match.groups.m);
+  return match.groups.sign === '-' ? -minutes : minutes;
+}
+
+/**
+ * Index every extracted telemetry artifact by its shared suffix. A
+ * `gpu_metrics_` upload wins over the `power_audit_` bundle for the same
+ * suffix; the bundle only fills in for multinode jobs that have no other.
+ */
+export function discoverGpuMetricsArtifacts(artifactsDir: string): Map<string, GpuMetricsArtifact> {
+  const discovered = new Map<string, GpuMetricsArtifact>();
+  if (!fs.existsSync(artifactsDir)) return discovered;
+  const names = fs
+    .readdirSync(artifactsDir)
+    .filter((artifactName) => fs.statSync(path.join(artifactsDir, artifactName)).isDirectory());
+  for (const preferred of [false, true]) {
+    for (const artifactName of names) {
+      if (isPowerAuditArtifact(artifactName) !== preferred) continue;
+      const suffix = gpuMetricsArtifactSuffix(artifactName);
+      if (!suffix || discovered.has(suffix)) continue;
+      discovered.set(suffix, { artifactName, artifactDir: path.join(artifactsDir, artifactName) });
+    }
+  }
+  return discovered;
+}
diff --git a/packages/db/src/etl/gpu-metrics-csv.test.ts b/packages/db/src/etl/gpu-metrics-csv.test.ts
new file mode 100644
index 000000000..be0425149
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-csv.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+
+import { computeGpuMetricStats, parseGpuMetricsCsv } from './gpu-metrics-csv.js';
+
+const NVIDIA_CSV = [
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+  '2026/09/11 04:19:41.982, 0, 187.80 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:41.986, 1, 190.96 W, 39, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:42.990, 0, 912.10 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+  '2026/09/11 04:19:42.994, 1, [N/A], 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+  '2026/09/11 04:19:43.990, 0, 930.00 W, 63, 1965 MHz, 3996 MHz, 99 %, 75 %',
+].join('\n');
+
+const AMD_HEADER =
+  'timestamp,gpu,gfx_activity,umc_activity,mm_activity,socket_power,gfx_voltage,soc_voltage,mem_voltage,gfx_0_clk,mem_0_clk,fclk_0_clk,socclk_0_clk,edge,hotspot,mem';
+
+const AMD_CSV = [
+  AMD_HEADER,
+  `1789515524,0,0,0,N/A,288,N/A,N/A,N/A,2402,2000,1250,39,N/A,44,24`,
+  `1789515525,0,95,80,N/A,1180,850,900,1250,2100,2000,1250,39,55,78,60`,
+  `1789515524,1,0,0,N/A,290,N/A,N/A,N/A,2402,2000,1250,39,40,45,25`,
+].join('\r\n');
+
+describe('parseGpuMetricsCsv — NVIDIA', () => {
+  it('parses unit-suffixed cells into UTC epoch samples and drops rows without power', () => {
+    const parsed = parseGpuMetricsCsv(NVIDIA_CSV);
+    expect(parsed?.vendor).toBe('nvidia');
+    expect(parsed?.samples).toHaveLength(4);
+    const first = parsed!.samples[0]!;
+    expect(first.timestampMs).toBe(Date.UTC(2026, 8, 11, 4, 19, 41, 982));
+    expect(first.gpuIndex).toBe(0);
+    expect(first.powerW).toBe(187.8);
+    expect(first.temperatureC).toBe(33);
+    expect(first.smClockMhz).toBe(120);
+    expect(first.memClockMhz).toBe(3996);
+    expect(first.gpuUtilPct).toBe(0);
+    expect(first.memUtilPct).toBe(0);
+    expect(first.edgeTempC).toBeNull();
+    // The `[N/A]` power row for GPU 1 is not a usable sample.
+    expect(parsed!.samples.filter((s) => s.gpuIndex === 1)).toHaveLength(1);
+  });
+});
+
+describe('parseGpuMetricsCsv — AMD', () => {
+  it('maps the amd-smi subset, preferring hotspot over edge temperature', () => {
+    const parsed = parseGpuMetricsCsv(AMD_CSV);
+    expect(parsed?.vendor).toBe('amd');
+    expect(parsed?.samples).toHaveLength(3);
+    const idle = parsed!.samples[0]!;
+    expect(idle.timestampMs).toBe(1789515524000);
+    expect(idle.powerW).toBe(288);
+    expect(idle.temperatureC).toBe(44);
+    expect(idle.edgeTempC).toBeNull();
+    expect(idle.memTempC).toBe(24);
+    expect(idle.gfxVoltageMv).toBeNull();
+    const busy = parsed!.samples[1]!;
+    expect(busy.gpuUtilPct).toBe(95);
+    expect(busy.memUtilPct).toBe(80);
+    expect(busy.gfxVoltageMv).toBe(850);
+    expect(busy.fclkMhz).toBe(1250);
+    expect(busy.socclkMhz).toBe(39);
+    expect(busy.edgeTempC).toBe(55);
+    expect(busy.temperatureC).toBe(78);
+  });
+});
+
+describe('computeGpuMetricStats', () => {
+  it('digests every non-null metric per GPU with interpolated percentiles', () => {
+    const parsed = parseGpuMetricsCsv(NVIDIA_CSV)!;
+    const stats = computeGpuMetricStats(parsed.samples);
+    const gpu0Power = stats.find((s) => s.gpuIndex === 0 && s.metric === 'powerW')!;
+    expect(gpu0Power.count).toBe(3);
+    expect(gpu0Power.min).toBe(187.8);
+    expect(gpu0Power.max).toBe(930);
+    expect(gpu0Power.mean).toBeCloseTo((187.8 + 912.1 + 930) / 3, 6);
+    expect(gpu0Power.median).toBe(912.1);
+    expect(gpu0Power.p95).toBeCloseTo(912.1 + (930 - 912.1) * 0.9, 6);
+    expect(gpu0Power.p99).toBeCloseTo(912.1 + (930 - 912.1) * 0.98, 6);
+    expect(gpu0Power.stddev).toBeGreaterThan(0);
+    // AMD-only columns never appear for an NVIDIA series.
+    expect(stats.some((s) => s.metric === 'edgeTempC')).toBe(false);
+    expect(stats.filter((s) => s.gpuIndex === 1 && s.metric === 'powerW')[0]!.count).toBe(1);
+  });
+});
diff --git a/packages/db/src/etl/gpu-metrics-csv.ts b/packages/db/src/etl/gpu-metrics-csv.ts
new file mode 100644
index 000000000..35ec33e57
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-csv.ts
@@ -0,0 +1,385 @@
+/**
+ * Parser and digest for the producer's `gpu_metrics.csv` telemetry.
+ *
+ * The InferenceX runner samples `nvidia-smi --query-gpu=…` or `amd-smi metric
+ * --csv` once per second for the lifetime of a benchmark job. This module is
+ * pure (no I/O) so the CI ingest, the historical backfill, and the app's
+ * GitHub fallback path all normalize the two vendor formats identically.
+ */
+
+export type GpuMetricsVendor = 'nvidia' | 'amd';
+
+export interface GpuMetricSample {
+  /** Sample instant in epoch milliseconds (UTC). */
+  timestampMs: number;
+  gpuIndex: number;
+  powerW: number | null;
+  temperatureC: number | null;
+  smClockMhz: number | null;
+  memClockMhz: number | null;
+  gpuUtilPct: number | null;
+  memUtilPct: number | null;
+  edgeTempC: number | null;
+  memTempC: number | null;
+  gfxVoltageMv: number | null;
+  socVoltageMv: number | null;
+  memVoltageMv: number | null;
+  fclkMhz: number | null;
+  socclkMhz: number | null;
+  mmActivityPct: number | null;
+}
+
+export interface ParsedGpuMetricsCsv {
+  vendor: GpuMetricsVendor;
+  samples: GpuMetricSample[];
+}
+
+/** Sample columns that participate in the per-GPU statistics digest. */
+export const GPU_METRIC_STAT_KEYS = [
+  'powerW',
+  'temperatureC',
+  'smClockMhz',
+  'memClockMhz',
+  'gpuUtilPct',
+  'memUtilPct',
+  'edgeTempC',
+  'memTempC',
+  'gfxVoltageMv',
+  'socVoltageMv',
+  'memVoltageMv',
+  'fclkMhz',
+  'socclkMhz',
+  'mmActivityPct',
+] as const;
+
+export type GpuMetricStatKey = (typeof GPU_METRIC_STAT_KEYS)[number];
+
+export interface GpuMetricStats {
+  gpuIndex: number;
+  metric: GpuMetricStatKey;
+  count: number;
+  min: number;
+  max: number;
+  mean: number;
+  median: number;
+  p95: number;
+  p99: number;
+  stddev: number;
+}
+
+export function splitCsvLine(line: string): string[] {
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+  for (const char of line) {
+    if (char === '"') {
+      inQuotes = !inQuotes;
+    } else if (char === ',' && !inQuotes) {
+      result.push(current.trim());
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+
+function buildColumnMap(headerLine: string): Map<string, number> {
+  const headers = splitCsvLine(headerLine);
+  const map = new Map<string, number>();
+  for (let i = 0; i < headers.length; i++) map.set(headers[i]!.toLowerCase(), i);
+  return map;
+}
+
+/** `N/A`, empty, and unparseable cells become null; unit suffixes are ignored. */
+export function parseMetricCell(value: string | undefined): number | null {
+  if (value === undefined) return null;
+  const trimmed = value.trim();
+  if (trimmed === '' || trimmed === 'N/A' || trimmed === '[N/A]') return null;
+  const parsed = Number.parseFloat(trimmed);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+const NVIDIA_TIMESTAMP_RE =
+  /^(?<y>\d{4})\/(?<mo>\d{2})\/(?<d>\d{2}) (?<h>\d{2}):(?<mi>\d{2}):(?<s>\d{2})(?:\.(?<ms>\d{1,3}))?$/u;
+
+/**
+ * nvidia-smi prints `YYYY/MM/DD HH:MM:SS.mmm` in the collector's local zone.
+ * The producer runs its collectors with TZ=UTC; callers can pass a different
+ * fixed offset (minutes east of UTC) when a context sidecar says otherwise.
+ */
+export function parseNvidiaTimestamp(raw: string, offsetMinutes = 0): number | null {
+  const match = NVIDIA_TIMESTAMP_RE.exec(raw.trim());
+  if (!match?.groups) return null;
+  const { y, mo, d, h, mi, s, ms } = match.groups;
+  const millis = ms ? Number(ms.padEnd(3, '0')) : 0;
+  const utc = Date.UTC(
+    Number(y),
+    Number(mo) - 1,
+    Number(d),
+    Number(h),
+    Number(mi),
+    Number(s),
+    millis,
+  );
+  return utc - offsetMinutes * 60_000;
+}
+
+/** amd-smi prints Unix epoch seconds; accept fractional and millisecond forms. */
+export function parseAmdTimestamp(raw: string): number | null {
+  const trimmed = raw.trim();
+  if (/^\d+(?:\.\d+)?$/u.test(trimmed)) {
+    const numeric = Number.parseFloat(trimmed);
+    if (numeric > 1e12) return Math.round(numeric); // already milliseconds
+    if (numeric > 1e9) return Math.round(numeric * 1000);
+    return null;
+  }
+  const iso = Date.parse(trimmed);
+  return Number.isFinite(iso) ? iso : null;
+}
+
+function emptySample(timestampMs: number, gpuIndex: number): GpuMetricSample {
+  return {
+    timestampMs,
+    gpuIndex,
+    powerW: null,
+    temperatureC: null,
+    smClockMhz: null,
+    memClockMhz: null,
+    gpuUtilPct: null,
+    memUtilPct: null,
+    edgeTempC: null,
+    memTempC: null,
+    gfxVoltageMv: null,
+    socVoltageMv: null,
+    memVoltageMv: null,
+    fclkMhz: null,
+    socclkMhz: null,
+    mmActivityPct: null,
+  };
+}
+
+/**
+ * Columns: timestamp, index, power.draw [W], temperature.gpu,
+ * clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%],
+ * utilization.memory [%]. Header order is fixed by NVIDIA_GPU_MONITOR_QUERY in
+ * the producer, but we still resolve by name so a reordered query keeps working.
+ */
+function parseNvidiaCsv(lines: readonly string[], offsetMinutes: number): GpuMetricSample[] {
+  const header = splitCsvLine(lines[0]!).map((h) => h.toLowerCase().replace(/\s*\[.*\]$/u, ''));
+  const col = (name: string) => header.indexOf(name);
+  const iTimestamp = col('timestamp');
+  const iIndex = col('index');
+  const iPower = col('power.draw');
+  const iTemp = col('temperature.gpu');
+  const iSm = col('clocks.current.sm');
+  const iMem = col('clocks.current.memory');
+  const iUtil = col('utilization.gpu');
+  const iMemUtil = col('utilization.memory');
+  if (iTimestamp < 0 || iIndex < 0 || iPower < 0) return [];
+
+  const samples: GpuMetricSample[] = [];
+  for (let i = 1; i < lines.length; i++) {
+    const cols = splitCsvLine(lines[i]!);
+    if (cols.length <= Math.max(iTimestamp, iIndex, iPower)) continue;
+    const timestampMs = parseNvidiaTimestamp(cols[iTimestamp]!, offsetMinutes);
+    const gpuIndex = Number.parseInt(cols[iIndex]!, 10);
+    if (timestampMs === null || !Number.isInteger(gpuIndex) || gpuIndex < 0) continue;
+    const sample = emptySample(timestampMs, gpuIndex);
+    sample.powerW = parseMetricCell(cols[iPower]);
+    if (sample.powerW === null) continue;
+    sample.temperatureC = iTemp >= 0 ? parseMetricCell(cols[iTemp]) : null;
+    sample.smClockMhz = iSm >= 0 ? parseMetricCell(cols[iSm]) : null;
+    sample.memClockMhz = iMem >= 0 ? parseMetricCell(cols[iMem]) : null;
+    sample.gpuUtilPct = iUtil >= 0 ? parseMetricCell(cols[iUtil]) : null;
+    sample.memUtilPct = iMemUtil >= 0 ? parseMetricCell(cols[iMemUtil]) : null;
+    samples.push(sample);
+  }
+  return samples;
+}
+
+/**
+ * amd-smi `metric --csv` is a wide table. The consumed subset mirrors the
+ * dashboard: socket_power, gfx_activity, umc_activity, mm_activity, the first
+ * gfx/mem/fclk/socclk clock domains, hotspot/edge/mem temperatures and the
+ * three voltage rails.
+ */
+function parseAmdCsv(lines: readonly string[]): GpuMetricSample[] {
+  const colMap = buildColumnMap(lines[0]!);
+  const col = (name: string) => colMap.get(name) ?? -1;
+  const iTimestamp = col('timestamp');
+  const iGpu = col('gpu');
+  const iPower = col('socket_power');
+  const iGfxActivity = col('gfx_activity');
+  const iUmcActivity = col('umc_activity');
+  const iGfxClk = col('gfx_0_clk');
+  const iMemClk = col('mem_0_clk');
+  const iHotspot = col('hotspot');
+  const iEdge = col('edge');
+  const iMemTemp = col('mem');
+  const iGfxVoltage = col('gfx_voltage');
+  const iSocVoltage = col('soc_voltage');
+  const iMemVoltage = col('mem_voltage');
+  const iFclk = col('fclk_0_clk');
+  const iSocClk = col('socclk_0_clk');
+  const iMmActivity = col('mm_activity');
+  if (iTimestamp < 0 || iGpu < 0 || iPower < 0) return [];
+
+  const samples: GpuMetricSample[] = [];
+  for (let i = 1; i < lines.length; i++) {
+    const cols = splitCsvLine(lines[i]!);
+    if (cols.length <= Math.max(iTimestamp, iGpu, iPower)) continue;
+    const timestampMs = parseAmdTimestamp(cols[iTimestamp]!);
+    const gpuIndex = Number.parseInt(cols[iGpu]!, 10);
+    if (timestampMs === null || !Number.isInteger(gpuIndex) || gpuIndex < 0) continue;
+    const sample = emptySample(timestampMs, gpuIndex);
+    sample.powerW = parseMetricCell(cols[iPower]);
+    if (sample.powerW === null) continue;
+    const hotspot = iHotspot >= 0 ? parseMetricCell(cols[iHotspot]) : null;
+    const edge = iEdge >= 0 ? parseMetricCell(cols[iEdge]) : null;
+    sample.temperatureC = hotspot ?? edge;
+    sample.edgeTempC = edge;
+    sample.memTempC = iMemTemp >= 0 ? parseMetricCell(cols[iMemTemp]) : null;
+    sample.smClockMhz = iGfxClk >= 0 ? parseMetricCell(cols[iGfxClk]) : null;
+    sample.memClockMhz = iMemClk >= 0 ? parseMetricCell(cols[iMemClk]) : null;
+    sample.gpuUtilPct = iGfxActivity >= 0 ? parseMetricCell(cols[iGfxActivity]) : null;
+    sample.memUtilPct = iUmcActivity >= 0 ? parseMetricCell(cols[iUmcActivity]) : null;
+    sample.gfxVoltageMv = iGfxVoltage >= 0 ? parseMetricCell(cols[iGfxVoltage]) : null;
+    sample.socVoltageMv = iSocVoltage >= 0 ? parseMetricCell(cols[iSocVoltage]) : null;
+    sample.memVoltageMv = iMemVoltage >= 0 ? parseMetricCell(cols[iMemVoltage]) : null;
+    sample.fclkMhz = iFclk >= 0 ? parseMetricCell(cols[iFclk]) : null;
+    sample.socclkMhz = iSocClk >= 0 ? parseMetricCell(cols[iSocClk]) : null;
+    sample.mmActivityPct = iMmActivity >= 0 ? parseMetricCell(cols[iMmActivity]) : null;
+    samples.push(sample);
+  }
+  return samples;
+}
+
+export interface ParseGpuMetricsOptions {
+  /** Fixed offset of the NVIDIA collector clock, minutes east of UTC. */
+  nvidiaUtcOffsetMinutes?: number;
+}
+
+/**
+ * Parse one gpu_metrics CSV, auto-detecting the vendor from the header.
+ * Samples are returned in file order; callers sort per GPU as needed.
+ */
+export function parseGpuMetricsCsv(
+  csvText: string,
+  options: ParseGpuMetricsOptions = {},
+): ParsedGpuMetricsCsv | null {
+  const lines = csvText
+    .split('\n')
+    .map((line) => line.replace(/\r$/u, ''))
+    .filter((line) => line.trim().length > 0);
+  if (lines.length <= 1) return null;
+  const headerLower = lines[0]!.toLowerCase();
+  if (headerLower.includes('socket_power') || headerLower.includes('gfx_activity')) {
+    return { vendor: 'amd', samples: parseAmdCsv(lines) };
+  }
+  if (headerLower.includes('power.draw')) {
+    return {
+      vendor: 'nvidia',
+      samples: parseNvidiaCsv(lines, options.nvidiaUtcOffsetMinutes ?? 0),
+    };
+  }
+  return null;
+}
+
+function percentile(sorted: readonly number[], p: number): number {
+  const idx = (p / 100) * (sorted.length - 1);
+  const lo = Math.floor(idx);
+  const hi = Math.ceil(idx);
+  if (lo === hi) return sorted[lo]!;
+  return sorted[lo]! + (sorted[hi]! - sorted[lo]!) * (idx - lo);
+}
+
+/** Per-GPU, per-metric summary over every non-null sample. */
+export function computeGpuMetricStats(samples: readonly GpuMetricSample[]): GpuMetricStats[] {
+  const groups = new Map<
+    string,
+    { gpuIndex: number; metric: GpuMetricStatKey; values: number[] }
+  >();
+  for (const sample of samples) {
+    for (const metric of GPU_METRIC_STAT_KEYS) {
+      const value = sample[metric];
+      if (value === null) continue;
+      const key = `${sample.gpuIndex}|${metric}`;
+      let group = groups.get(key);
+      if (!group) {
+        group = { gpuIndex: sample.gpuIndex, metric, values: [] };
+        groups.set(key, group);
+      }
+      group.values.push(value);
+    }
+  }
+
+  const stats: GpuMetricStats[] = [];
+  for (const group of groups.values()) {
+    const sorted = group.values.toSorted((a, b) => a - b);
+    const mean = sorted.reduce((acc, v) => acc + v, 0) / sorted.length;
+    const variance = sorted.reduce((acc, v) => acc + (v - mean) ** 2, 0) / sorted.length;
+    stats.push({
+      gpuIndex: group.gpuIndex,
+      metric: group.metric,
+      count: sorted.length,
+      min: sorted[0]!,
+      max: sorted.at(-1)!,
+      mean,
+      median: percentile(sorted, 50),
+      p95: percentile(sorted, 95),
+      p99: percentile(sorted, 99),
+      stddev: Math.sqrt(variance),
+    });
+  }
+  return stats.toSorted((a, b) => a.gpuIndex - b.gpuIndex || a.metric.localeCompare(b.metric));
+}
+
+export interface GpuMetricSeriesSummary {
+  sampleCount: number;
+  gpuCount: number;
+  startedAtMs: number;
+  endedAtMs: number;
+  /** Median gap between consecutive samples of one GPU, in seconds. */
+  sampleIntervalS: number | null;
+}
+
+/** Window and cadence facts stored on the series row. */
+export function summarizeGpuMetricSamples(
+  samples: readonly GpuMetricSample[],
+): GpuMetricSeriesSummary | null {
+  if (samples.length === 0) return null;
+  let startedAtMs = Number.POSITIVE_INFINITY;
+  let endedAtMs = Number.NEGATIVE_INFINITY;
+  const byGpu = new Map<number, number[]>();
+  for (const sample of samples) {
+    if (sample.timestampMs < startedAtMs) startedAtMs = sample.timestampMs;
+    if (sample.timestampMs > endedAtMs) endedAtMs = sample.timestampMs;
+    const bucket = byGpu.get(sample.gpuIndex);
+    if (bucket) bucket.push(sample.timestampMs);
+    else byGpu.set(sample.gpuIndex, [sample.timestampMs]);
+  }
+  const gaps: number[] = [];
+  for (const timestamps of byGpu.values()) {
+    const sorted = timestamps.toSorted((a, b) => a - b);
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i]! - sorted[i - 1]!;
+      if (gap > 0) gaps.push(gap);
+    }
+  }
+  const sampleIntervalS =
+    gaps.length > 0
+      ? percentile(
+          gaps.toSorted((a, b) => a - b),
+          50,
+        ) / 1000
+      : null;
+  return {
+    sampleCount: samples.length,
+    gpuCount: byGpu.size,
+    startedAtMs,
+    endedAtMs,
+    sampleIntervalS,
+  };
+}
diff --git a/packages/db/src/etl/gpu-metrics-ingest.test.ts b/packages/db/src/etl/gpu-metrics-ingest.test.ts
new file mode 100644
index 000000000..92d1506ba
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-ingest.test.ts
@@ -0,0 +1,416 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  ingestGpuMetricsArtifact,
+  prepareGpuMetricsArtifact,
+  refreshGpuMetricStats,
+} from './gpu-metrics-ingest';
+
+import { findOutdatedGpuMetricSeries } from '../lib/gpu-metrics-backfill';
+import { GPU_STATS_VERSION } from '../lib/gpu-metric-stats';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+let sql: Sql;
+const roots: string[] = [];
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, {
+    json: JSON.stringify,
+    array: (value: unknown) => value,
+  });
+}
+
+async function storedSeries(seriesId: number) {
+  return {
+    metadata: await sql`select * from gpu_metric_series where id = ${seriesId}`,
+    samples: await sql`select * from gpu_metric_samples where series_id = ${seriesId}
+      order by sampled_at, gpu_index`,
+    stats: await sql`select * from gpu_metric_gpu_stats where series_id = ${seriesId}
+      order by gpu_index, metric`,
+    links: await sql`select * from benchmark_result_gpu_metrics where series_id = ${seriesId}
+      order by benchmark_result_id`,
+  };
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  sql = Object.assign(queryClient(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(queryClient(tx) as unknown as Sql)),
+  }) as unknown as Sql;
+}, 20_000);
+
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+    VALUES (1, 34557177019, 1, 'Run Sweep', 'completed', 'success', '2026-09-11', '2026-09-11');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 4, 4, 4, 4);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+           (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}');`);
+});
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+afterAll(async () => {
+  await db?.close();
+});
+
+const NVIDIA_CSV = [
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+  '2026/09/11 04:19:41.982, 0, 187.80 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:41.986, 1, 190.96 W, 39, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:42.990, 0, 912.10 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+  // Duplicate flush of the last sample, as emitted when the monitor stops.
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+].join('\n');
+
+function writeArtifact(csv: string, contextZone = 'UTC') {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-ingest-'));
+  roots.push(root);
+  const artifactName = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+  const artifactDir = path.join(root, artifactName);
+  fs.mkdirSync(artifactDir);
+  fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_context.json'),
+    JSON.stringify({ timestamp_timezone: contextZone }),
+  );
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_identity.csv'),
+    'index, uuid, name\n0, GPU-a, NVIDIA B200\n1, GPU-b, NVIDIA B200\n',
+  );
+  return { artifactName, artifactDir };
+}
+
+// Multinode bundle: two hosts × two GPUs × two scrapes, host-local indices.
+const MULTINODE_POWER_CSV = [
+  'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+  '1,1789194365.292,4,host-b,0,GPU-b0,401.5',
+  '1,1789194365.292,4,host-a,0,GPU-a0,186.656',
+  '1,1789194365.292,4,host-a,1,GPU-a1,190.1',
+  '1,1789194366.292,5,host-a,0,GPU-a0,700.25',
+  '1,1789194366.292,5,host-a,1,GPU-a1,702.0',
+  '1,1789194366.292,5,host-b,0,GPU-b0,650.0',
+  '1,1789194366.292,5,host-b,1,GPU-b1,655.0',
+  '1,1789194366.292,5,host-a,0,GPU-a0,999.0',
+].join('\n');
+const MULTINODE_MANIFEST = {
+  schema_version: 1,
+  producer: 'srt-slurm.dcgm-power',
+  source_metric: 'DCGM_FI_DEV_POWER_USAGE',
+  sample_interval_seconds: 1,
+};
+
+function writePowerAuditArtifact() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-ingest-'));
+  roots.push(root);
+  const artifactName = 'power_audit_kimik3_conc8_fp4_dynamo-vllm_b200-slurm_0';
+  const artifactDir = path.join(root, artifactName);
+  fs.mkdirSync(path.join(artifactDir, 'LOGS', 'power'), { recursive: true });
+  fs.writeFileSync(path.join(artifactDir, 'LOGS', 'power', 'samples.csv'), MULTINODE_POWER_CSV);
+  fs.writeFileSync(
+    path.join(artifactDir, 'LOGS', 'power', 'manifest.json'),
+    JSON.stringify(MULTINODE_MANIFEST),
+  );
+  fs.writeFileSync(path.join(artifactDir, 'agg_kimik3_conc8.json'), '{}');
+  return { artifactName, artifactDir };
+}
+
+describe('prepareGpuMetricsArtifact', () => {
+  it('falls back to the multinode power bundle, one power-only series per host', () => {
+    const prepared = prepareGpuMetricsArtifact(writePowerAuditArtifact());
+    expect(prepared.map((series) => series.fileName)).toEqual([
+      'LOGS/power/samples.csv#host-a',
+      'LOGS/power/samples.csv#host-b',
+    ]);
+    const [hostA, hostB] = prepared;
+    expect(hostA!.vendor).toBe('nvidia');
+    expect(hostA!.gpuCount).toBe(2);
+    expect(hostA!.samples).toHaveLength(4);
+    expect(hostA!.startedAtMs).toBe(1789194365292);
+    expect(hostA!.endedAtMs).toBe(1789194366292);
+    expect(hostA!.sampleIntervalS).toBe(1);
+    // One deployment-wide CSV: both host series share its hash.
+    expect(hostB!.csvSha256).toBe(hostA!.csvSha256);
+    // Only power was scraped; no zero-filled clock/temperature/utilization digests.
+    expect(new Set(hostA!.stats.map((s) => s.metric))).toEqual(new Set(['powerW']));
+    expect(hostA!.stats.find((s) => s.gpuIndex === 1)?.max).toBe(702);
+    expect(hostA!.sidecars.context).toEqual(MULTINODE_MANIFEST);
+    expect(hostA!.sidecars.identity).toEqual([
+      { hostname: 'host-a', gpu_index: 0, gpu_uuid: 'GPU-a0' },
+      { hostname: 'host-a', gpu_index: 1, gpu_uuid: 'GPU-a1' },
+    ]);
+    expect(hostA!.sidecars.energyStart).toBeNull();
+  });
+});
+
+describe('ingestGpuMetricsArtifact', () => {
+  it('refuses a partial artifact when a discovered host CSV has only a header', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const missingHostFile = path.join(artifact.artifactDir, 'host-b', 'gpu_metrics.csv');
+    fs.mkdirSync(path.dirname(missingHostFile));
+    fs.writeFileSync(missingHostFile, NVIDIA_CSV.split('\n')[0]!);
+    await expect(
+      ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact,
+        benchmarkResultIds: [10],
+      }),
+    ).rejects.toThrow('host-b/gpu_metrics.csv');
+    const before = await sql`select count(*)::int as n from gpu_metric_series`;
+    expect(before).toEqual([{ n: 0 }]);
+    fs.writeFileSync(missingHostFile, NVIDIA_CSV);
+    const recovered = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(recovered.seriesIds).toHaveLength(2);
+    expect(recovered.samplesInserted).toBe(8);
+    const replay = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    expect(replay.samplesInserted).toBe(0);
+  });
+
+  it('stores series, samples, digest, and point links; reruns are no-ops', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 10],
+    });
+    expect(first.seriesIds).toHaveLength(1);
+    expect(first.samplesInserted).toBe(4);
+    expect(first.seriesSkipped).toBe(0);
+
+    const [series] = await sql<
+      {
+        artifact_name: string;
+        config_key: string;
+        vendor: string;
+        sample_count: number;
+        gpu_count: number;
+        started_at: Date;
+        ended_at: Date;
+        sample_interval_s: number | null;
+      }[]
+    >`select artifact_name, config_key, vendor, sample_count, gpu_count, started_at, ended_at,
+        sample_interval_s from gpu_metric_series`;
+    expect(series!.artifact_name).toBe(artifact.artifactName);
+    expect(series!.config_key).toBe('dsr1_8k1k_fp4_sglang_conc32_b200-x_0');
+    expect(series!.vendor).toBe('nvidia');
+    expect(series!.sample_count).toBe(4);
+    expect(series!.gpu_count).toBe(2);
+    expect(new Date(series!.started_at).toISOString()).toBe('2026-09-11T04:19:41.982Z');
+    expect(new Date(series!.ended_at).toISOString()).toBe('2026-09-11T04:19:42.994Z');
+    expect(series!.sample_interval_s).toBeCloseTo(1.008, 3);
+
+    const samples = await sql<{ gpu_index: number; power_w: number; sampled_at: Date }[]>`
+      select gpu_index, power_w, sampled_at from gpu_metric_samples order by sampled_at, gpu_index`;
+    expect(samples.map((s) => [s.gpu_index, s.power_w])).toEqual([
+      [0, 187.8],
+      [1, 190.96],
+      [0, 912.1],
+      [1, 905.3],
+    ]);
+
+    const stats = await sql<
+      { gpu_index: number; metric: string; sample_count: number; max_value: number }[]
+    >`
+      select gpu_index, metric, sample_count, max_value from gpu_metric_gpu_stats
+      where metric = 'power_w' order by gpu_index`;
+    expect(stats).toEqual([
+      { gpu_index: 0, metric: 'power_w', sample_count: 2, max_value: 912.1 },
+      { gpu_index: 1, metric: 'power_w', sample_count: 2, max_value: 905.3 },
+    ]);
+
+    const links = await sql<{ benchmark_result_id: number }[]>`
+      select benchmark_result_id from benchmark_result_gpu_metrics order by 1`;
+    expect(links.map((l) => Number(l.benchmark_result_id))).toEqual([10]);
+
+    const rerun = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 11],
+    });
+    expect(rerun.seriesIds).toEqual(first.seriesIds);
+    expect(rerun.samplesInserted).toBe(0);
+    expect(rerun.seriesSkipped).toBe(1);
+    const relinked = await sql<{ benchmark_result_id: number }[]>`
+      select benchmark_result_id from benchmark_result_gpu_metrics order by 1`;
+    expect(relinked.map((l) => Number(l.benchmark_result_id))).toEqual([10, 11]);
+    const [count] = await sql<{ n: number }[]>`select count(*)::int as n from gpu_metric_samples`;
+    expect(count!.n).toBe(4);
+  });
+
+  it('rolls back a replacement when point linking fails and retries without losing existing links', async () => {
+    const artifact = writeArtifact(NVIDIA_CSV);
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10],
+    });
+    const seriesId = first.seriesIds[0]!;
+    const before = await storedSeries(seriesId);
+    fs.writeFileSync(
+      path.join(artifact.artifactDir, 'gpu_metrics.csv'),
+      `${NVIDIA_CSV}\n2026/09/11 04:19:43.990, 0, 950.00 W, 65, 1965 MHz, 3996 MHz, 99 %, 75 %`,
+    );
+    fs.writeFileSync(
+      path.join(artifact.artifactDir, 'gpu_metrics_context.json'),
+      JSON.stringify({ timestamp_timezone: '+02:00' }),
+    );
+
+    // Point links are written last, after replacement metadata, samples and stats.
+    await expect(
+      ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact,
+        benchmarkResultIds: [11, 999],
+      }),
+    ).rejects.toMatchObject({ code: '23503' });
+    expect(await storedSeries(seriesId)).toEqual(before);
+
+    const recovered = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [11],
+    });
+    expect(recovered).toEqual({
+      metadataUpdatedBenchmarkResultIds: [],
+      seriesIds: [seriesId],
+      samplesInserted: 5,
+      seriesSkipped: 0,
+    });
+    const after = await storedSeries(seriesId);
+    expect(after.metadata).toMatchObject([
+      { sample_count: 5, sidecars: { context: { timestamp_timezone: '+02:00' } } },
+    ]);
+    expect(after.metadata[0]!.csv_sha256).not.toBe(before.metadata[0]!.csv_sha256);
+    expect(after.samples).toHaveLength(5);
+    expect(new Date(after.samples[0]!.sampled_at).toISOString()).toBe('2026-09-11T02:19:41.982Z');
+    expect(
+      after.stats.find((row) => row.gpu_index === 0 && row.metric === 'power_w'),
+    ).toMatchObject({
+      sample_count: 3,
+      max_value: 950,
+    });
+    expect(after.links.map((row) => Number(row.benchmark_result_id))).toEqual([10, 11]);
+  });
+});
+
+describe('versioned full-record digests', () => {
+  it('upgrades unchanged input without rewriting samples or links, then becomes a no-op', async () => {
+    const input = {
+      workflowRunId: 1,
+      artifact: writeArtifact(NVIDIA_CSV),
+      benchmarkResultIds: [10, 11],
+    };
+    const first = await ingestGpuMetricsArtifact(sql, input);
+    const id = first.seriesIds[0]!;
+    const original = await storedSeries(id);
+    await sql`update gpu_metric_series set stats_version = 0 where id = ${id}`;
+    await sql`update gpu_metric_gpu_stats set mean_value = -1 where series_id = ${id}`;
+    const updated = await ingestGpuMetricsArtifact(sql, input);
+    expect(updated).toMatchObject({ samplesInserted: 0, seriesSkipped: 0 });
+    expect(await storedSeries(id)).toEqual(original);
+    expect(await ingestGpuMetricsArtifact(sql, input)).toMatchObject({
+      samplesInserted: 0,
+      seriesSkipped: 1,
+    });
+  });
+
+  it('backfills both retained hosts without artifacts; preserves null metrics, links and unrelated series', async () => {
+    const artifact = writePowerAuditArtifact();
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 11],
+    });
+    const unrelated = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NVIDIA_CSV),
+      benchmarkResultIds: [10],
+    });
+    const untouched = await storedSeries(unrelated.seriesIds[0]!);
+    const originals = await Promise.all(first.seriesIds.map(storedSeries));
+    await sql`update gpu_metric_series set stats_version = 0 where id = any(${sql.array(first.seriesIds)}::bigint[])`;
+    await sql`update gpu_metric_gpu_stats set mean_value = -1 where series_id = any(${sql.array(first.seriesIds)}::bigint[])`;
+    fs.rmSync(artifact.artifactDir, { recursive: true });
+    // No default retention cutoff: old runs remain repairable.
+    await sql`update workflow_runs set date = '2020-01-01' where id = 1`;
+    const targets = await findOutdatedGpuMetricSeries(
+      sql,
+      { run: null, attempt: null, artifact: null, fromRun: null, since: null },
+      null,
+    );
+    expect(targets.map((row) => Number(row.id))).toEqual(first.seriesIds);
+    expect(
+      await findOutdatedGpuMetricSeries(
+        sql,
+        { run: 34557177019, attempt: 2, artifact: null, fromRun: null, since: null },
+        null,
+      ),
+    ).toEqual([]);
+    for (const [index, id] of first.seriesIds.entries()) {
+      expect(await refreshGpuMetricStats(sql, id)).toBe(true);
+      expect(await storedSeries(id)).toEqual(originals[index]);
+      expect(await refreshGpuMetricStats(sql, id)).toBe(false);
+    }
+    expect(await storedSeries(unrelated.seriesIds[0]!)).toEqual(untouched);
+  });
+
+  it('rolls back a failed digest replacement and permits retry; refuses incomplete samples', async () => {
+    const first = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NVIDIA_CSV),
+      benchmarkResultIds: [10],
+    });
+    const id = first.seriesIds[0]!;
+    await sql`update gpu_metric_series set stats_version = 0 where id = ${id}`;
+    await sql`update gpu_metric_gpu_stats set mean_value = -1 where series_id = ${id}`;
+    const before = await storedSeries(id);
+    await db.exec(
+      'ALTER TABLE gpu_metric_gpu_stats ADD CONSTRAINT reject_stats CHECK (mean_value < 0)',
+    );
+    await expect(refreshGpuMetricStats(sql, id)).rejects.toMatchObject({ code: '23514' });
+    expect(await storedSeries(id)).toEqual(before);
+    await db.exec('ALTER TABLE gpu_metric_gpu_stats DROP CONSTRAINT reject_stats');
+    expect(await refreshGpuMetricStats(sql, id)).toBe(true);
+    const recovered = await storedSeries(id);
+    expect(recovered.metadata[0]?.stats_version).toBe(GPU_STATS_VERSION);
+    await sql`update gpu_metric_series set stats_version = 0 where id = ${id}`;
+    await sql`delete from gpu_metric_samples where series_id = ${id} and gpu_index = 0`;
+    const incomplete = await storedSeries(id);
+    await expect(refreshGpuMetricStats(sql, id)).rejects.toThrow('missing samples');
+    expect(await storedSeries(id)).toEqual(incomplete);
+  });
+});
diff --git a/packages/db/src/etl/gpu-metrics-ingest.ts b/packages/db/src/etl/gpu-metrics-ingest.ts
new file mode 100644
index 000000000..a00fe9872
--- /dev/null
+++ b/packages/db/src/etl/gpu-metrics-ingest.ts
@@ -0,0 +1,451 @@
+/**
+ * Persist one gpu_metrics artifact: series metadata, full-resolution samples,
+ * the per-GPU statistics digest, and links to the benchmark points it covers.
+ *
+ * Idempotency: a series is identified by (workflow run, artifact name, CSV
+ * path). Re-ingesting an identical CSV, sidecars and sample count only refreshes
+ * the point links when the statistics version is current; a source change
+ * replaces samples and digest atomically.
+ */
+
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+
+import type postgres from 'postgres';
+
+import {
+  GPU_STATS_VERSION,
+  statMetricColumn,
+  computeStoredGpuMetricStats,
+  type StoredGpuMetricSample,
+} from '../lib/gpu-metric-stats.js';
+
+export { statMetricColumn } from '../lib/gpu-metric-stats.js';
+
+import type { Sql } from './db-utils.js';
+
+/** Either a pooled client or the transaction handle passed to `sql.begin` callbacks. */
+type TxLike = Sql | postgres.TransactionSql;
+import {
+  computeGpuMetricStats,
+  parseGpuMetricsCsv,
+  summarizeGpuMetricSamples,
+  type GpuMetricSample,
+  type GpuMetricStats,
+  type GpuMetricsVendor,
+} from './gpu-metrics-csv.js';
+import {
+  contextUtcOffsetMinutes,
+  gpuMetricsArtifactSuffix,
+  listGpuMetricsCsvFiles,
+  listMultinodePowerSampleFiles,
+  readGpuMetricsSidecars,
+  readMultinodePowerManifest,
+  readPowerAuditValidations,
+  type GpuMetricsArtifact,
+  type GpuMetricsSidecars,
+} from './gpu-metrics-artifacts.js';
+import { multinodePowerVendor, parseMultinodePowerSamples } from './multinode-power-samples.js';
+import { recoveredPowerAudit } from './power-audit-validations.js';
+
+/** Samples are streamed to Postgres in unnest batches of this many rows. */
+const SAMPLE_BATCH_SIZE = 5000;
+
+function uniqueSamples(samples: readonly GpuMetricSample[]): GpuMetricSample[] {
+  const seen = new Set<string>();
+  return samples.filter((sample) => {
+    const key = `${sample.gpuIndex}:${sample.timestampMs}`;
+    if (seen.has(key)) return false;
+    // Keep the first row, matching INSERT ... ON CONFLICT DO NOTHING.
+    seen.add(key);
+    return true;
+  });
+}
+
+export interface PreparedGpuMetricSeries {
+  fileName: string;
+  vendor: GpuMetricsVendor;
+  csvSha256: string;
+  samples: GpuMetricSample[];
+  stats: GpuMetricStats[];
+  sampleIntervalS: number | null;
+  gpuCount: number;
+  startedAtMs: number;
+  endedAtMs: number;
+  sidecars: GpuMetricsSidecars;
+}
+
+export interface GpuMetricsIngestResult {
+  seriesIds: number[];
+  samplesInserted: number;
+  seriesSkipped: number;
+  metadataUpdatedBenchmarkResultIds: number[];
+}
+
+/**
+ * One series per host from the multinode power bundle. The deployment-wide
+ * CSV is hashed once, so every host series of one upload shares its source sha.
+ * The `#<hostname>` fragment keeps the
+ * (run, artifact, file) identity unique per host.
+ */
+function prepareMultinodePowerSeries(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
+  const prepared: PreparedGpuMetricSeries[] = [];
+  const validations = readPowerAuditValidations(artifact.artifactDir, artifact.artifactName);
+  for (const file of listMultinodePowerSampleFiles(artifact.artifactDir)) {
+    const csvText = fs.readFileSync(file.path, 'utf8');
+    const hosts = parseMultinodePowerSamples(csvText);
+    if (!hosts) continue;
+    const manifest = readMultinodePowerManifest(file.path);
+    const vendor = multinodePowerVendor(manifest);
+    const csvSha256 = createHash('sha256').update(csvText).digest('hex');
+    for (const host of hosts) {
+      const samples = uniqueSamples(host.samples);
+      const summary = summarizeGpuMetricSamples(samples);
+      if (!summary) continue;
+      prepared.push({
+        fileName: `${file.fileName}#${host.hostname}`,
+        vendor,
+        csvSha256,
+        samples,
+        stats: computeGpuMetricStats(samples),
+        sampleIntervalS: summary.sampleIntervalS,
+        gpuCount: summary.gpuCount,
+        startedAtMs: summary.startedAtMs,
+        endedAtMs: summary.endedAtMs,
+        sidecars: {
+          context: manifest,
+          validations,
+          identity: Object.entries(host.gpuUuids).map(([index, uuid]) => ({
+            hostname: host.hostname,
+            gpu_index: Number(index),
+            gpu_uuid: uuid,
+          })),
+          energyStart: null,
+          energyEnd: null,
+        },
+      });
+    }
+  }
+  return prepared;
+}
+
+/**
+ * Parse every CSV in an extracted artifact; refuse a partly readable CSV set.
+ * Without usable nvidia-smi/amd-smi CSVs, fall back to the multinode power bundle.
+ */
+export function prepareGpuMetricsArtifact(artifact: GpuMetricsArtifact): PreparedGpuMetricSeries[] {
+  const prepared: PreparedGpuMetricSeries[] = [];
+  const unreadable: string[] = [];
+  for (const file of listGpuMetricsCsvFiles(artifact.artifactDir)) {
+    const csvText = fs.readFileSync(file.path, 'utf8');
+    const sidecars = readGpuMetricsSidecars(file.path);
+    if (artifact.artifactName.startsWith('power_audit_')) {
+      sidecars.validations = readPowerAuditValidations(artifact.artifactDir, artifact.artifactName);
+      const bundleFile = listMultinodePowerSampleFiles(artifact.artifactDir)[0];
+      sidecars.powerManifest = bundleFile ? readMultinodePowerManifest(bundleFile.path) : null;
+    }
+    const parsed = parseGpuMetricsCsv(csvText, {
+      nvidiaUtcOffsetMinutes: contextUtcOffsetMinutes(sidecars.context),
+    });
+    if (!parsed) {
+      unreadable.push(file.fileName);
+      continue;
+    }
+    const samples = uniqueSamples(parsed.samples);
+    const summary = summarizeGpuMetricSamples(samples);
+    if (!summary) {
+      unreadable.push(file.fileName);
+      continue;
+    }
+    prepared.push({
+      fileName: file.fileName,
+      vendor: parsed.vendor,
+      csvSha256: createHash('sha256').update(csvText).digest('hex'),
+      samples,
+      stats: computeGpuMetricStats(samples),
+      sampleIntervalS: summary.sampleIntervalS,
+      gpuCount: summary.gpuCount,
+      startedAtMs: summary.startedAtMs,
+      endedAtMs: summary.endedAtMs,
+      sidecars,
+    });
+  }
+  if (prepared.length > 0 && unreadable.length > 0) {
+    throw new Error(
+      `Incomplete telemetry artifact ${artifact.artifactName}: unreadable CSVs ${unreadable.join(', ')}`,
+    );
+  }
+  const series = prepared.length > 0 ? prepared : prepareMultinodePowerSeries(artifact);
+  const seriesInventory = series.map((entry) => ({
+    fileName: entry.fileName,
+    sampleCount: entry.samples.length,
+  }));
+  for (const entry of series) entry.sidecars.seriesInventory = seriesInventory;
+  return series;
+}
+
+async function insertSampleBatch(
+  tx: TxLike,
+  seriesId: number,
+  batch: readonly GpuMetricSample[],
+): Promise<number> {
+  const inserted = await tx<{ n: number }[]>`
+    with ins as (
+      insert into gpu_metric_samples (
+        series_id, gpu_index, sampled_at,
+        power_w, temperature_c, sm_clock_mhz, mem_clock_mhz, gpu_util_pct, mem_util_pct,
+        edge_temp_c, mem_temp_c, gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv,
+        fclk_mhz, socclk_mhz, mm_activity_pct
+      )
+      select
+        ${seriesId},
+        unnest(${tx.array(batch.map((s) => s.gpuIndex))}::smallint[]),
+        to_timestamp(unnest(${tx.array(batch.map((s) => s.timestampMs / 1000))}::double precision[])),
+        unnest(${tx.array(batch.map((s) => s.powerW))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.temperatureC))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.smClockMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memClockMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.gpuUtilPct))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memUtilPct))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.edgeTempC))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memTempC))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.gfxVoltageMv))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.socVoltageMv))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.memVoltageMv))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.fclkMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.socclkMhz))}::real[]),
+        unnest(${tx.array(batch.map((s) => s.mmActivityPct))}::real[])
+      -- nvidia-smi occasionally repeats the final sample when the monitor is
+      -- stopped and flushed; the primary key makes that a no-op.
+      on conflict (series_id, gpu_index, sampled_at) do nothing
+      returning 1
+    )
+    select count(*)::int as n from ins
+  `;
+  return Number(inserted[0]?.n ?? 0);
+}
+
+async function insertStats(
+  tx: TxLike,
+  seriesId: number,
+  stats: readonly GpuMetricStats[],
+): Promise<void> {
+  if (stats.length === 0) return;
+  await tx`
+    insert into gpu_metric_gpu_stats (
+      series_id, gpu_index, metric, sample_count,
+      min_value, max_value, mean_value, median_value, p95_value, p99_value, stddev_value
+    )
+    select
+      ${seriesId},
+      unnest(${tx.array(stats.map((s) => s.gpuIndex))}::smallint[]),
+      unnest(${tx.array(stats.map((s) => statMetricColumn(s.metric)))}::text[]),
+      unnest(${tx.array(stats.map((s) => s.count))}::int[]),
+      unnest(${tx.array(stats.map((s) => s.min))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.max))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.mean))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.median))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.p95))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.p99))}::real[]),
+      unnest(${tx.array(stats.map((s) => s.stddev))}::real[])
+  `;
+}
+
+/**
+ * Upsert one prepared series and link it to `benchmarkResultIds`. Returns the
+ * series id and how many sample rows were written (0 when the CSV, sidecars,
+ * and unique sample count are unchanged).
+ */
+export function upsertGpuMetricSeries(
+  sql: Sql,
+  input: {
+    workflowRunId: number;
+    artifactName: string;
+    series: PreparedGpuMetricSeries;
+    benchmarkResultIds: readonly number[];
+  },
+): Promise<{
+  seriesId: number;
+  samplesInserted: number;
+  replaced: boolean;
+  statsUpdated: boolean;
+}> {
+  const { workflowRunId, artifactName, series, benchmarkResultIds } = input;
+  const configKey = gpuMetricsArtifactSuffix(artifactName) ?? artifactName;
+  const sidecarsJson = JSON.stringify(series.sidecars);
+
+  return sql.begin(async (tx) => {
+    const existing = await tx<
+      {
+        id: number;
+        csv_sha256: string;
+        sample_count: number;
+        stats_version: number;
+        sidecars_match: boolean;
+      }[]
+    >`
+      select id, csv_sha256, sample_count, stats_version, sidecars = ${sidecarsJson}::jsonb as sidecars_match
+      from gpu_metric_series
+      where workflow_run_id = ${workflowRunId}
+        and artifact_name = ${artifactName}
+        and file_name = ${series.fileName}
+      for update
+    `;
+
+    let seriesId: number;
+    let needsSamples = true;
+    let replaced = false;
+    if (existing.length > 0) {
+      seriesId = Number(existing[0]!.id);
+      // Count also detects legacy digests computed before duplicate removal.
+      if (
+        existing[0]!.csv_sha256 === series.csvSha256 &&
+        existing[0]!.sidecars_match &&
+        existing[0]!.sample_count === series.samples.length
+      ) {
+        needsSamples = false;
+      } else {
+        replaced = true;
+        await tx`delete from gpu_metric_samples where series_id = ${seriesId}`;
+        await tx`delete from gpu_metric_gpu_stats where series_id = ${seriesId}`;
+        await tx`
+          update gpu_metric_series set
+            vendor = ${series.vendor},
+            csv_sha256 = ${series.csvSha256},
+            sample_interval_s = ${series.sampleIntervalS},
+            sample_count = ${series.samples.length},
+            gpu_count = ${series.gpuCount},
+            started_at = to_timestamp(${series.startedAtMs / 1000}::double precision),
+            ended_at = to_timestamp(${series.endedAtMs / 1000}::double precision),
+            sidecars = ${sidecarsJson}::jsonb,
+            ingested_at = now()
+          where id = ${seriesId}
+        `;
+      }
+    } else {
+      const [row] = await tx<{ id: number }[]>`
+        insert into gpu_metric_series (
+          workflow_run_id, artifact_name, config_key, file_name, vendor, csv_sha256,
+          sample_interval_s, sample_count, gpu_count, started_at, ended_at, sidecars
+        ) values (
+          ${workflowRunId}, ${artifactName}, ${configKey}, ${series.fileName},
+          ${series.vendor}, ${series.csvSha256}, ${series.sampleIntervalS},
+          ${series.samples.length}, ${series.gpuCount},
+          to_timestamp(${series.startedAtMs / 1000}::double precision),
+          to_timestamp(${series.endedAtMs / 1000}::double precision),
+          ${sidecarsJson}::jsonb
+        )
+        returning id
+      `;
+      seriesId = Number(row!.id);
+    }
+
+    let samplesInserted = 0;
+    if (needsSamples) {
+      for (let offset = 0; offset < series.samples.length; offset += SAMPLE_BATCH_SIZE) {
+        samplesInserted += await insertSampleBatch(
+          tx,
+          seriesId,
+          series.samples.slice(offset, offset + SAMPLE_BATCH_SIZE),
+        );
+      }
+    }
+    const statsUpdated = needsSamples || existing[0]?.stats_version !== GPU_STATS_VERSION;
+    if (statsUpdated) {
+      if (!needsSamples) await tx`delete from gpu_metric_gpu_stats where series_id = ${seriesId}`;
+      await insertStats(tx, seriesId, series.stats);
+      await tx`update gpu_metric_series set stats_version = ${GPU_STATS_VERSION} where id = ${seriesId}`;
+    }
+
+    if (benchmarkResultIds.length > 0) {
+      await tx`
+        insert into benchmark_result_gpu_metrics (benchmark_result_id, series_id)
+        select unnest(${tx.array([...new Set(benchmarkResultIds)])}::bigint[]), ${seriesId}
+        on conflict do nothing
+      `;
+    }
+
+    return { seriesId, samplesInserted, replaced, statsUpdated };
+  });
+}
+
+export function refreshGpuMetricStats(sql: Sql, seriesId: number): Promise<boolean> {
+  return sql.begin(async (tx) => {
+    const [series] = await tx<{ sample_count: number; stats_version: number }[]>`
+      select sample_count, stats_version from gpu_metric_series where id = ${seriesId} for update
+    `;
+    if (!series) throw new Error(`Unknown telemetry series ${seriesId}`);
+    if (series.stats_version === GPU_STATS_VERSION) return false;
+    const samples = await tx<StoredGpuMetricSample[]>`
+      select * from gpu_metric_samples where series_id = ${seriesId} order by sampled_at, gpu_index
+    `;
+    if (samples.length !== Number(series.sample_count)) {
+      throw new Error(
+        `Telemetry series ${seriesId} has missing samples; re-ingest its source artifact`,
+      );
+    }
+    const stats = computeStoredGpuMetricStats(samples);
+    await tx`delete from gpu_metric_gpu_stats where series_id = ${seriesId}`;
+    await insertStats(tx, seriesId, stats);
+    await tx`update gpu_metric_series set stats_version = ${GPU_STATS_VERSION} where id = ${seriesId}`;
+    return true;
+  });
+}
+
+/** Read, digest, and persist every CSV of one artifact for one set of points. */
+export async function ingestGpuMetricsArtifact(
+  sql: Sql,
+  input: {
+    workflowRunId: number;
+    artifact: GpuMetricsArtifact;
+    benchmarkResultIds: readonly number[];
+  },
+): Promise<GpuMetricsIngestResult> {
+  const prepared = prepareGpuMetricsArtifact(input.artifact);
+  const result: GpuMetricsIngestResult = {
+    seriesIds: [],
+    samplesInserted: 0,
+    seriesSkipped: 0,
+    metadataUpdatedBenchmarkResultIds: [],
+  };
+  for (const series of prepared) {
+    const upserted = await upsertGpuMetricSeries(sql, {
+      workflowRunId: input.workflowRunId,
+      artifactName: input.artifact.artifactName,
+      series,
+      benchmarkResultIds: input.benchmarkResultIds,
+    });
+    result.seriesIds.push(upserted.seriesId);
+    result.samplesInserted += upserted.samplesInserted;
+    if (upserted.samplesInserted === 0 && !upserted.replaced && !upserted.statsUpdated)
+      result.seriesSkipped++;
+  }
+  // The caller has resolved this artifact's exact benchmark identities. Recover
+  // only a unique AgentX point within that explicit set, after every host is
+  // stored/linked. This also repairs metadata when all samples were a no-op.
+  const validations = prepared[0]?.sidecars.validations ?? {};
+  const audits = Object.entries(validations)
+    .map(([source, validation]) => ({
+      audit: recoveredPowerAudit(source, validation),
+      conc: (validation.selected_window as Record<string, unknown> | undefined)?.concurrency,
+    }))
+    .filter((entry) => entry.audit !== null);
+  for (const { audit, conc } of audits) {
+    if (typeof conc !== 'number' || !Number.isSafeInteger(conc) || conc <= 0) continue;
+    if (audits.filter((entry) => entry.conc === conc).length !== 1) continue;
+    const updated = await sql<{ id: number }[]>`
+      with candidates as (
+        select id from benchmark_results
+        where workflow_run_id = ${input.workflowRunId}
+          and id = any(${sql.array([...new Set(input.benchmarkResultIds)])}::bigint[])
+          and benchmark_type = 'agentic_traces' and conc = ${conc}
+      )
+      update benchmark_results set power_audit = ${sql.json(audit)}::jsonb
+      where id in (select id from candidates)
+        and (select count(*) from candidates) = 1 and power_audit is null
+      returning id
+    `;
+    result.metadataUpdatedBenchmarkResultIds.push(...updated.map((row) => Number(row.id)));
+  }
+  return result;
+}
diff --git a/packages/db/src/etl/ingest-summary.ts b/packages/db/src/etl/ingest-summary.ts
index 16806cc47..684d7a1f5 100644
--- a/packages/db/src/etl/ingest-summary.ts
+++ b/packages/db/src/etl/ingest-summary.ts
@@ -38,6 +38,7 @@ export function printIngestSummaryFooter(
     ['unmapped hw', skips.unmappedHw],
     ['bad/empty zip', skips.badZip],
     ['DB errors', skips.dbError],
+    ['telemetry errors (non-fatal)', skips.telemetryError],
   );
 
   const nonzeroSkipLines = skipLines.filter(([, count]) => count > 0);
diff --git a/packages/db/src/etl/multinode-power-samples.ts b/packages/db/src/etl/multinode-power-samples.ts
new file mode 100644
index 000000000..9c711c4de
--- /dev/null
+++ b/packages/db/src/etl/multinode-power-samples.ts
@@ -0,0 +1,114 @@
+/**
+ * Parser for the multinode power producer's `LOGS/power/samples.csv`.
+ *
+ * `benchmark-multinode-tmpl.yml` uploads no `gpu_metrics_` artifact; its
+ * telemetry travels inside `power_audit_<suffix>` as one CSV for the whole
+ * deployment, written by `srt-slurm.dcgm-power` (DCGM scraped on every host
+ * once per second):
+ *
+ *   schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w
+ *
+ * Only power is scraped, so every other `GpuMetricSample` field stays null and
+ * the digest carries `powerW` alone. Rows are regrouped per host so each host
+ * becomes its own series, the shape the reader already uses for multinode
+ * staging ("one CSV per node"). Pure module: no I/O.
+ */
+
+import { splitCsvLine, type GpuMetricSample, type GpuMetricsVendor } from './gpu-metrics-csv.js';
+
+export interface MultinodePowerHost {
+  hostname: string;
+  /** Host-local GPU indices, as DCGM reports them. */
+  samples: GpuMetricSample[];
+  /** gpu_index → gpu_uuid for the identity sidecar. */
+  gpuUuids: Record<number, string>;
+}
+
+const REQUIRED_COLUMNS = ['timestamp_unix', 'hostname', 'gpu_index', 'power_w'] as const;
+
+/** `samples.csv` under `LOGS/` is the producer's only time-series file. */
+export function isMultinodePowerSamplesPath(relativePath: string): boolean {
+  const posix = relativePath.split('\\').join('/');
+  return /^LOGS\/(?:[^/]+\/)*samples\.csv$/u.test(posix);
+}
+
+function powerOnlySample(timestampMs: number, gpuIndex: number, powerW: number): GpuMetricSample {
+  return {
+    timestampMs,
+    gpuIndex,
+    powerW,
+    temperatureC: null,
+    smClockMhz: null,
+    memClockMhz: null,
+    gpuUtilPct: null,
+    memUtilPct: null,
+    edgeTempC: null,
+    memTempC: null,
+    gfxVoltageMv: null,
+    socVoltageMv: null,
+    memVoltageMv: null,
+    fclkMhz: null,
+    socclkMhz: null,
+    mmActivityPct: null,
+  };
+}
+
+/**
+ * Group the deployment-wide CSV by host. Returns null when the header is not
+ * the multinode power schema; malformed rows are skipped. Hosts sort by name
+ * so series order is stable across re-ingests.
+ */
+export function parseMultinodePowerSamples(csvText: string): MultinodePowerHost[] | null {
+  const lines = csvText
+    .split('\n')
+    .map((line) => line.replace(/\r$/u, ''))
+    .filter((line) => line.trim().length > 0);
+  if (lines.length <= 1) return null;
+  const header = splitCsvLine(lines[0]!).map((cell) => cell.trim().toLowerCase());
+  const column = new Map(header.map((name, index) => [name, index] as const));
+  if (REQUIRED_COLUMNS.some((name) => !column.has(name))) return null;
+  const at = (cells: string[], name: string): string | undefined => cells[column.get(name)!];
+
+  const hosts = new Map<string, MultinodePowerHost>();
+  for (const line of lines.slice(1)) {
+    const cells = splitCsvLine(line).map((cell) => cell.trim());
+    const hostname = at(cells, 'hostname');
+    const seconds = Number.parseFloat(at(cells, 'timestamp_unix') ?? '');
+    const gpuIndex = Number.parseInt(at(cells, 'gpu_index') ?? '', 10);
+    const powerW = Number.parseFloat(at(cells, 'power_w') ?? '');
+    if (
+      !hostname ||
+      !Number.isFinite(seconds) ||
+      !Number.isSafeInteger(gpuIndex) ||
+      gpuIndex < 0 ||
+      !Number.isFinite(powerW)
+    ) {
+      continue;
+    }
+    let host = hosts.get(hostname);
+    if (!host) {
+      host = { hostname, samples: [], gpuUuids: {} };
+      hosts.set(hostname, host);
+    }
+    host.samples.push(powerOnlySample(Math.round(seconds * 1000), gpuIndex, powerW));
+    const uuid = at(cells, 'gpu_uuid');
+    if (uuid && !(gpuIndex in host.gpuUuids)) host.gpuUuids[gpuIndex] = uuid;
+  }
+  if (hosts.size === 0) return null;
+  return [...hosts.values()].toSorted((a, b) => a.hostname.localeCompare(b.hostname));
+}
+
+/**
+ * The producer manifest names its source metric; DCGM means NVIDIA. Anything
+ * naming AMD tooling maps to 'amd', and an absent manifest defaults to NVIDIA
+ * because only the DCGM producer writes this layout today.
+ */
+export function multinodePowerVendor(manifest: Record<string, unknown> | null): GpuMetricsVendor {
+  const source = [manifest?.source_metric, manifest?.producer]
+    .filter((value): value is string => typeof value === 'string')
+    .join(' ')
+    .toLowerCase();
+  // `amd-smi`, `rocm_smi`: the tool name may continue with `-` or `_`.
+  if (/\b(?:amd|rocm)/u.test(source)) return 'amd';
+  return 'nvidia';
+}
diff --git a/packages/db/src/etl/power-audit-recovery.test.ts b/packages/db/src/etl/power-audit-recovery.test.ts
new file mode 100644
index 000000000..f90d1a0ae
--- /dev/null
+++ b/packages/db/src/etl/power-audit-recovery.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+
+import type { BenchmarkPersistenceInput } from './benchmark-ingest.js';
+import { createBenchmarkPowerAuditRecovery } from './power-audit-recovery.js';
+
+const resultFile = 'kimik3_recipe-a_conc48.json';
+const source = `power_validation_${resultFile}`;
+const validation = {
+  power_valid: true,
+  validation_path: 'LOGS/agentic/conc_48/power_validation.json',
+  result_file: resultFile,
+  selected_window: {
+    concurrency: 48,
+    start_time_unix: 1000,
+    end_time_unix: 1100,
+    result_path: 'agentic/conc_48/agentic_power_concurrency_48.json',
+    window_file: 'windows/agentic_power_concurrency_48.json',
+  },
+};
+const evidence = { resultFile, validations: { [source]: validation } };
+const expectedAudit = { source, window_start_unix: 1000, window_end_unix: 1100 };
+
+function point(overrides: Partial<BenchmarkPersistenceInput> = {}): BenchmarkPersistenceInput {
+  return {
+    configId: 1,
+    benchmarkType: 'agentic_traces',
+    isl: null,
+    osl: null,
+    conc: 48,
+    offloadMode: 'on',
+    image: 'image',
+    recipeFingerprint: 'recipe-a',
+    metrics: { power_valid: 1, avg_power_w: 234.5, mean_ttft: 0.2 },
+    workers: [{ role: 'agg', worker_idx: 0, num_gpus: 8, avg_power_w: 234.5 }],
+    ...overrides,
+  };
+}
+
+describe('CI benchmark audit recovery', () => {
+  it('retains exact provenance with aggregate after sibling and preserves benchmark values', () => {
+    const recover = createBenchmarkPowerAuditRecovery();
+    const original = point();
+    let latest = original;
+    for (const isPaired of [true, false]) {
+      latest = recover(original, isPaired ? evidence : undefined);
+      expect(latest.metrics).toBe(original.metrics);
+      expect(latest.workers).toBe(original.workers);
+      expect({ ...latest, powerAudit: undefined }).toEqual({ ...original, powerAudit: undefined });
+    }
+    expect(latest.powerAudit).toEqual(expectedAudit);
+    expect(original.powerAudit).toBeUndefined();
+  });
+
+  it('does not reuse the same run/concurrency audit for a point with another offload mode', () => {
+    const recover = createBenchmarkPowerAuditRecovery();
+    recover(point(), evidence);
+    const other = point({ offloadMode: 'off' });
+    expect(recover(other)).toBe(other);
+    expect(other.powerAudit).toBeUndefined();
+  });
+});
diff --git a/packages/db/src/etl/power-audit-recovery.ts b/packages/db/src/etl/power-audit-recovery.ts
new file mode 100644
index 000000000..808be3ef7
--- /dev/null
+++ b/packages/db/src/etl/power-audit-recovery.ts
@@ -0,0 +1,42 @@
+import { benchmarkPointIngestKey, type BenchmarkPersistenceInput } from './benchmark-ingest.js';
+import type { PowerAudit } from './benchmark-mapper.js';
+import { recoveredPowerAudit } from './power-audit-validations.js';
+
+export interface BenchmarkPowerAuditEvidence {
+  resultFile: string;
+  validations: Record<string, Record<string, unknown>>;
+}
+
+/** One run's exact sibling evidence also applies to its later aggregate copies. */
+export function createBenchmarkPowerAuditRecovery() {
+  const recovered = new Map<string, PowerAudit>();
+  return <T extends BenchmarkPersistenceInput>(
+    row: T,
+    evidence?: BenchmarkPowerAuditEvidence,
+  ): T => {
+    if (row.benchmarkType !== 'agentic_traces' || row.powerAudit !== undefined) return row;
+    const key = benchmarkPointIngestKey(row);
+    if (evidence) {
+      const matches = Object.entries(evidence.validations).filter(([, validation]) => {
+        const window = validation.selected_window;
+        if (
+          validation.result_file !== evidence.resultFile ||
+          !window ||
+          typeof window !== 'object' ||
+          Array.isArray(window) ||
+          !('concurrency' in window) ||
+          window.concurrency !== row.conc
+        )
+          return false;
+        return true;
+      });
+      // Ambiguous/missing evidence must not establish new provenance.
+      if (matches.length !== 1) return row;
+      const audit = recoveredPowerAudit(...matches[0]);
+      if (!audit) return row;
+      recovered.set(key, audit);
+    }
+    const audit = recovered.get(key);
+    return audit ? { ...row, powerAudit: audit } : row;
+  };
+}
diff --git a/packages/db/src/etl/power-audit-validations.test.ts b/packages/db/src/etl/power-audit-validations.test.ts
new file mode 100644
index 000000000..426073200
--- /dev/null
+++ b/packages/db/src/etl/power-audit-validations.test.ts
@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+
+import { normalizePowerAuditValidations } from './power-audit-validations.js';
+
+const ARTIFACT = 'power_audit_kimik3_agentx_fp4';
+const RESULT = 'kimik3_agentx_fp4_conc48.json';
+const SOURCE = 'power_validation_kimik3_agentx_fp4_conc48.json';
+const VALIDATION = 'LOGS/agentic/conc_48/power_validation.json';
+const WINDOW = 'LOGS/power/windows/agentic_power_concurrency_48.json';
+const RESULT_PATH = 'agentic/conc_48/agentic_power_concurrency_48.json';
+const START = 1789940129.369988;
+const END = 1789943769.371839;
+
+function fixture() {
+  const selected: Record<string, unknown> = {
+    window_file: 'windows/agentic_power_concurrency_48.json',
+    result_path: RESULT_PATH,
+    benchmark_type: 'custom',
+    concurrency: 48,
+    start_time_unix: START,
+    end_time_unix: END,
+    duration: END - START,
+  };
+  const validation: Record<string, unknown> = {
+    power_valid: true,
+    selected_window: selected,
+    per_gpu_role: { 'host-a/GPU-a': 'prefill', 'host-b/GPU-b': 'decode' },
+    validation_errors: [],
+  };
+  const result: Record<string, unknown> = { conc: 48, power_valid: 1 };
+  const window: Record<string, unknown> = {
+    schema_version: 1,
+    concurrency: 48,
+    result_path: RESULT_PATH,
+    benchmark_start_time_unix: START,
+    benchmark_end_time_unix: END,
+    status: 'completed',
+  };
+  const files = () =>
+    new Map([
+      [VALIDATION, JSON.stringify(validation)],
+      [RESULT, JSON.stringify(result)],
+      [WINDOW, JSON.stringify(window)],
+    ]);
+  return { selected, validation, result, window, files };
+}
+
+describe('normalizePowerAuditValidations', () => {
+  it('aliases an exactly matched nested document without changing its window, roles or verdict', () => {
+    const input = fixture();
+    const files = input.files();
+    const retained = [...files];
+    expect(normalizePowerAuditValidations(ARTIFACT, files)).toEqual(
+      new Map([
+        [SOURCE, { ...input.validation, validation_path: VALIDATION, result_file: RESULT }],
+      ]),
+    );
+    expect([...files]).toEqual(retained);
+    expect(input.validation).not.toHaveProperty('validation_path');
+  });
+
+  it('rejects mismatched window.benchmark_start_time_unix', () => {
+    const input = fixture();
+    input.window.benchmark_start_time_unix = START + 1;
+    expect(normalizePowerAuditValidations(ARTIFACT, input.files()).size).toBe(0);
+  });
+});
diff --git a/packages/db/src/etl/power-audit-validations.ts b/packages/db/src/etl/power-audit-validations.ts
new file mode 100644
index 000000000..179c2abf1
--- /dev/null
+++ b/packages/db/src/etl/power-audit-validations.ts
@@ -0,0 +1,125 @@
+/** Pure normalization of legacy and retained AgentX power-audit documents. */
+const LEGACY_VALIDATION = /^power_validation_[^/]+\.json$/u;
+const AGENTX_VALIDATION = /^LOGS\/agentic\/conc_(?<concurrency>[1-9]\d*)\/power_validation\.json$/u;
+const AGENTX_WINDOW = /^LOGS\/power\/windows\/agentic_power_concurrency_[1-9]\d*\.json$/u;
+const RESULT_FILE = /^(?<stem>[^/]+)_conc(?<concurrency>[1-9]\d*)\.json$/u;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function parseObject(text: string | undefined): Record<string, unknown> | null {
+  if (text === undefined) return null;
+  try {
+    const value: unknown = JSON.parse(text);
+    return isRecord(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function hasWindowTimes(value: unknown): value is Record<string, unknown> & {
+  start_time_unix: number;
+  end_time_unix: number;
+} {
+  return (
+    isRecord(value) &&
+    typeof value.start_time_unix === 'number' &&
+    Number.isFinite(value.start_time_unix) &&
+    value.start_time_unix > 0 &&
+    typeof value.end_time_unix === 'number' &&
+    Number.isFinite(value.end_time_unix) &&
+    value.end_time_unix > value.start_time_unix
+  );
+}
+
+/** Only documents needed to identify a validation and its recorded result/window. */
+export function isPowerAuditValidationEntry(name: string): boolean {
+  return (
+    LEGACY_VALIDATION.test(name) ||
+    AGENTX_VALIDATION.test(name) ||
+    AGENTX_WINDOW.test(name) ||
+    RESULT_FILE.test(name)
+  );
+}
+
+/**
+ * Legacy top-level documents keep their names and contents. A nested AgentX
+ * document gains a canonical alias only when its result and retained window
+ * agree; path annotations retain the original document's provenance.
+ */
+export function normalizePowerAuditValidations(
+  artifactName: string,
+  files: ReadonlyMap<string, string>,
+): Map<string, Record<string, unknown>> {
+  const validations = new Map<string, Record<string, unknown>>();
+  for (const [name, text] of files) {
+    if (!LEGACY_VALIDATION.test(name)) continue;
+    const validation = parseObject(text);
+    if (validation) validations.set(name, validation);
+  }
+  const artifactStem = /^power_audit_(?<stem>[^/]+)$/u.exec(artifactName)?.groups?.stem;
+  if (!artifactStem) return validations;
+
+  for (const [validationPath, text] of files) {
+    const match = AGENTX_VALIDATION.exec(validationPath);
+    if (!match?.groups) continue;
+    const concurrency = Number(match.groups.concurrency);
+    if (!Number.isSafeInteger(concurrency)) continue;
+    const resultFile = `${artifactStem}_conc${concurrency}.json`;
+    const source = `power_validation_${resultFile.slice(0, -5)}.json`;
+    if (validations.has(source)) continue;
+    const validation = parseObject(text);
+    const result = parseObject(files.get(resultFile));
+    const selected = validation?.selected_window;
+    const resultPath = `agentic/conc_${concurrency}/agentic_power_concurrency_${concurrency}.json`;
+    const windowFile = `windows/agentic_power_concurrency_${concurrency}.json`;
+    const window = parseObject(files.get(`LOGS/power/${windowFile}`));
+    if (
+      !validation ||
+      result?.conc !== concurrency ||
+      !hasWindowTimes(selected) ||
+      selected.concurrency !== concurrency ||
+      selected.result_path !== resultPath ||
+      selected.window_file !== windowFile ||
+      window?.concurrency !== concurrency ||
+      window.result_path !== resultPath ||
+      window.benchmark_start_time_unix !== selected.start_time_unix ||
+      window.benchmark_end_time_unix !== selected.end_time_unix
+    )
+      continue;
+    validations.set(source, {
+      ...validation,
+      validation_path: validationPath,
+      result_file: resultFile,
+    });
+  }
+  return validations;
+}
+
+/** Recover source/window metadata only from a normalized nested validation. */
+export function recoveredPowerAudit(
+  source: string,
+  validation: Record<string, unknown>,
+): { source: string; window_start_unix: number; window_end_unix: number } | null {
+  const path = validation.validation_path;
+  const result = validation.result_file;
+  if (typeof path !== 'string' || typeof result !== 'string') return null;
+  const nested = AGENTX_VALIDATION.exec(path)?.groups;
+  const file = RESULT_FILE.exec(result)?.groups;
+  const selected = validation.selected_window;
+  if (
+    !nested ||
+    !file ||
+    nested.concurrency !== file.concurrency ||
+    source !== `power_validation_${result.slice(0, -5)}.json` ||
+    !hasWindowTimes(selected) ||
+    selected.concurrency !== Number(nested.concurrency)
+  )
+    return null;
+  return {
+    source,
+    window_start_unix: selected.start_time_unix,
+    window_end_unix: selected.end_time_unix,
+  };
+}
diff --git a/packages/db/src/etl/skip-tracker.test.ts b/packages/db/src/etl/skip-tracker.test.ts
index e407db3a3..1851b0417 100644
--- a/packages/db/src/etl/skip-tracker.test.ts
+++ b/packages/db/src/etl/skip-tracker.test.ts
@@ -9,6 +9,7 @@ describe('createSkipTracker', () => {
     expect(tracker.skips.unmappedHw).toBe(0);
     expect(tracker.skips.noIslOsl).toBe(0);
     expect(tracker.skips.dbError).toBe(0);
+    expect(tracker.skips.telemetryError).toBe(0);
     expect(tracker.skips.traceReplayMissing).toBe(0);
   });
 
diff --git a/packages/db/src/etl/skip-tracker.ts b/packages/db/src/etl/skip-tracker.ts
index 5d485bf22..055a92b46 100644
--- a/packages/db/src/etl/skip-tracker.ts
+++ b/packages/db/src/etl/skip-tracker.ts
@@ -10,6 +10,15 @@ export interface Skips {
   noIslOsl: number;
   failedRun: number;
   dbError: number;
+  /**
+   * PowerX telemetry digest failures, counted apart from `dbError` because they
+   * are not fatal. The benchmark rows land either way; only the per-point
+   * telemetry tab is affected, and the artifact can be re-digested later by
+   * `admin:db:backfill-gpu-metrics`. Folding these into `dbError` would let one
+   * malformed `gpu_metrics_*` CSV turn the whole production ingest red, through
+   * the publication manifest that verify-power-publication treats as fatal.
+   */
+  telemetryError: number;
   /** Agentic point whose sibling `agentic_<suffix>` artifact had no trace_replay files. */
   traceReplayMissing: number;
 }
@@ -35,6 +44,15 @@ export interface SkipTracker {
    * @param err - The caught error.
    */
   recordDbError: (context: string, err: Error) => void;
+  /**
+   * Record a non-fatal PowerX telemetry digest failure. Same printing and
+   * suppression as `recordDbError`, but increments `skips.telemetryError` so the
+   * ingest is not failed by it.
+   *
+   * @param context - Human-readable label for where the error occurred.
+   * @param err - The caught error.
+   */
+  recordTelemetryError: (context: string, err: Error) => void;
   /**
    * Capture a point-in-time snapshot of the current skip counters and
    * unmapped-name sets. Used together with `diff()` to report per-artifact drops.
@@ -76,12 +94,14 @@ export function createSkipTracker(): SkipTracker {
     noIslOsl: 0,
     failedRun: 0,
     dbError: 0,
+    telemetryError: 0,
     traceReplayMissing: 0,
   };
   const unmappedModels = new Set<string>();
   const unmappedHws = new Set<string>();
   const unmappedPrecisions = new Set<string>();
   let dbErrorsPrinted = 0;
+  let telemetryErrorsPrinted = 0;
 
   return {
     skips,
@@ -100,6 +120,19 @@ export function createSkipTracker(): SkipTracker {
       }
     },
 
+    recordTelemetryError(context: string, err: Error): void {
+      skips.telemetryError++;
+      if (telemetryErrorsPrinted < MAX_DB_ERRORS) {
+        console.error(`  [TELEMETRY] ${context}: ${err.message}`);
+        telemetryErrorsPrinted++;
+        if (telemetryErrorsPrinted === MAX_DB_ERRORS) {
+          console.error(
+            '  [TELEMETRY] further telemetry errors suppressed; count included in summary',
+          );
+        }
+      }
+    },
+
     snapshot(): SkipSnapshot {
       return {
         model: skips.unmappedModel,
diff --git a/packages/db/src/ingest-ci-run.test.ts b/packages/db/src/ingest-ci-run.test.ts
index d3ad330b4..520028343 100644
--- a/packages/db/src/ingest-ci-run.test.ts
+++ b/packages/db/src/ingest-ci-run.test.ts
@@ -5,6 +5,47 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { describe, expect, it } from 'vitest';
 
+describe('explicit download attempt identity', () => {
+  it('rejects a download whose GitHub attempt differs from the requested one', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'attempt-ingest-'));
+    const manifestPath = path.join(dir, 'power-publication.json');
+    try {
+      fs.writeFileSync(
+        path.join(dir, 'gh'),
+        '#!/bin/sh\ncase "$*" in\n*--paginate*) exit 0 ;;\n*--jq*) printf "2\\n" ;;\n*) exit 3 ;;\nesac\n',
+        { mode: 0o755 },
+      );
+      const result = spawnSync(
+        'bun',
+        [
+          fileURLToPath(new URL('ingest-ci-run.ts', import.meta.url)),
+          '--download',
+          'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/25199291771/attempts/1',
+        ],
+        {
+          cwd: dir,
+          env: {
+            PATH: `${dir}${path.delimiter}${process.env.PATH}`,
+            TMPDIR: dir,
+            NODE_ENV: 'test',
+            DATABASE_WRITE_URL: 'postgres://unused:unused@127.0.0.1:1/unused',
+            GITHUB_TOKEN: 'unused',
+            POWER_PUBLICATION_MANIFEST: manifestPath,
+          },
+          encoding: 'utf8',
+          timeout: 10_000,
+        },
+      );
+      expect(result.error).toBeUndefined();
+      expect(result.status, result.stderr).toBe(1);
+      expect(result.stderr).toContain('GitHub attempt 2 differs from requested 1');
+      expect(fs.existsSync(manifestPath)).toBe(false);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
 describe('purged CI ingestion', () => {
   it.each([
     { runId: 20286769842, runAttempt: 1, reused: false },
@@ -53,6 +94,7 @@ describe('purged CI ingestion', () => {
           runAttempt,
           points: [],
           ingestErrors: [],
+          telemetryWarnings: [],
         });
       } finally {
         fs.rmSync(dir, { recursive: true, force: true });
diff --git a/packages/db/src/ingest-ci-run.ts b/packages/db/src/ingest-ci-run.ts
index a27225bc9..351233bf9 100644
--- a/packages/db/src/ingest-ci-run.ts
+++ b/packages/db/src/ingest-ci-run.ts
@@ -27,6 +27,8 @@ import { createHash } from 'node:crypto';
 import {
   powerPublicationPoint,
   publicationIdentity,
+  benchmarkPublicationIdentity,
+  stablePowerPointIdentity,
   type PowerPublicationPoint,
 } from './etl/power-publication';
 import os from 'os';
@@ -60,6 +62,7 @@ import {
   readReusedIngestMetadata,
 } from './etl/reused-ingest-metadata';
 import { mapBenchmarkRow, type BenchmarkParams } from './etl/benchmark-mapper';
+import { preflightRequiredPowerCurves } from './etl/required-power-curve';
 import {
   assertRequiredPowerPointsRetained,
   verifyRequiredPowerArtifacts,
@@ -78,6 +81,13 @@ import {
 import { AsyncSemaphore } from './etl/async-semaphore';
 import { discoverTraceReplayArtifacts } from './etl/trace-artifact-discovery';
 import { discoverServerLogArtifacts, readServerLogArtifact } from './etl/server-log-artifacts';
+import {
+  discoverGpuMetricsArtifacts,
+  readPowerAuditValidations,
+} from './etl/gpu-metrics-artifacts';
+import { createBenchmarkPowerAuditRecovery } from './etl/power-audit-recovery';
+import { ingestGpuMetricsArtifact } from './etl/gpu-metrics-ingest';
+import { readTelemetryReceipt, type TelemetryObservation } from './etl/telemetry-receipt';
 import { datasetSlugFromBenchmarkRow } from './etl/dataset-provenance';
 import { mapAggEvalRow, mapEvalRow } from './etl/eval-mapper';
 import { ingestEvalRow } from './etl/eval-ingest';
@@ -96,6 +106,9 @@ import {
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 const powerPublicationPoints = new Map<string, PowerPublicationPoint>();
 const powerPublicationErrors: string[] = [];
+const telemetryObservations = new Map<string, TelemetryObservation>();
+let telemetryExpectationsUnknown = false;
+let checkTelemetry = false;
 const tracker = createSkipTracker();
 const isDownloadMode = process.argv[2] === '--download';
 
@@ -151,6 +164,15 @@ if (isDownloadMode) {
     input.match(/^https:\/\/github\.com\/(?<repo>[^/]+\/[^/]+)\/actions\/runs\/\d+/u)?.[1] ??
     DEFAULT_REPO;
 
+  runAttemptNum = fetchRunAttempt(REPO, runIdStr);
+  const requestedAttempt = input.match(/\/attempts\/(?<attempt>\d+)/u)?.groups?.attempt;
+  if (requestedAttempt && Number(requestedAttempt) !== runAttemptNum) {
+    throw new Error(
+      `GitHub attempt ${runAttemptNum} differs from requested ${requestedAttempt}; ` +
+        'use retained artifacts and exact source metadata for historical-attempt ingestion',
+    );
+  }
+
   // Download artifacts
   tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ingest-'));
   artifactsDir = tempDir;
@@ -194,8 +216,6 @@ if (isDownloadMode) {
   }
 
   console.log(`\n  Downloaded ${byLogical.size} artifact(s)`);
-
-  runAttemptNum = fetchRunAttempt(REPO, runIdStr);
 } else {
   // CI mode — read from env vars
   for (const key of [
@@ -286,6 +306,7 @@ async function main(): Promise<void> {
   }
 
   validateRunBackfills();
+  checkTelemetry = true;
   const configCache = createConfigCache(sql);
   const { getOrCreateConfig, preloadConfigs } = configCache;
   const { fetchGithubRun, getOrCreateWorkflowRun } = createWorkflowRunServices(sql, GITHUB_TOKEN, [
@@ -333,11 +354,15 @@ async function main(): Promise<void> {
     }
   }
 
-  const requiredPowerPoints = verifyRequiredPowerArtifacts(artifactsDir, {
-    runId,
-    runAttempt: runAttemptNum,
-    headSha: ghInfo?.headSha ?? null,
-  });
+  const requiredPowerPoints = verifyRequiredPowerArtifacts(
+    artifactsDir,
+    {
+      runId,
+      runAttempt: runAttemptNum,
+      headSha: ghInfo?.headSha ?? null,
+    },
+    process.env.INGEST_REQUIRE_POWER === 'true',
+  );
   if (requiredPowerPoints.length > 0)
     console.log(`  Required power: ${requiredPowerPoints.length} source benchmark points verified`);
 
@@ -409,6 +434,18 @@ async function main(): Promise<void> {
   if (evalsOnly && requiredPowerPoints.length > 0)
     throw new Error('Required power: benchmark scope cannot be published as an evals-only run');
 
+  if (requiredPowerPoints.length > 0)
+    await preflightRequiredPowerCurves(
+      sql,
+      artifactsDir,
+      {
+        runId,
+        runAttempt: runAttemptNum,
+        headSha: ghInfo?.headSha ?? null,
+      },
+      { date, runStartedAt: workflowGhInfo?.runStartedAt ?? null, appendOnly },
+    );
+
   const workflowRunId = await getOrCreateWorkflowRun({
     githubRunId: runId,
     runAttempt: runAttemptNum,
@@ -452,6 +489,8 @@ async function main(): Promise<void> {
   let totalSampleFiles = 0;
   let totalChangelogs = 0;
   let totalTraceReplayLinked = 0;
+  let totalGpuMetricSeries = 0;
+  let totalGpuMetricSamples = 0;
   const datasetSlugs = new Set<string>();
   // Dataset slugs referenced by this run's agentic rows but absent from the
   // `datasets` table — timeline→dataset deep links 404 until they're ingested.
@@ -484,6 +523,14 @@ async function main(): Promise<void> {
     if (serverLogArtifacts.size > 0) {
       console.log(`  Found ${serverLogArtifacts.size} server log artifact(s)`);
     }
+    // PowerX telemetry: `gpu_metrics_<key>` is uploaded next to `bmk_<key>` by
+    // every single-node job; multinode jobs carry it inside `power_audit_<key>`
+    // instead (see migration 016). Digested here so the dashboard never
+    // re-downloads GitHub artifacts and keeps the series past retention.
+    const gpuMetricsArtifacts = discoverGpuMetricsArtifacts(artifactsDir);
+    if (gpuMetricsArtifacts.size > 0) {
+      console.log(`  Found ${gpuMetricsArtifacts.size} telemetry artifact(s)`);
+    }
 
     // Sibling aiperf artifacts: each `bmk_agentic_<suffix>` is paired with an
     // `agentic_<suffix>` dir holding `profile_export.jsonl` and
@@ -508,6 +555,7 @@ async function main(): Promise<void> {
 
     const allBmkFiles = [...bmkFiles, ...allBmkDirs.flatMap((d) => findJsonFiles(d))];
     const seenPointIdentities = new Map<string, string>();
+    const recoverPowerAudit = createBenchmarkPowerAuditRecovery();
     console.log(`  Found ${allBmkFiles.length} benchmark JSON file(s)`);
 
     for (const [fileIndex, file] of allBmkFiles.entries()) {
@@ -519,6 +567,7 @@ async function main(): Promise<void> {
       );
       const data = readJson(file);
       if (!data) {
+        telemetryExpectationsUnknown = true;
         powerPublicationErrors.push(`Unreadable benchmark JSON: ${relativeFile}`);
         console.log(`    skipped unreadable JSON (${elapsed(fileStart)})`);
         continue;
@@ -535,16 +584,26 @@ async function main(): Promise<void> {
         if (datasetSlug) datasetSlugs.add(datasetSlug);
       }
 
+      let fileExpectationsUnknown = false;
       const rows = rawRows
-        .filter((r) => typeof r === 'object' && r !== null)
+        .filter((r) => {
+          const isRow = typeof r === 'object' && r !== null;
+          if (!isRow) fileExpectationsUnknown = true;
+          return isRow;
+        })
         .map((r) => {
+          const failedRuns = tracker.skips.failedRun;
           const mapped = mapBenchmarkRow(r, tracker, undefined, runIdStr);
+          // Known failed benchmarks are intentionally excluded; unmappable rows
+          // leave an unknown number of successful attachment expectations.
+          if (!mapped && tracker.skips.failedRun === failedRuns) fileExpectationsUnknown = true;
           if (!mapped && Number(r.isl) === 8192 && Number(r.osl) === 1024) {
             powerPublicationErrors.push(`Unmapped or failed 8K/1K result: ${relativeFile}`);
           }
           return mapped;
         })
         .filter((r): r is NonNullable<typeof r> => r !== null);
+      if (fileExpectationsUnknown) telemetryExpectationsUnknown = true;
 
       console.log(`    mapped rows: ${rows.length}`);
       if (rows.length === 0) {
@@ -553,11 +612,34 @@ async function main(): Promise<void> {
       }
 
       const toInsert = [];
+      const parentDir = path.basename(path.dirname(file));
+      const configKey = parentDir.replace(/^bmk_/u, '');
+      const suffix = stripBmkAndAgenticPrefix(parentDir);
+      const gpuMetricsArtifact =
+        gpuMetricsArtifacts.get(configKey) ?? gpuMetricsArtifacts.get(suffix);
+      let auditEvidence;
+      if (parentDir.startsWith('bmk_agentic_') && gpuMetricsArtifact) {
+        try {
+          auditEvidence = {
+            resultFile: path.basename(file),
+            validations: readPowerAuditValidations(
+              gpuMetricsArtifact.artifactDir,
+              gpuMetricsArtifact.artifactName,
+            ),
+          };
+        } catch (error) {
+          tracker.recordTelemetryError(
+            `power audit for ${configKey}`,
+            error instanceof Error ? error : new Error(String(error)),
+          );
+        }
+      }
       for (const row of rows) {
         let configId: number;
         try {
           configId = await getOrCreateConfig(row.config);
         } catch (error: any) {
+          telemetryExpectationsUnknown = true;
           tracker.recordDbError(`config for ${path.basename(file)}`, error);
           continue;
         }
@@ -594,14 +676,32 @@ async function main(): Promise<void> {
               `config ${configId}, conc ${row.conc}`,
           );
         }
+        // Attach exact retained validation metadata before both the receipt and
+        // the upsert. A later aggregate copy must not null this run's recovery.
+        const point = recoverPowerAudit(applied.point, auditEvidence);
         const publication = powerPublicationPoint(
-          applied.point,
+          point,
           `https://github.com/${REPO}/actions/runs/${runIdNum}/attempts/${runAttemptNum}`,
           { path: relativeFile, sha256: artifactSha256 },
         );
         if (publication)
           powerPublicationPoints.set(publicationIdentity(publication.identity), publication);
-        toInsert.push(applied.point);
+        toInsert.push(point);
+        const identity = benchmarkPublicationIdentity(point);
+        const key = stablePowerPointIdentity(identity);
+        // Aggregate copies may arrive before/after their per-job sibling. Only
+        // the latter establishes whether that exact telemetry artifact exists.
+        if (parentDir.startsWith('bmk_') || !telemetryObservations.has(key)) {
+          telemetryObservations.set(key, {
+            identity,
+            artifactNames: gpuMetricsArtifact
+              ? [gpuMetricsArtifact.artifactName]
+              : parentDir.startsWith('bmk_')
+                ? [`gpu_metrics_${suffix}`, `power_audit_${suffix}`]
+                : [],
+            produced: parentDir.startsWith('bmk_') ? Boolean(gpuMetricsArtifact) : null,
+          });
+        }
       }
       console.log(`    rows with resolved configs: ${toInsert.length}`);
 
@@ -637,14 +737,12 @@ async function main(): Promise<void> {
             });
           }
 
-          const parentDir = path.basename(path.dirname(file));
           if (parentDir.startsWith('bmk_') && insertedIds.length > 0) {
             // Single-turn artifacts are `bmk_<key>` paired with
             // `server_logs_<key>`. Agentic artifacts are `bmk_agentic_<key>`
             // but the server log is still `server_logs_<key>` (no `agentic_`
             // prefix), so fall back to the fully-stripped suffix — otherwise
             // agentic rows never get their server log (and KV-pool size) linked.
-            const configKey = parentDir.replace(/^bmk_/u, '');
             const logArtifact =
               serverLogArtifacts.get(configKey) ??
               serverLogArtifacts.get(stripBmkAndAgenticPrefix(parentDir));
@@ -665,13 +763,48 @@ async function main(): Promise<void> {
                 tracker.recordDbError(`server_logs for ${configKey}`, error);
               }
             }
+            // Same pairing rule as server logs: `gpu_metrics_<key>` carries no
+            // `agentic_` prefix, so agentic points fall back to the bare suffix.
+            if (gpuMetricsArtifact) {
+              try {
+                const gpuMetricsStart = Date.now();
+                const ingested = await ingestGpuMetricsArtifact(sql, {
+                  workflowRunId,
+                  artifact: gpuMetricsArtifact,
+                  benchmarkResultIds: insertedIds,
+                });
+                if (ingested.seriesIds.length === 0)
+                  throw new Error(
+                    `No parseable telemetry series in ${gpuMetricsArtifact.artifactName}`,
+                  );
+                totalGpuMetricSeries += ingested.seriesIds.length;
+                totalGpuMetricSamples += ingested.samplesInserted;
+                console.log(
+                  `    gpu_metrics ${ingested.seriesIds.length} series, ` +
+                    `+${ingested.samplesInserted} sample(s), ` +
+                    `${ingested.seriesSkipped} unchanged (${elapsed(gpuMetricsStart)})`,
+                );
+              } catch (error: any) {
+                // Non-fatal on purpose: this point's benchmark rows are already
+                // committed and only its telemetry tab is affected, and
+                // `admin:db:backfill-gpu-metrics --run <id>` can re-digest the
+                // artifact later. Recording it as a DB error instead would reach
+                // the publication manifest and fail the whole production ingest.
+                tracker.recordTelemetryError(`gpu_metrics for ${configKey}`, error);
+                for (const row of toInsert) {
+                  const point = telemetryObservations.get(
+                    stablePowerPointIdentity(benchmarkPublicationIdentity(row)),
+                  );
+                  if (point) point.error = error instanceof Error ? error.message : String(error);
+                }
+              }
+            }
           }
 
           // Trace-replay sibling lookup for agentic points only. The aiperf
           // harness emits `agentic_<suffix>/trace_replay/...` next to the
           // `bmk_agentic_<suffix>` artifact we just ingested.
           if (parentDir.startsWith('bmk_agentic_') && insertedIds.length > 0) {
-            const suffix = stripBmkAndAgenticPrefix(parentDir);
             const concMatch = path.basename(file).match(/_conc(?<conc>\d+)\.json$/u);
             const trace =
               (concMatch?.groups?.conc
@@ -1042,9 +1175,24 @@ main()
     console.error('ingest-ci-run failed:', error);
     process.exitCode = 1;
   })
-  .finally(() => {
-    const publicationPath = process.env.POWER_PUBLICATION_MANIFEST;
+  .finally(async () => {
+    const publicationPath =
+      process.env.POWER_PUBLICATION_MANIFEST ??
+      `power-publication-${runIdNum}-attempt-${runAttemptNum}.json`;
     if (publicationPath) {
+      const telemetry = checkTelemetry
+        ? await readTelemetryReceipt(
+            sql,
+            { runId: runIdNum, runAttempt: runAttemptNum },
+            [...telemetryObservations.values()],
+            {
+              expectedSource:
+                !telemetryExpectationsUnknown && telemetryObservations.size > 0
+                  ? 'benchmark_artifacts'
+                  : 'unknown',
+            },
+          )
+        : undefined;
       fs.writeFileSync(
         publicationPath,
         `${JSON.stringify(
@@ -1057,11 +1205,17 @@ main()
               ...powerPublicationErrors,
               ...(tracker.skips.dbError ? [`${tracker.skips.dbError} database ingest errors`] : []),
             ],
+            // Reported but not fatal — see Skips.telemetryError.
+            telemetryWarnings: tracker.skips.telemetryError
+              ? [`${tracker.skips.telemetryError} gpu_metrics digest errors`]
+              : [],
+            ...(telemetry ? { telemetry } : {}),
           },
           null,
           2,
         )}\n`,
       );
+      console.log(`  PowerX ingest receipt: ${publicationPath}`);
     }
     if (tempDir) {
       try {
diff --git a/packages/db/src/ingest-gcs-backup.ts b/packages/db/src/ingest-gcs-backup.ts
index 709fdc9c3..b9cb76b59 100644
--- a/packages/db/src/ingest-gcs-backup.ts
+++ b/packages/db/src/ingest-gcs-backup.ts
@@ -104,8 +104,12 @@ interface WorkflowMapResult {
   changelogs: { baseRef: string; headRef: string; entries: ChangelogEntry[] }[];
   /** True when the changelog declares evals-only — benchmark/stats data is dropped. */
   evalsOnly: boolean;
-  /** Skip counts from mapping phase (dbError is tracked separately in phase 2). */
-  localSkips: Omit<Skips, 'dbError'>;
+  /**
+   * Skip counts from the mapping phase. `dbError` is tracked separately in phase 2,
+   * and `telemetryError` never applies here: the GCS backup path ingests no
+   * `gpu_metrics_*` artifacts.
+   */
+  localSkips: Omit<Skips, 'dbError' | 'telemetryError'>;
   localUnmappedModels: Set<string>;
   localUnmappedHws: Set<string>;
   /** Pre-formatted [WARN] lines to print at the start of phase 2 for this dir. */
@@ -121,7 +125,7 @@ interface WriteResult {
   evalSamples: number;
   changelogs: number;
   warnings: string[];
-  localSkips: Omit<Skips, 'dbError'>;
+  localSkips: Omit<Skips, 'dbError' | 'telemetryError'>;
   localUnmappedModels: string[];
   localUnmappedHws: string[];
 }
diff --git a/packages/db/src/lib/artifact-retry.ts b/packages/db/src/lib/artifact-retry.ts
index e145aa04d..4044dc35b 100644
--- a/packages/db/src/lib/artifact-retry.ts
+++ b/packages/db/src/lib/artifact-retry.ts
@@ -1,5 +1,17 @@
 const DEFAULT_RETRY_DELAYS_MS = [5_000, 15_000, 30_000, 60_000, 120_000] as const;
 
+/**
+ * Marks a failure no retry can fix (the run or artifact is gone, not
+ * unreachable). `retryArtifactOperation` rethrows it immediately instead of
+ * burning the full backoff schedule on it.
+ */
+export class NonRetryableArtifactError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'NonRetryableArtifactError';
+  }
+}
+
 interface ArtifactRetryOptions {
   delaysMs?: readonly number[];
   wait?: (delayMs: number) => Promise<void>;
@@ -26,6 +38,7 @@ export async function retryArtifactOperation<T>(
     try {
       return await operation();
     } catch (error) {
+      if (error instanceof NonRetryableArtifactError) throw error;
       lastError = error;
       if (attempt >= delaysMs.length) break;
       const delayMs = delaysMs[attempt];
diff --git a/packages/db/src/lib/github-artifacts.test.ts b/packages/db/src/lib/github-artifacts.test.ts
index 571643a5e..e612d5c1b 100644
--- a/packages/db/src/lib/github-artifacts.test.ts
+++ b/packages/db/src/lib/github-artifacts.test.ts
@@ -1,5 +1,4 @@
 import { describe, expect, it } from 'vitest';
-
 import { RUNNER_SUFFIX_RE, dedupeArtifactsByLogicalName } from './github-artifacts.js';
 
 const art = (name: string, created_at: string) => ({
diff --git a/packages/db/src/lib/github-artifacts.ts b/packages/db/src/lib/github-artifacts.ts
index 67827855e..c95957755 100644
--- a/packages/db/src/lib/github-artifacts.ts
+++ b/packages/db/src/lib/github-artifacts.ts
@@ -8,6 +8,8 @@ import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 
+import { NonRetryableArtifactError } from './artifact-retry.js';
+
 export interface ArtifactMeta {
   id?: number;
   name: string;
@@ -32,12 +34,46 @@ export interface ArtifactMeta {
  */
 export const RUNNER_SUFFIX_RE = /_[a-zA-Z][a-zA-Z0-9.-]*_\d+$/u;
 
-/** List a workflow run's artifacts via `gh api` (paginated). Malformed lines are skipped. */
+/**
+ * GitHub no longer has the run (deleted, or purged past retention), so its
+ * artifact listing 404s. Distinct from expired artifacts, which still list
+ * with `expired: true`.
+ */
+export class WorkflowRunNotFoundError extends NonRetryableArtifactError {
+  readonly repo: string;
+  readonly runId: string;
+
+  constructor(repo: string, runId: string) {
+    super(`GitHub has no run ${runId} in ${repo} (HTTP 404)`);
+    this.name = 'WorkflowRunNotFoundError';
+    this.repo = repo;
+    this.runId = runId;
+  }
+}
+
+/** `gh api` reports the HTTP status in its stderr (`gh: Not Found (HTTP 404)`). */
+export function isGithubNotFoundError(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) return false;
+  const { stderr, message } = error as { stderr?: unknown; message?: unknown };
+  const text = [stderr, message].filter((part) => typeof part === 'string').join('\n');
+  return /\(HTTP 404\)/u.test(text);
+}
+
+/**
+ * List a workflow run's artifacts via `gh api` (paginated). Malformed lines
+ * are skipped; a 404 surfaces as `WorkflowRunNotFoundError`.
+ */
 export function listRunArtifacts(repo: string, runId: string): ArtifactMeta[] {
-  const json = execSync(
-    `gh api "repos/${repo}/actions/runs/${runId}/artifacts" --paginate --jq '.artifacts[]'`,
-    { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 },
-  );
+  let json: string;
+  try {
+    json = execSync(
+      `gh api "repos/${repo}/actions/runs/${runId}/artifacts" --paginate --jq '.artifacts[]'`,
+      { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 },
+    );
+  } catch (error) {
+    if (isGithubNotFoundError(error)) throw new WorkflowRunNotFoundError(repo, runId);
+    throw error;
+  }
   const out: ArtifactMeta[] = [];
   for (const line of json.trim().split('\n')) {
     if (!line) continue;
diff --git a/packages/db/src/prepare-ci-artifacts.ts b/packages/db/src/prepare-ci-artifacts.ts
index fbf834d70..f0c35780e 100644
--- a/packages/db/src/prepare-ci-artifacts.ts
+++ b/packages/db/src/prepare-ci-artifacts.ts
@@ -6,6 +6,7 @@ import path from 'node:path';
 
 import { buildArtifactPlan } from './lib/ci-artifact-preparation.js';
 import { downloadArtifact, listRunArtifacts, type ArtifactMeta } from './lib/github-artifacts.js';
+import { verifyRequiredPowerArtifacts } from './etl/required-power-publication.js';
 
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 
@@ -148,6 +149,16 @@ function main(): void {
     console.log(`Downloading artifact: ${artifact.name}`);
     downloadWithRetries(artifact, artifactsPath);
   }
+  // This command precedes migrations: malformed required input must not reach any DB write.
+  verifyRequiredPowerArtifacts(
+    artifactsPath,
+    {
+      runId: Number(sourceRunId),
+      runAttempt: sourceMetadata.run_attempt ?? 1,
+      headSha: sourceMetadata.head_sha ?? null,
+    },
+    process.env.INGEST_REQUIRE_POWER === 'true',
+  );
   if (plan.reused) {
     writeReuseMetadata(artifactsPath, sourceRunId, mergeRunId, sourceMetadata, mergeMetadata);
   }

From 63d313baf4f9f8f0e3d1320b25fc77fb9960a033 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 091/103] feat(etl): publication receipts and required-power
 verification
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Write a per-run telemetry receipt (expected, produced, stored, API-readable points),
widen required-power publication to 1K/1K, and verify sweep manifests, point evidence
and curve preservation before a run is treated as published.

中文：为每个 run 写遥测回执（预期/产出/入库/API 可读点），required-power 发布范围扩展到 1K/1K，并在视为已发布前校验 sweep manifest、点证据与曲线保留。
---
 docs/fixtures/powerx-manifest-v2/README.md    | 101 ++++
 .../artifacts/agentic_golden/gpu_metrics.csv  |   3 +
 .../agentic_golden/gpu_metrics_identity.csv   |   2 +
 .../artifacts/agentic_golden/power_node.txt   |   1 +
 .../agentic_golden/power_validation.json      |  21 +
 .../artifacts/bmk_agentic_golden/agg.json     |  25 +
 .../changelog_metadata.json                   |   4 +
 .../sweep_manifest.json                       |  98 ++++
 .../required-power-agentic-matrix.json        |  50 --
 packages/db/src/etl/power-publication.test.ts |   8 +-
 packages/db/src/etl/power-publication.ts      |  76 ++-
 .../src/etl/required-power-curve-db.test.ts   |  89 +++
 .../db/src/etl/required-power-curve.test.ts   | 107 ++++
 packages/db/src/etl/required-power-curve.ts   | 287 ++++++++++
 .../etl/required-power-publication.test.ts    | 464 ++++++----------
 .../db/src/etl/required-power-publication.ts  | 520 +++++++++++++++++-
 packages/db/src/etl/telemetry-receipt.test.ts | 274 +++++++++
 packages/db/src/etl/telemetry-receipt.ts      | 461 ++++++++++++++++
 .../db/src/preflight-power-publication.ts     |  36 ++
 packages/db/src/verify-power-publication.ts   |  29 +-
 20 files changed, 2293 insertions(+), 363 deletions(-)
 create mode 100644 docs/fixtures/powerx-manifest-v2/README.md
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json
 create mode 100644 docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json
 delete mode 100644 packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json
 create mode 100644 packages/db/src/etl/required-power-curve-db.test.ts
 create mode 100644 packages/db/src/etl/required-power-curve.test.ts
 create mode 100644 packages/db/src/etl/required-power-curve.ts
 create mode 100644 packages/db/src/etl/telemetry-receipt.test.ts
 create mode 100644 packages/db/src/etl/telemetry-receipt.ts
 create mode 100644 packages/db/src/preflight-power-publication.ts

diff --git a/docs/fixtures/powerx-manifest-v2/README.md b/docs/fixtures/powerx-manifest-v2/README.md
new file mode 100644
index 000000000..0075b4a13
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/README.md
@@ -0,0 +1,101 @@
+# PowerX source manifest v2
+
+This small, synthetic one-GPU AgentX bundle is copied byte-for-byte between
+InferenceX and InferenceX-app. It tests the file contract. It is **not** a GPU
+capture, hardware qualification or publication receipt.
+
+`artifacts/required-power-sweep-manifest/sweep_manifest.json` is the source
+manifest. Evidence paths are relative to `artifacts/`, include their GitHub
+artifact directory, and have SHA-256 hashes of the exact retained bytes.
+
+## Contract
+
+- `schema-version: 2` versions publication independently of measurement-row
+  `power_metric_schema_version: 2`. Unsupported or unversioned required bundles
+  fail closed; legacy optional bundles remain optional.
+- `run-id`, `run-attempt`, and `head` name the tested source. A later rerun may
+  retain successful earlier-attempt evidence from the same run and head. The
+  consumer compares these fields with GitHub source metadata, including on reuse.
+- `matrix` retains the ordinary planner declaration. Every required,
+  non-evaluation matrix point must occur exactly once in `points`.
+- `config_key` is the matrix entry's `exp-name`. `identity` binds model, hardware,
+  framework, precision, recipe fingerprint, workload/sequence and concurrency.
+  AgentX uses `agentic_traces` with null `isl`/`osl`; fixed sequence uses
+  `single_turn`. Full recipe details remain in the matrix and hashed aggregate.
+- `topology` declares aggregate versus P/D, single versus multi-node and physical
+  GPU counts. `devices` binds actual nodes and GPU UUIDs to aggregate, prefill or
+  decode roles with positive per-device energy. Both P/D roles are mandatory for
+  disaggregated deployments. A local GPU index alone is insufficient.
+- `measurement_window` contains finite Unix-second boundaries, with end after
+  start. The evidence must describe the same window.
+- `artifacts` contains confined relative paths, exact hashes and
+  `validation_state: "valid"`. Missing files, path escapes, invalid verdicts,
+  mismatched identities and invalid power reject required publication. Missing
+  and invalid values remain distinct from numeric zero. Required energy and
+  derived power must be strictly positive; measured zero fails that gate.
+
+## Publication intent
+
+Normal manifests emit `publication: {"mode":"incremental","replacement_scope":[]}`.
+Incremental means **no authorized loss**; it does not change existing whole-curve
+selection or automatically enable append-only. A complete refresh can pass by
+retaining all stable point identities. Recipe/image fingerprint changes may need
+a reviewed exact replacement.
+
+`mode: "replacement"` permits only explicit entries containing:
+
+- `curve_scope`: the canonical logical curve JSON identity;
+- `previous_snapshot_workflow_run_id`: the exact database snapshot superseded;
+- `removed_point_identities`: the exact set of lost stable identities.
+
+No wildcard, stale snapshot or broader permission is implied. The producer's
+ordinary path emits no destructive authorization. Authoring authorization needs
+explicitly reviewed replacement intent and current snapshot evidence.
+
+AgentX scope groups model/hardware/framework/precision/workload; AGG/P/D,
+parallelism, offload and recipe variants are points in that curve. Fixed-sequence
+scopes retain existing spec/disagg/offload boundaries. The consumer models latest
+attempts, whole snapshots and same-image append-only inheritance before its first
+publication write. Row counts or a stale materialized view cannot establish safety.
+
+## Remaining publication boundary
+
+Artifact validation runs before workflow migrations. Curve preflight runs before
+workflow/config/benchmark upserts. It is a pure preflight, not an atomic commit:
+concurrent writers and failures after the first write can still cause partial
+publication. Follow-up work must stage the complete run, recheck the base-table
+curve under a target-database publication lock, then atomically promote metadata
+and benchmark rows. Sidecar preparation belongs outside that transaction.
+Post-write DB/API checks remain necessary; exact-run equality alone does not prove
+latest-curve visibility.
+
+## Read-only fixture check in InferenceX-app
+
+From the repository root:
+
+```sh
+bun packages/db/src/preflight-power-publication.ts \
+  docs/fixtures/powerx-manifest-v2/artifacts 123 1 \
+  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
+```
+
+This opens no database connection, dispatches no work and writes no files. It
+validates artifacts only; focused curve tests model previous published state.
+
+## 中文说明
+
+此目录是一份最小的合成 AgentX 样例，两个仓库保留完全相同的文件字节，
+用于测试 producer 与 consumer 的契约；它不是实机采集或生产发布证据。
+
+manifest schema v2 记录来源 run、attempt、测试 SHA、完整 matrix、逐点身份、
+测量窗口、实际 node/GPU UUID/角色及产物哈希。必需功耗路径拒绝缺失、损坏、
+不兼容或能量非正的证据；P/D 必须同时覆盖 prefill 和 decode。历史可选功耗
+路径保留兼容行为。数值 0 不会被改写为“缺失”，但不能通过正能量门槛。
+
+默认 incremental 只表示没有授权丢点，不会改变数据库整条曲线替换的语义。
+有意替换必须精确指定旧快照及全部移除点，不能使用通配或过期授权。AgentX
+的 AGG、P/D、offload 和配方属于同一条逻辑曲线，校验时必须一起比较。
+
+产物校验先于 migration；曲线校验先于发布数据写入。当前实现不是原子发布，
+仍需后续 staging、发布锁和事务性 promote 来处理并发及中途写入失败。
+DB/API 写后校验仍保留，exactRun 校验不能单独证明 latest 曲线完整可见。
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv
new file mode 100644
index 000000000..d39b2974a
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics.csv
@@ -0,0 +1,3 @@
+timestamp, index, power.draw [W]
+2023/11/14 22:13:20.000, 0, 500
+2023/11/14 22:13:22.000, 0, 500
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv
new file mode 100644
index 000000000..139b5a261
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/gpu_metrics_identity.csv
@@ -0,0 +1,2 @@
+index, uuid, pci.bus_id, name, driver_version
+0, GPU-golden, 00000000:01:00.0, NVIDIA H100, 000.00
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt
new file mode 100644
index 000000000..fb271d435
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_node.txt
@@ -0,0 +1 @@
+golden-node
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json
new file mode 100644
index 000000000..42d164cb2
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/agentic_golden/power_validation.json
@@ -0,0 +1,21 @@
+{
+  "schema_version": 1,
+  "power_valid": true,
+  "reasons": [],
+  "benchmark_window": {
+    "start_time_unix": 1700000000,
+    "end_time_unix": 1700000002
+  },
+  "expected_gpu_count": 1,
+  "observed_gpu_count": 1,
+  "observed_gpu_ids": ["0"],
+  "per_gpu_energy_j": {
+    "0": 1000
+  },
+  "metrics": {
+    "avg_power_w": 500,
+    "avg_total_gpu_power_w": 500,
+    "total_gpu_energy_j": 1000,
+    "joules_per_output_token": 2
+  }
+}
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json b/docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json
new file mode 100644
index 000000000..98df7c14b
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/bmk_agentic_golden/agg.json
@@ -0,0 +1,25 @@
+{
+  "infmax_model_prefix": "qwen3.5",
+  "hw": "h100",
+  "framework": "sglang",
+  "precision": "fp8",
+  "recipe_fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+  "scenario_type": "agentic-coding",
+  "conc": 1,
+  "users": 1,
+  "tp": 1,
+  "ep": 1,
+  "dp_attention": false,
+  "disagg": false,
+  "is_multinode": false,
+  "num_gpus": 1,
+  "image": "example/serving:golden",
+  "power_valid": 1,
+  "power_metric_schema_version": 2,
+  "avg_power_w": 500,
+  "avg_total_gpu_power_w": 500,
+  "total_gpu_energy_j": 1000,
+  "joules_per_output_token": 2,
+  "output_tput_per_gpu": 250,
+  "median_intvty": 50
+}
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json b/docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json
new file mode 100644
index 000000000..af53bb83d
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/changelog-metadata/changelog_metadata.json
@@ -0,0 +1,4 @@
+{
+  "require-power": true,
+  "entries": []
+}
diff --git a/docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json b/docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json
new file mode 100644
index 000000000..f51df0546
--- /dev/null
+++ b/docs/fixtures/powerx-manifest-v2/artifacts/required-power-sweep-manifest/sweep_manifest.json
@@ -0,0 +1,98 @@
+{
+  "schema-version": 2,
+  "head": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+  "run-id": 123,
+  "run-attempt": 1,
+  "full-sweep": false,
+  "matrix": {
+    "single_node": {
+      "agentic": [
+        {
+          "exp-name": "golden",
+          "model-prefix": "qwen3.5",
+          "model": "Qwen/Qwen3.5",
+          "runner": "h100",
+          "framework": "sglang",
+          "precision": "fp8",
+          "recipe-fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+          "conc": [1],
+          "require-power": true,
+          "scenario-type": "agentic-coding",
+          "disagg": false,
+          "num-gpus": 1,
+          "tp": 1,
+          "ep": 1,
+          "image": "example/serving:golden"
+        }
+      ]
+    },
+    "multi_node": {}
+  },
+  "publication": {
+    "mode": "incremental",
+    "replacement_scope": []
+  },
+  "points": [
+    {
+      "config_key": "golden",
+      "identity": {
+        "model": "qwen3.5",
+        "hardware": "h100",
+        "framework": "sglang",
+        "precision": "fp8",
+        "recipe_fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        "benchmark_type": "agentic_traces",
+        "isl": null,
+        "osl": null,
+        "concurrency": 1
+      },
+      "topology": {
+        "disagg": false,
+        "is_multinode": false,
+        "num_gpus": 1,
+        "tp": 1,
+        "ep": 1,
+        "dp_attention": false
+      },
+      "measurement_window": {
+        "start_time_unix": 1700000000,
+        "end_time_unix": 1700000002
+      },
+      "devices": [
+        {
+          "node": "golden-node",
+          "gpu_uuid": "GPU-golden",
+          "role": "aggregate",
+          "energy_j": 1000
+        }
+      ],
+      "artifacts": [
+        {
+          "path": "agentic_golden/gpu_metrics.csv",
+          "sha256": "f42dee832f8d837142be9d4dc5fbbf8462c02846f06e66edfce659b8b20943db",
+          "validation_state": "valid"
+        },
+        {
+          "path": "agentic_golden/gpu_metrics_identity.csv",
+          "sha256": "a4364a0d4050078b9cba24c7e695fbed658fabb1d48e61a3da8f61b8ec873627",
+          "validation_state": "valid"
+        },
+        {
+          "path": "agentic_golden/power_node.txt",
+          "sha256": "114aa18bee3688c0e6040020ad0230472645541372b88a54253116fd9c2148e6",
+          "validation_state": "valid"
+        },
+        {
+          "path": "agentic_golden/power_validation.json",
+          "sha256": "c00687e7239fd172aa15f60c8d967294a0fa623984d0eaeeb5222424b6335d94",
+          "validation_state": "valid"
+        },
+        {
+          "path": "bmk_agentic_golden/agg.json",
+          "sha256": "56e3377ae12402eec61e25e2f9a0480ab228048a29d32c35cb8d438d50ea2faa",
+          "validation_state": "valid"
+        }
+      ]
+    }
+  ]
+}
diff --git a/packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json b/packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json
deleted file mode 100644
index 4d17ed15a..000000000
--- a/packages/db/src/etl/__fixtures__/required-power-agentic-matrix.json
+++ /dev/null
@@ -1,50 +0,0 @@
-{
-  "single_node": {},
-  "multi_node": {
-    "agentic": [
-      {
-        "image": "vllm/vllm-openai:nightly-dev-x86_64-cu13.0.1-728d3ad",
-        "model": "moonshotai/Kimi-K3",
-        "model-prefix": "kimik3",
-        "precision": "fp4",
-        "framework": "dynamo-vllm",
-        "spec-decoding": "mtp",
-        "runner": "cluster:b200-nscale",
-        "require-power": true,
-        "node-count": 2,
-        "prefill": {
-          "num-worker": 1,
-          "tp": 8,
-          "pp": 2,
-          "dcp-size": 8,
-          "pcp-size": 1,
-          "ep": 1,
-          "dp-attn": false,
-          "additional-settings": [
-            "CONFIG_FILE=recipes/vllm/kimi-k3/agentic/agg-b200-tp8pp2-mooncake-c1-agentic.yaml",
-            "SYNTHETIC_ACCEPTANCE=true",
-            "SYNTHETIC_ACCEPTANCE_LENGTH=3.84"
-          ]
-        },
-        "decode": {
-          "num-worker": 0,
-          "tp": 8,
-          "pp": 2,
-          "dcp-size": 8,
-          "pcp-size": 1,
-          "ep": 1,
-          "dp-attn": false,
-          "additional-settings": []
-        },
-        "conc": [1],
-        "kv-offloading": "none",
-        "total-cpu-dram-gb": 0,
-        "duration": 3600,
-        "exp-name": "kimik3_p1x8_d0x8_conc1",
-        "disagg": false,
-        "scenario-type": "agentic-coding",
-        "recipe-fingerprint": "ebb89391c58441525072eeffe36b6a6f6f52445116c68c99c017f06d662b972e"
-      }
-    ]
-  }
-}
diff --git a/packages/db/src/etl/power-publication.test.ts b/packages/db/src/etl/power-publication.test.ts
index f223a07a4..b31ce0f98 100644
--- a/packages/db/src/etl/power-publication.test.ts
+++ b/packages/db/src/etl/power-publication.test.ts
@@ -37,7 +37,7 @@ function expected(overrides = {}) {
     'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/123/attempts/2',
     { path: 'bmk_qwen3.5/results.json', sha256: 'abc' },
   );
-  if (!point) throw new Error('Fixture must be 8K/1K');
+  if (!point) throw new Error('Fixture must belong to a supported PowerX workload');
   return point;
 }
 function actual(point = expected()): PublishedPowerRow {
@@ -51,6 +51,12 @@ function actual(point = expected()): PublishedPowerRow {
 }
 
 describe('PowerX publication', () => {
+  it('keeps required 1K/1K measurements in the publication receipt', () => {
+    const point = expected({ isl: 1024, joules_per_output_token: 2.5 });
+    expect(point.identity).toMatchObject({ benchmark_type: 'single_turn', isl: 1024, osl: 1024 });
+    expect(verifyPowerPublication([point], [actual(point)], 'database')).toEqual([]);
+    expect(verifyPowerPublication([point], [], 'public API')[0]).toContain('found 0');
+  });
   it('verifies AgentX source identity, nullable sequences, energy and audit through DB/API', () => {
     const point = expected({
       scenario_type: 'agentic-coding',
diff --git a/packages/db/src/etl/power-publication.ts b/packages/db/src/etl/power-publication.ts
index d2ed10c14..d4a0ba17c 100644
--- a/packages/db/src/etl/power-publication.ts
+++ b/packages/db/src/etl/power-publication.ts
@@ -1,6 +1,7 @@
 import { isDeepStrictEqual } from 'node:util';
 import { MEASURED_POWER_METRIC_KEYS } from '@semianalysisai/inferencex-constants';
 import type { BenchmarkParams } from './benchmark-mapper';
+import type { TelemetryReceipt } from './telemetry-receipt';
 
 const CONFIG_FIELDS = {
   hardware: 'hardware',
@@ -46,26 +47,67 @@ export interface PowerPublicationManifest {
   runId: number;
   runAttempt: number;
   points: PowerPublicationPoint[];
+  /** Fatal: verify-power-publication exits non-zero when this is non-empty. */
   ingestErrors?: string[];
+  /**
+   * Non-fatal: PowerX telemetry digest failures. Surfaced in the verification
+   * receipt so they stay visible, but they never fail the ingest — the benchmark
+   * rows landed, and the artifact can be re-digested by the backfill.
+   */
+  telemetryWarnings?: string[];
+  /** Attachment completeness, separate from benchmark/power publication validity. */
+  telemetry?: TelemetryReceipt;
+  /** Durable refresh responsibility when telemetry recovery fills benchmark metadata. */
+  benchmarkRefresh?: {
+    status: 'pending' | 'complete' | 'failed';
+    benchmarkResultIds: number[];
+    /** Expected enrichment comes from retained validation, never a DB snapshot. */
+    auditUpdates?: {
+      benchmarkResultId: number;
+      identity: Record<string, unknown>;
+      /** Original mapped identity when the existing historical offload resolver used a fallback. */
+      sourceIdentity?: Record<string, unknown>;
+      powerAudit: { source: string; window_start_unix: number; window_end_unix: number };
+    }[];
+    endpoint?: string;
+    checkedAt?: string;
+    error?: string;
+  };
+}
+/**
+ * The errors that fail an ingest. `telemetryWarnings` is deliberately not among
+ * them: a gpu_metrics digest failure costs one point's PowerX tab, while the
+ * benchmark rows it accompanies are already committed and the artifact can be
+ * re-digested by `admin:db:backfill-gpu-metrics`. Folding it in would let one
+ * malformed CSV turn a whole production ingest red.
+ */
+export function fatalPublicationErrors(
+  manifest: Pick<PowerPublicationManifest, 'ingestErrors' | 'telemetryWarnings'>,
+  verificationErrors: readonly string[],
+): string[] {
+  return [...(manifest.ingestErrors ?? []), ...verificationErrors];
 }
+
 export interface PublishedPowerRow extends Record<string, unknown> {
   metrics: Record<string, number>;
 }
 
+export function stablePowerPointIdentity(row: Record<string, unknown>): string {
+  return JSON.stringify(
+    IDENTITY_FIELDS.filter((key) => key !== 'image' && key !== 'run_url').map(
+      (key) => row[key] ?? null,
+    ),
+  );
+}
+
 export function publicationIdentity(row: Record<string, unknown>): string {
   return JSON.stringify(IDENTITY_FIELDS.map((key) => row[key] ?? null));
 }
 
-export function powerPublicationPoint(
+export function benchmarkPublicationIdentity(
   row: BenchmarkParams,
-  runUrl: string,
-  artifact: PowerPublicationPoint['artifact'],
-): PowerPublicationPoint | null {
-  if (
-    row.benchmarkType !== 'agentic_traces' &&
-    (row.benchmarkType !== 'single_turn' || row.isl !== 8192 || row.osl !== 1024)
-  )
-    return null;
+  runUrl = '',
+): Record<string, unknown> {
   const identity: Record<string, unknown> = Object.fromEntries(
     Object.entries(CONFIG_FIELDS).map(([source, target]) => [
       target,
@@ -82,6 +124,22 @@ export function powerPublicationPoint(
     image: row.image,
     run_url: runUrl,
   });
+  return identity;
+}
+
+export function powerPublicationPoint(
+  row: BenchmarkParams,
+  runUrl: string,
+  artifact: PowerPublicationPoint['artifact'],
+): PowerPublicationPoint | null {
+  if (
+    row.benchmarkType !== 'agentic_traces' &&
+    (row.benchmarkType !== 'single_turn' ||
+      (row.isl !== 1024 && row.isl !== 8192) ||
+      row.osl !== 1024)
+  )
+    return null;
+  const identity = benchmarkPublicationIdentity(row, runUrl);
   return {
     identity,
     metrics: Object.fromEntries(
diff --git a/packages/db/src/etl/required-power-curve-db.test.ts b/packages/db/src/etl/required-power-curve-db.test.ts
new file mode 100644
index 000000000..7ffcbfb06
--- /dev/null
+++ b/packages/db/src/etl/required-power-curve-db.test.ts
@@ -0,0 +1,89 @@
+import { PGlite } from '@electric-sql/pglite';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { beforeAll, beforeEach, afterAll, describe, it, expect } from 'vitest';
+import type { DbClient } from '../connection';
+import { preflightRequiredPowerCurves } from './required-power-curve';
+import { getLatestBenchmarks } from '../queries/benchmarks';
+let db: PGlite;
+const sql: DbClient = async (strings, ...values) => {
+  const query = strings.reduce((text, part, index) => text + (index ? `$${index}` : '') + part, '');
+  const result = await db.query<Record<string, unknown>>(query, values);
+  return result.rows;
+};
+const golden = path.resolve(
+  import.meta.dirname,
+  '../../../../docs/fixtures/powerx-manifest-v2/artifacts',
+);
+const source = { runId: 123, runAttempt: 1, headSha: 'b'.repeat(40) };
+const options = { date: '2026-09-16', runStartedAt: '2026-09-16T00:00:00Z', appendOnly: false };
+beforeAll(async () => {
+  db = await PGlite.create();
+  const dir = new URL('../../migrations/', import.meta.url);
+  for (const file of fs
+    .readdirSync(dir)
+    .filter((name) => name.endsWith('.sql'))
+    .sort())
+    await db.exec(fs.readFileSync(new URL(file, dir), 'utf8'));
+}, 20000);
+afterAll(async () => {
+  await db?.close();
+});
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, prefill_ep, decode_tp, decode_ep, num_prefill_gpu, num_decode_gpu)
+      VALUES (1, 'qwen3.5', 'h100', 'sglang', 'fp8', 'none', false, 1,1,1,1,1,1);
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, date, created_at, run_started_at)
+      VALUES (1, 111, 1, 'previous', '2026-09-15', '2026-09-15T00:00:00Z', '2026-09-15T00:00:00Z');`);
+});
+async function addPoint(conc: number, image = 'example/serving:golden') {
+  await sql`INSERT INTO benchmark_results (config_id, workflow_run_id, date, benchmark_type, isl, osl, conc, offload_mode, recipe_fingerprint, image, metrics)
+    VALUES (1,1,'2026-09-15','agentic_traces',NULL,NULL,${conc},'off',${'a'.repeat(64)},${image},'{}')`;
+}
+describe('read-only required-power DB preflight', () => {
+  it('rejects partial refresh from base tables before any write, even with a stale latest view', async () => {
+    await addPoint(1);
+    await addPoint(64);
+    const before = await sql`SELECT count(*)::int AS n FROM benchmark_results`;
+    await expect(preflightRequiredPowerCurves(sql, golden, source, options)).rejects.toThrow(
+      'shrink',
+    );
+    expect(await sql`SELECT count(*)::int AS n FROM benchmark_results`).toEqual(before);
+    expect(await sql`SELECT count(*)::int AS n FROM workflow_runs`).toEqual([{ n: 1 }]);
+    const published = await getLatestBenchmarks(sql, 'qwen3.5', '9999-12-31');
+    expect(published.map((row) => row.conc)).toEqual([1, 64]);
+  });
+  it('detects retry removal from a scope omitted entirely by incoming artifacts', async () => {
+    await sql`UPDATE workflow_runs SET github_run_id=123`;
+    await sql`UPDATE configs SET hardware='h200'`;
+    await addPoint(64);
+    await expect(
+      preflightRequiredPowerCurves(sql, golden, { ...source, runAttempt: 2 }, options),
+    ).rejects.toThrow('shrink');
+    expect(await sql`SELECT count(*)::int AS n FROM workflow_runs`).toEqual([{ n: 1 }]);
+  });
+  it('protects optional fixed workloads outside the power receipt whitelist', async () => {
+    await sql`INSERT INTO benchmark_results (config_id,workflow_run_id,date,benchmark_type,isl,osl,conc,offload_mode,recipe_fingerprint,image,metrics)
+      VALUES (1,1,'2026-09-15','single_turn',4096,1024,1,'off',${'c'.repeat(64)},'example/serving:golden','{}'),
+      (1,1,'2026-09-15','single_turn',4096,1024,8,'off',${'c'.repeat(64)},'example/serving:golden','{}')`;
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-optional-'));
+    try {
+      fs.cpSync(golden, dir, { recursive: true });
+      fs.mkdirSync(path.join(dir, 'results_optional'));
+      const row = JSON.parse(
+        fs.readFileSync(path.join(golden, 'bmk_agentic_golden/agg.json'), 'utf8'),
+      );
+      delete row.scenario_type;
+      delete row.users;
+      Object.assign(row, { isl: 4096, osl: 1024, recipe_fingerprint: 'c'.repeat(64) });
+      fs.writeFileSync(path.join(dir, 'results_optional/extra.json'), JSON.stringify(row));
+      await expect(preflightRequiredPowerCurves(sql, dir, source, options)).rejects.toThrow(
+        'shrink',
+      );
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/packages/db/src/etl/required-power-curve.test.ts b/packages/db/src/etl/required-power-curve.test.ts
new file mode 100644
index 000000000..8dafa5033
--- /dev/null
+++ b/packages/db/src/etl/required-power-curve.test.ts
@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest';
+import {
+  assertCurvePreserved,
+  publishedCurve,
+  type CurvePoint,
+  type CurvePublication,
+} from './required-power-curve';
+import { powerPublicationPoint, stablePowerPointIdentity } from './power-publication';
+import { verifyRequiredPowerArtifacts } from './required-power-publication';
+import path from 'node:path';
+const golden = path.resolve(
+  import.meta.dirname,
+  '../../../../docs/fixtures/powerx-manifest-v2/artifacts',
+);
+const benchmark = verifyRequiredPowerArtifacts(golden, {
+  runId: 123,
+  runAttempt: 1,
+  headSha: 'b'.repeat(40),
+})[0];
+const identity = powerPublicationPoint(benchmark, '', { path: '', sha256: '' })!.identity;
+const policy: CurvePublication = { mode: 'incremental', replacement_scope: [] };
+function point(run: number, conc: number, extra: Partial<CurvePoint> = {}): CurvePoint {
+  return {
+    identity: { ...identity, conc },
+    image: 'same-image',
+    workflowRunId: run,
+    githubRunId: run,
+    runAttempt: 1,
+    date: `2026-09-${run.toString().padStart(2, '0')}`,
+    runStartedAt: null,
+    appendOnly: false,
+    ...extra,
+  };
+}
+describe('pure projected publication curve', () => {
+  it('rejects the old partial-sweep regression without altering input rows', () => {
+    const old = [
+      point(1, 1),
+      point(1, 16),
+      point(1, 64, {
+        identity: { ...identity, conc: 64, disagg: true, recipe_fingerprint: 'split-recipe' },
+      }),
+    ];
+    const proposed = [...old, point(2, 1)];
+    expect(() => assertCurvePreserved(old, proposed, policy)).toThrow('shrink');
+    expect([...publishedCurve(old).values()][0]).toHaveLength(3);
+  });
+  it('does not inherit append-only history with an incompatible image', () => {
+    const old = [point(1, 1), point(1, 16)];
+    expect(() =>
+      assertCurvePreserved(
+        old,
+        [...old, point(2, 32, { appendOnly: true, image: 'new-image' })],
+        policy,
+      ),
+    ).toThrow('shrink');
+  });
+  it('inherits only an uninterrupted same-image append-only chain', () => {
+    const old = [point(1, 1), point(1, 16), point(2, 32, { appendOnly: true })];
+    expect([...publishedCurve(old).values()][0].map((row) => row.identity.conc)).toEqual([
+      32, 1, 16,
+    ]);
+    expect(() =>
+      assertCurvePreserved(old, [...old, point(3, 64, { appendOnly: true })], policy),
+    ).not.toThrow();
+    expect(() => assertCurvePreserved(old, [...old, point(3, 64)], policy)).toThrow('shrink');
+  });
+  it('permits only the exact removed identities of the observed snapshot', () => {
+    const old = [point(1, 1), point(1, 16)];
+    const proposed = [...old, point(2, 1)];
+    const replacement: CurvePublication = {
+      mode: 'replacement',
+      replacement_scope: [
+        {
+          curve_scope: [...publishedCurve(old).keys()][0],
+          previous_snapshot_workflow_run_id: 1,
+          removed_point_identities: [stablePowerPointIdentity(old[1].identity)],
+        },
+      ],
+    };
+    expect(() => assertCurvePreserved(old, proposed, replacement)).not.toThrow();
+    for (const altered of [
+      { ...replacement.replacement_scope[0], previous_snapshot_workflow_run_id: 99 },
+      { ...replacement.replacement_scope[0], removed_point_identities: ['*'] },
+      { ...replacement.replacement_scope[0], curve_scope: '*' },
+    ])
+      expect(() =>
+        assertCurvePreserved(old, proposed, { mode: 'replacement', replacement_scope: [altered] }),
+      ).toThrow('shrink');
+  });
+  it('treats topology and offload as point identity inside one AgentX curve', () => {
+    const old = [point(1, 1)];
+    for (const altered of [
+      { prefill_tp: 2 },
+      { offload_mode: 'on' },
+      { recipe_fingerprint: 'other-recipe' },
+    ]) {
+      expect(() =>
+        assertCurvePreserved(
+          old,
+          [...old, point(2, 1, { identity: { ...identity, ...altered } })],
+          policy,
+        ),
+      ).toThrow('shrink');
+    }
+  });
+});
diff --git a/packages/db/src/etl/required-power-curve.ts b/packages/db/src/etl/required-power-curve.ts
new file mode 100644
index 000000000..1b2cdfbfa
--- /dev/null
+++ b/packages/db/src/etl/required-power-curve.ts
@@ -0,0 +1,287 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  benchmarkCurveScope,
+  type BenchmarkCurveInput,
+} from '@semianalysisai/inferencex-constants';
+import type { DbClient } from '../connection';
+import type { Sql } from './db-utils';
+import { REQUIRED_POWER_MANIFEST } from '../lib/ci-artifact-preparation';
+import { mapBenchmarkRow, type BenchmarkParams } from './benchmark-mapper';
+import { configCacheKey, type ConfigParams } from './config-cache';
+import { benchmarkPublicationIdentity, stablePowerPointIdentity } from './power-publication';
+import {
+  assertRequiredPowerPointsRetained,
+  verifyRequiredPowerArtifacts,
+  type RequiredPowerSource,
+} from './required-power-publication';
+import {
+  applyBenchmarkPointBackfill,
+  isBenchmarkPointPurged,
+  recordBackfilledPointIdentity,
+} from './run-overrides';
+import { createSkipTracker } from './skip-tracker';
+
+export interface CurvePoint {
+  identity: Record<string, unknown>;
+  image: string | null;
+  workflowRunId: number;
+  githubRunId: number;
+  runAttempt: number;
+  date: string;
+  runStartedAt: string | null;
+  appendOnly: boolean;
+}
+export interface CurveReplacement {
+  curve_scope: string;
+  previous_snapshot_workflow_run_id: number;
+  removed_point_identities: string[];
+}
+export interface CurvePublication {
+  mode: 'incremental' | 'replacement';
+  replacement_scope: CurveReplacement[];
+}
+
+function scope(point: CurvePoint): string {
+  return benchmarkCurveScope(point.identity as unknown as BenchmarkCurveInput);
+}
+
+/** Mirrors migration 014: latest attempt, scope-level snapshots and same-image append chains. */
+export function publishedCurve(points: readonly CurvePoint[]): Map<string, CurvePoint[]> {
+  const latestAttempts = new Map<number, number>();
+  for (const point of points)
+    latestAttempts.set(
+      point.githubRunId,
+      Math.max(latestAttempts.get(point.githubRunId) ?? 0, point.runAttempt),
+    );
+  const scopes = new Map<string, Map<string, CurvePoint[]>>();
+  for (const point of points) {
+    if (point.runAttempt !== latestAttempts.get(point.githubRunId)) continue;
+    const key = scope(point);
+    const runs = scopes.get(key) ?? new Map<string, CurvePoint[]>();
+    const runDate = JSON.stringify([point.workflowRunId, point.date]);
+    runs.set(runDate, [...(runs.get(runDate) ?? []), point]);
+    scopes.set(key, runs);
+  }
+  const result = new Map<string, CurvePoint[]>();
+  for (const [key, runs] of scopes) {
+    const ranked = [...runs.values()].sort(
+      (a, b) =>
+        b[0].date.localeCompare(a[0].date) ||
+        (b[0].runStartedAt ? Date.parse(b[0].runStartedAt) : -Infinity) -
+          (a[0].runStartedAt ? Date.parse(a[0].runStartedAt) : -Infinity) ||
+        b[0].workflowRunId - a[0].workflowRunId,
+    );
+    const rootImage = ranked[0][0].image;
+    const uniformImage = (rows: CurvePoint[]) =>
+      rootImage !== null && rows.every((row) => row.image === rootImage);
+    const selected = new Map<string, CurvePoint>();
+    for (let index = 0; index < ranked.length; index++) {
+      const current = ranked[index];
+      // SQL groups run/date for ranking, then joins every point in that run/scope.
+      for (const point of [...runs.values()]
+        .flat()
+        .filter((candidate) => candidate.workflowRunId === current[0].workflowRunId)) {
+        const id = stablePowerPointIdentity(point.identity);
+        if (!selected.has(id)) selected.set(id, point);
+      }
+      if (
+        !current[0].appendOnly ||
+        !uniformImage(current) ||
+        !ranked[index + 1] ||
+        !uniformImage(ranked[index + 1])
+      )
+        break;
+    }
+    result.set(key, [...selected.values()]);
+  }
+  return result;
+}
+
+function canonical(entries: CurveReplacement[]): string {
+  return JSON.stringify(
+    entries
+      .map((entry) => {
+        if (
+          typeof entry.curve_scope !== 'string' ||
+          !Number.isSafeInteger(entry.previous_snapshot_workflow_run_id) ||
+          !Array.isArray(entry.removed_point_identities) ||
+          entry.removed_point_identities.some((id) => typeof id !== 'string')
+        )
+          throw new Error('Required power: invalid exact replacement scope');
+        return { ...entry, removed_point_identities: [...entry.removed_point_identities].sort() };
+      })
+      .sort((a, b) => a.curve_scope.localeCompare(b.curve_scope)),
+  );
+}
+
+/** Exact lost identities bind any destructive authorization to one observed snapshot. */
+export function assertCurvePreserved(
+  existing: readonly CurvePoint[],
+  proposed: readonly CurvePoint[],
+  publication: CurvePublication,
+): void {
+  if (
+    !publication ||
+    !['incremental', 'replacement'].includes(publication.mode) ||
+    !Array.isArray(publication.replacement_scope)
+  )
+    throw new Error('Required power: invalid curve publication policy');
+  const before = publishedCurve(existing);
+  const after = publishedCurve(proposed);
+  const losses: CurveReplacement[] = [];
+  for (const [key, oldPoints] of before) {
+    const next = new Set(
+      (after.get(key) ?? []).map((point) => stablePowerPointIdentity(point.identity)),
+    );
+    const removed = oldPoints
+      .map((point) => stablePowerPointIdentity(point.identity))
+      .filter((identity) => !next.has(identity))
+      .sort();
+    if (removed.length > 0)
+      losses.push({
+        curve_scope: key,
+        previous_snapshot_workflow_run_id: oldPoints[0].workflowRunId,
+        removed_point_identities: removed,
+      });
+  }
+  if (publication.mode === 'incremental' && publication.replacement_scope.length > 0)
+    throw new Error('Required power: incremental publication cannot authorize replacement');
+  if (
+    (losses.length > 0 && publication.mode !== 'replacement') ||
+    canonical(losses) !== canonical(publication.replacement_scope)
+  )
+    throw new Error(
+      `Required power: publication would shrink the existing curve; exact replacement_scope required: ${JSON.stringify(losses)}`,
+    );
+}
+
+/** Read-only preflight; no config/workflow upsert, migration, or materialized-view refresh. */
+export async function preflightRequiredPowerCurves(
+  sql: DbClient | Sql,
+  root: string,
+  source: RequiredPowerSource,
+  options: { date: string; runStartedAt: string | null; appendOnly: boolean },
+): Promise<void> {
+  const required = verifyRequiredPowerArtifacts(root, source);
+  if (required.length === 0) return;
+  const manifest = JSON.parse(
+    fs.readFileSync(path.join(root, REQUIRED_POWER_MANIFEST, 'sweep_manifest.json'), 'utf8'),
+  );
+  const configs = await sql`SELECT * FROM configs`;
+  const configIds = new Map(
+    configs.map((row) => [
+      configCacheKey({
+        hardware: row.hardware,
+        framework: row.framework,
+        model: row.model,
+        precision: row.precision,
+        specMethod: row.spec_method,
+        disagg: row.disagg,
+        isMultinode: row.is_multinode,
+        prefillTp: row.prefill_tp,
+        prefillEp: row.prefill_ep,
+        prefillDpAttn: row.prefill_dp_attention,
+        prefillNumWorkers: row.prefill_num_workers,
+        decodeTp: row.decode_tp,
+        decodeEp: row.decode_ep,
+        decodeDpAttn: row.decode_dp_attention,
+        decodeNumWorkers: row.decode_num_workers,
+        numPrefillGpu: row.num_prefill_gpu,
+        numDecodeGpu: row.num_decode_gpu,
+      } as ConfigParams),
+      Number(row.id),
+    ]),
+  );
+  const incoming = new Map<string, BenchmarkParams>();
+  const backfilled = new Map<string, string>();
+  for (const name of fs.readdirSync(root)) {
+    if (
+      (!name.startsWith('bmk_') && !name.startsWith('results_')) ||
+      !fs.statSync(path.join(root, name)).isDirectory()
+    )
+      continue;
+    for (const file of fs
+      .readdirSync(path.join(root, name))
+      .filter((candidateName) => candidateName.endsWith('.json'))) {
+      const data = JSON.parse(fs.readFileSync(path.join(root, name, file), 'utf8'));
+      for (const raw of Array.isArray(data) ? data : [data]) {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
+        const mapped = mapBenchmarkRow(raw, createSkipTracker(), undefined, source.runId);
+        if (!mapped) continue;
+        // A config not present yet cannot match a config-id-scoped purge/backfill.
+        const point = { ...mapped, configId: configIds.get(configCacheKey(mapped.config)) ?? -1 };
+        if (isBenchmarkPointPurged(source.runId, source.runAttempt, point)) continue;
+        const applied = applyBenchmarkPointBackfill(source.runId, source.runAttempt, point);
+        recordBackfilledPointIdentity(backfilled, applied.sourceIdentity, applied.desiredIdentity);
+        incoming.set(
+          stablePowerPointIdentity(benchmarkPublicationIdentity(applied.point)),
+          applied.point,
+        );
+      }
+    }
+  }
+  assertRequiredPowerPointsRetained(required, [...incoming.values()]);
+  const models = [...new Set([...incoming.values()].map((point) => point.config.model))];
+  const rows = await sql`
+    SELECT c.*, br.benchmark_type, br.isl, br.osl, br.conc, br.offload_mode,
+      br.recipe_fingerprint, br.image, br.date::text AS point_date,
+      wr.id AS workflow_run_id, wr.github_run_id, wr.run_attempt,
+      wr.run_started_at::text, wr.append_only
+    FROM benchmark_results br
+    JOIN configs c ON c.id = br.config_id
+    JOIN latest_workflow_runs wr ON wr.id = br.workflow_run_id
+    WHERE br.error IS NULL AND (c.model = ANY(${models}) OR wr.github_run_id = ${source.runId})`;
+  const stored = rows.map((row): CurvePoint => ({
+    identity: row,
+    image: row.image as string | null,
+    workflowRunId: Number(row.workflow_run_id),
+    githubRunId: Number(row.github_run_id),
+    runAttempt: Number(row.run_attempt),
+    date: String(row.point_date),
+    runStartedAt: row.run_started_at as string | null,
+    appendOnly: Boolean(row.append_only),
+  }));
+  const attempts =
+    await sql`SELECT id, run_attempt FROM workflow_runs WHERE github_run_id = ${source.runId}`;
+  const sameAttempt = attempts.find((row) => Number(row.run_attempt) === source.runAttempt);
+  // New serial IDs sort after stored IDs. A concurrent ingest is outside this pure preflight boundary.
+  const workflowRunId = sameAttempt ? Number(sameAttempt.id) : Number.MAX_SAFE_INTEGER;
+  const newPoints = [...incoming.values()].map((point): CurvePoint => ({
+    identity: benchmarkPublicationIdentity(point),
+    image: point.image,
+    workflowRunId,
+    githubRunId: source.runId,
+    runAttempt: source.runAttempt,
+    date:
+      stored.find(
+        (existing) =>
+          existing.workflowRunId === workflowRunId &&
+          stablePowerPointIdentity(existing.identity) ===
+            stablePowerPointIdentity(benchmarkPublicationIdentity(point)),
+      )?.date ?? options.date,
+    runStartedAt: options.runStartedAt,
+    appendOnly: options.appendOnly,
+  }));
+  const touched = new Set(
+    [...newPoints, ...stored.filter((point) => point.githubRunId === source.runId)].map(scope),
+  );
+  const existing = stored.filter((point) => touched.has(scope(point)));
+  const maxAttempt = Math.max(source.runAttempt, ...attempts.map((row) => Number(row.run_attempt)));
+  const changedIds = new Set(newPoints.map((point) => stablePowerPointIdentity(point.identity)));
+  const proposed = existing
+    .filter(
+      (point) =>
+        point.githubRunId !== source.runId ||
+        (point.runAttempt === maxAttempt &&
+          (source.runAttempt !== maxAttempt ||
+            !changedIds.has(stablePowerPointIdentity(point.identity)))),
+    )
+    .map((point) =>
+      point.githubRunId === source.runId && point.runAttempt === source.runAttempt
+        ? { ...point, runStartedAt: options.runStartedAt, appendOnly: options.appendOnly }
+        : point,
+    );
+  if (source.runAttempt === maxAttempt) proposed.push(...newPoints);
+  assertCurvePreserved(existing, proposed, manifest.publication);
+}
diff --git a/packages/db/src/etl/required-power-publication.test.ts b/packages/db/src/etl/required-power-publication.test.ts
index b51b8e526..ec1822234 100644
--- a/packages/db/src/etl/required-power-publication.test.ts
+++ b/packages/db/src/etl/required-power-publication.test.ts
@@ -1,314 +1,200 @@
+import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
-import agenticMatrix from './__fixtures__/required-power-agentic-matrix.json';
 import {
   assertRequiredPowerPointsRetained,
   verifyRequiredPowerArtifacts,
-  verifyRequiredPowerPublication,
 } from './required-power-publication';
-import {
-  isBenchmarkPointPurged,
-  PURGED_BENCHMARK_POINTS,
-  type PurgedBenchmarkPoint,
-} from './run-overrides';
 
-// Ordinary planner output for Qwen3.5/H100 8K1K; fingerprints include the full recipe.
-const fingerprint = 'fa0645b4dec181eafda7472c891e90d9a5bf7bad7ee764aa0fdcc41ff841adf1';
-const source = { runId: 123, runAttempt: 2, headSha: 'abc123' };
-const required = {
-  'recipe-fingerprint': fingerprint,
-  conc: 1,
-  isl: 8192,
-  osl: 1024,
-  'require-power': true,
-};
-const row = {
-  infmax_model_prefix: 'qwen3.5',
-  hw: 'h100',
-  framework: 'sglang',
-  precision: 'fp8',
-  recipe_fingerprint: fingerprint,
-  conc: 1,
-  isl: 8192,
-  osl: 1024,
-  tp: 8,
-  ep: 1,
-  power_valid: 1,
-  power_metric_schema_version: 2,
-  avg_power_w: 500,
-  avg_total_gpu_power_w: 4000,
-  total_gpu_energy_j: 8000,
-  joules_per_output_token: 2,
-};
-const manifest = (entries = [required]) => ({
-  head: source.headSha,
-  'run-id': source.runId,
-  'run-attempt': source.runAttempt,
-  // full-sweep is a Klaud policy field: fail-fast runs may legitimately set it false.
-  'full-sweep': false,
-  matrix: {
-    single_node: { '8k1k': entries },
-    multi_node: {},
-    evals: [{ ...required, 'eval-only': true }],
-  },
-});
-const artifacts = (rows: unknown[] = [row]) => [{ path: 'bmk_qwen/agg.json', rows }];
+const golden = path.resolve(
+  import.meta.dirname,
+  '../../../../docs/fixtures/powerx-manifest-v2/artifacts',
+);
+const source = { runId: 123, runAttempt: 1, headSha: 'b'.repeat(40) };
 const dirs: string[] = [];
+function fixture() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-contract-'));
+  dirs.push(dir);
+  fs.cpSync(golden, dir, { recursive: true });
+  return dir;
+}
+function json(dir: string, file: string): any {
+  return JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+}
+function write(dir: string, file: string, value: unknown) {
+  fs.writeFileSync(path.join(dir, file), JSON.stringify(value));
+}
+const manifestPath = 'required-power-sweep-manifest/sweep_manifest.json';
+const benchmarkPath = 'bmk_agentic_golden/agg.json';
+const auditPath = 'agentic_golden/power_validation.json';
+function changeManifest(dir: string, edit: (manifest: any) => void) {
+  const manifest = json(dir, manifestPath);
+  edit(manifest);
+  write(dir, manifestPath, manifest);
+}
+function changeArtifact(dir: string, file: string, edit: (value: any) => void) {
+  const value = json(dir, file);
+  edit(value);
+  write(dir, file, value);
+  changeManifest(dir, (manifest) => {
+    for (const point of manifest.points)
+      for (const artifact of point.artifacts)
+        if (artifact.path === file)
+          artifact.sha256 = createHash('sha256')
+            .update(fs.readFileSync(path.join(dir, file)))
+            .digest('hex');
+  });
+}
+function multinodeFixture() {
+  const dir = fixture();
+  const extras: Record<string, unknown> = {
+    'power_audit_golden/power/samples.csv':
+      'timestamp_unix,hostname,gpu_uuid,power_w\n1700000000,prefill,GPU-p,200\n',
+    'power_audit_golden/power/manifest.json': { status: 'complete', publication_valid: true },
+    'power_audit_golden/power/windows/point.json': {
+      benchmark_start_time_unix: 1700000000,
+      benchmark_end_time_unix: 1700000002,
+    },
+  };
+  for (const [file, value] of Object.entries(extras)) {
+    fs.mkdirSync(path.dirname(path.join(dir, file)), { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, file),
+      typeof value === 'string' ? value : JSON.stringify(value),
+    );
+  }
+  changeArtifact(dir, benchmarkPath, (row) =>
+    Object.assign(row, {
+      disagg: true,
+      is_multinode: true,
+      num_gpus: 2,
+      num_prefill_gpu: 1,
+      num_decode_gpu: 1,
+      prefill_gpu_energy_j: 400,
+      decode_gpu_energy_j: 600,
+      prefill_joules_per_input_token: 1,
+      decode_joules_per_output_token: 1,
+    }),
+  );
+  changeArtifact(dir, auditPath, (audit) =>
+    Object.assign(audit, {
+      expected_gpu_count: 2,
+      observed_gpu_count: 2,
+      per_gpu_energy_j: { 'prefill/GPU-p': 400, 'decode/GPU-d': 600 },
+      per_gpu_role: { 'prefill/GPU-p': 'prefill', 'decode/GPU-d': 'decode' },
+    }),
+  );
+  changeManifest(dir, (manifest) => {
+    const entry = manifest.matrix.single_node.agentic[0];
+    Object.assign(entry, { disagg: true, 'num-gpus': 2, 'node-count': 2 });
+    manifest.matrix = { single_node: {}, multi_node: { agentic: [entry] } };
+    const point = manifest.points[0];
+    Object.assign(point.topology, {
+      disagg: true,
+      is_multinode: true,
+      num_gpus: 2,
+      num_prefill_gpu: 1,
+      num_decode_gpu: 1,
+    });
+    point.devices = [
+      { node: 'prefill', gpu_uuid: 'GPU-p', role: 'prefill', energy_j: 400 },
+      { node: 'decode', gpu_uuid: 'GPU-d', role: 'decode', energy_j: 600 },
+    ];
+    for (const file of Object.keys(extras))
+      point.artifacts.push({
+        path: file,
+        sha256: createHash('sha256')
+          .update(fs.readFileSync(path.join(dir, file)))
+          .digest('hex'),
+        validation_state: 'valid',
+      });
+  });
+  return dir;
+}
 afterEach(() => {
   for (const dir of dirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
 });
 
-describe('required power publication preflight', () => {
-  it('matches the canonical AgentX users value instead of a conflicting raw conc', () => {
-    const scope = {
-      ...manifest(),
-      matrix: { single_node: { agentic: [required] }, multi_node: {} },
-    };
-    const conflicting = { ...row, scenario_type: 'agentic-coding', conc: 1, users: 2 };
-    expect(() => verifyRequiredPowerPublication(scope, artifacts([conflicting]), source)).toThrow(
-      'missing benchmark point',
-    );
-    expect(
-      verifyRequiredPowerPublication(
-        scope,
-        artifacts([{ ...conflicting, conc: 2, users: 1 }]),
-        source,
-      ),
-    ).toHaveLength(1);
+describe('required power publication contract', () => {
+  it('fails missing required manifests even when changelog metadata is also missing', () => {
+    const dir = fixture();
+    fs.rmSync(path.join(dir, 'required-power-sweep-manifest'), { recursive: true });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('sweep manifest missing');
+    fs.rmSync(path.join(dir, 'changelog-metadata'), { recursive: true });
+    expect(() => verifyRequiredPowerArtifacts(dir, source, true)).toThrow('sweep manifest missing');
+    expect(verifyRequiredPowerArtifacts(dir, source)).toEqual([]);
   });
-
-  it('accepts exact ordinary source points, including fail-fast manifests and identical aggregate copies', () => {
-    expect(
-      verifyRequiredPowerPublication(
-        manifest(),
-        [...artifacts(), { path: 'results_bmk/agg_bmk.json', rows: [{ ...row }] }],
-        source,
-      ),
-    ).toHaveLength(1);
+  it('rejects hash mismatches and explicit invalid evidence', () => {
+    const dir = fixture();
+    fs.appendFileSync(path.join(dir, 'agentic_golden/gpu_metrics.csv'), '\n');
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('hash');
+    const invalid = fixture();
+    changeManifest(invalid, (manifest) => {
+      manifest.points[0].artifacts[0].validation_state = 'invalid';
+    });
+    expect(() => verifyRequiredPowerArtifacts(invalid, source)).toThrow('validation');
   });
-
-  it('fails required coverage after a point purge even when an optional point is retained', () => {
-    const requiredPoints = verifyRequiredPowerPublication(manifest(), artifacts(), source);
-    const candidates = [requiredPoints[0], { ...requiredPoints[0], conc: 2 }];
-    const purged: PurgedBenchmarkPoint = {
-      githubRunId: source.runId,
-      runAttempt: source.runAttempt,
-      configId: 999999,
-      benchmarkType: 'single_turn',
-      isl: 8192,
-      osl: 1024,
-      conc: 1,
-      offloadMode: 'off',
-      recipeFingerprint: fingerprint,
-    };
-    const registry = PURGED_BENCHMARK_POINTS as PurgedBenchmarkPoint[];
-    registry.push(purged);
-    try {
-      const retained = candidates.filter(
-        (point) =>
-          !isBenchmarkPointPurged(source.runId, source.runAttempt, {
-            ...point,
-            configId: purged.configId,
-          }),
-      );
-      expect(retained.map((point) => point.conc)).toEqual([2]);
-      expect(() => assertRequiredPowerPointsRetained(requiredPoints, retained)).toThrow(
-        'missing benchmark point after ingest',
-      );
-      expect(isBenchmarkPointPurged(source.runId, source.runAttempt, purged)).toBe(true);
-      expect(() => assertRequiredPowerPointsRetained([], retained)).not.toThrow();
-    } finally {
-      registry.splice(registry.indexOf(purged), 1);
-    }
-  });
-
-  it('accepts retained aggregate copies but cannot replace a filtered required point with another identity', () => {
-    const requiredPoints = verifyRequiredPowerPublication(manifest(), artifacts(), source);
-    expect(() =>
-      assertRequiredPowerPointsRetained(requiredPoints, [
-        requiredPoints[0],
-        { ...requiredPoints[0] },
-      ]),
-    ).not.toThrow();
-    expect(() =>
-      assertRequiredPowerPointsRetained(requiredPoints, [
-        { ...requiredPoints[0], recipeFingerprint: 'other-recipe' },
-      ]),
-    ).toThrow('missing benchmark point after ingest');
-  });
-
-  it('fails before ingestion when any declared concurrency, fingerprint or scenario is missing', () => {
-    for (const candidate of [
-      [],
-      [{ ...row, conc: 2 }],
-      [{ ...row, recipe_fingerprint: '' }],
-      [{ ...row, isl: 1024 }],
-    ]) {
-      expect(() =>
-        verifyRequiredPowerPublication(manifest(), artifacts(candidate), source),
-      ).toThrow('missing benchmark point');
-    }
-  });
-
-  it('does not retroactively require optional matrix points or legacy results', () => {
-    const scope = manifest([required, { ...required, conc: 2, 'require-power': false }]);
-    expect(
-      verifyRequiredPowerPublication(scope, artifacts([row, { conc: 2, power_valid: 0 }]), source),
-    ).toHaveLength(1);
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'required-power-'));
-    dirs.push(dir);
-    expect(verifyRequiredPowerArtifacts(dir, { ...source, headSha: null })).toHaveLength(0);
+  it('rejects a measured zero energy', () => {
+    const dir = fixture();
+    changeArtifact(dir, benchmarkPath, (rows) => {
+      rows.total_gpu_energy_j = 0;
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow(
+      'total_gpu_energy_j must be finite and positive',
+    );
   });
-
-  it.each([
-    { power_valid: 0 },
-    { power_valid: '1' },
-    { power_metric_schema_version: '2' },
-    { avg_power_w: 0 },
-    { avg_total_gpu_power_w: -1 },
-    { total_gpu_energy_j: NaN },
-    { joules_per_output_token: Infinity },
-    { joules_per_output_token: undefined },
-    { benchmark_outcome: { status: 'failed' } },
-  ])('rejects invalid required measurements: %j', (change) => {
-    expect(() =>
-      verifyRequiredPowerPublication(manifest(), artifacts([{ ...row, ...change }]), source),
-    ).toThrow('Required power:');
+  it('does not replace canonical AgentX users with a conflicting raw conc', () => {
+    const dir = fixture();
+    changeArtifact(dir, benchmarkPath, (rows) => {
+      rows.conc = 1;
+      rows.users = 2;
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing benchmark point');
   });
-
-  it('rejects conflicting copies and duplicate rows inside either source or aggregate file', () => {
-    expect(() =>
-      verifyRequiredPowerPublication(
-        manifest(),
-        [...artifacts(), { path: 'results_bmk/agg.json', rows: [{ ...row, avg_power_w: 501 }] }],
-        source,
-      ),
-    ).toThrow('conflicting');
-    expect(() => verifyRequiredPowerPublication(manifest(), artifacts([row, row]), source)).toThrow(
-      'duplicate',
+  it('requires both prefill and decode physical evidence and matching role energy', () => {
+    const dir = multinodeFixture();
+    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
+    changeManifest(dir, (manifest) => {
+      manifest.points[0].devices.pop();
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing physical GPU');
+    const mismatched = multinodeFixture();
+    changeArtifact(mismatched, benchmarkPath, (row) => {
+      row.prefill_gpu_energy_j = 100;
+    });
+    expect(() => verifyRequiredPowerArtifacts(mismatched, source)).toThrow(
+      'prefill energy differs',
     );
-    expect(() =>
-      verifyRequiredPowerPublication(
-        manifest(),
-        [...artifacts(), { path: 'results_bmk/agg.json', rows: [row, row] }],
-        source,
-      ),
-    ).toThrow('duplicate');
   });
-
-  it('rejects stale source run, attempt or head, an empty scope, and duplicate planned points', () => {
-    for (const changed of [
-      { runId: 999 },
-      { runAttempt: 1 },
-      { headSha: 'stale' },
-      { headSha: null },
-    ])
-      expect(() =>
-        verifyRequiredPowerPublication(manifest(), artifacts(), { ...source, ...changed }),
-      ).toThrow('manifest source');
-    expect(() => verifyRequiredPowerPublication(manifest([]), [], source)).toThrow('no required');
-    expect(() =>
-      verifyRequiredPowerPublication(manifest([required, required]), artifacts(), source),
-    ).toThrow('duplicate matrix');
+  it('rejects invalid sidecar verdict and device energy disagreement despite valid hashes', () => {
+    const dir = fixture();
+    changeArtifact(dir, auditPath, (audit) => {
+      audit.power_valid = false;
+    });
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('invalid audit');
+    const other = fixture();
+    changeManifest(other, (manifest) => {
+      manifest.points[0].devices[0].energy_j = 2;
+    });
+    expect(() => verifyRequiredPowerArtifacts(other, source)).toThrow('differs from audit');
   });
-
-  it('reuses the declared scope from a successful earlier attempt of the same run and head', () => {
-    expect(
-      verifyRequiredPowerPublication({ ...manifest(), 'run-attempt': 1 }, artifacts(), source),
-    ).toHaveLength(1);
-  });
-
-  it('expands real ordinary AgentX planner concurrency arrays and fixed-sequence batches', () => {
-    // First B200 recipe from the ordinary Kimi K3 required-power planner, 2026-09-13.
-    const entry = agenticMatrix.multi_node.agentic[0];
-    expect(
-      verifyRequiredPowerPublication(
-        { ...manifest(), matrix: agenticMatrix },
-        artifacts([
-          {
-            ...row,
-            infmax_model_prefix: 'kimik3',
-            hw: 'b200',
-            framework: 'dynamo-vllm',
-            precision: 'fp4',
-            recipe_fingerprint: entry['recipe-fingerprint'],
-            conc: entry.conc[0],
-            scenario_type: 'agentic-coding',
-          },
-        ]),
-        source,
-      ),
-    ).toHaveLength(1);
-    const fixedMatrix = {
-      single_node: {},
-      multi_node: { '8k1k': [{ ...required, conc: [1, 2, 4] }] },
-    };
-    expect(
-      verifyRequiredPowerPublication(
-        { ...manifest(), matrix: fixedMatrix },
-        artifacts([1, 2, 4].map((conc) => ({ ...row, conc }))),
-        source,
-      ),
-    ).toHaveLength(3);
-    expect(() =>
-      verifyRequiredPowerPublication({ ...manifest(), matrix: fixedMatrix }, artifacts(), source),
-    ).toThrow('missing benchmark');
+  it('accepts identical aggregate copies but rejects conflicting duplicate rows', () => {
+    const dir = fixture();
+    fs.mkdirSync(path.join(dir, 'results_bmk'));
+    fs.copyFileSync(path.join(dir, benchmarkPath), path.join(dir, 'results_bmk/agg.json'));
+    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
+    const rows = json(dir, benchmarkPath);
+    rows.avg_power_w = 501;
+    write(dir, 'results_bmk/agg.json', rows);
+    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('conflicting');
   });
-
-  it('accepts AgentX and requires both energy roles only for a declared disaggregated recipe', () => {
-    const scope = manifest();
-    const agentic = { ...required, 'scenario-type': 'agentic-coding', disagg: true };
-    const agenticManifest = {
-      ...scope,
-      matrix: { single_node: {}, multi_node: { agentic: [agentic] } },
-    };
-    const split = {
-      ...row,
-      isl: undefined,
-      osl: undefined,
-      scenario_type: 'agentic-coding',
-      disagg: true,
-      prefill_gpu_energy_j: 3000,
-      decode_gpu_energy_j: 5000,
-      prefill_joules_per_input_token: 1,
-      decode_joules_per_output_token: 1.25,
-    };
-    expect(
-      verifyRequiredPowerPublication(agenticManifest, artifacts([split]), source),
-    ).toHaveLength(1);
+  it('retains every required identity after local purges and backfills', () => {
+    const required = verifyRequiredPowerArtifacts(golden, source);
     expect(() =>
-      verifyRequiredPowerPublication(
-        agenticManifest,
-        artifacts([{ ...split, decode_gpu_energy_j: undefined }]),
-        source,
-      ),
-    ).toThrow('decode_gpu_energy_j');
-    const aggregate = {
-      ...agenticManifest,
-      matrix: { single_node: {}, multi_node: { agentic: [{ ...agentic, disagg: false }] } },
-    };
-    expect(
-      verifyRequiredPowerPublication(
-        aggregate,
-        artifacts([{ ...row, scenario_type: 'agentic-coding' }]),
-        source,
-      ),
-    ).toHaveLength(1);
-  });
-
-  it('reads the producer artifact and checks all rows before the ingest entry point writes', () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'required-power-'));
-    dirs.push(dir);
-    fs.mkdirSync(path.join(dir, 'required-power-sweep-manifest'));
-    fs.writeFileSync(
-      path.join(dir, 'required-power-sweep-manifest', 'sweep_manifest.json'),
-      JSON.stringify(manifest()),
-    );
-    expect(() => verifyRequiredPowerArtifacts(dir, source)).toThrow('missing benchmark');
-    fs.mkdirSync(path.join(dir, 'bmk_qwen'));
-    fs.writeFileSync(path.join(dir, 'bmk_qwen', 'agg.json'), JSON.stringify(row));
-    expect(verifyRequiredPowerArtifacts(dir, source)).toHaveLength(1);
+      assertRequiredPowerPointsRetained(required, [{ ...required[0], conc: 2 }]),
+    ).toThrow('missing benchmark point');
+    expect(() => assertRequiredPowerPointsRetained(required, required)).not.toThrow();
   });
 });
diff --git a/packages/db/src/etl/required-power-publication.ts b/packages/db/src/etl/required-power-publication.ts
index 170b3e926..d8f995b8a 100644
--- a/packages/db/src/etl/required-power-publication.ts
+++ b/packages/db/src/etl/required-power-publication.ts
@@ -1,9 +1,11 @@
 import fs from 'node:fs';
+import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { mapBenchmarkRow, type BenchmarkParams } from './benchmark-mapper';
 import { createSkipTracker } from './skip-tracker';
-import { REQUIRED_POWER_MANIFEST } from '../lib/ci-artifact-preparation';
+import { configCacheKey } from './config-cache';
+import { CHANGELOG_ARTIFACT_NAME, REQUIRED_POWER_MANIFEST } from '../lib/ci-artifact-preparation';
 
 type JsonRow = Record<string, unknown>;
 export interface RequiredPowerSource {
@@ -14,6 +16,7 @@ export interface RequiredPowerSource {
 export interface BenchmarkArtifactRows {
   path: string;
   rows: unknown[];
+  contents?: Buffer | string;
 }
 
 function object(value: unknown, label: string): JsonRow {
@@ -45,11 +48,24 @@ export function assertRequiredPowerPointsRetained(
   required: readonly BenchmarkParams[],
   retained: readonly BenchmarkParams[],
 ): void {
-  const present = new Set(retained.map(mappedIdentity));
+  const retainedIdentity = (row: BenchmarkParams) =>
+    JSON.stringify([configCacheKey(row.config), row.offloadMode, mappedIdentity(row)]);
+  const present = new Map(retained.map((row) => [retainedIdentity(row), row]));
   for (const row of required) {
-    const key = mappedIdentity(row);
+    const key = retainedIdentity(row);
     if (!present.has(key))
       throw new Error(`Required power: missing benchmark point after ingest ${key}`);
+    const actual = present.get(key)!;
+    for (const field of [
+      'power_valid',
+      'power_metric_schema_version',
+      'avg_power_w',
+      'avg_total_gpu_power_w',
+      'total_gpu_energy_j',
+      'joules_per_output_token',
+    ])
+      if (actual.metrics[field] !== row.metrics[field])
+        throw new Error(`Required power: ${field} changed before ingest for ${key}`);
   }
 }
 
@@ -60,20 +76,52 @@ export function verifyRequiredPowerPublication(
   source: RequiredPowerSource,
 ): BenchmarkParams[] {
   const manifest = object(manifestValue, 'sweep manifest');
+  if (manifest['schema-version'] !== 2)
+    throw new Error('Required power: incompatible manifest schema-version (expected 2)');
+  const publication = object(manifest.publication, 'publication policy');
+  if (
+    !['incremental', 'replacement'].includes(String(publication.mode)) ||
+    !Array.isArray(publication.replacement_scope) ||
+    (publication.mode === 'incremental' && publication.replacement_scope.length > 0)
+  )
+    throw new Error('Required power: invalid publication policy');
+  const replacementScopes = new Set<string>();
+  for (const value of publication.replacement_scope) {
+    const replacement = object(value, 'exact replacement scope');
+    if (
+      typeof replacement.curve_scope !== 'string' ||
+      !replacement.curve_scope ||
+      replacementScopes.has(replacement.curve_scope) ||
+      !Number.isSafeInteger(replacement.previous_snapshot_workflow_run_id) ||
+      Number(replacement.previous_snapshot_workflow_run_id) <= 0 ||
+      !Array.isArray(replacement.removed_point_identities) ||
+      replacement.removed_point_identities.length === 0 ||
+      replacement.removed_point_identities.some((id) => typeof id !== 'string' || !id) ||
+      new Set(replacement.removed_point_identities).size !==
+        replacement.removed_point_identities.length
+    )
+      throw new Error('Required power: invalid exact replacement scope');
+    replacementScopes.add(replacement.curve_scope);
+  }
   const declaredAttempt = manifest['run-attempt'];
   if (
     manifest['run-id'] !== source.runId ||
+    !Number.isSafeInteger(source.runId) ||
+    source.runId <= 0 ||
+    !Number.isSafeInteger(source.runAttempt) ||
+    source.runAttempt <= 0 ||
     typeof declaredAttempt !== 'number' ||
     !Number.isSafeInteger(declaredAttempt) ||
     declaredAttempt <= 0 ||
     declaredAttempt > source.runAttempt ||
     !source.headSha ||
+    !/^[a-f0-9]{40}$/u.test(source.headSha) ||
     manifest.head !== source.headSha
   )
     throw new Error('Required power: manifest source run, attempt or head does not match');
 
   const matrix = object(manifest.matrix, 'sweep matrix');
-  const expected = new Map<string, boolean>();
+  const expected = new Map<string, JsonRow>();
   for (const topology of ['single_node', 'multi_node']) {
     const buckets = object(matrix[topology], topology);
     for (const [scenario, entries] of Object.entries(buckets)) {
@@ -99,7 +147,7 @@ export function verifyRequiredPowerPublication(
             osl,
           );
           if (expected.has(key)) throw new Error(`Required power: duplicate matrix point ${key}`);
-          expected.set(key, row.disagg === true);
+          expected.set(key, { ...row, matrixTopology: topology });
         }
       }
     }
@@ -140,7 +188,7 @@ export function verifyRequiredPowerPublication(
         'total_gpu_energy_j',
         'joules_per_output_token',
       ];
-      if (expected.get(key))
+      if (expected.get(key)?.disagg === true)
         fields.push(
           'prefill_gpu_energy_j',
           'decode_gpu_energy_j',
@@ -158,6 +206,7 @@ export function verifyRequiredPowerPublication(
   for (const key of expected.keys()) {
     if (!seen.has(key)) throw new Error(`Required power: missing benchmark point ${key}`);
   }
+  verifyPointEvidence(manifest, expected, seen, artifacts);
   return [...seen.values()].map(({ point }) => point);
 }
 
@@ -165,9 +214,21 @@ export function verifyRequiredPowerPublication(
 export function verifyRequiredPowerArtifacts(
   root: string,
   source: RequiredPowerSource,
+  required = false,
 ): BenchmarkParams[] {
   const manifestDir = path.join(root, REQUIRED_POWER_MANIFEST);
-  if (!fs.existsSync(manifestDir)) return [];
+  if (!fs.existsSync(manifestDir)) {
+    if (required) throw new Error('Required power: sweep manifest missing for required dispatch');
+    const metadataDir = path.join(root, CHANGELOG_ARTIFACT_NAME);
+    if (fs.existsSync(metadataDir)) {
+      for (const name of fs.readdirSync(metadataDir).filter((file) => file.endsWith('.json'))) {
+        const metadata = JSON.parse(fs.readFileSync(path.join(metadataDir, name), 'utf8'));
+        if (metadata?.['require-power'] === true)
+          throw new Error('Required power: sweep manifest missing for required changelog scope');
+      }
+    }
+    return [];
+  }
   const manifest = JSON.parse(
     fs.readFileSync(path.join(manifestDir, 'sweep_manifest.json'), 'utf8'),
   );
@@ -178,8 +239,28 @@ export function verifyRequiredPowerArtifacts(
     if (!fs.statSync(dir).isDirectory()) continue;
     for (const file of fs.readdirSync(dir)) {
       if (!file.endsWith('.json')) continue;
-      const data = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
-      artifacts.push({ path: path.join(name, file), rows: Array.isArray(data) ? data : [data] });
+      const contents = fs.readFileSync(path.join(dir, file));
+      const data = JSON.parse(contents.toString('utf8'));
+      artifacts.push({
+        path: path.join(name, file),
+        rows: Array.isArray(data) ? data : [data],
+        contents,
+      });
+    }
+  }
+  for (const pointValue of Array.isArray(manifest.points) ? manifest.points : []) {
+    const point = object(pointValue, 'point');
+    if (!Array.isArray(point.artifacts)) throw new Error('Required power: missing point artifacts');
+    for (const value of point.artifacts) {
+      const artifact = object(value, 'artifact');
+      const relative = safeArtifactPath(artifact.path);
+      const file = path.join(root, relative);
+      if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+        throw new Error(`Required power: missing required artifact ${relative}`);
+      if (!fs.realpathSync(file).startsWith(`${fs.realpathSync(root)}${path.sep}`))
+        throw new Error(`Required power: artifact escapes bundle ${relative}`);
+      if (!artifacts.some((item) => item.path === relative))
+        artifacts.push({ path: relative, rows: [], contents: fs.readFileSync(file) });
     }
   }
   const points = verifyRequiredPowerPublication(manifest, artifacts, source);
@@ -189,3 +270,424 @@ export function verifyRequiredPowerArtifacts(
   );
   return points;
 }
+
+function digest(artifact: BenchmarkArtifactRows): string {
+  return createHash('sha256').update(artifact.contents!).digest('hex');
+}
+
+function safeArtifactPath(value: unknown): string {
+  if (
+    typeof value !== 'string' ||
+    !value ||
+    value.includes('\\') ||
+    path.posix.isAbsolute(value) ||
+    value.split('/').some((part) => !part || part === '.' || part === '..')
+  )
+    throw new Error('Required power: invalid artifact path');
+  return value;
+}
+
+function positive(value: unknown, label: string): number {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+    throw new Error(`Required power: ${label} must be finite and positive`);
+  return value;
+}
+
+function nonempty(value: unknown, label: string): string {
+  if (typeof value !== 'string' || !value.trim())
+    throw new Error(`Required power: missing ${label}`);
+  return value;
+}
+
+function verifyPointEvidence(
+  manifest: JsonRow,
+  expected: Map<string, JsonRow>,
+  seen: Map<string, { row: JsonRow; path: string; point: BenchmarkParams }>,
+  artifacts: readonly BenchmarkArtifactRows[],
+): void {
+  if (!Array.isArray(manifest.points) || manifest.points.length !== expected.size)
+    throw new Error('Required power: point manifest does not cover the exact required matrix');
+  const verified = new Set<string>();
+  const files = new Map(artifacts.map((artifact) => [artifact.path, artifact]));
+  for (const declaredValue of manifest.points) {
+    const declared = object(declaredValue, 'point');
+    const id = object(declared.identity, 'point identity');
+    const key = identity(
+      id.recipe_fingerprint,
+      id.concurrency,
+      String(id.benchmark_type),
+      id.isl,
+      id.osl,
+    );
+    const matched = seen.get(key);
+    const matrix = expected.get(key);
+    if (!matched || !matrix || verified.has(key))
+      throw new Error(`Required power: unexpected or duplicate manifest point ${key}`);
+    verified.add(key);
+    if (nonempty(declared.config_key, 'config_key') !== matrix['exp-name'])
+      throw new Error(`Required power: config_key differs from required matrix for ${key}`);
+    const { row, point } = matched;
+    for (const [field, rawField] of [
+      ['model', 'infmax_model_prefix'],
+      ['hardware', 'hw'],
+      ['framework', 'framework'],
+      ['precision', 'precision'],
+    ]) {
+      if (
+        nonempty(id[field], field) !==
+        (row[rawField] ?? (field === 'model' ? row.model : undefined))
+      )
+        throw new Error(`Required power: ${field} identity differs from benchmark for ${key}`);
+    }
+    for (const [field, matrixField] of [
+      ['model', 'model-prefix'],
+      ['hardware', 'runner'],
+      ['framework', 'framework'],
+      ['precision', 'precision'],
+    ]) {
+      if (id[field] !== matrix[matrixField])
+        throw new Error(
+          `Required power: ${field} identity differs from required matrix for ${key}`,
+        );
+    }
+    const topology = object(declared.topology, 'point topology');
+    if (
+      topology.disagg !== point.config.disagg ||
+      topology.is_multinode !== point.config.isMultinode ||
+      topology.disagg !== (matrix.disagg === true) ||
+      topology.is_multinode !== (matrix.matrixTopology === 'multi_node')
+    )
+      throw new Error(`Required power: topology differs from benchmark or matrix for ${key}`);
+    const rawGpuCount =
+      row.num_gpus ??
+      (topology.is_multinode
+        ? Number(row.num_prefill_gpu) + Number(row.num_decode_gpu)
+        : Number(row.tp) * Number(row.pp ?? 1) * Number(row.pcp_size ?? 1));
+    if (topology.num_gpus !== rawGpuCount)
+      throw new Error(`Required power: num_gpus topology differs from benchmark for ${key}`);
+    const topologyFields = [
+      'num_prefill_gpu',
+      'num_decode_gpu',
+      'tp',
+      'ep',
+      'dp_attention',
+      'prefill_tp',
+      'prefill_ep',
+      'prefill_num_workers',
+      'decode_tp',
+      'decode_ep',
+      'decode_num_workers',
+      'pp',
+      'pcp_size',
+      'dcp_size',
+      'prefill_pp',
+      'decode_pp',
+      'prefill_pcp_size',
+      'decode_pcp_size',
+      'prefill_dcp_size',
+      'decode_dcp_size',
+      'prefill_dp_attention',
+      'decode_dp_attention',
+    ];
+    for (const field of topologyFields) {
+      if (topology[field] !== row[field])
+        throw new Error(`Required power: ${field} topology differs from benchmark for ${key}`);
+      const role = field.startsWith('prefill_')
+        ? 'prefill'
+        : field.startsWith('decode_')
+          ? 'decode'
+          : null;
+      const roleField = role ? field.slice(role.length + 1) : field;
+      const matrixField =
+        roleField === 'num_workers'
+          ? 'num-worker'
+          : roleField === 'dp_attention'
+            ? 'dp-attn'
+            : roleField.replaceAll('_', '-');
+      let planned = role
+        ? matrix[role]
+          ? object(matrix[role], `${role} matrix`)[matrixField]
+          : matrix[field.replaceAll('_', '-')]
+        : matrix[matrixField];
+      if (
+        role === 'decode' &&
+        matrix.decode &&
+        object(matrix.decode, 'decode matrix')['num-worker'] === 0 &&
+        ['tp', 'ep', 'pp', 'pcp_size', 'dcp_size'].includes(roleField)
+      )
+        planned = ['tp', 'ep'].includes(roleField) ? 0 : 1;
+      let actual =
+        topology[field] ??
+        (['pp', 'pcp_size', 'dcp_size'].includes(roleField)
+          ? 1
+          : roleField === 'dp_attention'
+            ? false
+            : undefined);
+      if (roleField === 'dp_attention' && typeof actual === 'string') actual = actual === 'true';
+      const normalizedPlanned =
+        roleField === 'dp_attention' && typeof planned === 'string' ? planned === 'true' : planned;
+      if (planned !== undefined && actual !== normalizedPlanned)
+        throw new Error(
+          `Required power: ${field} topology differs from required matrix for ${key}`,
+        );
+    }
+    let plannedGpuCount = matrix['num-gpus'];
+    if (matrix.prefill && matrix.decode) {
+      plannedGpuCount = 0;
+      for (const role of ['prefill', 'decode']) {
+        const planned = object(matrix[role], `${role} matrix`);
+        const count =
+          Number(planned.tp) *
+          Number(planned.pp ?? 1) *
+          Number(planned['pcp-size'] ?? 1) *
+          Number(planned['num-worker']);
+        if (count !== topology[`num_${role}_gpu`])
+          throw new Error(
+            `Required power: ${role} GPU count differs from required matrix for ${key}`,
+          );
+        plannedGpuCount = Number(plannedGpuCount) + count;
+      }
+    } else if (plannedGpuCount === undefined && matrix.tp !== undefined) {
+      plannedGpuCount =
+        Number(matrix.tp) * Number(matrix.pp ?? 1) * Number(matrix['pcp-size'] ?? 1);
+    }
+    if (plannedGpuCount !== undefined && plannedGpuCount !== topology.num_gpus)
+      throw new Error(`Required power: physical GPU count differs from required matrix for ${key}`);
+    const expectedCount = positive(topology.num_gpus, 'topology num_gpus');
+    if (!Number.isSafeInteger(expectedCount))
+      throw new Error('Required power: invalid physical GPU count');
+    const window = object(declared.measurement_window, 'measurement window');
+    const start = positive(window.start_time_unix, 'window start');
+    const end = positive(window.end_time_unix, 'window end');
+    if (end <= start) throw new Error('Required power: invalid measurement window boundaries');
+    if (!Array.isArray(declared.artifacts) || declared.artifacts.length === 0)
+      throw new Error('Required power: missing required artifacts');
+    const evidence = new Map<string, BenchmarkArtifactRows>();
+    for (const value of declared.artifacts) {
+      const artifact = object(value, 'required artifact');
+      const relative = safeArtifactPath(artifact.path);
+      if (evidence.has(relative))
+        throw new Error(`Required power: duplicate required artifact ${relative}`);
+      const file = files.get(relative);
+      if (!file || file.contents === undefined || file.contents.length === 0)
+        throw new Error(`Required power: missing required artifact ${relative}`);
+      if (
+        artifact.validation_state !== 'valid' ||
+        typeof artifact.sha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(artifact.sha256) ||
+        createHash('sha256').update(file.contents).digest('hex') !== artifact.sha256
+      )
+        throw new Error(`Required power: invalid artifact validation or hash ${relative}`);
+      evidence.set(relative, file);
+    }
+    if (
+      ![...evidence.values()].some((file) =>
+        file.rows.some((candidate) => isDeepStrictEqual(candidate, row)),
+      )
+    )
+      throw new Error(`Required power: benchmark artifact is not hash-bound for ${key}`);
+    const byName = (name: string): BenchmarkArtifactRows => {
+      const matches = [...evidence.values()].filter(
+        (file) => path.posix.basename(file.path) === name,
+      );
+      if (matches.length !== 1)
+        throw new Error(`Required power: expected one required ${name} artifact`);
+      return matches[0];
+    };
+    const sidecars = [...evidence.values()].filter((file) =>
+      /^power_validation.*\.json$/u.test(path.posix.basename(file.path)),
+    );
+    if (sidecars.length !== 1)
+      throw new Error('Required power: expected one required power validation artifact');
+    const audit = object(JSON.parse(sidecars[0].contents!.toString()), 'power validation');
+    const auditWindow = object(audit.benchmark_window, 'audit benchmark window');
+    if (
+      audit.power_valid !== true ||
+      auditWindow.start_time_unix !== start ||
+      auditWindow.end_time_unix !== end ||
+      audit.expected_gpu_count !== expectedCount ||
+      audit.observed_gpu_count !== expectedCount
+    )
+      throw new Error(
+        `Required power: invalid audit verdict, window or physical GPU coverage for ${key}`,
+      );
+    if (topology.is_multinode && audit.telemetry_kind === 'native_multinode_smi') {
+      if (!Array.isArray(audit.nodes) || audit.nodes.length === 0)
+        throw new Error('Required power: missing native node receipts');
+      const traces = [...evidence.values()].filter(
+        (file) => path.posix.basename(file.path) === 'gpu_metrics.csv',
+      );
+      if (traces.length !== audit.nodes.length)
+        throw new Error('Required power: missing native node telemetry');
+      for (const file of traces) {
+        const directory = path.posix.dirname(file.path);
+        const manifestFile = evidence.get(`${directory}/manifest.json`);
+        if (!manifestFile) throw new Error('Required power: missing native node manifest');
+        const nodeManifest = object(
+          JSON.parse(manifestFile.contents!.toString()),
+          'native node manifest',
+        );
+        if (nodeManifest.lifecycle !== 'complete' || nodeManifest.collector_exit_code !== 0)
+          throw new Error('Required power: invalid native node collection');
+        const receipt = (audit.nodes as JsonRow[]).find((node) => node.node === nodeManifest.node);
+        if (
+          !receipt ||
+          receipt.manifest_sha256 !== digest(manifestFile) ||
+          receipt.telemetry_sha256 !== digest(file)
+        )
+          throw new Error('Required power: native node receipt differs from evidence');
+        for (const hash of [receipt.identity_sha256, receipt.identity_end_sha256])
+          if (
+            ![...evidence.values()].some(
+              (item) => path.posix.dirname(item.path) === directory && digest(item) === hash,
+            )
+          )
+            throw new Error('Required power: missing native physical identity evidence');
+      }
+    } else if (topology.is_multinode) {
+      byName('samples.csv');
+      byName('manifest.json');
+      if (
+        ![...evidence.keys()].some((file) => file.includes('/windows/') && file.endsWith('.json'))
+      )
+        throw new Error('Required power: missing central measurement window artifact');
+    } else byName('gpu_metrics.csv');
+    const energies = object(audit.per_gpu_energy_j, 'audit device energy');
+    let auditDevices: JsonRow[];
+    if (audit.per_gpu_role === undefined) {
+      const nodeFiles = [...evidence.values()].filter((file) =>
+        ['power_node.txt', 'gpu_metrics_node.txt'].includes(path.posix.basename(file.path)),
+      );
+      if (nodeFiles.length !== 1)
+        throw new Error('Required power: expected one node identity artifact');
+      const node = nodeFiles[0].contents!.toString().trim();
+      const identityFiles = [...evidence.values()].filter((file) =>
+        /^(?:gpu_metrics_identity\.csv|gpu_metrics_devices\.json)$/u.test(
+          path.posix.basename(file.path),
+        ),
+      );
+      if (identityFiles.length !== 1)
+        throw new Error('Required power: expected one physical GPU identity artifact');
+      const uuidRows: [string, string][] = [];
+      if (identityFiles[0].path.endsWith('.csv')) {
+        const lines = identityFiles[0].contents!.toString().trim().split(/\r?\n/u);
+        const columns = lines
+          .shift()!
+          .split(',')
+          .map((part) => part.trim().replaceAll('"', '').toLowerCase());
+        const indexColumn = columns.indexOf('index');
+        const uuidColumn = columns.indexOf('uuid');
+        if (indexColumn === -1 || uuidColumn === -1)
+          throw new Error('Required power: invalid physical GPU identity CSV');
+        for (const line of lines) {
+          const fields = line.split(',').map((part) => part.trim().replaceAll('"', ''));
+          uuidRows.push([fields[indexColumn], fields[uuidColumn]]);
+        }
+      } else {
+        const visit = (value: unknown): void => {
+          if (Array.isArray(value)) value.forEach(visit);
+          else if (value && typeof value === 'object') {
+            const deviceRow = Object.fromEntries(
+              Object.entries(value).map(([field, item]) => [field.toLowerCase(), item]),
+            );
+            if ('gpu' in deviceRow && 'uuid' in deviceRow)
+              uuidRows.push([String(deviceRow.gpu), String(deviceRow.uuid)]);
+            else Object.values(value).forEach(visit);
+          }
+        };
+        visit(JSON.parse(identityFiles[0].contents!.toString()));
+      }
+      if (
+        uuidRows.length === 0 ||
+        uuidRows.some(
+          ([index, uuid]) =>
+            !/^\d+$/u.test(index) || !uuid || ['n/a', 'none', 'null'].includes(uuid.toLowerCase()),
+        ) ||
+        new Set(uuidRows.map(([index]) => index)).size !== uuidRows.length ||
+        new Set(uuidRows.map(([, uuid]) => uuid)).size !== uuidRows.length
+      )
+        throw new Error('Required power: invalid or duplicate physical GPU identity');
+      const uuids = new Map(uuidRows);
+      auditDevices = Object.entries(energies).map(([index, energy]) => ({
+        node,
+        gpu_uuid: uuids.get(index),
+        role: 'aggregate',
+        energy_j: energy,
+      }));
+    } else {
+      const roles = object(audit.per_gpu_role, 'audit device roles');
+      const nativeNodes = new Map<string, string>();
+      if (audit.telemetry_kind === 'native_multinode_smi')
+        for (const value of audit.nodes as unknown[]) {
+          const receipt = object(value, 'native node receipt');
+          for (const uuid of Object.values(
+            object(receipt.physical_gpu_ids, 'native GPU identities'),
+          )) {
+            const uuidValue = nonempty(uuid, 'native GPU UUID');
+            if (nativeNodes.has(uuidValue))
+              throw new Error('Required power: duplicate native GPU identity');
+            nativeNodes.set(uuidValue, nonempty(receipt.node, 'native node'));
+          }
+        }
+      auditDevices = Object.entries(energies).map(([device, energy]) => {
+        const slash = device.lastIndexOf('/');
+        return {
+          node: nativeNodes.get(device) ?? device.slice(0, slash),
+          gpu_uuid: nativeNodes.has(device) ? device : device.slice(slash + 1),
+          role: roles[device] === 'agg' ? 'aggregate' : roles[device],
+          energy_j: energy,
+        };
+      });
+    }
+    if (
+      !Array.isArray(declared.devices) ||
+      declared.devices.length !== expectedCount ||
+      auditDevices.length !== expectedCount
+    )
+      throw new Error(`Required power: missing physical GPU evidence for ${key}`);
+    const devices = new Set<string>();
+    const roles = new Map<string, number>();
+    let totalEnergy = 0;
+    const roleEnergy = new Map<string, number>();
+    const nodes = new Set<string>();
+    for (const value of declared.devices) {
+      const device = object(value, 'physical GPU');
+      const node = nonempty(device.node, 'GPU node');
+      nodes.add(node);
+      const uuid = nonempty(device.gpu_uuid, 'physical GPU UUID');
+      if (['n/a', 'none', 'null'].includes(uuid.toLowerCase()) || devices.has(uuid))
+        throw new Error('Required power: duplicate or invalid physical GPU UUID');
+      devices.add(uuid);
+      if (!['aggregate', 'prefill', 'decode'].includes(String(device.role)))
+        throw new Error('Required power: invalid physical GPU role');
+      roles.set(String(device.role), (roles.get(String(device.role)) ?? 0) + 1);
+      const energy = positive(device.energy_j, 'device energy_j');
+      totalEnergy += energy;
+      roleEnergy.set(String(device.role), (roleEnergy.get(String(device.role)) ?? 0) + energy);
+      if (!auditDevices.some((actual) => isDeepStrictEqual(actual, device)))
+        throw new Error(`Required power: physical GPU evidence differs from audit for ${key}`);
+    }
+    if (nodes.size !== (matrix['node-count'] ?? 1))
+      throw new Error(
+        `Required power: participating node count differs from required matrix for ${key}`,
+      );
+    if (topology.disagg) {
+      if (
+        roles.get('prefill') !== positive(topology.num_prefill_gpu, 'prefill GPU count') ||
+        roles.get('decode') !== positive(topology.num_decode_gpu, 'decode GPU count') ||
+        roles.has('aggregate')
+      )
+        throw new Error(`Required power: missing prefill or decode evidence for ${key}`);
+      for (const role of ['prefill', 'decode']) {
+        const energy = positive(row[`${role}_gpu_energy_j`], `${role} energy`);
+        if (Math.abs((roleEnergy.get(role) ?? 0) - energy) > Math.max(0.01, energy * 1e-4))
+          throw new Error(`Required power: ${role} energy differs from device evidence for ${key}`);
+      }
+    } else if (roles.get('aggregate') !== expectedCount) {
+      throw new Error(`Required power: invalid aggregate GPU roles for ${key}`);
+    }
+    const energy = positive(row.total_gpu_energy_j, 'total_gpu_energy_j');
+    if (Math.abs(totalEnergy - energy) > Math.max(0.01, energy * 1e-4))
+      throw new Error(`Required power: total GPU energy differs from device evidence for ${key}`);
+  }
+}
diff --git a/packages/db/src/etl/telemetry-receipt.test.ts b/packages/db/src/etl/telemetry-receipt.test.ts
new file mode 100644
index 000000000..1fba454e7
--- /dev/null
+++ b/packages/db/src/etl/telemetry-receipt.test.ts
@@ -0,0 +1,274 @@
+import { readFileSync } from 'node:fs';
+import { PGlite } from '@electric-sql/pglite';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { Sql } from './db-utils';
+import { stablePowerPointIdentity } from './power-publication';
+
+import {
+  readTelemetryReceipt,
+  summarizeTelemetryReceipt,
+  telemetryArtifactsForAttempt,
+  verifyTelemetryApi,
+  type TelemetryReceipt,
+} from './telemetry-receipt';
+
+describe('telemetry attachment receipts', () => {
+  it('isolates the source attempt before selecting or downloading artifact pairs', () => {
+    const old = {
+      name: 'gpu_metrics_old',
+      created_at: '2026-09-20T00:00:00Z',
+      archive_download_url: 'old',
+    };
+    const current = {
+      name: 'gpu_metrics_new',
+      created_at: '2026-09-21T01:00:00Z',
+      archive_download_url: 'new',
+    };
+    const source = { run_attempt: 2, run_started_at: '2026-09-21T00:00:00Z' };
+    expect(telemetryArtifactsForAttempt([old, current], source, 2)).toEqual([current]);
+    expect(() => telemetryArtifactsForAttempt([old, current], source, 1)).toThrow('mixed-attempt');
+    expect(() => telemetryArtifactsForAttempt([current], { run_attempt: 2 }, 2)).toThrow(
+      'start time',
+    );
+  });
+});
+
+const run = { runId: 123, runAttempt: 2 };
+const artifactName = 'gpu_metrics_shared';
+
+function receiptFixture(): TelemetryReceipt {
+  const series = [{ id: 1, artifactName, fileName: 'gpu_metrics.csv', sampleCount: 2 }];
+  return {
+    version: 1,
+    ...run,
+    checkedAt: '2026-09-21T00:00:00Z',
+    expectedSource: 'benchmark_artifacts',
+    plannedPointCount: null,
+    counts: {} as TelemetryReceipt['counts'],
+    points: [10, 11].map((id) => ({
+      key: String(id),
+      identity: { conc: id },
+      benchmarkResultId: id,
+      artifactNames: [artifactName],
+      produced: true,
+      series,
+      storage: { status: 'complete', expectedSeries: series },
+      linkedSeriesIds: [1],
+      api: { status: 'readable' },
+      reasons: [],
+      recovery: { ...run, artifactNames: [artifactName] },
+    })),
+  };
+}
+
+describe('telemetry completeness accounting', () => {
+  it('counts shared storage once while retaining both independently linked points', () => {
+    const { counts } = summarizeTelemetryReceipt(receiptFixture());
+    expect(counts).toMatchObject({
+      expectedPoints: 2,
+      producedPoints: 2,
+      producedArtifacts: 1,
+      storedPoints: 2,
+      linkedPoints: 2,
+      storedSeries: 1,
+      storedSamples: 2,
+      apiCompletePoints: 2,
+    });
+  });
+
+  it.each([
+    { expectedSource: 'unknown' as const },
+    {
+      expectationErrors: [
+        { benchmarkArtifact: 'bmk_missing', artifactNames: [], error: 'unreadable' },
+      ],
+    },
+  ])('keeps an unknown expectation denominator with %j', (unknown) => {
+    const result = summarizeTelemetryReceipt({ ...receiptFixture(), ...unknown });
+    expect(result.counts).toMatchObject({
+      expectedPoints: null,
+      storedPoints: 2,
+      storedSamples: 2,
+    });
+  });
+
+  it.each([
+    { databaseError: 'database unavailable' },
+    { recoveryError: 'corrective ingest failed' },
+  ])('does not promote readable old data to complete while %j', (failure) => {
+    const result = summarizeTelemetryReceipt({ ...receiptFixture(), ...failure });
+    expect(result.counts.apiReadablePoints).toBe(2);
+    expect(result.counts.apiCompletePoints).toBe(0);
+    expect(result.counts.storedSamples).toBe('databaseError' in failure ? null : 2);
+  });
+
+  it('does not count unlinked or failed corrected points as API-complete', () => {
+    const receipt = receiptFixture();
+    receipt.points[0]!.linkedSeriesIds = [];
+    receipt.points[1]!.error = 'correction failed';
+    expect(summarizeTelemetryReceipt(receipt).counts).toMatchObject({
+      storedPoints: 2,
+      linkedPoints: 1,
+      apiReadablePoints: 2,
+      apiCompletePoints: 0,
+    });
+  });
+});
+
+describe('telemetry API verification', () => {
+  it.each([
+    ['matching data', 200, 10, 2, 2, true],
+    ['missing endpoint', 404, 10, 2, 2, false],
+    ['unavailable endpoint', 503, 10, 2, 2, false],
+    ['different point', 200, 11, 2, 2, false],
+    ['different sample count', 200, 10, 3, 2, false],
+    ['truncated data', 200, 10, 2, 1, false],
+  ] as const)('%s', async (_name, status, id, sampleCount, dataCount, readable) => {
+    const receipt = receiptFixture();
+    receipt.points = [receipt.points[0]!];
+    receipt.points[0]!.api = { status: 'unknown' };
+    const fetcher = vi.fn<typeof fetch>().mockResolvedValue(
+      Response.json(
+        {
+          benchmarkResultId: id,
+          series: [
+            { id: 1, sampleCount, data: Array.from({ length: dataCount }, () => ({ power: 100 })) },
+          ],
+        },
+        { status },
+      ),
+    );
+    const result = await verifyTelemetryApi(receipt, 'https://example.test', { fetch: fetcher });
+    expect(String(fetcher.mock.calls[0]![0])).toBe(
+      'https://example.test/api/v1/gpu-metrics-point?id=10',
+    );
+    expect(result.points[0]!.api.status).toBe(readable ? 'readable' : 'failed');
+    expect(result.counts.apiCompletePoints).toBe(readable ? 1 : 0);
+    if (!readable) expect(result.points[0]!.api.error).toBeTruthy();
+  });
+
+  it('requires the complete stored series set and skips points without database identities', async () => {
+    const receipt = receiptFixture();
+    receipt.points[1]!.benchmarkResultId = null;
+    receipt.points[1]!.api = { status: 'unknown' };
+    const fetcher = vi
+      .fn<typeof fetch>()
+      .mockResolvedValue(Response.json({ benchmarkResultId: 10, series: [] }));
+    const result = await verifyTelemetryApi(receipt, 'https://example.test', { fetch: fetcher });
+    expect(fetcher).toHaveBeenCalledTimes(1);
+    expect(result.points[0]!.api.error).toContain('series set differs');
+    expect(result.points[1]!.api.status).toBe('unknown');
+    expect(result.counts.apiCompletePoints).toBe(0);
+  });
+});
+
+describe('persisted telemetry receipts', () => {
+  let db: PGlite;
+  let sql: Sql;
+  beforeAll(async () => {
+    db = await PGlite.create();
+    for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+      await db.exec(readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+    }
+    await db.exec(
+      "ALTER TABLE benchmark_results ADD COLUMN offload_mode text DEFAULT 'off'; ALTER TABLE benchmark_results ADD COLUMN recipe_fingerprint text",
+    );
+    sql = (async (strings: TemplateStringsArray, ...values: unknown[]) => {
+      const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+      const result = await db.query(query, values);
+      return result.rows;
+    }) as unknown as Sql;
+  }, 20_000);
+  afterAll(async () => {
+    await db?.close();
+  });
+  beforeEach(async () => {
+    await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+      INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
+      VALUES (1, 123, 2, 'Sweep', '2026-09-21', '2026-09-21');
+      INSERT INTO configs (id, model, hardware, framework, precision, spec_method, prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+      VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', 1, 1, 1, 1);
+      INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+      VALUES (10, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 1, '{}'),
+        (11, 1, 1, 'single_turn', '2026-09-21', 8192, 1024, 2, '{}');
+      INSERT INTO gpu_metric_series (id, workflow_run_id, artifact_name, config_key, file_name, vendor, csv_sha256, sample_count, gpu_count, started_at, ended_at)
+      VALUES (1, 1, 'gpu_metrics_shared', 'shared', 'gpu_metrics.csv', 'nvidia', 'source', 2, 1, '2026-09-21T00:00:00Z', '2026-09-21T00:00:01Z');
+      INSERT INTO gpu_metric_samples (series_id, gpu_index, sampled_at, power_w)
+      VALUES (1, 0, '2026-09-21T00:00:00Z', 100), (1, 0, '2026-09-21T00:00:01Z', 200);
+      INSERT INTO benchmark_result_gpu_metrics VALUES (10, 1), (11, 1);`);
+  });
+
+  async function inventory(value: unknown) {
+    await db.query('UPDATE gpu_metric_series SET sidecars = $1::jsonb', [JSON.stringify(value)]);
+  }
+  const completeInventory = { seriesInventory: [{ fileName: 'gpu_metrics.csv', sampleCount: 2 }] };
+
+  it.each([false, true])(
+    'reads complete JSONB inventory (encoded=%s) and preserves unrelated targeted state',
+    async (encoded) => {
+      await inventory(encoded ? JSON.stringify(completeInventory) : completeInventory);
+      const original = await readTelemetryReceipt(sql, run, []);
+      expect(original.counts).toMatchObject({
+        expectedPoints: 2,
+        storedPoints: 2,
+        linkedPoints: 2,
+        storedSeries: 1,
+        storedSamples: 2,
+        apiCompletePoints: 0,
+      });
+      original.points[1]!.api = { status: 'readable' };
+      const first = original.points[0]!;
+      const repaired = await readTelemetryReceipt(
+        sql,
+        run,
+        [{ identity: first.identity, artifactNames: [artifactName], produced: true }],
+        { previous: original, targeted: true },
+      );
+      expect(
+        repaired.points.find((point) => point.key === stablePowerPointIdentity(first.identity))!.api
+          .status,
+      ).toBe('unknown');
+      expect(repaired.points[1]).toEqual(original.points[1]);
+    },
+  );
+
+  it('keeps missing inventory unknown and missing host storage incomplete', async () => {
+    await inventory('{invalid json');
+    const unknown = await readTelemetryReceipt(sql, run, []);
+    expect(unknown.databaseError).toBeUndefined();
+    expect(unknown.counts).toMatchObject({
+      storedPoints: 0,
+      storageUnknownPoints: 2,
+      storedSamples: 2,
+    });
+    await inventory({
+      seriesInventory: [
+        ...completeInventory.seriesInventory,
+        { fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
+      ],
+    });
+    const incomplete = await readTelemetryReceipt(sql, run, []);
+    expect(incomplete.points[0]!.storage.status).toBe('incomplete');
+    expect(incomplete.points[0]!.reasons).toContain('series_coverage_incomplete');
+    expect(incomplete.counts.storedPoints).toBe(0);
+  });
+
+  it('reports failed SQL as unknown storage rather than a successful empty receipt', async () => {
+    await db.exec('ALTER TABLE gpu_metric_series RENAME TO unavailable_gpu_metric_series');
+    try {
+      const result = await readTelemetryReceipt(sql, run, []);
+      expect(result.databaseError).toContain('gpu_metric_series');
+      expect(result.counts).toMatchObject({
+        expectedPoints: null,
+        storedPoints: null,
+        linkedPoints: null,
+        storedSeries: null,
+        storedSamples: null,
+        apiCompletePoints: 0,
+      });
+    } finally {
+      await db.exec('ALTER TABLE unavailable_gpu_metric_series RENAME TO gpu_metric_series');
+    }
+  });
+});
diff --git a/packages/db/src/etl/telemetry-receipt.ts b/packages/db/src/etl/telemetry-receipt.ts
new file mode 100644
index 000000000..16b8b019b
--- /dev/null
+++ b/packages/db/src/etl/telemetry-receipt.ts
@@ -0,0 +1,461 @@
+import type { Sql } from './db-utils';
+import type { ArtifactMeta, RunMeta } from '../lib/github-artifacts';
+import { stablePowerPointIdentity } from './power-publication';
+import { gpuMetricsArtifactSuffix } from './gpu-metrics-artifacts';
+
+export interface TelemetryObservation {
+  identity: Record<string, unknown>;
+  /** Exact selected artifact names, or both allowed sibling names when absent. */
+  artifactNames: string[];
+  produced: boolean | null;
+  error?: string;
+}
+
+interface TelemetrySeriesCoverage {
+  artifactName: string;
+  fileName: string;
+  sampleCount: number;
+}
+
+export interface TelemetryPointReceipt extends TelemetryObservation {
+  key: string;
+  benchmarkResultId: number | null;
+  series: (TelemetrySeriesCoverage & { id: number })[];
+  storage: {
+    status: 'complete' | 'incomplete' | 'unknown';
+    /** Null means the original artifact inventory was not retained. */
+    expectedSeries: TelemetrySeriesCoverage[] | null;
+  };
+  linkedSeriesIds: number[];
+  api: {
+    status: 'unknown' | 'readable' | 'failed';
+    checkedAt?: string;
+    url?: string;
+    error?: string;
+  };
+  reasons: string[];
+  recovery: { runId: number; runAttempt: number; artifactNames: string[] };
+}
+
+export interface TelemetryReceipt {
+  version: 1;
+  runId: number;
+  runAttempt: number;
+  checkedAt: string;
+  /** This is attachment coverage for known benchmark points, not a full-sweep verdict. */
+  expectedSource: 'benchmark_artifacts' | 'database_benchmarks' | 'unknown';
+  /** No complete independent planned matrix is available to this attachment reader. */
+  plannedPointCount: null;
+  databaseError?: string;
+  recoveryError?: string;
+  /** Missing on older receipts or when the failed recovery covered the whole run. */
+  recoveryArtifactNames?: string[];
+  /** The sibling is known, but a download/parse failure prevents identifying its points. */
+  expectationErrors?: { benchmarkArtifact: string; artifactNames: string[]; error: string }[];
+  points: TelemetryPointReceipt[];
+  counts: {
+    expectedPoints: number | null;
+    producedPoints: number;
+    productionUnknownPoints: number;
+    storedPoints: number | null;
+    linkedPoints: number | null;
+    storageUnknownPoints: number;
+    /** Actual successful HTTP reads, including readable but incomplete artifacts. */
+    apiReadablePoints: number;
+    /** Readable, fully stored/linked points with no outstanding corrective-ingest failure. */
+    apiCompletePoints: number;
+    apiUnknownPoints: number;
+    producedArtifacts: number;
+    storedSeries: number | null;
+    storedSamples: number | null;
+  };
+}
+
+interface StoredPoint extends Record<string, unknown> {
+  id: number;
+}
+
+interface StoredSeries {
+  id: number;
+  artifact_name: string;
+  file_name: string;
+  sidecars: unknown;
+  sample_count: number;
+  benchmark_result_ids: number[];
+}
+
+function isInventoryEntry(value: unknown): value is { fileName: string; sampleCount: number } {
+  if (value === null || typeof value !== 'object') return false;
+  const entry = value as Record<string, unknown>;
+  return (
+    typeof entry.fileName === 'string' &&
+    typeof entry.sampleCount === 'number' &&
+    Number.isSafeInteger(entry.sampleCount) &&
+    entry.sampleCount >= 0
+  );
+}
+
+/** JSONB may contain an encoded object; unavailable inventories remain unknown. */
+function storedSeriesInventory(sidecars: unknown): unknown {
+  if (typeof sidecars === 'string') {
+    try {
+      sidecars = JSON.parse(sidecars) as unknown;
+    } catch {
+      return undefined;
+    }
+  }
+  return sidecars !== null && typeof sidecars === 'object' && !Array.isArray(sidecars)
+    ? (sidecars as { seriesInventory?: unknown }).seriesInventory
+    : undefined;
+}
+
+function seriesCoverageKey(artifact: string, file: string): string {
+  return JSON.stringify([artifact, file]);
+}
+
+function seriesCoverage(
+  series: readonly StoredSeries[],
+  reasons: string[],
+): TelemetryPointReceipt['storage'] {
+  if (series.length === 0) return { status: 'incomplete', expectedSeries: null };
+  const expected = new Map<string, TelemetrySeriesCoverage>();
+  const inventories = new Map<string, string>();
+  let unknown = false;
+  for (const entry of series) {
+    const inventory = storedSeriesInventory(entry.sidecars);
+    if (!Array.isArray(inventory) || inventory.length === 0 || !inventory.every(isInventoryEntry)) {
+      unknown = true;
+      continue;
+    }
+    const signature = JSON.stringify(
+      inventory.toSorted((a, b) => a.fileName.localeCompare(b.fileName)),
+    );
+    const previous = inventories.get(entry.artifact_name);
+    if (previous && previous !== signature) unknown = true;
+    inventories.set(entry.artifact_name, signature);
+    if (!inventory.some((item) => item.fileName === entry.file_name)) unknown = true;
+    for (const item of inventory) {
+      expected.set(seriesCoverageKey(entry.artifact_name, item.fileName), {
+        artifactName: entry.artifact_name,
+        ...item,
+      });
+    }
+  }
+  const actual = new Map(
+    series.map((entry) => [seriesCoverageKey(entry.artifact_name, entry.file_name), entry]),
+  );
+  const missing = [...expected].some(([name]) => !actual.has(name));
+  const wrongSamples = [...expected].some(([name, entry]) => {
+    const stored = actual.get(name);
+    return stored !== undefined && Number(stored.sample_count) !== entry.sampleCount;
+  });
+  if (missing) reasons.push('series_coverage_incomplete');
+  if (wrongSamples) reasons.push('sample_coverage_incomplete');
+  if (unknown) reasons.push('series_inventory_unknown');
+  return {
+    status:
+      missing || wrongSamples || series.some((entry) => Number(entry.sample_count) === 0)
+        ? 'incomplete'
+        : unknown
+          ? 'unknown'
+          : 'complete',
+    expectedSeries: expected.size > 0 ? [...expected.values()] : null,
+  };
+}
+
+/** GitHub's run-wide listing also retains artifacts from earlier attempts. */
+export function telemetryArtifactsForAttempt(
+  artifacts: readonly ArtifactMeta[],
+  source: Pick<RunMeta, 'run_attempt' | 'run_started_at'>,
+  targetAttempt: number,
+): ArtifactMeta[] {
+  if (source.run_attempt !== targetAttempt)
+    throw new Error(
+      `GitHub attempt ${source.run_attempt} differs from target ${targetAttempt}; refusing mixed-attempt telemetry recovery`,
+    );
+  const start = Date.parse(source.run_started_at ?? '');
+  if (!Number.isFinite(start))
+    throw new Error('Cannot isolate telemetry artifacts without attempt start time');
+  return artifacts.filter((artifact) => Date.parse(artifact.created_at) >= start);
+}
+
+/** Count identities, artifacts, series and samples separately; shared series count once. */
+export function summarizeTelemetryReceipt(receipt: TelemetryReceipt): TelemetryReceipt {
+  const points = receipt.points;
+  const series = new Map(points.flatMap((point) => point.series.map((s) => [s.id, s] as const)));
+  const complete = points.filter((point) => point.storage?.status === 'complete');
+  const linked = complete.filter((point) =>
+    point.series.every((s) => point.linkedSeriesIds.includes(s.id)),
+  );
+  receipt.counts = {
+    expectedPoints:
+      receipt.expectedSource === 'unknown' || receipt.expectationErrors?.length
+        ? null
+        : points.length,
+    producedPoints: points.filter((p) => p.produced === true).length,
+    productionUnknownPoints: points.filter((p) => p.produced === null).length,
+    storedPoints: receipt.databaseError ? null : complete.length,
+    linkedPoints: receipt.databaseError ? null : linked.length,
+    storageUnknownPoints: points.filter(
+      (point) => !point.storage || point.storage.status === 'unknown',
+    ).length,
+    apiReadablePoints: points.filter((p) => p.api.status === 'readable').length,
+    apiCompletePoints:
+      receipt.databaseError || receipt.recoveryError
+        ? 0
+        : linked.filter((point) => point.api.status === 'readable' && !point.error).length,
+    apiUnknownPoints: points.filter((p) => p.api.status === 'unknown').length,
+    producedArtifacts: new Set(
+      points.filter((p) => p.produced === true).flatMap((p) => p.artifactNames),
+    ).size,
+    storedSeries: receipt.databaseError ? null : series.size,
+    storedSamples: receipt.databaseError
+      ? null
+      : [...series.values()].reduce((sum, s) => sum + s.sampleCount, 0),
+  };
+  return receipt;
+}
+
+/** Absent observations name alternative siblings, not two required uploads. */
+function coversArtifactScope(
+  current: TelemetryObservation,
+  previous: TelemetryObservation,
+): boolean {
+  return (
+    previous.artifactNames.length > 0 &&
+    previous.artifactNames.every(
+      (name) =>
+        current.artifactNames.includes(name) ||
+        (previous.produced === false &&
+          gpuMetricsArtifactSuffix(name) !== null &&
+          current.artifactNames.some(
+            (candidate) => gpuMetricsArtifactSuffix(candidate) === gpuMetricsArtifactSuffix(name),
+          )),
+    )
+  );
+}
+
+/** Read actual persistence/link state, preserving unrelated points on targeted recovery. */
+export async function readTelemetryReceipt(
+  sql: Sql,
+  run: { runId: number; runAttempt: number },
+  observations: readonly TelemetryObservation[],
+  options: {
+    expectedSource?: TelemetryReceipt['expectedSource'];
+    previous?: TelemetryReceipt;
+    targeted?: boolean;
+    /** Mapped identity -> persisted ID, only from the historical resolver's unique fallback. */
+    uniqueFallbacks?: ReadonlyMap<string, number>;
+  } = {},
+): Promise<TelemetryReceipt> {
+  const previous = options.previous;
+  if (previous && (previous.runId !== run.runId || previous.runAttempt !== run.runAttempt))
+    throw new Error('Telemetry receipt run/attempt does not match the recovery target');
+  const receipt: TelemetryReceipt = {
+    version: 1,
+    ...run,
+    checkedAt: new Date().toISOString(),
+    expectedSource: options.expectedSource ?? previous?.expectedSource ?? 'database_benchmarks',
+    plannedPointCount: null,
+    points: [],
+    counts: {} as TelemetryReceipt['counts'],
+  };
+  let rows: StoredPoint[] = [];
+  let series: StoredSeries[] = [];
+  try {
+    rows = await sql<StoredPoint[]>`
+      select c.*, br.id, br.benchmark_type, br.isl, br.osl, br.conc,
+        br.offload_mode, br.recipe_fingerprint
+      from benchmark_results br
+      join configs c on c.id = br.config_id
+      join workflow_runs wr on wr.id = br.workflow_run_id
+      where wr.github_run_id = ${run.runId} and wr.run_attempt = ${run.runAttempt}
+      order by br.id
+    `;
+    series = await sql<StoredSeries[]>`
+      select s.id, s.artifact_name, s.file_name, s.sidecars,
+        (select count(*)::int from gpu_metric_samples x where x.series_id = s.id) as sample_count,
+        coalesce((select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
+          from benchmark_result_gpu_metrics l
+          join benchmark_results br on br.id = l.benchmark_result_id
+          where l.series_id = s.id and br.workflow_run_id = s.workflow_run_id), '{}') as benchmark_result_ids
+      from gpu_metric_series s join workflow_runs wr on wr.id = s.workflow_run_id
+      where wr.github_run_id = ${run.runId} and wr.run_attempt = ${run.runAttempt}
+      order by s.id
+    `;
+  } catch (error) {
+    receipt.databaseError = error instanceof Error ? error.message : String(error);
+    if (observations.length === 0 && !previous) receipt.expectedSource = 'unknown';
+  }
+  const stored = new Map(rows.map((row) => [stablePowerPointIdentity(row), row]));
+  const storedById = new Map(rows.map((row) => [Number(row.id), row]));
+  const prior = new Map(previous?.points.map((point) => [point.key, point]));
+  const observed = new Map(
+    observations.map((point) => [stablePowerPointIdentity(point.identity), point]),
+  );
+  for (const [key, id] of options.uniqueFallbacks ?? []) {
+    const observation = observed.get(key);
+    const row = storedById.get(id);
+    if (receipt.databaseError || !observation || !row || stored.has(key)) continue;
+    // The resolver allows historical offload drift only; keep every other dimension exact.
+    const identity = { ...observation.identity, offload_mode: row.offload_mode };
+    const canonicalKey = stablePowerPointIdentity(identity);
+    if (canonicalKey !== stablePowerPointIdentity(row)) continue;
+    const collision = observed.get(canonicalKey);
+    const priorCanonical = prior.get(canonicalKey);
+    if (
+      (priorCanonical &&
+        (priorCanonical.artifactNames.length > 0 || priorCanonical.error) &&
+        !coversArtifactScope(observation, priorCanonical)) ||
+      (collision &&
+        (collision.produced !== observation.produced ||
+          collision.error !== observation.error ||
+          collision.artifactNames.length !== observation.artifactNames.length ||
+          collision.artifactNames.some((name) => !observation.artifactNames.includes(name))))
+    ) {
+      receipt.expectedSource = 'unknown';
+      continue;
+    }
+    observed.delete(key);
+    observed.set(canonicalKey, { ...observation, identity });
+    const old = prior.get(key);
+    if (old?.benchmarkResultId === null && coversArtifactScope(observation, old)) prior.delete(key);
+  }
+  const resolvedObservations = [...observed.values()];
+  const pendingRecoveryArtifacts = previous?.recoveryArtifactNames?.filter(
+    (name) =>
+      !resolvedObservations.some(
+        (point) => point.produced === true && !point.error && point.artifactNames.includes(name),
+      ),
+  );
+  const successfulKeys = new Set(
+    resolvedObservations
+      .filter((point) => point.produced === true && !point.error)
+      .map((point) => stablePowerPointIdentity(point.identity)),
+  );
+  const recoveryUnresolved = previous?.recoveryArtifactNames?.length
+    ? pendingRecoveryArtifacts?.length
+    : options.targeted ||
+      resolvedObservations.length === 0 ||
+      successfulKeys.size !== resolvedObservations.length ||
+      [...prior.values()].some((point) => !successfulKeys.has(point.key));
+  Object.assign(receipt, {
+    ...(previous?.recoveryError && recoveryUnresolved
+      ? {
+          recoveryError: previous.recoveryError,
+          ...(pendingRecoveryArtifacts ? { recoveryArtifactNames: pendingRecoveryArtifacts } : {}),
+        }
+      : {}),
+    ...(previous?.expectationErrors
+      ? {
+          expectationErrors: previous.expectationErrors.filter(
+            (error) =>
+              !resolvedObservations.some((point) =>
+                point.artifactNames.some((name) => error.artifactNames.includes(name)),
+              ),
+          ),
+        }
+      : {}),
+  });
+  const keys = new Set([...prior.keys(), ...stored.keys(), ...observed.keys()]);
+  for (const key of keys) {
+    const old = prior.get(key);
+    if (options.targeted && old && !observed.has(key)) {
+      receipt.points.push(old);
+      continue;
+    }
+    const row = stored.get(key);
+    const benchmarkResultId = row ? Number(row.id) : null;
+    const linked = series.filter((s) =>
+      s.benchmark_result_ids.map(Number).includes(benchmarkResultId!),
+    );
+    const observation = observed.get(key) ??
+      old ?? {
+        identity: row!,
+        artifactNames: [...new Set(linked.map((s) => s.artifact_name))],
+        produced: linked.length > 0 ? true : null,
+      };
+    const matching = series.filter((s) => observation.artifactNames.includes(s.artifact_name));
+    const reasons: string[] = [];
+    if (observation.produced === false) reasons.push('artifact_missing');
+    if (observation.produced === null) reasons.push('artifact_pair_unknown');
+    if (observation.error) reasons.push('ingest_failed');
+    if (receipt.databaseError) reasons.push('database_check_failed');
+    else {
+      if (benchmarkResultId === null) reasons.push('benchmark_not_stored');
+      if (matching.length === 0) reasons.push('series_not_stored');
+      else if (matching.some((s) => Number(s.sample_count) === 0)) reasons.push('samples_missing');
+      if (matching.some((s) => !linked.includes(s))) reasons.push('point_link_missing');
+    }
+    const storage: TelemetryPointReceipt['storage'] = receipt.databaseError
+      ? { status: 'unknown', expectedSeries: null }
+      : seriesCoverage(matching, reasons);
+    receipt.points.push({
+      identity: observation.identity,
+      artifactNames: observation.artifactNames,
+      produced: observation.produced,
+      ...(observation.error ? { error: observation.error } : {}),
+      key,
+      benchmarkResultId,
+      series: matching.map((s) => ({
+        id: Number(s.id),
+        artifactName: s.artifact_name,
+        fileName: s.file_name,
+        sampleCount: Number(s.sample_count),
+      })),
+      storage,
+      linkedSeriesIds: linked.filter((s) => matching.includes(s)).map((s) => Number(s.id)),
+      api: { status: 'unknown' },
+      reasons,
+      recovery: { ...run, artifactNames: observation.artifactNames },
+    });
+  }
+  receipt.points.sort((a, b) => a.key.localeCompare(b.key));
+  return summarizeTelemetryReceipt(receipt);
+}
+
+/** Only an actual HTTP read advances API status; DB-queryable is not API-readable. */
+export async function verifyTelemetryApi(
+  receipt: TelemetryReceipt,
+  origin: string,
+  options: { fetch?: typeof fetch; headers?: HeadersInit } = {},
+): Promise<TelemetryReceipt> {
+  for (const point of receipt.points) {
+    if (point.benchmarkResultId === null) continue;
+    const url = new URL('/api/v1/gpu-metrics-point', origin);
+    url.searchParams.set('id', String(point.benchmarkResultId));
+    const checkedAt = new Date().toISOString();
+    try {
+      const response = await (options.fetch ?? fetch)(url, {
+        headers: options.headers,
+        signal: AbortSignal.timeout(30_000),
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const payload = await response.json();
+      if (payload?.benchmarkResultId !== point.benchmarkResultId || !Array.isArray(payload.series))
+        throw new Error('Point API returned a different identity or invalid series');
+      if (point.series.length === 0 || payload.series.length !== point.series.length)
+        throw new Error('Point API series set differs from stored telemetry');
+      for (const stored of point.series) {
+        const actual = payload.series.find((s: { id: number }) => s.id === stored.id);
+        if (
+          !actual ||
+          stored.sampleCount === 0 ||
+          actual.sampleCount !== stored.sampleCount ||
+          !Array.isArray(actual.data) ||
+          actual.data.length !== stored.sampleCount
+        )
+          throw new Error(`Point API series ${stored.id} sample count differs from storage`);
+      }
+      point.api = { status: 'readable', checkedAt, url: url.toString() };
+    } catch (error) {
+      point.api = {
+        status: 'failed',
+        checkedAt,
+        url: url.toString(),
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+  return summarizeTelemetryReceipt(receipt);
+}
diff --git a/packages/db/src/preflight-power-publication.ts b/packages/db/src/preflight-power-publication.ts
new file mode 100644
index 000000000..031c07170
--- /dev/null
+++ b/packages/db/src/preflight-power-publication.ts
@@ -0,0 +1,36 @@
+import { verifyRequiredPowerArtifacts } from './etl/required-power-publication';
+
+// Deliberately artifact-only: this entry point opens no DB connection and writes no files.
+const [root, runId, runAttempt, headSha, option] = process.argv.slice(2);
+if (
+  !root ||
+  !runId ||
+  !runAttempt ||
+  !/^\d+$/u.test(runId) ||
+  !/^\d+$/u.test(runAttempt) ||
+  !Number.isSafeInteger(Number(runId)) ||
+  !Number.isSafeInteger(Number(runAttempt)) ||
+  Number(runId) <= 0 ||
+  Number(runAttempt) <= 0 ||
+  !headSha ||
+  !/^[a-f0-9]{40}$/u.test(headSha) ||
+  (option !== undefined && option !== '--optional-power') ||
+  process.argv.length > 7
+)
+  throw new Error(
+    'Usage: preflight-power-publication.ts <artifacts-dir> <source-run-id> <attempt> <head-sha> [--optional-power]',
+  );
+
+const points = verifyRequiredPowerArtifacts(
+  root,
+  { runId: Number(runId), runAttempt: Number(runAttempt), headSha },
+  option !== '--optional-power',
+);
+console.log(
+  JSON.stringify({
+    status: 'validated_artifacts',
+    requiredPoints: points.length,
+    databaseWrites: 0,
+    curvePreservation: 'not_checked_requires_published_state',
+  }),
+);
diff --git a/packages/db/src/verify-power-publication.ts b/packages/db/src/verify-power-publication.ts
index 84bf86723..41038b292 100644
--- a/packages/db/src/verify-power-publication.ts
+++ b/packages/db/src/verify-power-publication.ts
@@ -1,7 +1,9 @@
 import fs from 'node:fs';
 import { DB_MODEL_TO_DISPLAY } from '@semianalysisai/inferencex-constants';
 import { createAdminSql } from './etl/db-utils';
+import { verifyTelemetryApi } from './etl/telemetry-receipt';
 import {
+  fatalPublicationErrors,
   verifyPowerPublication,
   type PowerPublicationManifest,
   type PublishedPowerRow,
@@ -33,12 +35,12 @@ try {
     join workflow_runs wr on wr.id = br.workflow_run_id
     where wr.github_run_id = ${manifest.runId} and wr.run_attempt = ${manifest.runAttempt}
       and (br.benchmark_type = 'agentic_traces' or
-        (br.benchmark_type = 'single_turn' and br.isl = 8192 and br.osl = 1024))
+        (br.benchmark_type = 'single_turn' and br.isl in (1024, 8192) and br.osl = 1024))
   `;
-  const errors = [
-    ...(manifest.ingestErrors ?? []),
-    ...verifyPowerPublication(manifest.points, rows as unknown as PublishedPowerRow[], 'database'),
-  ];
+  const errors = fatalPublicationErrors(
+    manifest,
+    verifyPowerPublication(manifest.points, rows as unknown as PublishedPowerRow[], 'database'),
+  );
   const publicRows: PublishedPowerRow[] = [];
   const models = [
     ...new Set(manifest.points.map((point) => DB_MODEL_TO_DISPLAY[String(point.identity.model)])),
@@ -70,6 +72,19 @@ try {
     publicRows.push(...body);
   }
   errors.push(...verifyPowerPublication(manifest.points, publicRows, 'public API'));
+  if (manifest.telemetry) {
+    if (
+      manifest.telemetry.runId !== manifest.runId ||
+      manifest.telemetry.runAttempt !== manifest.runAttempt
+    )
+      throw new Error('Telemetry receipt belongs to a different run/attempt');
+    manifest.telemetry = await verifyTelemetryApi(manifest.telemetry, origin, {
+      headers: process.env.CACHE_PROTECTION_BYPASS_SECRET
+        ? { 'x-vercel-protection-bypass': process.env.CACHE_PROTECTION_BYPASS_SECRET }
+        : undefined,
+    });
+    fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+  }
   const counts = { strict: 0, invalid: 0, other: 0 };
   for (const point of manifest.points) {
     if (point.metrics.power_valid === 1 && point.metrics.power_metric_schema_version === 2)
@@ -86,6 +101,10 @@ try {
     status:
       errors.length > 0 ? 'failed' : manifest.points.length > 0 ? 'matched' : 'no_power_points',
     errors,
+    // Kept out of `errors` on purpose: a telemetry digest failure costs one
+    // point's PowerX tab, not its benchmark data, so it must not fail the ingest.
+    telemetryWarnings: manifest.telemetryWarnings ?? [],
+    ...(manifest.telemetry ? { telemetry: manifest.telemetry } : {}),
   };
   fs.writeFileSync(`${manifestPath}.verification.json`, `${JSON.stringify(receipt, null, 2)}\n`);
   console.log(JSON.stringify(receipt, null, 2));

From 9ced2ec0895e88a731d205e422a9d6c8d15d04ba Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 092/103] feat(db): telemetry backfill CLI, purge accounting
 and benchmark refresh
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Backfill historical runs from GitHub artifacts before retention expires, skipping
purged points; purge telemetry alongside run overrides with explicit counts; refresh
recovered power_audit fields and invalidate the cache after a backfill.

中文：在 artifact 过期前从 GitHub 回填历史 run 并跳过已清理点；run overrides 清理时同步删除遥测并显式计数；回填后刷新恢复的 power_audit 字段并失效缓存。
---
 packages/db/src/apply-overrides.ts            |  28 +-
 packages/db/src/backfill-gpu-metrics.ts       | 675 ++++++++++++++++++
 packages/db/src/backfill-server-log-files.ts  | 113 +--
 .../db/src/lib/backfill-benchmark-refresh.ts  | 224 ++++++
 packages/db/src/lib/backfill-runner.ts        |  25 +
 .../src/lib/benchmark-result-lookup.test.ts   | 164 +++++
 .../db/src/lib/benchmark-result-lookup.ts     | 153 ++++
 .../db/src/lib/gpu-metrics-backfill.test.ts   |  50 ++
 packages/db/src/lib/gpu-metrics-backfill.ts   | 134 ++++
 packages/db/src/lib/telemetry-purge.ts        | 100 +++
 10 files changed, 1570 insertions(+), 96 deletions(-)
 create mode 100644 packages/db/src/backfill-gpu-metrics.ts
 create mode 100644 packages/db/src/lib/backfill-benchmark-refresh.ts
 create mode 100644 packages/db/src/lib/benchmark-result-lookup.test.ts
 create mode 100644 packages/db/src/lib/benchmark-result-lookup.ts
 create mode 100644 packages/db/src/lib/gpu-metrics-backfill.test.ts
 create mode 100644 packages/db/src/lib/gpu-metrics-backfill.ts
 create mode 100644 packages/db/src/lib/telemetry-purge.ts

diff --git a/packages/db/src/apply-overrides.ts b/packages/db/src/apply-overrides.ts
index 6ac41680b..62188b705 100644
--- a/packages/db/src/apply-overrides.ts
+++ b/packages/db/src/apply-overrides.ts
@@ -26,6 +26,13 @@ import { type Sql, createAdminSql, refreshLatestBenchmarks } from './etl/db-util
 import { jsonbParam } from './lib/backfill-runner.js';
 import { planBenchmarkPointBackfill } from './lib/benchmark-point-backfill.js';
 import { selectRunOverrides } from './lib/run-override-selection.js';
+import {
+  type TelemetryPurgeCounts,
+  countRunTelemetry,
+  deleteRunTelemetry,
+  describeTelemetry,
+  unlinkPointTelemetry,
+} from './lib/telemetry-purge.js';
 import {
   type BenchmarkPointBackfill,
   type ChangelogBackfill,
@@ -315,6 +322,7 @@ interface PurgeTarget {
   stats: number;
   evals: number;
   changelogs: number;
+  telemetry: TelemetryPurgeCounts;
 }
 
 /**
@@ -358,17 +366,21 @@ async function previewPurge(
     );
   }
 
-  const [[bmk], [stats], [evals], [changelogs], [logs]] = await Promise.all([
+  const [[bmk], [stats], [evals], [changelogs], [logs], telemetry] = await Promise.all([
     sql`SELECT count(*)::int AS n FROM benchmark_results WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(*)::int AS n FROM run_stats WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(*)::int AS n FROM eval_results WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(*)::int AS n FROM changelog_entries WHERE workflow_run_id = ANY(${wrIds})`,
     sql`SELECT count(DISTINCT server_log_id)::int AS n FROM benchmark_results WHERE workflow_run_id = ANY(${wrIds}) AND server_log_id IS NOT NULL`,
+    countRunTelemetry(sql, wrIds),
   ]);
 
   console.log(
     `    ${bmk.n} benchmarks, ${logs.n} server_logs, ${stats.n} run_stats, ${evals.n} evals, ${changelogs.n} changelogs`,
   );
+  // Surfaced separately: past GitHub's 90-day artifact retention these samples
+  // are the only copy, so the operator should see them before confirming.
+  if (telemetry.series > 0) console.log(`    ${describeTelemetry(telemetry)}`);
 
   return {
     githubRunId,
@@ -378,6 +390,7 @@ async function previewPurge(
     stats: stats.n,
     evals: evals.n,
     changelogs: changelogs.n,
+    telemetry,
   };
 }
 
@@ -404,6 +417,14 @@ async function purgeBenchmarkResults(tx: Sql, resultIds: number[]): Promise<void
     WHERE id = ANY(${resultIds}) AND trace_replay_id IS NOT NULL
   `;
 
+  // Drop the point→series links explicitly rather than through the cascade on
+  // benchmark_results, so the transcript records it. The series itself stays: it
+  // belongs to the workflow_run, which survives a point purge, and
+  // /api/gpu-metrics?runId= reads series by run rather than through these links.
+  const unlinked = await unlinkPointTelemetry(tx, resultIds);
+  if (unlinked > 0)
+    console.log(`    unlinked ${unlinked} gpu_metric_series link(s); series kept with the run.`);
+
   await tx`DELETE FROM benchmark_results WHERE id = ANY(${resultIds})`;
 
   const sIds = logRows.map((r) => r.id as number);
@@ -493,6 +514,11 @@ async function purge(wrIds: number[]): Promise<void> {
     await tx`DELETE FROM eval_results WHERE workflow_run_id = ANY(${wrIds})`;
     await tx`DELETE FROM changelog_entries WHERE workflow_run_id = ANY(${wrIds})`;
 
+    // Telemetry too. The workflow_runs delete below would cascade it away anyway,
+    // but silently; deleting it here reports the cost of an irreversible loss.
+    const telemetry = await deleteRunTelemetry(tx, wrIds);
+    if (telemetry.series > 0) console.log(`    deleted ${describeTelemetry(telemetry)}.`);
+
     // Parent last (target the specific workflow_runs rows so partial purges
     // leave sibling attempts of the same github_run_id intact)
     await tx`DELETE FROM workflow_runs WHERE id = ANY(${wrIds})`;
diff --git a/packages/db/src/backfill-gpu-metrics.ts b/packages/db/src/backfill-gpu-metrics.ts
new file mode 100644
index 000000000..cb898f0d8
--- /dev/null
+++ b/packages/db/src/backfill-gpu-metrics.ts
@@ -0,0 +1,675 @@
+/**
+ * Backfill PowerX telemetry (`gpu_metrics_<suffix>` artifacts) into the
+ * migration-016 tables for runs that were ingested before the CI path
+ * digested them.
+ *
+ * GitHub keeps run artifacts for 90 days and the GCS mirror only covers
+ * scheduled/push runs on main, so the reachable history is bounded by GitHub
+ * retention; runs GitHub has since deleted are reported and skipped. Each
+ * gpu_metrics artifact is paired with its exact `bmk_<suffix>`
+ * (or `bmk_agentic_<suffix>`) sibling, the raw rows are mapped through the
+ * production mapper, and the series is linked to those persisted points.
+ *
+ * Usage:
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --run 34557177019 --yes
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --all --yes
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --all --since 2026-08-01 --dry-run
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --all --force --limit 20 --yes
+ *
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --stats-only --all --dry-run
+ *   bun run --cwd packages/db db:backfill-gpu-metrics --stats-only --run 34557177019 --yes
+ *
+ * --stats-only upgrades outdated digests from DB samples without GitHub access.
+ * It includes all retained attempts and dates unless explicitly filtered.
+ *
+ * Runs that already have at least one stored series are skipped unless
+ * --force is passed. --parallel N (default 4) bounds concurrent artifact
+ * downloads within one run.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { hasNoSslFlag } from './cli-utils.js';
+import { AsyncSemaphore } from './etl/async-semaphore.js';
+import { createAdminSql } from './etl/db-utils.js';
+import { ingestGpuMetricsArtifact, refreshGpuMetricStats } from './etl/gpu-metrics-ingest.js';
+import { readPowerAuditValidations } from './etl/gpu-metrics-artifacts.js';
+import { recoveredPowerAudit } from './etl/power-audit-validations.js';
+import {
+  benchmarkPublicationIdentity,
+  stablePowerPointIdentity,
+  type PowerPublicationManifest,
+} from './etl/power-publication.js';
+import {
+  readTelemetryReceipt,
+  summarizeTelemetryReceipt,
+  telemetryArtifactsForAttempt,
+  type TelemetryObservation,
+  type TelemetryReceipt,
+} from './etl/telemetry-receipt.js';
+import { retryArtifactOperation } from './lib/artifact-retry.js';
+import {
+  checkpointBenchmarkRefresh,
+  refreshBackfillBenchmarks,
+  type BenchmarkAuditUpdate,
+} from './lib/backfill-benchmark-refresh.js';
+import {
+  confirmProceed,
+  listBackfillRunArtifacts,
+  parseLimitForceFlags,
+  runBackfillMain,
+} from './lib/backfill-runner.js';
+import {
+  filterPurgedBenchmarkRows,
+  findBenchmarkResultIds,
+  readMappedBenchmarkRows,
+} from './lib/benchmark-result-lookup.js';
+import { downloadArtifact, fetchRunMeta } from './lib/github-artifacts.js';
+import {
+  pairGpuMetricsArtifacts,
+  findOutdatedGpuMetricSeries,
+  collectMissingTelemetryExpectations,
+  type GpuMetricsArtifactPair,
+} from './lib/gpu-metrics-backfill.js';
+import { repositoryFromRunUrl } from './lib/runtime-metadata-artifacts.js';
+
+const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
+const GITHUB_RETENTION_DAYS = 90;
+const sql = createAdminSql({ noSsl: hasNoSslFlag(), max: 4, onnotice: () => {} });
+
+interface CandidateRun {
+  id: number;
+  github_run_id: number;
+  run_attempt: number;
+  html_url: string | null;
+  date: string;
+  series_count: number;
+}
+
+interface BackfillFlags {
+  all: boolean;
+  dryRun: boolean;
+  run: number | null;
+  fromRun: number | null;
+  since: string | null;
+  parallel: number;
+  attempt: number | null;
+  artifact: string | null;
+  receipt: string | null;
+  refreshCacheOnly: boolean;
+  statsOnly: boolean;
+}
+
+function positiveIntFlag(flag: string): number | null {
+  const index = process.argv.indexOf(flag);
+  if (index === -1) return null;
+  const raw = process.argv[index + 1];
+  if (!raw || !/^\d+$/u.test(raw) || Number(raw) <= 0) {
+    throw new Error(`${flag} requires a positive integer`);
+  }
+  return Number(raw);
+}
+
+function stringFlag(flag: string): string | null {
+  const index = process.argv.indexOf(flag);
+  if (index === -1) return null;
+  const value = process.argv[index + 1];
+  if (!value || value.startsWith('--')) throw new Error(`${flag} requires a value`);
+  return value;
+}
+
+function parseFlags(): BackfillFlags {
+  const sinceIndex = process.argv.indexOf('--since');
+  const since = sinceIndex === -1 ? null : (process.argv[sinceIndex + 1] ?? null);
+  if (sinceIndex !== -1 && (!since || !/^\d{4}-\d{2}-\d{2}$/u.test(since))) {
+    throw new Error('--since requires a YYYY-MM-DD date');
+  }
+  return {
+    all: process.argv.includes('--all'),
+    dryRun: process.argv.includes('--dry-run'),
+    run: positiveIntFlag('--run'),
+    fromRun: positiveIntFlag('--from-run'),
+    since,
+    parallel: positiveIntFlag('--parallel') ?? 4,
+    attempt: positiveIntFlag('--attempt'),
+    artifact: stringFlag('--artifact'),
+    receipt: stringFlag('--receipt'),
+    refreshCacheOnly: process.argv.includes('--refresh-cache-only'),
+    statsOnly: process.argv.includes('--stats-only'),
+  };
+}
+
+function isWithinGithubRetention(date: string): boolean {
+  const ageMs = Date.now() - new Date(date).getTime();
+  return ageMs <= GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+}
+
+async function loadCandidateRuns(
+  flags: BackfillFlags,
+  limit: number | null,
+  force: boolean,
+): Promise<CandidateRun[]> {
+  const cutoff = new Date(Date.now() - GITHUB_RETENTION_DAYS * 24 * 60 * 60 * 1000)
+    .toISOString()
+    .slice(0, 10);
+  const since = flags.since ?? cutoff;
+  const rows = await sql<CandidateRun[]>`
+    select wr.id, wr.github_run_id, wr.run_attempt, wr.html_url, wr.date::text as date,
+      (select count(*)::int from gpu_metric_series s where s.workflow_run_id = wr.id) as series_count
+    from workflow_runs wr
+    where exists (select 1 from benchmark_results br where br.workflow_run_id = wr.id)
+      and (${flags.run}::bigint is null or wr.github_run_id = ${flags.run})
+      and (${flags.fromRun}::bigint is null or wr.github_run_id >= ${flags.fromRun})
+      and (${flags.run}::bigint is not null or wr.date >= ${since}::date)
+      and ((${flags.attempt}::integer is not null and wr.run_attempt = ${flags.attempt}) or
+        (${flags.attempt}::integer is null and not exists (
+          select 1 from workflow_runs newer where newer.github_run_id = wr.github_run_id
+            and newer.run_attempt > wr.run_attempt)))
+    order by wr.date desc, wr.github_run_id desc
+  `;
+  const candidates = rows
+    .map((row) => ({
+      ...row,
+      id: Number(row.id),
+      github_run_id: Number(row.github_run_id),
+      series_count: Number(row.series_count),
+    }))
+    .filter((row) => force || flags.run !== null || row.series_count === 0);
+  return limit === null ? candidates : candidates.slice(0, limit);
+}
+
+type PairOutcome =
+  | {
+      kind: 'ingested';
+      seriesCount: number;
+      samplesInserted: number;
+      pointsLinked: number;
+      expectationsUnknown: boolean;
+      metadataUpdatedBenchmarkResultIds: number[];
+    }
+  | { kind: 'unmatched' }
+  | { kind: 'failed' };
+
+/** Download one gpu_metrics/bmk pair, resolve its points, and persist the series. */
+async function processPair(
+  run: CandidateRun,
+  pair: GpuMetricsArtifactPair,
+  tempDir: string,
+  observations: Map<string, TelemetryObservation>,
+  expectationErrors: NonNullable<TelemetryReceipt['expectationErrors']>,
+  uniqueFallbacks: Map<string, number>,
+  checkpointMetadata: (updates: BenchmarkAuditUpdate[]) => Promise<void>,
+): Promise<PairOutcome> {
+  let benchmarkDir: string | null = null;
+  let gpuMetricsDir: string | null = null;
+  const pointKeys: string[] = [];
+  let expectationsUnknown = false;
+  try {
+    benchmarkDir = await retryArtifactOperation(`downloading ${pair.benchmarks.name}`, () =>
+      downloadArtifact(pair.benchmarks, tempDir),
+    );
+    const mappedRows = await filterPurgedBenchmarkRows(
+      sql,
+      run,
+      readMappedBenchmarkRows(benchmarkDir, (error) => {
+        expectationsUnknown = true;
+        expectationErrors.push({
+          benchmarkArtifact: pair.benchmarks.name,
+          artifactNames: [pair.gpuMetrics.name],
+          error,
+        });
+      }),
+    );
+    for (const row of mappedRows) {
+      const identity = benchmarkPublicationIdentity(row);
+      const key = stablePowerPointIdentity(identity);
+      pointKeys.push(key);
+      observations.set(key, { identity, artifactNames: [pair.gpuMetrics.name], produced: true });
+    }
+    const matchedIds: number[] = [];
+    const mappedPoints: { ids: number[]; identity: Record<string, unknown> }[] = [];
+    for (const row of mappedRows) {
+      const ids = await findBenchmarkResultIds(sql, run, [row], (id) =>
+        uniqueFallbacks.set(stablePowerPointIdentity(benchmarkPublicationIdentity(row)), id),
+      );
+      if (ids.length === 0) throw new Error(`${pair.gpuMetrics.name}: no matching benchmark rows`);
+      matchedIds.push(...ids);
+      if (row.benchmarkType === 'agentic_traces')
+        mappedPoints.push({ ids, identity: benchmarkPublicationIdentity(row) });
+    }
+    const resultIds = [...new Set(matchedIds)];
+    if (resultIds.length === 0) {
+      if (expectationsUnknown) return { kind: 'failed' };
+      console.warn(`  [WARN] ${pair.gpuMetrics.name}: no matching benchmark rows`);
+      return { kind: 'unmatched' };
+    }
+    gpuMetricsDir = await retryArtifactOperation(`downloading ${pair.gpuMetrics.name}`, () =>
+      downloadArtifact(pair.gpuMetrics, tempDir),
+    );
+    const validations = Object.entries(
+      readPowerAuditValidations(gpuMetricsDir, pair.gpuMetrics.name),
+    )
+      .map(([source, validation]) => ({
+        powerAudit: recoveredPowerAudit(source, validation),
+        conc: (validation.selected_window as Record<string, unknown> | undefined)?.concurrency,
+      }))
+      .filter((validation) => validation.powerAudit !== null);
+    const auditUpdates: BenchmarkAuditUpdate[] = [];
+    for (const point of mappedPoints) {
+      const candidates = validations.filter(
+        (validation) => validation.conc === point.identity.conc,
+      );
+      if (candidates.length !== 1) continue;
+      const powerAudit = candidates[0]!.powerAudit;
+      if (powerAudit)
+        auditUpdates.push(
+          ...point.ids.map((benchmarkResultId) => ({
+            benchmarkResultId,
+            identity: point.identity,
+            powerAudit,
+          })),
+        );
+    }
+    await checkpointMetadata(auditUpdates);
+    const ingested = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: run.id,
+      artifact: { artifactName: pair.gpuMetrics.name, artifactDir: gpuMetricsDir },
+      benchmarkResultIds: resultIds,
+    });
+    if (ingested.seriesIds.length === 0) {
+      throw new Error(`${pair.gpuMetrics.name}: no parseable gpu_metrics CSV`);
+    }
+    return {
+      kind: 'ingested',
+      seriesCount: ingested.seriesIds.length,
+      samplesInserted: ingested.samplesInserted,
+      pointsLinked: resultIds.length,
+      expectationsUnknown,
+      metadataUpdatedBenchmarkResultIds: ingested.metadataUpdatedBenchmarkResultIds,
+    };
+  } catch (error) {
+    if (pointKeys.length === 0)
+      expectationErrors.push({
+        benchmarkArtifact: pair.benchmarks.name,
+        artifactNames: [pair.gpuMetrics.name],
+        error: error instanceof Error ? error.message : String(error),
+      });
+    for (const key of pointKeys) {
+      const observation = observations.get(key)!;
+      observation.error = error instanceof Error ? error.message : String(error);
+    }
+    console.error(`  ✗ run ${run.github_run_id} artifact ${pair.gpuMetrics.name}:`, error);
+    return { kind: 'failed' };
+  } finally {
+    if (benchmarkDir) fs.rmSync(benchmarkDir, { recursive: true, force: true });
+    if (gpuMetricsDir) fs.rmSync(gpuMetricsDir, { recursive: true, force: true });
+  }
+}
+
+async function main(): Promise<void> {
+  const flags = parseFlags();
+  const { limit, force } = parseLimitForceFlags();
+  if (!flags.all && flags.run === null) {
+    throw new Error('Pass --run <github run id> or --all');
+  }
+  if ((flags.attempt !== null || flags.artifact || flags.receipt) && flags.run === null)
+    throw new Error('--attempt, --artifact and --receipt require --run');
+  if (
+    flags.refreshCacheOnly &&
+    (!flags.run || !flags.receipt || flags.artifact || flags.all || flags.dryRun)
+  )
+    throw new Error(
+      '--refresh-cache-only requires --run and --receipt, without --all, --artifact or --dry-run',
+    );
+  if (flags.refreshCacheOnly && !fs.existsSync(flags.receipt!))
+    throw new Error('--refresh-cache-only requires an existing receipt');
+
+  if (flags.statsOnly) {
+    if (flags.refreshCacheOnly || flags.receipt || force)
+      throw new Error(
+        '--stats-only cannot be combined with --refresh-cache-only, --receipt or --force',
+      );
+    const series = await findOutdatedGpuMetricSeries(sql, flags, limit);
+    console.log(`${series.length} outdated digest(s); --limit counts series in --stats-only mode`);
+    if (flags.dryRun) {
+      console.table(series);
+      return;
+    }
+    if (
+      series.length === 0 ||
+      !(await confirmProceed('Recompute only these stored telemetry digests?'))
+    )
+      return;
+    for (const row of series) {
+      try {
+        const updated = await refreshGpuMetricStats(sql, Number(row.id));
+        console.log(
+          `series ${row.id} run ${row.github_run_id} attempt ${row.run_attempt}: ${updated ? 'updated' : 'current'}`,
+        );
+      } catch (error) {
+        process.exitCode = 1;
+        console.error(
+          `series ${row.id} failed; retry --stats-only --run ${row.github_run_id} --attempt ${row.run_attempt} --artifact ${row.artifact_name} --yes`,
+          error,
+        );
+      }
+    }
+    return;
+  }
+
+  console.log('=== backfill-gpu-metrics ===');
+  const runs = await loadCandidateRuns(flags, limit, force);
+  const staleRuns = runs.filter((run) => !isWithinGithubRetention(run.date)).length;
+  const staleNote =
+    staleRuns > 0
+      ? ` (${staleRuns} older than GitHub's ${GITHUB_RETENTION_DAYS}-day retention)`
+      : '';
+  console.log(`  ${runs.length} candidate run(s)${staleNote}`);
+  if (runs.length === 0) {
+    if (flags.attempt !== null || flags.artifact || flags.receipt)
+      throw new Error(
+        `No persisted benchmark target for run ${flags.run} attempt ${flags.attempt ?? 'latest'}`,
+      );
+    console.log('\n  Nothing to do.');
+    return;
+  }
+
+  if (flags.dryRun) {
+    let pairedRuns = 0;
+    let pairs = 0;
+    let goneRuns = 0;
+    let failedRuns = 0;
+    for (const run of runs) {
+      try {
+        const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
+        const artifacts = await listBackfillRunArtifacts(repository, run.github_run_id);
+        if (artifacts === null) {
+          goneRuns++;
+          console.log(`  run ${run.github_run_id} (${run.date}): gone from GitHub`);
+          continue;
+        }
+        const runPairs = pairGpuMetricsArtifacts(
+          telemetryArtifactsForAttempt(
+            artifacts,
+            fetchRunMeta(repository, String(run.github_run_id)),
+            run.run_attempt,
+          ),
+        ).filter((pair) => !flags.artifact || pair.gpuMetrics.name === flags.artifact);
+        if (runPairs.length > 0) pairedRuns++;
+        pairs += runPairs.length;
+        console.log(`  run ${run.github_run_id} (${run.date}): ${runPairs.length} pair(s)`);
+      } catch (error) {
+        if (flags.run !== null) throw error;
+        failedRuns++;
+        console.error(
+          `  run ${run.github_run_id} (${run.date}): ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+    console.log(
+      `\n=== dry run: ${runs.length} run(s), ${pairedRuns} with pairs, ${pairs} pair(s), ` +
+        `${goneRuns} gone from GitHub, ${failedRuns} failed ===`,
+    );
+    if (failedRuns > 0) process.exitCode = 1;
+    return;
+  }
+
+  if (
+    !(await confirmProceed(
+      flags.refreshCacheOnly
+        ? 'Only the recorded benchmark metadata cache will be refreshed.'
+        : `${runs.length} workflow run(s) will be checked for gpu_metrics.`,
+    ))
+  ) {
+    return;
+  }
+
+  let artifactsProcessed = 0;
+  let seriesStored = 0;
+  let samplesStored = 0;
+  let pointsLinked = 0;
+  let unmatchedArtifacts = 0;
+  let artifactFailures = 0;
+  let runFailures = 0;
+  let missingRuns = 0;
+  let goneRuns = 0;
+
+  for (const [runIndex, run] of runs.entries()) {
+    const runId = run.github_run_id;
+    const repository = repositoryFromRunUrl(run.html_url) ?? DEFAULT_REPO;
+    const runStart = Date.now();
+    const receiptPath =
+      flags.receipt ?? `power-publication-${runId}-attempt-${run.run_attempt}.json`;
+    const manifest: PowerPublicationManifest = fs.existsSync(receiptPath)
+      ? JSON.parse(fs.readFileSync(receiptPath, 'utf8'))
+      : { version: 1, runId, runAttempt: run.run_attempt, points: [] };
+    if (
+      manifest.version !== 1 ||
+      manifest.runId !== runId ||
+      manifest.runAttempt !== run.run_attempt ||
+      !Array.isArray(manifest.points) ||
+      (manifest.telemetry &&
+        (manifest.telemetry.runId !== runId || manifest.telemetry.runAttempt !== run.run_attempt))
+    )
+      throw new Error('Publication receipt run/attempt does not match the recovery target');
+    const saveReceipt = () => {
+      fs.mkdirSync(path.dirname(path.resolve(receiptPath)), { recursive: true });
+      const temporary = `${receiptPath}.tmp`;
+      fs.writeFileSync(temporary, `${JSON.stringify(manifest, null, 2)}\n`, { flush: true });
+      fs.renameSync(temporary, receiptPath);
+    };
+    const refresh = async () => {
+      try {
+        await refreshBackfillBenchmarks(sql, manifest, saveReceipt);
+      } catch (error) {
+        process.exitCode = 1;
+        console.error(
+          `  Benchmark metadata refresh failed; retry --refresh-cache-only --run ${runId} --attempt ${run.run_attempt} --receipt ${receiptPath} --yes`,
+          error,
+        );
+      }
+    };
+    if (flags.refreshCacheOnly) {
+      await refresh();
+      continue;
+    }
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `gpu-metrics-backfill-${runId}-`));
+    const checkpointMetadata = async (updates: BenchmarkAuditUpdate[]) => {
+      if (updates.length === 0) return;
+      const candidates = await sql<{ id: number; offload_mode: string }[]>`
+        select br.id, br.offload_mode from benchmark_results br
+        where br.workflow_run_id = ${run.id}
+          and br.id = any(${sql.array(updates.map((update) => update.benchmarkResultId))}::bigint[])
+          and br.benchmark_type = 'agentic_traces' and br.power_audit is null
+      `;
+      checkpointBenchmarkRefresh(
+        manifest,
+        candidates.map((row) => Number(row.id)),
+        saveReceipt,
+        candidates.map((row) => {
+          const update = updates.find((entry) => entry.benchmarkResultId === Number(row.id))!;
+          return {
+            ...update,
+            sourceIdentity: update.identity,
+            identity: { ...update.identity, offload_mode: row.offload_mode },
+          };
+        }),
+      );
+    };
+    const observations = new Map<string, TelemetryObservation>();
+    const uniqueFallbacks = new Map<string, number>();
+    let recoveryError: string | undefined;
+    let expectationErrors: TelemetryReceipt['expectationErrors'];
+    try {
+      const listedArtifacts = await listBackfillRunArtifacts(repository, runId);
+      if (listedArtifacts === null) {
+        goneRuns++;
+        runFailures++;
+        recoveryError = `Run ${runId} attempt ${run.run_attempt} is gone from GitHub`;
+        console.log(
+          `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt}: gone from GitHub`,
+        );
+        continue;
+      }
+      const artifacts = telemetryArtifactsForAttempt(
+        listedArtifacts,
+        fetchRunMeta(repository, String(runId)),
+        run.run_attempt,
+      );
+      const allPairs = pairGpuMetricsArtifacts(artifacts);
+      const pairs = allPairs.filter(
+        (pair) => !flags.artifact || pair.gpuMetrics.name === flags.artifact,
+      );
+      // Expectations come from benchmark siblings even when no telemetry was
+      // uploaded. Counting only the successful pairs would hide missing points.
+      const missing = await collectMissingTelemetryExpectations(
+        artifacts,
+        allPairs,
+        flags.artifact,
+        async (artifact, onUnmapped) => {
+          let directory: string | null = null;
+          try {
+            directory = await retryArtifactOperation(`downloading ${artifact.name}`, () =>
+              downloadArtifact(artifact, tempDir),
+            );
+            const rows = await filterPurgedBenchmarkRows(
+              sql,
+              run,
+              readMappedBenchmarkRows(directory, onUnmapped),
+            );
+            for (const row of rows)
+              await findBenchmarkResultIds(sql, run, [row], (id) =>
+                uniqueFallbacks.set(
+                  stablePowerPointIdentity(benchmarkPublicationIdentity(row)),
+                  id,
+                ),
+              );
+            return rows;
+          } finally {
+            if (directory) fs.rmSync(directory, { recursive: true, force: true });
+          }
+        },
+      );
+      for (const observation of missing.observations)
+        observations.set(stablePowerPointIdentity(observation.identity), observation);
+      expectationErrors = missing.errors;
+      artifactFailures += new Set(missing.errors.map((error) => error.benchmarkArtifact)).size;
+      if (pairs.length === 0) {
+        if (flags.artifact) {
+          artifactFailures++;
+          recoveryError = `No retained telemetry pair for ${flags.artifact}`;
+        }
+        missingRuns++;
+        console.log(
+          `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt}: no retained gpu_metrics pairs`,
+        );
+        continue;
+      }
+
+      const limiter = new AsyncSemaphore(flags.parallel);
+      const outcomes = await Promise.all(
+        pairs.map((pair) =>
+          limiter.run(() =>
+            processPair(
+              run,
+              pair,
+              tempDir,
+              observations,
+              missing.errors,
+              uniqueFallbacks,
+              checkpointMetadata,
+            ),
+          ),
+        ),
+      );
+      let runSeries = 0;
+      let runSamples = 0;
+      for (const outcome of outcomes) {
+        switch (outcome.kind) {
+          case 'ingested': {
+            artifactsProcessed++;
+            if (outcome.expectationsUnknown) artifactFailures++;
+            runSeries += outcome.seriesCount;
+            runSamples += outcome.samplesInserted;
+            pointsLinked += outcome.pointsLinked;
+            checkpointBenchmarkRefresh(
+              manifest,
+              outcome.metadataUpdatedBenchmarkResultIds,
+              saveReceipt,
+            );
+            break;
+          }
+          case 'unmatched': {
+            unmatchedArtifacts++;
+            break;
+          }
+          case 'failed': {
+            artifactFailures++;
+            break;
+          }
+        }
+      }
+      seriesStored += runSeries;
+      samplesStored += runSamples;
+      console.log(
+        `  [${runIndex + 1}/${runs.length}] run ${runId} attempt ${run.run_attempt} (${run.date}): ` +
+          `${pairs.length} pair(s), ${runSeries} series, +${runSamples} samples ` +
+          `(${((Date.now() - runStart) / 1000).toFixed(1)}s)`,
+      );
+    } catch (error) {
+      runFailures++;
+      recoveryError = error instanceof Error ? error.message : String(error);
+      console.error(`  ✗ run ${runId}:`, error);
+    } finally {
+      manifest.telemetry = await readTelemetryReceipt(
+        sql,
+        { runId, runAttempt: run.run_attempt },
+        [...observations.values()],
+        { previous: manifest.telemetry, targeted: Boolean(flags.artifact), uniqueFallbacks },
+      );
+      if (recoveryError) {
+        const priorError = manifest.telemetry.recoveryError;
+        const priorScope = manifest.telemetry.recoveryArtifactNames;
+        manifest.telemetry.recoveryError = [
+          ...new Set([priorError, recoveryError].filter(Boolean).join('\n').split('\n')),
+        ].join('\n');
+        if (flags.artifact && (!priorError || priorScope))
+          manifest.telemetry.recoveryArtifactNames = [
+            ...new Set([...(priorScope ?? []), flags.artifact]),
+          ];
+        else delete manifest.telemetry.recoveryArtifactNames;
+      }
+      if (expectationErrors) {
+        const failedBenchmarks = new Set(expectationErrors.map((error) => error.benchmarkArtifact));
+        manifest.telemetry.expectationErrors = [
+          ...(manifest.telemetry.expectationErrors ?? []).filter(
+            (error) => !failedBenchmarks.has(error.benchmarkArtifact),
+          ),
+          ...expectationErrors,
+        ];
+      }
+      summarizeTelemetryReceipt(manifest.telemetry);
+      saveReceipt();
+      if (manifest.benchmarkRefresh && manifest.benchmarkRefresh.status !== 'complete')
+        await refresh();
+      console.log(`  PowerX ingest receipt: ${receiptPath}`);
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+
+  console.log(
+    `\n=== backfill complete: ${artifactsProcessed} artifact(s), ${seriesStored} series, ` +
+      `${samplesStored} sample(s), ${pointsLinked} point link(s), ` +
+      `${unmatchedArtifacts} unmatched artifact(s), ` +
+      `${missingRuns} run(s) without pairs, ${goneRuns} run(s) gone from GitHub, ` +
+      `${artifactFailures} failed artifact(s), ${runFailures} failed run(s) ===`,
+  );
+  console.log(
+    '  Point telemetry reads use the stored revision; API verification is recorded separately.',
+  );
+  if (artifactFailures > 0 || runFailures > 0) process.exitCode = 1;
+}
+
+runBackfillMain('backfill-gpu-metrics', sql, main);
diff --git a/packages/db/src/backfill-server-log-files.ts b/packages/db/src/backfill-server-log-files.ts
index 8047e0db5..46c0d05be 100644
--- a/packages/db/src/backfill-server-log-files.ts
+++ b/packages/db/src/backfill-server-log-files.ts
@@ -19,24 +19,25 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { hasNoSslFlag } from './cli-utils.js';
-import { mapBenchmarkRow, type BenchmarkParams } from './etl/benchmark-mapper.js';
 import { insertServerLogFilePaths } from './etl/benchmark-ingest.js';
 import { createAdminSql } from './etl/db-utils.js';
 import { listServerLogFilePaths, serverLogArtifactRoot } from './etl/server-log-artifacts.js';
-import { createSkipTracker } from './etl/skip-tracker.js';
-import { downloadArtifact, listRunArtifacts } from './lib/github-artifacts.js';
+import { downloadArtifact } from './lib/github-artifacts.js';
 import {
   downloadGcsArtifact,
   listGcsServerLogArtifacts,
   type GcsArtifactMeta,
 } from './lib/gcs-artifacts.js';
-import { confirmProceed, parseLimitForceFlags, runBackfillMain } from './lib/backfill-runner.js';
+import {
+  confirmProceed,
+  listBackfillRunArtifacts,
+  parseLimitForceFlags,
+  runBackfillMain,
+} from './lib/backfill-runner.js';
 import { retryArtifactOperation } from './lib/artifact-retry.js';
+import { findBenchmarkResultIds, readMappedBenchmarkRows } from './lib/benchmark-result-lookup.js';
 import { repositoryFromRunUrl } from './lib/runtime-metadata-artifacts.js';
-import {
-  pairServerLogArtifacts,
-  resolveServerLogResultCandidates,
-} from './lib/server-log-backfill.js';
+import { pairServerLogArtifacts } from './lib/server-log-backfill.js';
 
 const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
 const RETENTION_DAYS = 90;
@@ -94,86 +95,6 @@ function parseBackfillFlags(): BackfillFlags {
   };
 }
 
-function findJsonFiles(root: string): string[] {
-  const files: string[] = [];
-  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
-    const pathname = path.join(root, entry.name);
-    if (entry.isDirectory()) files.push(...findJsonFiles(pathname));
-    else if (entry.isFile() && entry.name.endsWith('.json')) files.push(pathname);
-  }
-  return files.toSorted();
-}
-
-function readMappedRows(root: string): BenchmarkParams[] {
-  const tracker = createSkipTracker();
-  const rows: BenchmarkParams[] = [];
-  for (const file of findJsonFiles(root)) {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as unknown;
-    const rawRows = Array.isArray(parsed) ? parsed : [parsed];
-    for (const raw of rawRows) {
-      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
-      const mapped = mapBenchmarkRow(raw as Record<string, unknown>, tracker);
-      if (mapped) rows.push(mapped);
-    }
-  }
-  return rows;
-}
-
-async function findBenchmarkResultIds(
-  run: CandidateRun,
-  rows: readonly BenchmarkParams[],
-): Promise<number[]> {
-  const ids = new Set<number>();
-  for (const row of rows) {
-    const c = row.config;
-    const candidates = await sql<{ id: number; offload_mode: string }[]>`
-      select br.id, br.offload_mode
-      from benchmark_results br
-      join workflow_runs wr on wr.id = br.workflow_run_id
-      join configs cfg on cfg.id = br.config_id
-      where wr.github_run_id = ${run.github_run_id}
-        and wr.run_attempt = ${run.run_attempt}
-        and cfg.hardware = ${c.hardware}
-        and cfg.framework = ${c.framework}
-        and cfg.model = ${c.model}
-        and cfg.precision = ${c.precision}
-        and cfg.spec_method = ${c.specMethod}
-        and cfg.disagg = ${c.disagg}
-        and cfg.is_multinode = ${c.isMultinode}
-        and cfg.prefill_tp = ${c.prefillTp}
-        and cfg.prefill_ep = ${c.prefillEp}
-        and cfg.prefill_dp_attention = ${c.prefillDpAttn}
-        and cfg.prefill_num_workers = ${c.prefillNumWorkers}
-        and cfg.decode_tp = ${c.decodeTp}
-        and cfg.decode_ep = ${c.decodeEp}
-        and cfg.decode_dp_attention = ${c.decodeDpAttn}
-        and cfg.decode_num_workers = ${c.decodeNumWorkers}
-        and cfg.num_prefill_gpu = ${c.numPrefillGpu}
-        and cfg.num_decode_gpu = ${c.numDecodeGpu}
-        and br.benchmark_type = ${row.benchmarkType}
-        and br.isl is not distinct from ${row.isl}
-        and br.osl is not distinct from ${row.osl}
-        and br.conc = ${row.conc}
-        and br.recipe_fingerprint is not distinct from ${row.recipeFingerprint}
-    `;
-    const resolution = resolveServerLogResultCandidates(
-      candidates.map((candidate) => ({
-        id: Number(candidate.id),
-        offloadMode: candidate.offload_mode,
-      })),
-      row.offloadMode,
-    );
-    if (resolution.usedUniqueFallback) {
-      console.warn(
-        `  [WARN] benchmark result ${resolution.ids[0]} uses a historical offload label; ` +
-          `matched uniquely without offload_mode`,
-      );
-    }
-    for (const id of resolution.ids) ids.add(id);
-  }
-  return [...ids];
-}
-
 async function resultLogsAreComplete(resultIds: readonly number[]): Promise<boolean> {
   if (resultIds.length === 0) return false;
   const [row] = await sql<{ complete: boolean }[]>`
@@ -281,11 +202,8 @@ async function main(): Promise<void> {
         flags.source !== 'gcs' &&
         (flags.source === 'github' || isWithinGithubRetention(run.date))
       ) {
-        const artifacts = await retryArtifactOperation(
-          `listing GitHub artifacts for run ${runId}`,
-          () => listRunArtifacts(repository, String(runId)),
-        );
-        pairs = pairServerLogArtifacts(artifacts.filter((artifact) => !artifact.expired));
+        const artifacts = await listBackfillRunArtifacts(repository, runId);
+        pairs = pairServerLogArtifacts((artifacts ?? []).filter((artifact) => !artifact.expired));
         if (pairs.length > 0) {
           source = 'github';
           githubRuns++;
@@ -311,8 +229,13 @@ async function main(): Promise<void> {
               : await retryArtifactOperation(`downloading ${pair.benchmarks.name}`, () =>
                   downloadArtifact(pair.benchmarks, tempDir),
                 );
-          const mappedRows = readMappedRows(benchmarkDir);
-          const resultIds = await findBenchmarkResultIds(run, mappedRows);
+          const mappedRows = readMappedBenchmarkRows(benchmarkDir);
+          const resultIds = await findBenchmarkResultIds(sql, run, mappedRows, (id) =>
+            console.warn(
+              `  [WARN] benchmark result ${id} uses a historical offload label; ` +
+                `matched uniquely without offload_mode`,
+            ),
+          );
           if (resultIds.length === 0) {
             unmatchedArtifacts++;
             console.warn(`  [WARN] ${pair.serverLogs.name}: no matching benchmark rows`);
diff --git a/packages/db/src/lib/backfill-benchmark-refresh.ts b/packages/db/src/lib/backfill-benchmark-refresh.ts
new file mode 100644
index 000000000..15d2d60f6
--- /dev/null
+++ b/packages/db/src/lib/backfill-benchmark-refresh.ts
@@ -0,0 +1,224 @@
+import { isDeepStrictEqual } from 'node:util';
+import { DB_MODEL_TO_DISPLAY } from '@semianalysisai/inferencex-constants';
+import { refreshLatestBenchmarks, type Sql } from '../etl/db-utils.js';
+import {
+  stablePowerPointIdentity,
+  type PowerPublicationManifest,
+} from '../etl/power-publication.js';
+
+export type BenchmarkAuditUpdate = NonNullable<
+  NonNullable<PowerPublicationManifest['benchmarkRefresh']>['auditUpdates']
+>[number];
+
+function refreshTarget(manifest: PowerPublicationManifest) {
+  const raw = process.env.CACHE_INVALIDATE_URL;
+  if (!raw) throw new Error('CACHE_INVALIDATE_URL is required for benchmark metadata refresh');
+  const endpoint = new URL(raw);
+  if (
+    !['http:', 'https:'].includes(endpoint.protocol) ||
+    endpoint.pathname !== '/api/v1/invalidate' ||
+    endpoint.search ||
+    endpoint.hash ||
+    endpoint.username ||
+    endpoint.password
+  )
+    throw new Error(
+      'CACHE_INVALIDATE_URL must name /api/v1/invalidate without credentials or query',
+    );
+  const previous = manifest.benchmarkRefresh?.endpoint;
+  if (previous && previous !== endpoint.href)
+    throw new Error('Benchmark refresh receipt target differs from CACHE_INVALIDATE_URL');
+  const secret = process.env.CACHE_INVALIDATE_SECRET || process.env.INVALIDATE_SECRET;
+  if (!secret) throw new Error('CACHE_INVALIDATE_SECRET or INVALIDATE_SECRET is required');
+  return {
+    endpoint,
+    headers: {
+      Authorization: `Bearer ${secret}`,
+      ...(process.env.CACHE_PROTECTION_BYPASS_SECRET
+        ? { 'x-vercel-protection-bypass': process.env.CACHE_PROTECTION_BYPASS_SECRET }
+        : {}),
+    },
+  };
+}
+
+/** Persist possible writes before ingest, including a crash before UPDATE returns its IDs. */
+export function checkpointBenchmarkRefresh(
+  manifest: PowerPublicationManifest,
+  ids: number[],
+  save: () => void,
+  auditUpdates: BenchmarkAuditUpdate[] = [],
+): void {
+  if (ids.length === 0) return;
+  const previous = manifest.benchmarkRefresh;
+  manifest.benchmarkRefresh = {
+    status: 'pending',
+    benchmarkResultIds: [
+      ...new Set([
+        ...(previous?.status === 'complete' ? [] : (previous?.benchmarkResultIds ?? [])),
+        ...ids,
+      ]),
+    ],
+    auditUpdates: [...(previous?.auditUpdates ?? [])],
+    ...(previous?.endpoint ? { endpoint: previous.endpoint } : {}),
+  };
+  for (const update of auditUpdates) {
+    const existing = manifest.benchmarkRefresh.auditUpdates!.find(
+      (value) => value.benchmarkResultId === update.benchmarkResultId,
+    );
+    if (
+      existing &&
+      (!isDeepStrictEqual(existing.powerAudit, update.powerAudit) ||
+        stablePowerPointIdentity(existing.identity) !== stablePowerPointIdentity(update.identity))
+    )
+      throw new Error('Conflicting retained audit evidence for benchmark refresh');
+    if (!existing) manifest.benchmarkRefresh.auditUpdates!.push(update);
+  }
+  save();
+  try {
+    manifest.benchmarkRefresh.endpoint = refreshTarget(manifest).endpoint.href;
+  } catch (error) {
+    manifest.benchmarkRefresh.status = 'failed';
+    manifest.benchmarkRefresh.error = error instanceof Error ? error.message : String(error);
+    throw error;
+  } finally {
+    save();
+  }
+}
+
+/** Retry only the materialized view/cache/API phase; never download or rewrite samples. */
+export async function refreshBackfillBenchmarks(
+  sql: Sql,
+  manifest: PowerPublicationManifest,
+  save: () => void,
+): Promise<void> {
+  const receipt = manifest.benchmarkRefresh;
+  if (!receipt) throw new Error('Receipt has no benchmark metadata refresh responsibility');
+  receipt.status = 'pending';
+  receipt.checkedAt = new Date().toISOString();
+  delete receipt.error;
+  save();
+  let phase = 'validate target';
+  try {
+    const { endpoint, headers } = refreshTarget(manifest);
+    receipt.endpoint = endpoint.href;
+    save();
+    const ids = receipt.benchmarkResultIds;
+    if (
+      !Array.isArray(ids) ||
+      ids.some((id) => !Number.isSafeInteger(id) || id <= 0) ||
+      new Set(ids).size !== ids.length
+    )
+      throw new Error('Invalid benchmarkResultIds in refresh receipt');
+    const rows = await sql<
+      (Record<string, unknown> & { id: number; model: string; power_audit: unknown })[]
+    >`
+      select c.*, br.id, br.benchmark_type, br.isl, br.osl, br.conc, br.offload_mode,
+        br.recipe_fingerprint, br.power_audit from benchmark_results br
+      join configs c on c.id = br.config_id
+      join workflow_runs wr on wr.id = br.workflow_run_id
+      where wr.github_run_id = ${manifest.runId} and wr.run_attempt = ${manifest.runAttempt}
+        and br.id = any(${sql.array(ids)}::bigint[])
+    `;
+    if (rows.length !== ids.length)
+      throw new Error('Refresh receipt IDs do not belong to its run/attempt');
+    const changed = rows;
+    for (const row of changed) {
+      const audit = row.power_audit;
+      if (audit === null)
+        throw new Error(
+          `Benchmark ${row.id} power_audit is NULL; targeted artifact re-ingest is required before cache refresh`,
+        );
+      if (
+        !audit ||
+        typeof audit !== 'object' ||
+        Array.isArray(audit) ||
+        !('source' in audit) ||
+        typeof audit.source !== 'string' ||
+        !audit.source.trim()
+      )
+        throw new Error(`Benchmark ${row.id} power_audit must be an object with a nonempty source`);
+      const updates =
+        receipt.auditUpdates?.filter((update) => update.benchmarkResultId === Number(row.id)) ?? [];
+      if (updates.length !== 1 || !isDeepStrictEqual(updates[0]!.powerAudit, audit))
+        throw new Error(`Benchmark ${row.id} power_audit differs from retained source evidence`);
+      const update = updates[0]!;
+      if (stablePowerPointIdentity(update.identity) !== stablePowerPointIdentity(row))
+        throw new Error(`Benchmark ${row.id} identity differs from retained source mapping`);
+      const identities = new Set(
+        [update.identity, update.sourceIdentity ?? update.identity].map(stablePowerPointIdentity),
+      );
+      const points = manifest.points.filter((point) =>
+        identities.has(stablePowerPointIdentity(point.identity)),
+      );
+      if (points.length > 1)
+        throw new Error(`Ambiguous publication identity for benchmark ${row.id}`);
+      if (
+        points.length === 1 &&
+        (points[0]!.power_audit === null || points[0]!.power_audit === undefined)
+      )
+        points[0]!.power_audit = update.powerAudit;
+    }
+    save();
+    if (changed.length > 0) {
+      phase = 'refresh latest_benchmarks';
+      await refreshLatestBenchmarks(sql);
+      phase = 'invalidate cache';
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers,
+        redirect: 'error',
+        signal: AbortSignal.timeout(30_000),
+      });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const result = await response.json();
+      if (
+        result?.invalidated !== true ||
+        !Number.isSafeInteger(result.blobsDeleted) ||
+        result.blobsDeleted < 0
+      )
+        throw new Error('Invalid cache invalidation response');
+      phase = 'verify benchmark API';
+      for (const model of new Set(changed.map((row) => row.model))) {
+        const displayModel = DB_MODEL_TO_DISPLAY[model];
+        if (!displayModel) throw new Error(`Unmapped public model: ${model}`);
+        const url = new URL('/api/v1/benchmarks', endpoint);
+        url.search = new URLSearchParams({
+          model: displayModel,
+          runId: String(manifest.runId),
+          exactRun: 'true',
+        }).toString();
+        const api = await fetch(url, {
+          headers: process.env.CACHE_PROTECTION_BYPASS_SECRET
+            ? { 'x-vercel-protection-bypass': process.env.CACHE_PROTECTION_BYPASS_SECRET }
+            : undefined,
+          redirect: 'error',
+          signal: AbortSignal.timeout(30_000),
+        });
+        if (!api.ok) throw new Error(`HTTP ${api.status}`);
+        const body: unknown = await api.json();
+        if (!Array.isArray(body)) throw new Error('Invalid benchmark API response');
+        for (const row of changed.filter((entry) => entry.model === model)) {
+          const matches = body.filter((candidate) => {
+            const raw = candidate?.id;
+            const id =
+              typeof raw === 'number'
+                ? raw
+                : typeof raw === 'string' && /^[1-9]\d*$/u.test(raw)
+                  ? Number(raw)
+                  : NaN;
+            return Number.isSafeInteger(id) && id > 0 && id === Number(row.id);
+          });
+          if (matches.length !== 1 || !isDeepStrictEqual(matches[0].power_audit, row.power_audit))
+            throw new Error(`Benchmark ${row.id} power_audit differs from database`);
+        }
+      }
+    }
+    receipt.status = 'complete';
+  } catch (error) {
+    receipt.status = 'failed';
+    receipt.error = `${phase}: ${error instanceof Error ? error.message : String(error)}`;
+    throw new Error(receipt.error, { cause: error });
+  } finally {
+    save();
+  }
+}
diff --git a/packages/db/src/lib/backfill-runner.ts b/packages/db/src/lib/backfill-runner.ts
index 876e559b2..2051e493d 100644
--- a/packages/db/src/lib/backfill-runner.ts
+++ b/packages/db/src/lib/backfill-runner.ts
@@ -8,6 +8,12 @@
 
 import { confirm, hasYesFlag } from '../cli-utils.js';
 import type { Sql } from '../etl/db-utils.js';
+import { retryArtifactOperation } from './artifact-retry.js';
+import {
+  WorkflowRunNotFoundError,
+  listRunArtifacts,
+  type ArtifactMeta,
+} from './github-artifacts.js';
 
 export interface LimitForceFlags {
   limit: number | null;
@@ -165,6 +171,25 @@ export async function runCandidateIdBackfill(
  * class instances/prototypes so postgres.js serializes plain data only —
  * matches what the inline ingest path stores.
  */
+/**
+ * List a candidate run's GitHub artifacts with transient-failure retry.
+ * Returns `null` when GitHub no longer has the run at all, so a sweep over
+ * months of history reports the gap and moves on instead of aborting.
+ */
+export async function listBackfillRunArtifacts(
+  repository: string,
+  runId: number,
+): Promise<ArtifactMeta[] | null> {
+  try {
+    return await retryArtifactOperation(`listing GitHub artifacts for run ${runId}`, () =>
+      listRunArtifacts(repository, String(runId)),
+    );
+  } catch (error) {
+    if (error instanceof WorkflowRunNotFoundError) return null;
+    throw error;
+  }
+}
+
 export function jsonbParam(sql: Sql, value: unknown): ReturnType<Sql['json']> {
   return sql.json(structuredClone(value) as unknown as Parameters<typeof sql.json>[0]);
 }
diff --git a/packages/db/src/lib/benchmark-result-lookup.test.ts b/packages/db/src/lib/benchmark-result-lookup.test.ts
new file mode 100644
index 000000000..15478e635
--- /dev/null
+++ b/packages/db/src/lib/benchmark-result-lookup.test.ts
@@ -0,0 +1,164 @@
+import fs from 'node:fs';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import { mapBenchmarkRow, type BenchmarkParams } from '../etl/benchmark-mapper';
+import { createSkipTracker } from '../etl/skip-tracker';
+import { filterPurgedBenchmarkRows, findBenchmarkResultIds } from './benchmark-result-lookup';
+import { collectMissingTelemetryExpectations } from './gpu-metrics-backfill';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+let sql: Sql;
+const roots: string[] = [];
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, { json: JSON.stringify, array: (value: unknown) => value });
+}
+
+const GITHUB_RUN_ID = 34557177019;
+const RUN = { github_run_id: GITHUB_RUN_ID, run_attempt: 2 };
+
+/** Raw `bmk_` JSON as the runner emits it for a fixed-sequence sweep. */
+function rawRow(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    infmax_model_prefix: 'dsr1',
+    hw: 'b200-nv',
+    framework: 'sglang',
+    precision: 'fp4',
+    isl: 8192,
+    osl: 1024,
+    conc: 32,
+    tp: 8,
+    ep: 1,
+    dp_attention: false,
+    tput_per_gpu: 1234.5,
+    ...overrides,
+  };
+}
+
+function mapped(raw: Record<string, unknown>): BenchmarkParams {
+  const row = mapBenchmarkRow(raw, createSkipTracker());
+  if (!row) throw new Error('fixture did not map');
+  return row;
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  const dir = new URL('../../migrations/', import.meta.url);
+  for (const name of fs.readdirSync(dir).toSorted()) {
+    if (name.endsWith('.sql')) await db.exec(fs.readFileSync(new URL(name, dir), 'utf8'));
+  }
+  sql = queryClient(db) as unknown as Sql;
+}, 30_000);
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+afterAll(async () => {
+  await db?.close();
+});
+
+/**
+ * Config 1 matches the fixture rows; config 2 differs only in decode_tp. Attempt 1
+ * of the same GitHub run holds a point that must never be matched from attempt 2.
+ */
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, created_at, date)
+    VALUES (1, ${GITHUB_RUN_ID}, 1, 'Run Sweep', '2026-09-11T04:00:00Z', '2026-09-11'),
+           (2, ${GITHUB_RUN_ID}, 2, 'Run Sweep', '2026-09-11T06:00:00Z', '2026-09-11');
+
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      is_multinode, prefill_tp, prefill_ep, prefill_dp_attention, prefill_num_workers,
+      decode_tp, decode_ep, decode_dp_attention, decode_num_workers,
+      num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, false, 8, 1, false, 0,
+              8, 1, false, 0, 8, 8),
+           (2, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, false, 8, 1, false, 0,
+              4, 1, false, 0, 8, 8),
+           (3, 'dsv4', 'b200', 'vllm', 'fp4', 'none', false, false, 1, 1, false, 0,
+              1, 1, false, 0, 1, 1);
+
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+      isl, osl, conc, offload_mode, metrics)
+    VALUES (20, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'off', '{}'),
+           (21, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, 'off', '{}'),
+           (22, 2, 2, 'single_turn', '2026-09-11', 8192, 1024, 32, 'off', '{}'),
+           (23, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'off', '{}'),
+           (24, 2, 3, 'agentic_traces', '2026-09-11', null, null, 72, 'off', '{}');`);
+});
+
+describe('findBenchmarkResultIds', () => {
+  it('prefers the offload-exact point and reports no unique fallback', async () => {
+    await db.exec(`INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type,
+      date, isl, osl, conc, offload_mode, metrics)
+      VALUES (25, 2, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, 'on', '{}');`);
+    const fallbacks: number[] = [];
+    const ids = await findBenchmarkResultIds(sql, RUN, [mapped(rawRow())], (id) =>
+      fallbacks.push(id),
+    );
+    expect(ids).toEqual([20]);
+    expect(fallbacks).toEqual([]);
+  });
+});
+
+it('excludes exact purges from mixed artifacts and missing-artifact expectations', async () => {
+  await db.exec(`UPDATE benchmark_results SET config_id = 1 WHERE id = 24;
+    UPDATE configs SET id = 744 WHERE id = 3;
+    UPDATE workflow_runs SET github_run_id = 30730541420, run_attempt = 1 WHERE id = 2;
+    UPDATE benchmark_results SET config_id = 744, conc = 1, offload_mode = 'on' WHERE id = 24;`);
+  const run = { github_run_id: 30730541420, run_attempt: 1 };
+  const point: BenchmarkParams = {
+    ...mapped(rawRow({ infmax_model_prefix: 'dsv4', framework: 'vllm', tp: 1 })),
+    benchmarkType: 'agentic_traces',
+    isl: null,
+    osl: null,
+    offloadMode: 'on',
+    recipeFingerprint: null,
+  };
+  const purged = { ...point, conc: 32 };
+  const surviving = { ...point, conc: 1 };
+  const rows = await filterPurgedBenchmarkRows(sql, run, [purged, surviving]);
+  expect(rows).toEqual([surviving]);
+  expect(await findBenchmarkResultIds(sql, run, rows)).toEqual([24]);
+  expect(await filterPurgedBenchmarkRows(sql, run, [purged])).toEqual([]);
+  expect(await filterPurgedBenchmarkRows(sql, { ...run, run_attempt: 2 }, [purged])).toEqual([
+    purged,
+  ]);
+  expect(
+    await filterPurgedBenchmarkRows(sql, run, [{ ...purged, recipeFingerprint: 'new' }]),
+  ).toHaveLength(1);
+  expect(
+    await filterPurgedBenchmarkRows(sql, run, [{ ...purged, offloadMode: 'off' }]),
+  ).toHaveLength(1);
+  expect(
+    await filterPurgedBenchmarkRows(sql, run, [
+      { ...purged, config: { ...point.config, decodeTp: 4 } },
+    ]),
+  ).toHaveLength(1);
+  const missing = await collectMissingTelemetryExpectations(
+    [
+      {
+        id: 1,
+        name: 'bmk_agentic_retained',
+        expired: false,
+        created_at: '2026-09-11T00:00:00Z',
+        archive_download_url: 'https://example.test/1',
+      },
+    ],
+    [],
+    null,
+    () => filterPurgedBenchmarkRows(sql, run, [purged, surviving]),
+  );
+  expect(missing.observations.map((entry) => entry.identity.conc)).toEqual([1]);
+  expect(missing.errors).toEqual([]);
+});
diff --git a/packages/db/src/lib/benchmark-result-lookup.ts b/packages/db/src/lib/benchmark-result-lookup.ts
new file mode 100644
index 000000000..f94128f4f
--- /dev/null
+++ b/packages/db/src/lib/benchmark-result-lookup.ts
@@ -0,0 +1,153 @@
+/**
+ * Resolve persisted `benchmark_results` ids for raw artifact rows that were
+ * mapped through the production mapper. Shared by the sidecar backfills
+ * (server logs, gpu_metrics) so every historical attachment uses the same
+ * natural-key match as the CI ingest path.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { mapBenchmarkRow, type BenchmarkParams } from '../etl/benchmark-mapper.js';
+import { createSkipTracker } from '../etl/skip-tracker.js';
+import type { Sql } from '../etl/db-utils.js';
+import { configCacheKey } from '../etl/config-cache.js';
+import { isBenchmarkPointPurged, PURGED_BENCHMARK_POINTS } from '../etl/run-overrides.js';
+import { resolveServerLogResultCandidates } from './server-log-backfill.js';
+
+export interface BenchmarkRunSelector {
+  github_run_id: number;
+  run_attempt: number;
+}
+
+/** Purged points must not become missing-result errors or receipt expectations. */
+export async function filterPurgedBenchmarkRows(
+  sql: Sql,
+  run: BenchmarkRunSelector,
+  rows: readonly BenchmarkParams[],
+): Promise<BenchmarkParams[]> {
+  const configIds = PURGED_BENCHMARK_POINTS.filter(
+    (point) => point.githubRunId === run.github_run_id && point.runAttempt === run.run_attempt,
+  ).map((point) => point.configId);
+  if (configIds.length === 0) return [...rows];
+
+  const configs = new Map<string, number | null>();
+  const retained: BenchmarkParams[] = [];
+  for (const row of rows) {
+    const c = row.config;
+    const key = configCacheKey(c);
+    if (!configs.has(key)) {
+      const [config] = await sql<{ id: number }[]>`
+        select id from configs cfg
+        where cfg.id = any(${configIds}::integer[])
+          and cfg.hardware = ${c.hardware} and cfg.framework = ${c.framework}
+          and cfg.model = ${c.model} and cfg.precision = ${c.precision}
+          and cfg.spec_method = ${c.specMethod} and cfg.disagg = ${c.disagg}
+          and cfg.is_multinode = ${c.isMultinode}
+          and cfg.prefill_tp = ${c.prefillTp} and cfg.prefill_ep = ${c.prefillEp}
+          and cfg.prefill_dp_attention = ${c.prefillDpAttn}
+          and cfg.prefill_num_workers = ${c.prefillNumWorkers}
+          and cfg.decode_tp = ${c.decodeTp} and cfg.decode_ep = ${c.decodeEp}
+          and cfg.decode_dp_attention = ${c.decodeDpAttn}
+          and cfg.decode_num_workers = ${c.decodeNumWorkers}
+          and cfg.num_prefill_gpu = ${c.numPrefillGpu}
+          and cfg.num_decode_gpu = ${c.numDecodeGpu}
+      `;
+      configs.set(key, config ? Number(config.id) : null);
+    }
+    const configId = configs.get(key)!;
+    if (
+      configId === null ||
+      !isBenchmarkPointPurged(run.github_run_id, run.run_attempt, { ...row, configId })
+    )
+      retained.push(row);
+  }
+  return retained;
+}
+
+export async function findBenchmarkResultIds(
+  sql: Sql,
+  run: BenchmarkRunSelector,
+  rows: readonly BenchmarkParams[],
+  onUniqueFallback: (id: number) => void = () => {},
+): Promise<number[]> {
+  const ids = new Set<number>();
+  for (const row of rows) {
+    const c = row.config;
+    const candidates = await sql<{ id: number; offload_mode: string }[]>`
+      select br.id, br.offload_mode
+      from benchmark_results br
+      join workflow_runs wr on wr.id = br.workflow_run_id
+      join configs cfg on cfg.id = br.config_id
+      where wr.github_run_id = ${run.github_run_id}
+        and wr.run_attempt = ${run.run_attempt}
+        and cfg.hardware = ${c.hardware}
+        and cfg.framework = ${c.framework}
+        and cfg.model = ${c.model}
+        and cfg.precision = ${c.precision}
+        and cfg.spec_method = ${c.specMethod}
+        and cfg.disagg = ${c.disagg}
+        and cfg.is_multinode = ${c.isMultinode}
+        and cfg.prefill_tp = ${c.prefillTp}
+        and cfg.prefill_ep = ${c.prefillEp}
+        and cfg.prefill_dp_attention = ${c.prefillDpAttn}
+        and cfg.prefill_num_workers = ${c.prefillNumWorkers}
+        and cfg.decode_tp = ${c.decodeTp}
+        and cfg.decode_ep = ${c.decodeEp}
+        and cfg.decode_dp_attention = ${c.decodeDpAttn}
+        and cfg.decode_num_workers = ${c.decodeNumWorkers}
+        and cfg.num_prefill_gpu = ${c.numPrefillGpu}
+        and cfg.num_decode_gpu = ${c.numDecodeGpu}
+        and br.benchmark_type = ${row.benchmarkType}
+        and br.isl is not distinct from ${row.isl}
+        and br.osl is not distinct from ${row.osl}
+        and br.conc = ${row.conc}
+        and br.recipe_fingerprint is not distinct from ${row.recipeFingerprint}
+    `;
+    const resolution = resolveServerLogResultCandidates(
+      candidates.map((candidate) => ({
+        id: Number(candidate.id),
+        offloadMode: candidate.offload_mode,
+      })),
+      row.offloadMode,
+    );
+    if (resolution.usedUniqueFallback) onUniqueFallback(resolution.ids[0]!);
+    for (const id of resolution.ids) ids.add(id);
+  }
+  return [...ids];
+}
+
+function findJsonFiles(root: string): string[] {
+  const files: string[] = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const pathname = path.join(root, entry.name);
+    if (entry.isDirectory()) files.push(...findJsonFiles(pathname));
+    else if (entry.isFile() && entry.name.endsWith('.json')) files.push(pathname);
+  }
+  return files.toSorted();
+}
+
+/** Map known successful rows; report unidentifiable rows separately from known failures. */
+export function readMappedBenchmarkRows(
+  root: string,
+  onUnmapped: (error: string) => void = () => {},
+): BenchmarkParams[] {
+  const tracker = createSkipTracker();
+  const rows: BenchmarkParams[] = [];
+  for (const file of findJsonFiles(root)) {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as unknown;
+    const rawRows = Array.isArray(parsed) ? parsed : [parsed];
+    for (const [index, raw] of rawRows.entries()) {
+      const error = `Unmappable benchmark row: ${path.relative(root, file)} row ${index + 1}`;
+      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        onUnmapped(error);
+        continue;
+      }
+      const failedRuns = tracker.skips.failedRun;
+      const mapped = mapBenchmarkRow(raw as Record<string, unknown>, tracker);
+      if (mapped) rows.push(mapped);
+      else if (tracker.skips.failedRun === failedRuns) onUnmapped(error);
+    }
+  }
+  return rows;
+}
diff --git a/packages/db/src/lib/gpu-metrics-backfill.test.ts b/packages/db/src/lib/gpu-metrics-backfill.test.ts
new file mode 100644
index 000000000..bb9607ca7
--- /dev/null
+++ b/packages/db/src/lib/gpu-metrics-backfill.test.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import type { ArtifactMeta } from './github-artifacts.js';
+import { pairGpuMetricsArtifacts } from './gpu-metrics-backfill.js';
+
+const meta = (
+  name: string,
+  id: number,
+  created_at = '2026-09-11T00:00:00Z',
+  expired = false,
+): ArtifactMeta => ({
+  id,
+  name,
+  created_at,
+  expired,
+  archive_download_url: `https://example.test/${id}`,
+});
+
+describe('pairGpuMetricsArtifacts', () => {
+  it('lets a power_audit bundle stand in only when its suffix has no gpu_metrics upload', () => {
+    // The bundle is listed before its gpu_metrics sibling on purpose: input
+    // order alone must not decide the winner.
+    const pairs = pairGpuMetricsArtifacts([
+      meta('power_audit_cfg-mn_b200-slurm_0', 1),
+      meta('bmk_cfg-mn_b200-slurm_0', 2),
+      meta('power_audit_cfg-sn_h200-cw_0', 4),
+      meta('gpu_metrics_cfg-sn_h200-cw_0', 3),
+      meta('bmk_cfg-sn_h200-cw_0', 5),
+      meta('power_audit_orphan_b200-slurm_0', 6),
+    ]);
+    expect(pairs.map((pair) => [pair.gpuMetrics.name, pair.benchmarks.name])).toEqual([
+      ['gpu_metrics_cfg-sn_h200-cw_0', 'bmk_cfg-sn_h200-cw_0'],
+      ['power_audit_cfg-mn_b200-slurm_0', 'bmk_cfg-mn_b200-slurm_0'],
+    ]);
+  });
+
+  it('keeps only the newest retry per logical benchmark and drops expired uploads', () => {
+    const pairs = pairGpuMetricsArtifacts([
+      meta('gpu_metrics_cfg-a_h200-cw_0', 1, '2026-09-11T00:00:00Z'),
+      meta('bmk_cfg-a_h200-cw_0', 2, '2026-09-11T00:00:00Z'),
+      meta('gpu_metrics_cfg-a_h200-dgxc-slurm_1', 3, '2026-09-11T02:00:00Z'),
+      meta('bmk_cfg-a_h200-dgxc-slurm_1', 4, '2026-09-11T02:00:00Z'),
+      meta('gpu_metrics_cfg-c_h200-cw_0', 5, '2026-09-11T03:00:00Z', true),
+      meta('bmk_cfg-c_h200-cw_0', 6, '2026-09-11T03:00:00Z'),
+    ]);
+    expect(pairs.map((pair) => pair.gpuMetrics.name)).toEqual([
+      'gpu_metrics_cfg-a_h200-dgxc-slurm_1',
+    ]);
+  });
+});
diff --git a/packages/db/src/lib/gpu-metrics-backfill.ts b/packages/db/src/lib/gpu-metrics-backfill.ts
new file mode 100644
index 000000000..d1600e2d3
--- /dev/null
+++ b/packages/db/src/lib/gpu-metrics-backfill.ts
@@ -0,0 +1,134 @@
+import type { Sql } from '../etl/db-utils.js';
+import { GPU_STATS_VERSION } from './gpu-metric-stats.js';
+
+/** Pairing rules for the historical gpu_metrics backfill. */
+
+import { gpuMetricsArtifactSuffix, isPowerAuditArtifact } from '../etl/gpu-metrics-artifacts.js';
+import type { BenchmarkParams } from '../etl/benchmark-mapper.js';
+import { benchmarkPublicationIdentity } from '../etl/power-publication.js';
+import type { TelemetryObservation, TelemetryReceipt } from '../etl/telemetry-receipt.js';
+import {
+  dedupeArtifactsByLogicalName,
+  RUNNER_SUFFIX_RE,
+  type ArtifactMeta,
+} from './github-artifacts.js';
+
+export interface GpuMetricsArtifactPair {
+  /** `gpu_metrics_<suffix>`, or the `power_audit_<suffix>` bundle when a multinode job uploaded no other. */
+  gpuMetrics: ArtifactMeta;
+  benchmarks: ArtifactMeta;
+}
+
+function isNewerArtifact(candidate: ArtifactMeta, existing: ArtifactMeta): boolean {
+  return (
+    candidate.created_at > existing.created_at ||
+    (candidate.created_at === existing.created_at && (candidate.id ?? 0) > (existing.id ?? 0))
+  );
+}
+
+/**
+ * Pair every unexpired telemetry artifact with its exact bmk sibling. Retried
+ * jobs upload on different runners, so the newest artifact per logical
+ * (runner-suffix-stripped) benchmark name wins, matching CI ingest. A
+ * `power_audit_` bundle pairs only when its suffix has no `gpu_metrics_`
+ * upload, the same preference `discoverGpuMetricsArtifacts` applies.
+ */
+export function pairGpuMetricsArtifacts(
+  artifacts: readonly ArtifactMeta[],
+): GpuMetricsArtifactPair[] {
+  const byName = new Map<string, ArtifactMeta>();
+  for (const artifact of artifacts) {
+    if (artifact.expired) continue;
+    const existing = byName.get(artifact.name);
+    if (!existing || isNewerArtifact(artifact, existing)) byName.set(artifact.name, artifact);
+  }
+  const gpuMetricsSuffixes = new Set<string>();
+  for (const name of byName.keys()) {
+    const suffix = gpuMetricsArtifactSuffix(name);
+    if (suffix && !isPowerAuditArtifact(name)) gpuMetricsSuffixes.add(suffix);
+  }
+  const byLogicalBenchmark = new Map<string, GpuMetricsArtifactPair>();
+  for (const gpuMetrics of byName.values()) {
+    const suffix = gpuMetricsArtifactSuffix(gpuMetrics.name);
+    if (!suffix) continue;
+    if (isPowerAuditArtifact(gpuMetrics.name) && gpuMetricsSuffixes.has(suffix)) continue;
+    const benchmarks = byName.get(`bmk_agentic_${suffix}`) ?? byName.get(`bmk_${suffix}`);
+    if (!benchmarks) continue;
+    const logicalName = benchmarks.name.replace(RUNNER_SUFFIX_RE, '');
+    const existing = byLogicalBenchmark.get(logicalName);
+    if (!existing || isNewerArtifact(benchmarks, existing.benchmarks)) {
+      byLogicalBenchmark.set(logicalName, { gpuMetrics, benchmarks });
+    }
+  }
+  return [...byLogicalBenchmark.values()].toSorted((a, b) =>
+    a.gpuMetrics.name.localeCompare(b.gpuMetrics.name),
+  );
+}
+
+/** A corrupt unrelated benchmark sibling must not prevent valid pairs from being repaired. */
+export async function collectMissingTelemetryExpectations(
+  artifacts: readonly ArtifactMeta[],
+  pairs: readonly GpuMetricsArtifactPair[],
+  selectedArtifact: string | null,
+  readRows: (
+    artifact: ArtifactMeta,
+    onUnmapped: (error: string) => void,
+  ) => Promise<readonly BenchmarkParams[]>,
+): Promise<{
+  observations: TelemetryObservation[];
+  errors: NonNullable<TelemetryReceipt['expectationErrors']>;
+}> {
+  const paired = new Set(pairs.map((pair) => pair.benchmarks.name));
+  const observations: TelemetryObservation[] = [];
+  const errors: NonNullable<TelemetryReceipt['expectationErrors']> = [];
+  for (const artifact of dedupeArtifactsByLogicalName(artifacts).values()) {
+    if (!artifact.name.startsWith('bmk_') || paired.has(artifact.name)) continue;
+    const suffix = artifact.name.replace(/^bmk_(?:agentic_)?/u, '');
+    const artifactNames = [`gpu_metrics_${suffix}`, `power_audit_${suffix}`];
+    if (selectedArtifact && !artifactNames.includes(selectedArtifact)) continue;
+    const recordError = (error: string) => {
+      errors.push({ benchmarkArtifact: artifact.name, artifactNames, error });
+    };
+    if (artifact.expired) {
+      recordError('Benchmark artifact expired; point identities unavailable');
+      continue;
+    }
+    try {
+      for (const row of await readRows(artifact, recordError))
+        observations.push({
+          identity: benchmarkPublicationIdentity(row),
+          artifactNames,
+          produced: false,
+        });
+    } catch (error) {
+      recordError(error instanceof Error ? error.message : String(error));
+    }
+  }
+  return { observations, errors };
+}
+
+/** Stored samples outlive artifacts, including superseded attempts. */
+export function findOutdatedGpuMetricSeries(
+  sql: Sql,
+  flags: {
+    run: number | null;
+    attempt: number | null;
+    artifact: string | null;
+    fromRun: number | null;
+    since: string | null;
+  },
+  limit: number | null,
+) {
+  return sql`
+    select s.id, wr.github_run_id, wr.run_attempt, s.artifact_name, s.file_name
+    from gpu_metric_series s join workflow_runs wr on wr.id = s.workflow_run_id
+    where s.stats_version <> ${GPU_STATS_VERSION}
+      and (${flags.run}::bigint is null or wr.github_run_id = ${flags.run})
+      and (${flags.attempt}::integer is null or wr.run_attempt = ${flags.attempt})
+      and (${flags.artifact}::text is null or s.artifact_name = ${flags.artifact})
+      and (${flags.fromRun}::bigint is null or wr.github_run_id >= ${flags.fromRun})
+      and (${flags.since}::date is null or wr.date >= ${flags.since}::date)
+    order by wr.github_run_id, wr.run_attempt, s.id
+    limit ${limit}::integer
+  `;
+}
diff --git a/packages/db/src/lib/telemetry-purge.ts b/packages/db/src/lib/telemetry-purge.ts
new file mode 100644
index 000000000..13b2b76dd
--- /dev/null
+++ b/packages/db/src/lib/telemetry-purge.ts
@@ -0,0 +1,100 @@
+/**
+ * Explicit deletion of PowerX telemetry during a purge.
+ *
+ * Migration 016 declares `on delete cascade` from `gpu_metric_series.workflow_run_id`
+ * to `workflow_runs` and from `benchmark_result_gpu_metrics.benchmark_result_id` to
+ * `benchmark_results`, so a purge already removed telemetry — silently, with no count
+ * in the preview and no line in the log. That is the wrong default for this data:
+ * past GitHub's 90-day artifact retention the stored samples are the only copy, which
+ * is the reason migration 016 exists at all. These helpers make the deletion explicit
+ * so the operator sees the cost before confirming and again in the transcript.
+ *
+ * The two levels differ on purpose:
+ *   - A whole-run purge owns the series and deletes them (`deleteRunTelemetry`).
+ *   - A point purge only drops the point→series links (`unlinkPointTelemetry`). The
+ *     series stays attached to its workflow_run because `/api/gpu-metrics?runId=`
+ *     reads series by run, not through the links, and other points of the same run
+ *     may still reference it.
+ */
+
+import type { Sql } from '../etl/db-utils.js';
+
+export interface TelemetryPurgeCounts {
+  /** Rows in `gpu_metric_series`. */
+  series: number;
+  /** Sum of `gpu_metric_series.sample_count` across those series. */
+  samples: number;
+}
+
+export const NO_TELEMETRY: TelemetryPurgeCounts = { series: 0, samples: 0 };
+
+/** `count`/`sum` come back as strings over the wire; `sum` is null on an empty set. */
+function toCounts(row: { n: unknown; samples: unknown } | undefined): TelemetryPurgeCounts {
+  if (!row) return NO_TELEMETRY;
+  return { series: Number(row.n ?? 0), samples: Number(row.samples ?? 0) };
+}
+
+/**
+ * Telemetry a whole-run purge would destroy. Read-only, for the preview line.
+ * Sums the stored `sample_count` instead of counting `gpu_metric_samples` so the
+ * preview stays cheap against a table holding tens of millions of rows.
+ */
+export async function countRunTelemetry(
+  sql: Sql,
+  workflowRunIds: readonly number[],
+): Promise<TelemetryPurgeCounts> {
+  if (workflowRunIds.length === 0) return NO_TELEMETRY;
+  const [row] = await sql`
+    SELECT count(*)::int AS n, coalesce(sum(sample_count), 0)::bigint AS samples
+    FROM gpu_metric_series
+    WHERE workflow_run_id = ANY(${[...workflowRunIds]})
+  `;
+  return toCounts(row as { n: unknown; samples: unknown } | undefined);
+}
+
+/**
+ * Delete the telemetry owned by these workflow_runs and report what went, so the
+ * caller can log it. Samples and per-GPU stats follow by cascade from the series.
+ * Call this before deleting the `workflow_runs` rows themselves.
+ */
+export async function deleteRunTelemetry(
+  sql: Sql,
+  workflowRunIds: readonly number[],
+): Promise<TelemetryPurgeCounts> {
+  if (workflowRunIds.length === 0) return NO_TELEMETRY;
+  const [row] = await sql`
+    WITH deleted AS (
+      DELETE FROM gpu_metric_series
+      WHERE workflow_run_id = ANY(${[...workflowRunIds]})
+      RETURNING sample_count
+    )
+    SELECT count(*)::int AS n, coalesce(sum(sample_count), 0)::bigint AS samples FROM deleted
+  `;
+  return toCounts(row as { n: unknown; samples: unknown } | undefined);
+}
+
+/**
+ * Drop the point→series links for purged benchmark points and report how many went.
+ * Deliberately leaves `gpu_metric_series` in place: it belongs to the workflow_run,
+ * which is not being purged here.
+ */
+export async function unlinkPointTelemetry(
+  sql: Sql,
+  benchmarkResultIds: readonly number[],
+): Promise<number> {
+  if (benchmarkResultIds.length === 0) return 0;
+  const [row] = await sql`
+    WITH deleted AS (
+      DELETE FROM benchmark_result_gpu_metrics
+      WHERE benchmark_result_id = ANY(${[...benchmarkResultIds]})
+      RETURNING series_id
+    )
+    SELECT count(*)::int AS n FROM deleted
+  `;
+  return Number((row as { n: unknown } | undefined)?.n ?? 0);
+}
+
+/** One-line summary for preview and transcript output. */
+export function describeTelemetry(counts: TelemetryPurgeCounts): string {
+  return `${counts.series} gpu_metric_series (${counts.samples.toLocaleString('en-US')} samples)`;
+}

From c2e8282069fd5d24fbbf5d7323d42e626e95db4a Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:45 -0700
Subject: [PATCH 093/103] feat(db): telemetry read queries with snapshot checks
 and paged samples
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Read a run or point with prefix/source/host scoping pushed into SQL, page samples in
50k-row keyset pages under the Neon HTTP cap, re-check the series version after loading
so a concurrent re-ingest is retried, and expose a revision hash for the point cache.

中文：按 prefix/source/host 在 SQL 侧限定读取范围，样本以 5 万行 keyset 分页控制在 Neon HTTP 上限内，读取后复核序列版本以重试并发重入库，并为 point 缓存暴露 revision 哈希。
---
 .../db/src/queries/gpu-metrics-revision.ts    |  27 +
 .../src/queries/gpu-metrics-timeline.test.ts  | 288 ++++++++++
 .../gpu-metrics.reingest-consistency.test.ts  | 236 ++++++++
 packages/db/src/queries/gpu-metrics.test.ts   | 321 +++++++++++
 packages/db/src/queries/gpu-metrics.ts        | 515 ++++++++++++++++++
 5 files changed, 1387 insertions(+)
 create mode 100644 packages/db/src/queries/gpu-metrics-revision.ts
 create mode 100644 packages/db/src/queries/gpu-metrics-timeline.test.ts
 create mode 100644 packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
 create mode 100644 packages/db/src/queries/gpu-metrics.test.ts
 create mode 100644 packages/db/src/queries/gpu-metrics.ts

diff --git a/packages/db/src/queries/gpu-metrics-revision.ts b/packages/db/src/queries/gpu-metrics-revision.ts
new file mode 100644
index 000000000..fb7364b38
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics-revision.ts
@@ -0,0 +1,27 @@
+import { GPU_STATS_VERSION } from '../lib/gpu-metric-stats';
+
+import type { DbClient } from '../connection';
+
+/** Re-ingest and shared-link changes must bypass older point payloads. */
+export async function getGpuMetricsPointRevision(
+  sql: DbClient,
+  benchmarkResultId: number,
+): Promise<string | null> {
+  const [row] = await sql`
+    select md5(jsonb_agg(jsonb_build_array(
+      s.id, s.ingested_at, s.csv_sha256, s.sample_count, s.sidecars,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0),
+      (
+        select jsonb_agg(jsonb_build_array(l.benchmark_result_id, b.power_audit)
+          order by l.benchmark_result_id)
+        from benchmark_result_gpu_metrics l
+        join benchmark_results b on b.id = l.benchmark_result_id
+        where l.series_id = s.id
+      )
+    ) order by s.id)::text) as revision
+    from benchmark_result_gpu_metrics link
+    join gpu_metric_series s on s.id = link.series_id
+    where link.benchmark_result_id = ${benchmarkResultId}
+  `;
+  return typeof row?.revision === 'string' ? `${GPU_STATS_VERSION}:${row.revision}` : null;
+}
diff --git a/packages/db/src/queries/gpu-metrics-timeline.test.ts b/packages/db/src/queries/gpu-metrics-timeline.test.ts
new file mode 100644
index 000000000..2283453ce
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics-timeline.test.ts
@@ -0,0 +1,288 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import { cutPowerAuditBundle } from '../../../app/src/components/gpu-power/power-audit-bundle';
+import { storedPowerSeries } from '../../../app/src/components/gpu-power/stored-power-series';
+import type { DbClient } from '../connection';
+import { ingestGpuMetricsArtifact } from '../etl/gpu-metrics-ingest';
+import { getGpuMetricsForPoint, getGpuMetricsForRun } from './gpu-metrics';
+
+let db: PGlite;
+let sql: postgres.Sql;
+let readSql: DbClient;
+let root: string;
+const RUN = 34557177019;
+const NAME = 'power_audit_qwen3.5_8k1k_fp8_dynamo-sglang_b200-slurm_0';
+const SOURCE = 'power_validation_qwen3.5_8k1k_fp8_dynamo-sglang_b200-slurm_0_conc32.json';
+const START = 1789194365;
+const CSV = [
+  'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w',
+  `1,${START - 61},0,host-a,0,GPU-a0,1`, // outside the existing 60 s pad
+  `1,${START - 60},1,host-a,0,GPU-a0,0`, // genuine zero must survive
+  `1,${START + 0.1},2,host-b,0,GPU-b0,450`,
+  `1,${START + 0.1},2,host-a,0,GPU-a0,300`,
+  `1,${START + 0.1},2,host-a,0,GPU-a0,300`, // identical duplicate flush
+  `1,${START + 0.1},2,host-a,0,GPU-a0,999`, // conflicting duplicate: first wins
+  `1,${START + 0.8},3,host-a,0,GPU-a0,500`, // same second: mean 400 W
+  `1,${START + 1.1},4,host-a,0,GPU-a0,550`, // host-b dropout: null bucket
+  `1,${START + 61},5,host-b,0,GPU-b0,90`, // inclusive padded boundary
+  `1,${START + 62},6,host-b,0,GPU-b0,1`,
+].join('\n');
+const MANIFEST = {
+  producer: 'srt-slurm.dcgm-power',
+  expected_devices: [
+    { hostname: 'host-a', gpu_index: 0, assignments: [{ worker_role: 'prefill' }] },
+    { hostname: 'host-b', gpu_index: 0, assignments: [{ worker_role: 'decode' }] },
+  ],
+};
+const VALIDATION = {
+  selected_window: { start_time_unix: START, end_time_unix: START + 1 },
+  benchmark_window: { start_time_unix: START - 100, end_time_unix: START + 100 },
+};
+
+function stamp(seconds: number): string {
+  return new Date((seconds + 7200) * 1000)
+    .toISOString()
+    .replaceAll('-', '/')
+    .replace('T', ' ')
+    .replace('Z', '');
+}
+
+function client(database: Pick<PGlite, 'query'>) {
+  return Object.assign(
+    async (strings: TemplateStringsArray, ...values: unknown[]) => {
+      const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+      const result = await database.query<Record<string, unknown>>(query, values);
+      return result.rows;
+    },
+    { json: JSON.stringify, array: (value: unknown) => value },
+  );
+}
+
+function writeArtifact(name: string, files: ReadonlyMap<string, string>) {
+  const artifactDir = path.join(root, name);
+  for (const [file, contents] of files) {
+    const pathname = path.join(artifactDir, file);
+    fs.mkdirSync(path.dirname(pathname), { recursive: true });
+    fs.writeFileSync(pathname, contents);
+  }
+  return { artifactName: name, artifactDir };
+}
+
+function bundle(validation: Record<string, unknown> = VALIDATION) {
+  return new Map([
+    ['LOGS/power/samples.csv', CSV],
+    ['LOGS/power/manifest.json', JSON.stringify(MANIFEST)],
+    [SOURCE, JSON.stringify(validation)],
+  ]);
+}
+
+function agentxBundle() {
+  const files = bundle();
+  files.delete(SOURCE);
+  const resultPath = 'agentic/conc_32/agentic_power_concurrency_32.json';
+  files.set(`${NAME.slice('power_audit_'.length)}_conc32.json`, JSON.stringify({ conc: 32 }));
+  files.set(
+    'LOGS/agentic/conc_32/power_validation.json',
+    JSON.stringify({
+      ...VALIDATION,
+      power_valid: false,
+      selected_window: {
+        ...VALIDATION.selected_window,
+        concurrency: 32,
+        result_path: resultPath,
+        window_file: 'windows/agentic_power_concurrency_32.json',
+      },
+    }),
+  );
+  files.set(
+    'LOGS/power/windows/agentic_power_concurrency_32.json',
+    JSON.stringify({
+      concurrency: 32,
+      result_path: resultPath,
+      benchmark_start_time_unix: START,
+      benchmark_end_time_unix: START + 1,
+    }),
+  );
+  return files;
+}
+
+beforeAll(async () => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-timeline-'));
+  db = await PGlite.create();
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  await db.exec('ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb');
+  readSql = client(db);
+  sql = Object.assign(client(db), {
+    begin: (fn: (tx: postgres.Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(client(tx) as unknown as postgres.Sql)),
+  }) as unknown as postgres.Sql;
+}, 20_000);
+
+afterAll(async () => {
+  await db?.close();
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, created_at, date)
+      VALUES (1, ${RUN}, 1, 'Run Sweep', 'completed', '2026-09-12', '2026-09-12');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+      VALUES (1, 'qwen3.5', 'b200', 'sglang', 'fp8', 'none', false, 1, 1, 1, 1);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+      isl, osl, conc, metrics)
+      VALUES (10, 1, 1, 'single_turn', '2026-09-12', 8192, 1024, 32, '{}'),
+             (11, 1, 1, 'single_turn', '2026-09-12', 8192, 1024, 64, '{}');`);
+});
+
+describe('artifact → ingest → stored Timeline', () => {
+  it.each(['explicit', 'wrong-run', 'wrong-id', 'wrong-conc', 'ambiguous'])(
+    'does not infer or overwrite point provenance for %s identity',
+    async (scenario) => {
+      await db.exec("UPDATE benchmark_results SET benchmark_type = 'agentic_traces'");
+      if (scenario === 'explicit')
+        await db.exec(
+          `UPDATE benchmark_results SET power_audit = '{"source":"existing.json"}' WHERE id = 10`,
+        );
+      if (scenario === 'wrong-run') {
+        await db.exec(`INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, created_at, date)
+          VALUES (2, 1, 1, 'Other run', 'completed', '2026-09-12', '2026-09-12');
+          UPDATE benchmark_results SET workflow_run_id = 2 WHERE id = 10`);
+      }
+      if (scenario === 'wrong-conc')
+        await db.exec('UPDATE benchmark_results SET conc = 31 WHERE id = 10');
+      if (scenario === 'ambiguous')
+        await db.exec('UPDATE benchmark_results SET conc = 32, isl = 1 WHERE id = 11');
+      const before = await db.query('SELECT id, power_audit FROM benchmark_results ORDER BY id');
+      await ingestGpuMetricsArtifact(sql, {
+        workflowRunId: 1,
+        artifact: writeArtifact(NAME, agentxBundle()),
+        benchmarkResultIds: scenario === 'wrong-id' ? [11] : [10, 11],
+      });
+      const after = await db.query('SELECT id, power_audit FROM benchmark_results ORDER BY id');
+      expect(after.rows).toEqual(before.rows);
+    },
+  );
+
+  it('matches artifact windows, host/GPU identity, deduplicated mean watts and gaps for a multinode bundle', async () => {
+    const files = bundle();
+    const artifact = writeArtifact(NAME, files);
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact,
+      benchmarkResultIds: [10, 11],
+    });
+    // Remove the actual artifact before querying: only the DB survives.
+    fs.rmSync(artifact.artifactDir, { recursive: true });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    const actual = storedPowerSeries(stored!.series);
+    expect(actual).toEqual(cutPowerAuditBundle(NAME, files));
+    expect(actual[0]).toMatchObject({
+      artifact: NAME,
+      source: SOURCE,
+      startMs: (START - 60) * 1000,
+      t: [0, 60, 61, 121],
+      power: [
+        [0, 400, 550, null],
+        [null, 450, null, 90],
+      ],
+      devices: [
+        { id: 'host-a/GPU-a0', role: 'prefill' },
+        { id: 'host-b/GPU-b0', role: 'decode' },
+      ],
+    });
+    const point = await getGpuMetricsForPoint(readSql, 10);
+    expect(point!.series.map((series) => series.benchmarkResultIds)).toEqual([
+      [10, 11],
+      [10, 11],
+    ]);
+    expect(storedPowerSeries(point!.series)).toEqual(actual);
+  });
+
+  it('retains selected-window precedence and validation role overrides across ingestion', async () => {
+    const files = bundle({
+      ...VALIDATION,
+      per_gpu_role: { 'host-a/GPU-a0': 'decode', 'host-b/GPU-b0': 'prefill' },
+    });
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NAME, files),
+      benchmarkResultIds: [10],
+    });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    const actual = storedPowerSeries(stored!.series);
+    expect(actual).toEqual(cutPowerAuditBundle(NAME, files));
+    expect(actual[0].devices?.[0]).toEqual({ id: 'host-b/GPU-b0', role: 'prefill' });
+  });
+
+  it('keeps SMI telemetry embedded in a power_audit bundle readable with the same source/window cuts', async () => {
+    const files = bundle();
+    files.set(
+      'gpu_metrics.csv',
+      [
+        'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+        `${stamp(START - 61)}, 0, 1 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+        `${stamp(START)}, 0, 300 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+        `${stamp(START)}, 1, 500 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+        `${stamp(START + 1)}, 0, 700 W, 60, 1000 MHz, 2000 MHz, 80 %, 70 %`,
+      ].join('\n'),
+    );
+    files.set('gpu_metrics_identity.csv', 'index, uuid\n0, GPU-a\n1, GPU-b');
+    files.set(
+      'benchmark_gpu_metrics_context.json',
+      JSON.stringify({ timestamp_timezone: '+02:00' }),
+    );
+    const artifact = writeArtifact(NAME, files);
+    await ingestGpuMetricsArtifact(sql, { workflowRunId: 1, artifact, benchmarkResultIds: [10] });
+    fs.rmSync(artifact.artifactDir, { recursive: true });
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    expect(stored!.series).toHaveLength(1);
+    expect(stored!.series[0].fileName).toBe('gpu_metrics.csv');
+    const actual = storedPowerSeries(stored!.series);
+    expect(actual).toEqual(cutPowerAuditBundle(NAME, files));
+    expect(actual).toMatchObject([
+      {
+        source: SOURCE,
+        startMs: START * 1000,
+        gpus: [0, 1],
+        power: [
+          [300, 700],
+          [500, null],
+        ],
+        devices: [{ id: '0' }, { id: '1' }],
+      },
+    ]);
+  });
+
+  it('rejects incomplete per-host commits using the artifact inventory and legacy manifest', async () => {
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: writeArtifact(NAME, bundle()),
+      benchmarkResultIds: [10],
+    });
+    await sql`DELETE FROM gpu_metric_series WHERE file_name = 'LOGS/power/samples.csv#host-b'`;
+    const stored = await getGpuMetricsForRun(readSql, RUN);
+    expect(stored!.series).toHaveLength(1);
+    expect(() => storedPowerSeries(stored!.series)).toThrow(
+      'stored file/sample coverage is incomplete',
+    );
+    await sql`UPDATE gpu_metric_series SET sidecars = sidecars - 'seriesInventory'`;
+    const legacy = await getGpuMetricsForRun(readSql, RUN);
+    expect(() => storedPowerSeries(legacy!.series)).toThrow(
+      'expected device host-b GPU 0 is not stored',
+    );
+  });
+});
diff --git a/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts b/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
new file mode 100644
index 000000000..7cba11008
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics.reingest-consistency.test.ts
@@ -0,0 +1,236 @@
+/**
+ * Re-ingest consistency of the PowerX telemetry read path.
+ *
+ * Property under test: a reader of one benchmark point never observes samples
+ * and per-GPU statistics that come from different versions of the same series.
+ *
+ * `upsertGpuMetricSeries` replaces samples and stats inside one `sql.begin`
+ * transaction, so the write side is atomic. `getGpuMetricsForPoint` ->
+ * `loadSeriesDetails`, however, issues separate autocommit statements (series
+ * rows, then `gpu_metric_gpu_stats`, then `gpu_metric_samples`). In production
+ * the DbClient is either neon() HTTP (one implicit transaction per call) or a
+ * postgres.js pool used without a transaction, so a re-ingest can commit between
+ * the stats and the samples statement. The reader re-checks the series version
+ * key afterwards and restarts the read when it moved.
+ *
+ * PGlite is single-connection, so the interleaving is simulated at statement
+ * granularity: after the stats statement returns, a full re-ingest transaction
+ * runs and commits before the samples statement executes. Under READ COMMITTED
+ * this is observationally identical to a second connection committing between
+ * the two autocommit statements.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { PGlite } from '@electric-sql/pglite';
+import type postgres from 'postgres';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import type { DbClient } from '../connection';
+import { ingestGpuMetricsArtifact, refreshGpuMetricStats } from '../etl/gpu-metrics-ingest';
+import { getGpuMetricsForPoint, type GpuMetricSeries } from './gpu-metrics';
+
+type Sql = postgres.Sql;
+let db: PGlite;
+/** Writer handle: the ingest code calls `sql.begin`, `sql.array`, `sql.json`. */
+let sql: Sql;
+/** Reader handle: plain autocommit statements, as the app's DbClient issues them. */
+let reader: DbClient;
+const roots: string[] = [];
+
+function queryClient(database: Pick<PGlite, 'query'>) {
+  const client = async (strings: TemplateStringsArray, ...values: unknown[]) => {
+    const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+    const result = await database.query<Record<string, unknown>>(query, values);
+    return result.rows;
+  };
+  return Object.assign(client, {
+    json: JSON.stringify,
+    array: (value: unknown) => value,
+  });
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  // The point reader aggregates benchmark_results.power_audit (migration 015).
+  await db.exec('ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb');
+  sql = Object.assign(queryClient(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(queryClient(tx) as unknown as Sql)),
+  }) as unknown as Sql;
+  reader = queryClient(db) as DbClient;
+}, 20_000);
+
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+    VALUES (1, 34557177019, 1, 'Run Sweep', 'completed', 'success', '2026-09-11', '2026-09-11');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 4, 4, 4, 4);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+           (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}');`);
+});
+
+afterEach(() => {
+  for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+afterAll(async () => {
+  await db?.close();
+});
+
+/** Version 1: 2 GPUs x 2 distinct timestamps (+ duplicate flush row) = 4 unique samples. */
+const NVIDIA_CSV_V1 = [
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+  '2026/09/11 04:19:41.982, 0, 187.80 W, 33, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:41.986, 1, 190.96 W, 39, 120 MHz, 3996 MHz, 0 %, 0 %',
+  '2026/09/11 04:19:42.990, 0, 912.10 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+  // Duplicate flush of the last sample, as emitted when the monitor stops.
+  '2026/09/11 04:19:42.994, 1, 905.30 W, 62, 1965 MHz, 3996 MHz, 97 %, 73 %',
+].join('\n');
+
+/**
+ * Version 1 + `extraScrapes` further scrapes per GPU, each at a distinct
+ * timestamp, so every version has a distinct CSV digest and sample count.
+ */
+function csvVersion(extraScrapes: number): string {
+  const lines = [NVIDIA_CSV_V1];
+  for (let i = 0; i < extraScrapes; i += 1) {
+    const second = String(43 + i).padStart(2, '0');
+    lines.push(
+      `2026/09/11 04:19:${second}.990, 0, 700.00 W, 60, 1900 MHz, 3996 MHz, 90 %, 70 %`,
+      `2026/09/11 04:19:${second}.994, 1, 702.50 W, 61, 1900 MHz, 3996 MHz, 91 %, 71 %`,
+    );
+  }
+  return lines.join('\n');
+}
+
+/** Version 2: the same artifact re-uploaded with one more scrape per GPU = 6 unique samples. */
+const NVIDIA_CSV_V2 = csvVersion(1);
+
+const V1_UNIQUE_SAMPLES = 4;
+const V2_UNIQUE_SAMPLES = 6;
+
+function writeArtifact(csv: string, contextZone = 'UTC') {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-metrics-reingest-'));
+  roots.push(root);
+  const artifactName = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+  const artifactDir = path.join(root, artifactName);
+  fs.mkdirSync(artifactDir);
+  fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_context.json'),
+    JSON.stringify({ timestamp_timezone: contextZone }),
+  );
+  fs.writeFileSync(
+    path.join(artifactDir, 'gpu_metrics_identity.csv'),
+    'index, uuid, name\n0, GPU-a, NVIDIA B200\n1, GPU-b, NVIDIA B200\n',
+  );
+  return { artifactName, artifactDir };
+}
+
+function ingest(csv: string) {
+  return ingestGpuMetricsArtifact(sql, {
+    workflowRunId: 1,
+    artifact: writeArtifact(csv),
+    benchmarkResultIds: [10],
+  });
+}
+
+interface InterleavedReader {
+  client: DbClient;
+  /** How many times the reader issued its first statement (the point's series rows). */
+  seriesReads: () => number;
+}
+
+/**
+ * A DbClient that forwards every statement to `base`, but after each
+ * `gpu_metric_gpu_stats` statement has returned (and before the caller gets
+ * the rows back), runs `between(statsReadIndex)` to completion. With a
+ * committed re-ingest in `between`, this is the schedule: reader(series),
+ * reader(stats), WRITER COMMITS, reader(samples), reader(version check).
+ */
+function interleaveAfterStats(
+  base: DbClient,
+  between: (statsReadIndex: number) => Promise<unknown>,
+): InterleavedReader {
+  let statsReads = 0;
+  let seriesReads = 0;
+  const client: DbClient = async (strings, ...values) => {
+    const text = strings.join('');
+    if (/from benchmark_result_gpu_metrics link/.test(text)) seriesReads += 1;
+    const rows = await base(strings, ...values);
+    if (/from gpu_metric_gpu_stats/.test(text)) {
+      statsReads += 1;
+      await between(statsReads);
+    }
+    return rows;
+  };
+  return { client, seriesReads: () => seriesReads };
+}
+
+/**
+ * The consistency property: every statistic row was computed over exactly the
+ * sample rows returned in the same payload, and the series header agrees.
+ */
+function expectCoherent(series: GpuMetricSeries) {
+  for (const stat of series.stats) {
+    const rowsForGpu = series.data.filter((row) => row.index === stat.gpuIndex).length;
+    expect(stat.count, `stats.count for gpu ${stat.gpuIndex}/${stat.metric}`).toBe(rowsForGpu);
+  }
+  expect(series.sampleCount, 'series.sampleCount vs data.length').toBe(series.data.length);
+}
+
+describe('getGpuMetricsForPoint under telemetry re-ingest', () => {
+  it('a re-ingest committed between the stats and samples statements yields one version', async () => {
+    const first = await ingest(NVIDIA_CSV_V1);
+    expect(first.samplesInserted).toBe(V1_UNIQUE_SAMPLES);
+
+    let reingest: Awaited<ReturnType<typeof ingest>> | undefined;
+    const interleaved = interleaveAfterStats(reader, async (statsReadIndex) => {
+      if (statsReadIndex === 1) reingest = await ingest(NVIDIA_CSV_V2);
+    });
+
+    const payload = await getGpuMetricsForPoint(interleaved.client, 10);
+
+    // The writer really did replace the series inside its own transaction.
+    expect(reingest?.samplesInserted).toBe(V2_UNIQUE_SAMPLES);
+    expect(reingest?.seriesIds).toEqual(first.seriesIds);
+    expect(payload?.series).toHaveLength(1);
+    // The version key moved, so the reader restarted from the series statement.
+    expect(interleaved.seriesReads()).toBe(2);
+
+    for (const series of payload!.series) {
+      expect(series.sampleCount).toBe(V2_UNIQUE_SAMPLES);
+      expect(series.data).toHaveLength(V2_UNIQUE_SAMPLES);
+      for (const stat of series.stats) expect(stat.count).toBe(V2_UNIQUE_SAMPLES / 2);
+      expectCoherent(series);
+    }
+  });
+});
+
+it('retries when only the digest version changes between statements', async () => {
+  const first = await ingest(NVIDIA_CSV_V1);
+  await sql`update gpu_metric_series set stats_version = 0`;
+  await sql`update gpu_metric_gpu_stats set mean_value = -1`;
+  const interleaved = interleaveAfterStats(reader, async (index) => {
+    if (index === 1) await refreshGpuMetricStats(sql, first.seriesIds[0]!);
+  });
+  const payload = await getGpuMetricsForPoint(interleaved.client, 10);
+  expect(interleaved.seriesReads()).toBe(2);
+  expect(
+    payload?.series[0]?.stats.find((s) => s.gpuIndex === 0 && s.metric === 'power_w')?.mean,
+  ).toBeCloseTo(549.95, 3);
+});
diff --git a/packages/db/src/queries/gpu-metrics.test.ts b/packages/db/src/queries/gpu-metrics.test.ts
new file mode 100644
index 000000000..54745f11a
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics.test.ts
@@ -0,0 +1,321 @@
+import fs from 'node:fs';
+
+import { PGlite } from '@electric-sql/pglite';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+
+import type { DbClient } from '../connection';
+import { getGpuMetricsForPoint, getGpuMetricsForRun, SAMPLE_PAGE_SIZE } from './gpu-metrics';
+
+let db: PGlite;
+const sql: DbClient = async (strings, ...values) => {
+  const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+  const result = await db.query<Record<string, unknown>>(query, values);
+  return result.rows;
+};
+
+const WITH_SERIES = 34557177019;
+const RETRIED = 34557177021;
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of ['001_initial_schema.sql', '016_gpu_metrics.sql']) {
+    await db.exec(fs.readFileSync(new URL(`../../migrations/${name}`, import.meta.url), 'utf8'));
+  }
+  await db.exec('ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb');
+}, 20_000);
+
+afterAll(async () => {
+  await db?.close();
+});
+
+/**
+ * Run 1 holds a two-node artifact (one CSV per serving node) whose first CSV is
+ * shared by points 10 and 11; runs 3 and 4 are two attempts of one GitHub run.
+ * Point 12 is deliberately left unlinked.
+ */
+beforeEach(async () => {
+  await db.exec(`TRUNCATE workflow_runs, configs RESTART IDENTITY CASCADE;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion,
+      head_branch, head_sha, html_url, created_at, date)
+    VALUES (1, ${WITH_SERIES}, 1, 'Run Sweep', 'completed', 'success', 'main', 'abc123',
+        'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${WITH_SERIES}',
+        '2026-09-11T04:19:00Z', '2026-09-11'),
+      (3, ${RETRIED}, 1, 'Run Sweep', 'completed', 'failure', null, null, null,
+        '2026-09-13T04:19:00Z', '2026-09-13'),
+      (4, ${RETRIED}, 2, 'Run Sweep', 'completed', 'success', null, null, null,
+        '2026-09-13T06:19:00Z', '2026-09-13');
+
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      is_multinode, prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, true, 8, 8, 8, 8);
+
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date,
+      isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+           (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}'),
+           (12, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 128, '{}');
+
+    INSERT INTO gpu_metric_series (id, workflow_run_id, artifact_name, config_key, file_name,
+      vendor, csv_sha256, sample_interval_s, sample_count, gpu_count, started_at, ended_at,
+      sidecars)
+    VALUES (100, 1, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'node0/gpu_metrics.csv', 'nvidia', 'sha-node0',
+        1, 3, 2, '2026-09-11T04:19:41Z', '2026-09-11T04:19:43Z',
+        '{"context": {"timestamp_timezone": "UTC"}}'),
+      (101, 1, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'node1/gpu_metrics.csv', 'nvidia', 'sha-node1',
+        1, 1, 1, '2026-09-11T04:19:41Z', '2026-09-11T04:19:42Z', '{}'),
+      (102, 4, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_1',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_1', 'gpu_metrics.csv', 'amd', 'sha-attempt2',
+        null, 1, 1, '2026-09-13T06:20:00Z', '2026-09-13T06:20:01Z', '{}'),
+      (103, 3, 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+        'dsr1_8k1k_fp4_sglang_conc32_b200-x_0', 'gpu_metrics.csv', 'nvidia', 'sha-attempt1',
+        null, 1, 1, '2026-09-13T04:20:00Z', '2026-09-13T04:20:01Z', '{}');
+
+    INSERT INTO benchmark_result_gpu_metrics (benchmark_result_id, series_id)
+    VALUES (10, 100), (11, 100), (10, 101);
+
+    INSERT INTO gpu_metric_gpu_stats (series_id, gpu_index, metric, sample_count,
+      min_value, max_value, mean_value, median_value, p95_value, p99_value, stddev_value)
+    VALUES (100, 0, 'powerW', 2, 187.5, 912.25, 549.875, 549.875, 912.25, 912.25, 362.375),
+           (100, 1, 'powerW', 1, 190.5, 190.5, 190.5, 190.5, 190.5, 190.5, 0),
+           (101, 0, 'powerW', 1, 500.5, 500.5, 500.5, 500.5, 500.5, 500.5, 0),
+           (102, 0, 'powerW', 1, 700.5, 700.5, 700.5, 700.5, 700.5, 700.5, 0),
+           (103, 0, 'powerW', 1, 100.5, 100.5, 100.5, 100.5, 100.5, 100.5, 0);
+
+    INSERT INTO gpu_metric_samples (series_id, gpu_index, sampled_at, power_w, temperature_c,
+      sm_clock_mhz, mem_clock_mhz, gpu_util_pct, mem_util_pct, edge_temp_c, mem_temp_c,
+      gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv, fclk_mhz, socclk_mhz, mm_activity_pct)
+    VALUES (100, 0, '2026-09-11T04:19:41Z', 187.5, 33, 120, 3996, 0, 0,
+              35.5, 40.5, 750, 800, 1350, 1940, 1100, 12.5),
+           (100, 1, '2026-09-11T04:19:41Z', 190.5, 39, 120, 3996, 0, 0,
+              null, null, null, null, null, null, null, null),
+           -- Collector dropout: the row exists but every metric column is null.
+           (100, 0, '2026-09-11T04:19:42Z', null, null, null, null, null, null,
+              null, null, null, null, null, null, null, null),
+           (101, 0, '2026-09-11T04:19:41Z', 500.5, 50, 1965, 3996, 98, 74,
+              null, null, null, null, null, null, null, null),
+           (102, 0, '2026-09-13T06:20:00Z', 700.5, 60, 1965, 3996, 99, 80,
+              null, null, null, null, null, null, null, null),
+           (103, 0, '2026-09-13T04:20:00Z', 100.5, 20, 120, 3996, 0, 0,
+              null, null, null, null, null, null, null, null);`);
+});
+
+describe('getGpuMetricsForRun', () => {
+  it('returns the run header, every series, its per-GPU stats, and its samples', async () => {
+    const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
+
+    expect(payload?.workflowRun).toEqual({
+      id: 1,
+      githubRunId: WITH_SERIES,
+      runAttempt: 1,
+      name: 'Run Sweep',
+      date: '2026-09-11',
+      htmlUrl: `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${WITH_SERIES}`,
+      headBranch: 'main',
+      headSha: 'abc123',
+      conclusion: 'success',
+      status: 'completed',
+      createdAt: '2026-09-11T04:19:00.000Z',
+    });
+
+    expect(payload?.series.map((series) => series.fileName)).toEqual([
+      'node0/gpu_metrics.csv',
+      'node1/gpu_metrics.csv',
+    ]);
+
+    const [node0, node1] = payload!.series;
+    expect(node0).toMatchObject({
+      id: 100,
+      artifactName: 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+      configKey: 'dsr1_8k1k_fp4_sglang_conc32_b200-x_0',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 3,
+      gpuCount: 2,
+      startedAt: '2026-09-11T04:19:41.000Z',
+      endedAt: '2026-09-11T04:19:43.000Z',
+      sidecars: { context: { timestamp_timezone: 'UTC' } },
+      benchmarkResultIds: [10, 11],
+    });
+    // Pre-migration (unversioned) digests are recomputed read-only; null is not zero.
+    expect(node0?.stats.filter((stat) => stat.metric === 'power_w')).toEqual([
+      {
+        gpuIndex: 0,
+        metric: 'power_w',
+        count: 1,
+        min: 187.5,
+        max: 187.5,
+        mean: 187.5,
+        median: 187.5,
+        p95: 187.5,
+        p99: 187.5,
+        stddev: 0,
+      },
+      {
+        gpuIndex: 1,
+        metric: 'power_w',
+        count: 1,
+        min: 190.5,
+        max: 190.5,
+        mean: 190.5,
+        median: 190.5,
+        p95: 190.5,
+        p99: 190.5,
+        stddev: 0,
+      },
+    ]);
+    expect(node0?.stats).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ gpuIndex: 0, metric: 'edge_temp_c', mean: 35.5, count: 1 }),
+        expect.objectContaining({ gpuIndex: 0, metric: 'gpu_util_pct', mean: 0, count: 1 }),
+        expect.objectContaining({ gpuIndex: 0, metric: 'mem_voltage_mv', mean: 1350, count: 1 }),
+      ]),
+    );
+    expect(node0?.data.map((sample) => [sample.timestamp, sample.index, sample.power])).toEqual([
+      ['2026-09-11T04:19:41.000Z', 0, 187.5],
+      ['2026-09-11T04:19:41.000Z', 1, 190.5],
+      ['2026-09-11T04:19:42.000Z', 0, 0],
+    ]);
+    expect(node0?.data[0]).toEqual({
+      timestamp: '2026-09-11T04:19:41.000Z',
+      index: 0,
+      power: 187.5,
+      temperature: 33,
+      smClock: 120,
+      memClock: 3996,
+      gpuUtil: 0,
+      memUtil: 0,
+      edgeTemp: 35.5,
+      memTemp: 40.5,
+      gfxVoltage: 750,
+      socVoltage: 800,
+      memVoltage: 1350,
+      fclk: 1940,
+      socClk: 1100,
+      mmActivity: 12.5,
+    });
+    expect(node1?.benchmarkResultIds).toEqual([10]);
+  });
+
+  it('reads the latest attempt of a rerun GitHub run id, not the first', async () => {
+    const payload = await getGpuMetricsForRun(sql, RETRIED);
+    expect(payload?.workflowRun).toMatchObject({ id: 4, runAttempt: 2, conclusion: 'success' });
+    expect(payload?.series.map((series) => ({ id: series.id, vendor: series.vendor }))).toEqual([
+      { id: 102, vendor: 'amd' },
+    ]);
+  });
+
+  it('reports a dropped sample as zero power with every other metric absent', async () => {
+    const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
+    const dropped = payload?.series[0]?.data.at(-1);
+    // Power keeps the `?? 0` default (a null power reading is indistinguishable
+    // from a genuine 0 W reading once it reaches the chart); the other metrics
+    // stay absent so a power-only collector never shows up as 0 °C / 0 MHz / 0 %.
+    expect(dropped).toEqual({
+      timestamp: '2026-09-11T04:19:42.000Z',
+      index: 0,
+      power: 0,
+      temperature: undefined,
+      smClock: undefined,
+      memClock: undefined,
+      gpuUtil: undefined,
+      memUtil: undefined,
+      edgeTemp: undefined,
+      memTemp: undefined,
+      gfxVoltage: undefined,
+      socVoltage: undefined,
+      memVoltage: undefined,
+      fclk: undefined,
+      socClk: undefined,
+      mmActivity: undefined,
+    });
+    // Absent rather than zeroed, so consumers can tell "not collected" from
+    // "collected as zero" for everything except power.
+    expect(Object.hasOwn(dropped!, 'edgeTemp')).toBe(true);
+    expect(dropped?.edgeTemp).toBeUndefined();
+  });
+});
+
+it('keeps healthy hosts readable when an unversioned sibling has incomplete samples', async () => {
+  await sql`update gpu_metric_series set sample_count = 4 where id = 100`;
+  const payload = await getGpuMetricsForRun(sql, WITH_SERIES);
+  expect(payload?.series[0]?.stats).toEqual([]);
+  expect(payload?.series[0]?.data).toHaveLength(3);
+  expect(payload?.series[1]?.stats).toEqual(
+    expect.arrayContaining([expect.objectContaining({ metric: 'power_w', mean: 500.5, count: 1 })]),
+  );
+});
+
+it('scopes prefix and source reads in SQL, including containing power-audit bundles', async () => {
+  await db.exec(`INSERT INTO gpu_metric_series
+    (id, workflow_run_id, artifact_name, config_key, file_name, vendor, csv_sha256,
+      sample_count, gpu_count, started_at, ended_at)
+    VALUES (110, 1, 'power_audit_dsr1_8k1k_fp4_sglang', 'bundle', 'samples.csv', 'nvidia', 'bundle',
+      0, 1, now(), now()),
+      (111, 1, 'gpu_metrics_dsr1X8k1k_fp4_sglang_conc32_b200-x_0', 'other', 'gpu_metrics.csv', 'nvidia', 'other',
+      0, 1, now(), now());`);
+  const sampleIds: unknown[] = [];
+  const observed: DbClient = (strings, ...values) => {
+    if (strings.join('').includes('from gpu_metric_samples')) sampleIds.push(values[0]);
+    return sql(strings, ...values);
+  };
+  const payload = await getGpuMetricsForRun(observed, WITH_SERIES, {
+    prefix: 'dsr1_8k1k_fp4_sglang_conc32',
+    sourceResults: ['dsr1_8k1k_fp4_sglang_conc32_b200-x_0'],
+  });
+  expect(payload?.series.map((series) => series.id)).toEqual([100, 101, 110]);
+  expect(sampleIds).toEqual([[100, 101, 110]]);
+  expect(await getGpuMetricsForRun(sql, WITH_SERIES, { sourceResults: ['missing'] })).toBeNull();
+});
+
+it('reads only the selected view host while retaining every exact explorer label', async () => {
+  const prefix = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+  const names = [`${prefix}/node0/gpu_metrics.csv`, `${prefix}/node1/gpu_metrics.csv`];
+  const sampleIds: unknown[] = [];
+  const observed: DbClient = (strings, ...values) => {
+    if (strings.join('').includes('from gpu_metric_samples')) sampleIds.push(values[0]);
+    return sql(strings, ...values);
+  };
+  const selected = await getGpuMetricsForRun(observed, WITH_SERIES, { artifact: names[1] });
+  expect(selected?.artifactNames).toEqual(names);
+  expect(selected?.series.map((series) => series.id)).toEqual([101]);
+  expect(sampleIds).toEqual([[101]]);
+  const first = await getGpuMetricsForRun(sql, WITH_SERIES, { artifact: null });
+  expect(first?.series[0]?.id).toBe(100);
+  const missing = await getGpuMetricsForRun(observed, WITH_SERIES, { artifact: 'not-an-artifact' });
+  expect(missing).toMatchObject({ artifactNames: names, series: [] });
+  expect(sampleIds).toHaveLength(1);
+});
+
+it('pages a single large series without dropping microseconds and retries changes between pages', async () => {
+  await db.exec(`DELETE FROM gpu_metric_samples WHERE series_id = 100;
+    INSERT INTO gpu_metric_samples (series_id, gpu_index, sampled_at, power_w)
+    SELECT 100, 0, '2026-09-11T04:19:41Z'::timestamptz + n * interval '1 microsecond', n
+    FROM generate_series(1, ${SAMPLE_PAGE_SIZE + 2}) n;
+    UPDATE gpu_metric_series SET sample_count = ${SAMPLE_PAGE_SIZE + 2} WHERE id = 100;`);
+  let pages = 0;
+  const observed: DbClient = async (strings, ...values) => {
+    const rows = await sql(strings, ...values);
+    if (strings.join('').includes('from gpu_metric_samples')) {
+      // Model the bounded HTTP transport; the old whole-series query fails here.
+      expect(rows.length).toBeLessThanOrEqual(SAMPLE_PAGE_SIZE);
+      pages++;
+      if (pages === 1) {
+        await db.exec(`UPDATE gpu_metric_samples SET power_w = power_w + 20000 WHERE series_id = 100;
+          UPDATE gpu_metric_series SET ingested_at = ingested_at + interval '1 second' WHERE id = 100;`);
+      }
+    }
+    return rows;
+  };
+  const payload = await getGpuMetricsForPoint(observed, 11);
+  expect(pages).toBe(4);
+  const data = payload!.series[0]!.data;
+  expect(data).toHaveLength(SAMPLE_PAGE_SIZE + 2);
+  expect(data.map((row) => row.power)).toEqual(
+    Array.from({ length: SAMPLE_PAGE_SIZE + 2 }, (_, i) => i + 20001),
+  );
+  expect(payload!.series[0]!.stats.find((stat) => stat.metric === 'power_w')?.count).toBe(
+    SAMPLE_PAGE_SIZE + 2,
+  );
+});
diff --git a/packages/db/src/queries/gpu-metrics.ts b/packages/db/src/queries/gpu-metrics.ts
new file mode 100644
index 000000000..cc4767cb6
--- /dev/null
+++ b/packages/db/src/queries/gpu-metrics.ts
@@ -0,0 +1,515 @@
+/**
+ * Read side of the PowerX telemetry digest (migration 016).
+ *
+ * Two entry points: everything recorded during one GitHub Actions run (the
+ * PowerX explorer keyed by run ID), and the series linked to one benchmark
+ * point (the per-point detail tab). Samples are returned as flat rows with
+ * ISO timestamps so the existing D3 charts consume them unchanged.
+ */
+
+import {
+  GPU_STATS_VERSION,
+  computeStoredGpuMetricStats,
+  statMetricColumn,
+  type StoredGpuMetricSample,
+} from '../lib/gpu-metric-stats';
+
+import type { DbClient } from '../connection.js';
+
+export interface GpuMetricSampleRow {
+  timestamp: string;
+  index: number;
+  power: number;
+  /**
+   * Absent when the collector did not sample the metric (the multinode DCGM
+   * power bundle scrapes power only), so readers can tell "not collected"
+   * from a genuine zero reading.
+   */
+  temperature?: number;
+  smClock?: number;
+  memClock?: number;
+  gpuUtil?: number;
+  memUtil?: number;
+  edgeTemp?: number;
+  memTemp?: number;
+  gfxVoltage?: number;
+  socVoltage?: number;
+  memVoltage?: number;
+  fclk?: number;
+  socClk?: number;
+  mmActivity?: number;
+}
+
+export interface GpuMetricStatRow {
+  gpuIndex: number;
+  metric: string;
+  count: number;
+  min: number;
+  max: number;
+  mean: number;
+  median: number;
+  p95: number;
+  p99: number;
+  stddev: number;
+}
+
+export interface GpuMetricSeries {
+  id: number;
+  artifactName: string;
+  configKey: string;
+  fileName: string;
+  vendor: string;
+  sampleIntervalS: number | null;
+  sampleCount: number;
+  gpuCount: number;
+  startedAt: string;
+  endedAt: string;
+  sidecars: Record<string, unknown>;
+  benchmarkResultIds: number[];
+  /** Existing benchmark provenance can recover windows from older ingests. */
+  powerAudits?: Record<string, unknown>[];
+  stats: GpuMetricStatRow[];
+  data: GpuMetricSampleRow[];
+}
+
+export interface GpuMetricsRunPayload {
+  workflowRun: {
+    id: number;
+    githubRunId: number;
+    runAttempt: number;
+    name: string;
+    date: string;
+    htmlUrl: string | null;
+    headBranch: string | null;
+    headSha: string | null;
+    conclusion: string | null;
+    status: string | null;
+    createdAt: string | null;
+  };
+  series: GpuMetricSeries[];
+  /** Complete explorer labels when only one view artifact's samples were requested. */
+  artifactNames?: string[];
+}
+
+export interface GpuMetricsRunSelection {
+  prefix?: string | null;
+  sourceResults?: readonly string[] | null;
+  /** Undefined reads all matching artifacts; null selects the first explorer artifact. */
+  artifact?: string | null;
+}
+
+// One sample row serializes to roughly 0.5 KB over the Neon HTTP driver (17 numeric
+// columns plus keys and an ISO timestamp), so 50k rows stay near 25 MB, well below the
+// 64 MiB response cap, while a 1.25M-sample run needs ~25 sequential pages, not 125.
+export const SAMPLE_PAGE_SIZE = 50_000;
+
+interface RawSeriesRow {
+  id: number | string;
+  workflow_run_id: number | string;
+  artifact_name: string;
+  config_key: string;
+  file_name: string;
+  vendor: string;
+  sample_interval_s: number | null;
+  sample_count: number;
+  gpu_count: number;
+  started_at: string | Date;
+  ended_at: string | Date;
+  sidecars: Record<string, unknown> | string;
+  benchmark_result_ids: (number | string)[] | null;
+  power_audits: Record<string, unknown>[] | null;
+  csv_sha256: string;
+  ingested_at: string | Date;
+  stats_version: number;
+}
+
+/** The columns `upsertGpuMetricSeries` rewrites whenever it replaces a series. */
+interface RawSeriesVersionRow {
+  id: number | string;
+  csv_sha256: string;
+  sample_count: number;
+  ingested_at: string | Date;
+  stats_version: number;
+}
+
+interface RawStatRow {
+  series_id: number | string;
+  gpu_index: number;
+  metric: string;
+  sample_count: number;
+  min_value: number;
+  max_value: number;
+  mean_value: number;
+  median_value: number;
+  p95_value: number;
+  p99_value: number;
+  stddev_value: number;
+}
+
+interface RawSampleRow extends StoredGpuMetricSample {
+  series_id: number | string;
+}
+
+const isoString = (value: string | Date): string =>
+  value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+
+const optional = (value: number | null): number | undefined => (value === null ? undefined : value);
+
+/**
+ * Thrown by the point/run readers when a series was replaced while its parts
+ * were being read; the caller restarts the whole read (links may have changed).
+ */
+export class TelemetrySnapshotChangedError extends Error {
+  constructor(seriesIds: readonly number[]) {
+    super(`gpu_metric_series ${seriesIds.join(', ')} changed while being read`);
+    this.name = 'TelemetrySnapshotChangedError';
+  }
+}
+
+const MAX_SNAPSHOT_ATTEMPTS = 3;
+
+const seriesVersionKey = (row: RawSeriesVersionRow): string =>
+  `${Number(row.id)}:${row.csv_sha256}:${Number(row.sample_count)}:${isoString(row.ingested_at)}:${row.stats_version}`;
+
+async function withConsistentSnapshot<T>(read: () => Promise<T>): Promise<T> {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return await read();
+    } catch (error) {
+      if (!(error instanceof TelemetrySnapshotChangedError) || attempt >= MAX_SNAPSHOT_ATTEMPTS) {
+        throw error;
+      }
+    }
+  }
+}
+
+function toSampleRow(raw: RawSampleRow): GpuMetricSampleRow {
+  return {
+    timestamp: isoString(raw.sampled_at),
+    index: Number(raw.gpu_index),
+    power: raw.power_w ?? 0,
+    temperature: optional(raw.temperature_c),
+    smClock: optional(raw.sm_clock_mhz),
+    memClock: optional(raw.mem_clock_mhz),
+    gpuUtil: optional(raw.gpu_util_pct),
+    memUtil: optional(raw.mem_util_pct),
+    edgeTemp: optional(raw.edge_temp_c),
+    memTemp: optional(raw.mem_temp_c),
+    gfxVoltage: optional(raw.gfx_voltage_mv),
+    socVoltage: optional(raw.soc_voltage_mv),
+    memVoltage: optional(raw.mem_voltage_mv),
+    fclk: optional(raw.fclk_mhz),
+    socClk: optional(raw.socclk_mhz),
+    mmActivity: optional(raw.mm_activity_pct),
+  };
+}
+
+function toStatRow(raw: RawStatRow): GpuMetricStatRow {
+  return {
+    gpuIndex: Number(raw.gpu_index),
+    metric: raw.metric,
+    count: Number(raw.sample_count),
+    min: raw.min_value,
+    max: raw.max_value,
+    mean: raw.mean_value,
+    median: raw.median_value,
+    p95: raw.p95_value,
+    p99: raw.p99_value,
+    stddev: raw.stddev_value,
+  };
+}
+
+async function loadSeriesDetails(
+  sql: DbClient,
+  seriesRows: readonly RawSeriesRow[],
+): Promise<GpuMetricSeries[]> {
+  if (seriesRows.length === 0) return [];
+  const ids = seriesRows.map((row) => Number(row.id));
+
+  const statRows = (await sql`
+    select series_id, gpu_index, metric, sample_count, min_value, max_value, mean_value,
+      median_value, p95_value, p99_value, stddev_value
+    from gpu_metric_gpu_stats
+    where series_id = any(${ids}::bigint[])
+    order by series_id, gpu_index, metric
+  `) as unknown as RawStatRow[];
+
+  const sampleRows: RawSampleRow[] = [];
+  let cursor: RawSampleRow | undefined;
+  for (;;) {
+    const page = (await sql`
+      select series_id, gpu_index,
+        to_char(sampled_at at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"') as sampled_at,
+        power_w, temperature_c, sm_clock_mhz, mem_clock_mhz, gpu_util_pct, mem_util_pct,
+        edge_temp_c, mem_temp_c, gfx_voltage_mv, soc_voltage_mv, mem_voltage_mv,
+        fclk_mhz, socclk_mhz, mm_activity_pct
+      from gpu_metric_samples
+      where series_id = any(${ids}::bigint[])
+        and (${cursor?.series_id ?? null}::bigint is null or
+          (series_id, gpu_index, sampled_at) >
+          (${cursor?.series_id ?? null}::bigint, ${cursor?.gpu_index ?? null}::smallint,
+            ${cursor?.sampled_at ?? null}::timestamptz))
+      order by series_id, gpu_index, gpu_metric_samples.sampled_at
+      limit ${SAMPLE_PAGE_SIZE}
+    `) as unknown as RawSampleRow[];
+    sampleRows.push(...page);
+    if (page.length < SAMPLE_PAGE_SIZE) break;
+    // Keep PostgreSQL's microseconds: a JS Date cursor would repeat or omit boundary rows.
+    cursor = page.at(-1)!;
+  }
+  // The primary-key pages group by GPU; retain the public time-then-GPU ordering.
+  sampleRows.sort(
+    (a, b) =>
+      Number(a.series_id) - Number(b.series_id) ||
+      String(a.sampled_at).localeCompare(String(b.sampled_at)) ||
+      Number(a.gpu_index) - Number(b.gpu_index),
+  );
+
+  // The series, stats and sample pages use separate autocommit queries (the DbClient
+  // has no transaction), so a re-ingest can commit between them. The writer
+  // replaces samples, stats and the series row in one transaction and stamps
+  // `ingested_at`; digest-only upgrades change `stats_version`. An unchanged
+  // key after the sample read proves both belong to the same series version.
+  const versionRows = (await sql`
+    select id, csv_sha256, sample_count, ingested_at,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0) as stats_version
+    from gpu_metric_series s
+    where id = any(${ids}::bigint[])
+  `) as unknown as RawSeriesVersionRow[];
+  const versionKeys = new Set(versionRows.map(seriesVersionKey));
+  if (
+    versionRows.length !== seriesRows.length ||
+    !seriesRows.every((row) => versionKeys.has(seriesVersionKey(row)))
+  ) {
+    throw new TelemetrySnapshotChangedError(ids);
+  }
+
+  const statsBySeries = new Map<number, GpuMetricStatRow[]>();
+  for (const raw of statRows) {
+    const key = Number(raw.series_id);
+    const bucket = statsBySeries.get(key);
+    if (bucket) bucket.push(toStatRow(raw));
+    else statsBySeries.set(key, [toStatRow(raw)]);
+  }
+  const staleIds = new Set(
+    seriesRows
+      .filter((row) => row.stats_version !== GPU_STATS_VERSION)
+      .map((row) => Number(row.id)),
+  );
+  const staleSamples = new Map<number, RawSampleRow[]>();
+  for (const sample of sampleRows) {
+    const id = Number(sample.series_id);
+    if (!staleIds.has(id)) continue;
+    const rows = staleSamples.get(id) ?? [];
+    rows.push(sample);
+    staleSamples.set(id, rows);
+  }
+  for (const row of seriesRows) {
+    const id = Number(row.id);
+    if (!staleIds.has(id)) continue;
+    const samples = staleSamples.get(id) ?? [];
+    if (samples.length !== Number(row.sample_count)) {
+      // Keep samples available to the existing source-gap recovery path, but
+      // never present a partial-population digest as full-record statistics.
+      statsBySeries.set(id, []);
+      continue;
+    }
+    statsBySeries.set(
+      id,
+      computeStoredGpuMetricStats(samples).map((stat) => ({
+        ...stat,
+        metric: statMetricColumn(stat.metric),
+      })),
+    );
+  }
+  const samplesBySeries = new Map<number, GpuMetricSampleRow[]>();
+  for (const raw of sampleRows) {
+    const key = Number(raw.series_id);
+    const bucket = samplesBySeries.get(key);
+    if (bucket) bucket.push(toSampleRow(raw));
+    else samplesBySeries.set(key, [toSampleRow(raw)]);
+  }
+
+  return seriesRows.map((row) => {
+    const id = Number(row.id);
+    return {
+      id,
+      artifactName: row.artifact_name,
+      configKey: row.config_key,
+      fileName: row.file_name,
+      vendor: row.vendor,
+      sampleIntervalS: row.sample_interval_s,
+      sampleCount: Number(row.sample_count),
+      gpuCount: Number(row.gpu_count),
+      startedAt: isoString(row.started_at),
+      endedAt: isoString(row.ended_at),
+      sidecars:
+        typeof row.sidecars === 'string'
+          ? (JSON.parse(row.sidecars) as Record<string, unknown>)
+          : row.sidecars,
+      benchmarkResultIds: (row.benchmark_result_ids ?? []).map(Number),
+      powerAudits: row.power_audits ?? [],
+      stats: statsBySeries.get(id) ?? [],
+      data: samplesBySeries.get(id) ?? [],
+    };
+  });
+}
+
+/**
+ * Stored telemetry for one GitHub Actions run (latest attempt), optionally scoped
+ * before reading samples. View selection also returns the full artifact-name inventory.
+ * Returns null when the run is unknown or has no stored series, so callers can
+ * fall back to the live GitHub artifacts for in-flight runs.
+ */
+export function getGpuMetricsForRun(
+  sql: DbClient,
+  githubRunId: number,
+  selection: GpuMetricsRunSelection = {},
+): Promise<GpuMetricsRunPayload | null> {
+  return withConsistentSnapshot(() => readGpuMetricsForRun(sql, githubRunId, selection));
+}
+
+async function readGpuMetricsForRun(
+  sql: DbClient,
+  githubRunId: number,
+  selection: GpuMetricsRunSelection,
+): Promise<GpuMetricsRunPayload | null> {
+  const runRows = (await sql`
+    select id, github_run_id, run_attempt, name, date, html_url, head_branch, head_sha,
+      conclusion, status, created_at
+    from workflow_runs
+    where github_run_id = ${githubRunId}
+    order by run_attempt desc
+    limit 1
+  `) as unknown as {
+    id: number | string;
+    github_run_id: number | string;
+    run_attempt: number;
+    name: string;
+    date: string | Date;
+    html_url: string | null;
+    head_branch: string | null;
+    head_sha: string | null;
+    conclusion: string | null;
+    status: string | null;
+    created_at: string | Date | null;
+  }[];
+  const run = runRows[0];
+  if (!run) return null;
+
+  let artifactNames: string[] | undefined;
+  let selectedIds: number[] | null = null;
+  if (selection.artifact !== undefined) {
+    const inventory = (await sql`
+      select id,
+        case when count(*) over (partition by artifact_name) > 1
+          then artifact_name || '/' || file_name else artifact_name end as name
+      from gpu_metric_series
+      where workflow_run_id = ${Number(run.id)}
+      order by artifact_name, file_name
+    `) as { id: number | string; name: string }[];
+    if (inventory.length === 0) return null;
+    artifactNames = inventory.map((entry) => entry.name);
+    const selected = selection.artifact ?? artifactNames[0];
+    selectedIds = inventory
+      .filter((entry) => entry.name === selected)
+      .map((entry) => Number(entry.id));
+  }
+  const prefix = selection.prefix ?? null;
+  const sources = selection.sourceResults ?? null;
+
+  const seriesRows = (await sql`
+    select s.id, s.workflow_run_id, s.artifact_name, s.config_key, s.file_name, s.vendor,
+      s.sample_interval_s, s.sample_count, s.gpu_count, s.started_at, s.ended_at, s.sidecars,
+      s.csv_sha256, s.ingested_at,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0) as stats_version,
+      (
+        select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
+        from benchmark_result_gpu_metrics l where l.series_id = s.id
+      ) as benchmark_result_ids,
+      (
+        select jsonb_agg(br.power_audit order by br.id)
+        from benchmark_result_gpu_metrics l
+        join benchmark_results br on br.id = l.benchmark_result_id
+        where l.series_id = s.id and br.power_audit is not null
+      ) as power_audits
+    from gpu_metric_series s
+    where s.workflow_run_id = ${Number(run.id)}
+      and (${selectedIds}::bigint[] is null or s.id = any(${selectedIds}::bigint[]))
+      and (${prefix}::text is null or starts_with(s.artifact_name, 'gpu_metrics_' || ${prefix})
+        or (starts_with(s.artifact_name, 'power_audit_') and
+          (starts_with(s.artifact_name, 'power_audit_' || ${prefix})
+            or starts_with('power_audit_' || ${prefix}, s.artifact_name))))
+      and (${sources}::text[] is null or exists (
+        select 1 from unnest(${sources}::text[]) as requested(result)
+        where s.artifact_name = 'gpu_metrics_' || requested.result
+          or (starts_with(s.artifact_name, 'power_audit_') and
+            (starts_with(s.artifact_name, 'power_audit_' || requested.result)
+              or starts_with('power_audit_' || requested.result, s.artifact_name)))
+      ))
+    order by s.artifact_name, s.file_name
+  `) as unknown as RawSeriesRow[];
+  if (seriesRows.length === 0 && artifactNames === undefined) return null;
+
+  return {
+    workflowRun: {
+      id: Number(run.id),
+      githubRunId: Number(run.github_run_id),
+      runAttempt: Number(run.run_attempt),
+      name: run.name,
+      date: isoString(run.date).slice(0, 10),
+      htmlUrl: run.html_url,
+      headBranch: run.head_branch,
+      headSha: run.head_sha,
+      conclusion: run.conclusion,
+      status: run.status,
+      createdAt: run.created_at ? isoString(run.created_at) : null,
+    },
+    series: await loadSeriesDetails(sql, seriesRows),
+    ...(artifactNames === undefined ? {} : { artifactNames }),
+  };
+}
+
+export interface GpuMetricsPointPayload {
+  benchmarkResultId: number;
+  series: GpuMetricSeries[];
+}
+
+/** Series linked to one benchmark point, with samples. Null when none is linked. */
+export function getGpuMetricsForPoint(
+  sql: DbClient,
+  benchmarkResultId: number,
+): Promise<GpuMetricsPointPayload | null> {
+  return withConsistentSnapshot(() => readGpuMetricsForPoint(sql, benchmarkResultId));
+}
+
+async function readGpuMetricsForPoint(
+  sql: DbClient,
+  benchmarkResultId: number,
+): Promise<GpuMetricsPointPayload | null> {
+  const seriesRows = (await sql`
+    select s.id, s.workflow_run_id, s.artifact_name, s.config_key, s.file_name, s.vendor,
+      s.sample_interval_s, s.sample_count, s.gpu_count, s.started_at, s.ended_at, s.sidecars,
+      s.csv_sha256, s.ingested_at,
+      coalesce((to_jsonb(s)->>'stats_version')::integer, 0) as stats_version,
+      (
+        select array_agg(l.benchmark_result_id order by l.benchmark_result_id)
+        from benchmark_result_gpu_metrics l where l.series_id = s.id
+      ) as benchmark_result_ids,
+      (
+        select jsonb_agg(br.power_audit order by br.id)
+        from benchmark_result_gpu_metrics l
+        join benchmark_results br on br.id = l.benchmark_result_id
+        where l.series_id = s.id and br.power_audit is not null
+      ) as power_audits
+    from benchmark_result_gpu_metrics link
+    join gpu_metric_series s on s.id = link.series_id
+    where link.benchmark_result_id = ${benchmarkResultId}
+    order by s.artifact_name, s.file_name
+  `) as unknown as RawSeriesRow[];
+  if (seriesRows.length === 0) return null;
+  return {
+    benchmarkResultId,
+    series: await loadSeriesDetails(sql, seriesRows),
+  };
+}

From 039deba36a32013a8908ad7bfd2a3503e2290ec5 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 094/103] ci: migrate before ingest and support Neon branch
 targets
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Run admin:db:migrate before ingest and overrides so writers never meet a missing
column; let agentic ingest target a Neon branch; only invalidate the cache after
overrides actually applied.

中文：ingest 与 overrides 前先执行 admin:db:migrate，避免写入端遇到缺列；agentic ingest 可指向 Neon 分支；仅在 overrides 实际生效后失效缓存。
---
 .github/workflows/apply-run-overrides.yml    | 16 ++++++++++++++++
 .github/workflows/ingest-agentic-results.yml | 12 ++++++++++++
 .github/workflows/ingest-results.yml         |  2 ++
 3 files changed, 30 insertions(+)

diff --git a/.github/workflows/apply-run-overrides.yml b/.github/workflows/apply-run-overrides.yml
index 749880e80..819f09aca 100644
--- a/.github/workflows/apply-run-overrides.yml
+++ b/.github/workflows/apply-run-overrides.yml
@@ -53,7 +53,18 @@ jobs:
         env:
           CYPRESS_INSTALL_BINARY: '0'
 
+      # This workflow fires on a push to run-overrides.ts, which can land before the
+      # next ingest dispatch has applied a pending migration. admin:db:verify counts
+      # every table it knows about, so without this step it fails on a schema the
+      # checked-out ref expects but production does not have yet. Same command and
+      # ordering as ingest-results.yml; migrations are idempotent by filename.
+      - name: Run migrations
+        env:
+          DATABASE_WRITE_URL: ${{ secrets.DATABASE_WRITE_URL }}
+        run: bun run admin:db:migrate --yes
+
       - name: Apply run overrides
+        id: apply
         env:
           DATABASE_WRITE_URL: ${{ secrets.DATABASE_WRITE_URL }}
           RUN_ID: ${{ inputs.run_id }}
@@ -69,10 +80,15 @@ jobs:
           DATABASE_WRITE_URL: ${{ secrets.DATABASE_WRITE_URL }}
         run: bun run admin:db:verify
 
+      # Once the overrides are in the database the CDN is stale, so these must run
+      # even if the verify step above fails. Skipping them leaves the dashboard
+      # serving pre-override data with only a red workflow as the signal.
       - name: Invalidate production cache
+        if: ${{ always() && steps.apply.outcome == 'success' }}
         env:
           INVALIDATE_SECRET: ${{ secrets.VERCEL_INVALIDATE_SECRET }}
         run: bun run admin:cache:invalidate https://inferencex.semianalysis.com
 
       - name: Warm production cache
+        if: ${{ always() && steps.apply.outcome == 'success' }}
         run: bun run admin:cache:warmup https://inferencex.semianalysis.com
diff --git a/.github/workflows/ingest-agentic-results.yml b/.github/workflows/ingest-agentic-results.yml
index b81cd68b0..3dcd23773 100644
--- a/.github/workflows/ingest-agentic-results.yml
+++ b/.github/workflows/ingest-agentic-results.yml
@@ -31,6 +31,11 @@ on:
         description: InferenceX Actions run ID to ingest
         required: true
         type: string
+      require-power:
+        description: Require the versioned PowerX manifest and all declared evidence
+        required: false
+        default: false
+        type: boolean
       run-attempt:
         description: InferenceX Actions run attempt to ingest
         required: false
@@ -85,6 +90,11 @@ on:
         description: InferenceX Actions run ID to ingest
         required: true
         type: string
+      require-power:
+        description: Require the versioned PowerX manifest and all declared evidence
+        required: false
+        default: false
+        type: boolean
       run-attempt:
         description: InferenceX Actions run attempt to ingest
         required: false
@@ -276,6 +286,7 @@ jobs:
             github.event.client_payload.run-id || inputs.run-id }}
           ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true || inputs.require-power == true }}
         run: bun run admin:db:prepare:ci
 
       - name: Run migrations
@@ -288,6 +299,7 @@ jobs:
           INGEST_RUN_ATTEMPT: ${{ steps.artifacts.outputs.merge-run-attempt }}
           INGEST_ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true || inputs.require-power == true }}
           UNMAPPED_ENTITIES_OUTPUT: ${{ github.workspace }}/unmapped-entities.json
           POWER_PUBLICATION_MANIFEST: ${{ github.workspace }}/power-publication.json
         run: bun run admin:db:ingest:ci
diff --git a/.github/workflows/ingest-results.yml b/.github/workflows/ingest-results.yml
index 04b253e34..d66e50a8f 100644
--- a/.github/workflows/ingest-results.yml
+++ b/.github/workflows/ingest-results.yml
@@ -60,6 +60,7 @@ jobs:
             github.event.client_payload.run-id }}
           ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true }}
         run: bun run admin:db:prepare:ci
 
       - name: Run migrations
@@ -75,6 +76,7 @@ jobs:
           INGEST_RUN_ATTEMPT: ${{ steps.artifacts.outputs.merge-run-attempt }}
           INGEST_ARTIFACTS_PATH: ${{ github.workspace }}/artifacts
           INGEST_REPO: SemiAnalysisAI/InferenceX
+          INGEST_REQUIRE_POWER: ${{ github.event.client_payload.require-power == true }}
           POWER_PUBLICATION_MANIFEST: ${{ github.workspace }}/power-publication.json
           UNMAPPED_ENTITIES_OUTPUT: ${{ github.workspace }}/unmapped-entities.json
         run: bun run admin:db:ingest:ci

From 41ec32d8dd4f270ac7259a6549b35fb5847046b5 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 095/103] feat(api): DB-first gpu-metrics routes, point cache
 and views parity
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Serve /api/gpu-metrics from the database first and fall back to live GitHub artifacts
only when a run is not ingested; add /api/v1/gpu-metrics-point behind a revision-keyed
Blob cache; keep the public views route shape identical for stored and live runs and
normalize live NVIDIA timestamps to ISO UTC.

中文：/api/gpu-metrics 优先读数据库，仅在 run 未入库时回退到 GitHub artifact；新增以 revision 为键的 Blob 缓存 /api/v1/gpu-metrics-point；公开 views 路由对入库与 live run 保持同一形状，live NVIDIA 时间戳归一为 ISO UTC。
---
 packages/app/scripts/powerx-blob-fixture.ts   |  76 +++
 .../app/api/gpu-metrics/route.context.test.ts | 109 +++
 .../app/api/gpu-metrics/route.sources.test.ts | 120 ++++
 .../app/src/app/api/gpu-metrics/route.test.ts | 343 +++++++++-
 packages/app/src/app/api/gpu-metrics/route.ts | 625 +++++++++++++++++-
 .../api/v1/gpu-metrics-point/route.test.ts    | 264 ++++++++
 .../src/app/api/v1/gpu-metrics-point/route.ts |  46 ++
 .../src/app/api/v1/views/extensions.test.ts   |   2 +-
 .../api/v1/views/gpu-metrics/route.test.ts    | 101 +++
 .../src/app/api/v1/views/gpu-metrics/route.ts |  33 +-
 .../gpu-power/power-audit-bundle.test.ts      | 164 +++++
 .../gpu-power/power-audit-bundle.ts           | 373 +++++++++++
 .../components/gpu-power/power-series.test.ts | 103 +++
 .../src/components/gpu-power/power-series.ts  | 212 ++++++
 .../gpu-power/stored-gpu-stats.test.ts        | 128 ++++
 .../components/gpu-power/stored-gpu-stats.ts  |  30 +
 .../gpu-power/stored-power-series.ts          | 168 +++++
 .../app/src/hooks/api/benchmark-id-query.ts   |   2 +
 .../src/hooks/api/use-gpu-metrics-point.ts    |  24 +
 packages/app/src/lib/api-route-catalog.ts     |  64 +-
 packages/app/src/lib/github-artifacts.test.ts |   6 +-
 packages/app/src/lib/github-artifacts.ts      |  20 +-
 .../app/src/lib/views-api/docs/extensions.ts  |  24 +-
 .../skills/inferencex-api/integrity.json      |   2 +-
 .../references/dashboard-views.md             |  13 +-
 25 files changed, 2957 insertions(+), 95 deletions(-)
 create mode 100644 packages/app/scripts/powerx-blob-fixture.ts
 create mode 100644 packages/app/src/app/api/gpu-metrics/route.context.test.ts
 create mode 100644 packages/app/src/app/api/gpu-metrics/route.sources.test.ts
 create mode 100644 packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
 create mode 100644 packages/app/src/app/api/v1/gpu-metrics-point/route.ts
 create mode 100644 packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
 create mode 100644 packages/app/src/components/gpu-power/power-audit-bundle.test.ts
 create mode 100644 packages/app/src/components/gpu-power/power-audit-bundle.ts
 create mode 100644 packages/app/src/components/gpu-power/power-series.test.ts
 create mode 100644 packages/app/src/components/gpu-power/power-series.ts
 create mode 100644 packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
 create mode 100644 packages/app/src/components/gpu-power/stored-gpu-stats.ts
 create mode 100644 packages/app/src/components/gpu-power/stored-power-series.ts
 create mode 100644 packages/app/src/hooks/api/use-gpu-metrics-point.ts

diff --git a/packages/app/scripts/powerx-blob-fixture.ts b/packages/app/scripts/powerx-blob-fixture.ts
new file mode 100644
index 000000000..ea283fc10
--- /dev/null
+++ b/packages/app/scripts/powerx-blob-fixture.ts
@@ -0,0 +1,76 @@
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+
+/** Local HTTP transport for the real Blob SDK; never contacts a Blob store. */
+export async function startPowerxBlobFixture(port = 0) {
+  const objects = new Map<string, string>();
+  const counts = { reads: 0, writes: 0, failedWrites: 0 };
+  let rejectWrites = false;
+  const server = createServer(async (request, response) => {
+    const url = new URL(request.url!, 'http://localhost');
+    const pathname = url.searchParams.get('pathname') ?? url.searchParams.get('url');
+    response.setHeader('content-type', 'application/json');
+    const fail = (status: number, code: string) => {
+      response.writeHead(status);
+      response.end(JSON.stringify({ error: { code, message: code } }));
+    };
+    if (url.pathname === '/body') {
+      counts.reads++;
+      const body = objects.get(pathname!);
+      if (body === undefined) return fail(404, 'not_found');
+      response.end(body);
+      return;
+    }
+    if (!pathname) return fail(400, 'bad_request');
+    if (request.method === 'PUT') {
+      counts.writes++;
+      if (rejectWrites) {
+        counts.failedWrites++;
+        request.resume();
+        return fail(403, 'forbidden');
+      }
+      const chunks: Buffer[] = [];
+      for await (const chunk of request) chunks.push(Buffer.from(chunk));
+      objects.set(pathname, Buffer.concat(chunks).toString());
+    }
+    if (!objects.has(pathname)) return fail(404, 'not_found');
+    const address = server.address() as AddressInfo;
+    const bodyUrl = `http://127.0.0.1:${address.port}/body?url=${encodeURIComponent(pathname)}`;
+    response.end(
+      JSON.stringify({
+        url: bodyUrl,
+        downloadUrl: bodyUrl,
+        pathname,
+        size: Buffer.byteLength(objects.get(pathname)!),
+        contentType: 'application/json',
+        uploadedAt: new Date().toISOString(),
+        etag: 'local-fixture',
+      }),
+    );
+  });
+  await new Promise<void>((resolve) => {
+    server.listen(port, '127.0.0.1', resolve);
+  });
+  const address = server.address() as AddressInfo;
+  return {
+    env: {
+      VERCEL_BLOB_API_URL: `http://127.0.0.1:${address.port}`,
+      BLOB_READ_WRITE_TOKEN: 'vercel_blob_rw_local_fixture',
+      BLOB_CACHE_PREFIX: 'powerx-local-acceptance',
+    },
+    objects,
+    counts,
+    rejectWrites: (value: boolean) => {
+      rejectWrites = value;
+    },
+    close: () =>
+      new Promise<void>((resolve, reject) => {
+        server.closeAllConnections();
+        server.close((error) =>
+          error && (error as NodeJS.ErrnoException).code !== 'ERR_SERVER_NOT_RUNNING'
+            ? reject(error)
+            : resolve(),
+        );
+      }),
+  };
+}
diff --git a/packages/app/src/app/api/gpu-metrics/route.context.test.ts b/packages/app/src/app/api/gpu-metrics/route.context.test.ts
new file mode 100644
index 000000000..1e2b58eeb
--- /dev/null
+++ b/packages/app/src/app/api/gpu-metrics/route.context.test.ts
@@ -0,0 +1,109 @@
+import AdmZip from 'adm-zip';
+import { NextRequest } from 'next/server';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { readStored } = vi.hoisted(() => ({ readStored: vi.fn() }));
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({ getDb: () => ({}) }));
+vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
+  getGpuMetricsForRun: readStored,
+}));
+
+import { GET } from './route';
+
+const HEADER =
+  'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
+const CSV = `${HEADER}\n2026/09/21 00:00:00.000, 0, 100 W, 40, 1500, 2000, 90, 80\n2026/09/21 00:00:01.000, 0, 200 W, 41, 1500, 2000, 90, 80\n`;
+
+beforeEach(() => {
+  readStored.mockReset().mockResolvedValue(null);
+  vi.stubEnv('GITHUB_TOKEN', 'controlled-not-a-real-token');
+  vi.stubEnv('DATABASE_READONLY_URL', 'postgresql://controlled.invalid/never-contacted');
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.unstubAllEnvs();
+});
+
+function liveArtifact(files: Record<string, string>) {
+  const zip = new AdmZip();
+  for (const [entry, contents] of Object.entries(files)) zip.addFile(entry, Buffer.from(contents));
+  const bytes = zip.toBuffer();
+  vi.stubGlobal(
+    'fetch',
+    vi.fn((input: unknown) => {
+      const url = String(input);
+      if (url.includes('/artifacts?')) {
+        return Promise.resolve(
+          Response.json({
+            artifacts: [
+              {
+                id: 2,
+                name: 'gpu_metrics_probe_live',
+                archive_download_url: 'https://example.test/dl/live',
+              },
+            ],
+          }),
+        );
+      }
+      if (url === 'https://example.test/dl/live') {
+        return Promise.resolve(
+          new Response(new Uint8Array(bytes), {
+            headers: { 'Content-Length': String(bytes.length) },
+          }),
+        );
+      }
+      if (url.endsWith('/actions/runs/12345')) {
+        return Promise.resolve(
+          Response.json({
+            id: 12345,
+            name: 'Controlled context fixture',
+            head_branch: 'test',
+            head_sha: 'fixture',
+            created_at: '2026-09-21T00:00:00Z',
+            html_url: 'https://example.test/runs/12345',
+            conclusion: 'success',
+            status: 'completed',
+          }),
+        );
+      }
+      throw new Error(`Unexpected network request: ${url}`);
+    }),
+  );
+}
+
+async function readRoute() {
+  const response = await GET(new NextRequest('http://localhost/api/gpu-metrics?runId=12345'));
+  expect(response.status).toBe(200);
+  return response.json();
+}
+
+describe('GET /api/gpu-metrics collector context', () => {
+  it('uses each host directory context and skips malformed neighboring context files', async () => {
+    liveArtifact({
+      'gpu_metrics_context.json': '{"timestamp_timezone":"+12:00"}',
+      'host-a/gpu_metrics.csv': CSV,
+      'host-a/gpu_metrics_bad_context.json': '{bad json',
+      'host-a/gpu_metrics_context.json': '{"timestamp_timezone":"-07:00"}',
+      'host-b/gpu_metrics.csv': CSV,
+      'host-b/gpu_metrics_context.json': '{"timestamp_timezone":"+05:30"}',
+    });
+    const raw = await readRoute();
+    expect(raw.artifacts).toMatchObject([
+      {
+        name: 'gpu_metrics_probe_live/host-a/gpu_metrics.csv',
+        data: [
+          { timestamp: '2026-09-21T07:00:00.000Z' },
+          { timestamp: '2026-09-21T07:00:01.000Z' },
+        ],
+      },
+      {
+        name: 'gpu_metrics_probe_live/host-b/gpu_metrics.csv',
+        data: [
+          { timestamp: '2026-09-20T18:30:00.000Z' },
+          { timestamp: '2026-09-20T18:30:01.000Z' },
+        ],
+      },
+    ]);
+  });
+});
diff --git a/packages/app/src/app/api/gpu-metrics/route.sources.test.ts b/packages/app/src/app/api/gpu-metrics/route.sources.test.ts
new file mode 100644
index 000000000..afe830736
--- /dev/null
+++ b/packages/app/src/app/api/gpu-metrics/route.sources.test.ts
@@ -0,0 +1,120 @@
+import { NextRequest } from 'next/server';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+import { parseCsvData } from '@/components/gpu-power/types';
+
+const { readRun } = vi.hoisted(() => ({ readRun: vi.fn() }));
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({
+  getDb: () => ({}),
+}));
+vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
+  getGpuMetricsForRun: readRun,
+}));
+
+import { POST } from './route';
+
+const RUN_ID = '12345';
+const RUN_URL = `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${RUN_ID}`;
+const NAME_A = 'dsr1_conc32_b200';
+const NAME_B = 'dsr1_conc64_b200';
+const source = (name: string) => `power_validation_${name}.json`;
+const csvName = (name: string) => `gpu_metrics_${name}`;
+const SOURCE_A = source(NAME_A);
+const SOURCE_B = source(NAME_B);
+const START = Date.parse('2026-03-01T00:00:00Z') / 1000;
+const workflowRun = {
+  id: 1,
+  githubRunId: Number(RUN_ID),
+  runAttempt: 1,
+  name: 'Run Sweep',
+  date: '2026-03-01',
+  htmlUrl: RUN_URL,
+  headBranch: 'main',
+  headSha: 'abc123',
+  conclusion: 'success',
+  status: 'completed',
+  createdAt: '2026-03-01T00:00:00Z',
+};
+
+function csv(power: number): string {
+  return [
+    'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+    `2026/03/01 00:00:00.000, 0, ${power} W, 65, 1500 MHz, 2000 MHz, 95 %, 80 %`,
+    `2026/03/01 00:00:01.000, 0, ${power + 10} W, 65, 1500 MHz, 2000 MHz, 95 %, 80 %`,
+  ].join('\n');
+}
+
+function stored(name: string, power = 100): GpuMetricSeries {
+  return {
+    id: 1,
+    artifactName: csvName(name),
+    configKey: name,
+    fileName: 'gpu_metrics.csv',
+    vendor: 'nvidia',
+    sampleIntervalS: 1,
+    sampleCount: 2,
+    gpuCount: 1,
+    startedAt: '2026-03-01T00:00:00Z',
+    endedAt: '2026-03-01T00:00:01Z',
+    sidecars: {
+      seriesInventory: [{ fileName: 'gpu_metrics.csv', sampleCount: 2 }],
+    },
+    benchmarkResultIds: [1],
+    stats: [],
+    data: parseCsvData(csv(power)).map((row, index) => ({
+      ...row,
+      timestamp: new Date((START + index) * 1000).toISOString(),
+    })),
+  };
+}
+
+function request(body: unknown, prefix = 'dsr1_', raw = false): NextRequest {
+  const params = new URLSearchParams({
+    runId: RUN_ID,
+    series: 'power',
+    prefix,
+  });
+  return new NextRequest(`http://localhost/api/gpu-metrics?${params}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: raw ? String(body) : JSON.stringify(body),
+  });
+}
+
+beforeEach(() => {
+  readRun.mockReset().mockResolvedValue({ workflowRun, series: [stored(NAME_A)] });
+  vi.stubEnv('DATABASE_READONLY_URL', 'postgresql://readonly.example.test/test');
+  vi.stubEnv('GITHUB_TOKEN', 'test-token');
+  vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Unexpected GitHub request')));
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
+});
+
+describe('Timeline requested-source coverage', () => {
+  it('keeps known missing hosts as 503 even when another requested series is healthy', async () => {
+    const partial = stored(NAME_B, 300);
+    partial.sidecars.seriesInventory = [
+      { fileName: 'gpu_metrics.csv', sampleCount: 2 },
+      { fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
+    ];
+    readRun.mockResolvedValue({
+      workflowRun,
+      series: [stored(NAME_A), partial],
+    });
+    vi.stubEnv('GITHUB_TOKEN', '');
+    const response = await POST(request({ sources: [SOURCE_A, SOURCE_B] }));
+    expect(readRun).toHaveBeenCalledWith({}, Number(RUN_ID), {
+      prefix: 'dsr1_',
+      sourceResults: [NAME_A, NAME_B],
+    });
+    expect(response.status).toBe(503);
+    expect(await response.json()).toMatchObject({
+      code: 'STORED_TELEMETRY_INCOMPLETE',
+      artifact: csvName(NAME_B),
+    });
+  });
+});
diff --git a/packages/app/src/app/api/gpu-metrics/route.test.ts b/packages/app/src/app/api/gpu-metrics/route.test.ts
index c34a2147f..2b1dd8f15 100644
--- a/packages/app/src/app/api/gpu-metrics/route.test.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.test.ts
@@ -1,22 +1,37 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import type * as GpuPowerTypes from '@/components/gpu-power/types';
 
-const { mockParseCsvData } = vi.hoisted(() => ({
-  mockParseCsvData: vi.fn((csv: string) => {
-    if (csv.trim().length === 0) return [];
-    return [
-      {
-        timestamp: '2026-03-01T00:00:00Z',
-        index: 0,
-        power: 300,
-        temperature: 65,
-        smClock: 1500,
-        memClock: 2000,
-        gpuUtil: 95,
-        memUtil: 80,
-      },
-    ];
-  }),
-}));
+const { mockParseCsvData, zipArchives } = vi.hoisted(() => {
+  interface ZipEntry {
+    entryName: string;
+    data: string;
+  }
+  const csvArchive: ZipEntry[] = [
+    { entryName: 'gpu_metrics_0.csv', data: 'timestamp,index,power\n2026-03-01T00:00:00Z,0,300' },
+  ];
+  return {
+    mockParseCsvData: vi.fn((csv: string): GpuPowerTypes.GpuMetricRow[] => {
+      if (csv.trim().length === 0) return [];
+      return [
+        {
+          timestamp: '2026-03-01T00:00:00Z',
+          index: 0,
+          power: 300,
+          temperature: 65,
+          smClock: 1500,
+          memClock: 2000,
+          gpuUtil: 95,
+          memUtil: 80,
+        },
+      ];
+    }),
+    /**
+     * Entries the adm-zip mock serves, keyed by the downloaded buffer's text.
+     * An empty download (the default in older tests) is the one-CSV artifact.
+     */
+    zipArchives: { byKey: new Map<string, ZipEntry[]>(), csvArchive },
+  };
+});
 
 vi.mock('@semianalysisai/inferencex-constants', () => ({
   GITHUB_API_BASE: 'https://api.github.com',
@@ -28,36 +43,60 @@ vi.mock('@/components/gpu-power/types', () => ({
   parseCsvData: mockParseCsvData,
 }));
 
+const { mockGetGpuMetricsForRun } = vi.hoisted(() => ({
+  mockGetGpuMetricsForRun: vi.fn(),
+}));
+
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({
+  getDb: () => ({}),
+}));
+
+vi.mock('@semianalysisai/inferencex-db/queries/gpu-metrics', () => ({
+  getGpuMetricsForRun: mockGetGpuMetricsForRun,
+}));
+
 vi.mock('adm-zip', () => {
-  const csvContent = 'timestamp,index,power\n2026-03-01T00:00:00Z,0,300';
   class MockAdmZip {
+    private readonly key: string;
+    constructor(buffer: Buffer) {
+      this.key = buffer.toString('utf8');
+    }
     getEntries() {
-      return [
-        {
-          entryName: 'gpu_metrics_0.csv',
-          isDirectory: false,
-          getData: () => Buffer.from(csvContent),
-        },
-      ];
+      const entries = zipArchives.byKey.get(this.key) ?? zipArchives.csvArchive;
+      return entries.map((entry) => ({
+        entryName: entry.entryName,
+        isDirectory: false,
+        getData: () => Buffer.from(entry.data),
+      }));
     }
   }
   return { default: MockAdmZip };
 });
 
-import { GET } from './route';
+import { databasePayloadToResponse, GET, readGpuMetricsForView } from './route';
 import { NextRequest } from 'next/server';
 
 const originalFetch = globalThis.fetch;
 let origToken: string | undefined;
+let origReadonlyUrl: string | undefined;
 
 function req(url: string): NextRequest {
   return new NextRequest(new URL(url, 'http://localhost'));
 }
 
+function nvidiaRow(second: number, power: number): string {
+  return `2026/03/01 00:00:0${second}.000, 0, ${power} W, 65, 1500 MHz, 2000 MHz, 95 %, 80 %`;
+}
+
 beforeEach(() => {
   vi.clearAllMocks();
+  zipArchives.byKey.clear();
   origToken = process.env.GITHUB_TOKEN;
+  origReadonlyUrl = process.env.DATABASE_READONLY_URL;
   process.env.GITHUB_TOKEN = 'test-gh-token';
+  // No readonly URL: the GitHub fallback is exercised unless a test opts in.
+  delete process.env.DATABASE_READONLY_URL;
+  mockGetGpuMetricsForRun.mockResolvedValue(null);
 });
 
 afterEach(() => {
@@ -67,6 +106,258 @@ afterEach(() => {
   } else {
     process.env.GITHUB_TOKEN = origToken;
   }
+  if (origReadonlyUrl === undefined) {
+    delete process.env.DATABASE_READONLY_URL;
+  } else {
+    process.env.DATABASE_READONLY_URL = origReadonlyUrl;
+  }
+});
+
+const storedRunPayload = {
+  workflowRun: {
+    id: 7,
+    githubRunId: 34557177019,
+    runAttempt: 1,
+    name: 'Run Sweep - dsr1 fp4 b200',
+    date: '2026-09-11',
+    htmlUrl: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34557177019',
+    headBranch: 'main',
+    headSha: 'deadbeef',
+    conclusion: 'success',
+    status: 'completed',
+    createdAt: '2026-09-11T04:00:00.000Z',
+  },
+  series: [
+    {
+      id: 1,
+      artifactName: 'gpu_metrics_dsr1_conc32_b200-x_0',
+      configKey: 'dsr1_conc32_b200-x_0',
+      fileName: 'gpu_metrics.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 2,
+      gpuCount: 1,
+      startedAt: '2026-09-11T04:19:41.982Z',
+      endedAt: '2026-09-11T04:19:42.990Z',
+      sidecars: {},
+      benchmarkResultIds: [10],
+      stats: [],
+      data: [
+        {
+          timestamp: '2026-09-11T04:19:41.982Z',
+          index: 0,
+          power: 187.8,
+          temperature: 33,
+          smClock: 120,
+          memClock: 3996,
+          gpuUtil: 0,
+          memUtil: 0,
+        },
+        {
+          timestamp: '2026-09-11T04:19:42.990Z',
+          index: 0,
+          power: 912.1,
+          temperature: 61,
+          smClock: 1965,
+          memClock: 3996,
+          gpuUtil: 98,
+          memUtil: 74,
+        },
+      ],
+    },
+    {
+      id: 2,
+      artifactName: 'gpu_metrics_multinode_b200-x_0',
+      configKey: 'multinode_b200-x_0',
+      fileName: 'results/gpu_metrics_rank0.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 0,
+      gpuCount: 0,
+      startedAt: '2026-09-11T04:19:41.982Z',
+      endedAt: '2026-09-11T04:19:41.982Z',
+      sidecars: {},
+      benchmarkResultIds: [11],
+      stats: [],
+      data: [],
+    },
+    {
+      id: 3,
+      artifactName: 'gpu_metrics_multinode_b200-x_0',
+      configKey: 'multinode_b200-x_0',
+      fileName: 'results/gpu_metrics_rank1.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 0,
+      gpuCount: 0,
+      startedAt: '2026-09-11T04:19:41.982Z',
+      endedAt: '2026-09-11T04:19:41.982Z',
+      sidecars: {},
+      benchmarkResultIds: [11],
+      stats: [],
+      data: [],
+    },
+  ],
+};
+
+describe('databasePayloadToResponse', () => {
+  it('shapes the stored digest like the GitHub payload and disambiguates multinode CSVs', () => {
+    const response = databasePayloadToResponse(storedRunPayload);
+    expect(response.source).toBe('database');
+    expect(response.runInfo).toEqual({
+      id: 34557177019,
+      name: 'Run Sweep - dsr1 fp4 b200',
+      branch: 'main',
+      sha: 'deadbeef',
+      createdAt: '2026-09-11T04:00:00.000Z',
+      url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34557177019',
+      conclusion: 'success',
+      status: 'completed',
+    });
+    expect(response.artifacts.map((artifact) => artifact.name)).toEqual([
+      'gpu_metrics_dsr1_conc32_b200-x_0',
+      'gpu_metrics_multinode_b200-x_0/results/gpu_metrics_rank0.csv',
+      'gpu_metrics_multinode_b200-x_0/results/gpu_metrics_rank1.csv',
+    ]);
+    expect(response.artifacts[0]!.data).toHaveLength(2);
+    expect(response.artifacts[0]!.series?.benchmarkResultIds).toEqual([10]);
+    expect(response.artifacts[0]!.series).not.toHaveProperty('data');
+  });
+});
+
+describe('GET /api/gpu-metrics — database first', () => {
+  it('serves the stored digest without touching GitHub when the run is ingested', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    mockGetGpuMetricsForRun.mockResolvedValueOnce(storedRunPayload);
+    globalThis.fetch = vi.fn();
+
+    const res = await GET(req('/api/gpu-metrics?runId=34557177019'));
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.source).toBe('database');
+    expect(body.artifacts).toHaveLength(3);
+    expect(mockGetGpuMetricsForRun).toHaveBeenCalledWith({}, 34557177019, {
+      prefix: null,
+      sourceResults: null,
+    });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('passes selectors to the reader and preserves exact host labels for a scoped view', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    const names = databasePayloadToResponse(storedRunPayload).artifacts.map((entry) => entry.name);
+    mockGetGpuMetricsForRun.mockResolvedValueOnce({
+      ...storedRunPayload,
+      artifactNames: names,
+      series: [storedRunPayload.series[2]],
+    });
+    globalThis.fetch = vi.fn();
+    const response = await readGpuMetricsForView(
+      req('/api/gpu-metrics?runId=34557177019'),
+      names[2]!,
+    );
+    expect(await response.json()).toMatchObject({
+      artifactNames: names,
+      artifacts: [{ name: names[2] }],
+    });
+    expect(mockGetGpuMetricsForRun).toHaveBeenCalledWith({}, 34557177019, {
+      prefix: null,
+      sourceResults: null,
+      artifact: names[2],
+    });
+    mockGetGpuMetricsForRun.mockResolvedValueOnce({
+      ...storedRunPayload,
+      artifactNames: names,
+      series: [],
+    });
+    const missing = await readGpuMetricsForView(
+      req('/api/gpu-metrics?runId=34557177019'),
+      'missing',
+    );
+    expect(await missing.json()).toMatchObject({ artifactNames: names, artifacts: [] });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('reports a database failure separately instead of treating it as missing data', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    mockGetGpuMetricsForRun.mockRejectedValueOnce(new Error('relation does not exist'));
+    globalThis.fetch = vi.fn().mockResolvedValueOnce({ ok: false, status: 404 });
+
+    const res = await GET(req('/api/gpu-metrics?runId=99'));
+    expect(res.status).toBe(503);
+    expect(await res.json()).toMatchObject({ code: 'DATABASE_UNAVAILABLE' });
+    expect(globalThis.fetch).not.toHaveBeenCalled();
+  });
+
+  it('checks retained file/sample coverage before using a truncated host CSV fallback', async () => {
+    process.env.DATABASE_READONLY_URL = 'postgresql://readonly.example.test/db';
+    const { parseCsvData } = await vi.importActual<typeof GpuPowerTypes>(
+      '@/components/gpu-power/types',
+    );
+    const header =
+      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]';
+    const hostA = [header, nvidiaRow(0, 300), nvidiaRow(0, 999), nvidiaRow(1, 310)].join('\n');
+    // host-b lost its GPU 1 row: one of the two retained samples.
+    const hostB = [header, nvidiaRow(0, 500)].join('\n');
+    zipArchives.byKey.set('coverage', [
+      { entryName: 'host-a/gpu_metrics.csv', data: hostA },
+      { entryName: 'host-b/gpu_metrics.csv', data: hostB },
+    ]);
+    mockParseCsvData.mockImplementationOnce(parseCsvData).mockImplementationOnce(parseCsvData);
+    mockGetGpuMetricsForRun.mockResolvedValueOnce({
+      ...storedRunPayload,
+      series: [
+        {
+          ...storedRunPayload.series[0],
+          artifactName: 'gpu_metrics_live',
+          fileName: 'host-a/gpu_metrics.csv',
+          sidecars: {
+            seriesInventory: [
+              { fileName: 'host-a/gpu_metrics.csv', sampleCount: 2 },
+              { fileName: 'host-b/gpu_metrics.csv', sampleCount: 2 },
+            ],
+          },
+        },
+      ],
+    });
+    globalThis.fetch = vi
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            id: 34557177019,
+            name: 'Sweep',
+            head_branch: 'main',
+            head_sha: 'abc',
+            created_at: '2026-03-01T00:00:00Z',
+            html_url: 'https://example.test/run',
+            status: 'completed',
+            conclusion: 'success',
+          }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            artifacts: [
+              { id: 1, name: 'gpu_metrics_live', archive_download_url: 'https://example.test/zip' },
+            ],
+          }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        arrayBuffer: () => Promise.resolve(new TextEncoder().encode('coverage').buffer),
+      });
+    const res = await GET(req('/api/gpu-metrics?runId=34557177019&series=power'));
+    expect(res.status).toBe(503);
+    expect(await res.json()).toMatchObject({
+      code: 'STORED_TELEMETRY_INCOMPLETE',
+      artifact: 'gpu_metrics_live',
+    });
+    expect(globalThis.fetch).toHaveBeenCalledTimes(3);
+  });
 });
 
 describe('GET /api/gpu-metrics', () => {
diff --git a/packages/app/src/app/api/gpu-metrics/route.ts b/packages/app/src/app/api/gpu-metrics/route.ts
index 59a607f35..b9f351d66 100644
--- a/packages/app/src/app/api/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/gpu-metrics/route.ts
@@ -1,10 +1,70 @@
 /**
- * DO NOT ADD CACHING (blob, CDN, or unstable_cache) to this route.
- * It fetches live GitHub Actions artifacts which change while a run is in progress.
+ * PowerX telemetry for one GitHub Actions run.
+ *
+ * Reads the ingest-time telemetry digest first (migration 016: series,
+ * samples, per-GPU statistics, point links). Runs that have not been ingested
+ * yet, including runs still in progress, fall back to the live GitHub
+ * artifacts exactly as before.
+ *
+ * DO NOT ADD CACHING (blob, CDN, or unstable_cache) to this route. The
+ * fallback fetches live GitHub Actions artifacts which change while a run is
+ * in progress, and stored telemetry must reflect a successful re-ingest immediately.
+ *
+ * Two telemetry collectors publish GPU power for a run:
+ * - single-node runners (nvidia-smi / amd-smi) publish one `gpu_metrics_<RESULT_FILENAME>`
+ *   CSV artifact per benchmark config;
+ * - Slurm / Dynamo disaggregated runners (DCGM) publish one `power_audit_<RESULT_FILENAME>`
+ *   bundle per concurrency sweep, holding the sweep's samples plus one
+ *   `power_validation_*.json` window per config
+ *   (`components/gpu-power/power-audit-bundle.ts`).
+ *
+ * Two response shapes:
+ * - default: every `gpu_metrics_*` artifact's parsed rows (the `/gpu-metrics`
+ *   page), from the stored digest when the run is ingested, else from GitHub;
+ *   bundles are ignored on the GitHub path;
+ * - `series=power`: compact per-GPU watt series bucketed to one second
+ *   (`components/gpu-power/power-series.ts`) for the PowerX timeline, from
+ *   CSV artifacts and from bundles cut per validation window. The timeline
+ *   joins them to chart points by `source` (bundle) or artifact name (CSV).
+ *   Persisted samples and validation windows use the same bucketing/cut
+ *   transform as artifacts, so historical runs survive artifact expiry.
+ * `prefix=<RESULT_FILENAME prefix>` narrows either shape to the artifacts of
+ * one model / workload / precision so a full nightly sweep is not downloaded
+ * for one chart. A bundle names a whole sweep, so it also matches when the
+ * prefix extends past its name into the per-concurrency suffix.
+ * Timeline POSTs sorted validation basenames in `{ sources: [...] }` to recover
+ * missing siblings while keeping fully covered DB reads independent of GitHub.
+ * `sourceCoverage` describes those requested identities, not full-run completeness.
  */
 import { type NextRequest, NextResponse } from 'next/server';
 
-import { parseCsvData } from '@/components/gpu-power/types';
+import { getDb } from '@semianalysisai/inferencex-db/connection';
+import {
+  getGpuMetricsForRun,
+  type GpuMetricsRunPayload,
+  type GpuMetricsRunSelection,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import type {
+  GpuMetricRow,
+  GpuPowerRunInfo,
+  GpuMetricsArtifact,
+  GpuPowerApiResponse,
+} from '@/components/gpu-power/types';
+import {
+  cutPowerAuditBundle,
+  isPowerAuditBundleEntry,
+  parsePowerCsvData,
+} from '@/components/gpu-power/power-audit-bundle';
+import {
+  bucketPowerFiles,
+  parseTelemetryTimestampUtc,
+  type GpuPowerSeries,
+} from '@/components/gpu-power/power-series';
+import {
+  storedPowerSeries,
+  StoredTelemetryIncompleteError,
+} from '@/components/gpu-power/stored-power-series';
 import {
   downloadGithubArtifact,
   extractZipEntries,
@@ -12,12 +72,270 @@ import {
   fetchGithubWorkflowRun,
   getGithubToken,
   normalizeGithubRunInfo,
+  readZipEntries,
+  type GithubArtifact,
   type GithubWorkflowRun,
 } from '@/lib/github-artifacts';
 
 const MAX_ARTIFACT_BYTES = 50 * 1024 * 1024;
+/** Bundles carry a whole sweep (215 MB seen for nw8); only the power entries are decoded. */
+const MAX_BUNDLE_BYTES = 256 * 1024 * 1024;
+/** Bundle downloads are latency-bound; match the other artifact routes' budget. */
+export const maxDuration = 300;
+/** Parallel artifact downloads; GitHub's zip redirects are latency-bound, not CPU-bound. */
+const DOWNLOAD_CONCURRENCY = 4;
+const ARTIFACT_PREFIX = 'gpu_metrics_';
+const BUNDLE_PREFIX = 'power_audit_';
+/** RESULT_FILENAME characters: model, workload, precision, framework, parallelism, host, hash. */
+const PREFIX_PATTERN = /^[A-Za-z0-9._-]{1,200}$/u;
+const SOURCE_PATTERN = /^power_validation_[A-Za-z0-9._-]{1,200}\.json$/u;
+const MAX_REQUEST_BYTES = 256 * 1024;
+
+export type GpuMetricsSource = 'database' | 'github';
+
+export type GpuMetricsArtifactPayload = GpuMetricsArtifact;
+
+export interface GpuMetricsRouteResponse extends GpuPowerApiResponse {
+  source: GpuMetricsSource;
+  artifactNames?: string[];
+}
+
+/** Shape the stored digest like the GitHub payload so the explorer is source-agnostic. */
+export function databasePayloadToResponse(payload: GpuMetricsRunPayload): GpuMetricsRouteResponse {
+  const run = payload.workflowRun;
+  const filesPerArtifact = new Map<string, number>();
+  for (const series of payload.series) {
+    filesPerArtifact.set(series.artifactName, (filesPerArtifact.get(series.artifactName) ?? 0) + 1);
+  }
+  return {
+    source: 'database',
+    ...(payload.artifactNames ? { artifactNames: payload.artifactNames } : {}),
+    runInfo: {
+      id: run.githubRunId,
+      name: run.name,
+      branch: run.headBranch ?? '',
+      sha: run.headSha ?? '',
+      createdAt: run.createdAt ?? `${run.date}T00:00:00Z`,
+      url:
+        run.htmlUrl ??
+        `https://github.com/SemiAnalysisAI/InferenceX/actions/runs/${run.githubRunId}`,
+      conclusion: run.conclusion ?? '',
+      status: run.status ?? '',
+    },
+    artifacts: payload.series.map(({ data, ...series }) => ({
+      // Multinode uploads carry one CSV per node; keep them distinguishable.
+      name:
+        (filesPerArtifact.get(series.artifactName) ?? 1) > 1 ||
+        payload.artifactNames?.includes(`${series.artifactName}/${series.fileName}`)
+          ? `${series.artifactName}/${series.fileName}`
+          : series.artifactName,
+      data,
+      series,
+    })),
+  };
+}
+
+/** The GitHub path also carries the bundle series the timeline draws. */
+interface GithubArtifactPayload {
+  name: string;
+  files: { name: string; data: GpuMetricRow[] }[];
+}
+
+interface GithubGpuMetricsResponse extends Omit<GpuMetricsRouteResponse, 'artifacts'> {
+  artifacts: GithubArtifactPayload[];
+  source: 'github';
+  bundleSeries: GpuPowerSeries[];
+}
+
+type TelemetryJob =
+  | { kind: 'csv'; artifact: GithubArtifact }
+  | { kind: 'bundle'; artifact: GithubArtifact };
+
+type TelemetryResult =
+  | { kind: 'csv'; parsed: GithubArtifactPayload }
+  | { kind: 'bundle'; series: GpuPowerSeries[] };
+
+/** Fetches one artifact zip, or `null` (with a warning) when it fails or exceeds `maxBytes`. */
+async function downloadZip(
+  artifact: GithubArtifact,
+  githubToken: string,
+  maxBytes: number,
+): Promise<Buffer | null> {
+  const dlResp = await downloadGithubArtifact(artifact.archive_download_url, githubToken);
+  if (!dlResp.ok) {
+    console.warn(`Failed to download artifact ${artifact.name}: ${dlResp.statusText}`);
+    return null;
+  }
+
+  const contentLength = dlResp.headers.get('Content-Length');
+  if (contentLength && parseInt(contentLength, 10) > maxBytes) {
+    console.warn(`Artifact ${artifact.name} exceeds ${maxBytes / (1024 * 1024)} MB, skipping`);
+    return null;
+  }
+  return Buffer.from(await dlResp.arrayBuffer());
+}
+
+async function downloadArtifact(
+  artifact: GithubArtifact,
+  githubToken: string,
+): Promise<GithubArtifactPayload | null> {
+  const buffer = await downloadZip(artifact, githubToken, MAX_ARTIFACT_BYTES);
+  if (!buffer) return null;
+  const contexts = new Map<string, Record<string, unknown>>();
+  const contextFiles = extractZipEntries(buffer, '.json', (name, contents) => {
+    const base = name.slice(name.lastIndexOf('/') + 1);
+    if (!base.includes('gpu_metrics') || !base.toLowerCase().endsWith('_context.json')) return [];
+    const context: unknown = JSON.parse(contents);
+    return context && typeof context === 'object' && !Array.isArray(context)
+      ? [{ name, context: context as Record<string, unknown> }]
+      : [];
+  });
+  // Ingest uses code-unit filename order, not archive order or the host locale.
+  contextFiles.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  for (const { name, context } of contextFiles) {
+    const directory = name.slice(0, name.lastIndexOf('/') + 1);
+    if (!contexts.has(directory)) contexts.set(directory, context);
+  }
+  const files = extractZipEntries(
+    buffer,
+    '.csv',
+    (entryName, contents) => {
+      const directory = entryName.slice(0, entryName.lastIndexOf('/') + 1);
+      const data = parsePowerCsvData(contents, contexts.get(directory) ?? null);
+      return data.length > 0 ? [{ name: entryName, data }] : [];
+    },
+    (entryName, error) => {
+      console.warn(`Failed to parse CSV ${entryName} from ${artifact.name}:`, error);
+    },
+  );
+  return files.length > 0 ? { name: artifact.name, files } : null;
+}
+
+async function downloadBundle(
+  artifact: GithubArtifact,
+  githubToken: string,
+): Promise<GpuPowerSeries[] | null> {
+  const buffer = await downloadZip(artifact, githubToken, MAX_BUNDLE_BYTES);
+  if (!buffer) return null;
+  const series = cutPowerAuditBundle(
+    artifact.name,
+    readZipEntries(buffer, isPowerAuditBundleEntry),
+  );
+  return series.length > 0 ? series : null;
+}
+
+/**
+ * One artifact download and parse. A corrupt or truncated archive is that
+ * artifact's failure alone: it is logged and skipped so the other series of
+ * the run still reach the chart (the client would otherwise retry the whole
+ * multi-hundred-megabyte request).
+ */
+async function runJob(job: TelemetryJob, githubToken: string): Promise<TelemetryResult | null> {
+  try {
+    if (job.kind === 'csv') {
+      const parsed = await downloadArtifact(job.artifact, githubToken);
+      return parsed ? { kind: 'csv', parsed } : null;
+    }
+    const series = await downloadBundle(job.artifact, githubToken);
+    return series ? { kind: 'bundle', series } : null;
+  } catch (error) {
+    console.warn(`Failed to read artifact ${job.artifact.name}:`, error);
+    return null;
+  }
+}
+
+/** Downloads in listing order with a bounded number of requests in flight. */
+async function downloadTelemetry(
+  jobs: TelemetryJob[],
+  githubToken: string,
+): Promise<TelemetryResult[]> {
+  const results: (TelemetryResult | null)[] = Array.from({ length: jobs.length }, () => null);
+  let next = 0;
+  const worker = async () => {
+    while (next < jobs.length) {
+      const index = next++;
+      results[index] = await runJob(jobs[index], githubToken);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(DOWNLOAD_CONCURRENCY, jobs.length) }, worker));
+  return results.filter((result): result is TelemetryResult => result !== null);
+}
+
+/**
+ * A bundle names a whole sweep, while the client's prefix (the longest common
+ * prefix of its points' validation names) may run into the `_sa-bench_…_conc<c>`
+ * suffix; either side being a prefix of the other selects the bundle.
+ */
+function isWantedBundle(name: string, prefix: string | null): boolean {
+  if (!name.startsWith(BUNDLE_PREFIX)) return false;
+  if (prefix === null) return true;
+  const wanted = `${BUNDLE_PREFIX}${prefix}`;
+  return name.startsWith(wanted) || wanted.startsWith(name);
+}
+
+/** Validation basenames identify individual windows, including siblings in one bundle. */
+function seriesSource(series: GpuPowerSeries): string | null {
+  return (
+    series.source ??
+    (series.artifact.startsWith(ARTIFACT_PREFIX)
+      ? `power_validation_${series.artifact.slice(ARTIFACT_PREFIX.length)}.json`
+      : null)
+  );
+}
+
+function isRequestedArtifact(name: string, sources: string[] | null): boolean {
+  return (
+    sources === null ||
+    sources.some((source) => {
+      const result = source.slice('power_validation_'.length, -'.json'.length);
+      return name === `${ARTIFACT_PREFIX}${result}` || isWantedBundle(name, result);
+    })
+  );
+}
+
+function sourceCoverage(series: GpuPowerSeries[], sources: string[] | null) {
+  const available = new Set(series.map(seriesSource));
+  const missingSources = sources?.filter((source) => !available.has(source)) ?? [];
+  return {
+    status: sources === null ? 'unknown' : missingSources.length > 0 ? 'incomplete' : 'complete',
+    missingSources,
+  };
+}
+
+function powerSeriesResponse(
+  source: GpuMetricsSource,
+  runInfo: GpuPowerRunInfo,
+  series: GpuPowerSeries[],
+  sources: string[] | null,
+) {
+  return NextResponse.json(
+    { source, runInfo, series, sourceCoverage: sourceCoverage(series, sources) },
+    { headers: { 'Cache-Control': 'no-store' } },
+  );
+}
 
-async function fetchGpuMetrics(runId: string) {
+/**
+ * Narrows a stored run to the artifacts a `prefix` names, mirroring the GitHub
+ * listing filter so both sources answer the same request the same way.
+ */
+function filterArtifactsByPrefix(
+  artifacts: GpuMetricsArtifactPayload[],
+  prefix: string | null,
+): GpuMetricsArtifactPayload[] {
+  if (prefix === null) return artifacts;
+  const wanted = `${ARTIFACT_PREFIX}${prefix}`;
+  return artifacts.filter((artifact) => {
+    const name = artifact.series?.artifactName ?? artifact.name;
+    return name.startsWith(wanted) || isWantedBundle(name, prefix);
+  });
+}
+
+async function fetchGpuMetricsFromGithub(
+  runId: string,
+  prefix: string | null,
+  includeBundles: boolean,
+  sources: string[] | null = null,
+): Promise<GithubGpuMetricsResponse> {
   const githubToken = getGithubToken();
   if (!githubToken) throw new Error('GitHub token not configured');
 
@@ -27,57 +345,292 @@ async function fetchGpuMetrics(runId: string) {
 
   const artifacts = await fetchGithubRunArtifacts(runId, githubToken);
 
-  const gpuArtifacts = artifacts.filter((a) => a.name.startsWith('gpu_metrics'));
-  if (gpuArtifacts.length === 0) throw new Error('No gpu_metrics artifacts found for this run');
-
-  const parsedArtifacts: { name: string; data: ReturnType<typeof parseCsvData> }[] = [];
-  for (const artifact of gpuArtifacts) {
-    const dlResp = await downloadGithubArtifact(artifact.archive_download_url, githubToken);
-    if (!dlResp.ok) {
-      console.warn(`Failed to download artifact ${artifact.name}: ${dlResp.statusText}`);
-      continue;
+  // `eval_gpu_metrics_*` artifacts are excluded by the bare `gpu_metrics` test.
+  const wanted = prefix ? `${ARTIFACT_PREFIX}${prefix}` : 'gpu_metrics';
+  const jobs: TelemetryJob[] = artifacts
+    .filter((a) => a.name.startsWith(wanted) && isRequestedArtifact(a.name, sources))
+    .map((artifact) => ({ kind: 'csv', artifact }));
+  if (includeBundles) {
+    for (const artifact of artifacts) {
+      if (isWantedBundle(artifact.name, prefix) && isRequestedArtifact(artifact.name, sources))
+        jobs.push({ kind: 'bundle', artifact });
     }
-
-    const contentLength = dlResp.headers.get('Content-Length');
-    if (contentLength && parseInt(contentLength, 10) > MAX_ARTIFACT_BYTES) {
-      console.warn(`Artifact ${artifact.name} exceeds 50 MB, skipping`);
-      continue;
-    }
-
-    const rows = extractZipEntries(
-      Buffer.from(await dlResp.arrayBuffer()),
-      '.csv',
-      (_entryName, contents) => parseCsvData(contents),
-      (entryName, error) => {
-        console.warn(`Failed to parse CSV ${entryName} from ${artifact.name}:`, error);
-      },
+  }
+  if (jobs.length === 0) {
+    throw new Error(
+      includeBundles
+        ? 'No telemetry artifacts (gpu_metrics or power_audit) found for this run'
+        : 'No gpu_metrics artifacts found for this run',
     );
-    if (rows.length > 0) parsedArtifacts.push({ name: artifact.name, data: rows });
   }
 
-  if (parsedArtifacts.length === 0) throw new Error('No Chip metrics data found in artifacts');
+  const results = await downloadTelemetry(jobs, githubToken);
+  if (results.length === 0) throw new Error('No Chip metrics data found in artifacts');
 
+  const parsedArtifacts: GithubArtifactPayload[] = [];
+  const bundleSeries: GpuPowerSeries[] = [];
+  for (const result of results) {
+    if (result.kind === 'csv') parsedArtifacts.push(result.parsed);
+    else bundleSeries.push(...result.series);
+  }
   return {
-    runInfo: normalizeGithubRunInfo(run),
+    source: 'github',
+    runInfo: normalizeGithubRunInfo(run) as GpuPowerRunInfo,
     artifacts: parsedArtifacts,
+    bundleSeries,
   };
 }
 
-export async function GET(request: NextRequest) {
-  const runId = request.nextUrl.searchParams.get('runId');
+async function fetchGpuMetricsFromDatabase(
+  runId: string,
+  selection: GpuMetricsRunSelection,
+): Promise<GpuMetricsRouteResponse | null> {
+  if (!process.env.DATABASE_READONLY_URL) return null;
+  const payload = await getGpuMetricsForRun(getDb(), Number(runId), selection);
+  return payload ? databasePayloadToResponse(payload) : null;
+}
+
+export function GET(request: NextRequest) {
+  return readGpuMetrics(request, null);
+}
+
+/** Selecting a host must not discard the explorer's sibling artifact choices. */
+export function readGpuMetricsForView(request: NextRequest, artifact: string | null) {
+  return readGpuMetrics(request, null, artifact);
+}
+
+/** Read-only Timeline transport; the body avoids URL limits for a run's point identities. */
+export async function POST(request: NextRequest) {
+  const reader = request.body?.getReader();
+  const chunks: Uint8Array[] = [];
+  let bytes = 0;
+  try {
+    if (reader) {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        bytes += value.byteLength;
+        if (bytes > MAX_REQUEST_BYTES) {
+          await reader.cancel();
+          return NextResponse.json({ error: 'Request body exceeds 256 KiB' }, { status: 413 });
+        }
+        chunks.push(value);
+      }
+    }
+    const body: unknown = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    const sources =
+      body && typeof body === 'object' && !Array.isArray(body) && 'sources' in body
+        ? body.sources
+        : null;
+    if (
+      !Array.isArray(sources) ||
+      sources.length === 0 ||
+      sources.length > 1000 ||
+      !sources.every(
+        (source): source is string => typeof source === 'string' && SOURCE_PATTERN.test(source),
+      )
+    ) {
+      return NextResponse.json(
+        { error: 'sources must contain 1–1000 power_validation_<RESULT_FILENAME>.json basenames' },
+        { status: 400 },
+      );
+    }
+    if (request.nextUrl.searchParams.get('series') !== 'power') {
+      return NextResponse.json({ error: 'POST requires series=power' }, { status: 400 });
+    }
+    const prefix = request.nextUrl.searchParams.get('prefix');
+    if (
+      prefix !== null &&
+      sources.some((source) => !source.startsWith(`power_validation_${prefix}`))
+    ) {
+      return NextResponse.json({ error: 'Every source must match prefix' }, { status: 400 });
+    }
+    return readGpuMetrics(request, [...new Set(sources)].sort());
+  } catch {
+    return NextResponse.json({ error: 'Request body must be valid JSON' }, { status: 400 });
+  } finally {
+    reader?.releaseLock();
+  }
+}
+
+async function readGpuMetrics(
+  request: NextRequest,
+  sources: string[] | null,
+  selectedArtifact?: string | null,
+) {
+  const params = request.nextUrl.searchParams;
+  const runId = params.get('runId');
 
   if (!runId || !/^\d+$/u.test(runId)) {
     return NextResponse.json({ error: 'runId must be a numeric workflow run ID' }, { status: 400 });
   }
+  const prefix = params.get('prefix');
+  if (prefix !== null && !PREFIX_PATTERN.test(prefix)) {
+    return NextResponse.json(
+      { error: 'prefix must be a RESULT_FILENAME prefix (letters, digits, . _ -)' },
+      { status: 400 },
+    );
+  }
+  const series = params.get('series');
+  if (series !== null && series !== 'power') {
+    return NextResponse.json({ error: 'series must be "power" when present' }, { status: 400 });
+  }
+
+  let stored: GpuMetricsRouteResponse | null;
+  try {
+    stored = await fetchGpuMetricsFromDatabase(runId, {
+      prefix,
+      sourceResults:
+        sources?.map((source) => source.slice('power_validation_'.length, -'.json'.length)) ?? null,
+      ...(selectedArtifact === undefined ? {} : { artifact: selectedArtifact }),
+    });
+  } catch (error) {
+    // Missing data may use live artifacts; a failed read cannot establish absence.
+    console.error(`gpu-metrics: database lookup failed for run ${runId}:`, error);
+    return NextResponse.json(
+      {
+        error: 'Stored telemetry is temporarily unavailable. Retry the request.',
+        code: 'DATABASE_UNAVAILABLE',
+      },
+      { status: 503, headers: { 'Cache-Control': 'no-store' } },
+    );
+  }
 
+  const incomplete: StoredTelemetryIncompleteError[] = [];
+  const databaseSeries: GpuPowerSeries[] = [];
+  let githubFallbackStarted = false;
   try {
-    const data = await fetchGpuMetrics(runId);
-    return NextResponse.json(data);
+    if (stored) {
+      const artifacts = filterArtifactsByPrefix(stored.artifacts, prefix).filter((artifact) =>
+        isRequestedArtifact(artifact.series?.artifactName ?? artifact.name, sources),
+      );
+      if (series === 'power') {
+        const groups = Map.groupBy(
+          artifacts.flatMap((artifact) =>
+            artifact.series ? [{ ...artifact.series, data: artifact.data }] : [],
+          ),
+          (entry) => entry.artifactName,
+        );
+        for (const entries of groups.values()) {
+          try {
+            databaseSeries.push(
+              ...storedPowerSeries(entries).filter(
+                (entry) => sources === null || sources.includes(seriesSource(entry) ?? ''),
+              ),
+            );
+          } catch (error) {
+            if (!(error instanceof StoredTelemetryIncompleteError)) throw error;
+            incomplete.push(error);
+            console.warn(
+              'gpu-metrics: incomplete stored telemetry, trying artifacts:',
+              error.message,
+            );
+          }
+        }
+        if (
+          incomplete.length === 0 &&
+          databaseSeries.length > 0 &&
+          sourceCoverage(databaseSeries, sources).missingSources.length === 0
+        ) {
+          return powerSeriesResponse('database', stored.runInfo, databaseSeries, sources);
+        }
+      } else if (artifacts.length > 0 || stored.artifactNames) {
+        return NextResponse.json(
+          { ...stored, artifacts },
+          { headers: { 'Cache-Control': 'no-store' } },
+        );
+      }
+    }
+    if (series === 'power') {
+      githubFallbackStarted = true;
+      const { runInfo, artifacts, bundleSeries } = await fetchGpuMetricsFromGithub(
+        runId,
+        prefix,
+        true,
+        sources === null ? null : sourceCoverage(databaseSeries, sources).missingSources,
+      );
+      const powerSeries = artifacts
+        .map((artifact) => bucketPowerFiles(artifact.name, artifact.files))
+        .filter((entry): entry is GpuPowerSeries => entry !== null);
+      // A fallback response can combine durable history with live recovery.
+      // Keep healthy stored windows even when their GitHub copies expired,
+      // and never replace or duplicate them with a live copy. source='github'
+      // records that this response required fallback, not that every row is live.
+      const databaseSources = new Set(databaseSeries.map(seriesSource));
+      const combined = [
+        ...databaseSeries,
+        ...[...powerSeries, ...bundleSeries].filter(
+          (entry) =>
+            !databaseSources.has(seriesSource(entry)) &&
+            (sources === null || sources.includes(seriesSource(entry) ?? '')),
+        ),
+      ];
+      for (const missing of incomplete) {
+        const incompleteArtifact = missing.artifact;
+        const live = artifacts.find((artifact) => artifact.name === incompleteArtifact);
+        const inventory = stored?.artifacts.find(
+          (artifact) => artifact.series?.artifactName === incompleteArtifact,
+        )?.series?.sidecars.seriesInventory;
+        // A matching name alone cannot prove that missing hosts/samples recovered.
+        // Bundle cuts do not retain the raw inventory, so known-incomplete bundles
+        // require re-ingest; ordinary un-ingested bundle fallback stays available.
+        if (!live || !Array.isArray(inventory) || inventory.length === 0) throw missing;
+        const counts = new Map(
+          live.files.map((file) => [
+            file.name,
+            new Set(
+              file.data.flatMap((row) => {
+                const time = parseTelemetryTimestampUtc(row.timestamp);
+                return time === null || !Number.isInteger(row.index) || !Number.isFinite(row.power)
+                  ? []
+                  : [`${row.index}:${time}`];
+              }),
+            ).size,
+          ]),
+        );
+        if (
+          !inventory.every(
+            (expected) =>
+              expected !== null &&
+              typeof expected === 'object' &&
+              typeof expected.fileName === 'string' &&
+              typeof expected.sampleCount === 'number' &&
+              counts.get(expected.fileName) === expected.sampleCount,
+          )
+        )
+          throw missing;
+      }
+      return powerSeriesResponse('github', runInfo, combined, sources);
+    }
+    const live = await fetchGpuMetricsFromGithub(runId, prefix, false);
+    return NextResponse.json(
+      {
+        source: live.source,
+        runInfo: live.runInfo,
+        artifacts: live.artifacts.flatMap(({ name, files }) =>
+          files.map((file) => ({
+            name: files.length > 1 ? `${name}/${file.name}` : name,
+            data: file.data,
+          })),
+        ),
+      },
+      { headers: { 'Cache-Control': 'no-store' } },
+    );
   } catch (error) {
     console.error('Error fetching GPU power data:', error);
+    const missing = error instanceof StoredTelemetryIncompleteError ? error : incomplete[0];
+    if (githubFallbackStarted && !missing && stored && databaseSeries.length > 0) {
+      return powerSeriesResponse('database', stored.runInfo, databaseSeries, sources);
+    }
     return NextResponse.json(
-      { error: error instanceof Error ? error.message : 'Unknown error occurred' },
-      { status: 500 },
+      missing
+        ? {
+            error: missing.message,
+            code: 'STORED_TELEMETRY_INCOMPLETE',
+            artifact: missing.artifact,
+          }
+        : { error: error instanceof Error ? error.message : 'Unknown error occurred' },
+      { status: missing ? 503 : 500, headers: { 'Cache-Control': 'no-store' } },
     );
   }
 }
diff --git a/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts b/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
new file mode 100644
index 000000000..0fdad8907
--- /dev/null
+++ b/packages/app/src/app/api/v1/gpu-metrics-point/route.test.ts
@@ -0,0 +1,264 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { gunzipSync } from 'node:zlib';
+import { PGlite } from '@electric-sql/pglite';
+import { NextRequest } from 'next/server';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ingestGpuMetricsArtifact } from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
+import type * as GpuMetricStatsModule from '@semianalysisai/inferencex-db/lib/gpu-metric-stats';
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+import { getGpuMetricsPointRevision } from '@semianalysisai/inferencex-db/queries/gpu-metrics-revision';
+import { startPowerxBlobFixture } from '../../../../../scripts/powerx-blob-fixture';
+
+const algorithm = vi.hoisted(() => ({ version: 1 }));
+vi.mock('@semianalysisai/inferencex-db/lib/gpu-metric-stats', async (importOriginal) => {
+  const actual = await importOriginal<typeof GpuMetricStatsModule>();
+  return {
+    ...actual,
+    get GPU_STATS_VERSION() {
+      return algorithm.version;
+    },
+  };
+});
+
+const connection = vi.hoisted(() => ({ getDb: vi.fn() }));
+vi.mock('@semianalysisai/inferencex-db/connection', () => connection);
+// The query, cache abstraction, Blob SDK, HTTP transport and ETL are real.
+import { GET } from './route';
+
+let db: PGlite;
+type Sql = Parameters<typeof ingestGpuMetricsArtifact>[0];
+let sql: Sql;
+let blob: Awaited<ReturnType<typeof startPowerxBlobFixture>>;
+let root: string;
+let sampleReads = 0;
+const artifactName = 'gpu_metrics_dsr1_8k1k_fp4_sglang_conc32_b200-x_0';
+const artifact = () => ({ artifactName, artifactDir: root });
+
+function client(database: Pick<PGlite, 'query'>) {
+  return Object.assign(
+    async (strings: TemplateStringsArray, ...values: unknown[]) => {
+      const query = strings.reduce((text, part, i) => text + (i ? `$${i}` : '') + part, '');
+      if (query.includes('from gpu_metric_samples')) sampleReads++;
+      const result = await database.query<Record<string, unknown>>(query, values);
+      return result.rows;
+    },
+    { json: JSON.stringify, array: (value: unknown) => value },
+  );
+}
+
+beforeAll(async () => {
+  db = await PGlite.create();
+  for (const name of [
+    '001_initial_schema.sql',
+    '016_gpu_metrics.sql',
+    '017_gpu_metric_stats_version.sql',
+  ]) {
+    await db.exec(
+      fs.readFileSync(new URL(`../../../../../../db/migrations/${name}`, import.meta.url), 'utf8'),
+    );
+  }
+  await db.exec(`ALTER TABLE benchmark_results ADD COLUMN power_audit jsonb;
+    INSERT INTO workflow_runs (id, github_run_id, run_attempt, name, status, conclusion, created_at, date)
+    VALUES (1, 34557177019, 1, 'Run Sweep', 'completed', 'success', '2026-09-11', '2026-09-11');
+    INSERT INTO configs (id, model, hardware, framework, precision, spec_method, disagg,
+      prefill_tp, decode_tp, num_prefill_gpu, num_decode_gpu)
+    VALUES (1, 'dsr1', 'b200', 'sglang', 'fp4', 'none', false, 4, 4, 4, 4);
+    INSERT INTO benchmark_results (id, workflow_run_id, config_id, benchmark_type, date, isl, osl, conc, metrics)
+    VALUES (10, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 32, '{}'),
+      (11, 1, 1, 'single_turn', '2026-09-11', 8192, 1024, 64, '{}');`);
+  sql = Object.assign(client(db), {
+    begin: (fn: (tx: Sql) => Promise<unknown>) =>
+      db.transaction((tx) => fn(client(tx) as unknown as Sql)),
+  }) as unknown as Sql;
+  connection.getDb.mockReturnValue(sql);
+  blob = await startPowerxBlobFixture();
+  for (const [key, value] of Object.entries(blob.env)) vi.stubEnv(key, value);
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'powerx-cache-recovery-'));
+  // Retained run 34175132645, attempt 1; source and excerpt hashes live beside the fixture.
+  const csv = fs.readFileSync(
+    new URL('../../../../../../../docs/fixtures/powerx-reingest/nvidia.csv', import.meta.url),
+  );
+  expect(createHash('sha256').update(csv).digest('hex')).toBe(
+    '833cf864da4618579deeeda89b3ddde6dbf8b7b32b7877fda643f18411ee3481',
+  );
+  fs.writeFileSync(path.join(root, 'gpu_metrics.csv'), csv);
+}, 20_000);
+
+afterAll(async () => {
+  vi.unstubAllEnvs();
+  await blob?.close();
+  await db?.close();
+  if (root) fs.rmSync(root, { recursive: true, force: true });
+});
+
+beforeEach(async () => {
+  algorithm.version = 1;
+  await db.exec(
+    'TRUNCATE gpu_metric_series RESTART IDENTITY CASCADE; UPDATE benchmark_results SET power_audit = null;',
+  );
+  blob.objects.clear();
+  Object.assign(blob.counts, { reads: 0, writes: 0, failedWrites: 0 });
+  sampleReads = 0;
+  // Injected test sidecars: the retained source does not establish its timezone or identity.
+  fs.writeFileSync(
+    path.join(root, 'gpu_metrics_context.json'),
+    JSON.stringify({ timestamp_timezone: 'UTC' }),
+  );
+  fs.writeFileSync(
+    path.join(root, 'gpu_metrics_identity.csv'),
+    'index, uuid, name\n0, GPU-old, NVIDIA B200\n',
+  );
+});
+
+async function request(id: number) {
+  const response = await GET(new NextRequest(`http://localhost/api/v1/gpu-metrics-point?id=${id}`));
+  const bytes = Buffer.from(await response.arrayBuffer());
+  const body =
+    response.headers.get('content-encoding') === 'gzip'
+      ? gunzipSync(bytes).toString()
+      : bytes.toString();
+  return { response, body: JSON.parse(body) };
+}
+
+describe('artifact → local DB → real Blob cache → point API recovery', () => {
+  it('requires live revision checks for successful and missing responses', async () => {
+    const missing = await request(10);
+    expect(missing.response.headers.get('cache-control')).toBe('no-store');
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10],
+    });
+    const present = await request(10);
+    expect(present.response.headers.get('cache-control')).toBe('no-store');
+  });
+  it('refreshes missing points, shared links, timezone and identity repairs without purging', async () => {
+    const missing = await request(10);
+    expect(missing.response.status).toBe(404);
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10],
+    });
+    const old = await request(10);
+    expect(old.response.status).toBe(200);
+    const originalSeries: GpuMetricSeries = old.body.series[0];
+    expect(originalSeries).toMatchObject({
+      sampleCount: 24,
+      gpuCount: 8,
+      startedAt: '2026-09-08T07:20:19.279Z',
+      endedAt: '2026-09-08T07:20:21.279Z',
+    });
+    expect(originalSeries.data).toHaveLength(24);
+    expect(originalSeries.data.filter((row) => row.index === 0).map((row) => row.power)).toEqual([
+      380.42, 336.61, 337.18,
+    ]);
+    expect(blob.objects.size).toBe(1);
+    const beforeHit = blob.counts.reads;
+    const beforeSampleReads = sampleReads;
+    const cached = await request(10);
+    expect(cached.body).toEqual(old.body);
+    expect(blob.counts.reads).toBe(beforeHit + 1);
+    expect(sampleReads).toBe(beforeSampleReads);
+
+    const unlinked = await request(11);
+    expect(unlinked.response.status).toBe(404);
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [11],
+    });
+    for (const id of [10, 11]) {
+      const linked = await request(id);
+      expect(linked.body.series[0].benchmarkResultIds).toEqual([10, 11]);
+    }
+    const oldRevision = await getGpuMetricsPointRevision(client(db), 10);
+    fs.writeFileSync(
+      path.join(root, 'gpu_metrics_context.json'),
+      JSON.stringify({ timestamp_timezone: '+08:00' }),
+    );
+    fs.writeFileSync(
+      path.join(root, 'gpu_metrics_identity.csv'),
+      'index, uuid, name\n0, GPU-corrected, NVIDIA B200\n',
+    );
+    await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10, 11],
+    });
+    expect(await getGpuMetricsPointRevision(client(db), 10)).not.toBe(oldRevision);
+    for (const id of [10, 11]) {
+      const repaired = await request(id);
+      expect(repaired.body.series[0].data[0].timestamp).toBe('2026-09-07T23:20:19.279Z');
+      expect(repaired.body.series[0].sampleCount).toBe(24);
+      expect(JSON.stringify(repaired.body.series[0].sidecars)).toContain('GPU-corrected');
+    }
+    const revision = await getGpuMetricsPointRevision(client(db), 10);
+    const writes = blob.counts.writes;
+    const unchanged = await ingestGpuMetricsArtifact(sql, {
+      workflowRunId: 1,
+      artifact: artifact(),
+      benchmarkResultIds: [10, 11],
+    });
+    expect(unchanged.seriesSkipped).toBe(1);
+    expect(await getGpuMetricsPointRevision(client(db), 10)).toBe(revision);
+    await request(10);
+    expect(blob.counts.writes).toBe(writes);
+    const samples = await db.query('select count(*)::int as n from gpu_metric_samples');
+    expect(samples.rows).toEqual([{ n: 24 }]);
+  });
+});
+
+const power = (body: { series: GpuMetricSeries[] }) =>
+  body.series[0]!.stats.find((s) => s.gpuIndex === 0 && s.metric === 'power_w')!;
+
+it('bypasses warmed shared-point caches on algorithm upgrade, then persists through unchanged re-ingest', async () => {
+  const input = { workflowRunId: 1, artifact: artifact(), benchmarkResultIds: [10, 11] };
+  const first = await ingestGpuMetricsArtifact(sql, input);
+  await sql`update gpu_metric_gpu_stats set mean_value = -1`;
+
+  for (const id of [10, 11]) {
+    const cached = await request(id);
+    expect(power(cached.body).mean).toBe(-1);
+  }
+  const oldRevision = await getGpuMetricsPointRevision(client(db), 10);
+  const originalSamples =
+    await sql`select * from gpu_metric_samples order by series_id, sampled_at, gpu_index`;
+  // Model a code deploy: no DB row, sample, sidecar or link has changed.
+  algorithm.version = 2;
+  expect(await getGpuMetricsPointRevision(client(db), 10)).not.toBe(oldRevision);
+  for (const id of [10, 11]) {
+    const refreshed = await request(id);
+    expect(power(refreshed.body).mean).toBeCloseTo(351.403333, 3);
+  }
+  expect(await sql`select stats_version from gpu_metric_series`).toEqual([{ stats_version: 1 }]);
+  expect(await sql`select distinct mean_value from gpu_metric_gpu_stats`).toEqual([
+    { mean_value: -1 },
+  ]);
+  const upgradedRevision = await getGpuMetricsPointRevision(client(db), 10);
+  const repaired = await ingestGpuMetricsArtifact(sql, input);
+  expect(repaired).toMatchObject({
+    seriesIds: first.seriesIds,
+    samplesInserted: 0,
+    seriesSkipped: 0,
+  });
+  expect(await getGpuMetricsPointRevision(client(db), 10)).not.toBe(upgradedRevision);
+  for (const id of [10, 11]) {
+    const refreshed = await request(id);
+    expect(power(refreshed.body).mean).toBeCloseTo(351.403333, 3);
+  }
+  expect(await sql`select stats_version from gpu_metric_series`).toEqual([{ stats_version: 2 }]);
+  expect(
+    await sql`select * from gpu_metric_samples order by series_id, sampled_at, gpu_index`,
+  ).toEqual(originalSamples);
+  const beforeHit = sampleReads;
+  await request(10);
+  expect(sampleReads).toBe(beforeHit);
+  expect(await ingestGpuMetricsArtifact(sql, input)).toMatchObject({
+    samplesInserted: 0,
+    seriesSkipped: 1,
+  });
+});
diff --git a/packages/app/src/app/api/v1/gpu-metrics-point/route.ts b/packages/app/src/app/api/v1/gpu-metrics-point/route.ts
new file mode 100644
index 000000000..6b995ecb2
--- /dev/null
+++ b/packages/app/src/app/api/v1/gpu-metrics-point/route.ts
@@ -0,0 +1,46 @@
+import { getDb } from '@semianalysisai/inferencex-db/connection';
+import { getGpuMetricsPointRevision } from '@semianalysisai/inferencex-db/queries/gpu-metrics-revision';
+import type { NextRequest } from 'next/server';
+import {
+  getGpuMetricsForPoint,
+  type GpuMetricsPointPayload,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import { cachedQuery } from '@/lib/api-cache';
+
+import { idQueryRoute } from '../id-routes';
+
+export const dynamic = 'force-dynamic';
+
+export const CACHE_KEY_PREFIX = 'gpu-metrics-point-v2';
+
+const getCachedGpuMetricsForPoint = cachedQuery(
+  (id: number, _revision: string): Promise<GpuMetricsPointPayload | null> =>
+    getGpuMetricsForPoint(getDb(), id),
+  CACHE_KEY_PREFIX,
+  { blobOnly: true },
+);
+
+/**
+ * GET /api/v1/gpu-metrics-point?id=N
+ *
+ * PowerX telemetry recorded while one benchmark point ran: every linked
+ * gpu_metrics series with full-resolution per-GPU samples and the ingest-time
+ * per-GPU statistics digest. 404 when the point has no linked series (its
+ * run predates migration 016 and the artifacts have expired, or the job
+ * uploaded no gpu_metrics artifact).
+ */
+const handleGet = idQueryRoute({
+  logLabel: 'gpu metrics point',
+  fetch: async (id) => {
+    const revision = await getGpuMetricsPointRevision(getDb(), id);
+    return revision === null ? null : getCachedGpuMetricsForPoint(id, revision);
+  },
+});
+
+export async function GET(request: NextRequest): Promise<Response> {
+  const response = await handleGet(request);
+  // The live revision check must run even when a point used to be missing.
+  response.headers.set('Cache-Control', 'no-store');
+  return response;
+}
diff --git a/packages/app/src/app/api/v1/views/extensions.test.ts b/packages/app/src/app/api/v1/views/extensions.test.ts
index 11d6dac9a..99402904f 100644
--- a/packages/app/src/app/api/v1/views/extensions.test.ts
+++ b/packages/app/src/app/api/v1/views/extensions.test.ts
@@ -19,7 +19,7 @@ const mocks = vi.hoisted(() => ({
   unofficial: vi.fn(),
   submissions: vi.fn(),
 }));
-vi.mock('@/app/api/gpu-metrics/route', () => ({ GET: mocks.metrics }));
+vi.mock('@/app/api/gpu-metrics/route', () => ({ readGpuMetricsForView: mocks.metrics }));
 vi.mock('@/app/api/video-runs/route', () => ({ GET: mocks.video }));
 vi.mock('@/app/api/v1/benchmarks/route', () => ({ GET: mocks.benchmarks }));
 vi.mock('@/app/api/unofficial-run/route', () => ({ GET: mocks.unofficial }));
diff --git a/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts b/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
new file mode 100644
index 000000000..b4f3f167b
--- /dev/null
+++ b/packages/app/src/app/api/v1/views/gpu-metrics/route.test.ts
@@ -0,0 +1,101 @@
+import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+import type { GpuMetricsArtifact, GpuPowerApiResponse } from '@/components/gpu-power/types';
+import { NextRequest } from 'next/server';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { metrics } = vi.hoisted(() => ({ metrics: vi.fn() }));
+vi.mock('@/app/api/gpu-metrics/route', () => ({
+  GET: metrics,
+  readGpuMetricsForView: metrics,
+}));
+// These source handlers are imported by the shared source module, but this view never calls them.
+vi.mock('@/app/api/v1/benchmarks/route', () => ({ GET: vi.fn() }));
+vi.mock('@/app/api/unofficial-run/route', () => ({ GET: vi.fn() }));
+
+import { GET } from './route';
+
+const rows = [
+  { timestamp: '2026-09-08T00:00:00Z', index: 0, power: 100, temperature: 40 },
+  { timestamp: '2026-09-08T00:00:01Z', index: 0, power: 300, temperature: 42 },
+  { timestamp: '2026-09-08T00:00:01Z', index: 1, power: 50, temperature: 38 },
+];
+const digest: GpuMetricStatRow[] = [
+  {
+    gpuIndex: 0,
+    metric: 'power_w',
+    count: 10,
+    min: 0,
+    max: 800,
+    mean: 350,
+    median: 300,
+    p95: 750,
+    p99: 790,
+    stddev: 200,
+  },
+  {
+    gpuIndex: 1,
+    metric: 'power_w',
+    count: 12,
+    min: 100,
+    max: 900,
+    mean: 700,
+    median: 750,
+    p95: 880,
+    p99: 898,
+    stddev: 80,
+  },
+];
+function artifact(stats: GpuMetricStatRow[] = digest): GpuMetricsArtifact {
+  return {
+    name: 'gpu_metrics_retained/host-a/gpu_metrics.csv',
+    data: rows,
+    series: {
+      id: 1,
+      artifactName: 'gpu_metrics_retained',
+      configKey: 'retained',
+      fileName: 'host-a/gpu_metrics.csv',
+      vendor: 'nvidia',
+      sampleIntervalS: 1,
+      sampleCount: 22,
+      gpuCount: 2,
+      startedAt: '2026-09-08T00:00:00Z',
+      endedAt: '2026-09-08T00:00:10Z',
+      sidecars: {},
+      benchmarkResultIds: [10, 11],
+      stats,
+    },
+  };
+}
+const runInfo = {
+  id: 34175132645,
+  name: 'Run Sweep',
+  branch: 'main',
+  sha: 'retained-source',
+  createdAt: '2026-09-08T00:00:00Z',
+  url: 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/34175132645',
+  conclusion: 'success',
+  status: 'completed',
+};
+function source(artifacts: GpuMetricsArtifact[]) {
+  const payload: GpuPowerApiResponse = { runInfo, artifacts };
+  metrics.mockImplementation(() => Response.json(payload));
+}
+const request = (query = '') =>
+  new NextRequest(`http://localhost/api/v1/views/gpu-metrics?runId=${runInfo.id}${query}`);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  source([artifact()]);
+});
+
+describe('GET /api/v1/views/gpu-metrics full-record statistics', () => {
+  it('returns the stored digest even when raw rows would produce different statistics', async () => {
+    const response = await GET(request());
+    expect(response.status).toBe(200);
+    expect(response.headers.get('cache-control')).toBe('private, no-store');
+    const body = await response.json();
+    expect(body.stats).toEqual(digest.map(({ metric: _metric, ...stats }) => stats));
+    expect(body.rows).toEqual(rows);
+    expect(metrics.mock.calls[0][0].nextUrl.searchParams.get('runId')).toBe(String(runInfo.id));
+  });
+});
diff --git a/packages/app/src/app/api/v1/views/gpu-metrics/route.ts b/packages/app/src/app/api/v1/views/gpu-metrics/route.ts
index 253c8bb1f..9b9ae967d 100644
--- a/packages/app/src/app/api/v1/views/gpu-metrics/route.ts
+++ b/packages/app/src/app/api/v1/views/gpu-metrics/route.ts
@@ -1,10 +1,13 @@
-import { GET as metrics } from '@/app/api/gpu-metrics/route';
+import {
+  readGpuMetricsForView as metrics,
+  type GpuMetricsRouteResponse,
+} from '@/app/api/gpu-metrics/route';
 import { buildCorrelationData, buildGroupedData } from '@/components/gpu-power/chart-data';
+import { storedGpuStatsForMetric } from '@/components/gpu-power/stored-gpu-stats';
 import {
   ALL_METRIC_OPTIONS,
   computeGpuStats,
   getAvailableMetrics,
-  type GpuPowerApiResponse,
 } from '@/components/gpu-power/types';
 import { runViewsRoute, ViewsApiParamError } from '@/lib/views-api/errors';
 import {
@@ -21,24 +24,24 @@ import { type NextRequest, NextResponse } from 'next/server';
 export const dynamic = 'force-dynamic';
 export const maxDuration = 300;
 
-/** Live metrics intentionally bypass both CDN and Blob caching. */
+/** Stored and live metrics bypass response caching so repairs remain observable. */
 export function GET(request: NextRequest) {
   return runViewsRoute('gpu-metrics', async () => {
     validateViewParams(request.nextUrl.searchParams, VIEW_QUERY_PARAMS['gpu-metrics']);
     const s = request.nextUrl.searchParams;
     if (!s.get('runId')) throw new ViewsApiParamError('runId', 'runId is required');
     const runId = parseNumberParam(s.get('runId'), 'runId', 0, { min: 1, integer: true });
-    const data = await readResponse<GpuPowerApiResponse>(
-      await metrics(sourceRequest(request, '/api/gpu-metrics', { runId: String(runId) })),
+    const data = await readResponse<GpuMetricsRouteResponse>(
+      await metrics(
+        sourceRequest(request, '/api/gpu-metrics', { runId: String(runId) }),
+        s.get('artifact'),
+      ),
     );
+    const artifactNames = data.artifactNames ?? data.artifacts.map((a) => a.name);
     const artifact = s.get('artifact') ?? data.artifacts[0]?.name;
     const selected = data.artifacts.find((a) => a.name === artifact);
     if (artifact && !selected)
-      throw new ViewsApiParamError(
-        'artifact',
-        'Unknown artifact',
-        data.artifacts.map((a) => a.name),
-      );
+      throw new ViewsApiParamError('artifact', 'Unknown artifact', artifactNames);
     const rows = selected?.data ?? [];
     const availableMetrics = getAvailableMetrics(rows);
     const keys = ALL_METRIC_OPTIONS.map((m) => m.key);
@@ -70,9 +73,11 @@ export function GET(request: NextRequest) {
     );
     const direction = parseEnumParam(s.get('direction'), 'direction', ['asc', 'desc'], 'asc');
     // The UI statistics table uses all chips; chart visibility does not filter it.
-    const stats = computeGpuStats(rows, metric).sort(
-      (a, b) => (a[sort] - b[sort]) * (direction === 'asc' ? 1 : -1),
-    );
+    const stats = (
+      selected?.series
+        ? storedGpuStatsForMetric(selected.series.stats, metric)
+        : computeGpuStats(rows, metric)
+    ).sort((a, b) => (a[sort] - b[sort]) * (direction === 'asc' ? 1 : -1));
     return NextResponse.json(
       {
         view: 'gpu-metrics',
@@ -90,7 +95,7 @@ export function GET(request: NextRequest) {
           direction,
         },
         runInfo: data.runInfo,
-        artifacts: data.artifacts.map((a) => a.name),
+        artifacts: artifactNames,
         availableMetrics,
         gpuIndices: indices,
         rows: rows.filter((r) => gpus.includes(r.index)),
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.test.ts b/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
new file mode 100644
index 000000000..eb41678c5
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.test.ts
@@ -0,0 +1,164 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  BUNDLE_MANIFEST_ENTRY,
+  BUNDLE_SAMPLES_ENTRY,
+  BUNDLE_WINDOW_PAD_SECONDS,
+  cutPowerAuditBundle,
+  parsePowerCsvData,
+} from './power-audit-bundle';
+
+const ARTIFACT = 'power_audit_qwen3.5_8k1k_fp8_dynamo-sglang_x';
+const RESULT = 'qwen3.5_8k1k_fp8_dynamo-sglang_x_sa-bench_isl_8192_osl_1024';
+
+/** `<hostname>/<GPU-uuid>` ids of the 2 × 2 synthetic cluster. */
+const A0 = 'cn01/GPU-a0';
+const A1 = 'cn01/GPU-a1';
+const B0 = 'cn02/GPU-b0';
+const B1 = 'cn02/GPU-b1';
+
+const HEADER = 'schema_version,timestamp_unix,scrape_seq,hostname,gpu_index,gpu_uuid,power_w';
+
+function sample(time: number, device: string, power: number): string {
+  const [hostname, uuid] = device.split('/');
+  const gpuIndex = uuid.endsWith('0') ? 0 : 1;
+  return `1,${time},7,${hostname},${gpuIndex},${uuid},${power}`;
+}
+
+/** Every device sampled once per whole second in `[from, to]`, in scrambled device order. */
+function tick(time: number, watts: Record<string, number>): string[] {
+  return [B1, A1, B0, A0].map((device) => sample(time, device, watts[device]));
+}
+
+const WATTS = { [A0]: 100, [A1]: 110, [B0]: 200, [B1]: 50 };
+
+/** Window 1 at 1000–1010 s, window 2 at 2000–2010 s; nothing near window 3 at 5000 s. */
+const SAMPLES = [
+  HEADER,
+  // Just outside the 60 s pad of window 1.
+  ...tick(1000 - BUNDLE_WINDOW_PAD_SECONDS - 1, WATTS),
+  // Pad boundaries and the window itself.
+  ...tick(1000 - BUNDLE_WINDOW_PAD_SECONDS, WATTS),
+  ...tick(1000, WATTS),
+  ...tick(1005.4, { [A0]: 300, [A1]: 310, [B0]: 400, [B1]: 60 }),
+  ...tick(1010, WATTS),
+  ...tick(1010 + BUNDLE_WINDOW_PAD_SECONDS, WATTS),
+  ...tick(1010 + BUNDLE_WINDOW_PAD_SECONDS + 1, WATTS),
+  // Window 2, sampled by three devices only.
+  sample(2000, A1, 120),
+  sample(2000, A0, 130),
+  sample(2000, B0, 220),
+  sample(2001, A1, 121),
+  sample(2001, A0, 131),
+  sample(2001, B0, 221),
+  // Malformed rows: short line, non-numeric power, blank power (`Number('')`
+  // is 0), blank gpu_index, blank line.
+  '1,2002,7,cn01',
+  `1,2002,7,cn01,0,GPU-a0,N/A`,
+  `1,2002,7,cn01,0,GPU-a0,`,
+  `1,2002,7,cn01, ,GPU-a0,55`,
+  '',
+].join('\n');
+
+const MANIFEST = JSON.stringify({
+  schema_version: 1,
+  producer: 'srt-slurm.dcgm-power',
+  expected_devices: [
+    { hostname: 'cn01', gpu_index: 0, assignments: [{ worker_role: 'prefill' }] },
+    { hostname: 'cn01', gpu_index: 1, assignments: [{ worker_role: 'prefill' }] },
+    { hostname: 'cn02', gpu_index: 0, assignments: [{ worker_role: 'decode' }] },
+    { hostname: 'cn02', gpu_index: 1, assignments: [] },
+  ],
+});
+
+function validationName(conc: number): string {
+  return `power_validation_${RESULT}_conc${conc}_gpus_4_ctx_2_gen_2.json`;
+}
+
+/** Window 1: roles from `per_gpu_role`, where cn02/GPU-b0 is a prefill worker and GPU-b1 is unassigned. */
+const VALIDATION_1 = JSON.stringify({
+  schema_version: 1,
+  benchmark_window: { start_time_unix: 900, end_time_unix: 1100 },
+  selected_window: { concurrency: 1, start_time_unix: 1000, end_time_unix: 1010 },
+  per_gpu_role: { [A0]: 'decode', [A1]: 'prefill', [B0]: 'prefill' },
+});
+
+/** Window 2: no `per_gpu_role` and no `selected_window`, so the manifest and `benchmark_window` apply. */
+const VALIDATION_2 = JSON.stringify({
+  schema_version: 1,
+  benchmark_window: { start_time_unix: 2000, end_time_unix: 2010 },
+});
+
+/** Window 3: valid, but no sample lands within the pad. */
+const VALIDATION_3 = JSON.stringify({
+  selected_window: { concurrency: 3, start_time_unix: 5000, end_time_unix: 5010 },
+});
+
+function bundle(overrides: Record<string, string | undefined> = {}): Map<string, string> {
+  const files = new Map<string, string | undefined>([
+    [validationName(3), VALIDATION_3],
+    [validationName(1), VALIDATION_1],
+    [BUNDLE_SAMPLES_ENTRY, SAMPLES],
+    [BUNDLE_MANIFEST_ENTRY, MANIFEST],
+    [validationName(2), VALIDATION_2],
+  ]);
+  for (const [name, text] of Object.entries(overrides)) files.set(name, text);
+  const present = new Map<string, string>();
+  for (const [name, text] of files) if (text !== undefined) present.set(name, text);
+  return present;
+}
+
+describe('cutPowerAuditBundle', () => {
+  it('orders rows prefill, decode, unassigned, then by hostname and gpu_index', () => {
+    const [first] = cutPowerAuditBundle(ARTIFACT, bundle());
+    expect(first.devices).toEqual([
+      { id: A1, role: 'prefill' },
+      { id: B0, role: 'prefill' },
+      { id: A0, role: 'decode' },
+      { id: B1 },
+    ]);
+    expect(first.gpus).toEqual([0, 1, 2, 3]);
+    expect(first.power).toHaveLength(4);
+    // Row order is the device order: A1 reads 110 W, then 310 W in the window.
+    expect(first.power[0][1]).toBe(110);
+    expect(first.power[0][2]).toBe(310);
+    expect(first.power[3][2]).toBe(60);
+  });
+
+  it('clips samples to the window plus the pad on both sides', () => {
+    const [first] = cutPowerAuditBundle(ARTIFACT, bundle());
+    expect(first.startMs).toBe((1000 - BUNDLE_WINDOW_PAD_SECONDS) * 1000);
+    expect(first.t).toEqual([0, 60, 65, 70, 130]);
+    // 1005.4 s lands in the 1005 s bucket; the malformed 2002 s rows never appear.
+    expect(first.power[2]).toEqual([100, 100, 300, 100, 100]);
+  });
+});
+
+describe('parsePowerCsvData', () => {
+  const NVIDIA_CSV = [
+    'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+    '2026/09/11 04:19:41.123, 0, 350.5 W, 60, 1980 MHz, 2619 MHz, 90 %, 50 %',
+  ].join('\n');
+
+  it('normalizes UTC and missing collector context to ISO UTC like the stored path', () => {
+    // A zone-less stamp left as-is would be parsed as browser-local by `new Date`.
+    for (const context of [null, { timestamp_timezone: 'UTC' }, { timestamp_timezone: '+00:00' }]) {
+      expect(parsePowerCsvData(NVIDIA_CSV, context).map((row) => row.timestamp)).toEqual([
+        '2026-09-11T04:19:41.123Z',
+      ]);
+    }
+  });
+
+  it('applies a non-zero collector offset', () => {
+    expect(
+      parsePowerCsvData(NVIDIA_CSV, { timestamp_timezone: '+08:00' }).map((row) => row.timestamp),
+    ).toEqual(['2026-09-10T20:19:41.123Z']);
+  });
+
+  it('leaves ISO timestamps untouched', () => {
+    const iso = NVIDIA_CSV.replace('2026/09/11 04:19:41.123', '2026-09-11T04:19:41.123Z');
+    expect(parsePowerCsvData(iso, { timestamp_timezone: 'UTC' })[0]?.timestamp).toBe(
+      '2026-09-11T04:19:41.123Z',
+    );
+  });
+});
diff --git a/packages/app/src/components/gpu-power/power-audit-bundle.ts b/packages/app/src/components/gpu-power/power-audit-bundle.ts
new file mode 100644
index 000000000..063972401
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-audit-bundle.ts
@@ -0,0 +1,373 @@
+/**
+ * Cuts per-config power series out of a `power_audit_<RESULT_FILENAME>` bundle.
+ *
+ * Slurm / Dynamo disaggregated runners do not publish one `gpu_metrics_*` CSV
+ * per config. Their DCGM collector writes one bundle per concurrency sweep:
+ * `LOGS/power/samples.csv` holds ~1 Hz watts for every GPU across the whole
+ * sweep, `LOGS/power/manifest.json` names the devices and their worker role,
+ * and one top-level `power_validation_*.json` per concurrency records the
+ * validated measurement window. Each validation file becomes one
+ * `GpuPowerSeries` whose `source` is that file's basename, so the timeline
+ * joins it to the chart row carrying the same `power_audit.source`.
+ *
+ * Pure: the route hands over the extracted entry texts; nothing here reads
+ * the network or the zip.
+ */
+import { parseNvidiaTimestamp } from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
+import {
+  isPowerAuditValidationEntry,
+  normalizePowerAuditValidations,
+} from '@semianalysisai/inferencex-db/etl/power-audit-validations';
+
+import {
+  bucketPowerSeries,
+  parseTelemetryTimestampUtc,
+  type GpuPowerDevice,
+  type GpuPowerRole,
+  type GpuPowerSeries,
+} from './power-series';
+import { parseCsvData, type GpuMetricRow } from './types';
+
+/** Seconds of telemetry kept on each side of a validated window (ramp-up / drain context). */
+export const BUNDLE_WINDOW_PAD_SECONDS = 60;
+
+export const BUNDLE_SAMPLES_ENTRY = 'LOGS/power/samples.csv';
+export const BUNDLE_MANIFEST_ENTRY = 'LOGS/power/manifest.json';
+
+/** Zip entries the route must extract for `cutPowerAuditBundle`; everything else stays compressed. */
+export function isPowerAuditBundleEntry(entryName: string): boolean {
+  return (
+    entryName === BUNDLE_SAMPLES_ENTRY ||
+    entryName === BUNDLE_MANIFEST_ENTRY ||
+    isPowerAuditValidationEntry(entryName) ||
+    isSmiCsv(entryName) ||
+    isContextEntry(entryName)
+  );
+}
+
+function isSmiCsv(name: string): boolean {
+  return /(?:^|\/)gpu_metrics[^/]*\.csv$/u.test(name) && !/_(?:identity|energy_)/u.test(name);
+}
+
+function isContextEntry(entryName: string): boolean {
+  const name = basename(entryName);
+  return name.includes('gpu_metrics') && name.toLowerCase().endsWith('_context.json');
+}
+
+export interface PowerAuditSample {
+  /** Unix seconds. */
+  time: number;
+  deviceId: string;
+  power: number;
+}
+
+export interface PowerAuditDevice {
+  /** `<hostname>/<GPU-uuid>`, the form `power_audit.observed_gpu_ids` uses. */
+  id: string;
+  hostname: string;
+  gpuIndex: number;
+}
+
+interface ParsedSamples {
+  samples: PowerAuditSample[];
+  /** Devices in first-seen order. */
+  devices: Map<string, PowerAuditDevice>;
+}
+
+const SAMPLE_COLUMNS = ['timestamp_unix', 'hostname', 'gpu_index', 'gpu_uuid', 'power_w'] as const;
+
+const NUMERIC_CELL = /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/iu;
+
+/** A CSV cell as a number, or NaN for anything that is not a plain numeral (`Number('')` is 0). */
+function numericCell(cell: string): number {
+  const text = cell.trim();
+  return NUMERIC_CELL.test(text) ? Number(text) : Number.NaN;
+}
+
+function splitCsvLines(text: string): string[] {
+  return text.split('\n').map((line) => (line.endsWith('\r') ? line.slice(0, -1) : line));
+}
+
+/** Header-driven parse of `samples.csv`; malformed rows are skipped. */
+function parseSamples(csv: string): ParsedSamples {
+  const lines = splitCsvLines(csv);
+  const headerIndex = lines.findIndex((line) => line.trim().length > 0);
+  const empty: ParsedSamples = { samples: [], devices: new Map() };
+  if (headerIndex === -1) return empty;
+  const header = lines[headerIndex].split(',').map((cell) => cell.trim());
+  const columns = SAMPLE_COLUMNS.map((name) => header.indexOf(name));
+  if (columns.includes(-1)) return empty;
+  const [timeCol, hostCol, indexCol, uuidCol, powerCol] = columns;
+  const width = Math.max(...columns) + 1;
+
+  const samples: PowerAuditSample[] = [];
+  const devices = new Map<string, PowerAuditDevice>();
+  for (const line of lines.slice(headerIndex + 1)) {
+    const cells = line.split(',');
+    if (cells.length < width) continue;
+    const time = numericCell(cells[timeCol]);
+    const power = numericCell(cells[powerCol]);
+    const gpuIndex = numericCell(cells[indexCol]);
+    const hostname = cells[hostCol].trim();
+    const uuid = cells[uuidCol].trim();
+    if (
+      !Number.isFinite(time) ||
+      !Number.isFinite(power) ||
+      !Number.isInteger(gpuIndex) ||
+      hostname.length === 0 ||
+      uuid.length === 0
+    ) {
+      continue;
+    }
+    const deviceId = `${hostname}/${uuid}`;
+    if (!devices.has(deviceId)) devices.set(deviceId, { id: deviceId, hostname, gpuIndex });
+    samples.push({ time, deviceId, power });
+  }
+  return { samples, devices };
+}
+
+function asRole(value: unknown): GpuPowerRole | undefined {
+  return value === 'prefill' || value === 'decode' ? value : undefined;
+}
+
+function parseJsonObject(text: string | undefined): Record<string, unknown> | null {
+  if (text === undefined) return null;
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function manifestSlot(hostname: string, gpuIndex: number): string {
+  return `${hostname}#${gpuIndex}`;
+}
+
+/** `expected_devices[].assignments[0].worker_role`, keyed by hostname + gpu_index. */
+function manifestRoles(manifest: Record<string, unknown> | null): Map<string, GpuPowerRole> {
+  const roles = new Map<string, GpuPowerRole>();
+  const expected = manifest?.expected_devices;
+  if (!Array.isArray(expected)) return roles;
+  for (const device of expected) {
+    if (!isRecord(device)) continue;
+    const { hostname, gpu_index: gpuIndex, assignments } = device;
+    if (
+      typeof hostname !== 'string' ||
+      typeof gpuIndex !== 'number' ||
+      !Array.isArray(assignments)
+    ) {
+      continue;
+    }
+    const first: unknown = assignments[0];
+    const role = isRecord(first) ? asRole(first.worker_role) : undefined;
+    if (role) roles.set(manifestSlot(hostname, gpuIndex), role);
+  }
+  return roles;
+}
+
+interface TimeWindow {
+  start: number;
+  end: number;
+}
+
+/** `selected_window`, else `benchmark_window`; `null` when neither has a finite range. */
+function validationWindow(validation: Record<string, unknown>): TimeWindow | null {
+  for (const key of ['selected_window', 'benchmark_window']) {
+    const window = validation[key];
+    if (!isRecord(window)) continue;
+    const start = window.start_time_unix;
+    const end = window.end_time_unix;
+    if (
+      typeof start === 'number' &&
+      typeof end === 'number' &&
+      Number.isFinite(start) &&
+      Number.isFinite(end) &&
+      end >= start
+    ) {
+      return { start, end };
+    }
+  }
+  return null;
+}
+
+const ROLE_ORDER: Record<GpuPowerRole, number> = { prefill: 0, decode: 1 };
+
+function roleRank(role: GpuPowerRole | undefined): number {
+  return role ? ROLE_ORDER[role] : 2;
+}
+
+function compareText(a: string, b: string): number {
+  if (a < b) return -1;
+  return a > b ? 1 : 0;
+}
+
+/** Prefill, then decode, then unassigned; within a role by hostname, then gpu_index. */
+function orderDevices(
+  devices: readonly GpuPowerDevice[],
+  byId: ReadonlyMap<string, PowerAuditDevice>,
+) {
+  return devices.toSorted((a, b) => {
+    const rank = roleRank(a.role) - roleRank(b.role);
+    if (rank !== 0) return rank;
+    const deviceA = byId.get(a.id)!;
+    const deviceB = byId.get(b.id)!;
+    return compareText(deviceA.hostname, deviceB.hostname) || deviceA.gpuIndex - deviceB.gpuIndex;
+  });
+}
+
+function basename(entryName: string): string {
+  return entryName.slice(entryName.lastIndexOf('/') + 1);
+}
+
+/**
+ * Normalize NVIDIA's unzoned wall-clock timestamps to ISO UTC, matching the ingest
+ * parser: the adjacent collector context supplies the offset and missing or UTC
+ * context means zero. Live and stored reads then agree, so a run does not shift by
+ * the browser timezone before ingest. ISO and AMD timestamps pass through unchanged.
+ */
+export function parsePowerCsvData(
+  text: string,
+  context: Record<string, unknown> | null,
+): GpuMetricRow[] {
+  const zone = context?.timestamp_timezone;
+  const offset =
+    typeof zone === 'string'
+      ? /^(?<sign>[+-])(?<h>\d{2}):?(?<m>\d{2})$/u.exec(zone.trim())?.groups
+      : null;
+  const offsetMinutes = offset
+    ? (offset.sign === '-' ? -1 : 1) * (Number(offset.h) * 60 + Number(offset.m))
+    : 0;
+  return parseCsvData(text).map((row) => {
+    const timestamp = parseNvidiaTimestamp(row.timestamp, offsetMinutes);
+    return timestamp === null ? row : { ...row, timestamp: new Date(timestamp).toISOString() };
+  });
+}
+
+/**
+ * One series per validation file that has a window and samples within
+ * `BUNDLE_WINDOW_PAD_SECONDS` of it. Rows follow `devices`, ordered prefill,
+ * decode, unassigned (hostname, then gpu_index inside a role); `gpus` are the
+ * row indices `0..n-1`. Roles come from the validation's `per_gpu_role`, else
+ * the manifest's `expected_devices`. Malformed JSON skips that file; a
+ * missing or empty `samples.csv` yields `[]`. Output is ordered by window start.
+ */
+export function cutPowerAuditBundle(
+  artifact: string,
+  files: ReadonlyMap<string, string>,
+): GpuPowerSeries[] {
+  const validations = normalizePowerAuditValidations(artifact, files);
+  const manifest = parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY));
+  const contextFiles = [...files]
+    .filter(([name]) => isContextEntry(name))
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+  const smiFiles = [...files]
+    .filter(([name]) => isSmiCsv(name))
+    .map(([name, text]) => {
+      const directory = name.slice(0, name.lastIndexOf('/') + 1);
+      let context: Record<string, unknown> | null = null;
+      for (const [entry, contents] of contextFiles) {
+        if (entry.slice(0, entry.lastIndexOf('/') + 1) !== directory) continue;
+        context = parseJsonObject(contents);
+        if (context) break;
+      }
+      const data = parsePowerCsvData(text, context);
+      return { name, data };
+    })
+    .filter((file) => file.data.length > 0);
+  // Ingest prefers the richer SMI CSV when the bundle carries both collectors.
+  if (smiFiles.length > 0) return cutPowerAuditCsvs(artifact, smiFiles, validations, manifest);
+  const samplesText = files.get(BUNDLE_SAMPLES_ENTRY);
+  if (samplesText === undefined) return [];
+  const { samples, devices } = parseSamples(samplesText);
+  if (samples.length === 0) return [];
+  return cutPowerAuditSamples(
+    artifact,
+    samples,
+    devices,
+    validations,
+    parseJsonObject(files.get(BUNDLE_MANIFEST_ENTRY)),
+  );
+}
+
+/** Apply bundle window cuts to the richer SMI CSVs without requiring DCGM UUID sidecars. */
+export function cutPowerAuditCsvs(
+  artifact: string,
+  files: readonly { name: string; data: readonly GpuMetricRow[] }[],
+  validations: ReadonlyMap<string, Record<string, unknown>>,
+  manifest: Record<string, unknown> | null,
+): GpuPowerSeries[] {
+  const populated = files.filter((file) => file.data.length > 0);
+  const devices = new Map<string, PowerAuditDevice>();
+  const samples: PowerAuditSample[] = [];
+  for (const file of populated) {
+    for (const row of file.data) {
+      const id = populated.length === 1 ? String(row.index) : `${file.name}/${row.index}`;
+      devices.set(id, { id, hostname: file.name, gpuIndex: row.index });
+      const time = parseTelemetryTimestampUtc(row.timestamp);
+      if (time !== null) samples.push({ deviceId: id, time: time / 1000, power: row.power });
+    }
+  }
+  return cutPowerAuditSamples(artifact, samples, devices, validations, manifest);
+}
+
+/** The same window/device/bucketing transform for persisted samples and artifact CSVs. */
+export function cutPowerAuditSamples(
+  artifact: string,
+  samples: readonly PowerAuditSample[],
+  devices: ReadonlyMap<string, PowerAuditDevice>,
+  validations: ReadonlyMap<string, Record<string, unknown>>,
+  manifest: Record<string, unknown> | null,
+): GpuPowerSeries[] {
+  const fallbackRoles = manifestRoles(manifest);
+  const cut: { start: number; series: GpuPowerSeries }[] = [];
+  for (const [entryName, validation] of validations) {
+    const window = validationWindow(validation);
+    if (!window) continue;
+
+    const lo = window.start - BUNDLE_WINDOW_PAD_SECONDS;
+    const hi = window.end + BUNDLE_WINDOW_PAD_SECONDS;
+    const inRange = samples.filter((sample) => sample.time >= lo && sample.time <= hi);
+    if (inRange.length === 0) continue;
+
+    const explicitRoles = isRecord(validation.per_gpu_role) ? validation.per_gpu_role : {};
+    const present = [...new Set(inRange.map((sample) => sample.deviceId))].map((id) => {
+      const device = devices.get(id)!;
+      const role =
+        asRole(explicitRoles[id]) ??
+        fallbackRoles.get(manifestSlot(device.hostname, device.gpuIndex));
+      return role ? { id, role } : { id };
+    });
+    const ordered = orderDevices(present, devices);
+    const rowOf = new Map(ordered.map((device, row) => [device.id, row]));
+
+    const rows: GpuMetricRow[] = inRange.map((sample) => ({
+      timestamp: String(sample.time),
+      index: rowOf.get(sample.deviceId)!,
+      power: sample.power,
+    }));
+    const series = bucketPowerSeries(artifact, rows);
+    if (!series) continue;
+    // The synthetic `index` is the device's position in `ordered`, so each
+    // bucketed row maps back to its device; `gpus` becomes plain row indices.
+    cut.push({
+      start: window.start,
+      series: {
+        ...series,
+        artifact,
+        source: basename(entryName),
+        gpus: series.gpus.map((_, row) => row),
+        devices: series.gpus.map((row) => ordered[row]),
+      },
+    });
+  }
+  return cut
+    .toSorted((a, b) => a.start - b.start || compareText(a.series.source!, b.series.source!))
+    .map((entry) => entry.series);
+}
diff --git a/packages/app/src/components/gpu-power/power-series.test.ts b/packages/app/src/components/gpu-power/power-series.test.ts
new file mode 100644
index 000000000..4b5a0fd91
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-series.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  bucketPowerSeries,
+  bucketPowerFiles,
+  bucketTimeMs,
+  meanPowerAt,
+  sumPowerAt,
+  type GpuPowerSeries,
+} from './power-series';
+import type { GpuMetricRow } from './types';
+
+function row(timestamp: string, index: number, power: number): GpuMetricRow {
+  return {
+    timestamp,
+    index,
+    power,
+    temperature: 40,
+    smClock: 1,
+    memClock: 1,
+    gpuUtil: 0,
+    memUtil: 0,
+  };
+}
+
+describe('bucketPowerSeries', () => {
+  it('aligns every GPU on one-second buckets and marks missing samples null', () => {
+    const rows = [
+      row('2026/09/12 20:20:41.817', 0, 194.4),
+      row('2026/09/12 20:20:41.820', 1, 192.4),
+      row('2026/09/12 20:20:42.816', 0, 300),
+      // GPU 1 skipped this tick; GPU 0 sampled twice in the next one.
+      row('2026/09/12 20:20:43.815', 0, 400),
+      row('2026/09/12 20:20:43.900', 0, 500),
+      row('2026/09/12 20:20:43.818', 1, 350),
+    ];
+    const series = bucketPowerSeries('gpu_metrics_test', rows);
+    expect(series).not.toBeNull();
+    expect(series!.startMs).toBe(Date.UTC(2026, 8, 12, 20, 20, 41));
+    expect(series!.bucketSeconds).toBe(1);
+    expect(series!.gpus).toEqual([0, 1]);
+    expect(series!.t).toEqual([0, 1, 2]);
+    expect(series!.power).toEqual([
+      [194.4, 300, 450],
+      [192.4, null, 350],
+    ]);
+    expect(meanPowerAt(series!, 1)).toBe(300);
+    expect(meanPowerAt(series!, 2)).toBe(400);
+    expect(bucketTimeMs(series!, 2)).toBe(Date.UTC(2026, 8, 12, 20, 20, 43));
+  });
+});
+
+describe('sumPowerAt', () => {
+  const series: GpuPowerSeries = {
+    artifact: 'power_audit_sweep',
+    startMs: Date.UTC(2026, 8, 12, 20, 0, 0),
+    bucketSeconds: 1,
+    gpus: [0, 1, 2],
+    t: [0, 1, 2],
+    power: [
+      [100, null, 300],
+      [50, 60, null],
+      [10, null, null],
+    ],
+  };
+
+  it('returns null for a partial pool, an unsampled bucket, an empty pool or an unknown row', () => {
+    // GPU 0 and 2 have no sample in bucket 1: a partial sum would read as a dip.
+    expect(sumPowerAt(series, [0, 1, 2], 1)).toBeNull();
+    expect(sumPowerAt(series, [0, 1], 2)).toBeNull();
+    expect(sumPowerAt(series, [0, 2], 1)).toBeNull();
+    expect(sumPowerAt(series, [], 0)).toBeNull();
+    expect(sumPowerAt(series, [7], 0)).toBeNull();
+  });
+});
+
+describe('bucketPowerFiles', () => {
+  it('keeps repeated GPU indices from different host files separate with stable identity', () => {
+    const time = '2026-09-12T04:00:00Z';
+    const files = [
+      { name: 'host-b/gpu_metrics.csv', data: [row(time, 0, 500)] },
+      { name: 'host-a/gpu_metrics.csv', data: [row(time, 0, 100), row(time, 2, 200)] },
+      { name: 'empty.csv', data: [] },
+    ];
+    const expected = {
+      artifact: 'gpu_metrics_multinode',
+      startMs: Date.parse(time),
+      bucketSeconds: 1,
+      gpus: [0, 1, 2],
+      t: [0],
+      power: [[100], [200], [500]],
+      devices: [
+        { id: 'host-a/gpu_metrics.csv/0' },
+        { id: 'host-a/gpu_metrics.csv/2' },
+        { id: 'host-b/gpu_metrics.csv/0' },
+      ],
+    };
+    expect(bucketPowerFiles('gpu_metrics_multinode', files)).toEqual(expected);
+    expect(bucketPowerFiles('gpu_metrics_multinode', files.toReversed())).toEqual(expected);
+    expect(bucketPowerFiles('empty', [])).toBeNull();
+    expect(bucketPowerFiles('single', [files[0]])?.gpus).toEqual([0]);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/power-series.ts b/packages/app/src/components/gpu-power/power-series.ts
new file mode 100644
index 000000000..8ff75fabb
--- /dev/null
+++ b/packages/app/src/components/gpu-power/power-series.ts
@@ -0,0 +1,212 @@
+/**
+ * Compact per-GPU power series for the PowerX timeline.
+ *
+ * A `gpu_metrics_<RESULT_FILENAME>` artifact carries ~1 Hz samples for every
+ * GPU of one benchmark config (server start, warmup, and the measured window).
+ * The raw rows are heavy (a 25-config run is ~27 MB of JSON), so the API can
+ * return this columnar shape instead: one row of watts per GPU, aligned on
+ * fixed-width time buckets, with `null` where a GPU had no sample.
+ *
+ * Runner timestamps are UTC wall clock (`2026/09/12 20:19:57.158`); the
+ * validated measurement window in `power_audit` is UTC epoch seconds, so the
+ * two line up without a timezone guess.
+ */
+import type { GpuMetricRow, GpuPowerRunInfo } from './types';
+
+/** Worker role a GPU served, when the collector's manifest assigns one. */
+export type GpuPowerRole = 'prefill' | 'decode';
+
+export interface GpuPowerDevice {
+  /**
+   * Producer device identifier: the nvidia-smi / amd-smi index (`"3"`) for
+   * `gpu_metrics_*` CSVs, `<hostname>/<GPU-uuid>` for DCGM power-audit
+   * bundles — the same form as `power_audit.observed_gpu_ids` on the row.
+   */
+  id: string;
+  role?: GpuPowerRole;
+}
+
+export interface GpuPowerSeries {
+  /** GitHub artifact name: `gpu_metrics_<RESULT_FILENAME>` or `power_audit_<RESULT_FILENAME>`. */
+  artifact: string;
+  /**
+   * Basename of the `power_validation_*.json` this series belongs to, for
+   * series cut from a power-audit bundle (one bundle holds a whole
+   * concurrency sweep). Absent for `gpu_metrics_*` series, whose artifact
+   * already names one config.
+   */
+  source?: string;
+  /** UTC epoch milliseconds of bucket 0. */
+  startMs: number;
+  /** Bucket width in seconds. */
+  bucketSeconds: number;
+  /** GPU indices, one per row of `power`, ascending. */
+  gpus: number[];
+  /** Seconds since `startMs` for each bucket, ascending. */
+  t: number[];
+  /** Watts per GPU (outer) per bucket (inner); `null` when no sample landed in the bucket. */
+  power: (number | null)[][];
+  /** One entry per row of `power` when the collector reports device identity or roles. */
+  devices?: GpuPowerDevice[];
+}
+
+export interface GpuPowerSeriesResponse {
+  runInfo: GpuPowerRunInfo;
+  series: GpuPowerSeries[];
+  /** Coverage of requested validation identities only, never the full run/sweep. */
+  sourceCoverage?: {
+    status: 'complete' | 'incomplete' | 'unknown';
+    missingSources: string[];
+  };
+}
+
+const RUNNER_TIMESTAMP =
+  /^(?<y>\d{4})[/-](?<mo>\d{2})[/-](?<d>\d{2})[ T](?<h>\d{2}):(?<mi>\d{2}):(?<s>\d{2})(?:\.(?<ms>\d{1,6}))?$/u;
+
+/**
+ * Parses a runner telemetry timestamp as UTC epoch milliseconds.
+ *
+ * nvidia-smi / amd-smi write `YYYY/MM/DD HH:MM:SS.mmm` without a zone; the
+ * collectors run in UTC, and `new Date(...)` would read that as browser local
+ * time, so the digits are assembled explicitly. ISO strings with a zone and
+ * numeric epochs (seconds or milliseconds) are accepted as-is.
+ */
+export function parseTelemetryTimestampUtc(raw: string): number | null {
+  const text = raw.trim();
+  const match = RUNNER_TIMESTAMP.exec(text);
+  if (match?.groups) {
+    const { y, mo, d, h, mi, s, ms } = match.groups;
+    const millis = ms ? Math.round(Number(`0.${ms}`) * 1000) : 0;
+    return Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s), millis);
+  }
+  if (/^\d+(?:\.\d+)?$/u.test(text)) {
+    const numeric = Number(text);
+    return numeric < 1e12 ? Math.round(numeric * 1000) : Math.round(numeric);
+  }
+  const parsed = Date.parse(text);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+/**
+ * Buckets raw per-GPU rows into the compact series. Samples of one GPU that
+ * share a bucket are averaged; repeated GPU/timestamps keep the first sample,
+ * matching ingest. Buckets nobody sampled are omitted from `t`.
+ * Returns `null` when no row carries a parseable timestamp.
+ */
+export function bucketPowerSeries(
+  artifact: string,
+  rows: readonly GpuMetricRow[],
+  bucketSeconds = 1,
+): GpuPowerSeries | null {
+  if (!(bucketSeconds > 0)) throw new RangeError('bucketSeconds must be positive');
+  const bucketMs = bucketSeconds * 1000;
+  let startMs = Number.POSITIVE_INFINITY;
+  const parsed: { ms: number; gpu: number; power: number }[] = [];
+  const seen = new Set<string>();
+  for (const row of rows) {
+    if (!Number.isFinite(row.power) || !Number.isInteger(row.index)) continue;
+    const ms = parseTelemetryTimestampUtc(row.timestamp);
+    if (ms === null) continue;
+    const key = `${row.index}:${ms}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    parsed.push({ ms, gpu: row.index, power: row.power });
+    if (ms < startMs) startMs = ms;
+  }
+  if (parsed.length === 0) return null;
+  startMs = Math.floor(startMs / bucketMs) * bucketMs;
+
+  const gpus = [...new Set(parsed.map((sample) => sample.gpu))].toSorted((a, b) => a - b);
+  const gpuRow = new Map(gpus.map((gpu, row) => [gpu, row]));
+  // bucket index -> per GPU [sum, count]
+  const buckets = new Map<number, [number, number][]>();
+  for (const sample of parsed) {
+    const bucket = Math.floor((sample.ms - startMs) / bucketMs);
+    let cells = buckets.get(bucket);
+    if (!cells) {
+      cells = gpus.map(() => [0, 0]);
+      buckets.set(bucket, cells);
+    }
+    const cell = cells[gpuRow.get(sample.gpu)!];
+    cell[0] += sample.power;
+    cell[1] += 1;
+  }
+  const bucketIndices = [...buckets.keys()].toSorted((a, b) => a - b);
+  const power: (number | null)[][] = gpus.map(() =>
+    Array.from({ length: bucketIndices.length }, (): number | null => null),
+  );
+  bucketIndices.forEach((bucket, column) => {
+    const cells = buckets.get(bucket)!;
+    cells.forEach(([sum, count], row) => {
+      power[row][column] = count > 0 ? Math.round((sum / count) * 100) / 100 : null;
+    });
+  });
+  return {
+    artifact,
+    startMs,
+    bucketSeconds,
+    gpus,
+    t: bucketIndices.map((bucket) => bucket * bucketSeconds),
+    power,
+  };
+}
+
+/** Keep host-local GPU indices distinct when one artifact stages multiple CSVs. */
+export function bucketPowerFiles(
+  artifact: string,
+  files: readonly { name: string; data: readonly GpuMetricRow[] }[],
+): GpuPowerSeries | null {
+  const populated = files
+    .filter((file) => file.data.length > 0)
+    .toSorted((a, b) => a.name.localeCompare(b.name));
+  if (populated.length === 0) return null;
+  if (populated.length === 1) return bucketPowerSeries(artifact, populated[0].data);
+  const devices = populated.flatMap((file) =>
+    [...new Set(file.data.map((row) => row.index))]
+      .toSorted((a, b) => a - b)
+      .map((gpu) => ({ id: `${file.name}/${gpu}`, file, gpu })),
+  );
+  const rows = devices.flatMap(({ file, gpu }, index) =>
+    file.data.filter((row) => row.index === gpu).map((row) => ({ ...row, index })),
+  );
+  const bucketed = bucketPowerSeries(artifact, rows);
+  return bucketed ? { ...bucketed, devices: devices.map(({ id }) => ({ id })) } : null;
+}
+
+/** Mean watts across the GPUs that have a sample in bucket `column`, or `null`. */
+export function meanPowerAt(series: GpuPowerSeries, column: number): number | null {
+  let sum = 0;
+  let count = 0;
+  for (const row of series.power) {
+    const value = row[column];
+    if (value === null || value === undefined) continue;
+    sum += value;
+    count += 1;
+  }
+  return count > 0 ? sum / count : null;
+}
+
+/**
+ * Summed watts over `rows` in bucket `column`, or `null` unless EVERY row has
+ * a sample: a pool total with a device missing would read as a dip against
+ * the pool's TDP, so the bucket is left as a gap instead.
+ */
+export function sumPowerAt(
+  series: GpuPowerSeries,
+  rows: readonly number[],
+  column: number,
+): number | null {
+  if (rows.length === 0) return null;
+  let sum = 0;
+  for (const row of rows) {
+    const value = series.power[row]?.[column];
+    if (value === null || value === undefined) return null;
+    sum += value;
+  }
+  return sum;
+}
+
+/** UTC epoch milliseconds of bucket `column`. */
+export function bucketTimeMs(series: GpuPowerSeries, column: number): number {
+  return series.startMs + series.t[column] * 1000;
+}
diff --git a/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts b/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
new file mode 100644
index 000000000..893b1ae2a
--- /dev/null
+++ b/packages/app/src/components/gpu-power/stored-gpu-stats.test.ts
@@ -0,0 +1,128 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  computeGpuMetricStats,
+  parseGpuMetricsCsv,
+  type GpuMetricSample,
+} from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
+import {
+  prepareGpuMetricsArtifact,
+  statMetricColumn,
+} from '@semianalysisai/inferencex-db/etl/gpu-metrics-ingest';
+
+import { storedGpuStatsForMetric } from './stored-gpu-stats';
+import { ALL_METRIC_OPTIONS, computeGpuStats, parseCsvData, type GpuMetricRow } from './types';
+
+function storedStats(samples: GpuMetricSample[]) {
+  return computeGpuMetricStats(samples).map((row) => ({
+    ...row,
+    metric: statMetricColumn(row.metric),
+  }));
+}
+
+function assertAllMetricStats(samples: GpuMetricSample[], rows: GpuMetricRow[]) {
+  const digest = storedStats(samples);
+  for (const { key } of ALL_METRIC_OPTIONS) {
+    const actual = storedGpuStatsForMetric(digest, key);
+    const expected = computeGpuStats(rows, key);
+    expect(actual, key).toHaveLength(expected.length);
+    for (const [index, row] of actual.entries()) {
+      expect(row.gpuIndex).toBe(expected[index].gpuIndex);
+      expect(row.count).toBe(expected[index].count);
+      // ETL sums sorted samples while the live reader sums recording order.
+      for (const field of ['min', 'max', 'mean', 'median', 'p95', 'p99', 'stddev'] as const) {
+        expect(row[field], `${key}.${field}`).toBeCloseTo(expected[index][field], 10);
+      }
+    }
+  }
+}
+
+describe('storedGpuStatsForMetric', () => {
+  it.each(['UTC', 'America/Los_Angeles'])(
+    'matches live NVIDIA and ingest populations across DST in %s',
+    (timezone) => {
+      const csv = [
+        'timestamp,index,power.draw [W]',
+        '2026/03/08 02:30:00.000,0,100',
+        '2026/03/08 02:30:00.000,0,900',
+        '2026/03/08 03:30:00.000,0,300',
+      ].join('\n');
+      const artifactDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gpu-stats-dst-'));
+      const originalTimezone = process.env.TZ;
+      try {
+        process.env.TZ = timezone;
+        fs.writeFileSync(path.join(artifactDir, 'gpu_metrics.csv'), csv);
+        const [prepared] = prepareGpuMetricsArtifact({
+          artifactDir,
+          artifactName: 'gpu_metrics_nvidia_dst',
+        });
+        expect(
+          prepared.samples.map((sample) => new Date(sample.timestampMs).toISOString()),
+        ).toEqual(['2026-03-08T02:30:00.000Z', '2026-03-08T03:30:00.000Z']);
+        const live = parseCsvData(csv);
+        // Preserve raw timestamps for the bundle's later context-offset adjustment.
+        expect(live.map((row) => row.timestamp)).toEqual([
+          '2026/03/08 02:30:00.000',
+          '2026/03/08 03:30:00.000',
+        ]);
+        expect(live.map((row) => row.power)).toEqual([100, 300]);
+        const actual = computeGpuStats(live, 'power');
+        expect(actual).toEqual([
+          {
+            gpuIndex: 0,
+            count: 2,
+            min: 100,
+            max: 300,
+            mean: 200,
+            median: 200,
+            p95: 290,
+            p99: 298,
+            stddev: 100,
+          },
+        ]);
+        const { metric: _metric, ...expected } = prepared.stats[0];
+        expect(actual).toEqual([expected]);
+      } finally {
+        if (originalTimezone === undefined) delete process.env.TZ;
+        else process.env.TZ = originalTimezone;
+        fs.rmSync(artifactDir, { recursive: true, force: true });
+      }
+    },
+  );
+
+  it('preserves NVIDIA units, zero readings, and full-record percentiles', () => {
+    const csv = [
+      'timestamp, index, power.draw [W], temperature.gpu, clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]',
+      '2026/09/21 00:00:00, 0, 0 W, N/A, 120 MHz, 3996 MHz, 0 %, 0 %',
+      '2026/09/21 00:00:01, 0, 912.1 W, 61, 1965 MHz, 3996 MHz, 98 %, 74 %',
+      '2026/09/21 00:00:02, 0, 187.8 W, 35, 120 MHz, 3996 MHz, 0 %, 0 %',
+      // Conflicting stop-time flush must not change the first reading.
+      '2026/09/21 00:00:02, 0, 999 W, 90, 120 MHz, 3996 MHz, 0 %, 0 %',
+    ].join('\n');
+    const samples = parseGpuMetricsCsv(csv)!.samples.slice(0, 3);
+    assertAllMetricStats(samples, parseCsvData(csv));
+    const [power] = storedGpuStatsForMetric(storedStats(samples), 'power');
+    expect(power.count).toBe(3);
+    expect(power.median).toBe(187.8);
+    expect(power.p95).toBeCloseTo(839.67, 10);
+    expect(power.p99).toBeCloseTo(897.614, 10);
+  });
+
+  it('maps every AMD metric without converting missing readings to zero', () => {
+    const csv = [
+      'timestamp,gpu,gfx_activity,umc_activity,mm_activity,socket_power,gfx_voltage,soc_voltage,mem_voltage,gfx_0_clk,mem_0_clk,fclk_0_clk,socclk_0_clk,edge,hotspot,mem',
+      '1789948800,0,0,0,N/A,0,N/A,N/A,N/A,N/A,2000,1250,39,N/A,N/A,24',
+      '1789948801,0,95,80,5,1180,850,900,1250,2402,2050,1300,40,55,78,60',
+      '1789948801,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0',
+    ].join('\n');
+    const samples = parseGpuMetricsCsv(csv)!.samples.slice(0, 2);
+    assertAllMetricStats(samples, parseCsvData(csv));
+    expect(storedGpuStatsForMetric(storedStats(samples), 'gfxVoltage')[0]).toMatchObject({
+      count: 1,
+      mean: 850,
+      stddev: 0,
+    });
+  });
+});
diff --git a/packages/app/src/components/gpu-power/stored-gpu-stats.ts b/packages/app/src/components/gpu-power/stored-gpu-stats.ts
new file mode 100644
index 000000000..5eda4d3b2
--- /dev/null
+++ b/packages/app/src/components/gpu-power/stored-gpu-stats.ts
@@ -0,0 +1,30 @@
+import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import type { GpuMetricKey, GpuStats } from './types';
+
+const STORED_METRIC: Record<GpuMetricKey, string> = {
+  power: 'power_w',
+  temperature: 'temperature_c',
+  smClock: 'sm_clock_mhz',
+  memClock: 'mem_clock_mhz',
+  gpuUtil: 'gpu_util_pct',
+  memUtil: 'mem_util_pct',
+  edgeTemp: 'edge_temp_c',
+  memTemp: 'mem_temp_c',
+  gfxVoltage: 'gfx_voltage_mv',
+  socVoltage: 'soc_voltage_mv',
+  memVoltage: 'mem_voltage_mv',
+  fclk: 'fclk_mhz',
+  socClk: 'socclk_mhz',
+  mmActivity: 'mm_activity_pct',
+};
+
+/** Full-record statistics, including startup/warmup; never a measured-window summary. */
+export function storedGpuStatsForMetric(
+  stats: readonly GpuMetricStatRow[],
+  metricKey: GpuMetricKey,
+): GpuStats[] {
+  return stats
+    .filter((row) => row.metric === STORED_METRIC[metricKey])
+    .map(({ metric: _metric, ...row }) => row);
+}
diff --git a/packages/app/src/components/gpu-power/stored-power-series.ts b/packages/app/src/components/gpu-power/stored-power-series.ts
new file mode 100644
index 000000000..964d44812
--- /dev/null
+++ b/packages/app/src/components/gpu-power/stored-power-series.ts
@@ -0,0 +1,168 @@
+import type { GpuMetricSeries } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import {
+  cutPowerAuditSamples,
+  cutPowerAuditCsvs,
+  type PowerAuditDevice,
+  type PowerAuditSample,
+} from './power-audit-bundle';
+import { bucketPowerFiles, type GpuPowerSeries } from './power-series';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export class StoredTelemetryIncompleteError extends Error {
+  readonly artifact: string;
+
+  constructor(artifact: string, reason: string) {
+    super(`${artifact}: ${reason}. Re-ingest this artifact for the same run and attempt.`);
+    this.name = 'StoredTelemetryIncompleteError';
+    this.artifact = artifact;
+  }
+}
+
+/** Compare storage against the original parsed artifact, not only surviving host rows. */
+function checkSeriesInventory(artifact: string, series: readonly GpuMetricSeries[]): void {
+  for (const entry of series) {
+    const inventory = entry.sidecars.seriesInventory;
+    if (!Array.isArray(inventory)) continue;
+    for (const expected of inventory) {
+      if (
+        !isRecord(expected) ||
+        typeof expected.fileName !== 'string' ||
+        typeof expected.sampleCount !== 'number'
+      )
+        continue;
+      const actual = series.find((candidate) => candidate.fileName === expected.fileName);
+      if (!actual || actual.data.length !== expected.sampleCount) {
+        throw new StoredTelemetryIncompleteError(
+          artifact,
+          `stored file/sample coverage is incomplete for ${expected.fileName}`,
+        );
+      }
+    }
+  }
+}
+
+/** Reconstruct only source/window evidence retained by the pre-validation ingest. */
+function storedValidations(series: readonly GpuMetricSeries[]) {
+  const validations = new Map<string, Record<string, unknown>>();
+  for (const entry of series) {
+    if (!isRecord(entry.sidecars.validations)) continue;
+    for (const [name, validation] of Object.entries(entry.sidecars.validations)) {
+      if (/^power_validation_[^/]+\.json$/u.test(name) && isRecord(validation)) {
+        validations.set(name, validation);
+      }
+    }
+  }
+  // New ingests carry the complete original documents, including role overrides.
+  // The legacy path has source + the selected serving window and manifest roles.
+  if (validations.size > 0) return validations;
+  for (const entry of series) {
+    for (const audit of entry.powerAudits ?? []) {
+      const { source, window_start_unix: start, window_end_unix: end } = audit;
+      if (
+        typeof source !== 'string' ||
+        typeof start !== 'number' ||
+        typeof end !== 'number' ||
+        !Number.isFinite(start) ||
+        !Number.isFinite(end) ||
+        end < start
+      )
+        continue;
+      const name = source.slice(source.lastIndexOf('/') + 1);
+      if (!/^power_validation_[^/]+\.json$/u.test(name)) continue;
+      validations.set(name, { selected_window: { start_time_unix: start, end_time_unix: end } });
+    }
+  }
+  return validations;
+}
+
+function storedBundle(artifact: string, series: readonly GpuMetricSeries[]): GpuPowerSeries[] {
+  const validations = storedValidations(series);
+  if (validations.size === 0)
+    throw new StoredTelemetryIncompleteError(artifact, 'validation window provenance is missing');
+  const smiFiles = series.filter((entry) => /(?:^|\/)gpu_metrics[^/]*\.csv$/u.test(entry.fileName));
+  if (smiFiles.length > 0) {
+    const manifest = smiFiles.find((entry) => isRecord(entry.sidecars.powerManifest))?.sidecars
+      .powerManifest;
+    return cutPowerAuditCsvs(
+      artifact,
+      smiFiles.map((entry) => ({ name: entry.fileName, data: entry.data })),
+      validations,
+      isRecord(manifest) ? manifest : null,
+    );
+  }
+  const devices = new Map<string, PowerAuditDevice>();
+  const samples: PowerAuditSample[] = [];
+  for (const entry of series) {
+    const identity = entry.sidecars.identity;
+    if (!Array.isArray(identity)) continue;
+    const ids = new Map<number, string>();
+    for (const item of identity) {
+      if (!isRecord(item)) continue;
+      const { hostname, gpu_index: gpuIndex, gpu_uuid: uuid } = item;
+      if (typeof hostname !== 'string' || typeof gpuIndex !== 'number' || typeof uuid !== 'string')
+        continue;
+      const id = `${hostname}/${uuid}`;
+      ids.set(gpuIndex, id);
+      devices.set(id, { id, hostname, gpuIndex });
+    }
+    for (const row of entry.data) {
+      const deviceId = ids.get(row.index);
+      if (!deviceId)
+        throw new StoredTelemetryIncompleteError(
+          artifact,
+          `device identity is missing for ${entry.fileName} GPU ${row.index}`,
+        );
+      samples.push({ deviceId, time: Date.parse(row.timestamp) / 1000, power: row.power });
+    }
+  }
+  const manifest = series.find((entry) => isRecord(entry.sidecars.context))?.sidecars.context;
+  const expectedDevices = isRecord(manifest) ? manifest.expected_devices : null;
+  if (Array.isArray(expectedDevices)) {
+    const slots = new Set(
+      [...devices.values()].map((device) => `${device.hostname}#${device.gpuIndex}`),
+    );
+    for (const expected of expectedDevices) {
+      if (
+        isRecord(expected) &&
+        typeof expected.hostname === 'string' &&
+        typeof expected.gpu_index === 'number' &&
+        !slots.has(`${expected.hostname}#${expected.gpu_index}`)
+      ) {
+        throw new StoredTelemetryIncompleteError(
+          artifact,
+          `expected device ${expected.hostname} GPU ${expected.gpu_index} is not stored`,
+        );
+      }
+    }
+  }
+  return cutPowerAuditSamples(
+    artifact,
+    samples,
+    devices,
+    validations,
+    isRecord(manifest) ? manifest : null,
+  );
+}
+
+/** Apply the artifact path's existing cuts and one-second means to persisted rows. */
+export function storedPowerSeries(series: readonly GpuMetricSeries[]): GpuPowerSeries[] {
+  const groups = new Map<string, GpuMetricSeries[]>();
+  for (const entry of series) {
+    const group = groups.get(entry.artifactName) ?? [];
+    group.push(entry);
+    groups.set(entry.artifactName, group);
+  }
+  return [...groups].flatMap(([artifact, entries]) => {
+    checkSeriesInventory(artifact, entries);
+    if (artifact.startsWith('power_audit_')) return storedBundle(artifact, entries);
+    const bucketed = bucketPowerFiles(
+      artifact,
+      entries.map((entry) => ({ name: entry.fileName, data: entry.data })),
+    );
+    return bucketed ? [bucketed] : [];
+  });
+}
diff --git a/packages/app/src/hooks/api/benchmark-id-query.ts b/packages/app/src/hooks/api/benchmark-id-query.ts
index d1540f1d8..0f9adf95b 100644
--- a/packages/app/src/hooks/api/benchmark-id-query.ts
+++ b/packages/app/src/hooks/api/benchmark-id-query.ts
@@ -49,6 +49,7 @@ export function useByIdQuery<T, TSelected = T>(
   id: number | null,
   enabled: boolean,
   select?: (data: T) => TSelected,
+  freshness?: { staleTime: number; refetchOnWindowFocus: boolean },
 ) {
   const selectNullable = useCallback(
     (data: T | null): TSelected | null =>
@@ -67,6 +68,7 @@ export function useByIdQuery<T, TSelected = T>(
     },
     enabled,
     staleTime: STALE_TIME_MS,
+    ...freshness,
     // TanStack Query re-runs select when its function identity changes. Keep
     // this wrapper stable so decoding a large compact payload happens only
     // when the cached wire data or the caller's selector actually changes.
diff --git a/packages/app/src/hooks/api/use-gpu-metrics-point.ts b/packages/app/src/hooks/api/use-gpu-metrics-point.ts
new file mode 100644
index 000000000..53ae1dbe8
--- /dev/null
+++ b/packages/app/src/hooks/api/use-gpu-metrics-point.ts
@@ -0,0 +1,24 @@
+import type {
+  GpuMetricsPointPayload,
+  GpuMetricSeries,
+  GpuMetricStatRow,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+import { useByIdQuery } from './benchmark-id-query';
+
+export type { GpuMetricsPointPayload, GpuMetricSeries, GpuMetricStatRow };
+
+/**
+ * Lazy-fetch the PowerX telemetry linked to one benchmark point. Enabled only
+ * while the PowerX detail view is open: a series is one 1 s sample per GPU for
+ * the whole job (hundreds of KB), so it is not paid for on every page load.
+ */
+export function useGpuMetricsPoint(id: number | null, enabled = false) {
+  return useByIdQuery<GpuMetricsPointPayload>(
+    'gpu-metrics-point',
+    id,
+    enabled && Boolean(id),
+    undefined,
+    { staleTime: 0, refetchOnWindowFocus: true },
+  );
+}
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 2f8a5ceb3..70c72a16b 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -115,7 +115,7 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'published-read',
     operationId: 'get-gpu-metrics-view',
-    sourceSha256: '34860f3f64e4070bf4c0bf390c3b61f34bdb98b673a90d119bae162226dc1edd',
+    sourceSha256: '9513c85ee406f390f73c15757ea30ad9d902b2ec0e39dde25a0e305def2ff7a2',
   },
   {
     source: 'src/app/api/v1/views/gpu-specs/route.ts',
@@ -275,10 +275,21 @@ export const apiRouteCatalog = [
     method: 'GET',
     classification: 'ui-artifact-read',
     exclusionReason: {
-      en: 'UI-only live GPU metric artifact lookup; its run artifact shape is not a stable public contract.',
-      zh: '仅供界面读取实时 GPU 指标制品；其运行制品结构不是稳定的公开契约。',
+      en: 'UI-only PowerX raw/series=power read: DB-first with artifact fallback, separate host/GPU identities and adjacent CSV context timezone normalization. GET has no expected identities and reports sourceCoverage unknown. Healthy stored windows survive fallback; known-incomplete CSVs require retained file/sample inventory and known-incomplete bundles require re-ingest. DB failures return 503 DATABASE_UNAVAILABLE; unresolved stored gaps return 503 STORED_TELEMETRY_INCOMPLETE. Responses use no-store. This is not a stable public API.',
+      zh: '仅供 PowerX 界面读取原始遥测或 series=power：优先 DB，缺失时回退产物，保留主机/GPU 身份，并按相邻 CSV context 规范化时区。GET 没有预期身份清单，sourceCoverage 为 unknown。回退保留健康存储窗口；已知不完整 CSV 须满足文件/样本清单，已知不完整 bundle 须重新 ingest。数据库故障返回 503 DATABASE_UNAVAILABLE，未恢复的存储缺口返回 503 STORED_TELEMETRY_INCOMPLETE。响应使用 no-store，不作为稳定公开 API。',
     },
-    sourceSha256: '28e6cee4d67396ee8ea2e5a7e18271c6ee86228c33f33a20bf573f3a601ba8ed',
+    sourceSha256: '80fd8ea1d462b2d47d42411d8361db72802943a94c7ffb91879244c69ef2c693',
+  },
+  {
+    source: 'src/app/api/gpu-metrics/route.ts',
+    path: '/api/gpu-metrics',
+    method: 'POST',
+    classification: 'ui-artifact-read',
+    exclusionReason: {
+      en: 'Read-only Timeline transport with runId, series=power and optional prefix in the query; JSON sources contains 1–1000 validation basenames with RESULT_FILENAME up to 200 ASCII letters/digits/dot/underscore/hyphen, matching prefix. Invalid input returns 400; bodies over 256 KiB return 413. Fully covered DB reads skip GitHub; missing identities fall back and merge by validation source, preserving stored sibling windows. Offline GitHub preserves healthy DB series with incomplete sourceCoverage. Coverage describes only requested identities, never whole-run/sample completeness. The GET no-store/error/inventory guarantees also apply. UI-owned, excluded from the stable public API.',
+      zh: 'Timeline 只读传输：查询参数为 runId、series=power 和可选 prefix；JSON sources 含 1–1000 个验证文件 basename，RESULT_FILENAME 最长 200 个 ASCII 字母/数字/点/下划线/连字符，且须匹配 prefix。输入错误返回 400，正文超过 256 KiB 返回 413。DB 已覆盖请求时跳过 GitHub，否则按缺失身份回退，以 validation source 为键合并，并保留已存储的同 bundle 兄弟窗口。GitHub 离线仍返回健康 DB 序列，sourceCoverage 标记 incomplete。覆盖仅针对请求身份，不代表整次 run 或样本完整性。沿用 GET 的 no-store、错误和清单约束；属于界面接口，不纳入稳定公开 API。',
+    },
+    sourceSha256: '80fd8ea1d462b2d47d42411d8361db72802943a94c7ffb91879244c69ef2c693',
   },
   {
     source: 'src/app/api/openapi.json/route.ts',
@@ -534,6 +545,17 @@ export const apiRouteCatalog = [
     operationId: 'list-reliability',
     sourceSha256: 'ce1c5db78b47548beb77a69797f10fb33853cde01cea5c44675c8ad3519bcf20',
   },
+  {
+    source: 'src/app/api/v1/gpu-metrics-point/route.ts',
+    path: '/api/v1/gpu-metrics-point',
+    method: 'GET',
+    classification: 'page-bff',
+    exclusionReason: {
+      en: 'Point-detail BFF returning linked PowerX telemetry series, per-GPU digests and retained validation/audit metadata. Every read checks a live DB revision before using the Blob payload cache; responses use no-store, missing data returns 404, and database failures remain errors. Re-ingest, shared-link and digest algorithm/stored-version changes do not require manual cache purges. Outdated digests are recomputed read-only from retained samples. Coupled to the PowerX tab implementation.',
+      zh: '数据点详情页专用 BFF；返回关联的 PowerX 遥测序列、每 GPU 统计摘要及保留的验证与审计元数据。每次读取先核对数据库版本再使用 Blob 缓存；响应使用 no-store，数据缺失返回 404，数据库故障仍作为错误返回。重新入库、共享链接及摘要算法或存储版本变化无需手动清理缓存；旧摘要从保留样本只读重算。与 PowerX 标签页实现紧密耦合。',
+    },
+    sourceSha256: 'c04a01fcd8e1cb4cb7101a46a0ba44b227f2696819c499bcc93be8ee7a8ce255',
+  },
   {
     source: 'src/app/api/v1/request-chart-data/route.ts',
     path: '/api/v1/request-chart-data',
@@ -821,6 +843,38 @@ export interface ApiContractSourceDigest {
  * touching a route module. Digest changes require an explicit documentation review.
  */
 export const apiContractSourceDigests = [
+  {
+    source: '../db/src/etl/power-audit-validations.ts',
+    sourceSha256: '44a607747b79d038bb8f4e53590efba689d376c143f50a5d750d3552faa0c442',
+    reviewArea: {
+      en: 'Shared legacy and nested AgentX validation identity normalization for artifact and stored Timeline windows.',
+      zh: '产物与数据库 Timeline 窗口共用的 legacy 和嵌套 AgentX validation 身份规范化。',
+    },
+  },
+  {
+    source: 'src/components/gpu-power/power-audit-bundle.ts',
+    sourceSha256: '96aa2ed60692116d5b5219b90b562fdc8143b63359bd917bbc91812ffaf274a8',
+    reviewArea: {
+      en: 'Artifact Timeline validation windows, strict nested AgentX result identity, adjacent context selection, timezone normalization and device identity semantics.',
+      zh: '产物 Timeline 验证窗口、严格匹配的嵌套 AgentX result 身份、相邻 context 选择、时区规范化及设备身份语义。',
+    },
+  },
+  {
+    source: 'src/components/gpu-power/stored-gpu-stats.ts',
+    sourceSha256: '77e9f6ad6eef5f3c30899a9a24d04b0d85b64b0293bea9c38964a9680a55e289',
+    reviewArea: {
+      en: 'Stored full-record GPU metric mappings, authoritative missing digests, and UI/API statistics parity.',
+      zh: '已存全记录 GPU 指标映射、缺失摘要语义，以及界面和 API 的统计一致性。',
+    },
+  },
+  {
+    source: 'src/components/gpu-power/types.ts',
+    sourceSha256: 'e8c5460821f5d8228bcf8b7dd087abe14e29a8e220e1d8bcd75112fb5ead1baa',
+    reviewArea: {
+      en: 'GPU telemetry units, missing values, timestamp deduplication, and full-record live statistics definitions.',
+      zh: 'GPU 遥测单位、缺失值、时间戳去重，以及实时产物全记录统计的定义。',
+    },
+  },
   {
     source: 'src/lib/views-api/upstream-error.ts',
     sourceSha256: 'c3f1b4c318e1ae771a67edd85f16d69b7316461334604fd8c892254eface715a',
@@ -841,7 +895,7 @@ export const apiContractSourceDigests = [
 
   {
     source: 'src/components/gpu-power/chart-data.ts',
-    sourceSha256: '34bdab18810a5e6688d150b71c4c1b22d383a63775672c0c915549b841c48475',
+    sourceSha256: '3e4bed7d693f146c97ac52cc0bb64d854a9dee2a1fa8d5dbf534ac4e1e78fa3f',
     reviewArea: {
       en: 'Dashboard read-only selector and calculation parity.',
       zh: '仪表板只读接口的选择项与计算一致性。',
diff --git a/packages/app/src/lib/github-artifacts.test.ts b/packages/app/src/lib/github-artifacts.test.ts
index 4a80ae8a4..622f851a6 100644
--- a/packages/app/src/lib/github-artifacts.test.ts
+++ b/packages/app/src/lib/github-artifacts.test.ts
@@ -123,6 +123,7 @@ describe('extractZipEntries', () => {
   it('skips non-matching files and continues after parse errors', () => {
     const zip = new AdmZip();
     zip.addFile('good.json', Buffer.from('{"id":1}', 'utf8'));
+    zip.addFile('upper.JSON', Buffer.from('{"id":2}', 'utf8'));
     zip.addFile('bad.json', Buffer.from('not json', 'utf8'));
     zip.addFile('notes.txt', Buffer.from('ignore me', 'utf8'));
 
@@ -136,7 +137,10 @@ describe('extractZipEntries', () => {
       },
     );
 
-    expect(rows).toEqual([{ entryName: 'good.json', payload: { id: 1 } }]);
+    expect(rows).toEqual([
+      { entryName: 'good.json', payload: { id: 1 } },
+      { entryName: 'upper.JSON', payload: { id: 2 } },
+    ]);
     expect(parseErrors).toEqual(['bad.json']);
   });
 });
diff --git a/packages/app/src/lib/github-artifacts.ts b/packages/app/src/lib/github-artifacts.ts
index 3fe278903..d29162741 100644
--- a/packages/app/src/lib/github-artifacts.ts
+++ b/packages/app/src/lib/github-artifacts.ts
@@ -120,6 +120,24 @@ export function downloadGithubArtifact(url: string, token: string): Promise<Resp
   });
 }
 
+/**
+ * Decodes only the entries `predicate` selects, keyed by entry name. The rest
+ * of the archive stays compressed, so picking a few small files out of a
+ * multi-hundred-megabyte bundle costs the central directory, not the payload.
+ */
+export function readZipEntries(
+  buffer: Buffer,
+  predicate: (entryName: string) => boolean,
+): Map<string, string> {
+  const zip = new AdmZip(buffer);
+  const files = new Map<string, string>();
+  for (const entry of zip.getEntries()) {
+    if (entry.isDirectory || !predicate(entry.entryName)) continue;
+    files.set(entry.entryName, entry.getData().toString('utf8'));
+  }
+  return files;
+}
+
 export function extractZipEntries<T>(
   buffer: Buffer,
   extension: string,
@@ -131,7 +149,7 @@ export function extractZipEntries<T>(
   const rows: T[] = [];
 
   for (const entry of zip.getEntries()) {
-    if (!entry.entryName.endsWith(extension)) {
+    if (!entry.entryName.toLowerCase().endsWith(extension.toLowerCase())) {
       continue;
     }
 
diff --git a/packages/app/src/lib/views-api/docs/extensions.ts b/packages/app/src/lib/views-api/docs/extensions.ts
index dc35e0676..150861156 100644
--- a/packages/app/src/lib/views-api/docs/extensions.ts
+++ b/packages/app/src/lib/views-api/docs/extensions.ts
@@ -22,8 +22,8 @@ const PARAMETER_NOTES: Record<string, [string, string]> = {
     '快照截止日期，格式为 YYYY-MM-DD。指定 runId 时改为读取该次运行的逻辑快照。',
   ],
   runId: [
-    'Positive safe integer workflow run ID. Omit to select the default run; required for live GPU metrics.',
-    '正安全整数格式的工作流运行 ID。不填时选择默认运行；实时 GPU 指标必须填写。',
+    'Positive safe integer workflow run ID. Omit to select the default run; required for GPU metrics.',
+    '正安全整数格式的工作流运行 ID。不填时选择默认运行；GPU 指标必须填写。',
   ],
   precisions: [
     'Comma-separated precision keys; omitted selection uses available curve density. Calculator extensions auto-select the densest official precision and include precisions present in unofficial-run overlays.',
@@ -381,9 +381,19 @@ const NEW_VIEWS = {
     { rows: objects, options: object },
   ],
   'gpu-metrics': [
-    'Live GPU metrics and statistics',
-    '实时 GPU 指标与统计',
-    { runInfo: object, artifacts: strings, rows: objects, stats: objects, rendering: object },
+    'GPU telemetry and full-record statistics',
+    'GPU 遥测与全记录统计',
+    {
+      runInfo: object,
+      artifacts: strings,
+      rows: objects,
+      stats: {
+        ...objects,
+        description:
+          'Per-GPU statistics for the selected file/host series, including startup and warmup. Current-version stored digests are authoritative, including an empty or missing metric digest. Outdated or unversioned digests are recomputed read-only from retained DB samples using the current full-record algorithm. Count is the finite-reading count after first-wins timestamp/GPU deduplication. Mean is sample-weighted, P50/P95/P99 use linear interpolation at p*(N-1), and standard deviation divides by N. Values use the selected metric unit; the storage-only metric column is omitted. GPU visibility and chart downsampling do not change this population. These are not serving-window power or J/token.',
+      },
+      rendering: object,
+    },
   ],
   video: [
     'Published video evidence and tradeoffs',
@@ -412,14 +422,14 @@ export const operations: ApiOperation[] = Object.entries(NEW_VIEWS).map(
           view === 'video'
             ? ' Only already published artifacts are read. Cell, phase, slot and GPU-basis choices select result evidence and normalized serving rates; x/y/cost/workload filters produce computed tradeoff points. Local bundles and arbitrary URLs are excluded. Responses are no-store.'
             : view === 'gpu-metrics'
-              ? ' Live artifact reads are no-store; statistics use all chips and unsampled values, while chart rows respect selected GPU indices.'
+              ? ' Telemetry reads stored DB series first and falls back to GitHub artifacts when storage is absent. Responses use private, no-store; an upstream database failure remains HTTP 503 rather than an empty dataset. File/host series retain separate identities. Full-record statistics include startup and warmup and use current-version stored per-GPU digests; a current empty or missing metric digest stays empty. Outdated or unversioned digests are recomputed read-only from retained DB samples. Statistics cover every chip in the selected series, while raw rows and charts respect selected GPU indices. Chart downsampling does not alter statistics. Statistics expose the selected metric values without the storage-only metric column. These sample-weighted statistics are separate from serving-window power, J/token and selected-time-window calculations. Line time remains relative to the first sample across all chips; missing metric readings are omitted rather than zero-filled. Correlations require both readings.'
               : ''
         }`,
         `只读${zh}，使用仪表板的数据读取和计算函数。未知或重复查询键返回 400；响应包含解析后的参数，保留缺失数据。仅影响样式的控件不作为 API 参数。${
           view === 'video'
             ? ' 仅读取已发布产物。cell、阶段、slot 和 GPU 口径选择对应结果证据，并计算 serving 归一化速率；x/y、成本及工作负载筛选生成权衡图数据点。不读取本地数据包或任意 URL。响应不缓存。'
             : view === 'gpu-metrics'
-              ? ' 实时产物读取不缓存；统计量使用所有芯片的未降采样值，图表行则按芯片索引筛选。'
+              ? ' 遥测优先读取数据库中已存储的序列；缺少存储数据时回退到 GitHub 产物。响应使用 private, no-store；上游数据库故障保留 HTTP 503，不作为空数据返回。各文件、主机的序列身份独立保留。全记录统计包含服务启动与 warmup，已有数据使用当前算法版本的每 GPU 统计摘要；当前摘要为空或缺少所选指标时仍返回空统计数组。旧版本或无版本摘要从保留的 DB 样本只读重算。统计覆盖所选序列的全部芯片，原始数据行和图表则按芯片索引筛选；图表降采样不改变统计。统计项只包含所选指标的数值，不返回数据库内部的 metric 字段。这里按样本计算的统计与 serving-window 功率、J/token 及用户所选时间窗口的计算分别处理。折线时间以所有芯片的首个采样为起点；缺失指标读数会被跳过，不补零。相关性图要求两个指标均有读数。'
               : ''
         }`,
       ),
diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index b9389a7d7..690397040 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -8,7 +8,7 @@
     "references/cli-contract.md": "fa44faa38d889b4fbdee5ba42752b47758ee3706fab150513bd4e6db87a86cb0",
     "references/cli.md": "96b228f34cb3600f4548f4dc84df8506531747286763c56ca834c77bee05e1eb",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "57d78ece6595c3b8a28bf09722a633b3fe8e9e1322046534856d1f34e30ee805",
+    "references/dashboard-views.md": "339ebf9e7b33e4d586c852452a42a8ccf020e7edc0427f434d51cd092e69486e",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/pareto.md": "1b4d2d163f982e3f2d97addce310789eae9c1e5badd82dd7501708c9e0385027",
     "references/powerx.md": "cf8adcc5dfe395c5fb659908819980a872475f862f22b723815af43d363cedad",
diff --git a/packages/skills/skills/inferencex-api/references/dashboard-views.md b/packages/skills/skills/inferencex-api/references/dashboard-views.md
index 6f97cf3c5..81f123044 100644
--- a/packages/skills/skills/inferencex-api/references/dashboard-views.md
+++ b/packages/skills/skills/inferencex-api/references/dashboard-views.md
@@ -59,7 +59,7 @@ which controls belong together.
 | `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                               |
 | `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                    |
 | `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                 |
-| `gpu-metrics`                   | Required run, artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. Raw rows and statistics remain unsampled; live response is no-store.                                             |
+| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first telemetry; full-record statistics use stored digests. Responses are no-store.                 |
 | `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                    |
 
 ## Interpretation and maintenance
@@ -94,8 +94,15 @@ Custom chip costs are USD/chip-hour, token prices USD/million tokens,
 interactivity tok/s/user, and video costs USD/deployment-hour. Preserve the
 response's resolved TCO, utilization, license share, topology and power basis.
 Modeled and provisioned power are distinct. Missing measured evidence is not zero.
-GPU chart projections preserve the existing renderer's missing-metric zero
-fallback; use unsampled `rows` to distinguish absent optional sensor values.
+GPU chart projections omit missing metric readings; measured zero remains zero.
+The selected file/host series' full-record statistics include startup and warmup
+and cover all chips regardless of visibility or chart downsampling. Stats rows omit
+the storage-only `metric` column; `params.metric` identifies the selected metric. Current-version stored digests
+are authoritative, including empty or absent metric digests. Outdated or
+unversioned digests are recomputed read-only from retained DB samples. Keep these sample-weighted statistics separate from
+serving-window power, J/token and selected-time-window calculations. The view reads
+stored telemetry first, falls back to artifacts for missing storage, and preserves
+upstream 503 failures. Treat an error as unavailable evidence, not an empty dataset.
 
 Zoom, axis scale, theme, labels, report expansion, media playback and download
 buttons are presentation state, not new datasets. AI-chart provider keys and

From bcffadae3364496897d73f8d83521c51b8c5a31c Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 096/103] feat(ui): explorer smoothing controls and stored
 full-record statistics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The /gpu-metrics explorer reads stored series, shows full-record statistics from the
ingest digest, adds points/rolling display modes with a mean-of-chips line, and refetches
on focus so a re-ingest shows up in an open tab.

中文：/gpu-metrics explorer 读取入库序列，展示 ingest 摘要的全记录统计，新增点/滑动平均显示模式与芯片均值线，并在窗口聚焦时刷新以反映重入库。
---
 packages/app/cypress/e2e/gpu-power.cy.ts      |   6 +-
 .../components/gpu-power/GpuPowerChart.tsx    | 392 +++++++++++++++---
 .../components/gpu-power/GpuPowerDisplay.tsx  | 173 ++++----
 .../components/gpu-power/GpuStatsTable.tsx    |  99 +++--
 .../gpu-power/TelemetryDisplayControls.tsx    | 139 +++++++
 .../components/gpu-power/chart-data.test.ts   |  33 ++
 .../src/components/gpu-power/chart-data.ts    |  43 +-
 .../gpu-power/telemetry-smoothing.test.ts     |  34 ++
 .../gpu-power/telemetry-smoothing.ts          | 160 +++++++
 .../src/components/gpu-power/types.test.ts    | 365 +---------------
 .../app/src/components/gpu-power/types.ts     | 323 ++++-----------
 packages/app/src/lib/d3-chart/layers/lines.ts |   4 +-
 12 files changed, 967 insertions(+), 804 deletions(-)
 create mode 100644 packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
 create mode 100644 packages/app/src/components/gpu-power/chart-data.test.ts
 create mode 100644 packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
 create mode 100644 packages/app/src/components/gpu-power/telemetry-smoothing.ts

diff --git a/packages/app/cypress/e2e/gpu-power.cy.ts b/packages/app/cypress/e2e/gpu-power.cy.ts
index 2ff041dd5..eb769267b 100644
--- a/packages/app/cypress/e2e/gpu-power.cy.ts
+++ b/packages/app/cypress/e2e/gpu-power.cy.ts
@@ -211,9 +211,9 @@ describe('PowerX Chinese route', () => {
       .should('contain.text', '秒')
       .and('contain.text', '功耗 (W)');
     cy.get('[data-testid="gpu-metrics-chart-svg"]').should('contain.text', '点击数据点固定提示框');
-    cy.get('[data-testid="gpu-metrics-chart-svg"] svg .point')
-      .first()
-      .trigger('mouseenter', { force: true });
+    cy.get('[data-testid="gpu-metrics-chart-svg"] svg .point').first().scrollIntoView();
+    // Exercise the supported mobile interaction, not a forced off-screen hover.
+    cy.get('[data-testid="gpu-metrics-chart-svg"] svg .point').first().click();
     cy.get('[data-chart-tooltip]:visible')
       .should('contain.text', '芯片 0')
       .and('contain.text', '功耗：');
diff --git a/packages/app/src/components/gpu-power/GpuPowerChart.tsx b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
index 09635c51a..fa3f33b5d 100644
--- a/packages/app/src/components/gpu-power/GpuPowerChart.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerChart.tsx
@@ -2,13 +2,25 @@
 
 import * as d3 from 'd3';
 import React, { useMemo } from 'react';
-import { buildGroupedData, type ParsedPoint } from './chart-data';
+import { buildTelemetryData, type ParsedPoint } from './chart-data';
 
 import { D3Chart } from '@/lib/d3-chart/D3Chart';
+import type { RenderContext } from '@/lib/d3-chart/D3Chart/types';
+import { CHART_TYPE, px } from '@/lib/d3-chart/typography';
 import { useLocale } from '@/lib/use-locale';
+import {
+  DEFAULT_TELEMETRY_DISPLAY,
+  estimateSampleIntervalMs,
+  meanAcrossSeries,
+  nearestSample,
+  rollingTimeAverage,
+  type TelemetryDisplayState,
+  type TimedSample,
+} from './telemetry-smoothing';
 import {
   ALL_METRIC_OPTIONS,
   detectTdpFromArtifactName,
+  tdpForHardware,
   getGpuMetricLabel,
   getGpuMetricYAxisLabel,
   type GpuMetricKey,
@@ -26,6 +38,10 @@ const STRINGS = {
     power: 'Power',
     temp: 'Temp',
     utilization: 'Chip Util',
+    rollingSuffix: (windowS: number) => `${windowS} s rolling avg`,
+    meanChips: 'Mean of visible chips',
+    meanCount: (n: number) => `${n} chips`,
+    rightAxis: 'right axis',
   },
   zh: {
     empty: '暂无可显示的芯片指标数据。',
@@ -36,23 +52,155 @@ const STRINGS = {
     power: '功耗',
     temp: '温度',
     utilization: '芯片利用率',
+    rollingSuffix: (windowS: number) => `${windowS} 秒滚动平均`,
+    meanChips: '可见芯片均值',
+    meanCount: (n: number) => `${n} 个芯片`,
+    rightAxis: '右轴',
   },
 } as const;
 
+/** A second time series drawn over the telemetry on its own right-hand axis. */
+export interface TelemetryOverlaySeries {
+  label: string;
+  unit: string;
+  color: string;
+  /** Absolute-time samples; the chart re-bases them onto its own t=0. */
+  points: TimedSample[];
+}
+
 interface GpuMetricsChartProps {
   data: GpuMetricRow[];
   visibleGpus: Set<number>;
   metricKey: GpuMetricKey;
   artifactName: string;
+  /**
+   * Hardware key of the benchmark point (`b200`, `h200`, …). Multinode bundle
+   * names are hash-truncated and carry no SKU token, so callers that know the
+   * point pass it explicitly; the artifact-name sniff stays the fallback.
+   */
+  hardware?: string;
   legendElement?: React.ReactNode;
   caption?: React.ReactNode;
   /** Max interactive points before LTTB downsampling. Infinity to disable. */
   maxPoints?: number;
+  /** Raw samples vs. time-window rolling average. Defaults to raw samples. */
+  display?: TelemetryDisplayState;
+  /** Optional secondary series (e.g. decode throughput) on a right y-axis. */
+  overlay?: TelemetryOverlaySeries | null;
+}
+
+/** Mean across the visible chips, aligned by nearest sample within one poll interval. */
+function buildMeanSeries(groups: Map<number, ParsedPoint[]>, t0Ms: number): ParsedPoint[] {
+  const arrays = [...groups.values()];
+  if (arrays.length === 0) return [];
+  const longest = arrays.reduce((a, b) => (b.length > a.length ? b : a));
+  const mean = meanAcrossSeries(arrays, estimateSampleIntervalMs(longest));
+  return mean.map((p) => ({
+    seconds: (p.ms - t0Ms) / 1000,
+    ms: p.ms,
+    value: p.value,
+    gpuIndex: MEAN_INDEX,
+    raw: null,
+    count: p.count,
+  }));
+}
+
+/** Replace each point's value with its centered time-window mean. */
+function smoothSeries(points: ParsedPoint[], windowS: number): ParsedPoint[] {
+  const averaged = rollingTimeAverage(points, windowS * 1000);
+  return points.map((point, i) => ({ ...point, value: averaged[i]!.value, raw: null }));
+}
+
+/** Per-chip palette shared with legends that toggle chips on and off. */
+export const GPU_COLORS = d3.schemeTableau10;
+/** Pseudo chip index and line key for the mean across visible chips. */
+const MEAN_INDEX = -1;
+const MEAN_KEY = 'mean';
+const MEAN_COLOR = 'var(--foreground)';
+
+function lineKey(gpuIndex: number): string {
+  return gpuIndex === MEAN_INDEX ? MEAN_KEY : String(gpuIndex);
 }
 
-const GPU_COLORS = d3.schemeTableau10;
+function colorFor(gpuIndex: number): string {
+  return gpuIndex === MEAN_INDEX ? MEAN_COLOR : GPU_COLORS[gpuIndex % GPU_COLORS.length]!;
+}
 const CHART_ID = 'gpu-metrics-line';
 const MARGIN = { top: 24, right: 20, bottom: 60, left: 60 };
+/** Room for the overlay's right axis ticks and rotated title. */
+const MARGIN_WITH_OVERLAY = { ...MARGIN, right: 84 };
+
+interface OverlayPoint {
+  x: number;
+  y: number;
+}
+
+function overlayYScale(points: OverlayPoint[], height: number): d3.ScaleLinear<number, number> {
+  const max = d3.max(points, (p) => p.y) ?? 0;
+  return d3
+    .scaleLinear()
+    .domain([0, max > 0 ? max * 1.05 : 1])
+    .range([height, 0])
+    .nice();
+}
+
+function overlayLine(
+  xScale: d3.ScaleLinear<number, number>,
+  yScale: d3.ScaleLinear<number, number>,
+): d3.Line<OverlayPoint> {
+  return d3
+    .line<OverlayPoint>()
+    .x((p) => xScale(p.x))
+    .y((p) => yScale(p.y))
+    .curve(d3.curveMonotoneX);
+}
+
+/**
+ * Draw the overlay path inside the clipped zoom group and its axis in the
+ * unclipped root group. Both are removed first so toggling the overlay off
+ * (or re-rendering) never leaves a stale axis behind.
+ */
+function renderOverlay(
+  group: d3.Selection<SVGGElement, unknown, null, undefined>,
+  ctx: RenderContext,
+  overlay: TelemetryOverlaySeries | null | undefined,
+  points: OverlayPoint[],
+): void {
+  group.selectAll('.telemetry-overlay').remove();
+  ctx.layout.g.selectAll('.telemetry-overlay-axis').remove();
+  if (!overlay || points.length === 0) return;
+  const xScale = ctx.xScale as d3.ScaleLinear<number, number>;
+  const yScale = overlayYScale(points, ctx.height);
+  group
+    .append('path')
+    .attr('class', 'telemetry-overlay')
+    .attr('fill', 'none')
+    .attr('stroke', overlay.color)
+    .attr('stroke-width', 1.75)
+    .attr('opacity', 0.9)
+    .attr('pointer-events', 'none')
+    .attr('d', overlayLine(xScale, yScale)(points));
+
+  const axis = ctx.layout.g
+    .append('g')
+    .attr('class', 'telemetry-overlay-axis')
+    .attr('transform', `translate(${ctx.width},0)`)
+    .call(d3.axisRight(yScale).ticks(6).tickSize(4).tickFormat(d3.format('~s')));
+  axis.select('.domain').attr('stroke', overlay.color);
+  axis.selectAll('.tick line').attr('stroke', overlay.color);
+  axis
+    .selectAll('.tick text')
+    .attr('fill', overlay.color)
+    .attr('font-size', px(CHART_TYPE.axisLabel));
+  axis
+    .append('text')
+    .attr('class', 'telemetry-overlay-axis-label')
+    .attr('transform', `translate(${ctx.layout.margin.right - 14},${ctx.height / 2}) rotate(90)`)
+    .attr('text-anchor', 'middle')
+    .attr('fill', overlay.color)
+    .attr('font-size', px(CHART_TYPE.axisLabel))
+    .text(`${overlay.label} (${overlay.unit})`);
+}
 
 const GpuMetricsChart = React.memo(
   ({
@@ -60,19 +208,42 @@ const GpuMetricsChart = React.memo(
     visibleGpus,
     metricKey,
     artifactName,
+    hardware,
     legendElement,
     caption,
     maxPoints,
+    display = DEFAULT_TELEMETRY_DISPLAY,
+    overlay,
   }: GpuMetricsChartProps) => {
     const locale = useLocale();
     const t = STRINGS[locale];
     const metricConfig = ALL_METRIC_OPTIONS.find((m) => m.key === metricKey)!;
+    const rolling = display.mode === 'rolling';
+    const showChips = display.series !== 'mean';
+    const showMean = display.series !== 'chips';
 
-    const groupedData = useMemo(
-      () => buildGroupedData(data, visibleGpus, metricKey),
+    const { t0Ms, groups: rawGroups } = useMemo(
+      () => buildTelemetryData(data, visibleGpus, metricKey),
       [data, visibleGpus, metricKey],
     );
 
+    // Displayed series keyed by chip index (MEAN_INDEX for the mean line):
+    // per-chip and/or mean, then optionally smoothed.
+    const groupedData = useMemo(() => {
+      const series = new Map<number, ParsedPoint[]>();
+      if (showChips) for (const [gpuIndex, points] of rawGroups) series.set(gpuIndex, points);
+      if (showMean) {
+        const mean = buildMeanSeries(rawGroups, t0Ms);
+        if (mean.length > 0) series.set(MEAN_INDEX, mean);
+      }
+      if (!rolling) return series;
+      const smoothed = new Map<number, ParsedPoint[]>();
+      for (const [gpuIndex, points] of series) {
+        smoothed.set(gpuIndex, smoothSeries(points, display.windowS));
+      }
+      return smoothed;
+    }, [rawGroups, t0Ms, showChips, showMean, rolling, display.windowS]);
+
     const allPoints = useMemo(() => {
       const pts: ParsedPoint[] = [];
       for (const points of groupedData.values()) pts.push(...points);
@@ -83,11 +254,64 @@ const GpuMetricsChart = React.memo(
     const lineData = useMemo(() => {
       const result: Record<string, { x: number; y: number }[]> = {};
       for (const [gpuIndex, points] of groupedData) {
-        result[String(gpuIndex)] = points.map((p) => ({ x: p.seconds, y: p.value }));
+        result[lineKey(gpuIndex)] = points.map((p) => ({ x: p.seconds, y: p.value }));
       }
       return result;
     }, [groupedData]);
 
+    // Overlay samples, smoothed with the same window as the chip lines when
+    // averaging so both series answer the same "how much over N seconds"
+    // question, then re-based onto the telemetry's t=0.
+    const overlaySamples = useMemo<TimedSample[]>(() => {
+      if (!overlay) return [];
+      return rolling ? rollingTimeAverage(overlay.points, display.windowS * 1000) : overlay.points;
+    }, [overlay, rolling, display.windowS]);
+    const overlayPoints = useMemo<OverlayPoint[]>(
+      () => overlaySamples.map((p) => ({ x: (p.ms - t0Ms) / 1000, y: p.value })),
+      [overlaySamples, t0Ms],
+    );
+    const hasOverlay = Boolean(overlay) && overlayPoints.length > 0;
+
+    const hasMeanLine = groupedData.has(MEAN_INDEX);
+    const keyRow =
+      hasMeanLine || hasOverlay ? (
+        <div
+          className="mt-1 flex flex-wrap items-center gap-x-4 gap-y-1 text-xs text-muted-foreground"
+          data-testid="gpu-metrics-chart-keys"
+        >
+          {hasMeanLine && (
+            <span className="inline-flex items-center gap-1.5">
+              <span
+                aria-hidden
+                className="inline-block h-0.5 w-4 rounded"
+                style={{ background: MEAN_COLOR }}
+              />
+              {t.meanChips}
+            </span>
+          )}
+          {hasOverlay && overlay && (
+            <span
+              className="inline-flex items-center gap-1.5"
+              data-testid="gpu-metrics-overlay-key"
+            >
+              <span
+                aria-hidden
+                className="inline-block h-0.5 w-4 rounded"
+                style={{ background: overlay.color }}
+              />
+              {overlay.label} ({overlay.unit} · {t.rightAxis})
+            </span>
+          )}
+        </div>
+      ) : null;
+    const resolvedCaption =
+      caption || keyRow ? (
+        <>
+          {caption}
+          {keyRow}
+        </>
+      ) : undefined;
+
     // Scale domains
     const xDomain = useMemo(() => {
       if (allPoints.length === 0) return [0, 100] as [number, number];
@@ -95,14 +319,23 @@ const GpuMetricsChart = React.memo(
       return ext;
     }, [allPoints]);
 
-    const tdpInfo = metricKey === 'power' ? detectTdpFromArtifactName(artifactName) : null;
+    const tdpInfo =
+      metricKey === 'power'
+        ? (tdpForHardware(hardware) ?? detectTdpFromArtifactName(artifactName))
+        : null;
 
     const yDomain = useMemo(() => {
       if (allPoints.length === 0) return [0, 100] as [number, number];
       const ext = d3.extent(allPoints, (d) => d.value) as [number, number];
       const range = ext[1] - ext[0];
-      const yMin = Math.max(0, ext[0] - range * 0.05);
-      let yMax = ext[1] + range * 0.05;
+      // Constant telemetry and floating-point noise still need a readable axis.
+      const padding = Math.max(
+        range * 0.05,
+        Math.max(Math.abs(ext[0]), Math.abs(ext[1])) * 0.01,
+        1,
+      );
+      const yMin = Math.max(0, ext[0] - padding);
+      let yMax = ext[1] + padding;
       if (tdpInfo && tdpInfo.tdp > yMax) yMax = tdpInfo.tdp * 1.05;
       return [yMin, yMax] as [number, number];
     }, [allPoints, tdpInfo]);
@@ -120,46 +353,52 @@ const GpuMetricsChart = React.memo(
         chartId={CHART_ID}
         data={allPoints}
         height={600}
-        margin={MARGIN}
+        margin={hasOverlay ? MARGIN_WITH_OVERLAY : MARGIN}
         watermark="logo"
         testId="gpu-metrics-chart-svg"
         grabCursor={true}
         instructions={t.instructions}
         xScale={{ type: 'linear', domain: xDomain, nice: true }}
         yScale={{ type: 'linear', domain: yDomain, nice: true }}
-        xAxis={{ label: t.seconds, tickCount: 10 }}
+        xAxis={{
+          label: t.seconds,
+          tickValues: (scale) => {
+            const secondsScale = scale as d3.ScaleLinear<number, number>;
+            const [left, right] = secondsScale.range();
+            return secondsScale.ticks(Math.max(2, Math.min(10, Math.floor((right - left) / 60))));
+          },
+        }}
         yAxis={{ label: getGpuMetricYAxisLabel(metricConfig, locale), tickCount: 8 }}
         layers={[
           // TDP reference line (power metric only)
           {
             type: 'custom',
             key: 'tdp-line',
-            render: tdpInfo
-              ? (group, ctx) => {
-                  const yScale = ctx.yScale as d3.ScaleLinear<number, number>;
-                  const tdpY = yScale(tdpInfo.tdp);
-                  group.selectAll('.tdp-line').remove();
-                  const tdpGroup = group.append('g').attr('class', 'tdp-line');
-                  tdpGroup
-                    .append('line')
-                    .attr('x1', 0)
-                    .attr('x2', ctx.width)
-                    .attr('y1', tdpY)
-                    .attr('y2', tdpY)
-                    .attr('stroke', '#ef4444')
-                    .attr('stroke-width', 1.5)
-                    .attr('stroke-dasharray', '6,4');
-                  tdpGroup
-                    .append('text')
-                    .attr('x', ctx.width - 4)
-                    .attr('y', tdpY - 6)
-                    .attr('text-anchor', 'end')
-                    .attr('fill', '#ef4444')
-                    .attr('font-size', '11px')
-                    .attr('font-weight', '600')
-                    .text(`${tdpInfo.sku} TDP: ${tdpInfo.tdp}W`);
-                }
-              : null,
+            render: (group, ctx) => {
+              group.selectAll('.tdp-line').remove();
+              if (!tdpInfo) return;
+              const yScale = ctx.yScale as d3.ScaleLinear<number, number>;
+              const tdpY = yScale(tdpInfo.tdp);
+              const tdpGroup = group.append('g').attr('class', 'tdp-line');
+              tdpGroup
+                .append('line')
+                .attr('x1', 0)
+                .attr('x2', ctx.width)
+                .attr('y1', tdpY)
+                .attr('y2', tdpY)
+                .attr('stroke', '#ef4444')
+                .attr('stroke-width', 1.5)
+                .attr('stroke-dasharray', '6,4');
+              tdpGroup
+                .append('text')
+                .attr('x', ctx.width - 4)
+                .attr('y', tdpY - 6)
+                .attr('text-anchor', 'end')
+                .attr('fill', '#ef4444')
+                .attr('font-size', '11px')
+                .attr('font-weight', '600')
+                .text(`${tdpInfo.sku} TDP: ${tdpInfo.tdp}W`);
+            },
           },
           // GPU lines
           {
@@ -167,8 +406,8 @@ const GpuMetricsChart = React.memo(
             key: 'gpu-lines',
             lines: lineData,
             config: {
-              getColor: (key) => GPU_COLORS[parseInt(key, 10) % GPU_COLORS.length],
-              strokeWidth: 1.5,
+              getColor: (key) => (key === MEAN_KEY ? MEAN_COLOR : colorFor(parseInt(key, 10))),
+              getStrokeWidth: (key) => (key === MEAN_KEY ? 2.5 : rolling ? 1.75 : 1.5),
               curve: d3.curveMonotoneX,
             },
           },
@@ -182,11 +421,31 @@ const GpuMetricsChart = React.memo(
               getCy: () => 0,
               getX: (d) => d.seconds,
               getY: (d) => d.value,
-              getColor: (d) => GPU_COLORS[d.gpuIndex % GPU_COLORS.length],
-              getRadius: () => 2,
+              // Averaged mode draws lines only; the circles stay as invisible
+              // hover targets so the tooltip and crosshair keep working.
+              getColor: (d) => (rolling ? 'transparent' : colorFor(d.gpuIndex)),
+              getRadius: () => (rolling ? 3 : 2),
               maxPoints,
             },
           },
+          // Secondary series on a right-hand axis (e.g. decode throughput)
+          {
+            type: 'custom',
+            key: 'telemetry-overlay',
+            render: (group, ctx) => {
+              renderOverlay(group, ctx, hasOverlay ? overlay : null, overlayPoints);
+            },
+            onZoom: (group, ctx) => {
+              if (!hasOverlay) return;
+              const xScale = ctx.newXScale as d3.ScaleLinear<number, number>;
+              group
+                .select<SVGPathElement>('.telemetry-overlay')
+                .attr(
+                  'd',
+                  overlayLine(xScale, overlayYScale(overlayPoints, ctx.height))(overlayPoints),
+                );
+            },
+          },
         ]}
         zoom={{
           enabled: true,
@@ -197,29 +456,60 @@ const GpuMetricsChart = React.memo(
         tooltip={{
           rulerType: 'crosshair',
           content: (d: ParsedPoint, isPinned: boolean) => {
-            const color = GPU_COLORS[d.gpuIndex % GPU_COLORS.length];
+            const color = colorFor(d.gpuIndex);
+            const sep = locale === 'zh' ? '：' : ':';
+            const title =
+              d.gpuIndex === MEAN_INDEX
+                ? `${t.meanChips}${d.count ? ` · ${t.meanCount(d.count)}` : ''}`
+                : `${t.chip} ${d.gpuIndex}`;
+            const overlayAt = hasOverlay ? nearestSample(overlaySamples, d.ms) : null;
+            const overlayRow =
+              overlay && overlayAt
+                ? `<div class="mt-1" style="color: ${overlay.color}">${overlay.label}${sep} ${
+                    overlayAt.value >= 100 ? overlayAt.value.toFixed(0) : overlayAt.value.toFixed(1)
+                  } ${overlay.unit}</div>`
+                : '';
             return `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md backdrop-blur-sm" style="min-width: 160px; user-select: ${isPinned ? 'text' : 'none'}">
               ${isPinned ? `<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">${t.dismiss}</div>` : ''}
-              <div class="font-semibold mb-1" style="color: ${color}">${t.chip} ${d.gpuIndex}</div>
+              <div class="font-semibold mb-1" style="color: ${color}">${title}</div>
               <div class="text-muted-foreground">${d.seconds.toFixed(1)}${locale === 'zh' ? ' 秒' : 's'}</div>
-              <div class="mt-1 font-medium">${getGpuMetricLabel(metricConfig, locale)}${locale === 'zh' ? '：' : ':'} ${d.value.toFixed(1)} ${metricConfig.unit}</div>
-              <div class="text-muted-foreground">${t.power}${locale === 'zh' ? '：' : ':'} ${d.raw.power.toFixed(1)} W</div>
-              <div class="text-muted-foreground">${t.temp}${locale === 'zh' ? '：' : ':'} ${d.raw.temperature}\u00B0C</div>
-              <div class="text-muted-foreground">${t.utilization}${locale === 'zh' ? '：' : ':'} ${d.raw.gpuUtil}%</div>
+              <div class="mt-1 font-medium">${getGpuMetricLabel(metricConfig, locale)}${sep} ${d.value.toFixed(1)} ${metricConfig.unit}</div>
+              ${rolling ? `<div class="text-muted-foreground">${t.rollingSuffix(display.windowS)}</div>` : ''}
+              ${
+                d.raw
+                  ? `<div class="text-muted-foreground">${t.power}${sep} ${d.raw.power.toFixed(1)} W</div>${
+                      d.raw.temperature === undefined
+                        ? ''
+                        : `<div class="text-muted-foreground">${t.temp}${sep} ${d.raw.temperature}\u00B0C</div>`
+                    }${
+                      d.raw.gpuUtil === undefined
+                        ? ''
+                        : `<div class="text-muted-foreground">${t.utilization}${sep} ${d.raw.gpuUtil}%</div>`
+                    }`
+                  : ''
+              }
+              ${overlayRow}
             </div>`;
           },
           getRulerX: (d, xScale) => (xScale as d3.ScaleLinear<number, number>)(d.seconds),
           getRulerY: (d, yScale) => yScale(d.value),
-          onHoverStart: (sel) => {
-            sel.attr('r', 5).attr('stroke', 'white').attr('stroke-width', 1);
+          onHoverStart: (sel, d) => {
+            sel
+              .attr('r', 5)
+              .attr('fill', colorFor(d.gpuIndex))
+              .attr('stroke', 'white')
+              .attr('stroke-width', 1);
           },
-          onHoverEnd: (sel) => {
-            sel.attr('r', 2).attr('stroke', 'none');
+          onHoverEnd: (sel, d) => {
+            sel
+              .attr('r', rolling ? 3 : 2)
+              .attr('fill', rolling ? 'transparent' : colorFor(d.gpuIndex))
+              .attr('stroke', 'none');
           },
           attachToLayer: 2,
         }}
         legendElement={legendElement}
-        caption={caption}
+        caption={resolvedCaption}
       />
     );
   },
diff --git a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
index f0949589c..d28dbf25d 100644
--- a/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
+++ b/packages/app/src/components/gpu-power/GpuPowerDisplay.tsx
@@ -33,6 +33,8 @@ import { useClientSearchParams } from '@/hooks/useClientSearch';
 import GpuCorrelationChart from './GpuCorrelationChart';
 import GpuMetricsChart from './GpuPowerChart';
 import GpuStatsTable from './GpuStatsTable';
+import { DEFAULT_TELEMETRY_DISPLAY, type TelemetryDisplayState } from './telemetry-smoothing';
+import { TelemetryDisplayControls } from './TelemetryDisplayControls';
 import {
   type GpuMetricKey,
   type GpuPowerApiResponse,
@@ -81,6 +83,7 @@ const STRINGS = {
     chip: 'Chip',
     chartToolbar: 'Chart controls',
     correlationAxes: 'Correlation axes',
+    displayControls: 'Line options',
   },
   zh: {
     heading: 'PowerX',
@@ -119,6 +122,7 @@ const STRINGS = {
     chip: '芯片',
     chartToolbar: '图表控制',
     correlationAxes: '相关性坐标轴',
+    displayControls: '曲线选项',
   },
 } as const;
 
@@ -175,6 +179,7 @@ export default function GpuMetricsDisplay() {
     gcTime: 0,
     retry: false,
     refetchOnMount: 'always',
+    refetchOnWindowFocus: true,
   });
   const artifacts = query.data?.artifacts ?? [];
   const runInfo = query.data?.runInfo ?? null;
@@ -200,10 +205,8 @@ export default function GpuMetricsDisplay() {
     artifacts.some((artifact) => artifact.name === selectedArtifactCandidate)
       ? selectedArtifactCandidate
       : (artifacts[0]?.name ?? '');
-  const currentData = useMemo(
-    () => artifacts.find((artifact) => artifact.name === selectedArtifact)?.data ?? [],
-    [artifacts, selectedArtifact],
-  );
+  const currentArtifact = artifacts.find((artifact) => artifact.name === selectedArtifact);
+  const currentData = useMemo(() => currentArtifact?.data ?? [], [currentArtifact]);
   const availableMetrics = useMemo(() => getAvailableMetrics(currentData), [currentData]);
   const urlMetric = searchParams.get('gm_metric');
   const selectedMetricCandidate = selectionApplies ? selection.metric : urlMetric;
@@ -237,6 +240,16 @@ export default function GpuMetricsDisplay() {
   const [chartView, setChartView] = useState<GpuMetricsView>('chart');
   const [corrXMetric, setCorrXMetric] = useState<GpuMetricKey>('power');
   const [corrYMetric, setCorrYMetric] = useState<GpuMetricKey>('temperature');
+  // A power-only series (multinode DCGM bundle) has no temperature axis to
+  // default to; use the first other collected metric instead of an empty plot.
+  const effectiveCorrYMetric = useMemo<GpuMetricKey>(
+    () =>
+      availableMetrics.some((m) => m.key === corrYMetric)
+        ? corrYMetric
+        : (availableMetrics.find((m) => m.key !== corrXMetric)?.key ?? corrXMetric),
+    [availableMetrics, corrXMetric, corrYMetric],
+  );
+  const [display, setDisplay] = useState<TelemetryDisplayState>(DEFAULT_TELEMETRY_DISPLAY);
   const viewOptions = useMemo<SegmentedToggleOption<GpuMetricsView>[]>(
     () => [
       {
@@ -359,6 +372,52 @@ export default function GpuMetricsDisplay() {
     else setCorrYMetric(value as GpuMetricKey);
   }, []);
 
+  const legendElement = (
+    <ChartLegend
+      variant="sidebar"
+      onItemRemove={removeGpu}
+      legendItems={allGpuIndices.map((gpuIndex) => ({
+        name: `${t.chip} ${gpuIndex}`,
+        hw: String(gpuIndex),
+        label: `${t.chip} ${gpuIndex}`,
+        color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
+        isActive: visibleGpus.has(gpuIndex),
+        onClick: () => toggleGpu(gpuIndex),
+      }))}
+      isLegendExpanded={isLegendExpanded}
+      onExpandedChange={(expanded) => {
+        setIsLegendExpanded(expanded);
+        track('gpu_metrics_legend_expanded', { expanded });
+      }}
+      actions={
+        allGpusSelected
+          ? []
+          : [
+              {
+                id:
+                  chartView === 'correlation'
+                    ? 'gpu-metrics-reset-filter-2'
+                    : 'gpu-metrics-reset-filter',
+                label: t.resetFilter,
+                onClick: selectAllGpus,
+              },
+            ]
+      }
+      switches={[
+        {
+          id:
+            chartView === 'correlation' ? 'gpu-metrics-downsample-corr' : 'gpu-metrics-downsample',
+          label: t.downsample,
+          checked: downsample,
+          onCheckedChange: (c) => {
+            setDownsample(c);
+            track('gpu_metrics_downsample_toggled', { enabled: c });
+          },
+        },
+      ]}
+    />
+  );
+
   return (
     <section data-testid="gpu-metrics-display">
       <Card className="mb-4">
@@ -608,7 +667,7 @@ export default function GpuMetricsDisplay() {
                   <div className="space-y-1 min-w-0">
                     <Label htmlFor="gpu-metrics-correlation-y">{t.yAxis}</Label>
                     <Select
-                      value={corrYMetric}
+                      value={effectiveCorrYMetric}
                       onValueChange={(v) => handleCorrelationMetricChange('y', v)}
                     >
                       <SelectTrigger id="gpu-metrics-correlation-y" className="w-full">
@@ -627,6 +686,17 @@ export default function GpuMetricsDisplay() {
               </ControlPanel>
             )}
 
+            {chartView === 'chart' && (
+              <ControlPanel legend={t.displayControls} className="mb-3 no-export">
+                <TelemetryDisplayControls
+                  value={display}
+                  onChange={setDisplay}
+                  analyticsPrefix="gpu_metrics"
+                  idPrefix="gpu-metrics-display"
+                />
+              </ControlPanel>
+            )}
+
             {chartView === 'chart' && (
               <GpuMetricsChart
                 data={currentData}
@@ -634,6 +704,7 @@ export default function GpuMetricsDisplay() {
                 metricKey={selectedMetric}
                 artifactName={selectedArtifact}
                 maxPoints={downsample ? 2000 : Infinity}
+                display={display}
                 caption={
                   <>
                     <h2 className="text-lg font-semibold">
@@ -643,47 +714,7 @@ export default function GpuMetricsDisplay() {
                     <UnofficialDomainNotice />
                   </>
                 }
-                legendElement={
-                  <ChartLegend
-                    variant="sidebar"
-                    onItemRemove={removeGpu}
-                    legendItems={allGpuIndices.map((gpuIndex) => ({
-                      name: `${t.chip} ${gpuIndex}`,
-                      hw: String(gpuIndex),
-                      label: `${t.chip} ${gpuIndex}`,
-                      color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
-                      isActive: visibleGpus.has(gpuIndex),
-                      onClick: () => toggleGpu(gpuIndex),
-                    }))}
-                    isLegendExpanded={isLegendExpanded}
-                    onExpandedChange={(expanded) => {
-                      setIsLegendExpanded(expanded);
-                      track('gpu_metrics_legend_expanded', { expanded });
-                    }}
-                    actions={
-                      allGpusSelected
-                        ? []
-                        : [
-                            {
-                              id: 'gpu-metrics-reset-filter',
-                              label: t.resetFilter,
-                              onClick: selectAllGpus,
-                            },
-                          ]
-                    }
-                    switches={[
-                      {
-                        id: 'gpu-metrics-downsample',
-                        label: t.downsample,
-                        checked: downsample,
-                        onCheckedChange: (c) => {
-                          setDownsample(c);
-                          track('gpu_metrics_downsample_toggled', { enabled: c });
-                        },
-                      },
-                    ]}
-                  />
-                }
+                legendElement={legendElement}
               />
             )}
             {chartView === 'correlation' && (
@@ -691,7 +722,7 @@ export default function GpuMetricsDisplay() {
                 data={currentData}
                 visibleGpus={visibleGpus}
                 xMetric={corrXMetric}
-                yMetric={corrYMetric}
+                yMetric={effectiveCorrYMetric}
                 maxPoints={downsample ? 2000 : Infinity}
                 caption={
                   <>
@@ -699,47 +730,7 @@ export default function GpuMetricsDisplay() {
                     <UnofficialDomainNotice />
                   </>
                 }
-                legendElement={
-                  <ChartLegend
-                    variant="sidebar"
-                    onItemRemove={removeGpu}
-                    legendItems={allGpuIndices.map((gpuIndex) => ({
-                      name: `${t.chip} ${gpuIndex}`,
-                      hw: String(gpuIndex),
-                      label: `${t.chip} ${gpuIndex}`,
-                      color: GPU_COLORS[gpuIndex % GPU_COLORS.length],
-                      isActive: visibleGpus.has(gpuIndex),
-                      onClick: () => toggleGpu(gpuIndex),
-                    }))}
-                    isLegendExpanded={isLegendExpanded}
-                    onExpandedChange={(expanded) => {
-                      setIsLegendExpanded(expanded);
-                      track('gpu_metrics_legend_expanded', { expanded });
-                    }}
-                    actions={
-                      allGpusSelected
-                        ? []
-                        : [
-                            {
-                              id: 'gpu-metrics-reset-filter-2',
-                              label: t.resetFilter,
-                              onClick: selectAllGpus,
-                            },
-                          ]
-                    }
-                    switches={[
-                      {
-                        id: 'gpu-metrics-downsample-corr',
-                        label: t.downsample,
-                        checked: downsample,
-                        onCheckedChange: (c) => {
-                          setDownsample(c);
-                          track('gpu_metrics_downsample_toggled', { enabled: c });
-                        },
-                      },
-                    ]}
-                  />
-                }
+                legendElement={legendElement}
               />
             )}
           </Card>
@@ -749,7 +740,11 @@ export default function GpuMetricsDisplay() {
             <h3 className="text-sm font-semibold mb-2">
               {t.perGpuStats} ({getGpuMetricLabel(metricConfig, locale)})
             </h3>
-            <GpuStatsTable data={currentData} metricKey={selectedMetric} />
+            <GpuStatsTable
+              data={currentData}
+              metricKey={selectedMetric}
+              storedStats={currentArtifact?.series?.stats}
+            />
           </Card>
         </>
       )}
diff --git a/packages/app/src/components/gpu-power/GpuStatsTable.tsx b/packages/app/src/components/gpu-power/GpuStatsTable.tsx
index 2d569786a..d301f5acb 100644
--- a/packages/app/src/components/gpu-power/GpuStatsTable.tsx
+++ b/packages/app/src/components/gpu-power/GpuStatsTable.tsx
@@ -1,9 +1,11 @@
 'use client';
 
 import React, { useMemo, useState } from 'react';
+import type { GpuMetricStatRow } from '@semianalysisai/inferencex-db/queries/gpu-metrics';
 
 import { track } from '@/lib/analytics';
 import { useLocale } from '@/lib/use-locale';
+import { storedGpuStatsForMetric } from './stored-gpu-stats';
 
 import {
   type GpuMetricKey,
@@ -16,18 +18,26 @@ import {
 interface GpuStatsTableProps {
   data: GpuMetricRow[];
   metricKey: GpuMetricKey;
+  /** Full-record digest; omit only for live artifacts without stored statistics. */
+  storedStats?: readonly GpuMetricStatRow[];
 }
 
 type SortCol = keyof GpuStats;
 
 const fmtStat = (v: number) => (v >= 1000 ? v.toFixed(0) : v.toFixed(1));
 
-const GpuStatsTable = React.memo(({ data, metricKey }: GpuStatsTableProps) => {
+const GpuStatsTable = React.memo(({ data, metricKey, storedStats }: GpuStatsTableProps) => {
   const locale = useLocale();
   const [sortCol, setSortCol] = useState<SortCol>('gpuIndex');
   const [sortAsc, setSortAsc] = useState(true);
 
-  const stats = useMemo(() => computeGpuStats(data, metricKey), [data, metricKey]);
+  const stats = useMemo(
+    () =>
+      storedStats === undefined
+        ? computeGpuStats(data, metricKey)
+        : storedGpuStatsForMetric(storedStats, metricKey),
+    [data, metricKey, storedStats],
+  );
   const metricConfig = ALL_METRIC_OPTIONS.find((m) => m.key === metricKey)!;
 
   const sorted = useMemo(
@@ -66,47 +76,54 @@ const GpuStatsTable = React.memo(({ data, metricKey }: GpuStatsTableProps) => {
   ];
 
   return (
-    <div className="overflow-x-auto">
-      <table className="w-full text-xs">
-        <thead>
-          <tr className="border-b">
-            {cols.map((c) => (
-              <th
-                key={c.key}
-                className="px-2 py-1.5 text-left font-medium text-muted-foreground"
-                aria-sort={sortCol === c.key ? (sortAsc ? 'ascending' : 'descending') : 'none'}
-              >
-                <button
-                  type="button"
-                  className="cursor-pointer select-none hover:text-foreground"
-                  onClick={() => handleSort(c.key)}
+    <div>
+      <p className="mb-2 text-xs text-muted-foreground" data-testid="gpu-stats-scope">
+        {locale === 'zh'
+          ? '全记录统计，包含服务启动与 warmup；不随图表所选时间窗口变化。'
+          : 'Full-record statistics include startup and warmup; the selected chart window does not change this table.'}
+      </p>
+      <div className="overflow-x-auto">
+        <table className="w-full text-xs">
+          <thead>
+            <tr className="border-b">
+              {cols.map((c) => (
+                <th
+                  key={c.key}
+                  className="px-2 py-1.5 text-left font-medium text-muted-foreground"
+                  aria-sort={sortCol === c.key ? (sortAsc ? 'ascending' : 'descending') : 'none'}
                 >
-                  {c.label}
-                  {c.key !== 'gpuIndex' && c.key !== 'count' ? ` (${metricConfig.unit})` : ''}
-                  {sortCol === c.key && (sortAsc ? ' \u2191' : ' \u2193')}
-                </button>
-              </th>
-            ))}
-          </tr>
-        </thead>
-        <tbody>
-          {sorted.map((s) => (
-            <tr key={s.gpuIndex} className="border-b border-border/50 hover:bg-muted/50">
-              <td className="px-2 py-1 font-medium">{s.gpuIndex}</td>
-              <td className="px-2 py-1">
-                {locale === 'zh' ? s.count.toLocaleString('zh-CN') : s.count.toLocaleString()}
-              </td>
-              <td className="px-2 py-1">{fmtStat(s.min)}</td>
-              <td className="px-2 py-1">{fmtStat(s.max)}</td>
-              <td className="px-2 py-1">{fmtStat(s.mean)}</td>
-              <td className="px-2 py-1">{fmtStat(s.median)}</td>
-              <td className="px-2 py-1">{fmtStat(s.p95)}</td>
-              <td className="px-2 py-1">{fmtStat(s.p99)}</td>
-              <td className="px-2 py-1">{fmtStat(s.stddev)}</td>
+                  <button
+                    type="button"
+                    className="cursor-pointer select-none hover:text-foreground"
+                    onClick={() => handleSort(c.key)}
+                  >
+                    {c.label}
+                    {c.key !== 'gpuIndex' && c.key !== 'count' ? ` (${metricConfig.unit})` : ''}
+                    {sortCol === c.key && (sortAsc ? ' \u2191' : ' \u2193')}
+                  </button>
+                </th>
+              ))}
             </tr>
-          ))}
-        </tbody>
-      </table>
+          </thead>
+          <tbody>
+            {sorted.map((s) => (
+              <tr key={s.gpuIndex} className="border-b border-border/50 hover:bg-muted/50">
+                <td className="px-2 py-1 font-medium">{s.gpuIndex}</td>
+                <td className="px-2 py-1">
+                  {locale === 'zh' ? s.count.toLocaleString('zh-CN') : s.count.toLocaleString()}
+                </td>
+                <td className="px-2 py-1">{fmtStat(s.min)}</td>
+                <td className="px-2 py-1">{fmtStat(s.max)}</td>
+                <td className="px-2 py-1">{fmtStat(s.mean)}</td>
+                <td className="px-2 py-1">{fmtStat(s.median)}</td>
+                <td className="px-2 py-1">{fmtStat(s.p95)}</td>
+                <td className="px-2 py-1">{fmtStat(s.p99)}</td>
+                <td className="px-2 py-1">{fmtStat(s.stddev)}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
     </div>
   );
 });
diff --git a/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx b/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
new file mode 100644
index 000000000..816de67e3
--- /dev/null
+++ b/packages/app/src/components/gpu-power/TelemetryDisplayControls.tsx
@@ -0,0 +1,139 @@
+'use client';
+
+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 { track } from '@/lib/analytics';
+import { useLocale } from '@/lib/use-locale';
+
+import {
+  SMOOTHING_WINDOWS_S,
+  type SmoothingWindowS,
+  type TelemetryDisplayMode,
+  type TelemetryDisplayState,
+  type TelemetrySeriesMode,
+} from './telemetry-smoothing';
+
+const STRINGS = {
+  en: {
+    display: 'Display',
+    points: 'Points',
+    rolling: 'Rolling average',
+    window: 'Window',
+    windowOption: (s: number) => `${s} s`,
+    series: 'Lines',
+    chips: 'Per chip',
+    mean: 'Mean of chips',
+    both: 'Both',
+  },
+  zh: {
+    display: '显示方式',
+    points: '数据点',
+    rolling: '滚动平均',
+    window: '窗口',
+    windowOption: (s: number) => `${s} 秒`,
+    series: '曲线',
+    chips: '单芯片',
+    mean: '芯片均值',
+    both: '两者',
+  },
+} as const;
+
+interface Props {
+  value: TelemetryDisplayState;
+  onChange: (next: TelemetryDisplayState) => void;
+  /** Analytics event prefix, e.g. `gpu_metrics` → `gpu_metrics_display_mode_changed`. */
+  analyticsPrefix: string;
+  /** Prefix for control ids so two charts on one page do not collide. */
+  idPrefix: string;
+  className?: string;
+}
+
+/**
+ * Display-mode controls shared by the PowerX explorer and the per-point PowerX
+ * tab: raw samples vs. a time-window rolling average, and per-chip lines vs.
+ * the mean across the visible chips.
+ */
+export function TelemetryDisplayControls({
+  value,
+  onChange,
+  analyticsPrefix,
+  idPrefix,
+  className,
+}: Props) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+
+  const modeOptions: SegmentedToggleOption<TelemetryDisplayMode>[] = [
+    { value: 'points', label: t.points, testId: `${idPrefix}-mode-points` },
+    { value: 'rolling', label: t.rolling, testId: `${idPrefix}-mode-rolling` },
+  ];
+  const seriesOptions: SegmentedToggleOption<TelemetrySeriesMode>[] = [
+    { value: 'chips', label: t.chips, testId: `${idPrefix}-series-chips` },
+    { value: 'mean', label: t.mean, testId: `${idPrefix}-series-mean` },
+    { value: 'both', label: t.both, testId: `${idPrefix}-series-both` },
+  ];
+
+  return (
+    <div className={className} data-testid={`${idPrefix}-controls`}>
+      <div className="flex flex-wrap items-end gap-x-4 gap-y-3">
+        <div className="space-y-1">
+          <Label id={`${idPrefix}-mode-label`}>{t.display}</Label>
+          <SegmentedToggle
+            value={value.mode}
+            options={modeOptions}
+            role="group"
+            ariaLabel={t.display}
+            onValueChange={(mode) => {
+              track(`${analyticsPrefix}_display_mode_changed`, { mode });
+              onChange({ ...value, mode });
+            }}
+          />
+        </div>
+        {value.mode === 'rolling' && (
+          <div className="space-y-1">
+            <Label htmlFor={`${idPrefix}-window`}>{t.window}</Label>
+            <Select
+              value={String(value.windowS)}
+              onValueChange={(raw) => {
+                const windowS = Number(raw) as SmoothingWindowS;
+                track(`${analyticsPrefix}_smoothing_window_changed`, { windowS });
+                onChange({ ...value, windowS });
+              }}
+            >
+              <SelectTrigger id={`${idPrefix}-window`} className="w-24" size="sm">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {SMOOTHING_WINDOWS_S.map((s) => (
+                  <SelectItem key={s} value={String(s)}>
+                    {t.windowOption(s)}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+        )}
+        <div className="space-y-1">
+          <Label id={`${idPrefix}-series-label`}>{t.series}</Label>
+          <SegmentedToggle
+            value={value.series}
+            options={seriesOptions}
+            role="group"
+            ariaLabel={t.series}
+            onValueChange={(series) => {
+              track(`${analyticsPrefix}_series_mode_changed`, { series });
+              onChange({ ...value, series });
+            }}
+          />
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/packages/app/src/components/gpu-power/chart-data.test.ts b/packages/app/src/components/gpu-power/chart-data.test.ts
new file mode 100644
index 000000000..f7912f47c
--- /dev/null
+++ b/packages/app/src/components/gpu-power/chart-data.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { buildCorrelationData, buildGroupedData, buildTelemetryData } from './chart-data';
+import type { GpuMetricRow } from './types';
+
+const rows: GpuMetricRow[] = [
+  { timestamp: '2026-09-21T00:00:00Z', index: 0, power: 100 },
+  { timestamp: '2026-09-21T00:00:02Z', index: 1, power: 200, temperature: 40 },
+  { timestamp: '2026-09-21T00:00:03Z', index: 1, power: 250 },
+  { timestamp: '2026-09-21T00:00:04Z', index: 1, power: 0, temperature: 0 },
+];
+
+describe('shared telemetry chart preparation', () => {
+  it('keeps the whole-series time origin when a chip is hidden and skips missing readings', () => {
+    const { t0Ms, groups } = buildTelemetryData(rows, new Set([1]), 'temperature');
+    expect(t0Ms).toBe(Date.parse(rows[0].timestamp));
+    expect(groups.get(1)?.map(({ seconds, ms, value }) => ({ seconds, ms, value }))).toEqual([
+      { seconds: 2, ms: t0Ms + 2000, value: 40 },
+      { seconds: 4, ms: t0Ms + 4000, value: 0 },
+    ]);
+    expect(groups.has(0)).toBe(false);
+    expect(buildGroupedData(rows, new Set([1]), 'temperature').get(1)).toEqual([
+      { seconds: 2, value: 40, gpuIndex: 1, raw: rows[1] },
+      { seconds: 4, value: 0, gpuIndex: 1, raw: rows[3] },
+    ]);
+  });
+
+  it('omits unsampled correlation metrics while retaining measured zeros', () => {
+    expect(buildCorrelationData(rows, new Set([0, 1]), 'power', 'temperature')).toEqual([
+      { x: 200, y: 40, gpuIndex: 1, raw: rows[1] },
+      { x: 0, y: 0, gpuIndex: 1, raw: rows[3] },
+    ]);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/chart-data.ts b/packages/app/src/components/gpu-power/chart-data.ts
index 7c0aef074..51db731f9 100644
--- a/packages/app/src/components/gpu-power/chart-data.ts
+++ b/packages/app/src/components/gpu-power/chart-data.ts
@@ -1,10 +1,16 @@
 import type { GpuMetricKey, GpuMetricRow } from './types';
 export interface ParsedPoint {
   seconds: number;
+  /** Absolute sample time in ms; smoothing and alignment work in this space. */
+  ms: number;
   value: number;
   gpuIndex: number;
-  raw: GpuMetricRow;
+  /** The raw sample behind this point; null once the value has been averaged. */
+  raw: GpuMetricRow | null;
+  /** For the mean line: how many chips contributed at this timestamp. */
+  count?: number;
 }
+
 function parseTimestamp(raw: string): Date | null {
   const isoDate = new Date(raw);
   if (!isNaN(isoDate.getTime())) return isoDate;
@@ -15,28 +21,33 @@ function parseTimestamp(raw: string): Date | null {
   return null;
 }
 
-export function buildGroupedData(
+export function buildTelemetryData(
   data: GpuMetricRow[],
   visibleGpus: Set<number>,
   metricKey: GpuMetricKey,
-): Map<number, ParsedPoint[]> {
+): { t0Ms: number; groups: Map<number, ParsedPoint[]> } {
+  // t=0 is the first sample of the whole series, not of the visible chips, so
+  // hiding a chip never shifts the time axis under the remaining lines.
   let minTime = Infinity;
   const parsed: { row: GpuMetricRow; ms: number }[] = [];
   for (const row of data) {
-    if (!visibleGpus.has(row.index)) continue;
     const time = parseTimestamp(row.timestamp);
     if (!time) continue;
     const ms = time.getTime();
-    parsed.push({ row, ms });
     if (ms < minTime) minTime = ms;
+    if (visibleGpus.has(row.index)) parsed.push({ row, ms });
   }
 
   const groups = new Map<number, ParsedPoint[]>();
   for (const { row, ms } of parsed) {
+    const value = row[metricKey];
+    // A metric the collector never sampled has no point, not a zero.
+    if (value === undefined) continue;
     if (!groups.has(row.index)) groups.set(row.index, []);
     groups.get(row.index)!.push({
       seconds: (ms - minTime) / 1000,
-      value: row[metricKey] ?? 0,
+      ms,
+      value,
       gpuIndex: row.index,
       raw: row,
     });
@@ -44,7 +55,19 @@ export function buildGroupedData(
   for (const points of groups.values()) {
     points.sort((a, b) => a.seconds - b.seconds);
   }
-  return groups;
+  return { t0Ms: minTime, groups };
+}
+
+/** Keep the read-only view's serialized point shape while sharing chart preparation. */
+export function buildGroupedData(
+  data: GpuMetricRow[],
+  visibleGpus: Set<number>,
+  metricKey: GpuMetricKey,
+) {
+  const { groups } = buildTelemetryData(data, visibleGpus, metricKey);
+  return new Map(
+    [...groups].map(([index, points]) => [index, points.map(({ ms: _ms, ...point }) => point)]),
+  );
 }
 
 export function buildCorrelationData(
@@ -55,5 +78,9 @@ export function buildCorrelationData(
 ) {
   return data
     .filter((r) => visibleGpus.has(r.index))
-    .map((r) => ({ x: r[xMetric] ?? 0, y: r[yMetric] ?? 0, gpuIndex: r.index, raw: r }));
+    .flatMap((r) => {
+      const x = r[xMetric];
+      const y = r[yMetric];
+      return x === undefined || y === undefined ? [] : [{ x, y, gpuIndex: r.index, raw: r }];
+    });
 }
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
new file mode 100644
index 000000000..c181eac2d
--- /dev/null
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.test.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+
+import { meanAcrossSeries, rollingTimeAverage, type TimedSample } from './telemetry-smoothing';
+
+const T0 = Date.parse('2026-09-15T21:36:14.107Z');
+
+/** One sample per second starting at T0, values from `values`. */
+function everySecond(values: number[], offsetMs = 0): TimedSample[] {
+  return values.map((value, i) => ({ ms: T0 + offsetMs + i * 1000, value }));
+}
+
+describe('rollingTimeAverage', () => {
+  it('averages a centered window and shrinks it at the series edges', () => {
+    // 1 s cadence, 2 s window => each sample sees itself and its immediate neighbours.
+    const out = rollingTimeAverage(everySecond([100, 200, 600, 200, 100]), 2000);
+    expect(out.map((p) => p.value)).toEqual([150, 300, 1000 / 3, 300, 150]);
+    expect(out.map((p) => p.ms)).toEqual(everySecond([0, 0, 0, 0, 0]).map((p) => p.ms));
+  });
+});
+
+describe('meanAcrossSeries', () => {
+  it('picks the nearest sample when a chip dropped a row', () => {
+    const chip0 = everySecond([0, 0, 0, 0]);
+    const chip1: TimedSample[] = [
+      { ms: T0, value: 10 },
+      // row at T0 + 1000 dropped
+      { ms: T0 + 2000, value: 30 },
+      { ms: T0 + 3000, value: 40 },
+    ];
+    const out = meanAcrossSeries([chip0, chip1], 400);
+    expect(out.map((p) => p.count)).toEqual([2, 1, 2, 2]);
+    expect(out.map((p) => p.value)).toEqual([5, 0, 15, 20]);
+  });
+});
diff --git a/packages/app/src/components/gpu-power/telemetry-smoothing.ts b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
new file mode 100644
index 000000000..a9ec9a307
--- /dev/null
+++ b/packages/app/src/components/gpu-power/telemetry-smoothing.ts
@@ -0,0 +1,160 @@
+/**
+ * Pure time-series helpers for the PowerX telemetry charts. They operate on
+ * absolute millisecond timestamps so irregular sampling (dropped rows, a few
+ * ms of skew between chips) is handled by time, not by sample index.
+ */
+
+export interface TimedSample {
+  /** Absolute timestamp in milliseconds since the Unix epoch. */
+  ms: number;
+  value: number;
+}
+
+/** Rolling-average window choices offered by the chart controls, in seconds. */
+export const SMOOTHING_WINDOWS_S = [10, 30, 60, 300] as const;
+export type SmoothingWindowS = (typeof SMOOTHING_WINDOWS_S)[number];
+
+export interface AggregatedSample extends TimedSample {
+  /** Number of chips that contributed a sample within tolerance. */
+  count: number;
+}
+
+export type TelemetryDisplayMode = 'points' | 'rolling';
+/** Per-chip lines, one mean line across the visible chips, or both. */
+export type TelemetrySeriesMode = 'chips' | 'mean' | 'both';
+
+export interface TelemetryDisplayState {
+  mode: TelemetryDisplayMode;
+  windowS: SmoothingWindowS;
+  series: TelemetrySeriesMode;
+}
+
+/** Rolling average is the default: at 1 s cadence the raw points read as noise. */
+export const DEFAULT_TELEMETRY_DISPLAY: TelemetryDisplayState = {
+  mode: 'rolling',
+  windowS: 30,
+  series: 'chips',
+};
+
+/**
+ * Centered time-window mean. Each output sample averages every input sample
+ * whose timestamp lies within `windowMs / 2` (inclusive) of its own, so the
+ * smoothed line stays time-aligned with the raw one instead of lagging by half
+ * a window as a trailing average would. Window edges are inclusive on both
+ * sides; samples near the start or end of the series average over the shorter
+ * one-sided neighbourhood that exists.
+ *
+ * `samples` must be sorted by `ms` ascending. O(n) via prefix sums.
+ */
+export function rollingTimeAverage(
+  samples: readonly TimedSample[],
+  windowMs: number,
+): TimedSample[] {
+  if (samples.length === 0) return [];
+  if (!(windowMs > 0)) return samples.map(({ ms, value }) => ({ ms, value }));
+  const half = windowMs / 2;
+  const n = samples.length;
+  const prefix = new Float64Array(n + 1);
+  for (let i = 0; i < n; i += 1) prefix[i + 1] = prefix[i]! + samples[i]!.value;
+
+  const out: TimedSample[] = Array.from({ length: n });
+  let lo = 0;
+  let hi = 0;
+  for (let i = 0; i < n; i += 1) {
+    const center = samples[i]!.ms;
+    while (samples[lo]!.ms < center - half) lo += 1;
+    while (hi < n && samples[hi]!.ms <= center + half) hi += 1;
+    const count = hi - lo;
+    out[i] = { ms: center, value: (prefix[hi]! - prefix[lo]!) / count };
+  }
+  return out;
+}
+
+/**
+ * Median gap between consecutive samples, in ms. Used as the alignment
+ * tolerance when averaging chips that were polled a few ms apart. Falls back
+ * to `fallbackMs` when fewer than two distinct timestamps exist.
+ */
+export function estimateSampleIntervalMs(
+  samples: readonly TimedSample[],
+  fallbackMs = 1000,
+): number {
+  const gaps: number[] = [];
+  for (let i = 1; i < samples.length; i += 1) {
+    const gap = samples[i]!.ms - samples[i - 1]!.ms;
+    if (gap > 0) gaps.push(gap);
+  }
+  if (gaps.length === 0) return fallbackMs;
+  gaps.sort((a, b) => a - b);
+  return gaps[Math.floor(gaps.length / 2)]!;
+}
+
+/**
+ * Mean across several chips at each timestamp of the reference chip (the one
+ * with the most samples, first on ties). For every reference sample each other
+ * chip contributes its nearest sample if that sample lies within
+ * `toleranceMs`; chips with no sample that close are left out of that mean
+ * rather than interpolated, and `count` records how many contributed.
+ *
+ * Every inner array must be sorted by `ms` ascending.
+ */
+export function meanAcrossSeries(
+  series: readonly (readonly TimedSample[])[],
+  toleranceMs: number,
+): AggregatedSample[] {
+  const populated = series.filter((s) => s.length > 0);
+  if (populated.length === 0) return [];
+  let reference = populated[0]!;
+  for (const s of populated) if (s.length > reference.length) reference = s;
+  const others = populated.filter((s) => s !== reference);
+  const cursors: number[] = Array.from({ length: others.length }, () => 0);
+  const tolerance = Math.max(0, toleranceMs);
+
+  return reference.map((ref) => {
+    let sum = ref.value;
+    let count = 1;
+    for (let k = 0; k < others.length; k += 1) {
+      const other = others[k]!;
+      let cursor = cursors[k]!;
+      while (
+        cursor + 1 < other.length &&
+        Math.abs(other[cursor + 1]!.ms - ref.ms) <= Math.abs(other[cursor]!.ms - ref.ms)
+      ) {
+        cursor += 1;
+      }
+      cursors[k] = cursor;
+      const candidate = other[cursor]!;
+      if (Math.abs(candidate.ms - ref.ms) <= tolerance) {
+        sum += candidate.value;
+        count += 1;
+      }
+    }
+    return { ms: ref.ms, value: sum / count, count };
+  });
+}
+
+/**
+ * Convert a relative-seconds series (`t` from its own start) to absolute
+ * milliseconds so it can share an x-axis with wall-clock telemetry.
+ */
+export function toAbsoluteMs(
+  points: readonly { t: number; value: number }[],
+  originMs: number,
+): TimedSample[] {
+  return points.map((p) => ({ ms: originMs + p.t * 1000, value: p.value }));
+}
+
+/** Sample nearest to `ms` (earlier one on a tie), or null when the series is empty. */
+export function nearestSample(samples: readonly TimedSample[], ms: number): TimedSample | null {
+  if (samples.length === 0) return null;
+  let lo = 0;
+  let hi = samples.length - 1;
+  while (lo < hi) {
+    const mid = (lo + hi) >> 1;
+    if (samples[mid]!.ms < ms) lo = mid + 1;
+    else hi = mid;
+  }
+  const after = samples[lo]!;
+  const before = lo > 0 ? samples[lo - 1]! : after;
+  return Math.abs(before.ms - ms) <= Math.abs(after.ms - ms) ? before : after;
+}
diff --git a/packages/app/src/components/gpu-power/types.test.ts b/packages/app/src/components/gpu-power/types.test.ts
index cefd8d6ef..1d741a5fa 100644
--- a/packages/app/src/components/gpu-power/types.test.ts
+++ b/packages/app/src/components/gpu-power/types.test.ts
@@ -3,11 +3,9 @@ import { describe, expect, it } from 'vitest';
 import {
   ALL_METRIC_OPTIONS,
   computeGpuStats,
-  detectAnomalies,
   detectTdpFromArtifactName,
   getAvailableMetrics,
   type GpuMetricRow,
-  GPU_METRIC_OPTIONS,
   parseCsvData,
 } from './types';
 
@@ -47,49 +45,16 @@ describe('parseCsvData', () => {
     expect(result[1].power).toBe(76.08);
   });
 
-  it('parses CSV with bare numeric values (no unit suffixes)', () => {
-    const csv = `${CSV_HEADER}
-2024-01-15T10:00:00Z, 0, 250.5, 72, 1980, 1593, 95, 80
-2024-01-15T10:00:00Z, 1, 300.2, 68, 1950, 1593, 88, 75`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(2);
-    expect(result[0].power).toBe(250.5);
-    expect(result[0].smClock).toBe(1980);
-    expect(result[1].power).toBe(300.2);
-  });
-
   it('returns empty array for header-only CSV', () => {
     expect(parseCsvData(CSV_HEADER)).toEqual([]);
   });
 
-  it('returns empty array for empty string', () => {
-    expect(parseCsvData('')).toEqual([]);
-  });
-
-  it('skips rows with insufficient columns', () => {
-    const csv = `${CSV_HEADER}
-2026/03/07 00:20:37.071, 0, 76.78 W
-2026/03/07 00:20:37.071, 1, 76.08 W, 29, 345 MHz, 3201 MHz, 0 %, 0 %`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(1);
-    expect(result[0].index).toBe(1);
-  });
-
   it('skips rows with NaN values', () => {
     const csv = `${CSV_HEADER}
 2026/03/07 00:20:37.071, abc, 76.78 W, 30, 345 MHz, 3201 MHz, 0 %, 0 %`;
     expect(parseCsvData(csv)).toEqual([]);
   });
 
-  it('trims whitespace from values', () => {
-    const csv = `${CSV_HEADER}
- 2026/03/07 00:20:37.071 , 0 , 76.78 W , 30 , 345 MHz , 3201 MHz , 0 % , 0 % `;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(1);
-    expect(result[0].timestamp).toBe('2026/03/07 00:20:37.071');
-    expect(result[0].power).toBe(76.78);
-  });
-
   it('handles Windows-style line endings', () => {
     const csv = `${CSV_HEADER}\r\n2026/03/07 00:20:37.071, 0, 76.78 W, 30, 345 MHz, 3201 MHz, 0 %, 0 %\r\n`;
     const result = parseCsvData(csv);
@@ -97,19 +62,6 @@ describe('parseCsvData', () => {
     expect(result[0].power).toBe(76.78);
   });
 
-  it('parses multiple timestamps for same GPU correctly', () => {
-    const csv = `${CSV_HEADER}
-2026/03/07 00:20:37.071, 0, 76.78 W, 30, 345 MHz, 3201 MHz, 0 %, 0 %
-2026/03/07 00:20:38.076, 0, 76.70 W, 30, 345 MHz, 3201 MHz, 0 %, 0 %
-2026/03/07 00:20:39.076, 0, 80.49 W, 31, 345 MHz, 3201 MHz, 0 %, 0 %`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(3);
-    expect(result[0].power).toBe(76.78);
-    expect(result[1].power).toBe(76.7);
-    expect(result[2].power).toBe(80.49);
-    expect(result[2].temperature).toBe(31);
-  });
-
   it('ignores extra columns beyond the expected 8', () => {
     const csv = `${CSV_HEADER}
 2026/03/07 00:20:37.071, 0, 76.78, 30, 345, 3201, 0, 0, extra1, extra2`;
@@ -119,21 +71,6 @@ describe('parseCsvData', () => {
     expect(result[0].memUtil).toBe(0);
   });
 
-  it('handles 8-GPU real-world scenario', () => {
-    const lines = [];
-    for (let gpu = 0; gpu < 8; gpu++) {
-      lines.push(
-        `2026/03/07 00:20:37.071, ${gpu}, ${300 + gpu * 10}, ${65 + gpu}, 1980, 1593, 95, 80`,
-      );
-    }
-    const csv = `${CSV_HEADER}\n${lines.join('\n')}`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(8);
-    expect(result[7].index).toBe(7);
-    expect(result[7].power).toBe(370);
-    expect(result[7].temperature).toBe(72);
-  });
-
   // --- AMD amd-smi format ---
 
   it('auto-detects and parses AMD amd-smi CSV format', () => {
@@ -178,18 +115,6 @@ describe('parseCsvData', () => {
     expect(result[0].temperature).toBe(38); // falls back to edge
   });
 
-  it('AMD: handles quoted array fields with embedded commas', () => {
-    const amdHeader =
-      'timestamp,gpu,gfx_activity,umc_activity,mm_activity,vcn_activity,jpeg_activity,socket_power,gfx_0_clk,mem_0_clk,edge,hotspot,mem';
-    const csv = `${amdHeader}
-1772939616,0,95,80,N/A,"['N/A', 'N/A', 'N/A', 'N/A']","['N/A', 'N/A']",350,1980,901,38,72,65`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(1);
-    expect(result[0].power).toBe(350);
-    expect(result[0].smClock).toBe(1980);
-    expect(result[0].temperature).toBe(72);
-  });
-
   it('AMD: parses real-world amd-smi row with all columns', () => {
     // Full amd-smi header with ~100+ columns
     const amdHeader =
@@ -207,26 +132,6 @@ describe('parseCsvData', () => {
     expect(result[0].temperature).toBe(40); // hotspot
   });
 
-  it('AMD: parses 8 GPUs from same timestamp', () => {
-    const amdHeader =
-      'timestamp,gpu,gfx_activity,umc_activity,socket_power,gfx_0_clk,mem_0_clk,edge,hotspot,mem';
-    const lines = [];
-    for (let gpu = 0; gpu < 8; gpu++) {
-      lines.push(
-        `1772939616,${gpu},${90 + gpu},${70 + gpu},${300 + gpu * 5},${1900 + gpu * 10},901,${35 + gpu},${60 + gpu},${50 + gpu}`,
-      );
-    }
-    const csv = `${amdHeader}\n${lines.join('\n')}`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(8);
-    expect(result[0].index).toBe(0);
-    expect(result[7].index).toBe(7);
-    expect(result[7].power).toBe(335);
-    expect(result[7].gpuUtil).toBe(97);
-    expect(result[7].temperature).toBe(67); // hotspot
-    expect(result[7].smClock).toBe(1970);
-  });
-
   it('AMD: skips rows with N/A power', () => {
     const amdHeader =
       'timestamp,gpu,gfx_activity,umc_activity,socket_power,gfx_0_clk,mem_0_clk,edge,hotspot,mem';
@@ -245,7 +150,7 @@ describe('parseCsvData', () => {
 1772939616,0,0,0,135,133,901,N/A,N/A,41`;
     const result = parseCsvData(csv);
     expect(result).toHaveLength(1);
-    expect(result[0].temperature).toBe(0); // defaults to 0 when both are N/A
+    expect(result[0].temperature).toBeUndefined();
   });
 
   it('AMD: populates all AMD-specific metric fields', () => {
@@ -279,17 +184,6 @@ describe('parseCsvData', () => {
     expect(result[0].fclk).toBe(1300);
     expect(result[0].socClk).toBe(28);
   });
-
-  it('NVIDIA: does not have AMD-specific fields', () => {
-    const csv = `${CSV_HEADER}
-2026/03/07 00:20:37.071, 0, 300, 65, 1980, 1593, 95, 80`;
-    const result = parseCsvData(csv);
-    expect(result).toHaveLength(1);
-    expect(result[0].edgeTemp).toBeUndefined();
-    expect(result[0].memTemp).toBeUndefined();
-    expect(result[0].gfxVoltage).toBeUndefined();
-    expect(result[0].fclk).toBeUndefined();
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -297,22 +191,6 @@ describe('parseCsvData', () => {
 // ---------------------------------------------------------------------------
 
 describe('getAvailableMetrics', () => {
-  it('returns only common metrics for NVIDIA data', () => {
-    const nvidiaRow: GpuMetricRow = {
-      timestamp: '2026/03/07 00:20:37.071',
-      index: 0,
-      power: 300,
-      temperature: 65,
-      smClock: 1980,
-      memClock: 1593,
-      gpuUtil: 95,
-      memUtil: 80,
-    };
-    const metrics = getAvailableMetrics([nvidiaRow]);
-    const keys = metrics.map((m) => m.key);
-    expect(keys).toEqual(['power', 'temperature', 'smClock', 'memClock', 'gpuUtil', 'memUtil']);
-  });
-
   it('returns common + AMD metrics for AMD data', () => {
     const amdRow: GpuMetricRow = {
       timestamp: '2026-03-07T00:00:00Z',
@@ -364,11 +242,6 @@ describe('getAvailableMetrics', () => {
     expect(keys).not.toContain('gfxVoltage');
     expect(keys).not.toContain('fclk');
   });
-
-  it('returns common metrics for empty data', () => {
-    const metrics = getAvailableMetrics([]);
-    expect(metrics.length).toBe(6);
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -383,54 +256,14 @@ describe('detectTdpFromArtifactName', () => {
     expect(result).toEqual({ sku: 'H200', tdp: 700 });
   });
 
-  it('detects H100 from artifact name', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp8_h100-sxm_0');
-    expect(result).toEqual({ sku: 'H100', tdp: 700 });
-  });
-
   it('detects GB200 without matching B200', () => {
     const result = detectTdpFromArtifactName('gpu_metrics_model_fp4_gb200-nvl72_0');
     expect(result).toEqual({ sku: 'GB200', tdp: 1200 });
   });
 
-  it('detects GB300 without matching B300', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp4_gb300-nvl72_0');
-    expect(result).toEqual({ sku: 'GB300', tdp: 1400 });
-  });
-
-  it('detects B200 when no GB prefix', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp4_b200-sxm_0');
-    expect(result).toEqual({ sku: 'B200', tdp: 1000 });
-  });
-
-  it('detects B300 when no GB prefix', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp4_b300-sxm_0');
-    expect(result).toEqual({ sku: 'B300', tdp: 1200 });
-  });
-
-  it('detects MI300X from artifact name', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp8_mi300x_0');
-    expect(result).toEqual({ sku: 'MI300X', tdp: 750 });
-  });
-
-  it('detects MI325X from artifact name', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp8_mi325x_0');
-    expect(result).toEqual({ sku: 'MI325X', tdp: 1000 });
-  });
-
-  it('detects MI355X from artifact name', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp4_mi355x_0');
-    expect(result).toEqual({ sku: 'MI355X', tdp: 1400 });
-  });
-
   it('returns null for unrecognized GPU', () => {
     expect(detectTdpFromArtifactName('gpu_metrics_model_fp8_unknown_0')).toBeNull();
   });
-
-  it('is case-insensitive', () => {
-    const result = detectTdpFromArtifactName('gpu_metrics_model_fp8_H200-SXM_0');
-    expect(result).toEqual({ sku: 'H200', tdp: 700 });
-  });
 });
 
 // ---------------------------------------------------------------------------
@@ -451,187 +284,11 @@ function makeRow(
   };
 }
 
-// ---------------------------------------------------------------------------
-// detectAnomalies
-// ---------------------------------------------------------------------------
-
-describe('detectAnomalies', () => {
-  it('returns empty array for empty data', () => {
-    expect(detectAnomalies([], 'power')).toEqual([]);
-  });
-
-  it('detects statistical outliers via MAD', () => {
-    const rows: GpuMetricRow[] = [];
-    for (let i = 0; i < 10; i++) {
-      rows.push(
-        makeRow({
-          timestamp: `2026/03/07 00:20:${37 + i}.000`,
-          index: 0,
-          power: i === 9 ? 600 : 300 + (i % 3),
-        }),
-      );
-    }
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'statistical')).toBe(true);
-    const stat = anomalies.find((a) => a.type === 'statistical')!;
-    expect(stat.gpuIndex).toBe(0);
-    expect(stat.value).toBe(600);
-  });
-
-  it('detects thermal throttle above 83°C', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, temperature: 70 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'thermal')).toBe(true);
-    const thermal = anomalies.find((a) => a.type === 'thermal')!;
-    expect(thermal.value).toBe(85);
-  });
-
-  it('detects near-TDP power draw', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 300 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 650 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, power: 300 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power', 'gpu_metrics_h200_test');
-    expect(anomalies.some((a) => a.type === 'near_tdp')).toBe(true);
-  });
-
-  it('does not flag near-TDP without artifact name', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 650 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 650 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, power: 650 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'near_tdp')).toBe(false);
-  });
-
-  it('detects utilization drop to 0% after high usage', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, gpuUtil: 95 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, gpuUtil: 0 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, gpuUtil: 90 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'util_drop')).toBe(true);
-  });
-
-  it('does not flag all-identical values as anomalies', () => {
-    const rows: GpuMetricRow[] = [];
-    for (let i = 0; i < 10; i++) {
-      rows.push(makeRow({ timestamp: `2026/03/07 00:20:${37 + i}.000`, index: 0, power: 300 }));
-    }
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.filter((a) => a.type === 'statistical')).toHaveLength(0);
-  });
-
-  it('deduplicates anomalies at same second', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:37.500', index: 0, temperature: 86 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, temperature: 65 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    const thermals = anomalies.filter(
-      (a) => a.type === 'thermal' && a.gpuIndex === 0 && Math.round(a.seconds) === 0,
-    );
-    expect(thermals).toHaveLength(1);
-  });
-
-  it('detects clock drop when SM clock drops >30% below median', () => {
-    const rows: GpuMetricRow[] = [];
-    // 9 rows at 1980 MHz, 1 row at 1000 MHz (49% drop)
-    for (let i = 0; i < 10; i++) {
-      rows.push(
-        makeRow({
-          timestamp: `2026/03/07 00:20:${37 + i}.000`,
-          index: 0,
-          smClock: i === 5 ? 1000 : 1980,
-        }),
-      );
-    }
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'clock_drop')).toBe(true);
-    const drop = anomalies.find((a) => a.type === 'clock_drop')!;
-    expect(drop.value).toBe(1000);
-  });
-
-  it('detects anomalies independently per GPU', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 1, temperature: 85 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 1, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 1, temperature: 65 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'temperature');
-    const thermals = anomalies.filter((a) => a.type === 'thermal');
-    expect(thermals).toHaveLength(2);
-    expect(thermals.map((a) => a.gpuIndex).toSorted()).toEqual([0, 1]);
-  });
-
-  it('skips GPU groups with fewer than 3 samples for MAD detection', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 100 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 900 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    // Only 2 samples — MAD-based statistical detection should be skipped
-    expect(anomalies.filter((a) => a.type === 'statistical')).toHaveLength(0);
-  });
-
-  it('anomaly message includes GPU index and metric value', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 2, temperature: 65 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 2, temperature: 90 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 2, temperature: 65 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'temperature');
-    const thermal = anomalies.find((a) => a.type === 'thermal')!;
-    expect(thermal.message).toContain('Chip 2');
-    expect(thermal.message).toContain('90');
-    expect(thermal.message).toContain('83');
-  });
-
-  it('does not flag util_drop when previous utilization is <= 50%', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, gpuUtil: 40 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, gpuUtil: 0 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, gpuUtil: 50 }),
-    ];
-    const anomalies = detectAnomalies(rows, 'power');
-    expect(anomalies.some((a) => a.type === 'util_drop')).toBe(false);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // computeGpuStats
 // ---------------------------------------------------------------------------
 
 describe('computeGpuStats', () => {
-  it('computes correct statistics for a single GPU', () => {
-    const rows = [
-      makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 0, power: 100 }),
-      makeRow({ timestamp: '2026/03/07 00:20:38.000', index: 0, power: 200 }),
-      makeRow({ timestamp: '2026/03/07 00:20:39.000', index: 0, power: 300 }),
-      makeRow({ timestamp: '2026/03/07 00:20:40.000', index: 0, power: 400 }),
-      makeRow({ timestamp: '2026/03/07 00:20:41.000', index: 0, power: 500 }),
-    ];
-    const stats = computeGpuStats(rows, 'power');
-    expect(stats).toHaveLength(1);
-    expect(stats[0].gpuIndex).toBe(0);
-    expect(stats[0].count).toBe(5);
-    expect(stats[0].min).toBe(100);
-    expect(stats[0].max).toBe(500);
-    expect(stats[0].mean).toBe(300);
-    expect(stats[0].median).toBe(300);
-  });
-
   it('returns stats per GPU sorted by index', () => {
     const rows = [
       makeRow({ timestamp: '2026/03/07 00:20:37.000', index: 1, power: 200 }),
@@ -695,23 +352,3 @@ describe('computeGpuStats', () => {
     expect(stats[0].stddev).toBe(0);
   });
 });
-
-// ---------------------------------------------------------------------------
-// GPU_METRIC_OPTIONS
-// ---------------------------------------------------------------------------
-
-describe('GPU_METRIC_OPTIONS', () => {
-  it('covers all 6 GpuMetricKey values', () => {
-    const keys = GPU_METRIC_OPTIONS.map((m) => m.key);
-    expect(keys).toEqual(['power', 'temperature', 'smClock', 'memClock', 'gpuUtil', 'memUtil']);
-  });
-
-  it('each option has non-empty label, unit, and yAxisLabel', () => {
-    for (const opt of GPU_METRIC_OPTIONS) {
-      expect(opt.label.length).toBeGreaterThan(0);
-      expect(opt.unit.length).toBeGreaterThan(0);
-      expect(opt.yAxisLabel.length).toBeGreaterThan(0);
-      expect(opt.yAxisLabel).toContain(opt.unit);
-    }
-  });
-});
diff --git a/packages/app/src/components/gpu-power/types.ts b/packages/app/src/components/gpu-power/types.ts
index 814eb2bb5..6c82d5616 100644
--- a/packages/app/src/components/gpu-power/types.ts
+++ b/packages/app/src/components/gpu-power/types.ts
@@ -1,24 +1,16 @@
 import { HW_REGISTRY } from '@semianalysisai/inferencex-constants';
-
-export interface GpuMetricRow {
-  timestamp: string;
-  index: number;
-  power: number;
-  temperature: number;
-  smClock: number;
-  memClock: number;
-  gpuUtil: number;
-  memUtil: number;
-  // AMD-specific optional fields
-  edgeTemp?: number;
-  memTemp?: number;
-  gfxVoltage?: number;
-  socVoltage?: number;
-  memVoltage?: number;
-  fclk?: number;
-  socClk?: number;
-  mmActivity?: number;
-}
+import {
+  parseAmdTimestamp,
+  parseNvidiaTimestamp,
+  splitCsvLine,
+} from '@semianalysisai/inferencex-db/etl/gpu-metrics-csv';
+import type {
+  GpuMetricSampleRow,
+  GpuMetricSeries,
+  GpuMetricStatRow,
+} from '@semianalysisai/inferencex-db/queries/gpu-metrics';
+
+export type GpuMetricRow = GpuMetricSampleRow;
 
 export interface GpuPowerRunInfo {
   id: number;
@@ -34,6 +26,8 @@ export interface GpuPowerRunInfo {
 export interface GpuMetricsArtifact {
   name: string;
   data: GpuMetricRow[];
+  /** Only database-backed artifacts carry the full-record digest. */
+  series?: Omit<GpuMetricSeries, 'data'>;
 }
 
 export interface GpuPowerApiResponse {
@@ -199,17 +193,24 @@ export const ALL_METRIC_OPTIONS: GpuMetricConfig[] = [...GPU_METRIC_OPTIONS, ...
 
 /**
  * Returns the metric options that have data in the given dataset.
- * AMD-specific metrics are only shown when at least one row has a non-undefined value.
+ * A metric is shown only when at least one row has a finite reading.
  */
 export function getAvailableMetrics(data: GpuMetricRow[]): GpuMetricConfig[] {
   if (data.length === 0) return GPU_METRIC_OPTIONS;
-  return ALL_METRIC_OPTIONS.filter((m) => data.some((row) => row[m.key] !== undefined));
+  return ALL_METRIC_OPTIONS.filter((m) => data.some((row) => Number.isFinite(row[m.key])));
 }
 
 /**
  * Detect GPU SKU from an artifact name and return its TDP in watts.
  * Artifact names look like: gpu_metrics_dsr1_1k8k_fp8_sglang_tp8_..._h200-nb_0
  */
+/** TDP for a known hardware key, e.g. the benchmark point's own `hardware`. */
+export function tdpForHardware(hardware: string | undefined): { sku: string; tdp: number } | null {
+  const key = hardware?.toLowerCase();
+  const entry = key ? HW_REGISTRY[key] : undefined;
+  return entry ? { sku: key!.toUpperCase(), tdp: entry.tdp } : null;
+}
+
 export function detectTdpFromArtifactName(
   artifactName: string,
 ): { sku: string; tdp: number } | null {
@@ -224,21 +225,6 @@ export function detectTdpFromArtifactName(
   return null;
 }
 
-export interface Anomaly {
-  type: 'statistical' | 'thermal' | 'near_tdp' | 'clock_drop' | 'util_drop';
-  label: string;
-  gpuIndex: number;
-  seconds: number;
-  value: number;
-  message: string;
-}
-
-function median(values: number[]): number {
-  const sorted = [...values].toSorted((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-}
-
 function parseTimestampToMs(raw: string): number | null {
   const d = new Date(raw);
   if (!isNaN(d.getTime())) return d.getTime();
@@ -247,158 +233,6 @@ function parseTimestampToMs(raw: string): number | null {
   return null;
 }
 
-/**
- * Detect anomalies in GPU metrics data using MAD-based Modified Z-score
- * (per NIST/Iglewicz & Hoaglin, threshold 3.5) plus domain-specific GPU thresholds.
- */
-export function detectAnomalies(
-  data: GpuMetricRow[],
-  metricKey: GpuMetricKey,
-  artifactName?: string,
-): Anomaly[] {
-  if (data.length === 0) return [];
-
-  const anomalies: Anomaly[] = [];
-  const tdpInfo = artifactName ? detectTdpFromArtifactName(artifactName) : null;
-
-  // Find earliest timestamp for seconds calculation
-  let minTime = Infinity;
-  for (const row of data) {
-    const ms = parseTimestampToMs(row.timestamp);
-    if (ms !== null && ms < minTime) minTime = ms;
-  }
-
-  // Group by GPU index
-  const gpuGroups = new Map<number, GpuMetricRow[]>();
-  for (const row of data) {
-    if (!gpuGroups.has(row.index)) gpuGroups.set(row.index, []);
-    gpuGroups.get(row.index)!.push(row);
-  }
-
-  for (const [gpuIndex, rows] of gpuGroups) {
-    const rawValues = rows.map((r) => r[metricKey]);
-    // Skip if any values are undefined (metric not available for this vendor)
-    if (rawValues.some((v) => v === undefined)) continue;
-    const values = rawValues as number[];
-    if (values.length < 3) continue;
-
-    // MAD-based Modified Z-score detection
-    const med = median(values);
-    const absDeviations = values.map((v) => Math.abs(v - med));
-    const mad = median(absDeviations);
-
-    // Pre-compute SM clock median for clock_drop detection (avoid O(n^2))
-    const smMedian =
-      metricKey === 'smClock' || metricKey === 'power' ? median(rows.map((r) => r.smClock)) : 0;
-
-    for (let i = 0; i < rows.length; i++) {
-      const row = rows[i];
-      const ms = parseTimestampToMs(row.timestamp);
-      const seconds = ms === null ? i : (ms - minTime) / 1000;
-
-      // Statistical outlier (MAD)
-      if (mad > 0) {
-        const modifiedZ = (0.6745 * (values[i] - med)) / mad;
-        if (Math.abs(modifiedZ) > 3.5) {
-          anomalies.push({
-            type: 'statistical',
-            label: 'Statistical Outlier',
-            gpuIndex,
-            seconds,
-            value: values[i],
-            message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: ${metricKey} = ${values[i].toFixed(1)} (Modified Z = ${modifiedZ.toFixed(1)}, median = ${med.toFixed(1)})`,
-          });
-        }
-      }
-
-      // Domain-specific: thermal throttle (temperature > 83°C)
-      if (row.temperature > 83) {
-        anomalies.push({
-          type: 'thermal',
-          label: 'Thermal Throttle',
-          gpuIndex,
-          seconds,
-          value: row.temperature,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: temperature ${row.temperature}°C exceeds throttle threshold (83°C)`,
-        });
-      }
-
-      // Domain-specific: near TDP (power > 90% of TDP)
-      if (tdpInfo && row.power > tdpInfo.tdp * 0.9) {
-        anomalies.push({
-          type: 'near_tdp',
-          label: 'Near TDP',
-          gpuIndex,
-          seconds,
-          value: row.power,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: power ${row.power.toFixed(1)}W is ${((row.power / tdpInfo.tdp) * 100).toFixed(0)}% of TDP (${tdpInfo.tdp}W)`,
-        });
-      }
-
-      // Domain-specific: clock drop (SM clock > 30% below median)
-      if (
-        (metricKey === 'smClock' || metricKey === 'power') &&
-        smMedian > 0 &&
-        row.smClock < smMedian * 0.7
-      ) {
-        anomalies.push({
-          type: 'clock_drop',
-          label: 'Clock Drop',
-          gpuIndex,
-          seconds,
-          value: row.smClock,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: SM clock ${row.smClock} MHz dropped ${((1 - row.smClock / smMedian) * 100).toFixed(0)}% below median (${smMedian.toFixed(0)} MHz)`,
-        });
-      }
-
-      // Domain-specific: utilization drop (GPU util = 0 after being > 50%)
-      if (row.gpuUtil === 0 && i > 0 && rows[i - 1].gpuUtil > 50) {
-        anomalies.push({
-          type: 'util_drop',
-          label: 'Utilization Drop',
-          gpuIndex,
-          seconds,
-          value: 0,
-          message: `Chip ${gpuIndex} at ${seconds.toFixed(0)}s: utilization dropped to 0% (was ${rows[i - 1].gpuUtil}%)`,
-        });
-      }
-    }
-  }
-
-  // Deduplicate: keep only one anomaly per (type, gpuIndex, second)
-  const seen = new Set<string>();
-  const deduped = anomalies.filter((a) => {
-    const key = `${a.type}_${a.gpuIndex}_${Math.round(a.seconds)}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-
-  return deduped.toSorted((a, b) => a.seconds - b.seconds);
-}
-
-/**
- * Split a CSV line respecting double-quoted fields (which may contain commas).
- * Required for AMD amd-smi CSV where array fields like "['N/A', 'N/A']" are quoted.
- */
-function splitCsvLine(line: string): string[] {
-  const result: string[] = [];
-  let current = '';
-  let inQuotes = false;
-  for (const char of line) {
-    if (char === '"') {
-      inQuotes = !inQuotes;
-    } else if (char === ',' && !inQuotes) {
-      result.push(current.trim());
-      current = '';
-    } else {
-      current += char;
-    }
-  }
-  result.push(current.trim());
-  return result;
-}
-
 /**
  * Build a column-index lookup from a CSV header line.
  * Returns a map of header name → column index.
@@ -407,7 +241,7 @@ function buildColumnMap(headerLine: string): Map<string, number> {
   const headers = splitCsvLine(headerLine);
   const map = new Map<string, number>();
   for (let i = 0; i < headers.length; i++) {
-    map.set(headers[i].toLowerCase(), i);
+    map.set(headers[i].toLowerCase().replace(/\s*\[.*\]$/u, ''), i);
   }
   return map;
 }
@@ -418,40 +252,39 @@ function buildColumnMap(headerLine: string): Map<string, number> {
  * clocks.current.sm [MHz], clocks.current.memory [MHz], utilization.gpu [%], utilization.memory [%]
  */
 function parseNvidiaCsv(lines: string[]): GpuMetricRow[] {
+  const columns = buildColumnMap(lines[0]);
+  const col = (name: string) => columns.get(name) ?? -1;
+  const iTimestamp = col('timestamp');
+  const iIndex = col('index');
+  const iPower = col('power.draw');
+  if (iTimestamp < 0 || iIndex < 0 || iPower < 0) return [];
   const results: GpuMetricRow[] = [];
   for (let i = 1; i < lines.length; i++) {
     const cols = lines[i].split(',').map((c) => c.trim());
-    if (cols.length < 8) continue;
-
-    const index = parseInt(cols[1], 10);
-    const power = parseFloat(cols[2]);
-    const temperature = parseFloat(cols[3]);
-    const smClock = parseFloat(cols[4]);
-    const memClock = parseFloat(cols[5]);
-    const gpuUtil = parseFloat(cols[6]);
-    const memUtil = parseFloat(cols[7]);
-
-    if ([index, power, temperature, smClock, memClock, gpuUtil, memUtil].some(isNaN)) continue;
+    if (cols.length <= Math.max(iTimestamp, iIndex, iPower)) continue;
+    const index = parseInt(cols[iIndex], 10);
+    const power = safeFloat(cols[iPower]);
+    if (!Number.isInteger(index) || index < 0 || power === undefined) continue;
 
     results.push({
-      timestamp: cols[0],
+      timestamp: cols[iTimestamp],
       index,
       power,
-      temperature,
-      smClock,
-      memClock,
-      gpuUtil,
-      memUtil,
+      temperature: safeFloat(cols[col('temperature.gpu')]),
+      smClock: safeFloat(cols[col('clocks.current.sm')]),
+      memClock: safeFloat(cols[col('clocks.current.memory')]),
+      gpuUtil: safeFloat(cols[col('utilization.gpu')]),
+      memUtil: safeFloat(cols[col('utilization.memory')]),
     });
   }
   return results;
 }
 
-/** Safely parse a float, returning undefined for N/A or unparseable values. */
+/** Missing, unparseable and nonfinite readings stay absent; measured zero is valid. */
 function safeFloat(val: string | undefined): number | undefined {
   if (val === undefined || val === 'N/A' || val === '') return undefined;
   const n = parseFloat(val);
-  return isNaN(n) ? undefined : n;
+  return Number.isFinite(n) ? n : undefined;
 }
 
 /**
@@ -484,28 +317,25 @@ function parseAmdCsv(lines: string[], colMap: Map<string, number>): GpuMetricRow
   const results: GpuMetricRow[] = [];
   for (let i = 1; i < lines.length; i++) {
     const cols = splitCsvLine(lines[i]);
-    if (cols.length < 3) continue;
+    if (cols.length <= Math.max(iTimestamp, iGpu, iPower)) continue;
 
     const index = parseInt(cols[iGpu], 10);
-    const power = parseFloat(cols[iPower]);
+    const power = safeFloat(cols[iPower]);
     // Prefer hotspot temp, fall back to edge
-    let temperature = iHotspot >= 0 ? parseFloat(cols[iHotspot]) : NaN;
-    if (isNaN(temperature) && iEdge >= 0) temperature = parseFloat(cols[iEdge]);
-    const smClock = iGfxClk >= 0 ? parseFloat(cols[iGfxClk]) : 0;
-    const memClock = iMemClk >= 0 ? parseFloat(cols[iMemClk]) : 0;
-    const gpuUtil = iGfxActivity >= 0 ? parseFloat(cols[iGfxActivity]) : 0;
-    const memUtil = iUmcActivity >= 0 ? parseFloat(cols[iUmcActivity]) : 0;
-
-    if (isNaN(index) || isNaN(power)) continue;
-    if (isNaN(temperature)) temperature = 0;
-
-    // AMD timestamps are Unix epoch seconds — convert to ms-based string for consistency
-    const rawTimestamp = cols[iTimestamp];
-    const epochSec = parseFloat(rawTimestamp);
-    const timestamp =
-      !isNaN(epochSec) && epochSec > 1e9 && epochSec < 1e11
-        ? new Date(epochSec * 1000).toISOString()
-        : rawTimestamp;
+    const temperature = safeFloat(cols[iHotspot]) ?? safeFloat(cols[iEdge]);
+    const smClock = safeFloat(cols[iGfxClk]);
+    const memClock = safeFloat(cols[iMemClk]);
+    const gpuUtil = safeFloat(cols[iGfxActivity]);
+    const memUtil = safeFloat(cols[iUmcActivity]);
+
+    if (!Number.isInteger(index) || index < 0 || power === undefined) continue;
+
+    // Round epoch fractions exactly as ingest does before constructing the dedup key.
+    const timestampMs = parseAmdTimestamp(cols[iTimestamp]);
+    if (timestampMs === null) continue;
+    const date = new Date(timestampMs);
+    if (!Number.isFinite(date.getTime())) continue;
+    const timestamp = date.toISOString();
 
     // AMD-specific metrics
     const edgeTemp = iEdge >= 0 ? safeFloat(cols[iEdge]) : undefined;
@@ -552,28 +382,27 @@ export function parseCsvData(csvText: string): GpuMetricRow[] {
 
   const headerLower = lines[0].toLowerCase();
 
-  // Detect AMD format by checking for amd-smi specific columns
-  if (headerLower.includes('socket_power') || headerLower.includes('gfx_activity')) {
-    const colMap = buildColumnMap(lines[0]);
-    return parseAmdCsv(lines, colMap);
-  }
-
-  return parseNvidiaCsv(lines);
+  const rows =
+    headerLower.includes('socket_power') || headerLower.includes('gfx_activity')
+      ? parseAmdCsv(lines, buildColumnMap(lines[0]))
+      : parseNvidiaCsv(lines);
+  // Normalize one CSV at a time: host-local indices may repeat in other files.
+  // Keep the first device/timestamp sample, matching the persisted digest.
+  const seen = new Set<string>();
+  return rows.filter((row) => {
+    // NVIDIA's naive collector clock must not use the reader's local DST rules.
+    const ms = parseNvidiaTimestamp(row.timestamp) ?? parseTimestampToMs(row.timestamp);
+    if (ms === null || !Number.isFinite(ms)) return false;
+    const key = `${row.index}:${ms}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
 }
 
 // --- Statistics ---
 
-export interface GpuStats {
-  gpuIndex: number;
-  count: number;
-  min: number;
-  max: number;
-  mean: number;
-  median: number;
-  p95: number;
-  p99: number;
-  stddev: number;
-}
+export type GpuStats = Omit<GpuMetricStatRow, 'metric'>;
 
 function percentile(sorted: number[], p: number): number {
   const idx = (p / 100) * (sorted.length - 1);
@@ -587,7 +416,7 @@ export function computeGpuStats(data: GpuMetricRow[], metricKey: GpuMetricKey):
   const groups = new Map<number, number[]>();
   for (const row of data) {
     const val = row[metricKey];
-    if (val === undefined) continue;
+    if (val === undefined || !Number.isFinite(val)) continue;
     if (!groups.has(row.index)) groups.set(row.index, []);
     groups.get(row.index)!.push(val);
   }
diff --git a/packages/app/src/lib/d3-chart/layers/lines.ts b/packages/app/src/lib/d3-chart/layers/lines.ts
index 075a1be71..885e0630d 100644
--- a/packages/app/src/lib/d3-chart/layers/lines.ts
+++ b/packages/app/src/lib/d3-chart/layers/lines.ts
@@ -9,6 +9,8 @@ export interface LineConfig {
   /** Optional per-series SVG dash pattern; return `none` for a solid line. */
   getStrokeDasharray?: (key: string) => string;
   strokeWidth?: number;
+  /** Optional per-series stroke width; falls back to `strokeWidth`, then 2. */
+  getStrokeWidth?: (key: string) => number;
   curve?: d3.CurveFactory;
   /** Return false to create gaps in the line (e.g., missing data points). */
   isDefined?: (d: { x: number; y: number }) => boolean;
@@ -61,7 +63,7 @@ export function renderLines(
     .attr('class', (d) => `line-path line-${d.key}`)
     .attr('stroke', (d) => config.getColor(d.key))
     .attr('stroke-dasharray', (d) => config.getStrokeDasharray?.(d.key) ?? null)
-    .attr('stroke-width', config.strokeWidth ?? 2)
+    .attr('stroke-width', (d) => config.getStrokeWidth?.(d.key) ?? config.strokeWidth ?? 2)
     .attr('d', (d) => lineGenerator(d.points));
 }
 

From 13fd98cb771228370eb2b9c5f4a389c42ce52ca7 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:27:46 -0700
Subject: [PATCH 097/103] docs: PowerX persistence runbook and telemetry
 pipeline notes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Document the telemetry digest, receipts, migration prerequisites, targeted repair and
rollback, the gpu-metrics views route, and the new API route entries.

中文：记录遥测摘要、回执、迁移前置条件、定向修复与回滚、gpu-metrics views 路由及新增 API 路由条目。
---
 AGENTS.md                           |   1 +
 docs/dashboard-readonly-views.md    |  13 +-
 docs/data-pipeline.md               | 216 +++++++++++++++++--
 docs/index.md                       |   1 +
 docs/powerx-persistence-recovery.md | 307 ++++++++++++++++++++++++++++
 5 files changed, 520 insertions(+), 18 deletions(-)
 create mode 100644 docs/powerx-persistence-recovery.md

diff --git a/AGENTS.md b/AGENTS.md
index baf40e2dc..61be9ec0e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -85,6 +85,7 @@ API routes (`packages/app/src/app/api/v1/`):
 - `reliability` — raw `ReliabilityRow[]`
 - `evaluations` — raw `EvalRow[]`
 - `server-log` — retrieve benchmark runtime logs
+- `gpu-metrics-point?id=N` — PowerX chip telemetry (samples + per-GPU digest) linked to one benchmark point
 - `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
diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 1ca378966..04294ebce 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -44,7 +44,9 @@ combinations, not the full Cartesian product of all possible filter values.
 - Evaluation/reliability: chart-data, date resolution and rolling aggregation.
 - CollectiveX: selected EP/KV/swap chart and fit helpers.
 - Submissions/images: existing table, weekly/cumulative and image freshness helpers.
-- GPU metrics: shared line/correlation transforms and unsampled statistics.
+- GPU metrics: shared line/correlation transforms and stored full-record per-GPU
+  digests. Live artifacts alone calculate statistics from samples; empty stored
+  digests remain empty. File/host identity and missing-versus-zero semantics persist.
 - Video: checksum-verified stored bundles, serving/fidelity selectors and tradeoffs.
 - Overview/rankings/compare: existing discovery-page assembly and scenario helpers.
 
@@ -61,6 +63,11 @@ OperatorX is feature-gated in navigation and uses page-owned
 contract.
 Zoom, theme, axis scale, labels, media playback and report expansion are renderer
 state. GPU interactive downsampling does not alter returned raw data or statistics.
+The GPU statistics table includes startup and warmup for all chips in the selected
+series, regardless of chip visibility. It is separate from serving-window power,
+J/token and selected-time-window calculations. Run telemetry is DB-first with an
+artifact fallback for missing storage; the public view returns private, no-store
+responses and preserves upstream 503 failures.
 
 Run-specific recognition labels are also presentation-only. Run `35879254139`
 displays `UMBP MoRI SGLang` through October 9, 2026 in America/New_York
@@ -89,6 +96,10 @@ those properties.
 私有上传、密钥、提示词、反馈及管理操作不作为公开读取接口。
 OperatorX 的入口受功能开关控制，页面使用专属的 `/api/v1/operatorx/*`
 接口；目前没有发布 `/api/v1/views/operatorx` 契约。
+GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全记录统计使用所选文件、
+主机序列的全部芯片摘要，包含启动与 warmup；已有摘要为空时不补算，缺失读数不补零。
+芯片显隐和图表降采样不改变该统计，也不改变 serving-window 或 J/token 的计算口径。
+响应使用 private, no-store，上游 503 保留为错误响应。
 
 测试覆盖契约同步及代表性的筛选行为，并未穷举所有参数组合。生产数据库上的
 完整 UI/API 对照仍需集成审查，不能仅凭单元测试宣称已完成。
diff --git a/docs/data-pipeline.md b/docs/data-pipeline.md
index ca9a196aa..a7a365103 100644
--- a/docs/data-pipeline.md
+++ b/docs/data-pipeline.md
@@ -84,23 +84,36 @@ must use the append-only contract below.
 
 ### Required Power Publication
 
-Ordinary sweeps that opt into `require-power` upload the producer's
-`required-power-sweep-manifest/sweep_manifest.json`. Before any CI ingest upsert,
-the app matches its required benchmark rows by recipe fingerprint, concurrency,
-and scenario/sequence lengths, then requires valid v2 power and positive energy.
-Disaggregated recipes also require both role energy measurements. Identical
-per-job and collected artifact copies are allowed; conflicting copies fail.
-Matching uses the ingest mapper's canonical identity, including AgentX `users`
-precedence over `conc`. After benchmark writes, any required point omitted by a
-purge or another filter fails the run; purged data is never restored to satisfy
-the declaration.
-
-The manifest must name the source run and head. A successful earlier attempt of
-that same run may supply the scope and retained points when failed jobs are
-rerun; ingestion logs both declared and current attempts. Sweeps without this
-optional manifest keep historical behavior. The separate PowerX publication
-receipt compares ingested 8K/1K and AgentX measurements with the database and
-public API after cache invalidation; it does not assert browser rendering.
+Required ordinary sweeps upload a versioned
+`required-power-sweep-manifest/sweep_manifest.json`. The [shared v2 fixture and
+contract](./fixtures/powerx-manifest-v2/README.md) bind the complete required
+matrix to source run/head/attempt, point identities, topology, exact measurement
+windows, physical node/GPU roles and hashed evidence. Both repositories test the
+same bytes. Unversioned required manifests fail closed; optional legacy bundles
+retain their existing behavior.
+
+Artifact preparation validates required evidence before workflow migrations.
+Required intent also travels in the dispatch payload, so losing both the manifest
+and changelog marker cannot downgrade an ordinary required dispatch. Ingestion
+repeats validation before workflow/config upserts, checks purges/backfills before
+writing, and projects the resulting published curves from base-table state. It
+models the actual latest-attempt, whole-curve and same-image append-only rules.
+An unexplained loss of an existing recipe or concurrency point rejects ingestion.
+Destructive replacement requires exact old-snapshot and lost-point identities in
+the manifest; the ordinary producer supplies no such permission.
+
+The source run and head must match. A successful earlier attempt of that same run
+may supply retained evidence when failed jobs are rerun; ingestion logs declared
+and current attempts. Required energy must be finite and positive. Missing,
+invalid and measured zero remain different values even though all fail this gate.
+Disaggregated deployments require physical evidence for both roles.
+
+This is pure preflight, not atomic publication. Schema migrations occur after
+artifact validation but before the curve check. Concurrent writers and failures
+during the existing per-file importer remain a risk; staging plus an atomic,
+serialized promotion is the follow-up described in the contract. The separate
+PowerX receipt still compares source measurements against the DB and exact-run
+API after ingestion. It does not prove latest-curve visibility or browser rendering.
 
 ### Append-Only Curve Extensions
 
@@ -526,6 +539,175 @@ Producers (`aggregate_power.py`) annotate every aggregate result row with two op
 
 Reads are **permanently tolerant**: `queries/benchmarks.ts` selects the columns as `to_jsonb(br) -> 'power_invalid_reasons'` (and `lb` on the matview branch) rather than bare column references. A bare reference fails during query planning until the next ingest workflow applies the migration, because migrations run in the ingest workflows rather than at Vercel deploy. The key lookup degrades to NULL while the column is missing and is byte-identical once it exists, making deploy order irrelevant.
 
+### PowerX Telemetry Digest (`gpu_metric_*`, migration 016)
+
+Every single-node benchmark job (`benchmark-tmpl.yml`) samples `nvidia-smi` /
+`amd-smi` once per second for its whole lifetime and uploads the CSV as
+`gpu_metrics_<suffix>` next to `bmk_<suffix>` (agentic jobs: `bmk_agentic_<suffix>`,
+still paired by the bare suffix). The multinode template uploads no `gpu_metrics_`
+artifact; its telemetry travels inside `power_audit_<suffix>` as
+`LOGS/power/samples.csv`, one deployment-wide CSV written by srt-slurm's
+`dcgm-power` collector (`timestamp_unix, hostname, gpu_index, gpu_uuid, power_w`,
+power only). `etl/multinode-power-samples.ts` regroups it per host and the ingest
+stores one series per host (`file_name` = `LOGS/power/samples.csv#<hostname>`),
+so multinode and disaggregated points get per-GPU power curves with null clocks,
+temperature and utilization. Single-node jobs upload a `power_audit_` bundle too,
+so discovery and backfill pairing use it only for a suffix with no `gpu_metrics_`
+upload. The PowerX explorer used to download and parse the artifacts from GitHub
+on every request and lost them after GitHub's 90-day retention. CI ingest now
+digests them at ingest time, in the same step that links server logs:
+
+- `gpu_metric_series` — one row per (workflow run, artifact, CSV path): vendor,
+  CSV sha256, sample count, GPU count, recorded window, median cadence, and the
+  parsed sidecars (`gpu_metrics_context.json`, identity, amd-smi energy counters).
+- `gpu_metric_samples` — full-resolution rows, one per (GPU, sample). NVIDIA
+  fills the six common columns; AMD additionally fills edge/memory temperature,
+  voltages, FCLK/SOCCLK and multimedia activity. Timestamps are UTC; NVIDIA's
+  zone-less `YYYY/MM/DD HH:MM:SS.mmm` is interpreted with the context sidecar's
+  `timestamp_timezone` (the producer writes UTC).
+- `gpu_metric_gpu_stats` — per (series, GPU, metric) count/min/max/mean/median/
+  p95/p99/stddev computed at ingest; matching algorithm versions avoid rescanning samples.
+- `benchmark_result_gpu_metrics` — links each benchmark point to the series that
+  was recorded while it ran (several series per point for multinode artifacts).
+
+Ingest is idempotent: the same CSV hash, sidecars, and unique sample count refresh
+only the point links when `stats_version` matches `GPU_STATS_VERSION`. An outdated
+digest is rebuilt without replacing samples or links. A source change replaces the samples and digest inside one
+transaction, including corrected timezone or identity sidecars. Repeated samples
+keep the first row per (GPU, timestamp) before computing counts and statistics,
+matching the sample table's primary key. Explicitly re-ingesting a run also
+repairs older duplicate-inflated counts and digests; `--all` skips runs already
+containing series, so target those runs with `--run` or use `--force`. Series are
+stored per artifact, not per point: an AgentX per-concurrency job maps to one
+point, while older fixed-sequence jobs that swept several concurrencies in one
+job share one series across points. Windowing a series to the measured serving
+interval is a reader concern; the raw series deliberately includes server
+start-up and warm-up so both phases can be inspected.
+
+Run readers filter artifact prefixes and requested Timeline sources in SQL before
+loading samples. The public GPU metrics view loads only its selected file/host
+series while retaining the complete artifact-name inventory. Both point and run
+readers fetch samples in primary-key pages of at most 10,000 rows, preserving
+microsecond cursors and returning the complete selected series in time order.
+
+The point and run readers assemble a series from separate autocommit statements
+(series rows, statistics, samples). After loading, they re-read the series
+version key (`csv_sha256`, `sample_count`, `ingested_at`, `stats_version`) and retry the whole
+read when a re-ingest committed in between, so one payload never mixes the
+statistics of one version with the samples of another.
+
+`bun run admin:db:backfill-gpu-metrics --all --yes` attaches telemetry for runs
+ingested before this migration. The reachable history is bounded by GitHub's
+90-day artifact retention (the upload step sets no `retention-days`) because the
+GCS backup, which keeps every artifact name, only mirrors `schedule` and `push`
+runs on `main`; PR sweeps and manual dispatches — nearly every telemetry-bearing
+run — are never copied. Our own GCS reader (`lib/gcs-artifacts.ts`) additionally
+ignores everything but `bmk_`/`server_logs_` objects, so widening the mirror's run
+filter would also need a reader change before backfill could use it.
+
+Readers: `/api/gpu-metrics?runId=` serves stored telemetry first, including
+`series=power` Timeline buckets reconstructed with retained windows and device
+identities. Missing storage falls back to GitHub artifacts. Known-incomplete CSV
+fallback must match retained filenames and sample counts; known-incomplete bundles
+need exact-source re-ingest. Healthy DB series remain in mixed fallback responses.
+Database failures return `503 DATABASE_UNAVAILABLE`; incomplete storage without
+usable fallback returns `503 STORED_TELEMETRY_INCOMPLETE` with re-ingest guidance.
+Timeline requests use read-only POST with sorted validation basenames in a `sources`
+JSON body. Stored coverage of those identities permits an artifact-independent response;
+missing siblings, including other windows in the same bundle, use source-level DB-first
+merging. Unavailable artifacts leave healthy DB traces readable with explicit missing
+sources. `sourceCoverage` describes only the requested identities; legacy GET reports
+coverage unknown. Plain CSV fallback applies the adjacent context timezone just like
+ingest and bundle reads. Raw multi-file artifacts retain separate file/host series.
+Successful reads and storage errors use no-store.
+
+AgentX nested validation documents are matched to the exact root result and retained
+window before receiving a canonical validation filename alias. Original path, result
+filename and validation hash remain in stored sidecars. CI attaches recovered source
+and window metadata before benchmark publication/upsert; targeted telemetry re-ingest
+fills only NULL provenance for a unique explicit run/result/concurrency match, even
+when samples are unchanged. Metrics and validity remain untouched. Benchmark metadata
+repair additionally needs the existing materialized-view refresh and benchmark-cache
+invalidation before the UI planner can discover the restored Timeline source.
+
+`/api/v1/gpu-metrics-point?id=` powers the PowerX point-detail tab. Every request
+checks the current DB revision before reading its Blob payload cache. Sidecar repairs,
+new point links and shared-series changes therefore select fresh payloads without a
+manual purge. Success, missing-point and error responses use no-store; missing data
+is 404 and database failures remain errors. Cache-write failures log a warning and
+serve the fresh uncached result; the next request retries cache population.
+
+The public `/api/v1/views/gpu-metrics` projection and full-record UI table use the
+same per-GPU statistics digest for the selected file/host series. Current-version
+empty or missing metric digests remain empty. Unversioned or outdated digests
+are recomputed read-only from retained DB samples with the shared ingest algorithm.
+Incomplete retained samples leave statistics empty while preserving raw data for
+the existing source-gap recovery path; stats-only writes fail until the source is repaired.
+Statistics include startup and warmup, retain measured zero, and exclude missing
+readings per metric after first-wins timestamp/GPU deduplication. Mean is
+sample-weighted, percentiles interpolate at `p * (N - 1)`, and standard deviation
+divides by `N`. GPU visibility and chart downsampling do not alter this population.
+Serving-window power, J/token and selected-time-window calculations remain separate.
+
+中文：历史遥测和 Timeline 优先读取数据库；缺少存储数据时回退到 GitHub 产物，
+文件、主机与 GPU 的身份保持独立。数据库故障返回 503；已知存储不完整且无法恢复时，
+返回带定向重新入库提示的 503。Timeline 通过只读 POST 传入所需来源标识；缺失的兄弟曲线
+按来源补齐，GitHub 不可用时仍返回健康的 DB 曲线，并显式标出缺失来源。旧的 GET
+没有预期清单，覆盖状态为 unknown。sourceCoverage 仅描述本次请求，不代表整个 run
+的完整性；普通 CSV 与 bundle、ingest 使用相同的 context 时区。
+点详情每次读取先核对数据库版本，修正 sidecar 或共享关联后
+无需手动清缓存；响应均为 no-store。全记录统计使用已存摘要，包含启动与 warmup；
+缺失读数不补零；当前版本的摘要为空时保留为空，旧版本或无版本摘要从 DB 样本只读重算。它与 serving-window 功率、J/token 和
+用户所选时间窗口的统计分别处理。
+
+### Full-record statistics upgrades (migration 017)
+
+`GPU_STATS_VERSION` identifies the full-record digest algorithm, independently
+of source hashes and serving-window power schema versions. Bump it whenever
+metric populations, mappings, units or statistical definitions change. Migration
+017 marks existing series as version 0 (unknown); it does not certify old digests.
+Readers also treat a not-yet-migrated column as version 0, allowing app deployment
+before the writer migration. Read fallback does not write to the database.
+
+Point-cache revisions include both the deployed algorithm version and the stored
+version, so an algorithm deployment and subsequent digest repair each bypass old
+payloads for every linked point. Browser responses remain no-store; an already
+open tab receives the new result on its existing refetch/focus path.
+
+After applying migration 017 to the explicitly selected DB, use the existing
+backfill entry point (commands below are operator instructions, not automatic writes):
+
+```bash
+bun run admin:db:backfill-gpu-metrics --stats-only --all --dry-run
+bun run admin:db:backfill-gpu-metrics --stats-only --run <run-id> --attempt <attempt> --artifact <artifact-name> --dry-run
+bun run admin:db:backfill-gpu-metrics --stats-only --run <run-id> --attempt <attempt> --artifact <artifact-name> --yes
+```
+
+This mode uses DB samples only: no GitHub, artifact-retention cutoff, GPU work,
+benchmark publication, or cache purge. Unspecified attempts include all stored
+attempts; `--limit` counts series. Each series is locked and its digest/version
+replaced in one transaction. Current versions are no-ops, failures retain the old
+complete digest and print a scoped retry command with a nonzero exit status.
+Missing samples require source re-ingest. Successful retries skip completed series.
+DB `real` columns round to float32; comparisons with original CSV computations
+should allow float32 tolerance (e.g. 1e-5 relative), not require bit equality.
+
+Before production repair, retain a DB snapshot of affected series metadata and
+digests. Rollback stops the repair worker and restores the prior app/ingest build;
+leave the additive column in place. A prior version-aware build recomputes from
+samples when versions differ. To restore pre-versioned software and old stored
+results, restore the saved digest plus version together while writers are stopped,
+then invalidate the legacy cache. Raw samples and links are never changed by
+stats-only repair. Parser/timezone/identity fixes still require source re-ingest.
+
+中文：统计版本独立于数据 revision 和 serving-window schema。迁移先把旧摘要标记为
+未知版本；读取时可从 DB 样本重算，但不写库。`--stats-only` 支持按 run、attempt、artifact
+定向持久修复，也可覆盖全部保留历史，不依赖 GitHub 产物。每个 series 在事务内更新摘要与
+版本，失败保留旧结果并输出重试命令；成功后再次执行为 no-op。部署算法或修复摘要都会
+改变点详情缓存键，页面下次 refetch 时生效。生产修复前保留快照，回滚保留新增列；旧软件
+需要旧摘要时，停写后成对恢复摘要与版本，并清除旧缓存。此过程不修改 samples、关联或
+serving-window 指标。
+
 ### PowerX publication receipts
 
 The normal CI importer writes `POWER_PUBLICATION_MANIFEST` when configured. Each
diff --git a/docs/index.md b/docs/index.md
index 812ef351e..c67e877ae 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -9,6 +9,7 @@ Design rationale and non-obvious conventions. See [CLAUDE.md](../CLAUDE.md) for
 
 - [API Skill Examples](./inferencex-api-examples.md) — Install the public skill, query benchmarks, export measured PowerX data, and explain empty results
 - [PowerX System Power](./powerx-system-power.md) — Pinned chassis model, measured-input guards, assumptions, and reproducible article exports
+- [PowerX Persistence and Recovery](./powerx-persistence-recovery.md) — Telemetry receipts, migration prerequisites, and targeted repair
 - [API Skill Releases](./inferencex-skills-release.md) — Prepare an immutable package, verify clean installations and agent exports, and publish through the package-specific workflow
 - [API Skill Discovery](./inferencex-skills-discovery.md) — Accept or reject implicit skill discovery in fresh Codex and Claude Code projects
 - [CLI Compatibility](./inferencex-cli-compatibility.md) — Contract 1 schemas, bundle and exit semantics, platform scope, and legacy migration
diff --git a/docs/powerx-persistence-recovery.md b/docs/powerx-persistence-recovery.md
new file mode 100644
index 000000000..898d5ace7
--- /dev/null
+++ b/docs/powerx-persistence-recovery.md
@@ -0,0 +1,307 @@
+# PowerX persistence and repair
+
+PowerX point detail, the run explorer and Power Timeline read migration-016 telemetry
+from the database. Timeline applies the same prefix selection, validation-window cuts,
+60-second padding and one-second per-device means as the artifact path. Stored samples
+retain UTC timestamps, original units and separate host-local GPU identities. GitHub
+remains the fallback for telemetry that has not been stored. Database failures return an
+error, not an empty result or an artifact fallback.
+
+Timeline sends a read-only `POST /api/gpu-metrics?runId=RUN_ID&series=power&prefix=PREFIX`
+with JSON `{ "sources": ["power_validation_RESULT_FILENAME.json"] }`. The planner sorts
+and deduplicates validation basenames, and includes them in the React Query key. The body
+accepts 1–1000 identities, each RESULT_FILENAME up to 200 ASCII letters/digits/`.`/`_`/`-`,
+matching `prefix` when supplied; invalid input returns 400 and bodies above 256 KiB return 413. POST avoids putting a whole run's identity list in a URL. GET remains compatible with
+the raw explorer and existing callers.
+
+Only requested identities absent from healthy DB series trigger artifact discovery. Merging
+prefers DB by validation identity, so a live sibling window in the same bundle is retained.
+`sourceCoverage: { status, missingSources }` reports coverage of the requested identities:
+`complete` or `incomplete` for POST, `unknown` for GET without an expectation list. It is
+not a full-run/sweep or raw-sample completeness receipt. An unavailable GitHub token, listing
+or download keeps healthy requested DB series readable with incomplete coverage; it cannot
+hide known-incomplete stored telemetry or database failures. Unrelated stored artifacts
+outside the requested identities do not block that read.
+
+Live ordinary CSVs and bundle CSVs normalize NVIDIA wall-clock timestamps to ISO UTC with
+the ingest parser, so live and stored reads agree. Adjacent collector context supplies the
+offset; missing or UTC context means zero. Context must be in the same ZIP directory as
+the CSV; host directories never share offsets. When multiple context candidates exist, both
+ingest and live reads select the first valid object in code-unit filename order, independent
+of archive or filesystem listing order. ISO/AMD timestamps pass through unchanged.
+
+Both paths keep the first row for a device/timestamp, matching the existing ingest
+deduplication, before averaging distinct samples within a bucket. A discovered unreadable
+host CSV alongside readable CSVs fails telemetry preparation before any series is written;
+it cannot disappear from the stored inventory and falsely establish complete coverage.
+
+New ingests preserve validation documents, bundle manifests and expected file/sample
+inventories in the existing series sidecars. Older ingests
+can recover validation source/window from linked benchmark `power_audit` provenance.
+Information never retained, such as historical validation role overrides, cannot be
+reconstructed: recover the exact original artifact and re-ingest it. An incomplete
+stored bundle must not silently become a smaller deployment's average. Incomplete stored
+telemetry can use live CSV fallback only when every retained file and deduplicated sample
+count is present. Missing/header-only host files, truncated data, and a second incomplete
+artifact must not disappear behind another artifact's successful recovery. Complete stored
+artifacts remain in a fallback response even if their GitHub artifacts have expired.
+A known-incomplete power bundle needs re-ingest because the downloaded window cuts do not
+prove its full original host/sample inventory. Un-ingested bundles still use normal artifact
+fallback. Unverifiable recovery returns `503 STORED_TELEMETRY_INCOMPLETE` with the artifact
+and a targeted re-ingest action. DB query failures return `503 DATABASE_UNAVAILABLE` and do
+not attempt artifact fallback.
+
+The live raw explorer also keeps each CSV as a separate series, matching the database
+reader. Multi-file artifact labels include the CSV path, so host-local GPU 0 values cannot
+be merged into one device. Single-file labels remain unchanged.
+
+AgentX artifacts may retain their validation at
+`LOGS/agentic/conc_N/power_validation.json`. Both stored and artifact readers recognize
+this layout only when the exact root result filename, its `conc`, and the retained
+`LOGS/power/windows/agentic_power_concurrency_N.json` agree with the validation's
+selected window. Missing, malformed or mismatched evidence does not create a window.
+The normalized source is `power_validation_<root-result-stem>.json`; it is an alias,
+not an invented top-level file. Stored validation sidecars retain `validation_path`,
+`result_file` and the SHA-256 of the original validation bytes. Legacy top-level
+validation documents take precedence, and power-validity and role values stay unchanged.
+
+Normal CI derives missing AgentX benchmark source/window metadata before publication
+and benchmark upsert, retaining it across aggregate copies of the same full point
+identity. Targeted telemetry re-ingest also fills SQL-NULL `power_audit` after all hosts
+are stored and linked, including sample no-ops. It requires one unambiguous AgentX point
+within the caller's explicit run/result IDs with matching concurrency; it neither
+overwrites non-null provenance nor changes metrics, workers or validity. The ingest
+result reports actual `metadataUpdatedBenchmarkResultIds`. Ordinary benchmark reads
+also require the existing `latest_benchmarks` refresh and benchmark cache invalidation;
+point/Timeline revision changes alone do not refresh the UI's benchmark source list.
+
+## Cache and browser recovery
+
+`/api/v1/gpu-metrics-point?id=N` checks a live database revision before reading its existing
+Blob cache. The revision includes linked series, ingest time, CSV hash, sidecars and shared
+point links/audits. The payload stays in Blob; the revision query reads only metadata.
+Same-input ingest leaves the revision unchanged. A sidecar correction, series replacement,
+new point link or linked audit correction selects a new cache entry, including for every
+point sharing the series. Missing points are not negatively cached. A re-ingest that
+commits while the reader is between its statements changes the series version key
+(`csv_sha256`, `sample_count`, `ingested_at`), which the reader re-checks after loading
+and retries, so a payload never mixes statistics and samples from two versions.
+
+Point and Timeline responses use `Cache-Control: no-store`, so CDN/browser response caches
+cannot skip the database check. Client queries revalidate on mount and window focus.
+An already open page refreshes when revisited/refocused or reloaded; there is no continuous
+polling. A failed Blob write logs `serving uncached result`, returns fresh DB data, and is
+retried on the next read. A database failure remains an API error even if an old Blob exists.
+Old cache generations remain until the existing prefix cleanup runs; repair does not require
+a manual PowerX cache purge. General benchmark cache invalidation still follows normal CI.
+
+## Coverage receipts
+
+The existing `power-publication.json` gains an optional `telemetry` receipt, keyed by run,
+attempt and stable benchmark-point identity. Its stages distinguish expected benchmark
+attachments, produced artifacts, stored series/samples, point links and actual API readback.
+Normal CI builds expectations from benchmark rows before telemetry discovery. Backfill
+also inspects benchmark siblings whose telemetry artifact is absent. Unreadable benchmark
+siblings are recorded in `expectationErrors`; known identities still proceed independently.
+
+`plannedPointCount: null` explicitly means the full planned sweep is unknown. Attachment
+coverage over available benchmark rows does **not** prove full sweep coverage. Point,
+artifact, series and sample counts are separate: a bundle can contain multiple host series
+and multiple points can share those series. Receipt entries list missing identities,
+reasons, and exact run/attempt/artifact recovery targets. DB success leaves API status
+`unknown`; only `verify-power-publication.ts` advances it after an actual HTTP read.
+Telemetry failures remain isolated from benchmark publication failure policy.
+
+The expectation boundary is the successfully mapped, non-purged benchmark rows
+selected for ingestion, plus persisted benchmark identities recovered by the
+receipt query. It is not every raw result or every planned job. Mapping/preflight
+errors remain in the existing ingest diagnostics. Unreadable/unmappable benchmark
+rows and failed config resolution make `expectedSource` unknown while retaining
+known point identities; intentionally failed or purged benchmarks remain excluded.
+The telemetry receipt does not
+reconstruct the planned matrix, even when a separate required-power manifest is
+available; `plannedPointCount` stays null. An unreadable backfill benchmark sibling
+sets `expectationErrors` and makes `expectedPoints` unknown, including when its
+telemetry pair exists.
+Backfill preserves mapped points alongside per-row diagnostics for unmappable rows;
+multiple row errors in one benchmark artifact count as one failed artifact. Every
+mapped point in a correction must match a persisted benchmark before telemetry
+ingest can clear that artifact's recovery failure. An uploaded correction with an
+unmatched point is not a successful repair, even when older data remains readable.
+Later refreshes retain unresolved expectation errors until that exact sibling's
+identities can actually be recovered; an expired sibling cannot disappear from
+the unknown denominator.
+This also applies on the first receipt: a selected expired benchmark sibling records
+an expectation error without attempting a download. Superseded retries and unrelated
+targets remain excluded by the existing logical-name and artifact filters.
+Known failed benchmark rows remain excluded, matching normal CI.
+
+Historical backfill retains the resolver's exact-first, unique-fallback offload matching.
+A proven fallback uses the persisted point's offload identity before receipt counting
+and recovery checks, including benchmark siblings whose telemetry is absent. Repeating
+the recovery removes only the corresponding old null-ID phantom in that artifact's
+scope; real on/off points remain distinct. Conflicting artifact observations or prior
+artifact scope stay visible with an unknown denominator rather than overwriting errors.
+
+Normal CI deliberately retains successful artifacts from earlier attempts of the
+same run/head for `rerun-failed`. Receipt `runAttempt` identifies the persisted
+ingest cohort, not the collection attempt of every artifact. Per-artifact collection
+attempt is unknown unless independently retained in source provenance. Do not
+filter the normal artifact plan to the latest attempt and silently drop successful
+points. Explicit `--download .../attempts/N` rejects a different current attempt;
+targeted GitHub telemetry recovery uses its stricter current-attempt filter below.
+
+An empty or wholly unreadable telemetry correction is an ingest failure, even when
+older stored samples remain readable. A targeted recovery retains unresolved
+`recoveryError` and `recoveryArtifactNames` from other artifacts. Sequential successful
+repairs remove only their own artifact names. Older receipts with an unscoped recovery
+error require a successful full-run refresh to clear that error; repairing a different
+artifact cannot establish recovery. Retained error text describes the failed attempts;
+the remaining artifact names identify the outstanding scope.
+
+| Receipt reason       | Targeted action                                                                                                                                                     |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `artifact_missing`   | Recover the exact listed sibling from the same source provenance; use retained local bytes if GitHub no longer has that attempt. Do not substitute a newer attempt. |
+| `ingest_failed`      | Inspect the recorded error, correct the exact artifact or sidecar, then re-ingest it. Empty/unparseable CSVs do not count as a successful correction.               |
+| `point_link_missing` | Re-ingest the named unchanged artifact for the recorded run/attempt. Existing series/samples remain idempotent and the missing link is restored.                    |
+| `expectationErrors`  | Recover the named benchmark sibling first so its point identities can be enumerated; successful telemetry downloads alone do not establish the denominator.         |
+
+Apply the run/attempt/artifact selectors in each point's `recovery` object to the
+commands below, merge the same receipt, then run the HTTP verifier. A missing explicit
+target or deleted GitHub run reports failure. Neither a successful command nor the
+benchmark-level `matched` status establishes telemetry completeness: inspect the
+separate counts, unknowns and outstanding errors.
+
+The stored inventory distinguishes `storage.status` complete/incomplete/unknown. Missing
+host files and mismatched sample counts remain gaps even when the surviving payload can be
+read. `apiReadablePoints` counts actual successful HTTP reads; `apiCompletePoints` additionally
+requires the retained artifact inventory and every point link. Legacy rows without an inventory
+remain unknown until recovered; they do not silently count as complete. A failed correction or
+receipt recovery error also blocks the complete count, even when older data remains readable.
+
+## Full-record statistics
+
+The point detail, run explorer and public `/api/v1/views/gpu-metrics` projection use the
+stored per-GPU digest for the existing full-record statistics, with name mappings only.
+Units and percentile/stddev definitions are unchanged.
+Zero is a value; missing metrics or an empty digest remain missing. Live, un-ingested
+artifact data still computes statistics in the browser. These tables include startup and
+warmup. They are not serving-window power, energy, or user-selected-window statistics.
+
+For each file/host series and GPU, the population keeps the first row at each timestamp,
+then excludes missing or nonfinite readings separately for each metric. Live CSV parsing
+uses the same rule; a missing optional temperature or clock does not discard valid power.
+Count is exact, mean is sample-weighted, P50/P95/P99 use linear interpolation at
+`p * (N - 1)`, and standard deviation uses the population denominator `N`. Multi-host
+GPU indices must remain in separate series. No time weighting, smoothing, chart zoom or
+GPU visibility filter changes the full-record table. Window calculations still consume
+the selected samples, and serving energy/financial metrics retain their own definitions.
+SQL samples and digests use `real` (float32), so compare stored values with an explicit
+float32 tolerance rather than the tighter tolerance of the in-memory parser tests.
+
+## Local verification
+
+From the repository root:
+
+```sh
+bun install --frozen-lockfile --ignore-scripts
+bun run test:unit
+bun run typecheck
+bun run lint
+bun run fmt
+bun run check:typography
+bun run --cwd packages/app test:unit src/app/api/v1/gpu-metrics-point/route.test.ts
+bun run --cwd packages/app test:unit src/app/api/v1/views/gpu-metrics/route.test.ts
+bun run --cwd packages/db test:unit src/queries/gpu-metrics-timeline.test.ts src/etl/telemetry-receipt.test.ts
+```
+
+The ordinary fixture-backed smoke command remains `bun run test:e2e` with an
+`E2E_FIXTURES=1` dev server. The full cross-browser matrix remains the repository CI gate.
+
+## Deployment and targeted data repair (operator review required)
+
+1. Deploy the reviewed application and ingest/backfill code together. Check the target's
+   migration ledger and apply pending migrations with `bun run admin:db:migrate --yes`
+   before running ingest or backfill. This branch adds `016_gpu_metrics.sql` and
+   `017_gpu_metric_stats_version.sql`; writers require the `stats_version` column from 017. CI ingest workflows migrate automatically, but manual backfill does not.
+   Do not run migrations or backfill against production merely to inspect a receipt.
+2. Retain the original publication receipt, exact artifact bytes, sidecars, source run and
+   attempt. Snapshot the target run's telemetry series, samples, digests and point links
+   before correction. Check that the app reads the same database that ingest writes.
+3. Inspect a bounded candidate with the existing command, using explicitly selected
+   target credentials in the operator environment:
+
+   ```sh
+   bun run admin:db:backfill-gpu-metrics --run RUN_ID --attempt ATTEMPT --dry-run
+   ```
+
+4. Once authorized, repair only the named artifact and merge the existing receipt:
+
+   ```sh
+   bun run admin:db:backfill-gpu-metrics --run RUN_ID --attempt ATTEMPT \
+     --artifact EXACT_ARTIFACT_NAME --receipt /path/power-publication.json --yes
+   bun packages/db/src/verify-power-publication.ts /path/power-publication.json https://TARGET_ORIGIN
+   ```
+
+   Before a backfill that may fill missing AgentX `power_audit`, set
+   `CACHE_INVALIDATE_URL=https://TARGET_ORIGIN/api/v1/invalidate` and
+   `CACHE_INVALIDATE_SECRET` (or `INVALIDATE_SECRET`); protected previews also need
+   `CACHE_PROTECTION_BYPASS_SECRET`. The selected app must use the same DB and its
+   existing cache namespace/Blob prefix. No new cache scope is introduced.
+
+   The backfill checkpoints NULL-audit AgentX candidates in the existing manifest
+   before ingest writes. `benchmarkRefresh` records IDs, retained source-derived
+   audit updates, target endpoint, pending/complete/failed status, check time and
+   error. DB audits must match that saved source evidence. Only the matching
+   publication points' NULL audit fields are enriched; original artifact hashes,
+   benchmark values and unrelated points remain unchanged. Without `--receipt`, the
+   existing default is `power-publication-RUN_ID-attempt-ATTEMPT.json`. Missing
+   configuration fails that pair before ingest; configuration errors cannot
+   silently turn a metadata write into a successful backfill.
+
+   After ingest, refresh runs in this order: `latest_benchmarks` materialized view,
+   the existing invalidate endpoint, then exact-run benchmark API comparison by ID
+   and structured `power_audit`. Refresh failure exits nonzero and retains the
+   responsibility even if the next ingest changes no samples or metadata.
+   To retry only that phase, without downloading artifacts or rewriting samples:
+
+   ```sh
+   bun run admin:db:backfill-gpu-metrics --run RUN_ID --attempt ATTEMPT \
+     --receipt /path/power-publication.json --refresh-cache-only --yes
+   ```
+
+   The receipt's run/attempt, point IDs and endpoint must still match. A checkpoint
+   interrupted before its metadata UPDATE leaves NULL candidates. They retain a
+   failed refresh responsibility and require targeted artifact re-ingest; a later
+   upsert clearing an already-written audit cannot erase that responsibility.
+   Invalid/string-encoded audits fail explicitly. HTTP calls have a 30-second
+   timeout; retries use the saved receipt rather than an unrecorded manual purge.
+   Dry runs never refresh. `complete` covers the recorded IDs and API metadata,
+   not browser state, energy validity or deployment-wide acceptance.
+
+   An explicit `--run` is rechecked even if some series already exist. Unchanged inputs
+   are no-ops. The GitHub backfill route accepts only the current source attempt and
+   filters out earlier attempt artifacts; it refuses a mismatched historical attempt.
+   Expired or older-attempt bytes require retained artifacts through the existing local
+   ingest path (`INGEST_ARTIFACTS_PATH` and exact source-run metadata), after operator
+   review. Never substitute another attempt's bytes. A local sidecar correction must be
+   applied to the retained artifact tree; re-downloading unchanged GitHub bytes cannot fix it.
+   The local ingest entry takes `INGEST_RUN_ID`, `INGEST_RUN_ATTEMPT`,
+   `INGEST_REPO=SemiAnalysisAI/InferenceX`, `INGEST_ARTIFACTS_PATH` and
+   `POWER_PUBLICATION_MANIFEST`, then `bun run admin:db:ingest:ci`. It also requires
+   `GITHUB_TOKEN` and the reviewed `DATABASE_WRITE_URL`. Inspect any retained
+   `reused-ingest-metadata/reuse_source_run.json` first: it overrides run/attempt identity.
+
+5. Inspect per-point receipt gaps and both point/Timeline APIs, then refocus/reload the
+   browser. Check expected hosts, GPU IDs, timestamps and digest values. Ingest success
+   alone is insufficient. No telemetry cache purge is required.
+
+For rollback, revert application code only if needed; additive sidecars/receipt fields are
+compatible with the previous schema. Reverting application code restores its old cache
+behavior, so the existing cache invalidation procedure is required in that case. To undo
+a data correction, re-ingest the retained original bytes/sidecars against the exact same
+run/attempt/point identities, or restore only the snapshotted rows in a reviewed transaction.
+Verify links and counts again. Do not delete a shared series to repair one point.
+
+Local tests do not establish deployment, production repair, expired-artifact recoverability,
+or complete published PowerX coverage.

From 2c440285799fa4014e21b61844e7c2707596b87e Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 12:52:26 -0700
Subject: [PATCH 098/103] test: retry blog listing visits in E2E
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：将博客列表页的访问放入每个用例的准备阶段，使 Cypress 能在页面加载超时时重试。
---
 packages/app/cypress/e2e/blog.cy.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/app/cypress/e2e/blog.cy.ts b/packages/app/cypress/e2e/blog.cy.ts
index a527bff8b..d34c4e676 100644
--- a/packages/app/cypress/e2e/blog.cy.ts
+++ b/packages/app/cypress/e2e/blog.cy.ts
@@ -38,10 +38,10 @@ describe('Blog', () => {
   });
 
   describe('Blog listing page', () => {
-    before(() => {
+    beforeEach(() => {
       // Stub remote Substack thumbnails with a real 1×1 PNG. A 204 empty body
       // can prevent Firefox from firing `window.load` while eager card images
-      // stay pending, which times out `cy.visit` in before-all.
+      // stay pending. Per-test setup also lets Cypress retry a failed visit.
       cy.intercept(
         {
           method: 'GET',

From f320e183e38a2fb231932eb697a1e6c940056304 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Tue, 29 Sep 2026 13:04:18 -0700
Subject: [PATCH 099/103] test: stub optimized blog thumbnails in E2E
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：博客列表页的 E2E 用例统一替换图片优化请求，避免 Firefox 等待缩略图时页面加载超时。
---
 packages/app/cypress/e2e/blog.cy.ts | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/packages/app/cypress/e2e/blog.cy.ts b/packages/app/cypress/e2e/blog.cy.ts
index d34c4e676..b70a927ce 100644
--- a/packages/app/cypress/e2e/blog.cy.ts
+++ b/packages/app/cypress/e2e/blog.cy.ts
@@ -39,17 +39,12 @@ describe('Blog', () => {
 
   describe('Blog listing page', () => {
     beforeEach(() => {
-      // Stub remote Substack thumbnails with a real 1×1 PNG. A 204 empty body
-      // can prevent Firefox from firing `window.load` while eager card images
-      // stay pending. Per-test setup also lets Cypress retry a failed visit.
-      cy.intercept(
-        {
-          method: 'GET',
-          pathname: '/_next/image',
-          query: { url: /^https:\/\/substack-post-media\.s3\.amazonaws\.com\// },
-        },
-        { fixture: '1x1.png', headers: { 'content-type': 'image/png' } },
-      );
+      // The listing checks text and links, so stub every optimized thumbnail.
+      // Waiting on image optimization can keep Firefox from firing `window.load`.
+      cy.intercept('GET', '**/_next/image?*', {
+        fixture: '1x1.png',
+        headers: { 'content-type': 'image/png' },
+      });
       cy.visit('/blog');
     });
 

From 75b6f61a859305a0594f34f4b33c258078a9d87e Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Wed, 30 Sep 2026 15:13:12 -0700
Subject: [PATCH 100/103] fix: preserve stitched PowerX comparison sources
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Group snapshot-backed observations across telemetry producer and exporter
revisions while retaining serving-image, recipe and topology boundaries.
Cover complete comparison/fit ladders and preserve raw endpoint provenance.
Synchronize bilingual API documentation and the packaged skill contract.

中文：保留拼接后的 PowerX 曲线对比来源。曲线快照允许不同遥测采集版本，
同时保留服务镜像、测试配置和拓扑边界；补充完整对比与拟合回归测试，
并同步中英文 API 文档与技能包说明。
---
 docs/dashboard-readonly-views.md              | 10 +++++--
 packages/app/cypress/e2e/powerx-compare.cy.ts | 13 ++++++++--
 .../app/api/v1/views/inference/route.test.ts  | 21 ++++++++++++---
 .../utils/equal-service-comparison.test.ts    | 26 ++++++++++++++++++-
 .../utils/equal-service-comparison.ts         |  6 +++--
 .../inference/utils/power-fit.test.ts         |  1 +
 packages/app/src/lib/api-route-catalog.ts     |  2 +-
 .../app/src/lib/views-api/docs/inference.ts   |  4 +--
 .../skills/inferencex-api/integrity.json      |  2 +-
 .../references/dashboard-views.md             |  7 ++++-
 10 files changed, 77 insertions(+), 15 deletions(-)

diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index 85c805ed0..de3eeb061 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -158,8 +158,10 @@ recipe, topology and workload identity; changing display dates does not create a
 new measured source. The source run is the logical curve snapshot
 (`curve_workflow_run_id` / `curve_date`, see
 [Append-Only Curve Extensions](./data-pipeline.md#append-only-curve-extensions)), so
-points an append-only run stitched onto an older curve stay one source; rows without a
-snapshot id, such as unofficial overlays, key by their own run URL and measured date, and
+points an append-only run stitched onto an older curve stay one source even when their
+telemetry producer or exporter hashes differ. Recipe, image and topology remain separate
+configuration identities. Rows without a snapshot id, such as unofficial overlays, retain
+their own run URL, measured date and telemetry producer/exporter hashes, and
 an unknown run never joins distinct rows. Comparisons never join different sources into one
 interpolation bracket. All three metrics use bounded numerical linear
 interpolation of the underlying quantities, then compute
@@ -252,6 +254,10 @@ GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全
 
 `serviceSources` 中各数据源的 `label` 仅供显示，由硬件和日期组成；只有两个数据源无法区分时，
 才补充精度、拓扑、运行等信息。选择数据源时应使用其 `key`。
+数据源的运行标识取自逻辑曲线快照（`curve_workflow_run_id` / `curve_date`）：append-only 运行
+拼接到旧曲线上的数据点仍视为同一数据源，即使其 telemetry producer 或 exporter hash 不同；
+测试配置指纹、镜像和拓扑仍用于区分不同配置。没有快照标识的行（例如非官方叠加数据）继续按各自的
+运行 URL、实测日期和 telemetry producer/exporter hash 区分数据源；运行未知的行不会与其他行合并为同一数据源。
 
 `serviceCompare=true` 还返回 `matchedConcurrency`：按并发数逐行配对两个所选数据源，任一方在
 该并发数下有观测即列出一行；每侧为 `observed`、`missing`，或同一负载下观测值不一致时的
diff --git a/packages/app/cypress/e2e/powerx-compare.cy.ts b/packages/app/cypress/e2e/powerx-compare.cy.ts
index 921bbab3c..b0b1982ab 100644
--- a/packages/app/cypress/e2e/powerx-compare.cy.ts
+++ b/packages/app/cypress/e2e/powerx-compare.cy.ts
@@ -82,9 +82,17 @@ const availability = [
   },
 ];
 
-/** Official rows; their run URL makes them one source, as ingested runs do. */
 function interceptRows(officialRunUrl: string) {
-  const official = rows(null, 'b200').map((row) => ({ ...row, run_url: officialRunUrl }));
+  const official = rows(null, 'b200').map((row, index) => ({
+    ...row,
+    curve_workflow_run_id: 27182818284,
+    curve_date: DATE,
+    run_url: index === 0 ? officialRunUrl : `${officialRunUrl}0`,
+    power_audit: {
+      producer_sha: index === 0 ? 'producer-a' : 'producer-b',
+      exporter_image_sha256: index === 0 ? 'exporter-a' : 'exporter-b',
+    },
+  }));
   cy.intercept('GET', '/api/v1/availability', { body: availability }).as('availability');
   cy.intercept('GET', '/api/v1/benchmarks*', { body: official }).as('benchmarks');
   cy.intercept('GET', '/api/v1/workflow-info*', {
@@ -159,6 +167,7 @@ describe('PowerX article panels', () => {
       OFFICIAL_RUN_URL,
     );
     cy.wait('@unofficialRun');
+    cy.get('[data-testid="equal-service-baseline"] option').should('have.length', 2);
 
     // Official B200 against the overlay H200 at each observed concurrency.
     for (const [conc] of CONFIGS) {
diff --git a/packages/app/src/app/api/v1/views/inference/route.test.ts b/packages/app/src/app/api/v1/views/inference/route.test.ts
index 03077bf42..662b9717a 100644
--- a/packages/app/src/app/api/v1/views/inference/route.test.ts
+++ b/packages/app/src/app/api/v1/views/inference/route.test.ts
@@ -102,12 +102,20 @@ beforeEach(() => {
 });
 
 describe('GET /api/v1/views/inference', () => {
-  it('calculates equal-service panels from observed points before frontier pruning with endpoint provenance', async () => {
+  it('compares stitched observations before frontier pruning and preserves each producer endpoint', async () => {
     const rows = ['h200', 'mi300x'].flatMap((hardware, index) =>
       [20, 60].map((x, position) =>
         makeRow({
           hardware,
           conc: position + 1,
+          curve_workflow_run_id: 900,
+          curve_date: '2026-03-02',
+          date: position === 0 ? '2026-03-01' : '2026-03-02',
+          run_url: `https://github.com/org/repo/actions/runs/${777 + position}`,
+          power_audit: {
+            producer_sha: `producer-${position}`,
+            exporter_image_sha256: `exporter-${position}`,
+          },
           metrics: {
             ...makeRow().metrics,
             median_intvty: x,
@@ -147,6 +155,7 @@ describe('GET /api/v1/views/inference', () => {
     );
     const body = await response.json();
     expect(response.status).toBe(200);
+    expect(body.serviceSources).toHaveLength(2);
     expect(body.serviceSources).toEqual(sources);
     expect(body.equalServiceComparison.metrics.meanWattsPerGpu.changePercent).toBeCloseTo(100 / 6);
     expect(body.equalServiceComparison.metrics.outputTokensPerSecond.changePercent).toBeCloseTo(
@@ -167,8 +176,14 @@ describe('GET /api/v1/views/inference', () => {
       ),
     ).toEqual(rows.slice(0, 2).map((row) => row.id));
     expect(
-      body.equalServiceComparison.metrics.meanWattsPerGpu.baseline.endpoints[0].point.runUrl,
-    ).toBe(rows[0].run_url);
+      body.equalServiceComparison.metrics.meanWattsPerGpu.baseline.endpoints.map(
+        (endpoint: { point: { runUrl: string } }) => endpoint.point.runUrl,
+      ),
+    ).toEqual(rows.slice(0, 2).map((row) => row.run_url));
+    expect(body.matchedConcurrency.rows).toMatchObject([
+      { concurrency: 1, baseline: { status: 'observed' }, comparator: { status: 'observed' } },
+      { concurrency: 2, baseline: { status: 'observed' }, comparator: { status: 'observed' } },
+    ]);
     expect(body).not.toHaveProperty('observedPoints');
     expect(body.equalServiceCurve).toHaveLength(2);
   });
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
index a29d0b472..a0ebdd036 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.test.ts
@@ -169,12 +169,19 @@ describe('equal-service comparison', () => {
     // B200 TP4: run 35905882425 appended c1–c4 onto run 35843506474's c8–c128.
     const snapshot = { curve_workflow_run_id: 35843506474, curve_date: '2026-09-20' };
     const stitched = [
-      point({ id: 1, conc: 8, actualDate: '2026-09-20', ...snapshot }),
+      point({
+        id: 1,
+        conc: 8,
+        actualDate: '2026-09-20',
+        power_audit: { producer_sha: 'producer-a', exporter_image_sha256: 'exporter-a' },
+        ...snapshot,
+      }),
       point({
         id: 2,
         conc: 1,
         actualDate: '2026-09-23',
         run_url: 'https://example.invalid/runs/35905882425/attempts/1',
+        power_audit: { producer_sha: 'producer-b', exporter_image_sha256: 'exporter-b' },
         ...snapshot,
       }),
     ];
@@ -199,6 +206,23 @@ describe('equal-service comparison', () => {
     ]);
   });
 
+  it.each([
+    { image: 'another-image' },
+    { recipe_fingerprint: 'another-recipe' },
+    { decode_tp: 8, physicalChips: 8 },
+    { curve_workflow_run_id: 2 },
+  ])('keeps distinct snapshot configurations separate: %j', (variant) => {
+    const original = point({ curve_workflow_run_id: 1, curve_date: '2026-09-20' });
+    expect(getEqualServiceSources([original, { ...original, ...variant }])).toHaveLength(2);
+  });
+
+  it.each([{ producer_sha: 'another-producer' }, { exporter_image_sha256: 'another-exporter' }])(
+    'keeps producer distinctions when no snapshot authorizes stitching: %j',
+    (power_audit) => {
+      expect(getEqualServiceSources([point(), point({ power_audit })])).toHaveLength(2);
+    },
+  );
+
   it('plots role panels on the trace-derived P75/P90 axes from point.x without interpolating on them', () => {
     const role = (overrides: Partial<InferenceData>) =>
       point({
diff --git a/packages/app/src/components/inference/utils/equal-service-comparison.ts b/packages/app/src/components/inference/utils/equal-service-comparison.ts
index 3cb58c7e6..c74e061b5 100644
--- a/packages/app/src/components/inference/utils/equal-service-comparison.ts
+++ b/packages/app/src/components/inference/utils/equal-service-comparison.ts
@@ -82,6 +82,8 @@ const sourceDate = (point: InferenceData): string =>
 /**
  * Concurrency is excluded; unknown run identity must never join distinct rows.
  * Rows with a curve snapshot key by that snapshot instead of their own run.
+ * A snapshot can retain multiple telemetry producers; their hashes stay on the
+ * observations, while recipe, image and topology still distinguish configurations.
  */
 export function equalServiceSourceKey(point: InferenceData): string {
   const snapshot = curveSnapshotId(point);
@@ -110,8 +112,8 @@ export function equalServiceSourceKey(point: InferenceData): string {
     point.kv_p2p_transfer ?? null,
     point.router_name ?? null,
     point.router_version ?? null,
-    point.power_audit?.producer_sha ?? null,
-    point.power_audit?.exporter_image_sha256 ?? null,
+    snapshot === null ? (point.power_audit?.producer_sha ?? null) : null,
+    snapshot === null ? (point.power_audit?.exporter_image_sha256 ?? null) : null,
   ]);
 }
 
diff --git a/packages/app/src/components/inference/utils/power-fit.test.ts b/packages/app/src/components/inference/utils/power-fit.test.ts
index dc5a18b07..ce5571872 100644
--- a/packages/app/src/components/inference/utils/power-fit.test.ts
+++ b/packages/app/src/components/inference/utils/power-fit.test.ts
@@ -81,6 +81,7 @@ describe('buildPowerFits', () => {
               actualDate: '2026-09-23',
               run_url:
                 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/35905882425/attempts/1',
+              power_audit: { producer_sha: 'appended-producer', exporter_image_sha256: 'exporter' },
             }
           : entry,
     );
diff --git a/packages/app/src/lib/api-route-catalog.ts b/packages/app/src/lib/api-route-catalog.ts
index 821dd462b..b989cadd6 100644
--- a/packages/app/src/lib/api-route-catalog.ts
+++ b/packages/app/src/lib/api-route-catalog.ts
@@ -853,7 +853,7 @@ export const apiContractSourceDigests = [
   },
   {
     source: 'src/components/inference/utils/equal-service-comparison.ts',
-    sourceSha256: '9da8ffb9df5b1df9bca9a2d155e32a9dbb1599edb87093afda1c4dd6cfe973b2',
+    sourceSha256: 'ff06f0eb908b6912706bb8dc67d931698d9cbd356546f20850ea8221fedc9354',
     reviewArea: {
       en: 'Source-scoped equal-service interpolation, comparator-relative changes, endpoint provenance, prefill share projection and role points.',
       zh: '按完整来源限定的同等服务插值、相对基准变化、端点来源、prefill 占比视图以及各角色数据点。',
diff --git a/packages/app/src/lib/views-api/docs/inference.ts b/packages/app/src/lib/views-api/docs/inference.ts
index 7dc330dde..e8a4ca670 100644
--- a/packages/app/src/lib/views-api/docs/inference.ts
+++ b/packages/app/src/lib/views-api/docs/inference.ts
@@ -245,8 +245,8 @@ const parameters: readonly ApiParameter[] = [
     required: false,
     type: 'string',
     description: text(
-      'Exact comparator key from serviceSources. Omitted selects the second deterministic source. Keys retain hardware, source run, recipe, topology and workload identity; never replace them with a hardware name.',
-      'serviceSources 中的完整对比来源键。省略时按确定性顺序选择第二项。来源键保留硬件、运行、配置配方、拓扑和工作负载标识，不能用硬件名称代替。',
+      'Exact comparator key from serviceSources. Omitted selects the second deterministic source. Keys retain hardware, curve snapshot, recipe, image, topology and workload identity. Stitched telemetry producer/exporter hashes do not split a snapshot; rows without one retain their own run, date and hashes. Never substitute a hardware name.',
+      'serviceSources 中的完整对比来源键。省略时按确定性顺序选择第二项。来源键保留硬件、曲线快照、测试配置指纹、镜像、拓扑和工作负载标识。同一快照内不同 telemetry producer/exporter 的 hash 不拆分来源；没有快照的行仍按原运行、日期和 hash 区分。不能用硬件名称代替。',
     ),
     schema: stringSchema,
     example: 'Exact key returned in serviceSources',
diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index 50fc97c1f..747e90c39 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -8,7 +8,7 @@
     "references/cli-contract.md": "fa44faa38d889b4fbdee5ba42752b47758ee3706fab150513bd4e6db87a86cb0",
     "references/cli.md": "96b228f34cb3600f4548f4dc84df8506531747286763c56ca834c77bee05e1eb",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "c1cfd2a5843039b14936a2d410822307781e9aadc3f8b1bafce12d31c5c7c30a",
+    "references/dashboard-views.md": "1c594e186f79adf74663eb2b845e54116eaec560c139e184b107994c75a98937",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/pareto.md": "1b4d2d163f982e3f2d97addce310789eae9c1e5badd82dd7501708c9e0385027",
     "references/powerx.md": "cf8adcc5dfe395c5fb659908819980a872475f862f22b723815af43d363cedad",
diff --git a/packages/skills/skills/inferencex-api/references/dashboard-views.md b/packages/skills/skills/inferencex-api/references/dashboard-views.md
index 077a82d1b..554288280 100644
--- a/packages/skills/skills/inferencex-api/references/dashboard-views.md
+++ b/packages/skills/skills/inferencex-api/references/dashboard-views.md
@@ -113,6 +113,11 @@ two sources; unknown explicit keys stay unavailable. Omitted target means no
 selected-target result. Targets are tok/s/user for streaming speed, seconds for
 TTFT/E2E. Concurrency is unsupported for equal-service interpolation.
 
+A source groups one logical curve snapshot and configuration. Stitched points retain
+their original producer provenance; differing telemetry producer/exporter hashes do not
+split the snapshot. Recipe, image and topology remain distinct. Rows without a snapshot
+retain their own run, measured date and telemetry producer/exporter hashes in the source key.
+
 The same dashboard helper uses scoped observed points before frontier/best
 pruning, with no power-comparison clones. It interpolates raw quantities
 linearly only inside each exact source range, then reports signed
@@ -120,7 +125,7 @@ linearly only inside each exact source range, then reports signed
 whole-deployment output tokens/s, and validated GPU J/output token. Negative energy
 change means lower comparator energy. Preserve bracket endpoint identities,
 `interpolated`, missing reasons and nulls. Never call interpolated points new
-measurements or bridge different runs, recipes, topologies or missing endpoints.
+measurements or bridge different sources, recipes, topologies or missing endpoints.
 
 `serviceCompare=true` also returns `matchedConcurrency`: the two selected sources
 paired at each concurrency either observed. Sides are `observed`, `missing`, or

From d1728a9f9420d541e4566ec2a3bacd6877fe84ee Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Wed, 30 Sep 2026 16:23:52 -0700
Subject: [PATCH 101/103] refactor: remove PowerX service comparison panels
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：移除 PowerX 同速度或延迟对比面板、同并发诊断表及对应分享参数。保留角色分析和功耗拟合面板；现有只读对比 API 保持兼容，并同步中英文文档与回归测试。
---
 docs/dashboard-readonly-views.md              |  34 +-
 docs/powerx-permanent-view.md                 |  47 +-
 .../component/power-analysis-panels.cy.tsx    | 163 ++++++
 .../component/power-service-comparison.cy.tsx | 192 -------
 packages/app/cypress/e2e/powerx-compare.cy.ts |  28 +-
 .../components/inference/ui/ChartDisplay.tsx  |  12 +-
 .../inference/ui/MatchedConcurrencyTable.tsx  | 211 --------
 .../inference/ui/PowerAnalysisPanels.tsx      | 142 +++++
 .../inference/ui/PowerServiceComparison.tsx   | 493 ------------------
 packages/app/src/lib/url-state.test.ts        |  16 +
 packages/app/src/lib/url-state.ts             |   8 -
 .../app/src/lib/views-api/docs/inference.ts   |   8 +-
 .../skills/inferencex-api/integrity.json      |   2 +-
 .../references/dashboard-views.md             |  62 ++-
 14 files changed, 424 insertions(+), 994 deletions(-)
 create mode 100644 packages/app/cypress/component/power-analysis-panels.cy.tsx
 delete mode 100644 packages/app/cypress/component/power-service-comparison.cy.tsx
 delete mode 100644 packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
 create mode 100644 packages/app/src/components/inference/ui/PowerAnalysisPanels.tsx
 delete mode 100644 packages/app/src/components/inference/ui/PowerServiceComparison.tsx

diff --git a/docs/dashboard-readonly-views.md b/docs/dashboard-readonly-views.md
index de3eeb061..c65916275 100644
--- a/docs/dashboard-readonly-views.md
+++ b/docs/dashboard-readonly-views.md
@@ -130,6 +130,10 @@ median. AgentX keeps its selected `percentile`, and concurrency has no statistic
 `params.xstat` resolves to null in both cases, while `xAxis.statistic` records the
 effective percentile or null.
 
+Equal-service comparisons and the same-concurrency diagnostic are API-only analysis.
+The dashboard has no source-pair selector, target input, comparison curve or matched-concurrency
+table. Its role and power-fit panels remain available.
+
 `serviceCompare=true` adds `serviceSources`, `equalServiceCurve`, and (when
 `serviceTarget` is present) `equalServiceComparison`. Select exact opaque
 `serviceBaseline` and `serviceComparator` keys returned by `serviceSources`,
@@ -147,10 +151,10 @@ two selected sources paired at every concurrency either one observed. Each side
 named by `interactivityField`, plus its point identity), `missing`, or `ambiguous`
 when one source's observations at that load disagree; all are listed and none is
 chosen. `changePercent` is `100 × (comparator / baseline − 1)` only when both sides
-were observed. Same-load pairs usually serve different speeds, so the table sits
-beside the equal-service comparison rather than replacing it.
+were observed. Same-load pairs usually serve different speeds, so interpret this
+diagnostic separately from an equal-service comparison.
 
-The dashboard and API share `equal-service-comparison.ts`: both consume scoped
+The service-comparison API uses `equal-service-comparison.ts` and consumes scoped
 observed points after chart coverage/limits, before frontier and best-per-SKU
 pruning, with power-comparison clones excluded. `allPoints=true` restores clipped
 observations. Source keys retain hardware, precision, source run, source date,
@@ -196,12 +200,16 @@ point identity. Fewer than three distinct output rates return `fit: null` with
 `reason: "too-few-points"`. `P₀` is an extrapolated intercept, not measured idle
 power, and R² is null when power did not vary.
 
-These panel results are JSON-only: `format=csv` with any panel enabled returns
+These analytical results are JSON-only: `format=csv` with any analysis enabled returns
 400, rather than silently exporting only the primary chart. Ordinary CSV retains
-its existing plotted-point contract. Share controls map directly:
-`i_mstat` → `xstat`, `i_servicecompare` → `serviceCompare`, `i_servicebase` →
-`serviceBaseline`, `i_servicepeer` → `serviceComparator`, `i_servicetarget` →
-`serviceTarget`, `i_roleshare` → `roleShare`, and `i_powerfit` → `powerFit`.
+its existing plotted-point contract.
+
+| Surface                                        | Dashboard control / share parameter               | Read-only API coverage                                                    |
+| ---------------------------------------------- | ------------------------------------------------- | ------------------------------------------------------------------------- |
+| Fixed-sequence statistic                       | `i_mstat`                                         | `xstat`                                                                   |
+| Equal-service and matched-concurrency analysis | API-only; no dashboard control or share parameter | `serviceCompare`, `serviceBaseline`, `serviceComparator`, `serviceTarget` |
+| Prefill / decode roles                         | `i_roleshare`                                     | `roleShare`                                                               |
+| Power vs output-rate fit                       | `i_powerfit`                                      | `powerFit`                                                                |
 
 The scatter chart's Frontier points table (shown with `i_frontier` on a measured
 power metric) lists the drawn cross-platform frontier with each point's run and
@@ -252,6 +260,12 @@ GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全
 条目一份投影）和 `overlays`（每个非官方运行一份）。按日期显隐属于渲染状态，不是查询参数，
 因此无需修改 API 或 OpenAPI 契约。
 
+同等服务条件下的对比和相同并发下的诊断仅通过 API 提供。仪表板不提供这两项分析的来源选择、
+目标值输入、对比曲线或同并发表格；prefill/decode 角色分析和功耗拟合面板继续保留。
+`serviceCompare`、`serviceBaseline`、`serviceComparator`、`serviceTarget` 仍为 API 查询参数，
+不对应仪表板控件或分享参数。固定长度工作负载的统计量、角色分析和功耗拟合的分享参数与 API
+参数仍一一对应：`i_mstat` → `xstat`、`i_roleshare` → `roleShare`、`i_powerfit` → `powerFit`。
+
 `serviceSources` 中各数据源的 `label` 仅供显示，由硬件和日期组成；只有两个数据源无法区分时，
 才补充精度、拓扑、运行等信息。选择数据源时应使用其 `key`。
 数据源的运行标识取自逻辑曲线快照（`curve_workflow_run_id` / `curve_date`）：append-only 运行
@@ -268,8 +282,8 @@ GPU 视图优先读取已存遥测，缺少存储数据时回退到产物。全
 `equalServiceComparison` 不在这些横轴上插值。
 `powerFit=true` 返回 `powerFits`：每个数据源以最小二乘法拟合平均 W/GPU 与每个已分配
 GPU 的输出 tok/s，给出 `P₀`、`m`（J/输出 token）、R²、点数、拟合范围和注册表 TDP；
-不同输出速率少于 3 个时不拟合。`P₀` 是外推截距，不是实测空载功耗。这些面板只支持
-JSON；`i_powerfit` 对应 `powerFit`。散点图的前沿点表（`i_frontier` 开启且为实测功耗
+不同输出速率少于 3 个时不拟合。`P₀` 是外推截距，不是实测空载功耗。这些分析结果只支持
+JSON。散点图的前沿点表（`i_frontier` 开启且为实测功耗
 指标时显示）列出跨平台前沿各点的运行和尝试次数，并可导出 CSV；只读 API 没有全局前沿
 参数。
 
diff --git a/docs/powerx-permanent-view.md b/docs/powerx-permanent-view.md
index 4c730b37e..ba51b2e70 100644
--- a/docs/powerx-permanent-view.md
+++ b/docs/powerx-permanent-view.md
@@ -290,30 +290,24 @@ config is `display: 'timeline'`.
   `inference_power_trace_opened { hwKey, conc, overlay }` (scatter tooltip action),
   `inference_power_timeline_focus_cleared`.
 
-## Analysis panels (article figures 6–16)
+## Analysis panels
 
-Figure numbers here follow the current article draft; the share-link table above predates its
-renumbering. Below the measured chart, `ui/PowerServiceComparison.tsx` offers three opt-in
-panels, and the scatter chart adds a fourth. All read the chart's scoped observed points
+Below the measured chart, `ui/PowerAnalysisPanels.tsx` offers the opt-in role and power-fit panels, and the scatter chart
+offers the frontier-points table. They read the chart's scoped observed points
 (`observedPoints`: official and `?unofficialrun=` rows, comparison clones excluded), keep one
 source per curve snapshot and recipe (`equalServiceSourceKey`: a stitched append-only curve is
 one source keyed by `curve_workflow_run_id`; rows without a snapshot id key by their own run),
 and colour overlay sources with `overlayRunColor`.
 
-| Figures      | Panel                                                                                                                                         | Switch (share param)                                                                                    | Helper                                                 |
-| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
-| 6 / 7 / 9    | Same-concurrency table: baseline and comparator J/output token, W/GPU and streaming speed, with % change                                      | _Compare at the same speed / latency_ (`i_servicecompare=1`, sources `i_servicebase` / `i_servicepeer`) | `utils/matched-concurrency.ts`                         |
-| 12 / 13 / 14 | Role group: W/GPU by role, role-local J/input and J/output (not added), J/output token by role with the total, prefill share                  | _Prefill / decode roles_ (`i_roleshare=1`)                                                              | `getRolePoints` in `utils/equal-service-comparison.ts` |
-| 15           | Least-squares fit of mean W/GPU against output tok/s per allocated GPU: points, line, dashed extension to zero, P₀, P₀ ÷ TDP, m, R², n, range | _Power vs output-rate fit_ (`i_powerfit=1`)                                                             | `utils/power-fit.ts`                                   |
-| 16           | Frontier points: the drawn cross-platform frontier and each point's run and attempt                                                           | Legend _Pareto frontier_ (`i_frontier`) on a measured metric                                            | `utils/frontier-points.ts`                             |
+| Figures      | Panel                                                                                                                                         | Switch (share param)                                         | Helper                                                 |
+| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------ |
+| 12 / 13 / 14 | Role group: W/GPU by role, role-local J/input and J/output (not added), J/output token by role with the total, prefill share                  | _Prefill / decode roles_ (`i_roleshare=1`)                   | `getRolePoints` in `utils/equal-service-comparison.ts` |
+| 15           | Least-squares fit of mean W/GPU against output tok/s per allocated GPU: points, line, dashed extension to zero, P₀, P₀ ÷ TDP, m, R², n, range | _Power vs output-rate fit_ (`i_powerfit=1`)                  | `utils/power-fit.ts`                                   |
+| 16           | Frontier points: the drawn cross-platform frontier and each point's run and attempt                                                           | Legend _Pareto frontier_ (`i_frontier`) on a measured metric | `utils/frontier-points.ts`                             |
 
 - **Role group** follows the chart's X axis, including the trace-derived P75/P90 E2E-normalized
   interactivity axes (their values live on `point.x`); equal-service interpolation stays limited
   to observed service fields and reports `unsupported-axis` there.
-- **Same concurrency** pairs only observations; nothing is interpolated. A side missing at a
-  load reads _Not measured_. Disagreeing duplicates of one source read as ambiguous, with none
-  chosen. % change needs both sides. Same load usually means different speed, so the table
-  sits beside the equal-service comparison, not in place of it.
 - **Roles** use validated disaggregated rows. Each panel names its denominator. Missing role
   telemetry is omitted, never drawn as zero, and share points stay unconnected.
 - **Fit** needs three distinct output rates per source. Output is whole-deployment tok/s over
@@ -324,16 +318,23 @@ and colour overlay sources with `overlayRunColor`.
 - **Source labels** (`getEqualServiceSources`) read hardware and snapshot date, adding
   precision, topology, snapshot run, attempt, recipe, image or point only where two sources
   would otherwise look the same. The opaque key stays the exact identity.
-- Plots export PNG and CSV; the frontier table exports CSV only. Panel subtitles and the
-  baseline → comparator pair are export-only, so a PNG names its workload and sources while
-  the screen shows only the source selects. The views API returns
-  `matchedConcurrency`, `rolePoints` and `powerFits`
+- Role and fit plots export PNG and CSV; the frontier table exports CSV only. Export subtitles
+  name the workload and sources. The views API returns `rolePoints` and `powerFits`
   ([Dashboard read-only views](./dashboard-readonly-views.md#fixed-sequence-service-comparisons));
   it has no global-frontier parameter.
-- Analytics: `inference_equal_service_toggled`, `inference_power_roles_toggled` and
-  `inference_power_fit_toggled` (`{ enabled }`), `inference_equal_service_source_changed
-{ role }`, and chart-button events under `matched_concurrency`, `power_roles`, `power_fit`
-  and `frontier_points`.
+- Analytics: `inference_power_roles_toggled` and `inference_power_fit_toggled` (`{ enabled }`),
+  and chart-button events under `power_roles`, `power_fit` and `frontier_points`.
+
+Equal-service comparisons and the matched-concurrency diagnostic remain available through the
+read-only inference API with `serviceCompare`, `serviceBaseline`, `serviceComparator` and
+`serviceTarget`. They have no dashboard control, panel, table or share parameter. The API retains
+source identity, bounded interpolation, missing-data reasons and same-load pairing semantics;
+see [Dashboard read-only views](./dashboard-readonly-views.md#fixed-sequence-service-comparisons).
+
+同等服务条件下的对比和相同并发下的诊断继续通过只读 inference API 提供，查询参数为
+`serviceCompare`、`serviceBaseline`、`serviceComparator` 和 `serviceTarget`。仪表板不提供
+对应的控件、面板、表格或分享参数；角色分析、功耗拟合和前沿点表继续保留。API 的来源标识、
+有界插值、缺失原因和同并发配对规则保持不变，详见[仪表板只读视图](./dashboard-readonly-views.md#fixed-sequence-service-comparisons)。
 
 ## Tests
 
@@ -356,6 +357,6 @@ and colour overlay sources with `overlayRunColor`.
 - `utils/matched-concurrency.test.ts`, `utils/power-fit.test.ts`, `utils/powerTimeline.test.ts`
   — signed same-concurrency deltas, the least-squares fit and R², disaggregated fits on output
   per allocated GPU, and the peak pool power inside the validated window.
-- `cypress/component/power-service-comparison.cy.tsx`, `frontier-points-panel.cy.tsx`,
+- `cypress/component/power-analysis-panels.cy.tsx`, `frontier-points-panel.cy.tsx`,
   `power-timeline.cy.tsx` and `cypress/e2e/powerx-compare.cy.ts` — the article panels on
   `?unofficialrun=` overlay rows.
diff --git a/packages/app/cypress/component/power-analysis-panels.cy.tsx b/packages/app/cypress/component/power-analysis-panels.cy.tsx
new file mode 100644
index 000000000..2993c0e71
--- /dev/null
+++ b/packages/app/cypress/component/power-analysis-panels.cy.tsx
@@ -0,0 +1,163 @@
+import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
+import { useState } from 'react';
+
+import type { AggDataEntry, InferenceData } from '@/components/inference/types';
+import PowerAnalysisPanels from '@/components/inference/ui/PowerAnalysisPanels';
+import { writeUrlParams } from '@/lib/url-state';
+
+import { createMockInferenceData } from '../support/mock-data';
+import { mountWithProviders } from '../support/test-utils';
+
+const metric = (y: number) => ({ y, roof: false });
+const point = (overrides: Partial<InferenceData> = {}) =>
+  createMockInferenceData({
+    hwKey: 'b200_sglang',
+    hw: 'B200',
+    framework: 'sglang',
+    precision: 'fp8',
+    physicalChips: 4,
+    tp: 4,
+    decode_tp: 4,
+    conc: 8,
+    date: '2026-09-23',
+    run_url: 'https://example.invalid/runs/900000001',
+    benchmark_type: 'single_turn',
+    mean_tpot_intvty: 20,
+    output_tput_per_gpu: 50,
+    measuredAvgPower: metric(400),
+    measuredJPerOutputToken: metric(10),
+    ...overrides,
+  });
+const OVERLAY_RUN_URL = 'https://example.invalid/runs/900000002';
+const overlayPoints = [100, 200].map((rate, index) =>
+  point({
+    id: 3 + index,
+    hwKey: 'b300_sglang',
+    run_url: OVERLAY_RUN_URL,
+    conc: 2 ** index,
+    output_tput_per_gpu: rate,
+    measuredAvgPower: metric(600 + 2 * rate),
+    measuredJPerOutputToken: metric(8 + 8 * index),
+  }),
+);
+const fitLadder = [20, 60, 120, 260].map((rate, index) =>
+  point({
+    id: 20 + index,
+    conc: 2 ** index,
+    mean_tpot_intvty: 100 - 20 * index,
+    output_tput_per_gpu: rate,
+    measuredAvgPower: metric(250 + 0.5 * rate),
+    measuredJPerOutputToken: metric((250 + 0.5 * rate) / rate),
+  }),
+);
+
+function PanelsHarness({
+  initial,
+  added = [],
+  overlay = overlayPoints,
+  xField = 'mean_tpot_intvty',
+}: {
+  initial: InferenceData[];
+  added?: InferenceData[];
+  overlay?: InferenceData[];
+  xField?: keyof AggDataEntry;
+}) {
+  const [extra, setExtra] = useState<InferenceData[]>([]);
+  return (
+    <PathnameContext.Provider value="/inference">
+      <div style={{ width: '100%', maxWidth: 1120, padding: 12, boxSizing: 'border-box' }}>
+        {added.length > 0 && (
+          <button type="button" data-testid="add-source" onClick={() => setExtra(added)}>
+            add source
+          </button>
+        )}
+        <PowerAnalysisPanels
+          data={[...initial, ...extra]}
+          overlayData={overlay}
+          xField={xField}
+          xLabel="Interactivity (output tok/s/user)"
+          chartId="power-analysis-test"
+        />
+      </div>
+    </PathnameContext.Provider>
+  );
+}
+
+const providers = {
+  inference: {},
+  unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } },
+};
+
+describe('PowerAnalysisPanels', () => {
+  beforeEach(() => {
+    cy.on('uncaught:exception', (error) => {
+      if (error.message.includes('ResizeObserver loop')) return false;
+    });
+    // URL state survives the previous component mount.
+    writeUrlParams({ i_roleshare: '0', i_powerfit: '0' });
+  });
+
+  it('keeps official and overlay power fits without the retired comparison controls', () => {
+    mountWithProviders(<PanelsHarness initial={[...fitLadder, ...overlayPoints]} />, providers);
+    cy.get('[data-testid="power-analysis-panels"]').should('be.visible');
+    cy.get('[data-testid="power-fit-toggle"]').check();
+    cy.get(
+      '[data-testid="power-analysis-test-power-fit-plot"] circle.point[fill="var(--overlay-run-0)"]',
+    ).should('have.length', 2);
+    cy.get('[data-testid="power-analysis-test-power-fit-plot"] circle.point')
+      .not('[fill="var(--overlay-run-0)"]')
+      .should('have.length', 4);
+    cy.get('[data-testid="power-fit-row"]').should('have.length', 2);
+    cy.get('[data-testid^="equal-service-"]').should('not.exist');
+    cy.get('[data-testid^="matched-concurrency"]').should('not.exist');
+  });
+
+  it('adds late official observations to an enabled fit without losing the overlay', () => {
+    mountWithProviders(<PanelsHarness initial={overlayPoints} added={fitLadder} />, providers);
+    cy.get('[data-testid="power-fit-toggle"]').check();
+    cy.get('[data-testid="power-fit-row"]').should('have.length', 1);
+    cy.get('[data-testid="add-source"]').click();
+    cy.get('[data-testid="power-fit-row"]').should('have.length', 2);
+    cy.get('[data-testid="power-analysis-test-power-fit-plot"] circle.point').should(
+      'have.length',
+      6,
+    );
+    cy.get(
+      '[data-testid="power-analysis-test-power-fit-plot"] circle.point[fill="var(--overlay-run-0)"]',
+    ).should('have.length', 2);
+  });
+
+  for (const percentile of ['p75', 'p90']) {
+    it(`renders role observations on the derived ${percentile.toUpperCase()} axis`, () => {
+      const rolePoints = [...fitLadder.slice(0, 2), overlayPoints[0]].map<InferenceData>(
+        (entry, index) => ({
+          ...entry,
+          x: [31.2, 24.8, 28][index],
+          benchmark_type: 'agentic_traces',
+          disagg: true,
+          physicalChips: 8,
+          num_prefill_gpu: 4,
+          num_decode_gpu: 4,
+          measuredPrefillAvgPower: metric(300),
+          measuredDecodeAvgPower: metric(500),
+        }),
+      );
+      mountWithProviders(
+        <PanelsHarness
+          initial={rolePoints}
+          overlay={[rolePoints[2]]}
+          xField={`${percentile}_e2e_norm_intvty` as keyof AggDataEntry}
+        />,
+        providers,
+      );
+      cy.get('[data-testid="role-share-toggle"]').check();
+      cy.get('[data-testid="power-analysis-test-role-power-plot"] circle.point').should(
+        'have.length',
+        6,
+      );
+      cy.get(
+        '[data-testid="power-analysis-test-role-power-plot"] circle.point[fill="var(--overlay-run-0)"]',
+      ).should('have.length', 2);
+    });
+  }
+});
diff --git a/packages/app/cypress/component/power-service-comparison.cy.tsx b/packages/app/cypress/component/power-service-comparison.cy.tsx
deleted file mode 100644
index 48614a637..000000000
--- a/packages/app/cypress/component/power-service-comparison.cy.tsx
+++ /dev/null
@@ -1,192 +0,0 @@
-import { PathnameContext } from 'next/dist/shared/lib/hooks-client-context.shared-runtime';
-import { useState } from 'react';
-
-import type { InferenceData } from '@/components/inference/types';
-import PowerServiceComparison from '@/components/inference/ui/PowerServiceComparison';
-import { writeUrlParams } from '@/lib/url-state';
-
-import { createMockInferenceData } from '../support/mock-data';
-import { mountWithProviders } from '../support/test-utils';
-
-const metric = (y: number) => ({ y, roof: false });
-const point = (overrides: Partial<InferenceData> = {}) =>
-  createMockInferenceData({
-    hwKey: 'b200_sglang',
-    hw: 'B200',
-    framework: 'sglang',
-    precision: 'fp8',
-    physicalChips: 4,
-    tp: 4,
-    decode_tp: 4,
-    conc: 8,
-    date: '2026-09-23',
-    run_url: 'https://example.invalid/runs/900000001',
-    benchmark_type: 'single_turn',
-    mean_tpot_intvty: 20,
-    output_tput_per_gpu: 50,
-    measuredAvgPower: metric(400),
-    measuredJPerOutputToken: metric(10),
-    ...overrides,
-  });
-// The overlay run: two loads of a second source.
-const comparator = [
-  point({
-    id: 3,
-    hwKey: 'b300_sglang',
-    run_url: 'https://example.invalid/runs/900000002',
-    measuredAvgPower: metric(800),
-    output_tput_per_gpu: 100,
-    measuredJPerOutputToken: metric(8),
-  }),
-  point({
-    id: 4,
-    hwKey: 'b300_sglang',
-    run_url: 'https://example.invalid/runs/900000002',
-    mean_tpot_intvty: 60,
-    conc: 1,
-    measuredAvgPower: metric(1000),
-    output_tput_per_gpu: 200,
-    measuredJPerOutputToken: metric(16),
-  }),
-];
-const OVERLAY_RUN_URL = 'https://example.invalid/runs/900000002';
-// W/GPU = 250 + 0.5 × output tok/s/GPU on four loads of one source.
-const fitLadder = [20, 60, 120, 260].map((rate, index) =>
-  point({
-    id: 20 + index,
-    conc: 2 ** index,
-    mean_tpot_intvty: 100 - 20 * index,
-    output_tput_per_gpu: rate,
-    measuredAvgPower: metric(250 + 0.5 * rate),
-    measuredJPerOutputToken: metric((250 + 0.5 * rate) / rate),
-  }),
-);
-
-function mountComparison(points: InferenceData[], overlay: InferenceData[]) {
-  mountWithProviders(
-    <PathnameContext.Provider value="/inference">
-      <div style={{ width: '100%', maxWidth: 1120, padding: 12, boxSizing: 'border-box' }}>
-        <PowerServiceComparison
-          data={[...points, ...overlay]}
-          overlayData={overlay}
-          xField="mean_tpot_intvty"
-          xLabel="Mean interactivity (output tok/s/user)"
-          interactivityField="mean_tpot_intvty"
-          chartId="power-service-test"
-        />
-      </div>
-    </PathnameContext.Provider>,
-    {
-      inference: {},
-      unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } },
-    },
-  );
-}
-
-// Its key sorts ahead of the B200 baseline, so an unpinned pair would jump to it.
-const laterSource = point({
-  id: 40,
-  hwKey: 'b100_sglang',
-  run_url: 'https://example.invalid/runs/900000003',
-  measuredAvgPower: metric(600),
-});
-function PinnedComparisonHarness({
-  initial,
-  added,
-}: {
-  initial: InferenceData[];
-  added: InferenceData[];
-}) {
-  const [extra, setExtra] = useState<InferenceData[]>([]);
-  return (
-    <PathnameContext.Provider value="/inference">
-      <button type="button" data-testid="add-source" onClick={() => setExtra(added)}>
-        add source
-      </button>
-      <PowerServiceComparison
-        data={[...initial, ...extra]}
-        overlayData={comparator}
-        xField="mean_tpot_intvty"
-        xLabel="Mean interactivity (output tok/s/user)"
-        interactivityField="mean_tpot_intvty"
-        chartId="power-service-pin"
-      />
-    </PathnameContext.Provider>
-  );
-}
-
-describe('PowerServiceComparison', () => {
-  beforeEach(() => {
-    cy.on('uncaught:exception', (error) => {
-      if (error.message.includes('ResizeObserver loop')) return false;
-    });
-    // The URL-state store is module-scoped and outlives the previous test's
-    // Compare selection, which would otherwise pre-pin the next mount.
-    writeUrlParams({ i_servicecompare: '0', i_servicebase: '', i_servicepeer: '' });
-  });
-
-  it('colours ?unofficialrun= sources with their run colour in every panel', () => {
-    mountComparison(fitLadder, comparator);
-    cy.get('[data-testid="power-fit-toggle"]').check();
-    cy.get(
-      '[data-testid="power-service-test-power-fit-plot"] circle.point[fill="var(--overlay-run-0)"]',
-    ).should('have.length', 2);
-    cy.get('[data-testid="power-service-test-power-fit-plot"] circle.point')
-      .not('[fill="var(--overlay-run-0)"]')
-      .should('have.length', 4);
-    cy.get('[data-testid="equal-service-toggle"]').check();
-    cy.get('[data-testid="equal-service-comparator"]')
-      .invoke('val')
-      .should('contain', OVERLAY_RUN_URL);
-    // The selects are screen-only; exported images name the pair instead.
-    for (const pair of ['equal-service-pair', 'matched-concurrency-pair']) {
-      cy.get(`[data-testid="${pair}"]`)
-        .should('not.be.visible')
-        .and(
-          'have.text',
-          'Baseline: B200 (SGLang) · 2026-09-23 → Comparator: B300 (SGLang) · 2026-09-23',
-        );
-    }
-    cy.get('[data-testid="matched-concurrency-row-8"]').should('exist');
-  });
-
-  it('keeps the compared pair when a new source sorts ahead of the baseline', () => {
-    mountWithProviders(
-      <PinnedComparisonHarness initial={[...fitLadder, ...comparator]} added={[laterSource]} />,
-      {
-        inference: {},
-        unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } },
-      },
-    );
-    cy.get('[data-testid="equal-service-toggle"]').check();
-    cy.get('[data-testid="equal-service-baseline"]').invoke('val').should('contain', 'b200_sglang');
-    cy.get('[data-testid="equal-service-comparator"]')
-      .invoke('val')
-      .should('contain', OVERLAY_RUN_URL);
-    cy.get('[data-testid="add-source"]').click();
-    cy.get('[data-testid="equal-service-baseline"] option').should('have.length', 3);
-    cy.get('[data-testid="equal-service-baseline"]').invoke('val').should('contain', 'b200_sglang');
-    cy.get('[data-testid="equal-service-comparator"]')
-      .invoke('val')
-      .should('contain', OVERLAY_RUN_URL);
-  });
-
-  it('resolves a share link that pre-enables Compare as its rows arrive', () => {
-    // The overlay run can land before the official rows; pinning that first
-    // source would fix both sides on it.
-    writeUrlParams({ i_servicecompare: '1' });
-    mountWithProviders(<PinnedComparisonHarness initial={comparator} added={fitLadder} />, {
-      inference: {},
-      unofficial: { runIndexByUrl: { [OVERLAY_RUN_URL]: 0 } },
-    });
-    cy.get('[data-testid="equal-service-baseline"]')
-      .invoke('val')
-      .should('contain', OVERLAY_RUN_URL);
-    cy.get('[data-testid="add-source"]').click();
-    cy.get('[data-testid="equal-service-baseline"]').invoke('val').should('contain', 'b200_sglang');
-    cy.get('[data-testid="equal-service-comparator"]')
-      .invoke('val')
-      .should('contain', OVERLAY_RUN_URL);
-    cy.get('[data-testid="matched-concurrency-row-8"]').should('exist');
-  });
-});
diff --git a/packages/app/cypress/e2e/powerx-compare.cy.ts b/packages/app/cypress/e2e/powerx-compare.cy.ts
index b0b1982ab..159b01683 100644
--- a/packages/app/cypress/e2e/powerx-compare.cy.ts
+++ b/packages/app/cypress/e2e/powerx-compare.cy.ts
@@ -144,11 +144,10 @@ function visitChart(extraParams: string, officialRunUrl: string) {
   cy.get('[data-testid="chart-figure"]').should('have.length.at.least', 1);
 }
 
-// The article panels under a measured chart: load-matched rows, the role group,
-// the power-vs-output fit and the frontier's provenance, each for official rows
-// and a `?unofficialrun=` overlay together.
 describe('PowerX article panels', () => {
-  const PANELS = '&i_servicecompare=1&i_roleshare=1&i_powerfit=1&i_frontier=1';
+  const PANELS = '&i_roleshare=1&i_powerfit=1&i_frontier=1';
+  const RETIRED_COMPARE =
+    '&i_servicecompare=1&i_servicebase=old-baseline&i_servicepeer=old-comparator&i_servicetarget=40';
   const OFFICIAL_RUN_URL = 'https://github.com/SemiAnalysisAI/InferenceX/actions/runs/27182818284';
   const OVERLAY_COLOR = 'var(--overlay-run-0)';
 
@@ -160,22 +159,16 @@ describe('PowerX article panels', () => {
     });
   });
 
-  it('reproduces matched-load, role, fit and frontier panels for official and overlay rows', () => {
+  it('keeps role, fit and frontier panels while ignoring retired comparison share state', () => {
     interceptCheaperOverlayRows();
     visitChart(
-      `&unofficialrun=${OVERLAY_RUN_ID}&i_metric=y_measuredJPerOutputToken${PANELS}`,
+      `&unofficialrun=${OVERLAY_RUN_ID}&i_metric=y_measuredJPerOutputToken${PANELS}${RETIRED_COMPARE}`,
       OFFICIAL_RUN_URL,
     );
     cy.wait('@unofficialRun');
-    cy.get('[data-testid="equal-service-baseline"] option').should('have.length', 2);
-
-    // Official B200 against the overlay H200 at each observed concurrency.
-    for (const [conc] of CONFIGS) {
-      cy.get(`[data-testid="matched-concurrency-row-${conc}"]`).should(($row) => {
-        const text = $row.text().replaceAll('−', '-');
-        expect(text).to.include('-10.0%').and.include('W/GPU +0.0%');
-      });
-    }
+    cy.get('[data-testid="power-analysis-panels"]').should('be.visible');
+    cy.get('[data-testid^="equal-service-"]').should('not.exist');
+    cy.get('[data-testid^="matched-concurrency"]').should('not.exist');
 
     // Role power: prefill and decode W/GPU for both sources; the overlay in its run colour.
     cy.get('[data-testid="chart-0-role-power-plot"] circle.point').should(
@@ -213,7 +206,10 @@ describe('PowerX article panels', () => {
         expect($row.find('a').attr('href')).to.eq(OVERLAY_RUN_URL);
       });
     assertShareLinkParams({
-      i_servicecompare: '1',
+      i_servicecompare: null,
+      i_servicebase: null,
+      i_servicepeer: null,
+      i_servicetarget: null,
       i_roleshare: '1',
       i_powerfit: '1',
       i_frontier: '1',
diff --git a/packages/app/src/components/inference/ui/ChartDisplay.tsx b/packages/app/src/components/inference/ui/ChartDisplay.tsx
index eb8e0a6e3..768d87c48 100644
--- a/packages/app/src/components/inference/ui/ChartDisplay.tsx
+++ b/packages/app/src/components/inference/ui/ChartDisplay.tsx
@@ -46,13 +46,12 @@ import {
   makeRunComparisonEntry,
 } from '@/components/inference/utils/comparisonEntry';
 import { dataRunsForDate } from '@/components/inference/utils/runEnumeration';
-import { resolveServiceField } from '@/components/inference/utils/resolveXAxisField';
 import { matchesQuickFilters } from '@/components/inference/utils/quickFilters';
 import { bestSeriesPerSku } from '@/components/inference/utils/best-series-per-sku';
 import InferenceTable from '@/components/inference/ui/InferenceTable';
 import ScatterGraph from '@/components/inference/ui/ScatterGraph';
 import PowerTimeline from '@/components/inference/ui/PowerTimeline';
-import PowerServiceComparison from '@/components/inference/ui/PowerServiceComparison';
+import PowerAnalysisPanels from '@/components/inference/ui/PowerAnalysisPanels';
 import { Card } from '@/components/ui/card';
 import { ChartButtons } from '@/components/ui/chart-buttons';
 import { ShareButton } from '@/components/ui/share-button';
@@ -752,12 +751,6 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
   }, [effectiveGraphs, selectedXAxisMode]);
 
   const isAgenticSequence = sequenceKind(selectedSequence) === 'agentic';
-  // Streaming speed at the selected statistic, read by the load-matched PowerX rows.
-  const serviceInteractivityField = resolveServiceField('median_intvty', {
-    isAgentic: isAgenticSequence,
-    percentile: selectedPercentile,
-    fixedSequenceStatistic,
-  });
   const residentPointIds = useMemo(() => {
     if (!isAgenticSequence) return [] as number[];
     const ids = new Set<number>();
@@ -1354,14 +1347,13 @@ export default function ChartDisplay({ embedded = false }: { embedded?: boolean
                           ? visibleDateComparisonRows(graph.data, overlay)
                           : visibleComparisonRows(graph.data, overlay);
                         return (
-                          <PowerServiceComparison
+                          <PowerAnalysisPanels
                             chartId={`chart-${graphIndex}`}
                             contextLabel={`${getModelLabel(selectedModel)} · ${getSequenceLabel(selectedSequence)}`}
                             data={[...officialRows, ...overlayRows]}
                             overlayData={overlayRows}
                             xField={graph.chartDefinition.x_scale_field as keyof AggDataEntry}
                             xLabel={resolvedXLabel}
-                            interactivityField={serviceInteractivityField}
                           />
                         );
                       })()}
diff --git a/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx b/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
deleted file mode 100644
index f535542a2..000000000
--- a/packages/app/src/components/inference/ui/MatchedConcurrencyTable.tsx
+++ /dev/null
@@ -1,211 +0,0 @@
-'use client';
-
-import * as d3 from 'd3';
-import { useMemo } from 'react';
-
-import { ChartButtons } from '@/components/ui/chart-buttons';
-import { Heading } from '@/components/ui/heading';
-import { exportToCsv } from '@/lib/csv-export';
-import { useLocale } from '@/lib/use-locale';
-import type { AggDataEntry, InferenceData } from '../types';
-import {
-  buildMatchedConcurrencyTable,
-  type MatchedConcurrencySide,
-} from '../utils/matched-concurrency';
-
-const STRINGS = {
-  en: {
-    title: 'Matched concurrency (load diagnostic)',
-    concurrency: 'Concurrency',
-    baseline: 'Baseline',
-    comparator: 'Comparator',
-    change: 'Change',
-    energy: 'J/output token',
-    speed: 'tok/s/user',
-    power: 'W/GPU',
-    missing: 'Not measured',
-    ambiguous: (count: number) => `${count} conflicting observations; none selected`,
-    metricMissing: 'Energy not reported',
-    energyChange: 'GPU energy',
-    empty: 'Neither source has an observation with a positive concurrency.',
-    unavailable: 'Choose two different available sources.',
-  },
-  zh: {
-    title: '相同并发下的对照（负载诊断）',
-    concurrency: '并发数',
-    baseline: '基准',
-    comparator: '对比对象',
-    change: '变化',
-    energy: 'J/输出 token',
-    speed: 'tok/s/user',
-    power: 'W/GPU',
-    missing: '未测量',
-    ambiguous: (count: number) => `${count} 个观测值相互冲突，均未采用`,
-    metricMissing: '未报告能耗',
-    energyChange: 'GPU 能耗',
-    empty: '两个数据源都没有并发数为正的观测值。',
-    unavailable: '请选择两个不同且可用的数据源。',
-  },
-};
-
-const joules = d3.format(',.3f');
-const watts = d3.format(',.0f');
-const speed = d3.format(',.1f');
-const signed = d3.format('+.1f');
-const percent = (value: number | null) => (value === null ? '—' : `${signed(value)}%`);
-const sideColumns = (side: MatchedConcurrencySide) =>
-  side.status === 'observed'
-    ? [
-        side.status,
-        side.values.joulesPerOutputToken,
-        side.values.meanWattsPerGpu,
-        side.values.interactivity,
-        side.point.id ?? null,
-        side.point.run_url ?? null,
-      ]
-    : [side.status, null, null, null, null, null];
-
-export default function MatchedConcurrencyTable({
-  chartId,
-  data,
-  baseline,
-  comparator,
-  interactivityField,
-  sourceLabel,
-}: {
-  chartId: string;
-  data: InferenceData[];
-  baseline: string;
-  comparator: string;
-  interactivityField: keyof AggDataEntry;
-  sourceLabel: (key: string) => string;
-}) {
-  const locale = useLocale();
-  const t = STRINGS[locale];
-  const table = useMemo(
-    () => buildMatchedConcurrencyTable(data, { baseline, comparator, interactivityField }),
-    [data, baseline, comparator, interactivityField],
-  );
-  const cell = (side: MatchedConcurrencySide) => {
-    if (side.status === 'missing')
-      return <span className="text-muted-foreground">{t.missing}</span>;
-    if (side.status === 'ambiguous')
-      return <span className="text-muted-foreground">{t.ambiguous(side.points.length)}</span>;
-    const { joulesPerOutputToken, meanWattsPerGpu, interactivity } = side.values;
-    return (
-      <>
-        <strong>
-          {joulesPerOutputToken === null ? t.metricMissing : joules(joulesPerOutputToken)}
-        </strong>
-        <span className="block text-xs text-muted-foreground">
-          {meanWattsPerGpu === null ? '—' : watts(meanWattsPerGpu)} {t.power} ·{' '}
-          {interactivity === null ? '—' : speed(interactivity)} {t.speed}
-        </span>
-      </>
-    );
-  };
-  const sectionId = `${chartId}-matched-concurrency`;
-  const exportCsv = () => {
-    exportToCsv(
-      `InferenceX_matched_concurrency`,
-      [
-        'concurrency',
-        ...['baseline', 'comparator'].flatMap((prefix) => [
-          `${prefix}_status`,
-          `${prefix}_j_per_output_token`,
-          `${prefix}_w_per_gpu`,
-          `${prefix}_${String(interactivityField)}`,
-          `${prefix}_point_id`,
-          `${prefix}_run_url`,
-        ]),
-        'change_j_per_output_token_pct',
-        'change_w_per_gpu_pct',
-        'change_interactivity_pct',
-      ],
-      table.rows.map((row) => [
-        row.concurrency,
-        ...sideColumns(row.baseline),
-        ...sideColumns(row.comparator),
-        row.changePercent.joulesPerOutputToken,
-        row.changePercent.meanWattsPerGpu,
-        row.changePercent.interactivity,
-      ]),
-      [`baseline: ${sourceLabel(baseline)}`, `comparator: ${sourceLabel(comparator)}`],
-    );
-  };
-  return (
-    <section id={sectionId} className="min-w-0 space-y-3" data-testid="matched-concurrency-panel">
-      <Heading as="h3" level="card">
-        {t.title}
-      </Heading>
-      <p className="export-only hidden break-words text-sm" data-testid="matched-concurrency-pair">
-        {t.baseline}: {sourceLabel(baseline)} → {t.comparator}: {sourceLabel(comparator)}
-      </p>
-      {table.reason ? (
-        <p className="text-sm text-muted-foreground">{t.unavailable}</p>
-      ) : table.rows.length === 0 ? (
-        <p className="text-sm text-muted-foreground">{t.empty}</p>
-      ) : (
-        <div className="min-w-0 overflow-x-auto">
-          <table
-            className="w-full min-w-[34rem] table-fixed break-words text-left text-sm"
-            data-testid="matched-concurrency-table"
-          >
-            <thead>
-              <tr>
-                <th className="w-28 whitespace-nowrap p-2">{t.concurrency}</th>
-                <th className="p-2">
-                  {t.baseline}
-                  <span className="block text-xs font-normal text-muted-foreground">
-                    {t.energy}
-                  </span>
-                </th>
-                <th className="p-2">
-                  {t.comparator}
-                  <span className="block text-xs font-normal text-muted-foreground">
-                    {t.energy}
-                  </span>
-                </th>
-                <th className="p-2">
-                  {t.change}
-                  <span className="block text-xs font-normal text-muted-foreground">
-                    {t.energyChange}
-                  </span>
-                </th>
-              </tr>
-            </thead>
-            <tbody>
-              {table.rows.map((row) => (
-                <tr
-                  key={row.concurrency}
-                  className="border-t"
-                  data-testid={`matched-concurrency-row-${row.concurrency}`}
-                >
-                  <th className="p-2 font-medium">{row.concurrency}</th>
-                  <td className="p-2 align-top">{cell(row.baseline)}</td>
-                  <td className="p-2 align-top">{cell(row.comparator)}</td>
-                  <td className="p-2 align-top">
-                    <strong>{percent(row.changePercent.joulesPerOutputToken)}</strong>
-                    <span className="block text-xs text-muted-foreground">
-                      {t.power} {percent(row.changePercent.meanWattsPerGpu)} · {t.speed}{' '}
-                      {percent(row.changePercent.interactivity)}
-                    </span>
-                  </td>
-                </tr>
-              ))}
-            </tbody>
-          </table>
-        </div>
-      )}
-      <div className="max-h-0 overflow-hidden">
-        <div id={`${sectionId}-export`} className="p-4" />
-      </div>
-      <ChartButtons
-        chartId={sectionId}
-        analyticsPrefix="matched_concurrency"
-        hideZoomReset
-        onExportCsv={table.rows.length > 0 ? exportCsv : undefined}
-      />
-    </section>
-  );
-}
diff --git a/packages/app/src/components/inference/ui/PowerAnalysisPanels.tsx b/packages/app/src/components/inference/ui/PowerAnalysisPanels.tsx
new file mode 100644
index 000000000..d2171eea1
--- /dev/null
+++ b/packages/app/src/components/inference/ui/PowerAnalysisPanels.tsx
@@ -0,0 +1,142 @@
+'use client';
+
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { useUnofficialRun } from '@/components/unofficial-run-provider';
+import { useThemeColors } from '@/hooks/useThemeColors';
+import { useUrlState } from '@/hooks/useUrlState';
+import { track } from '@/lib/analytics';
+import { overlayRunColor, overlayRunIndex } from '@/lib/overlay-run-style';
+import { useLocale } from '@/lib/use-locale';
+import type { AggDataEntry, InferenceData } from '../types';
+import {
+  equalServiceSourceKey,
+  getEqualServiceSources,
+  observedPoints,
+} from '../utils/equal-service-comparison';
+import PowerFitPanel from './PowerFitPanel';
+import PowerRoleGroup from './PowerRoleGroup';
+
+const STRINGS = {
+  en: {
+    roles: 'Prefill / decode roles',
+    fit: 'Power vs output-rate fit',
+  },
+  zh: {
+    roles: '预填充 / 解码角色',
+    fit: '功耗与输出速率拟合',
+  },
+};
+
+function PanelToggle({
+  checked,
+  onChange,
+  label,
+  testId,
+  event,
+}: {
+  checked: boolean;
+  onChange: (checked: boolean) => void;
+  label: string;
+  testId: string;
+  event: string;
+}) {
+  return (
+    <label className="flex items-center gap-2">
+      <input
+        type="checkbox"
+        checked={checked}
+        onChange={(e) => {
+          onChange(e.target.checked);
+          track(event, { enabled: e.target.checked });
+        }}
+        data-testid={testId}
+      />
+      {label}
+    </label>
+  );
+}
+
+export default function PowerAnalysisPanels({
+  data,
+  overlayData = [],
+  xField,
+  xLabel,
+  chartId,
+  contextLabel,
+}: {
+  data: InferenceData[];
+  overlayData?: readonly InferenceData[];
+  xField: keyof AggDataEntry;
+  xLabel: string;
+  chartId: string;
+  contextLabel?: string;
+}) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const { getUrlParam, setUrlParams } = useUrlState();
+  const { runIndexByUrl } = useUnofficialRun();
+  const [roleShare, setRoleShare] = useState(() => getUrlParam('i_roleshare') === '1');
+  const [powerFit, setPowerFit] = useState(() => getUrlParam('i_powerfit') === '1');
+  const sources = useMemo(() => getEqualServiceSources(data, locale), [data, locale]);
+  useEffect(() => {
+    setUrlParams({
+      i_roleshare: roleShare ? '1' : '0',
+      i_powerfit: powerFit ? '1' : '0',
+    });
+  }, [roleShare, powerFit, setUrlParams]);
+  const { resolveColor } = useThemeColors({
+    highContrast: true,
+    identifiers: sources.map((s) => s.key),
+  });
+  const overlaySourceKeys = useMemo(
+    () => new Map(observedPoints(overlayData).map((p) => [equalServiceSourceKey(p), p.run_url])),
+    [overlayData],
+  );
+  const colorOf = useCallback(
+    (key: string) =>
+      overlaySourceKeys.has(key)
+        ? overlayRunColor(overlayRunIndex(overlaySourceKeys.get(key), runIndexByUrl))
+        : resolveColor(key),
+    [overlaySourceKeys, runIndexByUrl, resolveColor],
+  );
+  return (
+    <div className="mt-6 min-w-0 space-y-4 border-t pt-4" data-testid="power-analysis-panels">
+      <div className="no-export flex flex-wrap gap-4 text-sm">
+        <PanelToggle
+          checked={roleShare}
+          onChange={setRoleShare}
+          label={t.roles}
+          testId="role-share-toggle"
+          event="inference_power_roles_toggled"
+        />
+        <PanelToggle
+          checked={powerFit}
+          onChange={setPowerFit}
+          label={t.fit}
+          testId="power-fit-toggle"
+          event="inference_power_fit_toggled"
+        />
+      </div>
+      {roleShare && (
+        <PowerRoleGroup
+          chartId={chartId}
+          data={data}
+          xField={xField}
+          xLabel={xLabel}
+          contextLabel={contextLabel}
+          sources={sources}
+          colorOf={colorOf}
+        />
+      )}
+      {powerFit && (
+        <PowerFitPanel
+          chartId={chartId}
+          data={data}
+          contextLabel={contextLabel}
+          colorOf={colorOf}
+        />
+      )}
+    </div>
+  );
+}
diff --git a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx b/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
deleted file mode 100644
index cc7c8dcc0..000000000
--- a/packages/app/src/components/inference/ui/PowerServiceComparison.tsx
+++ /dev/null
@@ -1,493 +0,0 @@
-'use client';
-
-import * as d3 from 'd3';
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-
-import { ChartButtons } from '@/components/ui/chart-buttons';
-import { Heading } from '@/components/ui/heading';
-import { useUnofficialRun } from '@/components/unofficial-run-provider';
-import { useThemeColors } from '@/hooks/useThemeColors';
-import { useUrlState } from '@/hooks/useUrlState';
-import { track } from '@/lib/analytics';
-import { overlayRunColor, overlayRunIndex } from '@/lib/overlay-run-style';
-import { useLocale } from '@/lib/use-locale';
-import type { AggDataEntry, InferenceData } from '../types';
-import {
-  buildEqualServiceComparison,
-  equalServiceSourceKey,
-  getEqualServiceComparisonCurve,
-  getEqualServiceSources,
-  observedPoints,
-  type EqualServiceEstimate,
-  type EqualServiceReason,
-} from '../utils/equal-service-comparison';
-import MatchedConcurrencyTable from './MatchedConcurrencyTable';
-import PowerFitPanel from './PowerFitPanel';
-import { PowerPanelPlot } from './PowerPanelPlot';
-import PowerRoleGroup from './PowerRoleGroup';
-
-const STRINGS = {
-  en: {
-    compare: 'Compare at the same speed / latency',
-    roles: 'Prefill / decode roles',
-    fit: 'Power vs output-rate fit',
-    baseline: 'Baseline',
-    comparator: 'Comparator',
-    target: 'Target',
-    change: 'Change',
-    title: 'Power, throughput and energy at the same service point',
-    concurrency:
-      'Concurrency is a load diagnostic, not equal service. Select interactivity, TTFT or end-to-end latency for the equal-service comparison; the table below pairs observations at each concurrency.',
-    metric: 'Metric',
-    empty: 'No comparable points in the selected sources’ overlapping range.',
-    measured: 'Observed',
-    interpolated: 'Interpolated',
-    observation: 'Observation',
-    meanWattsPerGpu: 'Mean GPU power (W/GPU)',
-    outputTokensPerSecond: 'Deployment output (tok/s)',
-    joulesPerOutputToken: 'GPU energy (J/output token)',
-    percent: 'Comparator change (%)',
-    unavailable: 'Unavailable',
-  },
-  zh: {
-    compare: '在相同速度 / 延迟下比较',
-    roles: '预填充 / 解码角色',
-    fit: '功耗与输出速率拟合',
-    baseline: '基准',
-    comparator: '对比对象',
-    target: '目标值',
-    change: '变化',
-    title: '相同服务指标下的功耗、吞吐量与能耗',
-    concurrency:
-      '并发数用于分析负载，并不代表相同服务水平。相同服务水平的比较请选择交互性、首 token 延迟或端到端延迟；下表按各并发数配对观测值。',
-    metric: '指标',
-    empty: '所选数据源的重叠范围内没有可比较的数据。',
-    measured: '实测',
-    interpolated: '插值',
-    observation: '观测点',
-    meanWattsPerGpu: '平均 GPU 功耗（W/GPU）',
-    outputTokensPerSecond: '部署输出吞吐量（tok/s）',
-    joulesPerOutputToken: 'GPU 能耗（J/输出 token）',
-    percent: '对比对象变化（%）',
-    unavailable: '不可用',
-  },
-};
-const REASONS: Record<EqualServiceReason, [string, string]> = {
-  'unsupported-axis': ['Select a service axis.', '请选择服务指标横轴。'],
-  'invalid-target': ['Enter a positive finite target.', '请输入有效的正数目标值。'],
-  'same-source': ['Choose two different sources.', '请选择两个不同的数据源。'],
-  'unknown-source': [
-    'A selected source is unavailable under these filters.',
-    '当前筛选条件下找不到所选数据源。',
-  ],
-  'out-of-range': ['Target is outside a source range.', '目标值超出数据源范围。'],
-  'ambiguous-x': [
-    'Conflicting observations at the same X; no value selected.',
-    '相同横轴值有冲突的观测数据，未选择数值。',
-  ],
-  'missing-metric': ['A required observation is missing this metric.', '所需观测点缺少该指标。'],
-};
-const METRICS = ['meanWattsPerGpu', 'outputTokensPerSecond', 'joulesPerOutputToken'] as const;
-const DASHES = ['', '6,4', '2,3'];
-const number = d3.format(',.4~g');
-const percent = d3.format('+.2f');
-
-function PanelToggle({
-  checked,
-  onChange,
-  label,
-  testId,
-  event,
-}: {
-  checked: boolean;
-  onChange: (checked: boolean) => void;
-  label: string;
-  testId: string;
-  event: string;
-}) {
-  return (
-    <label className="flex items-center gap-2">
-      <input
-        type="checkbox"
-        checked={checked}
-        onChange={(e) => {
-          onChange(e.target.checked);
-          track(event, { enabled: e.target.checked });
-        }}
-        data-testid={testId}
-      />
-      {label}
-    </label>
-  );
-}
-
-/**
- * PowerX analysis panels under a measured-power chart: equal-service and
- * matched-concurrency comparisons, the prefill/decode role group and the
- * power-vs-output-rate fit. Every panel reads the chart's visible official and
- * `?unofficialrun=` rows; overlay sources take their run's legend colour.
- */
-export default function PowerServiceComparison({
-  data,
-  overlayData = [],
-  xField,
-  xLabel,
-  interactivityField,
-  chartId,
-  contextLabel,
-}: {
-  data: InferenceData[];
-  /** The subset of `data` loaded from unofficial runs. */
-  overlayData?: readonly InferenceData[];
-  xField: keyof AggDataEntry;
-  xLabel: string;
-  /** Streaming-speed field at the selected statistic, for load-matched rows. */
-  interactivityField: keyof AggDataEntry;
-  chartId: string;
-  contextLabel?: string;
-}) {
-  const locale = useLocale();
-  const t = STRINGS[locale];
-  const { getUrlParam, setUrlParams } = useUrlState();
-  const { runIndexByUrl } = useUnofficialRun();
-  const [enabled, setEnabled] = useState(() => getUrlParam('i_servicecompare') === '1');
-  const [roleShare, setRoleShare] = useState(() => getUrlParam('i_roleshare') === '1');
-  const [powerFit, setPowerFit] = useState(() => getUrlParam('i_powerfit') === '1');
-  const [baseline, setBaseline] = useState(() => getUrlParam('i_servicebase') ?? '');
-  const [comparator, setComparator] = useState(() => getUrlParam('i_servicepeer') ?? '');
-  const [target, setTarget] = useState(() => getUrlParam('i_servicetarget') ?? '');
-  const sources = useMemo(() => getEqualServiceSources(data, locale), [data, locale]);
-  const base = baseline || sources[0]?.key || '';
-  const peer = comparator || sources[1]?.key || '';
-  // Turning Compare on pins the pair the user sees: otherwise an added overlay
-  // run or a filter change re-sorts `sources` and silently retargets the panels.
-  // A share link that pre-enables Compare keeps resolving dynamically, because
-  // its rows arrive in any order (an overlay can land before the official rows)
-  // and pinning mid-load would fix both sides on the same source. The URL sync
-  // below records the resolved keys, so a reload restores the pair explicitly.
-  const toggleCompare = useCallback(
-    (checked: boolean) => {
-      setEnabled(checked);
-      if (!checked) return;
-      if (!baseline && sources[0]) setBaseline(sources[0].key);
-      if (!comparator && sources[1]) setComparator(sources[1].key);
-    },
-    [baseline, comparator, sources],
-  );
-  const previousAxis = useRef(xField);
-  useEffect(() => {
-    if (previousAxis.current !== xField) {
-      previousAxis.current = xField;
-      setTarget('');
-      setUrlParams({ i_servicetarget: '' });
-    }
-  }, [xField, setUrlParams]);
-  useEffect(() => {
-    setUrlParams({
-      i_servicecompare: enabled ? '1' : '0',
-      i_roleshare: roleShare ? '1' : '0',
-      i_powerfit: powerFit ? '1' : '0',
-      i_servicebase: enabled ? base : baseline,
-      i_servicepeer: enabled ? peer : comparator,
-      i_servicetarget: target,
-    });
-  }, [enabled, roleShare, powerFit, base, peer, baseline, comparator, target, setUrlParams]);
-  const curve = useMemo(
-    () =>
-      enabled
-        ? getEqualServiceComparisonCurve(data, {
-            baseline: base,
-            comparator: peer,
-            xField,
-          })
-        : [],
-    [enabled, data, base, peer, xField],
-  );
-  const comparison = useMemo(
-    () =>
-      enabled && target.trim()
-        ? buildEqualServiceComparison(data, {
-            baseline: base,
-            comparator: peer,
-            xField,
-            target: Number(target),
-          })
-        : null,
-    [enabled, data, base, peer, xField, target],
-  );
-  const { resolveColor } = useThemeColors({
-    highContrast: true,
-    identifiers: [...METRICS, ...sources.map((s) => s.key)],
-  });
-  const metricColors = Object.fromEntries(METRICS.map((key) => [key, resolveColor(key)]));
-  const overlaySourceKeys = useMemo(
-    () => new Map(observedPoints(overlayData).map((p) => [equalServiceSourceKey(p), p.run_url])),
-    [overlayData],
-  );
-  const colorOf = useCallback(
-    (key: string) =>
-      overlaySourceKeys.has(key)
-        ? overlayRunColor(overlayRunIndex(overlaySourceKeys.get(key), runIndexByUrl))
-        : resolveColor(key),
-    [overlaySourceKeys, runIndexByUrl, resolveColor],
-  );
-  const sourceLabel = (key: string) =>
-    sources.find((source) => source.key === key)?.label ?? t.unavailable;
-  // The percentage of interpolated raw values is not linear in X. Include the
-  // exact selected target as a knot so its plotted marker agrees with the table.
-  const plottedCurve =
-    comparison && Object.values(comparison.metrics).some((metric) => metric.changePercent !== null)
-      ? [...curve.filter((row) => row.target !== comparison.target), comparison].sort(
-          (a, b) => a.target - b.target,
-        )
-      : curve;
-  const plotPoints = METRICS.flatMap((key) =>
-    plottedCurve.map((row) => ({
-      key,
-      x: row.target,
-      y: row.metrics[key].changePercent ?? NaN,
-      selected: row.target === comparison?.target,
-    })),
-  );
-  const reason = (value?: EqualServiceReason) =>
-    value ? REASONS[value][locale === 'zh' ? 1 : 0] : t.unavailable;
-  const estimate = (value: EqualServiceEstimate | null) =>
-    value ? (
-      <>
-        <strong>{number(value.value)}</strong>
-        <span className="block text-xs text-muted-foreground">
-          {value.interpolated ? t.interpolated : t.measured}
-        </span>
-        <span className="block text-xs text-muted-foreground">
-          {value.endpoints
-            .map(
-              (endpoint) =>
-                `${t.observation} ${endpoint.point.id ?? '—'}: ${number(endpoint.x)} · c${endpoint.point.conc}`,
-            )
-            .join(' → ')}
-        </span>
-      </>
-    ) : (
-      '—'
-    );
-  const selectClass = 'w-full min-w-0 rounded-md border bg-background p-2 text-sm';
-  const sourceSelect = (
-    value: string,
-    onChange: (value: string) => void,
-    label: string,
-    testId: string,
-    role: 'baseline' | 'comparator',
-  ) => (
-    <label className="min-w-0 space-y-1 text-sm">
-      <span>{label}</span>
-      <select
-        className={selectClass}
-        aria-label={label}
-        data-testid={testId}
-        value={value}
-        onChange={(event) => {
-          onChange(event.target.value);
-          track('inference_equal_service_source_changed', { role });
-        }}
-      >
-        {!sources.some((source) => source.key === value) && (
-          <option value={value}>{t.unavailable}</option>
-        )}
-        {sources.map((source) => (
-          <option key={source.key} value={source.key}>
-            {source.label}
-          </option>
-        ))}
-      </select>
-    </label>
-  );
-  return (
-    <div className="mt-6 min-w-0 space-y-4 border-t pt-4" data-testid="power-service-comparison">
-      <div className="no-export flex flex-wrap gap-4 text-sm">
-        <PanelToggle
-          checked={enabled}
-          onChange={toggleCompare}
-          label={t.compare}
-          testId="equal-service-toggle"
-          event="inference_equal_service_toggled"
-        />
-        <PanelToggle
-          checked={roleShare}
-          onChange={setRoleShare}
-          label={t.roles}
-          testId="role-share-toggle"
-          event="inference_power_roles_toggled"
-        />
-        <PanelToggle
-          checked={powerFit}
-          onChange={setPowerFit}
-          label={t.fit}
-          testId="power-fit-toggle"
-          event="inference_power_fit_toggled"
-        />
-      </div>
-      {enabled && (
-        <>
-          <div className="no-export grid min-w-0 gap-3 md:grid-cols-2">
-            {sourceSelect(base, setBaseline, t.baseline, 'equal-service-baseline', 'baseline')}
-            {sourceSelect(
-              peer,
-              setComparator,
-              t.comparator,
-              'equal-service-comparator',
-              'comparator',
-            )}
-          </div>
-          {xField === 'conc' ? (
-            <p
-              className="text-sm text-muted-foreground"
-              data-testid="equal-service-concurrency-note"
-            >
-              {t.concurrency}
-            </p>
-          ) : (
-            <section
-              id={`${chartId}-service`}
-              className="min-w-0 space-y-3"
-              data-testid="equal-service-panel"
-            >
-              <Heading as="h3" level="card">
-                {t.title}
-              </Heading>
-              <p className="export-only hidden text-sm text-muted-foreground">{contextLabel}</p>
-              {/* The source selects are no-export, so exported images name the pair here. */}
-              <p
-                className="export-only hidden break-words text-sm"
-                data-testid="equal-service-pair"
-              >
-                {t.baseline}: {sourceLabel(base)} → {t.comparator}: {sourceLabel(peer)}
-              </p>
-              <div className="flex flex-wrap gap-x-5 gap-y-2 text-sm">
-                {METRICS.map((key, index) => (
-                  <span key={key} className="inline-flex items-center gap-2">
-                    <svg width="28" height="10" aria-hidden="true">
-                      <line
-                        x1="0"
-                        x2="28"
-                        y1="5"
-                        y2="5"
-                        stroke={metricColors[key]}
-                        strokeWidth="2"
-                        strokeDasharray={DASHES[index]}
-                      />
-                    </svg>
-                    {t[key]}
-                  </span>
-                ))}
-              </div>
-              {plotPoints.some((p) => Number.isFinite(p.y)) ? (
-                <PowerPanelPlot
-                  chartId={`${chartId}-service`}
-                  markers={plotPoints.filter((p) => Number.isFinite(p.y))}
-                  lines={METRICS.map((key, index) => ({
-                    key,
-                    color: metricColors[key],
-                    dash: DASHES[index],
-                    points: plotPoints.filter((p) => p.key === key),
-                  }))}
-                  markerColor={(key) => metricColors[key]}
-                  xLabel={xLabel}
-                  yLabel={t.percent}
-                  reference={0}
-                  height={360}
-                />
-              ) : (
-                <p className="py-6 text-sm text-muted-foreground">{t.empty}</p>
-              )}
-              <div className="max-h-0 overflow-hidden">
-                <div id={`${chartId}-service-export`} className="p-4" />
-              </div>
-              <ChartButtons
-                chartId={`${chartId}-service`}
-                analyticsPrefix="equal_service"
-                hideZoomReset
-              />
-              <label className="no-export block max-w-lg space-y-1 text-sm">
-                {t.target} · {xLabel}
-                <input
-                  className={selectClass}
-                  type="number"
-                  min="0"
-                  step="any"
-                  value={target}
-                  onChange={(e) => setTarget(e.target.value)}
-                  data-testid="equal-service-target"
-                />
-              </label>
-              {comparison && (
-                <div className="min-w-0">
-                  <table
-                    className="w-full table-fixed break-words text-left text-sm"
-                    data-testid="equal-service-table"
-                  >
-                    <caption className="mb-2 text-left">
-                      {xLabel}: {number(comparison.target)}
-                    </caption>
-                    <thead>
-                      <tr>
-                        <th className="p-2">{t.metric}</th>
-                        <th className="p-2">{t.baseline}</th>
-                        <th className="p-2">{t.comparator}</th>
-                        <th className="p-2">{t.change}</th>
-                      </tr>
-                    </thead>
-                    <tbody>
-                      {METRICS.map((key) => (
-                        <tr className="border-t" key={key} data-testid={`equal-service-${key}`}>
-                          <th className="p-2 font-medium">{t[key]}</th>
-                          <td className="p-2 align-top">
-                            {estimate(comparison.metrics[key].baseline)}
-                          </td>
-                          <td className="p-2 align-top">
-                            {estimate(comparison.metrics[key].comparator)}
-                          </td>
-                          <td className="p-2 align-top">
-                            {comparison.metrics[key].changePercent === null
-                              ? reason(comparison.metrics[key].reason)
-                              : `${percent(comparison.metrics[key].changePercent!)}%`}
-                          </td>
-                        </tr>
-                      ))}
-                    </tbody>
-                  </table>
-                </div>
-              )}
-            </section>
-          )}
-          <MatchedConcurrencyTable
-            chartId={chartId}
-            data={data}
-            baseline={base}
-            comparator={peer}
-            interactivityField={interactivityField}
-            sourceLabel={sourceLabel}
-          />
-        </>
-      )}
-      {roleShare && (
-        <PowerRoleGroup
-          chartId={chartId}
-          data={data}
-          xField={xField}
-          xLabel={xLabel}
-          contextLabel={contextLabel}
-          sources={sources}
-          colorOf={colorOf}
-        />
-      )}
-      {powerFit && (
-        <PowerFitPanel
-          chartId={chartId}
-          data={data}
-          contextLabel={contextLabel}
-          colorOf={colorOf}
-        />
-      )}
-    </div>
-  );
-}
diff --git a/packages/app/src/lib/url-state.test.ts b/packages/app/src/lib/url-state.test.ts
index 39a1937e0..c10e39e74 100644
--- a/packages/app/src/lib/url-state.test.ts
+++ b/packages/app/src/lib/url-state.test.ts
@@ -99,6 +99,22 @@ describe('PARAM_DEFAULTS', () => {
     expect(PARAM_DEFAULTS.i_advlabel).toBe('');
   });
 
+  it('drops retired comparison controls from old share links while preserving analysis toggles', async () => {
+    setupWindow(
+      '?i_servicecompare=1&i_servicebase=baseline&i_servicepeer=comparator&i_servicetarget=8&i_roleshare=1&i_powerfit=1',
+    );
+    const { readUrlParams, buildShareUrl } = await import('@/lib/url-state');
+    const params = readUrlParams();
+    const shared = new URL(buildShareUrl()).searchParams;
+    expect(params).toMatchObject({ i_roleshare: '1', i_powerfit: '1' });
+    expect(shared.get('i_roleshare')).toBe('1');
+    expect(shared.get('i_powerfit')).toBe('1');
+    for (const key of ['i_servicecompare', 'i_servicebase', 'i_servicepeer', 'i_servicetarget']) {
+      expect(params).not.toHaveProperty(key);
+      expect(shared.has(key)).toBe(false);
+    }
+  });
+
   it('strips the normalized revenue source but preserves OpenRouter as explicit state', async () => {
     const { PARAM_DEFAULTS } = await import('@/lib/url-state');
     expect(PARAM_DEFAULTS.i_revenue).toBe('normalized');
diff --git a/packages/app/src/lib/url-state.ts b/packages/app/src/lib/url-state.ts
index d75f4e736..4479c9d30 100644
--- a/packages/app/src/lib/url-state.ts
+++ b/packages/app/src/lib/url-state.ts
@@ -31,10 +31,6 @@ const URL_STATE_KEYS = [
   'i_revenue',
   'i_pctl',
   'i_mstat',
-  'i_servicecompare',
-  'i_servicebase',
-  'i_servicepeer',
-  'i_servicetarget',
   'i_roleshare',
   'i_powerfit',
   'i_xmetric',
@@ -172,10 +168,6 @@ export const PARAM_DEFAULTS: Record<UrlStateKey, string> = {
   i_revenue: 'normalized',
   i_pctl: 'p90',
   i_mstat: 'median',
-  i_servicecompare: '0',
-  i_servicebase: '',
-  i_servicepeer: '',
-  i_servicetarget: '',
   i_roleshare: '0',
   i_powerfit: '0',
   i_xmetric: 'p90_ttft',
diff --git a/packages/app/src/lib/views-api/docs/inference.ts b/packages/app/src/lib/views-api/docs/inference.ts
index e8a4ca670..5530d2b22 100644
--- a/packages/app/src/lib/views-api/docs/inference.ts
+++ b/packages/app/src/lib/views-api/docs/inference.ts
@@ -221,8 +221,8 @@ const parameters: readonly ApiParameter[] = [
     required: false,
     type: 'boolean',
     description: text(
-      'Include source options, equal-service percentage curves, an optional target comparison and the same-concurrency diagnostic table (matchedConcurrency), using the same helpers as the dashboard. Uses scoped observed points before frontier/best pruning. JSON only.',
-      '返回来源选项、同等服务条件下的百分比对比曲线、可选目标值对比，以及相同并发下的诊断表（matchedConcurrency）；复用仪表板计算逻辑，使用筛选后、前沿和 best 筛选前的实测点。仅支持 JSON。',
+      'API-only analysis: include source options, equal-service percentage curves, an optional target comparison and the same-concurrency diagnostic table (matchedConcurrency). Uses scoped observed points before frontier/best pruning. No corresponding dashboard control or panel. JSON only.',
+      '仅通过 API 提供的分析：返回来源选项、同等服务条件下的百分比对比曲线、可选目标值对比，以及相同并发下的诊断表（matchedConcurrency）。使用筛选后、前沿和 best 筛选前的实测点。仪表板不提供对应控件或面板。仅支持 JSON。',
     ),
     schema: { type: 'boolean', default: false },
     example: 'true',
@@ -293,8 +293,8 @@ const parameters: readonly ApiParameter[] = [
     required: false,
     type: 'enum',
     description: text(
-      'Response encoding. csv returns one flat row per plotted point; serviceCompare, roleShare and powerFit panels require JSON and return 400 with CSV.',
-      '响应编码。csv 为每个图表点返回一行平面数据；serviceCompare、roleShare 和 powerFit 面板仅支持 JSON，与 CSV 同用时返回 400。',
+      'Response encoding. csv returns one flat row per plotted point; serviceCompare, roleShare and powerFit analytical results require JSON and return 400 with CSV.',
+      '响应编码。csv 为每个图表点返回一行平面数据；serviceCompare、roleShare 和 powerFit 分析结果仅支持 JSON，与 CSV 同用时返回 400。',
     ),
     schema: { type: 'string', enum: ['json', 'csv'], default: 'json' },
     example: 'csv',
diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index 747e90c39..57f2d58d8 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -8,7 +8,7 @@
     "references/cli-contract.md": "fa44faa38d889b4fbdee5ba42752b47758ee3706fab150513bd4e6db87a86cb0",
     "references/cli.md": "96b228f34cb3600f4548f4dc84df8506531747286763c56ca834c77bee05e1eb",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "1c594e186f79adf74663eb2b845e54116eaec560c139e184b107994c75a98937",
+    "references/dashboard-views.md": "aecc8dab0ee0ae8e1d0aaaafa5e5a5911a7c04526ab35af5bdbad61e387bc9f2",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/pareto.md": "1b4d2d163f982e3f2d97addce310789eae9c1e5badd82dd7501708c9e0385027",
     "references/powerx.md": "cf8adcc5dfe395c5fb659908819980a872475f862f22b723815af43d363cedad",
diff --git a/packages/skills/skills/inferencex-api/references/dashboard-views.md b/packages/skills/skills/inferencex-api/references/dashboard-views.md
index 554288280..3df908d57 100644
--- a/packages/skills/skills/inferencex-api/references/dashboard-views.md
+++ b/packages/skills/skills/inferencex-api/references/dashboard-views.md
@@ -37,30 +37,30 @@ https://inferencex.semianalysis.com/api/v1/views/profit-estimator?model=DeepSeek
 
 All paths below are relative to `/api/v1/views/`. The maintained exhaustive
 query-key list is in the app's OpenAPI contract. The following groups explain
-which controls belong together.
-
-| View                            | Selection and calculation                                                                                                                                                                                                                                                                                              |
-| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `options`                       | Static registries and defaults, JSON only. Data-dependent run/config choices come from their own views.                                                                                                                                                                                                                |
-| `inference`                     | Model, sequence, precisions, date/exact run, GPU/vendor/framework/deployment/spec/power filters; metric, xmode, xstat, xmetric, percentile, optimal/best/allPoints; equal-service sources/target, roleShare and powerFit; TCO, custom costs/powers, pricing, unofficial runs, comparison dates/endpoints. JSON or CSV. |
-| `historical`                    | Model, sequence, target, metric, precisions, GPUs/vendors/frameworks/deployment, start/end, TCO and pricing. `extendToDate` labels synthetic extension, defaults to current UTC date. JSON or CSV.                                                                                                                     |
-| `calculator`                    | Model/sequence/run/date, precisions/GPUs, percentile, target/mode, token type, owning/renting cost, TCO, power budget, cost cap, hide-above-limit and public unofficial runs. JSON or CSV.                                                                                                                             |
-| `first-token`                   | Benchmark selection plus 1–8 positive TTFT caps in seconds, minimum interactivity, cost provider and token type. Shared dashboard winner selection.                                                                                                                                                                    |
-| `cache-reuse`                   | AgentX selection plus exact `config` from returned configurations. Cache-reuse curves retain official versus unofficial evidence.                                                                                                                                                                                      |
-| `profit-estimator`              | AgentX selection, comparison dates/runs, target, utilization, lab revenue share, list/OpenRouter/custom token prices, own/rent/custom chip costs, TCO and provisioned/modeled/compare power. USD/chip-hour.                                                                                                            |
-| `profit-estimator-per-gigawatt` | Same selectors; USD/GW-year basis and owning-cost default.                                                                                                                                                                                                                                                             |
-| `fleet`                         | Model/sequence/precision/GPUs, target/percentile, TCO/token type/cost provider, MW, input/output prices, ramp, cache discount, MTBI, recovery, horizon and metric. JSON or CSV.                                                                                                                                        |
-| `evaluation`                    | Model, task, date, precision and GPU selection; public unofficial runs remain separately labeled and independent of the official date cutoff. JSON or CSV.                                                                                                                                                             |
-| `reliability`                   | Rolling range, GPU selection and optional `asOf` date for reproducibility. JSON or CSV.                                                                                                                                                                                                                                |
-| `gpu-specs`                     | Full hardware properties or selected metric ranking; table/radar/bar are renderings of these values. JSON or CSV.                                                                                                                                                                                                      |
-| `overview`                      | Models, model/hardware row limits, hardware tier, engine, comparison mode and reference. JSON or CSV.                                                                                                                                                                                                                  |
-| `rankings`                      | Ranking kind (model or chip), selected model/scenario and format. Use the exact values in OpenAPI.                                                                                                                                                                                                                     |
-| `compare`                       | GPU pairs, model/slug, scenario, tier selection and variant. JSON or CSV.                                                                                                                                                                                                                                              |
-| `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                                                                                            |
-| `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                                                                                 |
-| `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                                                                              |
-| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first raw-explorer projection; full-record statistics use stored digests. Not a serving-window/role-pool projection. Responses are no-store.                     |
-| `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                                                                                 |
+which API selectors belong together.
+
+| View                            | Selection and calculation                                                                                                                                                                                                                                                                                                              |
+| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `options`                       | Static registries and defaults, JSON only. Data-dependent run/config choices come from their own views.                                                                                                                                                                                                                                |
+| `inference`                     | Model, sequence, precisions, date/exact run, GPU/vendor/framework/deployment/spec/power filters; metric, xmode, xstat, xmetric, percentile, optimal/best/allPoints; API-only equal-service sources/target; roleShare and powerFit panels; TCO, custom costs/powers, pricing, unofficial runs, comparison dates/endpoints. JSON or CSV. |
+| `historical`                    | Model, sequence, target, metric, precisions, GPUs/vendors/frameworks/deployment, start/end, TCO and pricing. `extendToDate` labels synthetic extension, defaults to current UTC date. JSON or CSV.                                                                                                                                     |
+| `calculator`                    | Model/sequence/run/date, precisions/GPUs, percentile, target/mode, token type, owning/renting cost, TCO, power budget, cost cap, hide-above-limit and public unofficial runs. JSON or CSV.                                                                                                                                             |
+| `first-token`                   | Benchmark selection plus 1–8 positive TTFT caps in seconds, minimum interactivity, cost provider and token type. Shared dashboard winner selection.                                                                                                                                                                                    |
+| `cache-reuse`                   | AgentX selection plus exact `config` from returned configurations. Cache-reuse curves retain official versus unofficial evidence.                                                                                                                                                                                                      |
+| `profit-estimator`              | AgentX selection, comparison dates/runs, target, utilization, lab revenue share, list/OpenRouter/custom token prices, own/rent/custom chip costs, TCO and provisioned/modeled/compare power. USD/chip-hour.                                                                                                                            |
+| `profit-estimator-per-gigawatt` | Same selectors; USD/GW-year basis and owning-cost default.                                                                                                                                                                                                                                                                             |
+| `fleet`                         | Model/sequence/precision/GPUs, target/percentile, TCO/token type/cost provider, MW, input/output prices, ramp, cache discount, MTBI, recovery, horizon and metric. JSON or CSV.                                                                                                                                                        |
+| `evaluation`                    | Model, task, date, precision and GPU selection; public unofficial runs remain separately labeled and independent of the official date cutoff. JSON or CSV.                                                                                                                                                                             |
+| `reliability`                   | Rolling range, GPU selection and optional `asOf` date for reproducibility. JSON or CSV.                                                                                                                                                                                                                                                |
+| `gpu-specs`                     | Full hardware properties or selected metric ranking; table/radar/bar are renderings of these values. JSON or CSV.                                                                                                                                                                                                                      |
+| `overview`                      | Models, model/hardware row limits, hardware tier, engine, comparison mode and reference. JSON or CSV.                                                                                                                                                                                                                                  |
+| `rankings`                      | Ranking kind (model or chip), selected model/scenario and format. Use the exact values in OpenAPI.                                                                                                                                                                                                                                     |
+| `compare`                       | GPU pairs, model/slug, scenario, tier selection and variant. JSON or CSV.                                                                                                                                                                                                                                                              |
+| `collectivex`                   | Ordered run selection and suite; EP size/phase/modes/precision/operation/percentile/axis/SKU/backend/series; KV page size/x/y/pull/push/overlap ISL/series; swap direction/layout/metric/percentile/series.                                                                                                                            |
+| `submissions`                   | Search, table sort/direction/offset/limit, weekly/cumulative chart, on-change cutoff and NVIDIA/AMD/total lines. Table search does not filter the independent submission-volume chart.                                                                                                                                                 |
+| `current-inferencex-image`      | Model, sequence, hardware, precision, speculation, node type, framework families and `asOf` for image age/release status.                                                                                                                                                                                                              |
+| `gpu-metrics`                   | Required run, file/host artifact, GPU indices, metric or correlation axes, statistics sorting, chart mode and interactive downsampling preference. DB-first raw-explorer projection; full-record statistics use stored digests. Not a serving-window/role-pool projection. Responses are no-store.                                     |
+| `video`                         | CI run/artifact discovery; only already-published artifact reads; source, serving cell, media/fidelity slot, power phase and GPU denominator; same-workload comparisons, axes, deployment costs and selected tradeoff point. No-store.                                                                                                 |
 
 ## Interpretation and maintenance
 
@@ -103,6 +103,11 @@ TTFT/E2E use recorded means. Default is median; absent means are not replaced.
 AgentX still uses `percentile`; concurrency uses no statistic. Check resolved
 `params.xstat` and `xAxis.statistic`, not the requested parameter alone.
 
+Equal-service and matched-concurrency analysis are API-only. The dashboard keeps role and
+power-fit panels, but has no service-comparison control, source selector, target input or
+matched-concurrency table. Use `serviceCompare`, `serviceBaseline`, `serviceComparator` and
+`serviceTarget` as API query parameters; they have no dashboard share-parameter equivalents.
+
 `serviceCompare=true` returns exact opaque `serviceSources` keys, an
 `equalServiceCurve`, and an optional `equalServiceComparison` at `serviceTarget`.
 Use returned keys verbatim for `serviceBaseline` and `serviceComparator` via
@@ -118,7 +123,7 @@ their original producer provenance; differing telemetry producer/exporter hashes
 split the snapshot. Recipe, image and topology remain distinct. Rows without a snapshot
 retain their own run, measured date and telemetry producer/exporter hashes in the source key.
 
-The same dashboard helper uses scoped observed points before frontier/best
+The API uses scoped observed points before frontier/best
 pruning, with no power-comparison clones. It interpolates raw quantities
 linearly only inside each exact source range, then reports signed
 `100 × (comparator / baseline − 1)`. Metrics are measured GPU W/GPU,
@@ -146,9 +151,14 @@ n, x-range, registry `tdpWatts` and point identities. Fewer than three distinct
 rates return `fit: null`, `reason: "too-few-points"`. Call `P₀` an extrapolated
 intercept, not idle power, and do not read the line outside its x-range.
 
-These panels require JSON; enabling any with CSV returns 400. Existing CSV remains
+These analytical results require JSON; enabling any with CSV returns 400. Existing CSV remains
 a plotted-point export.
 
+同等服务对比与同并发诊断仅通过 API 提供，查询参数为 `serviceCompare`、`serviceBaseline`、
+`serviceComparator` 和 `serviceTarget`；仪表板没有对应的服务对比控件、来源选择、目标值输入、
+同并发表格或分享参数。角色分析和功耗拟合面板仍在仪表板中提供，分别对应 `roleShare` 和
+`powerFit`。来源标识、插值规则、缺失原因和仅 JSON 的响应约束以上文说明为准。
+
 For exact-load comparisons, use `xmode=concurrency`. The response resolves
 `optimal=false` and `best=false`, retains every eligible observed load, and sets
 `frontier.direction=null`; concurrency is not a speed or quality preference.

From 19b853c2c514272e85e1bd70b5e0b6ee5fd75984 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <105094497+edwingao28@users.noreply.github.com>
Date: Wed, 30 Sep 2026 16:25:17 -0700
Subject: [PATCH 102/103] =?UTF-8?q?fix(inference):=20remove=20agentic=20La?=
 =?UTF-8?q?tency=20Percentile=20control=20/=20=E7=A7=BB=E9=99=A4=E6=99=BA?=
 =?UTF-8?q?=E8=83=BD=E4=BD=93=E5=BB=B6=E8=BF=9F=E5=88=86=E4=BD=8D=E6=95=B0?=
 =?UTF-8?q?=E6=8E=A7=E4=BB=B6=20(#1243)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(inference): fix agentic x-axis latency at p75

Remove the gated Latency Percentile dropdown on inference agentic charts.
Keep measured power Average/P75/P90 and label that control Power statistic.

中文：移除智能体图表上的延迟分位数下拉；X 轴固定为 p75；保留功耗统计量 Average/P75/P90。

Co-authored-by: Wenyao Gao <edwingao28@users.noreply.github.com>

* fix(inference): keep agentic x-axis latency fixed at p90

Match the pre-change agentic basis. Dropdown stays removed; Power statistic unchanged.

中文：智能体 X 轴延迟分位数改回固定 p90（与改前一致）；下拉仍移除。

Co-authored-by: Wenyao Gao <edwingao28@users.noreply.github.com>

---------

Co-authored-by: Wenyao Gao <edwingao28@users.noreply.github.com>
---
 .../app/cypress/e2e/ttft-x-axis-toggle.cy.ts  | 35 +++++--------------
 packages/app/cypress/support/mock-data.ts     |  1 -
 .../components/inference/InferenceContext.tsx |  9 ++---
 .../app/src/components/inference/types.ts     |  1 -
 .../components/inference/ui/ChartControls.tsx | 21 ++---------
 .../inference/ui/MeasuredMetricControls.tsx   |  4 +--
 6 files changed, 14 insertions(+), 57 deletions(-)

diff --git a/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts b/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts
index 4aba05b46..316316d69 100644
--- a/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts
+++ b/packages/app/cypress/e2e/ttft-x-axis-toggle.cy.ts
@@ -212,7 +212,7 @@ describe('X-Axis Mode Toggle (inference chart)', () => {
     cy.get('#chart-0 [data-testid="offload-halo-key"]').should('not.exist');
   });
 
-  it('shows the selected percentile in the Interactivity axis label', () => {
+  it('shows the fixed p90 percentile in the Interactivity axis label', () => {
     // Explicitly select the mode — do not rely on the agentic default mode.
     selectXAxisMode('interactivity', 'Interactivity');
     // Agentic plots percentile fields (p90_intvty), so the axis label carries it.
@@ -274,22 +274,6 @@ describe('X-Axis Mode Toggle (inference chart)', () => {
       'contain.text',
       'P90 E2E Normalized Interactivity (tok/s/user)',
     );
-
-    cy.get('[data-testid="percentile-selector"]').click();
-    cy.contains('[role="option"]', 'p75').click();
-    cy.get('[data-testid="chart-figure"] h2').should(
-      'contain.text',
-      'P75 E2E Normalized Interactivity',
-    );
-
-    // The percentile selector is shared page state for the whole suite —
-    // restore the p90 default so later tests assert against a known value.
-    cy.get('[data-testid="percentile-selector"]').click();
-    cy.contains('[role="option"]', 'p90').click();
-    cy.get('[data-testid="chart-figure"] h2').should(
-      'contain.text',
-      'P90 E2E Normalized Interactivity',
-    );
   });
 
   it('does not change the chart while browsing options, and Escape cancels', () => {
@@ -312,15 +296,12 @@ describe('X-Axis Mode Toggle (inference chart)', () => {
     );
   });
 
-  it('follows the percentile selector in the Interactivity axis label', () => {
-    // Select p75 here rather than inheriting it from another test — the axis
-    // label must track the selector on its own.
+  it('keeps the agentic Latency Percentile control removed and labels the fixed p90 basis', () => {
     selectXAxisMode('interactivity', 'Interactivity');
-    cy.get('[data-testid="percentile-selector"]').click();
-    cy.contains('[role="option"]', 'p75').click();
+    cy.get('[data-testid="percentile-selector"]').should('not.exist');
     cy.get('[data-testid="chart-figure"] svg').should(
       'contain.text',
-      'P75 Interactivity (tok/s/user)',
+      'P90 Interactivity (tok/s/user)',
     );
   });
 });
@@ -352,15 +333,15 @@ describe('X-axis mode URL param', () => {
     cy.get('[data-testid="chart-figure"] h2').should('contain.text', 'Time To First Token');
   });
 
-  // AgentX publishes on P90, so the percentile control is insider-only. With
-  // the gate locked it must not render, and the chart must still plot P90.
-  it('hides the percentile selector behind the feature gate and defaults to P90', () => {
+  // Agentic inference charts fix the x-axis latency basis at P90. The old
+  // Latency Percentile dropdown is gone even when the feature gate is unlocked.
+  it('never shows the latency percentile selector and labels the fixed P90 basis', () => {
     interceptAgenticData();
     interceptDerivedAgenticMetrics();
     cy.visit('/inference?i_seq=agentic-traces', {
       onBeforeLoad(win) {
         win.localStorage.setItem('inferencex-star-modal-dismissed', String(Date.now()));
-        win.localStorage.removeItem('inferencex-feature-gate');
+        unlockAgenticGate(win);
       },
     });
 
diff --git a/packages/app/cypress/support/mock-data.ts b/packages/app/cypress/support/mock-data.ts
index 5fffbf9f2..6d5823812 100644
--- a/packages/app/cypress/support/mock-data.ts
+++ b/packages/app/cypress/support/mock-data.ts
@@ -229,7 +229,6 @@ export function createMockInferenceContextValues(
     selectedPercentile: 'p90',
     fixedSequenceStatistic: 'median',
     setFixedSequenceStatistic: namedStub('setFixedSequenceStatistic'),
-    setSelectedPercentile: namedStub('setSelectedPercentile'),
     selectedXAxisMetric: null,
     setSelectedXAxisMetric: namedStub('setSelectedXAxisMetric'),
     selectedE2eXAxisMetric: null,
diff --git a/packages/app/src/components/inference/InferenceContext.tsx b/packages/app/src/components/inference/InferenceContext.tsx
index 109de2fb1..d29bc5759 100644
--- a/packages/app/src/components/inference/InferenceContext.tsx
+++ b/packages/app/src/components/inference/InferenceContext.tsx
@@ -489,11 +489,8 @@ export function InferenceProvider({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
-  // Latency percentile applied to the chart x-axis for agentic scenarios.
-  // Values: 'p90' | 'p99'. Non-agentic charts ignore.
-  const [selectedPercentile, setSelectedPercentile] = useState<string>(
-    () => getUrlParam('i_pctl') || 'p90',
-  );
+  // Agentic x-axis latency basis is fixed at p90 (no Latency Percentile control).
+  const selectedPercentile = 'p90';
   const selectedE2eXAxisMetric = resolveE2eXAxisMetric(
     requestedE2eXAxisMetric,
     selectedXAxisMode,
@@ -1620,7 +1617,6 @@ export function InferenceProvider({
     {
       i_metric: selectedYAxisMetric,
       i_revenue: usesTokenSalePricing(selectedYAxisMetric) ? tokenRevenuePriceSource : 'normalized',
-      i_pctl: selectedPercentile,
       i_mstat: fixedSequenceStatistic,
       i_gpus: selectedGPUs.join(','),
       i_dates: selectedDates.join(','),
@@ -1965,7 +1961,6 @@ export function InferenceProvider({
     setSelectedPrecisions: setSelectedPrecisionsAndClear,
     setSelectedYAxisMetric: setSelectedYAxisMetricAndClear,
     setTokenRevenuePriceSource,
-    setSelectedPercentile,
     setFixedSequenceStatistic,
     setSelectedXAxisMetric,
     setSelectedXAxisMode: handleSetXAxisMode,
diff --git a/packages/app/src/components/inference/types.ts b/packages/app/src/components/inference/types.ts
index 904d1d9d5..33a491b16 100644
--- a/packages/app/src/components/inference/types.ts
+++ b/packages/app/src/components/inference/types.ts
@@ -767,7 +767,6 @@ export interface InferenceActionsContextType {
   setSelectedPrecisions: (precisions: string[]) => void;
   setSelectedYAxisMetric: (metric: string) => void;
   setTokenRevenuePriceSource: (source: TokenRevenuePriceSource) => void;
-  setSelectedPercentile: (percentile: string) => void;
   setFixedSequenceStatistic: (statistic: FixedSequenceStatistic) => void;
   setSelectedXAxisMetric: (metric: string | null) => void;
   setSelectedXAxisMode: (mode: XAxisMode) => void;
diff --git a/packages/app/src/components/inference/ui/ChartControls.tsx b/packages/app/src/components/inference/ui/ChartControls.tsx
index 16e03f4c7..38ff3d99f 100644
--- a/packages/app/src/components/inference/ui/ChartControls.tsx
+++ b/packages/app/src/components/inference/ui/ChartControls.tsx
@@ -20,7 +20,6 @@ import {
 import {
   ModelSelector,
   ScenarioSelector,
-  PercentileSelector,
   PrecisionSelector,
 } from '@/components/ui/chart-selectors';
 import { DateRangePicker } from '@/components/ui/date-range-picker';
@@ -66,7 +65,7 @@ import {
   type MeasuredMetricFamily,
 } from '../measured-metric-config';
 import { XAxisModeSelector } from './XAxisModeSelector';
-import { showsTcoBasisSelector, Sequence, type Model, type Percentile } from '@/lib/data-mappings';
+import { showsTcoBasisSelector, Sequence, type Model } from '@/lib/data-mappings';
 import { useLocale } from '@/lib/use-locale';
 import { DEFAULT_Y_AXIS_METRIC } from '@/lib/url-state';
 
@@ -226,7 +225,6 @@ export default function ChartControls({
     openRouterModelId,
     openRouterPricingLoading,
     openRouterPricingError,
-    selectedPercentile,
     selectedXAxisMetric,
     selectedXAxisMode,
     scaleType,
@@ -238,7 +236,6 @@ export default function ChartControls({
     setSelectedPrecisions,
     setSelectedYAxisMetric,
     setTokenRevenuePriceSource,
-    setSelectedPercentile,
     setSelectedGPUs,
     setSelectedDateRange,
     setSelectedXAxisMetric,
@@ -463,8 +460,6 @@ export default function ChartControls({
     showTcoBasis &&
     isCostMetric(selectedYAxisMetric) &&
     showsTcoBasisSelector(selectedModel, selectedSequence);
-  const showPercentile =
-    mounted && selectedSequence === Sequence.AgenticTraces && featureGateUnlocked;
 
   return (
     <TooltipProvider delayDuration={0}>
@@ -473,9 +468,7 @@ export default function ChartControls({
           legend={t.benchmarkControls}
           className={hideGpuComparison ? 'lg:col-span-2' : 'lg:col-span-3'}
         >
-          <div
-            className={`grid min-w-0 grid-cols-2 items-start gap-3 ${showPercentile ? 'md:grid-cols-5' : 'md:grid-cols-4'}`}
-          >
+          <div className="grid min-w-0 grid-cols-2 items-start gap-3 md:grid-cols-4">
             <div className="min-w-0 col-span-2">
               <ModelSelector
                 value={selectedModel}
@@ -505,16 +498,6 @@ export default function ChartControls({
               availablePrecisions={availablePrecisions}
               data-testid="precision-multiselect"
             />
-            {/* AgentX publishes on P90, so the percentile control is an insider
-              affordance rather than a normal chart filter: it stays behind the
-              ↑↑↓↓ feature gate and the chart defaults to P90 without it. */}
-            {showPercentile && (
-              <PercentileSelector
-                value={selectedPercentile}
-                onChange={(p: Percentile) => setSelectedPercentile(p)}
-                data-testid="percentile-selector"
-              />
-            )}
           </div>
         </ControlPanel>
 
diff --git a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
index 02cdf64c3..d371c4db2 100644
--- a/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
+++ b/packages/app/src/components/inference/ui/MeasuredMetricControls.tsx
@@ -34,7 +34,7 @@ const STRINGS = {
     all: 'All GPUs',
     prefill: 'Prefill GPUs',
     decode: 'Decode GPUs',
-    statistic: 'Statistic',
+    statistic: 'Power statistic',
     statisticHelp:
       'P75 and P90 are time-weighted percentiles of synchronized fleet power, divided by chip count. They are available for all GPUs only.',
     average: 'Average',
@@ -68,7 +68,7 @@ const STRINGS = {
     all: '全部 GPU',
     prefill: '预填充 GPU',
     decode: '解码 GPU',
-    statistic: '统计量',
+    statistic: '功耗统计量',
     statisticHelp:
       'P75 和 P90 是同步采样的集群总功率按时间加权得到的分位数，再除以芯片数。仅支持全部 GPU。',
     average: '平均值',

From 2f9b62029ca80591479a102a67ca51e03f964837 Mon Sep 17 00:00:00 2001
From: Wenyao Gao <wenyao.gao28@gmail.com>
Date: Wed, 30 Sep 2026 16:25:07 -0700
Subject: [PATCH 103/103] fix: synchronize PowerX API skill integrity
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

中文：更新简化后的仪表板 API 文档校验值，确保安装包完整性校验与最终格式化后的文件一致。
---
 packages/skills/skills/inferencex-api/integrity.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/skills/skills/inferencex-api/integrity.json b/packages/skills/skills/inferencex-api/integrity.json
index 57f2d58d8..be58a7ebc 100644
--- a/packages/skills/skills/inferencex-api/integrity.json
+++ b/packages/skills/skills/inferencex-api/integrity.json
@@ -8,7 +8,7 @@
     "references/cli-contract.md": "fa44faa38d889b4fbdee5ba42752b47758ee3706fab150513bd4e6db87a86cb0",
     "references/cli.md": "96b228f34cb3600f4548f4dc84df8506531747286763c56ca834c77bee05e1eb",
     "references/collectivex.md": "eb794f9c28d4a27bec4db80c42c4685ff3b1d204fd9b12a6788511fb258a789f",
-    "references/dashboard-views.md": "aecc8dab0ee0ae8e1d0aaaafa5e5a5911a7c04526ab35af5bdbad61e387bc9f2",
+    "references/dashboard-views.md": "42906d29813e31fe863dc46ba3fdb0ab1d647f98249d82858d231c8d094c16e6",
     "references/offline-exports.md": "95aa565dcd4c9e592159baa560a9a58217bc61e395de1c6daf0576795c7f4ec9",
     "references/pareto.md": "1b4d2d163f982e3f2d97addce310789eae9c1e5badd82dd7501708c9e0385027",
     "references/powerx.md": "cf8adcc5dfe395c5fb659908819980a872475f862f22b723815af43d363cedad",