diff --git a/packages/ui/API.md b/packages/ui/API.md
index 5ecb190..2ab40cd 100644
--- a/packages/ui/API.md
+++ b/packages/ui/API.md
@@ -158,11 +158,15 @@ All return `ComparisonResponse`: `columns` (each with the runs it covers), `rows
 | `GET /api/matrix?workspace=&project=&experiment=` | `MatrixResponse` | Every run in scope (filters as in `/api/runs`; none = all runs; an unknown value is an empty matrix). |
 
 A cell is one eval entry × run-matrix row × eval-matrix row (from the task id). Every run of a cell has a `coverage`:
-`full` (every expected case settled and at least one has a result; errored cases count as settled), `partial` (some
-expected cases never ran or never settled), or `none` (no case has a result). `latest` is the task of the newest run
-(by start time) that covered the cell fully or is still running it, else of the newest run: run, experiment, attempt,
-task state, coverage, expected case total (`caseTotal`), case counts, exact and judge score. A partial re-run of a few
-cases therefore never replaces a full run as the cell's score. `history` lists every run with that cell, oldest first
+`full` (every expected case settled and at least one has a result; errored cases count as settled, over the same cases
+as the headline run), `other` (every expected case settled, but over other cases than the headline run, told apart by
+`identity`: a smoke or limited run, or another case set under the same entry), `partial` (some expected cases never ran or never settled), or `none` (no case has a result). `latest` is the task
+of the newest run (by start time) that covered the cell fully or is still running it, else of the newest run: run,
+experiment, attempt, task state, coverage, expected case total (`caseTotal`), case counts, the exact score of every case
+(`caseScores`), exact and judge score. The headline run is the newest one that settled every case it planned over cases no other run covers a strict
+superset of; `caseCount` is its number of cases. A partial re-run or a run over other cases therefore never replaces a full run as the
+cell's score. `superseded` is `true` when a newer run ran the same entry and run row with other eval values (the eval
+axes changed since). `history` lists every run with that cell, oldest first
 (one point per run: attempt, coverage, case counts, exact, state, start time). Two tasks of one
 run in the same cell (several inference executors) keep the last one in queue order. `axes` lists the run-matrix axes,
 then the eval-matrix axes, each with its values in natural order. Cells are ordered by entry, then run row and eval
diff --git a/packages/ui/client/src/caseMetrics.test.ts b/packages/ui/client/src/caseMetrics.test.ts
index cacb462..f5e99e8 100644
--- a/packages/ui/client/src/caseMetrics.test.ts
+++ b/packages/ui/client/src/caseMetrics.test.ts
@@ -12,6 +12,7 @@ function caseNode(index: number, name: string, state: CaseNode['state']): CaseNo
     // Durations that do not follow the metrics below, so they stay their own signal.
     durationMs: [5, 1, 4, 2][index]! * 1000,
     evidenceLinkCount: 0,
+    identity: caseId,
     index,
     key: `task\u0000${caseId}`,
     logLineCount: 0,
diff --git a/packages/ui/client/src/components/ErrorGroupsPanel.test.ts b/packages/ui/client/src/components/ErrorGroupsPanel.test.ts
index ab639e6..12dbc46 100644
--- a/packages/ui/client/src/components/ErrorGroupsPanel.test.ts
+++ b/packages/ui/client/src/components/ErrorGroupsPanel.test.ts
@@ -6,7 +6,7 @@ import { render } from 'vitest-browser-vue'
 import ErrorGroupsPanel from './ErrorGroupsPanel.vue'
 
 function caseOf(caseId: string, state: CaseNode['state'], errorMessage?: string): CaseNode {
-  return { artifactCount: 0, caseId, errorMessage, errorName: errorMessage == null ? undefined : 'APICallError', evidenceLinkCount: 0, index: 0, key: `task\u0000${caseId}`, logLineCount: 0, metricCount: 0, name: caseId, rounds: [], scores: {}, startedAt: '2026-10-19T06:36:26.000Z', state, taskId: 'task' }
+  return { artifactCount: 0, caseId, errorMessage, errorName: errorMessage == null ? undefined : 'APICallError', evidenceLinkCount: 0, identity: caseId, index: 0, key: `task\u0000${caseId}`, logLineCount: 0, metricCount: 0, name: caseId, rounds: [], scores: {}, startedAt: '2026-10-19T06:36:26.000Z', state, taskId: 'task' }
 }
 
 describe('errorGroupsPanel', () => {
diff --git a/packages/ui/client/src/components/MatrixView.vue b/packages/ui/client/src/components/MatrixView.vue
index f26f2e6..0c46400 100644
--- a/packages/ui/client/src/components/MatrixView.vue
+++ b/packages/ui/client/src/components/MatrixView.vue
@@ -2,8 +2,9 @@
 import type { MatrixCell, MatrixResponse } from '../../../src/shared/contract'
 
 import { useQuery } from '@pinia/colada'
-import { computed, watch } from 'vue'
+import { computed, shallowRef, watch } from 'vue'
 
+import ScoreBar from './ScoreBar.vue'
 import ScoreCard from './ScoreCard.vue'
 import Sparkline from './Sparkline.vue'
 import StateView from './StateView.vue'
@@ -18,6 +19,9 @@ import { href } from '../router'
  * Matrix of a project or experiment (`GET /api/matrix`): one grid per eval entry, rows along the run axis with the
  * most values (for example `model`), columns for the combinations of the other axes (for example `repeat`). A cell
  * is the newest run that covered that combination fully (see `MatrixCell.latest`), with the trend of every run.
+ *
+ * Columns of a configuration the project moved away from (every cell `superseded`, for example an eval axis dropped
+ * since) are folded until asked for, so the table opens on what the newest runs measure.
  */
 const props = defineProps<{ experiment?: string, project: string, workspace: string }>()
 
@@ -45,12 +49,14 @@ function runOf(cell: MatrixCell) {
 const axisName = (key: string) => key.replace(/^(?:run|eval)\./, '')
 
 interface Grid {
-  columns: { key: string, label: string }[]
+  columns: { key: string, label: string, superseded: boolean }[]
   entryId: string
   name: string
   rowAxis: string | undefined
   /** One row per value of `rowAxis`; `cells` line up with `columns` (`undefined`: combination never ran). */
   rows: { cells: (MatrixCell | undefined)[], key: string, label: string }[]
+  /** Axis values every column has (for example `listener gpt-6-luna`), said once above the table instead of per column. */
+  shared: string
 }
 
 function buildGrid(entryId: string, cells: MatrixCell[], response: MatrixResponse): Grid {
@@ -68,8 +74,23 @@ function buildGrid(entryId: string, cells: MatrixCell[], response: MatrixRespons
   }
   const columnKey = (cell: MatrixCell) => columnAxes.map(key => `${axisName(key)} ${coordinates(cell)[key] ?? '—'}`).join(' · ')
   const rowKey = (cell: MatrixCell) => (rowAxis == null ? '' : coordinates(cell)[rowAxis] ?? '—')
+  // With several columns, an axis with one value in every cell says nothing about a column; it moves above the table.
+  // The other axes name a column by the values it has; an axis a column lacks (it ran before the axis was added, or
+  // after it was dropped) is left out instead of shown as `asr —`.
+  const multiColumn = new Set(cells.map(columnKey)).size > 1
+  const sharedAxes = multiColumn ? columnAxes.filter(key => cells.every(cell => coordinates(cell)[key] != null && coordinates(cell)[key] === coordinates(cells[0]!)[key])) : []
+  const varyingAxes = columnAxes.filter(key => !sharedAxes.includes(key))
+  const columnLabel = (cell: MatrixCell) => {
+    const present = varyingAxes.filter(key => coordinates(cell)[key] != null)
+    if (present.length > 0)
+      return present.map(key => `${axisName(key)} ${coordinates(cell)[key]}`).join(' · ')
+    return varyingAxes.length > 0 ? `without ${varyingAxes.map(axisName).join(', ')}` : 'all'
+  }
 
-  const columns = [...new Set(cells.map(columnKey))].map(key => ({ key, label: key === '' ? 'all' : key }))
+  const columns = [...new Set(cells.map(columnKey))].map((key) => {
+    const columnCells = cells.filter(cell => columnKey(cell) === key)
+    return { key, label: columnLabel(columnCells[0]!), superseded: columnCells.every(cell => cell.superseded) }
+  })
   // Column order follows the axis order of the API (numeric for `repeat`), not the order cells arrived in.
   columns.sort((a, b) => {
     const cellA = cells.find(cell => columnKey(cell) === a.key)!
@@ -88,7 +109,14 @@ function buildGrid(entryId: string, cells: MatrixCell[], response: MatrixRespons
     key: value,
     label: rowAxis == null ? 'all' : value,
   }))
-  return { columns, entryId, name: shortTaskId(entryId).split('/').at(-1) ?? entryId, rowAxis: rowAxis == null ? undefined : axisName(rowAxis), rows }
+  return {
+    columns,
+    entryId,
+    name: shortTaskId(entryId).split('/').at(-1) ?? entryId,
+    rowAxis: rowAxis == null ? undefined : axisName(rowAxis),
+    rows,
+    shared: sharedAxes.map(key => `${axisName(key)} ${coordinates(cells[0]!)[key]}`).join(' · '),
+  }
 }
 
 const grids = computed<Grid[]>(() => {
@@ -105,6 +133,25 @@ const grids = computed<Grid[]>(() => {
   }
   return [...byEntry.entries()].map(([entryId, cells]) => buildGrid(entryId, cells, response))
 })
+
+const showSuperseded = shallowRef(false)
+/** Labels of the folded columns across the grids (one label per configuration, however many entries ran it). */
+const supersededLabels = computed(() => new Set(grids.value.flatMap(grid => grid.columns.filter(column => column.superseded).map(column => column.label))))
+const visibleGrids = computed(() => grids.value.map((grid) => {
+  if (showSuperseded.value)
+    return grid
+  const kept = grid.columns.flatMap((column, index) => (column.superseded ? [] : [index]))
+  return { ...grid, columns: kept.map(index => grid.columns[index]!), rows: grid.rows.map(row => ({ ...row, cells: kept.map(index => row.cells[index]) })) }
+}))
+
+/**
+ * Whether a cell is read by its score: every case of its run got a result and none failed an assertion, so the case
+ * counts are all green and say nothing; how the scores spread does.
+ */
+function isScored(cell: MatrixCell): boolean {
+  const { counts, exact, state } = cell.latest
+  return exact != null && counts.failed === 0 && state !== 'running' && state !== 'queued'
+}
 /** When a point of a cell's history started: its run's start time, else the attempt label. */
 function pointTime(point: MatrixCell['history'][number]): string {
   return point.startedAt == null ? attemptLabel(point.attemptId) : formatShortDateTime(new Date(point.startedAt))
@@ -122,25 +169,30 @@ function scoreDelta(cell: MatrixCell): number | undefined {
   return previous == null ? undefined : (cell.latest.exact - previous.exact!) * 100
 }
 
-const COVERAGE_TEXT = { full: 'every case', none: 'no result', partial: 'some cases' } as const
+const COVERAGE_TEXT = { full: 'every case', none: 'no result', other: 'other cases', partial: 'some cases' } as const
 /** Tooltip of one history point: when, how much it measured, and its score. */
-function pointTitle(point: MatrixCell['history'][number]): string {
+function pointTitle(cell: MatrixCell, point: MatrixCell['history'][number]): string {
   const measured = point.counts.passed + point.counts.failed
-  return `${pointTime(point)} · ${COVERAGE_TEXT[point.coverage]} (${measured} with a result) · exact ${formatScore(point.exact)}`
+  return `${pointTime(point)} · ${COVERAGE_TEXT[point.coverage]} (${measured} of ${cell.caseCount} cases with a result) · exact ${formatScore(point.exact)}`
 }
 </script>
 
 <template>
   <StateView :error="matrix.error.value" :loading="matrix.isPending.value" :empty="grids.length === 0" empty-text="No matrix rows" empty-hint="Runs without tasks have nothing to show here." skeleton="matrix" @retry="matrix.refetch()">
     <p :class="['flex flex-wrap items-center gap-x-3 gap-y-1 text-xs muted mb-3']">
-      <span>Newest full run of every combination across {{ matrix.data.value?.runCount }} run(s); a partial re-run never replaces it.</span>
+      <span>Newest full run of every combination across {{ matrix.data.value?.runCount }} run(s); a partial run or one over other cases never replaces it.</span>
       <span :class="['inline-flex items-center gap-1']"><svg width="8" height="8" viewBox="0 0 8 8" aria-hidden="true"><circle cx="4" cy="4" r="2.5" fill="var(--series-1)" /></svg>full run</span>
-      <span :class="['inline-flex items-center gap-1']"><svg width="8" height="8" viewBox="0 0 8 8" aria-hidden="true"><circle cx="4" cy="4" r="2.5" fill="none" stroke="var(--series-1)" stroke-width="1.25" stroke-dasharray="1.5 1.2" /></svg>partial run</span>
+      <span :class="['inline-flex items-center gap-1']"><svg width="8" height="8" viewBox="0 0 8 8" aria-hidden="true"><circle cx="4" cy="4" r="2.5" fill="none" stroke="var(--series-1)" stroke-width="1.25" stroke-dasharray="1.5 1.2" /></svg>partial run or other cases</span>
       <span :class="['inline-flex items-center gap-1']"><svg width="8" height="8" viewBox="0 0 8 8" aria-hidden="true"><circle cx="4" cy="4" r="2.5" fill="none" stroke="var(--mark-errored)" stroke-width="1.25" /></svg>no result</span>
+      <button v-if="supersededLabels.size > 0" type="button" :class="['btn text-xs px-1.5! py-0.5! ml-auto']" :title="[...supersededLabels].join('\n')" data-testid="matrix-toggle-superseded" @click="showSuperseded = !showSuperseded">
+        <span :class="[showSuperseded ? 'i-mingcute-eye-close-line' : 'i-mingcute-history-line']" aria-hidden="true" />
+        {{ showSuperseded ? 'Hide' : 'Show' }} {{ countOf(supersededLabels.size, 'older configuration') }}
+      </button>
     </p>
-    <section v-for="grid in grids" :key="grid.entryId" :class="['card mb-4 overflow-x-auto']" :data-testid="`matrix-${grid.entryId}`">
+    <section v-for="grid in visibleGrids" :key="grid.entryId" :class="['card mb-4 overflow-x-auto']" :data-testid="`matrix-${grid.entryId}`">
       <h2 :class="['card-title']" :title="shortTaskId(grid.entryId)">
         <span class="i-mingcute-layout-grid-line" aria-hidden="true" />{{ grid.name }}
+        <span v-if="grid.shared" :class="['text-xs font-normal muted']">{{ grid.shared }}</span>
       </h2>
       <table :class="['border-separate border-spacing-2']">
         <thead>
@@ -148,7 +200,7 @@ function pointTitle(point: MatrixCell['history'][number]): string {
             <th :class="['th']">
               {{ grid.rowAxis ?? '' }}
             </th>
-            <th v-for="column in grid.columns" :key="column.key" :class="['th text-center']">
+            <th v-for="column in grid.columns" :key="column.key" :class="['th text-center', column.superseded && 'opacity-60']" :title="column.superseded ? 'An older configuration: newer runs measured this entry with other eval values' : undefined">
               {{ column.label }}
             </th>
           </tr>
@@ -161,11 +213,12 @@ function pointTitle(point: MatrixCell['history'][number]): string {
             <td v-for="(cell, index) in row.cells" :key="grid.columns[index]!.key" :class="['align-top']">
               <ScoreCard
                 v-if="cell"
-                :class="['w-44 md:w-56 p-3! md:p-3.5!']"
+                :class="['w-44 md:w-56', cell.superseded && 'opacity-60']"
+                compact
                 :href="href({ name: 'task', runKey: cell.latest.runKey, taskId: cell.latest.taskId })"
                 :score="cell.latest.exact"
-                :state="cell.latest.state"
-                :counts="{ ...cell.latest.counts, total: Math.max(cell.latest.counts.total, cell.latest.caseTotal ?? 0) }"
+                :state="isScored(cell) && cell.latest.state === 'passed' ? undefined : cell.latest.state"
+                :counts="isScored(cell) ? undefined : { ...cell.latest.counts, total: Math.max(cell.latest.counts.total, cell.latest.caseTotal ?? 0) }"
                 :run="runOf(cell)"
                 data-testid="matrix-cell"
               >
@@ -179,15 +232,18 @@ function pointTitle(point: MatrixCell['history'][number]): string {
                     <span :class="[scoreDelta(cell)! > 0 ? 'i-mingcute-arrow-up-line' : 'i-mingcute-arrow-down-line']" aria-hidden="true" />{{ Math.abs(scoreDelta(cell)!).toFixed(1) }}
                   </span>
                 </template>
+                <template v-if="isScored(cell)" #bar>
+                  <ScoreBar :class="['w-full']" :scores="cell.latest.caseScores" />
+                </template>
                 <span :class="['flex items-center gap-1.5 min-w-0']" :title="`${attemptLabel(cell.latest.attemptId)} · ${cell.latest.runKey}`">
-                  <span :class="['truncate']">{{ cell.latest.startedAt ? formatShortDateTime(new Date(cell.latest.startedAt)) : attemptLabel(cell.latest.attemptId) }} · {{ countOf(cell.history.length, 'run') }}</span>
+                  <span :class="['truncate']">{{ cell.latest.startedAt ? formatShortDateTime(new Date(cell.latest.startedAt)) : attemptLabel(cell.latest.attemptId) }} · {{ countOf(cell.latest.counts.total, 'case') }} · {{ countOf(cell.history.length, 'run') }}</span>
                   <Sparkline
-                    :class="['ml-auto']" :values="cell.history.map(point => point.exact)" :coverage="cell.history.map(point => point.coverage)" :titles="cell.history.map(pointTitle)"
+                    :class="['ml-auto']" :values="cell.history.map(point => point.exact)" :coverage="cell.history.map(point => point.coverage)" :titles="cell.history.map(point => pointTitle(cell, point))"
                     :label="`exact score of ${cell.history.length} runs`" :width="48" :height="16"
                   />
                 </span>
                 <span v-if="cell.latest.coverage !== 'full' && cell.latest.state !== 'running' && cell.latest.state !== 'queued'" :class="['flex items-center gap-1.5 [color:var(--ink-errored)]']" data-testid="matrix-cell-partial">
-                  <span class="i-mingcute-alert-octagon-line" aria-hidden="true" />{{ cell.latest.counts.passed + cell.latest.counts.failed }} of {{ Math.max(cell.latest.counts.total, cell.latest.caseTotal ?? 0) }} cases with a result · no full run yet
+                  <span class="i-mingcute-alert-octagon-line" aria-hidden="true" />{{ cell.latest.counts.passed + cell.latest.counts.failed }} of {{ cell.caseCount }} cases with a result · no full run yet
                 </span>
               </ScoreCard>
               <span v-else :class="['flex items-center justify-center w-44 md:w-56 h-24 rounded-xl text-xs muted border border-dashed border-neutral-300/60 dark:border-neutral-700/40']">not run</span>
diff --git a/packages/ui/client/src/components/ScoreCard.vue b/packages/ui/client/src/components/ScoreCard.vue
index 5269988..0df895d 100644
--- a/packages/ui/client/src/components/ScoreCard.vue
+++ b/packages/ui/client/src/components/ScoreCard.vue
@@ -16,16 +16,18 @@ import { formatScore } from '../format'
  * meta (run counts, times)
  * Ends at 06:04      started 1h 12m ago   ← only while the run is running
  * ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬ progress
- * ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬ cases (counts on hover)
- * ╭──────────────────╮
- * │ tags (matrix)    │                       ← `footer` slot, an inset with the card's inner radius
+ * ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬ cases (counts on hover), or the `bar` slot
  * ╰──────────────────╯
+ *  tags (matrix)                             ← `footer` slot, on the tray below the panel
  * ```
  *
- * The surface is a faint fill with a hairline edge (the look of the matrix cells), not a bordered panel, so the
- * numbers stay the strongest thing on it. With `href` the whole card is the link; put no other links inside it.
+ * A white panel raised on a gray tray (the anatomy of airi's `IconStatusItem`: a 2 px tray edge, the panel's corners
+ * one step inside the tray's), so the numbers sit on the brightest surface and what describes the item (its matrix
+ * values) sits on the tray below. With `href` the whole card is the link; put no other links inside it.
  */
 const props = defineProps<{
+  /** Tighter panel padding, for cards in a grid of many (matrix cells). */
+  compact?: boolean
   counts?: CaseCounts
   href?: string
   /** Run whose progress shows while `state` is `running`. */
@@ -49,34 +51,38 @@ const props = defineProps<{
     :is="props.href ? 'a' : 'div'"
     :href="props.href"
     :class="[
-      'relative flex flex-col gap-2 p-4 min-w-0 rounded-xl transition-colors',
-      'bg-neutral-500/5 border border-neutral-500/8',
-      props.href && 'hover:(bg-primary-500/6 border-primary-500/15)',
+      'flex flex-col min-w-0 rounded-xl overflow-hidden transition-colors',
+      'bg-neutral-100/70 dark:bg-neutral-800/60 border-2 border-neutral-200/50 dark:border-neutral-800/40',
+      props.href && 'hover:border-primary-500/30 dark:hover:border-primary-400/30',
     ]"
     data-testid="score-card"
   >
-    <span :class="['flex items-start gap-2']">
-      <span :class="['flex items-baseline flex-wrap gap-x-1.5 min-w-0']">
-        <span :class="['text-2xl font-semibold tabular-nums leading-none']" :title="props.scoreLabel ?? 'exact score'" data-testid="score-card-score">
-          {{ formatScore(props.score) }}<span :class="['sr-only']"> {{ props.scoreLabel ?? 'exact score' }}</span>
+    <span :class="['relative flex flex-col gap-2 flex-1 min-w-0 rounded-lg bg-white dark:bg-neutral-900', props.compact ? 'p-3 md:p-3.5' : 'p-4']">
+      <span :class="['flex items-start gap-2']">
+        <span :class="['flex items-baseline flex-wrap gap-x-1.5 min-w-0']">
+          <span :class="['text-2xl font-semibold tabular-nums leading-none']" :title="props.scoreLabel ?? 'exact score'" data-testid="score-card-score">
+            {{ formatScore(props.score) }}<span :class="['sr-only']"> {{ props.scoreLabel ?? 'exact score' }}</span>
+          </span>
+          <!-- Change from the previous run, a trend line, …: facts about the score itself. -->
+          <slot name="score" />
         </span>
-        <!-- Change from the previous run, a trend line, …: facts about the score itself. -->
-        <slot name="score" />
+        <StateBadge v-if="props.state" :class="['ml-auto shrink-0']" :state="props.state" />
+      </span>
+      <span v-if="props.title || $slots.title" :class="['font-semibold min-w-0 truncate']">
+        <slot name="title">{{ props.title }}</slot>
+      </span>
+      <span v-if="$slots.default" :class="['flex flex-col gap-1 text-xs muted min-w-0']">
+        <slot />
+      </span>
+      <span v-if="(props.run && props.state === 'running') || props.counts || $slots.bar" :class="['flex flex-col gap-2.5 mt-auto pt-1']">
+        <RunEta v-if="props.run && props.state === 'running'" :run-key="props.run.runKey" :seq="props.run.lastSeq" :started-at="props.run.startedAt" />
+        <!-- Another bar in place of the case counts, for example how the scores spread in a scored eval. -->
+        <slot name="bar">
+          <CountsBar v-if="props.counts" :counts="props.counts" labels="hover" />
+        </slot>
       </span>
-      <StateBadge v-if="props.state" :class="['ml-auto shrink-0']" :state="props.state" />
-    </span>
-    <span v-if="props.title || $slots.title" :class="['font-semibold min-w-0 truncate']">
-      <slot name="title">{{ props.title }}</slot>
-    </span>
-    <span v-if="$slots.default" :class="['flex flex-col gap-1 text-xs muted min-w-0']">
-      <slot />
-    </span>
-    <span v-if="(props.run && props.state === 'running') || props.counts" :class="['flex flex-col gap-2.5 mt-auto pt-1']">
-      <RunEta v-if="props.run && props.state === 'running'" :run-key="props.run.runKey" :seq="props.run.lastSeq" :started-at="props.run.startedAt" />
-      <CountsBar v-if="props.counts" :counts="props.counts" labels="hover" />
     </span>
-    <!-- Concentric corners: the inset sits 8 px inside the card's 12 px corners (`rounded-xl`), so its radius is 4 px. -->
-    <span v-if="$slots.footer" :class="['flex flex-wrap gap-1 -mx-2 -mb-2 mt-1 p-2 rounded bg-neutral-500/6']">
+    <span v-if="$slots.footer" :class="['flex flex-wrap gap-1 px-2 py-1.5']">
       <slot name="footer" />
     </span>
   </component>
diff --git a/packages/ui/client/src/components/Sparkline.vue b/packages/ui/client/src/components/Sparkline.vue
index 9e2fdfd..8e7ea68 100644
--- a/packages/ui/client/src/components/Sparkline.vue
+++ b/packages/ui/client/src/components/Sparkline.vue
@@ -2,16 +2,17 @@
 import { computed } from 'vue'
 
 /**
- * Coverage of one point of the line (see `cellCoverageSchema`): `full` points are joined by the line; a `partial` point
- * is a dashed ring off the line, and a point `none` (no result) is an amber ring on the floor.
+ * Coverage of one point of the line (see `cellCoverageSchema`): `full` points are joined by the line; a `partial` or
+ * `other` point (a score over other cases) is a dashed ring off the line, and a point `none` (no result) is an amber
+ * ring on the floor.
  */
-export type SparklineCoverage = 'full' | 'none' | 'partial'
+export type SparklineCoverage = 'full' | 'none' | 'other' | 'partial'
 
 /**
  * Tiny line of scores (0–1) in run order, for cards and matrix cells: the trend, not the exact values.
  *
  * Missing scores (`null`) break the line. Fewer than two scores draw nothing. With `coverage`, only fully covered
- * points are joined, so a partial re-run or a run without a result never bends the trend; they are drawn as rings.
+ * points are joined, so a partial re-run, a run over other cases, or a run without a result never bends the trend; they are drawn as rings.
  */
 const props = withDefaults(defineProps<{
   /** Coverage of each value, in the same order; every value counts as `full` without it. */
@@ -68,7 +69,7 @@ const marks = computed<Mark[]>(() => {
       return [{ kind: 'none', title, x, y: props.height - 1 }]
     if (value == null || !Number.isFinite(value))
       return []
-    if (coverage === 'partial')
+    if (coverage === 'partial' || coverage === 'other')
       return [{ kind: 'partial', title, x, y: yOf(value) }]
     return index === lastFull || title != null ? [{ kind: index === lastFull ? 'last' : 'full', title, x, y: yOf(value) }] : []
   })
diff --git a/packages/ui/client/src/errorGroups.test.ts b/packages/ui/client/src/errorGroups.test.ts
index e14e32b..0c5163e 100644
--- a/packages/ui/client/src/errorGroups.test.ts
+++ b/packages/ui/client/src/errorGroups.test.ts
@@ -8,6 +8,7 @@ function caseOf(fields: Partial<CaseNode> & Pick<CaseNode, 'caseId' | 'state'>):
   return {
     artifactCount: 0,
     evidenceLinkCount: 0,
+    identity: fields.caseId,
     index: 0,
     key: `task\u0000${fields.caseId}`,
     logLineCount: 0,
diff --git a/packages/ui/client/src/pages/HomePage.vue b/packages/ui/client/src/pages/HomePage.vue
index b823021..61c40c4 100644
--- a/packages/ui/client/src/pages/HomePage.vue
+++ b/packages/ui/client/src/pages/HomePage.vue
@@ -27,11 +27,16 @@ const workspaces = computed(() => catalog.workspaces.value.filter(workspace => p
 const projectCount = computed(() => workspaces.value.reduce((sum, workspace) => sum + workspace.projects.length, 0))
 const runCount = computed(() => workspaces.value.reduce((sum, workspace) => sum + workspace.projects.reduce((count, project) => count + project.runs.length, 0), 0))
 
-/** Card data of a project: the best exact score of any of its runs and its matrix axes. */
+/**
+ * Card data of a project: its matrix axes, with the score of its newest run.
+ *
+ * The score is the newest run's own, like the state and the case bar beside it, and empty when that run scored no case.
+ * It previously was the best exact score of any run, so a 3-case smoke run that got everything right showed 100% above
+ * a newer full run's 94%.
+ */
 function toCard(project: ProjectEntry) {
-  const best = project.runs.reduce<null | number>((max, run) => (run.exactAverage == null ? max : Math.max(max ?? 0, run.exactAverage)), null)
   const matrix = mergeMatrices(project.runs.map(run => run.matrix))
-  return { ...project, axes: Object.entries(matrix).map(([axis, values]) => ({ axis, values: formatAxisValues(values) })), best }
+  return { ...project, axes: Object.entries(matrix).map(([axis, values]) => ({ axis, values: formatAxisValues(values) })) }
 }
 const sections = computed(() => workspaces.value.map(workspace => ({ id: workspace.id, projects: workspace.projects.map(toCard) })))
 </script>
@@ -56,8 +61,8 @@ const sections = computed(() => workspaces.value.map(workspace => ({ id: workspa
           v-for="project in section.projects"
           :key="project.id"
           :href="href({ name: 'scope', project: project.id, workspace: section.id })"
-          :score="project.best"
-          :score-label="`best exact score of ${countOf(project.runs.length, 'run')}`"
+          :score="project.latest.exactAverage"
+          score-label="exact score of the newest run"
           :state="project.latest.state"
           :counts="project.latest.counts"
           :run="project.latest"
@@ -76,7 +81,7 @@ const sections = computed(() => workspaces.value.map(workspace => ({ id: workspa
             </template>
           </span>
           <template v-if="project.axes.length > 0" #footer>
-            <span v-for="axis in project.axes" :key="axis.axis" :class="['badge state-neutral font-normal']">
+            <span v-for="axis in project.axes" :key="axis.axis" :class="['inline-flex items-center gap-1 px-1 text-xs text-neutral-700 dark:text-neutral-300 whitespace-nowrap']">
               <span class="muted">{{ axis.axis }}</span>{{ axis.values }}
             </span>
           </template>
diff --git a/packages/ui/client/src/styles.css b/packages/ui/client/src/styles.css
index dbf4766..054f111 100644
--- a/packages/ui/client/src/styles.css
+++ b/packages/ui/client/src/styles.css
@@ -27,12 +27,19 @@
   --ink-running: #174ea6;
   /* Stripes over the `errored` mark (`.vv-hatch`): "no data", and a second cue next to green for red-green CVD. */
   --hatch-stripe: rgb(255 255 255 / 0.5);
-  /* Five-step sequential ramp (dataviz reference blue) for coloring by a metric, low to high. */
-  --seq-1: #b7d3f6;
-  --seq-2: #6da7ec;
-  --seq-3: #2a78d6;
-  --seq-4: #1c5cab;
-  --seq-5: #0d366b;
+  /*
+   * Five-step sequential ramp for coloring by a metric, low to high: the theme hue from light to deep, so scores read
+   * in the page's own color. It was the dataviz reference blue, which on an orange theme turned every score bar and
+   * score-colored chart navy. Lightness steps are even in OKLCH, so the five steps stay apart for any hue; chroma
+   * tapers toward the light end to stay inside sRGB without `--chromatic-sat`. The deep end stops at a mid tone (58%):
+   * a 0 / 1 score bar uses only both ends, and a deeper end turned most of a low-scoring bar dark brown, heavier than
+   * anything else on the card. Checked by eye for the hues 55, 145, 250, and 320 on light and dark pages.
+   */
+  --seq-1: oklch(92% calc(var(--chromatic-chroma-500) * 0.3) var(--chromatic-hue));
+  --seq-2: oklch(84% calc(var(--chromatic-chroma-500) * 0.5) var(--chromatic-hue));
+  --seq-3: oklch(76% calc(var(--chromatic-chroma-500) * 0.7) var(--chromatic-hue));
+  --seq-4: oklch(67% calc(var(--chromatic-chroma-500) * 0.85) var(--chromatic-hue));
+  --seq-5: oklch(58% calc(var(--chromatic-chroma-500) * 0.9) var(--chromatic-hue));
   --chart-grid: #e5e5e5;
   --chart-text: #52514e;
   color-scheme: light;
@@ -69,11 +76,11 @@
   --ink-running: #a5d8ff;
   --hatch-stripe: rgb(0 0 0 / 0.4);
   /* Dark pages run the ramp the other way: low values sink toward the ground, high values stand out. */
-  --seq-1: #184f95;
-  --seq-2: #2a78d6;
-  --seq-3: #5598e7;
-  --seq-4: #86b6ef;
-  --seq-5: #cde2fb;
+  --seq-1: oklch(58% calc(var(--chromatic-chroma-500) * 0.9) var(--chromatic-hue));
+  --seq-2: oklch(67% calc(var(--chromatic-chroma-500) * 0.85) var(--chromatic-hue));
+  --seq-3: oklch(76% calc(var(--chromatic-chroma-500) * 0.7) var(--chromatic-hue));
+  --seq-4: oklch(84% calc(var(--chromatic-chroma-500) * 0.5) var(--chromatic-hue));
+  --seq-5: oklch(92% calc(var(--chromatic-chroma-500) * 0.3) var(--chromatic-hue));
   --chart-grid: #333332;
   --chart-text: #c3c2b7;
   color-scheme: dark;
diff --git a/packages/ui/src/server/compare.test.ts b/packages/ui/src/server/compare.test.ts
index 18ae937..5b8b31c 100644
--- a/packages/ui/src/server/compare.test.ts
+++ b/packages/ui/src/server/compare.test.ts
@@ -7,24 +7,26 @@ import { buildTaskNodes, createRunReducer } from '../shared/reduce'
 import { buildMatrix } from './compare'
 
 const TASK = 'evals%2Fdemo::default::run=tts%3Dofficial::eval=asr%3Dwhisper-1'
+const TASK_WITH_JUDGE = 'evals%2Fdemo::default::run=tts%3Dofficial::eval=judge%3Dgpt-5.5'
 
 interface CaseResult {
   exact?: number
   state: 'errored' | 'failed' | 'passed'
 }
 
-/** One ended run of {@link TASK}: the given cases settle, out of `total` expected ones. */
-function runOf(runKey: string, startedAt: string, total: number, results: readonly CaseResult[]): { item: RunListItem, tasks: TaskNode[] } {
+/** One ended run of {@link TASK}: the given cases (named `<prefix>-<index>`) settle, out of `total` expected ones. */
+function runOf(runKey: string, startedAt: string, total: number, results: readonly CaseResult[], options: { prefix?: string, taskId?: string } = {}): { item: RunListItem, tasks: TaskNode[] } {
+  const { prefix = 'case', taskId = TASK } = options
   const envelope = createEnvelopeFactory(runKey)
   const reducer = createRunReducer()
-  const taskScope = { projectId: 'demo', taskId: TASK }
+  const taskScope = { projectId: 'demo', taskId }
   reducer.apply(envelope('task.started', {}, taskScope))
   results.forEach((result, index) => {
-    const scope = { caseId: `${index}:case-${index}`, projectId: 'demo', taskId: TASK }
-    reducer.apply(envelope('case.started', { index, name: `case-${index}`, total }, scope))
+    const scope = { caseId: `${index}:${prefix}-${index}`, projectId: 'demo', taskId }
+    reducer.apply(envelope('case.started', { index, name: `${prefix}-${index}`, total }, scope))
     if (result.exact != null)
       reducer.apply(envelope('score.recorded', { kind: 'exact', score: result.exact }, scope))
-    reducer.apply(envelope('case.ended', { index, name: `case-${index}`, state: result.state, total }, scope))
+    reducer.apply(envelope('case.ended', { index, name: `${prefix}-${index}`, state: result.state, total }, scope))
   })
   reducer.apply(envelope('task.ended', { state: 'passed' }, taskScope))
   const item: RunListItem = {
@@ -120,4 +122,61 @@ describe('buildMatrix', () => {
     expect(cell.latest.runKey).toBe('run-new')
     expect(cell.history.map(point => point.runKey)).toEqual(['run-old', 'run-partial', 'run-new'])
   })
+
+  // ROOT CAUSE:
+  //
+  // A run that settled every case it planned counted as full, whatever it planned. A 5-case smoke run after a 67-case
+  // run became the headline, and the change from the previous run compared scores over different cases (0% "↓65.7"
+  // from a 5-case run, "↑12.5" against a run of another 120-case set under the same entry):
+  //
+  // passed + failed + errored + skipped + timeout >= expected ? 'full' : 'partial'
+  //
+  // We fixed this by scoring every cell over the cases (`identity`) of its newest run that settled everything and is no
+  // strict subset of another run; a settled run over other cases is `other`, kept in the history like a partial run,
+  // but never the headline or a baseline.
+  /**
+   * @example
+   * expect(cell.history.map(point => point.coverage)).toEqual(['other', 'full', 'other'])
+   */
+  it('marks a settled run over some of the cell\'s cases as other, and keeps the full run as the headline', () => {
+    const smoke = runOf('run-smoke', '2026-10-19T06:00:00.000Z', 3, scored(3, 1))
+    const full = runOf('run-full', '2026-10-19T06:36:00.000Z', 6, scored(6, 0.5))
+    const limited = runOf('run-limited', '2026-10-19T07:00:00.000Z', 2, scored(2, 0))
+
+    const [cell] = buildMatrix([smoke, full, limited]).cells
+
+    expect(cell.caseCount).toBe(6)
+    expect(cell.history.map(point => point.coverage)).toEqual(['other', 'full', 'other'])
+    expect(cell.latest.runKey).toBe('run-full')
+    expect(cell.latest.caseScores).toEqual([0.5, 0.5, 0.5, 0.5, 0.5, 0.5])
+  })
+
+  /**
+   * @example
+   * expect(cells.map(cell => cell.superseded)).toEqual([true, false])
+   */
+  it('marks a cell superseded when a newer run ran the same run row with other eval values', () => {
+    const old = runOf('run-old', '2026-10-19T06:36:00.000Z', 2, scored(2, 0.5))
+    const fresh = runOf('run-new', '2026-10-20T06:36:00.000Z', 2, scored(2, 1), { taskId: TASK_WITH_JUDGE })
+
+    const cells = buildMatrix([old, fresh]).cells
+
+    expect(cells.map(cell => [cell.eval, cell.superseded])).toEqual([[{ asr: 'whisper-1' }, true], [{ judge: 'gpt-5.5' }, false]])
+  })
+
+  /**
+   * @example
+   * expect(cell.latest.runKey).toBe('run-formula-new')
+   */
+  it('scores a cell over the cases of its newest full run when another case set ran under the same entry', () => {
+    const formula = runOf('run-formula', '2026-10-19T06:36:00.000Z', 3, scored(3, 0.5), { prefix: 'formula' })
+    const other = runOf('run-other-set', '2026-10-19T07:00:00.000Z', 5, scored(5, 1), { prefix: 'mb' })
+    const fresh = runOf('run-formula-new', '2026-10-19T08:00:00.000Z', 3, scored(3, 1), { prefix: 'formula' })
+
+    const [cell] = buildMatrix([formula, other, fresh]).cells
+
+    expect(cell.latest.runKey).toBe('run-formula-new')
+    expect(cell.caseCount).toBe(3)
+    expect(cell.history.map(point => point.coverage)).toEqual(['full', 'other', 'full'])
+  })
 })
diff --git a/packages/ui/src/server/compare.ts b/packages/ui/src/server/compare.ts
index 2793cbe..2427730 100644
--- a/packages/ui/src/server/compare.ts
+++ b/packages/ui/src/server/compare.ts
@@ -4,6 +4,12 @@ import type { RunHandle } from './store'
 import { axisValues, buildTaskNodes, compareNatural } from '../shared/reduce'
 import { toRunListItem } from './store'
 
+/** One run of a matrix cell: its result, and the cases it ran (by `CaseNode.identity`). */
+interface CellRun {
+  cases: ReadonlySet<string>
+  result: MatrixCell['latest']
+}
+
 interface Column {
   handles: RunHandle[]
   id: string
@@ -22,14 +28,16 @@ interface Column {
  * Returns:
  * - cells ordered by entry, then run row and eval row in natural order; `history` is every run with a task in the
  *   cell, oldest first, each with its coverage; `latest` is the newest run that covered the cell fully or is still
- *   running it, else the newest run. Tasks without a parsable matrix are skipped. Tasks of one run that share a cell
- *   (several inference executors) keep the last one in queue order.
+ *   running it, else the newest run. A run that settled every case it planned but over other cases than that run (a
+ *   smoke or limited run, another case set) is `other`, not `full`: its score is not comparable. Tasks without a
+ *   parsable matrix are skipped.
+ *   Tasks of one run that share a cell (several inference executors) keep the last one in queue order.
  */
 export function buildMatrix(runs: readonly { item: RunListItem, tasks: readonly TaskNode[] }[]): MatrixResponse {
   const oldestFirst = [...runs].sort((left, right) => (left.item.startedAt ?? '').localeCompare(right.item.startedAt ?? ''))
-  const cells = new Map<string, MatrixCell>()
-  // Whether the cell's `latest` is a headline run (full or running); a partial run only fills an empty headline.
-  const headline = new Map<string, boolean>()
+  // Runs of each cell, oldest first, with the cases each one ran; whether a run is `full` depends on the cases of the
+  // cell's other runs, so it is settled after every run was read.
+  const cells = new Map<string, { entryId: string, eval: Record<string, string>, evalRowId: string, run: Record<string, string>, runRowId: string, runs: CellRun[] }>()
   const runRows: Record<string, string>[] = []
   const evalRows: Record<string, string>[] = []
   for (const { item, tasks } of oldestFirst) {
@@ -39,13 +47,12 @@ export function buildMatrix(runs: readonly { item: RunListItem, tasks: readonly
       }
       runRows.push(task.matrix.run)
       evalRows.push(task.matrix.eval)
-      const coverage = coverageOf(task)
-      const point = { attemptId: item.attemptId, counts: task.caseCounts, coverage, exact: task.scores.exact, runKey: item.runKey, startedAt: item.startedAt, state: task.state }
-      const latest: MatrixCell['latest'] = {
+      const result: MatrixCell['latest'] = {
         attemptId: item.attemptId,
+        caseScores: task.cases.map(node => node.scores.exact ?? null),
         caseTotal: task.caseTotal,
         counts: task.caseCounts,
-        coverage,
+        coverage: coverageOf(task),
         exact: task.scores.exact,
         experimentId: item.experimentId,
         judge: task.scores.judge,
@@ -54,35 +61,61 @@ export function buildMatrix(runs: readonly { item: RunListItem, tasks: readonly
         state: task.state,
         taskId: task.id,
       }
-      const isHeadline = coverage === 'full' || task.state === 'running' || task.state === 'queued'
+      const cellRun = { cases: new Set(task.cases.map(node => node.identity)), result }
       // NUL cannot appear in decoded ids, so the joined key is unambiguous.
       const key = [task.entryId, task.matrix.runRowId, task.matrix.evalRowId].join('\0')
       const cell = cells.get(key)
       if (cell == null) {
-        cells.set(key, { entryId: task.entryId, eval: task.matrix.eval, evalRowId: task.matrix.evalRowId, history: [point], latest, run: task.matrix.run, runRowId: task.matrix.runRowId })
-        headline.set(key, isHeadline)
+        cells.set(key, { entryId: task.entryId, eval: task.matrix.eval, evalRowId: task.matrix.evalRowId, run: task.matrix.run, runRowId: task.matrix.runRowId, runs: [cellRun] })
         continue
       }
-      // Runs are visited oldest first; a second task of the same run replaces its point (and its headline).
-      const sameRun = cell.history.at(-1)?.runKey === item.runKey
-      if (sameRun) {
-        cell.history[cell.history.length - 1] = point
+      // Runs are visited oldest first; a second task of the same run replaces its entry.
+      if (cell.runs.at(-1)?.result.runKey === item.runKey) {
+        cell.runs[cell.runs.length - 1] = cellRun
       }
       else {
-        cell.history.push(point)
-      }
-      if (isHeadline || sameRun || headline.get(key) !== true) {
-        cell.latest = latest
-        headline.set(key, isHeadline)
+        cell.runs.push(cellRun)
       }
     }
   }
+
+  // Newest start of any run of each entry × run row: a cell whose runs all started before it is a configuration the
+  // project moved away from (its eval axes changed since).
+  const rowKey = (cell: { entryId: string, runRowId: string }) => [cell.entryId, cell.runRowId].join('\0')
+  const newestOf = (list: readonly CellRun[]) => list.reduce((max, run) => ((run.result.startedAt ?? '') > max ? run.result.startedAt ?? '' : max), '')
+  const rowNewest = new Map<string, string>()
+  for (const cell of cells.values()) {
+    const newest = newestOf(cell.runs)
+    if (newest > (rowNewest.get(rowKey(cell)) ?? ''))
+      rowNewest.set(rowKey(cell), newest)
+  }
+
+  const output = [...cells.values()].map(({ runs: cellRuns, ...cell }): MatrixCell => {
+    // The cases the cell is scored over: those of the newest run that settled every case it planned, unless another
+    // run covered more of the same cases (then it was a smoke or limited run). Runs over other cases, a subset or
+    // another case set, keep their score in the history but are neither the headline nor a baseline.
+    const reference = cellRuns.findLast(run => run.result.coverage === 'full' && !cellRuns.some(other => isStrictSubset(run.cases, other.cases)))
+    const settled = cellRuns.map(({ cases, result }) => ({
+      ...result,
+      coverage: result.coverage === 'full' && (reference == null || !isSameSet(cases, reference.cases)) ? 'other' as const : result.coverage,
+    }))
+    // The headline is the newest full or running run; a partial run or one over other cases only stands in while
+    // there is none.
+    const latest = settled.findLast(run => run.coverage === 'full' || run.state === 'running' || run.state === 'queued') ?? settled.at(-1)!
+    return {
+      ...cell,
+      caseCount: reference?.cases.size ?? Math.max(latest.counts.total, latest.caseTotal ?? 0),
+      history: settled.map(run => ({ attemptId: run.attemptId, counts: run.counts, coverage: run.coverage, exact: run.exact, runKey: run.runKey, startedAt: run.startedAt, state: run.state })),
+      latest,
+      superseded: newestOf(cellRuns) < (rowNewest.get(rowKey(cell)) ?? ''),
+    }
+  })
   return {
     axes: [
       ...Object.entries(axisValues(runRows)).map(([name, values]) => ({ kind: 'run' as const, name, values })),
       ...Object.entries(axisValues(evalRows)).map(([name, values]) => ({ kind: 'eval' as const, name, values })),
     ],
-    cells: [...cells.values()].sort((left, right) =>
+    cells: output.sort((left, right) =>
       left.entryId.localeCompare(right.entryId)
       || compareNatural(left.runRowId, right.runRowId)
       || compareNatural(left.evalRowId, right.evalRowId)),
@@ -174,7 +207,8 @@ function buildComparison(view: ComparisonResponse['view'], columns: readonly Col
 
 /**
  * How much of its task a run measured (see `cellCoverageSchema`): cases with a result are `passed` and `failed`;
- * every expected case must have settled for `full`.
+ * every expected case must have settled for `full`. Whether a full run ran the cell's cases or `other` ones depends on
+ * the cell's other runs, so {@link buildMatrix} decides that.
  */
 function coverageOf(task: TaskNode): CellCoverage {
   const { errored, failed, passed, skipped, timeout, total } = task.caseCounts
@@ -185,6 +219,14 @@ function coverageOf(task: TaskNode): CellCoverage {
   return passed + failed + errored + skipped + timeout >= expected ? 'full' : 'partial'
 }
 
+function isSameSet(left: ReadonlySet<string>, right: ReadonlySet<string>): boolean {
+  return left.size === right.size && [...left].every(key => right.has(key))
+}
+
+function isStrictSubset(inner: ReadonlySet<string>, outer: ReadonlySet<string>): boolean {
+  return inner.size < outer.size && [...inner].every(key => outer.has(key))
+}
+
 function matches(handle: RunHandle, filter: { project: string, workspace: string }, now: number): boolean {
   const item = toRunListItem(handle, now)
   return item.workspaceId === filter.workspace && (item.projectSegment === filter.project || item.projectIds.includes(filter.project))
diff --git a/packages/ui/src/shared/contract.ts b/packages/ui/src/shared/contract.ts
index f0f58c0..7bcbd70 100644
--- a/packages/ui/src/shared/contract.ts
+++ b/packages/ui/src/shared/contract.ts
@@ -175,6 +175,11 @@ export const caseNodeSchema = v.object({
   /** `name` of the error that ended the last round, for grouping failures. */
   errorName: v.optional(v.string()),
   evidenceLinkCount: v.number(),
+  /**
+   * Identity of the case across runs, as `vieval report compare` aligns cases: the `benchmark.case.id` metric, else the
+   * `vieval.case.id` metric, else the case name (`caseId` carries the index, which differs when a run lists other cases).
+   */
+  identity: v.string(),
   index: v.number(),
   /** `taskId + '\u0000' + caseId`, the same key `cases.jsonl` tooling uses. */
   key: v.string(),
@@ -583,20 +588,27 @@ export const imagePreviewSchema = v.object({
 })
 
 /**
- * How much of a matrix cell one run measured.
+ * How much of a matrix cell one run measured. Cases are told apart by `CaseNode.identity`.
  *
  * - `full`: every expected case of the task settled and at least one has a result (cases without a result are counted
- *   in `counts.errored`, they do not make the run partial)
+ *   in `counts.errored`, they do not make the run partial), over the same cases as the cell's headline run
+ * - `other`: every case the run planned settled, but over other cases than the headline run: a smoke or limited run
+ *   of some of its cases, or another case set (a second dataset under the same entry); its score is not comparable
  * - `partial`: some expected cases never ran or never settled (an interrupted run, a re-run of a few cases, a running
  *   task)
  * - `none`: no case has a result (every case errored, or none ran)
  */
-export const cellCoverageSchema = v.picklist(['full', 'partial', 'none'])
+export const cellCoverageSchema = v.picklist(['full', 'other', 'partial', 'none'])
 
 /**
  * One cell of the matrix overview: one eval entry × run-matrix row × eval-matrix row, across the runs in scope.
  */
 export const matrixCellSchema = v.object({
+  /**
+   * Cases of the cell's headline run: the newest run that settled every case it planned, over cases that no other run
+   * of the cell covers a strict superset of. Expected cases of the newest run when no run settled every case.
+   */
+  caseCount: v.number(),
   /** Eval entry id parsed from the task id (`evals%2Fosworld%2F…`); one entry is one table in the UI. */
   entryId: v.string(),
   eval: v.record(v.string(), v.string()),
@@ -613,10 +625,12 @@ export const matrixCellSchema = v.object({
   })),
   /**
    * Result of the run the cell shows: the newest run that covered the cell fully or is still running it; the newest
-   * run when none did. A partial re-run of a few cases therefore never replaces a full run as the headline.
+   * run when none did. A partial re-run or a run over other cases therefore never replaces a full run as the headline.
    */
   latest: v.object({
     attemptId: v.string(),
+    /** Exact score of every case of the run (`null`: no score), for the spread of the score under the mean. */
+    caseScores: v.array(nullableNumber),
     /** Expected cases of the task (`case.started.total`); `undefined` until its first case started. */
     caseTotal: v.optional(v.number()),
     counts: caseCountsSchema,
@@ -632,6 +646,11 @@ export const matrixCellSchema = v.object({
   }),
   run: v.record(v.string(), v.string()),
   runRowId: v.string(),
+  /**
+   * Whether a newer run ran the same entry and run row with other eval values only (an eval axis added, removed, or
+   * changed since): the cell is a configuration the project moved away from.
+   */
+  superseded: v.boolean(),
 })
 
 /**
diff --git a/packages/ui/src/shared/reduce.ts b/packages/ui/src/shared/reduce.ts
index 2e76c06..1d17dac 100644
--- a/packages/ui/src/shared/reduce.ts
+++ b/packages/ui/src/shared/reduce.ts
@@ -982,6 +982,7 @@ export function toCaseNode(reduced: ReducedCase, options: { evidenceLinkCount: n
     errorMessage: lastRound?.errorMessage,
     errorName: lastRound?.errorName,
     evidenceLinkCount: options.evidenceLinkCount,
+    identity: identityOf(reduced),
     index: reduced.index,
     key: reduced.key,
     logLineCount: reduced.logLineCount,
@@ -1028,6 +1029,26 @@ function asString(value: unknown): string | undefined {
   return typeof value === 'string' ? value : undefined
 }
 
+/**
+ * Identity of a case across runs (see `CaseNode.identity`), resolved in the order of `vieval report compare`.
+ *
+ * Before:
+ * - metrics `benchmark.case.id = "lim-sinx|en|none"`, name `case #2`
+ * - no id metric, name `case #2`
+ *
+ * After:
+ * - "lim-sinx|en|none"
+ * - "case #2"
+ */
+function identityOf(reduced: ReducedCase): string {
+  for (const name of ['benchmark.case.id', 'vieval.case.id']) {
+    const value = reduced.metrics.findLast(metric => metric.name === name)?.value
+    if (typeof value === 'string' || typeof value === 'number')
+      return String(value)
+  }
+  return reduced.name
+}
+
 function parseCaseIndex(caseId: string): number {
   const index = Number.parseInt(caseId.split(':')[0] ?? '', 10)
   return Number.isNaN(index) ? 0 : index
diff --git a/packages/vieval/src/cli/run.test.ts b/packages/vieval/src/cli/run.test.ts
index 5764870..de64caa 100644
--- a/packages/vieval/src/cli/run.test.ts
+++ b/packages/vieval/src/cli/run.test.ts
@@ -462,22 +462,16 @@ function stripAnsi(value: string): string {
   return stripVTControlCharacters(value)
 }
 
-async function waitForExpectation(assertion: () => void, attempts = 30): Promise<void> {
-  let lastError: unknown
-
-  for (let index = 0; index < attempts; index += 1) {
-    try {
-      assertion()
-      return
-    }
-    catch (error) {
-      lastError = error
-      await new Promise(resolve => setTimeout(resolve, 10))
-    }
-  }
-
-  throw lastError
-}
+/**
+ * How long a test waits for the run to reach a state (cases started, released, or ended).
+ *
+ * NOTICE:
+ * A run loads its config and transpiles the eval files before the first case starts, which takes well over the 300 ms
+ * the previous helper (`waitForExpectation`: 30 tries 10 ms apart) allowed on a busy CI runner. Tests then failed with
+ * "expected [] to have a length of 3" before any case had started (seen on `main` and on PR #33). `vi.waitFor` polls as
+ * often, but gives the run seconds; it still returns as soon as the expectation holds.
+ */
+const RUN_STATE_WAIT = { interval: 10, timeout: 3000 }
 
 describe('runVievalCli', () => {
   afterEach(async () => {
@@ -1292,23 +1286,23 @@ export default defineConfig({
       cwd: projectDirectory,
     })
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toHaveLength(2)
       expect(state.started.some(entry => entry.startsWith('alpha:'))).toBe(true)
       expect(state.started.some(entry => entry.startsWith('beta:'))).toBe(true)
       expect(state.projectPeak.alpha).toBe(1)
       expect(state.projectPeak.beta).toBe(1)
       expect(state.peak).toBe(2)
-    })
+    }, RUN_STATE_WAIT)
 
     await Promise.resolve()
     expect(state.started).toHaveLength(2)
 
     state.releases.splice(0).forEach(release => release())
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toHaveLength(4)
-    })
+    }, RUN_STATE_WAIT)
 
     state.releases.splice(0).forEach(release => release())
 
@@ -1338,19 +1332,19 @@ export default defineConfig({
       taskConcurrency: 2,
     })
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toHaveLength(2)
       expect(state.peak).toBe(2)
-    })
+    }, RUN_STATE_WAIT)
 
     await Promise.resolve()
     expect(state.started).toHaveLength(2)
 
     state.releases.splice(0).forEach(release => release())
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toHaveLength(3)
-    })
+    }, RUN_STATE_WAIT)
 
     state.releases.splice(0).forEach(release => release())
 
@@ -1379,19 +1373,19 @@ export default defineConfig({
       taskConcurrency: 3,
     })
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toHaveLength(1)
       expect(state.peak).toBe(1)
-    })
+    }, RUN_STATE_WAIT)
 
     await Promise.resolve()
     expect(state.started).toHaveLength(1)
 
     state.releases.splice(0).forEach(release => release())
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toHaveLength(2)
-    })
+    }, RUN_STATE_WAIT)
 
     state.releases.splice(0).forEach(release => release())
 
@@ -1419,16 +1413,16 @@ export default defineConfig({
       taskConcurrency: 2,
     })
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toHaveLength(2)
       expect(state.peak).toBe(2)
-    })
+    }, RUN_STATE_WAIT)
 
     state.releases.splice(0).forEach(release => release())
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toHaveLength(3)
-    })
+    }, RUN_STATE_WAIT)
 
     state.releases.splice(0).forEach(release => release())
 
@@ -1486,9 +1480,9 @@ ${domainTask('vlc', 20)}
       report: false,
     })
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toHaveLength(3)
-    })
+    }, RUN_STATE_WAIT)
     await new Promise(resolve => setTimeout(resolve, 20))
 
     // Three slots, filled by cases of more than one domain task.
@@ -1562,9 +1556,9 @@ export default defineConfig({
     const runPromise = runVievalCli({ configFilePath: join(directory, 'vieval.config.ts'), cwd: directory, report: false })
 
     // alpha's quick case ends, its slow case keeps one slot: beta must take the other.
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toContain(10)
-    }, 200)
+    }, RUN_STATE_WAIT)
     expect(state.started).toEqual(expect.arrayContaining([1, 2, 10]))
     expect(state.releases).toHaveLength(2)
 
@@ -1691,23 +1685,23 @@ describeTask('cli-case-concurrency', (task) => {
       cwd: projectDirectory,
     })
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toEqual([1, 2])
-    })
+    }, RUN_STATE_WAIT)
     expect(state.peak).toBe(2)
 
     state.releases.shift()?.()
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toEqual([1, 2, 3])
-    })
+    }, RUN_STATE_WAIT)
     expect(state.peak).toBe(2)
 
     state.releases.shift()?.()
 
-    await waitForExpectation(() => {
+    await vi.waitFor(() => {
       expect(state.started).toEqual([1, 2, 3, 4])
-    })
+    }, RUN_STATE_WAIT)
     expect(state.peak).toBe(2)
 
     while (state.releases.length > 0) {