diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index e781ba9db..6f2f91ba7 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -13,6 +13,14 @@ import type {
 } from 'vue-media-annotator/alignedView/CameraRegistrationStore';
 import type { CameraRole } from 'dive-common/pipelineCameraOrder';
 import type { PercentileStretch } from 'vue-media-annotator/use/useImageEnhancements';
+import type {
+  ScoringDatasetSummary,
+  ScoringJobArgs,
+  ScoringPair,
+  ScoringResult,
+  ScoringResultSummary,
+  ScoringSourceOptions,
+} from 'dive-common/scoring/types';
 
 type DatasetType = 'image-sequence' | 'video' | 'multi' | 'large-image';
 type MultiTrackRecord = Record<string, TrackData>;
@@ -448,6 +456,28 @@ interface Api {
     },
   ): Promise<unknown>;
 
+  /**
+   * Scoring mode. Every member is optional so a platform that cannot run the
+   * `viame score` applet simply leaves the mode unavailable.
+   */
+  runScoring?(args: ScoringJobArgs): Promise<unknown>;
+  /** Resolve once the scoring job stored on this dataset, launched after this call, ends. */
+  watchScoringJob?(datasetId: string): Promise<PipelineJobResult>;
+  /** Runs stored on one dataset, or every run the user can read when omitted. */
+  listScoringResults?(datasetId?: string): Promise<ScoringResultSummary[]>;
+  loadScoringResult?(datasetId: string, resultId: string): Promise<ScoringResult>;
+  deleteScoringResult?(datasetId: string, resultId: string): Promise<void>;
+  /** Annotation sets, revisions or on-disk files a source on this dataset can point at. */
+  listScoringSources?(datasetId: string): Promise<ScoringSourceOptions>;
+  /** Datasets that may be named as the other side of a comparison. */
+  listScoringDatasets?(): Promise<ScoringDatasetSummary[]>;
+  /** Open a platform dataset picker; returns null when the user cancels. */
+  pickScoringDataset?(excludeIds: string[]): Promise<ScoringDatasetSummary | null>;
+  /** Save a text export where the user chooses; resolves false when they cancel. */
+  saveScoringExport?(args: { filename: string; mime: string; content: string }): Promise<boolean>;
+  /** Print the page as it stands (the scoring report view) to a PDF; false when cancelled. */
+  exportScoringPdf?(filename: string): Promise<boolean>;
+
   loadConfig(datasetId: string): Promise<DatasetConfig>;
   loadDetections(datasetId: string, revision?: number, set?: string): Promise<AnnotationSchemaList>;
   loadFrameMetadata(datasetId: string): Promise<FrameMetadataSourcesResponse>;
@@ -758,6 +788,12 @@ export type {
   TrainingConfigs,
   MultiCamMedia,
   MediaImportResponse,
+  ScoringDatasetSummary,
+  ScoringJobArgs,
+  ScoringPair,
+  ScoringResult,
+  ScoringResultSummary,
+  ScoringSourceOptions,
 };
 
 export type { PercentileStretch, CameraObservations };
diff --git a/client/dive-common/components/Scoring/ScoringClassTable.vue b/client/dive-common/components/Scoring/ScoringClassTable.vue
new file mode 100644
index 000000000..eb70b8863
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringClassTable.vue
@@ -0,0 +1,114 @@
+<script lang="ts">
+import { computed, defineComponent } from 'vue';
+import { useScoring } from 'dive-common/use/useScoring';
+import { formatMetric } from 'dive-common/scoring/metrics';
+
+const COLUMNS: { key: string; text: string; format: 'ratio' | 'count' }[] = [
+  { key: 'total_gt', text: 'Truth', format: 'count' },
+  { key: 'total_computed', text: 'Computed', format: 'count' },
+  { key: 'true_positives', text: 'TP', format: 'count' },
+  { key: 'false_positives', text: 'FP', format: 'count' },
+  { key: 'false_negatives', text: 'FN', format: 'count' },
+  { key: 'precision', text: 'Precision', format: 'ratio' },
+  { key: 'recall', text: 'Recall', format: 'ratio' },
+  { key: 'f1_score', text: 'F1', format: 'ratio' },
+  { key: 'average_precision', text: 'AP', format: 'ratio' },
+  { key: 'ap50', text: 'AP@50', format: 'ratio' },
+  { key: 'ap75', text: 'AP@75', format: 'ratio' },
+  { key: 'ap50_95', text: 'AP@[.5:.95]', format: 'ratio' },
+];
+
+export default defineComponent({
+  name: 'ScoringClassTable',
+  setup() {
+    const scoring = useScoring();
+
+    const headers = computed(() => [
+      { text: 'Class', value: 'name', sortable: true },
+      ...COLUMNS.map((c) => ({
+        text: c.text, value: c.key, sortable: true, align: 'end',
+      })),
+    ]);
+
+    const rows = computed(() => {
+      const perClass = scoring.metrics.value?.perClass || {};
+      return Object.entries(perClass).map(([name, metrics]) => ({
+        name,
+        color: scoring.classColor(name),
+        ...metrics,
+      }));
+    });
+
+    function display(value: unknown, key: string) {
+      const col = COLUMNS.find((c) => c.key === key);
+      return formatMetric(typeof value === 'number' ? value : null, col?.format || 'ratio');
+    }
+
+    return {
+      headers,
+      rows,
+      display,
+      COLUMNS,
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="px-2">
+    <div
+      v-if="rows.length === 0"
+      class="text-caption grey--text pa-2"
+    >
+      Per-class metrics were not requested for this run. Enable "Per class" in the scoring parameters.
+    </div>
+    <v-data-table
+      v-else
+      :headers="headers"
+      :items="rows"
+      dense
+      disable-pagination
+      hide-default-footer
+      sort-by="f1_score"
+      sort-desc
+      class="class-table"
+    >
+      <template #[`item.name`]="{ item }">
+        <span
+          class="class-swatch"
+          :style="{ background: item.color }"
+        />
+        {{ item.name }}
+      </template>
+      <template
+        v-for="col in COLUMNS"
+        #[`item.${col.key}`]="{ item }"
+      >
+        <span
+          :key="col.key"
+          class="tabular"
+        >{{ display(item[col.key], col.key) }}</span>
+      </template>
+    </v-data-table>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.class-swatch {
+  display: inline-block;
+  width: 10px;
+  height: 10px;
+  border-radius: 2px;
+  margin-right: 6px;
+}
+
+.tabular {
+  font-variant-numeric: tabular-nums;
+}
+
+.class-table ::v-deep td,
+.class-table ::v-deep th {
+  font-size: 12px !important;
+  height: 26px !important;
+}
+</style>
diff --git a/client/dive-common/components/Scoring/ScoringConfusion.vue b/client/dive-common/components/Scoring/ScoringConfusion.vue
new file mode 100644
index 000000000..c5ae172e1
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringConfusion.vue
@@ -0,0 +1,110 @@
+<script lang="ts">
+import { computed, defineComponent, ref } from 'vue';
+import { useScoring } from 'dive-common/use/useScoring';
+import ScoringHeatmap from './charts/ScoringHeatmap.vue';
+
+export default defineComponent({
+  name: 'ScoringConfusion',
+  components: { ScoringHeatmap },
+  setup(_, { emit }) {
+    const scoring = useScoring();
+    const normalized = ref(false);
+    const selected = ref<{ row: number; col: number } | null>(null);
+
+    const matrix = computed(() => scoring.metrics.value?.confusionMatrix || null);
+    const backgroundIndex = computed(() => (matrix.value ? matrix.value.classNames.indexOf('background') : -1));
+    const accuracy = computed(() => scoring.metrics.value?.values.classification_accuracy ?? null);
+
+    function onSelect(cell: { row: number; col: number }) {
+      if (!matrix.value) return;
+      if (selected.value && selected.value.row === cell.row && selected.value.col === cell.col) {
+        selected.value = null;
+        emit('filter', null);
+        return;
+      }
+      selected.value = cell;
+      const truthClass = matrix.value.classNames[cell.row];
+      const computedClass = matrix.value.classNames[cell.col];
+      // Background rows are misses, background columns are false alarms
+      let status: 'tp' | 'fp' | 'fn' | null = null;
+      if (truthClass === 'background') status = 'fp';
+      else if (computedClass === 'background') status = 'fn';
+      else status = 'tp';
+      emit('filter', {
+        status,
+        gtClass: truthClass === 'background' ? null : truthClass,
+        computedClass: computedClass === 'background' ? null : computedClass,
+      });
+    }
+
+    return {
+      matrix,
+      normalized,
+      selected,
+      backgroundIndex,
+      accuracy,
+      onSelect,
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="px-2">
+    <div
+      v-if="!matrix"
+      class="text-caption grey--text pa-2"
+    >
+      No confusion matrix in this result.
+    </div>
+    <div
+      v-else
+      class="d-flex flex-wrap"
+    >
+      <ScoringHeatmap
+        :row-labels="matrix.classNames"
+        :col-labels="matrix.classNames"
+        :counts="matrix.matrix"
+        :fractions="matrix.normalized"
+        :show-fractions="normalized"
+        :background-index="backgroundIndex"
+        :selected="selected"
+        @select="onSelect"
+      />
+      <div class="pl-4 pt-2 confusion-side">
+        <v-switch
+          v-model="normalized"
+          dense
+          hide-details
+          label="Normalize rows"
+          class="mt-0"
+        />
+        <div
+          v-if="accuracy !== null"
+          class="text-body-2 mt-2"
+        >
+          Classification accuracy among matches: <b>{{ (accuracy * 100).toFixed(1) }}%</b>
+        </div>
+        <div class="text-caption grey--text mt-2">
+          Rows are truth classes, columns are computed classes. The background row holds
+          false positives and the background column holds missed objects. Click a cell to
+          browse the objects behind it in the Errors tab.
+        </div>
+        <div class="text-caption mt-2">
+          <div
+            v-for="name in matrix.classNames.filter((n) => n !== 'background')"
+            :key="name"
+          >
+            {{ name }}: {{ matrix.perClassAccuracy[name] === null || matrix.perClassAccuracy[name] === undefined ? 'n/a' : `${(matrix.perClassAccuracy[name] * 100).toFixed(1)}%` }} correct
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.confusion-side {
+  max-width: 320px;
+}
+</style>
diff --git a/client/dive-common/components/Scoring/ScoringCurves.vue b/client/dive-common/components/Scoring/ScoringCurves.vue
new file mode 100644
index 000000000..cf2f16ab9
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringCurves.vue
@@ -0,0 +1,402 @@
+<script lang="ts">
+import {
+  computed, defineComponent, ref, watch,
+} from 'vue';
+import { useScoring } from 'dive-common/use/useScoring';
+import type { PRCurve } from 'dive-common/scoring/metrics';
+import ScoringLineChart from './charts/ScoringLineChart.vue';
+import type { ChartHover, ChartSeries } from './charts/chartTypes';
+
+const OVERALL_COLOR = '#e0e0e0';
+
+export default defineComponent({
+  name: 'ScoringCurves',
+  components: { ScoringLineChart },
+  setup() {
+    const scoring = useScoring();
+
+    const mode = ref<'overall' | 'classes' | 'both'>('both');
+    const threshold = ref<number>(scoring.currentFilters.value.default ?? 0.5);
+    const applied = ref(false);
+    watch(() => scoring.currentFilters.value.default, (value) => {
+      if (value !== undefined) threshold.value = value;
+    });
+
+    const metrics = computed(() => scoring.metrics.value);
+    const hasClasses = computed(() => Object.keys(metrics.value?.perClassPrCurves || {}).length > 0);
+
+    watch(hasClasses, (value) => {
+      if (!value) mode.value = 'overall';
+    }, { immediate: true });
+
+    function prSeries(name: string, curve: PRCurve, color: string, dashed = false): ChartSeries {
+      return {
+        name,
+        color,
+        dashed,
+        points: curve.points.map((p) => ({
+          x: p.recall,
+          y: p.precision,
+          meta: {
+            threshold: p.confidence, F1: p.f1, TP: p.tp, FP: p.fp, FN: p.fn,
+          },
+        })),
+      };
+    }
+
+    const prCurves = computed(() => {
+      const out: { name: string; curve: PRCurve; color: string; dashed: boolean }[] = [];
+      if (!metrics.value) return out;
+      if (mode.value !== 'classes' && metrics.value.prCurve) {
+        out.push({
+          name: 'Overall', curve: metrics.value.prCurve, color: OVERALL_COLOR, dashed: mode.value === 'both',
+        });
+      }
+      if (mode.value !== 'overall') {
+        Object.entries(metrics.value.perClassPrCurves).forEach(([name, curve]) => {
+          out.push({
+            name, curve, color: scoring.classColor(name), dashed: false,
+          });
+        });
+      }
+      return out;
+    });
+
+    const prSeriesList = computed(() => prCurves.value.map((c) => prSeries(c.name, c.curve, c.color, c.dashed)));
+
+    const rocSeries = computed<ChartSeries[]>(() => {
+      const roc = metrics.value?.rocCurve;
+      if (!roc) return [];
+      return [{
+        name: 'Overall',
+        color: OVERALL_COLOR,
+        points: roc.points
+          .filter((p) => Number.isFinite(p.falseAlarmsPerFrame) && Number.isFinite(p.truePositiveRate))
+          .map((p) => ({
+            x: p.falseAlarmsPerFrame,
+            y: p.truePositiveRate,
+            meta: { threshold: p.confidence },
+          })),
+      }];
+    });
+
+    /** The curve point whose confidence sits at or just above the threshold */
+    function pointAtThreshold(curve: PRCurve) {
+      const candidates = curve.points.filter((p) => p.confidence >= threshold.value);
+      if (candidates.length === 0) return null;
+      return candidates.reduce((best, p) => (p.confidence < best.confidence ? p : best), candidates[0]);
+    }
+
+    const operatingPoints = computed(() => prCurves.value.map((c) => {
+      const point = pointAtThreshold(c.curve);
+      return {
+        name: c.name,
+        color: c.color,
+        ap: c.curve.averagePrecision,
+        maxF1: c.curve.maxF1,
+        bestThreshold: c.curve.bestThreshold,
+        point,
+      };
+    }));
+
+    const selectedRecall = computed(() => {
+      const overall = operatingPoints.value.find((o) => o.name === 'Overall') || operatingPoints.value[0];
+      return overall?.point ? overall.point.recall : null;
+    });
+
+    const prMarkers = computed(() => operatingPoints.value
+      .filter((o) => o.point && o.name !== 'Overall' && mode.value === 'classes')
+      .map((o) => ({ x: o.point!.recall, label: o.name, color: o.color })));
+
+    const rocSelected = computed(() => {
+      const roc = metrics.value?.rocCurve;
+      if (!roc) return null;
+      const candidates = roc.points.filter((p) => p.confidence !== null && p.confidence >= threshold.value);
+      if (candidates.length === 0) return null;
+      const best = candidates.reduce((b, p) => ((p.confidence ?? 0) < (b.confidence ?? 0) ? p : b), candidates[0]);
+      return best.falseAlarmsPerFrame;
+    });
+
+    function tooltip(h: ChartHover): string[] {
+      const m = h.point.meta || {};
+      return [
+        h.series.name,
+        `threshold ≥ ${Number(m.threshold ?? 0).toFixed(3)}`,
+        `precision ${h.point.y.toFixed(3)}  recall ${h.point.x.toFixed(3)}`,
+        `F1 ${Number(m.F1 ?? 0).toFixed(3)}  (TP ${m.TP}, FP ${m.FP}, FN ${m.FN})`,
+      ];
+    }
+
+    function rocTooltip(h: ChartHover): string[] {
+      const t = h.point.meta?.threshold;
+      return [
+        `threshold ≥ ${typeof t === 'number' ? t.toFixed(3) : 'n/a'}`,
+        `Pd ${h.point.y.toFixed(3)} at ${h.point.x.toFixed(3)} false alarms / frame`,
+      ];
+    }
+
+    function pickThreshold(h: ChartHover) {
+      const t = h.point.meta?.threshold;
+      if (typeof t === 'number' && Number.isFinite(t)) {
+        threshold.value = Math.round(t * 1000) / 1000;
+        applied.value = false;
+      }
+    }
+
+    async function applyThreshold() {
+      await scoring.applyConfidenceFilters({ default: threshold.value });
+      applied.value = true;
+    }
+
+    const roc = computed(() => metrics.value?.rocCurve || null);
+
+    return {
+      mode,
+      threshold,
+      applied,
+      hasClasses,
+      prSeriesList,
+      rocSeries,
+      operatingPoints,
+      selectedRecall,
+      prMarkers,
+      rocSelected,
+      roc,
+      tooltip,
+      rocTooltip,
+      pickThreshold,
+      applyThreshold,
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="px-2 scoring-curves">
+    <div class="d-flex align-center flex-wrap controls">
+      <v-btn-toggle
+        v-model="mode"
+        dense
+        mandatory
+        group
+      >
+        <v-btn
+          value="overall"
+          x-small
+        >
+          Consolidated
+        </v-btn>
+        <v-btn
+          value="classes"
+          x-small
+          :disabled="!hasClasses"
+        >
+          Per class
+        </v-btn>
+        <v-btn
+          value="both"
+          x-small
+          :disabled="!hasClasses"
+        >
+          Both
+        </v-btn>
+      </v-btn-toggle>
+      <v-spacer />
+      <span class="text-caption mr-2">Threshold</span>
+      <v-slider
+        v-model="threshold"
+        :min="0"
+        :max="1"
+        :step="0.005"
+        dense
+        hide-details
+        class="threshold-slider"
+        @change="applied = false"
+      />
+      <v-text-field
+        v-model.number="threshold"
+        type="number"
+        :min="0"
+        :max="1"
+        :step="0.01"
+        dense
+        hide-details
+        outlined
+        class="threshold-field ml-2"
+      />
+      <v-tooltip bottom>
+        <template #activator="{ on }">
+          <v-btn
+            x-small
+            outlined
+            class="ml-2"
+            :color="applied ? 'success' : 'primary'"
+            v-on="on"
+            @click="applyThreshold"
+          >
+            {{ applied ? 'Applied' : 'Use as confidence filter' }}
+          </v-btn>
+        </template>
+        <span>Save this threshold as the base confidence filter of every scored dataset. Click a curve point to pick its threshold.</span>
+      </v-tooltip>
+    </div>
+    <div class="d-flex flex-wrap charts">
+      <div class="chart-col">
+        <div class="chart-title">
+          Precision / Recall
+        </div>
+        <ScoringLineChart
+          :series="prSeriesList"
+          x-label="Recall"
+          y-label="Precision"
+          :x-domain="[0, 1]"
+          :y-domain="[0, 1.02]"
+          :selected-x="selectedRecall"
+          :markers="prMarkers"
+          :tooltip="tooltip"
+          :height="230"
+          @click="pickThreshold"
+        />
+      </div>
+      <div
+        v-if="rocSeries.length"
+        class="chart-col"
+      >
+        <div class="chart-title">
+          Detection ROC
+          <span
+            v-if="roc && roc.meanPd !== null"
+            class="text-caption grey--text"
+          >(mean Pd {{ roc.meanPd.toFixed(3) }})</span>
+        </div>
+        <ScoringLineChart
+          :series="rocSeries"
+          x-label="False alarms per frame"
+          y-label="Probability of detection"
+          :y-domain="[0, 1.02]"
+          :selected-x="rocSelected"
+          :tooltip="rocTooltip"
+          :height="230"
+          @click="pickThreshold"
+        />
+      </div>
+      <div class="operating-col">
+        <table class="operating-table">
+          <thead>
+            <tr>
+              <th>Curve</th>
+              <th>AP</th>
+              <th>Max F1</th>
+              <th>@</th>
+              <th>P @ t</th>
+              <th>R @ t</th>
+              <th>F1 @ t</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr
+              v-for="o in operatingPoints"
+              :key="o.name"
+            >
+              <td>
+                <span
+                  class="swatch"
+                  :style="{ background: o.color }"
+                />{{ o.name }}
+              </td>
+              <td>{{ o.ap === null ? 'n/a' : o.ap.toFixed(3) }}</td>
+              <td>{{ o.maxF1 === null ? 'n/a' : o.maxF1.toFixed(3) }}</td>
+              <td>{{ o.bestThreshold === null ? 'n/a' : o.bestThreshold.toFixed(2) }}</td>
+              <td>{{ o.point ? o.point.precision.toFixed(3) : '—' }}</td>
+              <td>{{ o.point ? o.point.recall.toFixed(3) : '—' }}</td>
+              <td>{{ o.point ? o.point.f1.toFixed(3) : '—' }}</td>
+            </tr>
+          </tbody>
+        </table>
+        <div class="text-caption grey--text mt-1">
+          "@ t" columns read each curve at the selected threshold. Hover a curve for the
+          threshold behind any point; click a point to select its threshold.
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.controls {
+  gap: 4px;
+}
+
+.threshold-slider {
+  max-width: 220px;
+  min-width: 120px;
+}
+
+.threshold-field {
+  max-width: 90px;
+}
+
+.threshold-field ::v-deep input {
+  font-size: 12px;
+  padding: 2px 0;
+}
+
+.charts {
+  gap: 8px;
+  align-items: flex-start;
+}
+
+.chart-col {
+  flex: 1 1 320px;
+  min-width: 280px;
+}
+
+.chart-title {
+  font-size: 12px;
+  font-weight: bold;
+  color: #ccc;
+  padding-left: 46px;
+}
+
+.operating-col {
+  flex: 0 1 380px;
+  min-width: 260px;
+  padding-top: 18px;
+}
+
+.operating-table {
+  border-collapse: collapse;
+  font-size: 12px;
+  width: 100%;
+
+  th {
+    text-align: right;
+    color: #aaa;
+    font-weight: normal;
+    border-bottom: 1px solid #444;
+    padding: 0 4px;
+  }
+
+  th:first-child {
+    text-align: left;
+  }
+
+  td {
+    text-align: right;
+    padding: 1px 4px;
+    font-variant-numeric: tabular-nums;
+  }
+
+  td:first-child {
+    text-align: left;
+  }
+
+  .swatch {
+    display: inline-block;
+    width: 10px;
+    height: 10px;
+    border-radius: 2px;
+    margin-right: 5px;
+  }
+}
+</style>
diff --git a/client/dive-common/components/Scoring/ScoringErrors.vue b/client/dive-common/components/Scoring/ScoringErrors.vue
new file mode 100644
index 000000000..f393a4dc8
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringErrors.vue
@@ -0,0 +1,281 @@
+<script lang="ts">
+import {
+  computed, defineComponent, PropType, ref, watch,
+} from 'vue';
+import { useScoring } from 'dive-common/use/useScoring';
+import { perFrameErrorCounts, ScoringMatch } from 'dive-common/scoring/metrics';
+import ScoringLineChart from './charts/ScoringLineChart.vue';
+import type { ChartHover, ChartSeries } from './charts/chartTypes';
+
+export interface ErrorFilter {
+  status: 'tp' | 'fp' | 'fn' | null;
+  gtClass: string | null;
+  computedClass: string | null;
+}
+
+const STATUS_LABEL: Record<string, string> = { tp: 'Match', fp: 'False positive', fn: 'Missed' };
+const STATUS_COLOR: Record<string, string> = { tp: '#4caf50', fp: '#e53935', fn: '#ff9800' };
+
+export default defineComponent({
+  name: 'ScoringErrors',
+  components: { ScoringLineChart },
+  props: {
+    filter: {
+      type: Object as PropType<ErrorFilter | null>,
+      default: null,
+    },
+  },
+  setup(props, { emit }) {
+    const scoring = useScoring();
+
+    const status = ref<'all' | 'tp' | 'fp' | 'fn'>('all');
+    const klass = ref<string>('');
+    const sequence = ref<number>(0);
+    const showMatches = ref(false);
+
+    watch(() => props.filter, (f) => {
+      if (!f) return;
+      status.value = f.status || 'all';
+      klass.value = f.gtClass || f.computedClass || '';
+    });
+
+    const pairs = computed(() => scoring.result.value?.pairs || []);
+    const sequenceItems = computed(() => pairs.value.map((p, i) => ({
+      value: i,
+      text: scoring.datasetName(p.computed.datasetId),
+    })));
+    watch(pairs, () => { sequence.value = 0; });
+
+    const matches = computed(() => scoring.matches.value);
+    const classes = computed(() => {
+      const names = new Set<string>();
+      matches.value.forEach((m) => {
+        if (m.gtClass) names.add(m.gtClass);
+        if (m.computedClass) names.add(m.computedClass);
+      });
+      return Array.from(names).sort();
+    });
+
+    const filtered = computed(() => matches.value.filter((m) => {
+      if (status.value !== 'all' && m.status !== status.value) return false;
+      if (status.value === 'all' && !showMatches.value && m.status === 'tp') return false;
+      if (klass.value && m.gtClass !== klass.value && m.computedClass !== klass.value) return false;
+      if (props.filter && props.filter.status === 'tp' && props.filter.gtClass && props.filter.computedClass
+        && status.value === 'tp') {
+        return m.gtClass === props.filter.gtClass && m.computedClass === props.filter.computedClass;
+      }
+      return true;
+    }));
+
+    const counts = computed(() => {
+      const out = { tp: 0, fp: 0, fn: 0 };
+      matches.value.forEach((m) => { out[m.status] += 1; });
+      return out;
+    });
+
+    const frameSeries = computed<ChartSeries[]>(() => {
+      const perFrame = perFrameErrorCounts(matches.value.filter((m) => m.sequence === sequence.value
+        && (!klass.value || m.gtClass === klass.value || m.computedClass === klass.value)));
+      if (!perFrame.length) return [];
+      const build = (key: 'tp' | 'fp' | 'fn') => ({
+        name: STATUS_LABEL[key],
+        color: STATUS_COLOR[key],
+        points: perFrame.map((f) => ({ x: f.frame, y: f[key] })),
+      });
+      const series = [build('fp'), build('fn')];
+      if (showMatches.value) series.unshift(build('tp'));
+      return series;
+    });
+
+    function frameTooltip(h: ChartHover): string[] {
+      return [`frame ${h.point.x}`, `${h.series.name}: ${h.point.y}`];
+    }
+
+    function datasetFor(m: ScoringMatch) {
+      return pairs.value[m.sequence]?.computed.datasetId || '';
+    }
+
+    function sequenceName(m: ScoringMatch) {
+      const id = datasetFor(m);
+      return id ? scoring.datasetName(id) : `#${m.sequence}`;
+    }
+
+    function open(m: ScoringMatch) {
+      const id = datasetFor(m);
+      if (id) emit('open-viewer', id);
+    }
+
+    const headers = computed(() => [
+      ...(pairs.value.length > 1 ? [{ text: 'Sequence', value: 'sequence' }] : []),
+      { text: 'Frame', value: 'frame', align: 'end' },
+      { text: 'Status', value: 'status' },
+      { text: 'Computed', value: 'computedId', align: 'end' },
+      { text: 'Truth', value: 'gtId', align: 'end' },
+      { text: 'Computed class', value: 'computedClass' },
+      { text: 'Truth class', value: 'gtClass' },
+      { text: 'Conf', value: 'confidence', align: 'end' },
+      { text: 'IoU', value: 'iou', align: 'end' },
+      {
+        text: '', value: 'open', sortable: false, width: 32,
+      },
+    ]);
+
+    const statusItems = [
+      { value: 'all', text: 'Errors only' },
+      { value: 'fp', text: 'False positives' },
+      { value: 'fn', text: 'Missed' },
+      { value: 'tp', text: 'Matches' },
+    ];
+
+    return {
+      status,
+      klass,
+      sequence,
+      sequenceItems,
+      showMatches,
+      classes,
+      filtered,
+      counts,
+      frameSeries,
+      frameTooltip,
+      sequenceName,
+      open,
+      headers,
+      statusItems,
+      STATUS_LABEL,
+      STATUS_COLOR,
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="px-2 scoring-errors">
+    <div
+      v-if="counts.fp + counts.fn + counts.tp === 0"
+      class="text-caption grey--text pa-2"
+    >
+      No per-object matches were stored for this result.
+    </div>
+    <template v-else>
+      <div class="d-flex align-center flex-wrap controls">
+        <v-select
+          v-model="status"
+          :items="statusItems"
+          dense
+          outlined
+          hide-details
+          class="status-select"
+        />
+        <v-select
+          v-model="klass"
+          :items="[{ value: '', text: 'All classes' }, ...classes.map((c) => ({ value: c, text: c }))]"
+          dense
+          outlined
+          hide-details
+          class="class-select"
+        />
+        <v-select
+          v-if="sequenceItems.length > 1"
+          v-model="sequence"
+          :items="sequenceItems"
+          dense
+          outlined
+          hide-details
+          label="Chart sequence"
+          class="class-select"
+        />
+        <v-checkbox
+          v-model="showMatches"
+          dense
+          hide-details
+          label="Show matches"
+          class="mt-0 ml-2"
+        />
+        <v-spacer />
+        <span class="text-caption">
+          <span :style="{ color: STATUS_COLOR.tp }">{{ counts.tp }} matched</span> ·
+          <span :style="{ color: STATUS_COLOR.fp }">{{ counts.fp }} false positives</span> ·
+          <span :style="{ color: STATUS_COLOR.fn }">{{ counts.fn }} missed</span>
+        </span>
+      </div>
+      <div class="chart-col">
+        <ScoringLineChart
+          :series="frameSeries"
+          x-label="Frame"
+          y-label="Objects"
+          :tooltip="frameTooltip"
+          :x-format="(v) => String(Math.round(v))"
+          :y-format="(v) => String(Math.round(v))"
+          :height="150"
+          step
+        />
+      </div>
+      <v-data-table
+        :headers="headers"
+        :items="filtered"
+        dense
+        :items-per-page="10"
+        :footer-props="{ 'items-per-page-options': [10, 25, 100] }"
+        class="error-table"
+      >
+        <template #[`item.sequence`]="{ item }">
+          {{ sequenceName(item) }}
+        </template>
+        <template #[`item.status`]="{ item }">
+          <span :style="{ color: STATUS_COLOR[item.status] }">{{ STATUS_LABEL[item.status] }}</span>
+        </template>
+        <template #[`item.computedId`]="{ item }">
+          {{ item.computedId === null ? '—' : item.computedId }}
+        </template>
+        <template #[`item.gtId`]="{ item }">
+          {{ item.gtId === null ? '—' : item.gtId }}
+        </template>
+        <template #[`item.confidence`]="{ item }">
+          {{ item.status === 'fn' ? '—' : item.confidence.toFixed(3) }}
+        </template>
+        <template #[`item.iou`]="{ item }">
+          {{ item.status === 'tp' ? item.iou.toFixed(3) : '—' }}
+        </template>
+        <template #[`item.open`]="{ item }">
+          <v-tooltip bottom>
+            <template #activator="{ on }">
+              <v-btn
+                icon
+                x-small
+                v-on="on"
+                @click="open(item)"
+              >
+                <v-icon small>
+                  mdi-open-in-new
+                </v-icon>
+              </v-btn>
+            </template>
+            <span>Open this sequence in the viewer</span>
+          </v-tooltip>
+        </template>
+      </v-data-table>
+    </template>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.controls {
+  gap: 8px;
+}
+
+.status-select,
+.class-select {
+  max-width: 200px;
+}
+
+.chart-col {
+  max-width: 720px;
+}
+
+.error-table ::v-deep td,
+.error-table ::v-deep th {
+  font-size: 12px !important;
+  height: 24px !important;
+}
+</style>
diff --git a/client/dive-common/components/Scoring/ScoringPage.vue b/client/dive-common/components/Scoring/ScoringPage.vue
new file mode 100644
index 000000000..7fc054ae9
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringPage.vue
@@ -0,0 +1,530 @@
+<script lang="ts">
+import {
+  computed, defineComponent, nextTick, onMounted, PropType, ref, watch,
+} from 'vue';
+import { useApi } from 'dive-common/apispec';
+import { usePrompt } from 'dive-common/vue-utilities/prompt-service';
+import { createScoringService, provideScoring } from 'dive-common/use/useScoring';
+import { formatMetric } from 'dive-common/scoring/metrics';
+import {
+  downloadTextFile, exportFilename, resultToCsv, resultToJson,
+} from 'dive-common/scoring/export';
+import ScoringReport from './ScoringReport.vue';
+import ScoringPairsTable from './ScoringPairsTable.vue';
+import ScoringParamsDialog from './ScoringParamsDialog.vue';
+import ScoringSummary from './ScoringSummary.vue';
+import ScoringClassTable from './ScoringClassTable.vue';
+import ScoringConfusion from './ScoringConfusion.vue';
+import ScoringCurves from './ScoringCurves.vue';
+import ScoringSweep from './ScoringSweep.vue';
+import ScoringErrors, { ErrorFilter } from './ScoringErrors.vue';
+
+const TABS = [
+  { key: 'summary', text: 'Summary' },
+  { key: 'classes', text: 'Classes' },
+  { key: 'confusion', text: 'Confusion' },
+  { key: 'curves', text: 'Curves' },
+  { key: 'sweep', text: 'Sweep' },
+  { key: 'errors', text: 'Errors' },
+];
+
+/**
+ * The scoring page: pick sequences and their computed/truth annotations, run
+ * `viame score` on all of them as one job, and browse this or any earlier run.
+ * Platform shells own routing; this emits `open-viewer` with a dataset id.
+ */
+export default defineComponent({
+  name: 'ScoringPage',
+  components: {
+    ScoringPairsTable,
+    ScoringParamsDialog,
+    ScoringSummary,
+    ScoringClassTable,
+    ScoringConfusion,
+    ScoringCurves,
+    ScoringSweep,
+    ScoringErrors,
+    ScoringReport,
+  },
+  props: {
+    initialDatasetIds: {
+      type: Array as PropType<string[]>,
+      default: () => [],
+    },
+  },
+  setup(props, { emit }) {
+    const api = useApi();
+    const scoring = createScoringService({ api });
+    provideScoring(scoring);
+    const { prompt } = usePrompt();
+
+    const tab = ref('summary');
+    const showParams = ref(false);
+    const errorFilter = ref<ErrorFilter | null>(null);
+    const reportMode = ref(false);
+    const exporting = ref(false);
+
+    async function saveText(filename: string, content: string, mime: string) {
+      if (api.saveScoringExport) {
+        await api.saveScoringExport({ filename, mime, content });
+      } else {
+        downloadTextFile(filename, content, mime);
+      }
+    }
+
+    async function exportAs(kind: 'json' | 'csv' | 'pdf') {
+      const result = scoring.result.value;
+      if (!result || exporting.value) return;
+      if (kind === 'pdf') {
+        reportMode.value = true;
+        return;
+      }
+      exporting.value = true;
+      try {
+        if (kind === 'json') {
+          await saveText(exportFilename(result, 'json'), resultToJson(result), 'application/json');
+        } else {
+          await saveText(exportFilename(result, 'csv'), resultToCsv(result, scoring.metrics.value || undefined), 'text/csv');
+        }
+      } finally {
+        exporting.value = false;
+      }
+    }
+
+    // Electron's printToPDF renders the screen layout rather than print media,
+    // so the chrome is hidden through a class as well as the print stylesheet.
+    async function printReport() {
+      const result = scoring.result.value;
+      if (!result) return;
+      exporting.value = true;
+      document.documentElement.classList.add('scoring-print');
+      try {
+        await nextTick();
+        if (api.exportScoringPdf) {
+          await api.exportScoringPdf(exportFilename(result, 'pdf'));
+        } else {
+          window.print();
+        }
+      } finally {
+        document.documentElement.classList.remove('scoring-print');
+        exporting.value = false;
+      }
+    }
+
+    const canSavePdf = computed(() => typeof api.exportScoringPdf === 'function');
+
+    const paramsSummary = computed(() => {
+      const p = scoring.params;
+      const bits = [`IoU ≥ ${p.iouThreshold}`, `${p.matchMode} matching`];
+      if (p.confidenceThreshold > 0) bits.push(`conf ≥ ${p.confidenceThreshold}`);
+      if (p.perClass) bits.push('per class');
+      if (p.tracking) bits.push('tracking');
+      if (p.sweep) bits.push(`sweep ×${p.sweepInterval}`);
+      return bits.join(' · ');
+    });
+
+    const resultItems = computed(() => scoring.results.value.map((r) => ({
+      id: r.id,
+      title: r.title,
+      when: new Date(r.created).toLocaleString(),
+      f1: formatMetric(r.headline.f1_score, 'ratio'),
+      sequences: r.pairs.length,
+    })));
+
+    async function removeResult(id: string) {
+      const ok = await prompt({
+        title: 'Delete scoring result',
+        text: 'Remove this scoring run?',
+        confirm: true,
+      });
+      if (ok) await scoring.deleteResult(id);
+    }
+
+    function onConfusionFilter(filter: ErrorFilter | null) {
+      errorFilter.value = filter;
+      if (filter) tab.value = 'errors';
+    }
+
+    async function applyInitial(ids: string[]) {
+      if (ids.length) await scoring.setDatasets(ids);
+    }
+
+    onMounted(async () => {
+      await scoring.refreshDatasets();
+      scoring.refreshResults();
+      await applyInitial(props.initialDatasetIds);
+    });
+    watch(() => props.initialDatasetIds, (ids) => { applyInitial(ids); });
+
+    return {
+      scoring,
+      tab,
+      tabs: TABS,
+      showParams,
+      errorFilter,
+      paramsSummary,
+      resultItems,
+      removeResult,
+      onConfusionFilter,
+      reportMode,
+      exporting,
+      exportAs,
+      printReport,
+      canSavePdf,
+      openViewer: (id: string) => emit('open-viewer', id),
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="scoring-page">
+    <v-alert
+      v-if="!scoring.available.value"
+      type="info"
+      dense
+      outlined
+    >
+      Scoring is not available on this platform.
+    </v-alert>
+    <div
+      v-else-if="reportMode"
+      class="report-mode"
+    >
+      <div class="d-flex align-center scoring-report-toolbar mb-2">
+        <v-btn
+          text
+          @click="reportMode = false"
+        >
+          <v-icon left>
+            mdi-arrow-left
+          </v-icon>
+          Back to results
+        </v-btn>
+        <v-spacer />
+        <span class="text-caption grey--text mr-3">
+          {{ canSavePdf ? 'Saves the report below as a PDF.' : 'Choose "Save as PDF" in the print dialog.' }}
+        </span>
+        <v-btn
+          color="primary"
+          depressed
+          :loading="exporting"
+          @click="printReport"
+        >
+          <v-icon left>
+            mdi-file-pdf-box
+          </v-icon>
+          {{ canSavePdf ? 'Save PDF' : 'Print' }}
+        </v-btn>
+      </div>
+      <ScoringReport />
+    </div>
+    <v-row v-else>
+      <v-col
+        cols="12"
+        lg="5"
+        xl="4"
+      >
+        <v-card outlined>
+          <v-card-title class="text-h6 py-2">
+            <v-icon
+              class="mr-2"
+            >
+              mdi-chart-box-outline
+            </v-icon>
+            Score annotations
+          </v-card-title>
+          <v-card-text>
+            <ScoringPairsTable @open-viewer="openViewer" />
+            <div class="d-flex align-center mt-3 flex-wrap run-row">
+              <v-btn
+                small
+                outlined
+                @click="showParams = true"
+              >
+                <v-icon
+                  small
+                  left
+                >
+                  mdi-tune
+                </v-icon>
+                Parameters
+              </v-btn>
+              <span class="text-caption grey--text mx-2">{{ paramsSummary }}</span>
+              <v-spacer />
+              <v-btn
+                depressed
+                color="primary"
+                :loading="scoring.running.value"
+                :disabled="scoring.running.value || scoring.pairs.value.length === 0"
+                @click="scoring.run()"
+              >
+                <v-icon left>
+                  mdi-play
+                </v-icon>
+                Score
+              </v-btn>
+            </div>
+            <div
+              v-if="scoring.status.value"
+              class="text-caption d-flex align-center mt-2"
+            >
+              <v-progress-circular
+                indeterminate
+                size="12"
+                width="2"
+                class="mr-2"
+              />
+              {{ scoring.status.value }}
+            </div>
+            <v-alert
+              v-if="scoring.error.value"
+              dense
+              dismissible
+              type="error"
+              class="mt-2 mb-0"
+              @input="scoring.clearError()"
+            >
+              {{ scoring.error.value }}
+            </v-alert>
+          </v-card-text>
+        </v-card>
+
+        <v-card
+          outlined
+          class="mt-3"
+        >
+          <v-card-title class="text-subtitle-1 py-2">
+            Previous runs
+            <v-spacer />
+            <v-btn
+              icon
+              small
+              :loading="scoring.loading.value"
+              @click="scoring.refreshResults()"
+            >
+              <v-icon small>
+                mdi-refresh
+              </v-icon>
+            </v-btn>
+          </v-card-title>
+          <v-list
+            dense
+            class="result-list"
+          >
+            <div
+              v-if="resultItems.length === 0"
+              class="text-caption grey--text px-4 pb-2"
+            >
+              No scoring runs stored yet.
+            </div>
+            <v-list-item
+              v-for="item in resultItems"
+              :key="item.id"
+              :input-value="scoring.selectedResultId.value === item.id"
+              color="primary"
+              @click="scoring.selectResult(item.id)"
+            >
+              <v-list-item-content>
+                <v-list-item-title>{{ item.title }}</v-list-item-title>
+                <v-list-item-subtitle>
+                  {{ item.when }} · F1 {{ item.f1 }} · {{ item.sequences }} sequence{{ item.sequences === 1 ? '' : 's' }}
+                </v-list-item-subtitle>
+              </v-list-item-content>
+              <v-list-item-action>
+                <v-btn
+                  icon
+                  x-small
+                  @click.stop="removeResult(item.id)"
+                >
+                  <v-icon small>
+                    mdi-delete-outline
+                  </v-icon>
+                </v-btn>
+              </v-list-item-action>
+            </v-list-item>
+          </v-list>
+        </v-card>
+      </v-col>
+
+      <v-col
+        cols="12"
+        lg="7"
+        xl="8"
+      >
+        <v-card
+          outlined
+          class="results-card"
+        >
+          <template v-if="scoring.result.value">
+            <div class="d-flex align-center px-3 pt-2">
+              <div>
+                <div class="text-subtitle-1">
+                  {{ scoring.result.value.title }}
+                </div>
+                <div class="text-caption grey--text">
+                  {{ new Date(scoring.result.value.created).toLocaleString() }}
+                </div>
+              </div>
+              <v-spacer />
+              <v-menu offset-y>
+                <template #activator="{ on }">
+                  <v-btn
+                    small
+                    text
+                    :loading="exporting"
+                    v-on="on"
+                  >
+                    <v-icon
+                      small
+                      left
+                    >
+                      mdi-download
+                    </v-icon>
+                    Export
+                  </v-btn>
+                </template>
+                <v-list dense>
+                  <v-list-item @click="exportAs('json')">
+                    <v-list-item-title>JSON (metrics, matches, setup)</v-list-item-title>
+                  </v-list-item>
+                  <v-list-item @click="exportAs('csv')">
+                    <v-list-item-title>CSV (summary and per-class tables)</v-list-item-title>
+                  </v-list-item>
+                  <v-list-item @click="exportAs('pdf')">
+                    <v-list-item-title>PDF report</v-list-item-title>
+                  </v-list-item>
+                </v-list>
+              </v-menu>
+              <v-tooltip bottom>
+                <template #activator="{ on }">
+                  <v-btn
+                    small
+                    text
+                    v-on="on"
+                    @click="scoring.useResultSetup()"
+                  >
+                    <v-icon
+                      small
+                      left
+                    >
+                      mdi-restore
+                    </v-icon>
+                    Reuse setup
+                  </v-btn>
+                </template>
+                <span>Load this run's sequences and parameters into the form</span>
+              </v-tooltip>
+            </div>
+            <v-tabs
+              v-model="tab"
+              height="32"
+              class="result-tabs"
+            >
+              <v-tab
+                v-for="t in tabs"
+                :key="t.key"
+                :href="`#${t.key}`"
+              >
+                {{ t.text }}
+              </v-tab>
+            </v-tabs>
+            <div class="results-body">
+              <ScoringSummary v-if="tab === 'summary'" />
+              <ScoringClassTable v-else-if="tab === 'classes'" />
+              <ScoringConfusion
+                v-else-if="tab === 'confusion'"
+                @filter="onConfusionFilter"
+              />
+              <ScoringCurves v-else-if="tab === 'curves'" />
+              <ScoringSweep v-else-if="tab === 'sweep'" />
+              <ScoringErrors
+                v-else-if="tab === 'errors'"
+                :filter="errorFilter"
+                @open-viewer="openViewer"
+              />
+            </div>
+          </template>
+          <v-card-text
+            v-else
+            class="text-body-2 grey--text"
+          >
+            <div v-if="scoring.running.value">
+              Scoring is running; results appear here when the job finishes.
+            </div>
+            <div v-else>
+              Add the sequences to score, choose which annotations are computed and which are
+              truth for each, and press Score. Pick an earlier run on the left to review it.
+            </div>
+          </v-card-text>
+        </v-card>
+      </v-col>
+    </v-row>
+    <ScoringParamsDialog v-model="showParams" />
+  </div>
+</template>
+
+<style lang="scss">
+/* Printing the report view: only the report itself goes to paper */
+@mixin report-only {
+  .v-app-bar,
+  .v-navigation-drawer,
+  .v-footer,
+  .scoring-report-toolbar {
+    display: none !important;
+  }
+
+  .v-main {
+    padding: 0 !important;
+  }
+
+  .v-application,
+  .v-application .v-main__wrap,
+  .scoring-page,
+  .report-mode {
+    background: white !important;
+  }
+
+  .scoring-page,
+  .report-mode {
+    padding: 0 !important;
+  }
+}
+
+@media print {
+  @include report-only;
+}
+
+html.scoring-print {
+  @include report-only;
+}
+</style>
+
+<style lang="scss" scoped>
+.run-row {
+  gap: 4px;
+}
+
+.report-mode {
+  background: white;
+  padding: 8px;
+  border-radius: 4px;
+}
+
+.result-list {
+  max-height: 50vh;
+  overflow-y: auto;
+}
+
+.results-card {
+  min-height: 60vh;
+}
+
+.result-tabs {
+  border-bottom: 1px solid #444;
+}
+
+.results-body {
+  padding: 8px 0;
+}
+</style>
diff --git a/client/dive-common/components/Scoring/ScoringPairsTable.vue b/client/dive-common/components/Scoring/ScoringPairsTable.vue
new file mode 100644
index 000000000..8954a720e
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringPairsTable.vue
@@ -0,0 +1,184 @@
+<script lang="ts">
+import { computed, defineComponent, ref } from 'vue';
+import { useApi } from 'dive-common/apispec';
+import { useScoring } from 'dive-common/use/useScoring';
+import ScoringSourceSelect from './ScoringSourceSelect.vue';
+
+export default defineComponent({
+  name: 'ScoringPairsTable',
+  components: { ScoringSourceSelect },
+  setup(_, { emit }) {
+    const api = useApi();
+    const scoring = useScoring();
+    const toAdd = ref<string | null>(null);
+    const picking = ref(false);
+
+    const usePicker = computed(() => typeof api.pickScoringDataset === 'function');
+
+    const addable = computed(() => {
+      const used = new Set(scoring.pairs.value.map((p) => p.computed.datasetId));
+      return scoring.datasets.value
+        .filter((d) => !used.has(d.id))
+        .map((d) => ({ value: d.id, text: d.name }));
+    });
+
+    async function add(id: string | null) {
+      if (!id) return;
+      await scoring.addDataset(id);
+      toAdd.value = null;
+    }
+
+    async function openPicker() {
+      if (!api.pickScoringDataset || picking.value) return;
+      picking.value = true;
+      try {
+        const used = scoring.pairs.value.map((p) => p.computed.datasetId);
+        const picked = await api.pickScoringDataset(used);
+        if (picked) await scoring.addDataset(picked.id, picked);
+      } finally {
+        picking.value = false;
+      }
+    }
+
+    return {
+      scoring,
+      toAdd,
+      addable,
+      add,
+      usePicker,
+      picking,
+      openPicker,
+      open: (id: string) => emit('open-viewer', id),
+    };
+  },
+});
+</script>
+
+<template>
+  <div>
+    <div class="d-flex align-center mb-2 flex-wrap">
+      <v-btn
+        v-if="usePicker"
+        small
+        outlined
+        :loading="picking"
+        @click="openPicker"
+      >
+        <v-icon
+          small
+          left
+        >
+          mdi-plus
+        </v-icon>
+        Add sequence
+      </v-btn>
+      <v-autocomplete
+        v-else
+        v-model="toAdd"
+        :items="addable"
+        label="Add a sequence"
+        dense
+        outlined
+        hide-details
+        clearable
+        class="add-select"
+        @change="add"
+      />
+      <span class="text-caption grey--text ml-3 hidden-md-and-down">
+        Each sequence is scored against its own truth; metrics are pooled.
+      </span>
+    </div>
+    <div
+      v-if="scoring.pairs.value.length === 0"
+      class="text-caption grey--text py-2"
+    >
+      No sequences yet. Add one above, or select datasets in the library and choose Score.
+    </div>
+    <v-simple-table
+      v-else
+      dense
+      class="pairs-table"
+    >
+      <thead>
+        <tr>
+          <th>Sequence</th>
+          <th>Computed annotations</th>
+          <th />
+          <th>Ground truth</th>
+          <th />
+        </tr>
+      </thead>
+      <tbody>
+        <tr
+          v-for="(pair, i) in scoring.pairs.value"
+          :key="pair.computed.datasetId"
+        >
+          <td class="sequence-cell">
+            <a @click="open(pair.computed.datasetId)">{{ scoring.datasetName(pair.computed.datasetId) }}</a>
+          </td>
+          <td>
+            <ScoringSourceSelect
+              :source="pair.computed"
+              :media-dataset-id="pair.computed.datasetId"
+              title="Computed annotations"
+              @update:source="scoring.setComputed(i, $event)"
+            />
+          </td>
+          <td class="px-0">
+            <v-tooltip bottom>
+              <template #activator="{ on }">
+                <v-btn
+                  icon
+                  x-small
+                  v-on="on"
+                  @click="scoring.swapPair(i)"
+                >
+                  <v-icon small>
+                    mdi-swap-horizontal
+                  </v-icon>
+                </v-btn>
+              </template>
+              <span>Swap computed and truth</span>
+            </v-tooltip>
+          </td>
+          <td>
+            <ScoringSourceSelect
+              :source="pair.truth"
+              :media-dataset-id="pair.computed.datasetId"
+              title="Ground truth annotations"
+              @update:source="scoring.setTruth(i, $event)"
+            />
+          </td>
+          <td class="px-0">
+            <v-btn
+              icon
+              x-small
+              @click="scoring.removePair(i)"
+            >
+              <v-icon small>
+                mdi-close
+              </v-icon>
+            </v-btn>
+          </td>
+        </tr>
+      </tbody>
+    </v-simple-table>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.add-select {
+  max-width: 360px;
+}
+
+.sequence-cell {
+  max-width: 160px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.pairs-table ::v-deep td {
+  padding: 4px 6px !important;
+}
+</style>
diff --git a/client/dive-common/components/Scoring/ScoringParamsDialog.vue b/client/dive-common/components/Scoring/ScoringParamsDialog.vue
new file mode 100644
index 000000000..ac23a3d5f
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringParamsDialog.vue
@@ -0,0 +1,228 @@
+<script lang="ts">
+import { defineComponent } from 'vue';
+import { useScoring } from 'dive-common/use/useScoring';
+import { FILTER_ESTIMATORS } from 'dive-common/scoring/metrics';
+
+export default defineComponent({
+  name: 'ScoringParamsDialog',
+  props: {
+    value: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  setup() {
+    const scoring = useScoring();
+    return {
+      params: scoring.params,
+      resetParams: scoring.resetParams,
+      FILTER_ESTIMATORS,
+      matchModes: [
+        { value: 'box', text: 'Bounding boxes' },
+        { value: 'polygon', text: 'Polygons where both sides have one' },
+      ],
+    };
+  },
+});
+</script>
+
+<template>
+  <v-dialog
+    :value="value"
+    max-width="720"
+    scrollable
+    @input="$emit('input', $event)"
+  >
+    <v-card outlined>
+      <v-card-title class="text-h6">
+        Scoring parameters
+      </v-card-title>
+      <v-card-text>
+        <div class="section-title">
+          Matching
+        </div>
+        <v-row dense>
+          <v-col cols="6">
+            <v-text-field
+              v-model.number="params.iouThreshold"
+              type="number"
+              min="0"
+              max="1"
+              step="0.05"
+              label="IoU threshold"
+              hint="Overlap needed for a computed object to match a truth object"
+              persistent-hint
+              dense
+              outlined
+            />
+          </v-col>
+          <v-col cols="6">
+            <v-text-field
+              v-model.number="params.confidenceThreshold"
+              type="number"
+              min="0"
+              max="1"
+              step="0.05"
+              label="Confidence threshold"
+              hint="Computed objects below this are ignored; 0 keeps everything for the curves"
+              persistent-hint
+              dense
+              outlined
+            />
+          </v-col>
+          <v-col cols="6">
+            <v-select
+              v-model="params.matchMode"
+              :items="matchModes"
+              label="Match on"
+              hint="Polygon matching scores segmentations; boxes are used for any pair without polygons"
+              persistent-hint
+              dense
+              outlined
+            />
+          </v-col>
+          <v-col cols="6">
+            <v-text-field
+              v-model.number="params.keypointThreshold"
+              type="number"
+              min="0"
+              max="1"
+              step="0.05"
+              label="Keypoint tolerance"
+              hint="Head/tail points within this fraction of the truth length count as correct"
+              persistent-hint
+              dense
+              outlined
+            />
+          </v-col>
+        </v-row>
+        <div class="section-title">
+          Classes
+        </div>
+        <v-row dense>
+          <v-col cols="4">
+            <v-switch
+              v-model="params.perClass"
+              label="Per class"
+              hint="Report every class separately (needed for per-class curves and filters)"
+              persistent-hint
+              dense
+            />
+          </v-col>
+          <v-col cols="4">
+            <v-switch
+              v-model="params.topClass"
+              label="Top class only"
+              hint="Offer each detection only to its highest scoring class"
+              persistent-hint
+              dense
+            />
+          </v-col>
+          <v-col cols="4">
+            <v-switch
+              v-model="params.auxConfidence"
+              label="Detection confidence"
+              hint="Rank on the detection confidence rather than the class score"
+              persistent-hint
+              dense
+            />
+          </v-col>
+          <v-col cols="6">
+            <v-text-field
+              v-model="params.defaultLabel"
+              label="Default class"
+              hint="Class reported for objects that carry none"
+              persistent-hint
+              dense
+              outlined
+            />
+          </v-col>
+          <v-col cols="12">
+            <v-textarea
+              v-model="params.labelSynonyms"
+              label="Class synonyms"
+              hint="One class per line as 'canonical: alias, alias', so differing vocabularies score together"
+              persistent-hint
+              rows="2"
+              dense
+              outlined
+            />
+          </v-col>
+        </v-row>
+        <div class="section-title">
+          Tracking and sweep
+        </div>
+        <v-row dense>
+          <v-col cols="4">
+            <v-switch
+              v-model="params.tracking"
+              label="Track metrics"
+              hint="MOTA, HOTA, IDF1 and the KWANT metrics"
+              persistent-hint
+              dense
+            />
+          </v-col>
+          <v-col cols="4">
+            <v-switch
+              v-model="params.sweep"
+              label="Sweep thresholds"
+              hint="Score at many confidence thresholds to find the best operating point"
+              persistent-hint
+              dense
+            />
+          </v-col>
+          <v-col cols="4">
+            <v-text-field
+              v-model.number="params.sweepInterval"
+              type="number"
+              min="2"
+              max="200"
+              step="1"
+              label="Sweep steps"
+              hint="Thresholds between 0 and 1; more steps take longer"
+              persistent-hint
+              dense
+              outlined
+              :disabled="!params.sweep"
+            />
+          </v-col>
+          <v-col cols="12">
+            <v-select
+              v-model="params.filterEstimator"
+              :items="FILTER_ESTIMATORS"
+              label="Recommended filter from the sweep"
+              dense
+              outlined
+              hide-details
+              :disabled="!params.sweep"
+            />
+          </v-col>
+        </v-row>
+      </v-card-text>
+      <v-card-actions>
+        <v-btn
+          text
+          @click="resetParams"
+        >
+          Reset to defaults
+        </v-btn>
+        <v-spacer />
+        <v-btn
+          color="primary"
+          @click="$emit('input', false)"
+        >
+          Done
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
+
+<style lang="scss" scoped>
+.section-title {
+  font-weight: bold;
+  color: #ccc;
+  border-bottom: 1px solid #444;
+  margin: 10px 0 6px;
+}
+</style>
diff --git a/client/dive-common/components/Scoring/ScoringReport.vue b/client/dive-common/components/Scoring/ScoringReport.vue
new file mode 100644
index 000000000..4ab78bead
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringReport.vue
@@ -0,0 +1,583 @@
+<script lang="ts">
+import { computed, defineComponent } from 'vue';
+import { useScoring } from 'dive-common/use/useScoring';
+import {
+  formatMetric, METRIC_GROUPS, METRIC_DEFINITIONS, PRCurve,
+} from 'dive-common/scoring/metrics';
+import ScoringHeatmap from './charts/ScoringHeatmap.vue';
+import ScoringLineChart from './charts/ScoringLineChart.vue';
+import type { ChartSeries } from './charts/chartTypes';
+
+const HEADLINE = ['precision', 'recall', 'f1_score', 'average_precision', 'mota', 'idf1', 'hota', 'mean_iou'];
+const PER_CLASS_COLUMNS = ['true_positives', 'false_positives', 'false_negatives', 'precision', 'recall', 'f1_score', 'average_precision', 'ap50'];
+const SWEEP_METRICS = ['f1_score', 'mota', 'idf1', 'hota'];
+const SWEEP_COLORS = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'];
+const MAX_ERROR_ROWS = 30;
+
+/** Print-oriented rendering of the loaded run, light on white, no interaction. */
+export default defineComponent({
+  name: 'ScoringReport',
+  components: { ScoringHeatmap, ScoringLineChart },
+  setup() {
+    const scoring = useScoring();
+    const result = computed(() => scoring.result.value);
+    const metrics = computed(() => scoring.metrics.value);
+    const values = computed(() => metrics.value?.values || {});
+
+    const headline = computed(() => HEADLINE
+      .filter((key) => key in values.value)
+      .map((key) => ({
+        key,
+        label: METRIC_DEFINITIONS[key]?.label || key,
+        value: formatMetric(values.value[key], METRIC_DEFINITIONS[key]?.format || 'ratio'),
+      })));
+
+    const groups = computed(() => METRIC_GROUPS
+      .filter((group) => !group.requires || (values.value[group.requires] || 0) > 0)
+      .map((group) => ({
+        name: group.name,
+        rows: group.metrics
+          .filter((m) => m.key in values.value)
+          .map((m) => ({ key: m.key, label: m.label, value: formatMetric(values.value[m.key], m.format) })),
+      }))
+      .filter((group) => group.rows.length > 0));
+
+    const paramRows = computed(() => Object.entries(result.value?.params || {})
+      .filter(([key, value]) => !(key === 'labelSynonyms' && !value))
+      .map(([key, value]) => ({ key, value: String(value) })));
+
+    const classRows = computed(() => Object.entries(metrics.value?.perClass || {})
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([name, m]) => ({
+        name,
+        cells: PER_CLASS_COLUMNS.map((key) => formatMetric(m[key], METRIC_DEFINITIONS[key]?.format || 'ratio')),
+      })));
+    const classColumns = PER_CLASS_COLUMNS.map((key) => METRIC_DEFINITIONS[key]?.label || key);
+
+    function prSeries(name: string, curve: PRCurve, color: string, dashed = false): ChartSeries {
+      return {
+        name,
+        color,
+        dashed,
+        points: curve.points.map((p) => ({ x: p.recall, y: p.precision, meta: { threshold: p.confidence } })),
+      };
+    }
+
+    const prSeriesList = computed<ChartSeries[]>(() => {
+      const m = metrics.value;
+      if (!m) return [];
+      const out: ChartSeries[] = [];
+      if (m.prCurve) out.push(prSeries('Overall', m.prCurve, '#333333', Object.keys(m.perClassPrCurves).length > 0));
+      Object.entries(m.perClassPrCurves).forEach(([name, curve]) => {
+        out.push(prSeries(name, curve, scoring.classColor(name)));
+      });
+      return out;
+    });
+
+    const rocSeries = computed<ChartSeries[]>(() => {
+      const roc = metrics.value?.rocCurve;
+      if (!roc) return [];
+      return [{
+        name: 'Overall',
+        color: '#333333',
+        points: roc.points.map((p) => ({ x: p.falseAlarmsPerFrame, y: p.truePositiveRate })),
+      }];
+    });
+
+    const apRows = computed(() => {
+      const m = metrics.value;
+      if (!m) return [];
+      const rows = [];
+      if (m.prCurve) {
+        rows.push({
+          name: 'Overall', ap: m.prCurve.averagePrecision, maxF1: m.prCurve.maxF1, at: m.prCurve.bestThreshold,
+        });
+      }
+      Object.entries(m.perClassPrCurves).forEach(([name, c]) => {
+        rows.push({
+          name, ap: c.averagePrecision, maxF1: c.maxF1, at: c.bestThreshold,
+        });
+      });
+      return rows;
+    });
+
+    const sweep = computed(() => metrics.value?.sweep || null);
+    const sweepCurveName = computed(() => {
+      const names = Object.keys(sweep.value?.curves || {});
+      return names.find((n) => n === 'overall' || n === 'default') || names[0] || '';
+    });
+    const sweepSeries = computed<ChartSeries[]>(() => {
+      const curve = sweep.value?.curves[sweepCurveName.value];
+      if (!curve) return [];
+      return SWEEP_METRICS
+        .filter((key) => curve.metrics[key])
+        .map((key, i) => ({
+          name: METRIC_DEFINITIONS[key]?.label || key,
+          color: SWEEP_COLORS[i % SWEEP_COLORS.length],
+          points: curve.thresholds.map((t, j) => ({ x: t, y: curve.metrics[key][j] ?? 0 })),
+        }));
+    });
+    const sweepRows = computed(() => Object.entries(sweep.value?.curves || {}).map(([name, c]) => ({
+      name,
+      idf1: c.best.idf1,
+      idf1Thresh: c.best.idf1Thresh,
+      mota: c.best.mota,
+      motaThresh: c.best.motaThresh,
+    })));
+
+    const counts = computed(() => {
+      const out = { tp: 0, fp: 0, fn: 0 };
+      scoring.matches.value.forEach((m) => { out[m.status] += 1; });
+      return out;
+    });
+    const errorRows = computed(() => scoring.matches.value
+      .filter((m) => m.status !== 'tp')
+      .sort((a, b) => (a.status === b.status ? b.confidence - a.confidence : a.status.localeCompare(b.status)))
+      .slice(0, MAX_ERROR_ROWS)
+      .map((m) => ({
+        sequence: scoring.datasetName(result.value?.pairs[m.sequence]?.computed.datasetId || ''),
+        frame: m.frame,
+        status: m.status === 'fp' ? 'False positive' : 'Missed',
+        id: m.status === 'fp' ? m.computedId : m.gtId,
+        klass: m.status === 'fp' ? m.computedClass : m.gtClass,
+        confidence: m.status === 'fp' ? m.confidence.toFixed(3) : '',
+      })));
+
+    return {
+      scoring,
+      result,
+      metrics,
+      headline,
+      groups,
+      paramRows,
+      classRows,
+      classColumns,
+      prSeriesList,
+      rocSeries,
+      apRows,
+      sweep,
+      sweepCurveName,
+      sweepSeries,
+      sweepRows,
+      counts,
+      errorRows,
+      multiSequence: computed(() => (result.value?.pairs.length || 0) > 1),
+      fmt: (v: number | null) => (v === null || v === undefined ? 'n/a' : v.toFixed(3)),
+    };
+  },
+});
+</script>
+
+<template>
+  <div
+    v-if="result && metrics"
+    class="scoring-report"
+  >
+    <h1>Scoring report</h1>
+    <div class="subtitle">
+      {{ result.title }} · {{ new Date(result.created).toLocaleString() }}
+    </div>
+
+    <section>
+      <h2>Sequences</h2>
+      <table class="report-table">
+        <thead>
+          <tr><th>#</th><th>Computed annotations</th><th>Ground truth</th></tr>
+        </thead>
+        <tbody>
+          <tr
+            v-for="(pair, i) in result.pairs"
+            :key="i"
+          >
+            <td>{{ i + 1 }}</td>
+            <td>{{ scoring.sourceLabel(pair.computed) }}</td>
+            <td>{{ scoring.sourceLabel(pair.truth) }}</td>
+          </tr>
+        </tbody>
+      </table>
+      <h2>Parameters</h2>
+      <div class="param-grid">
+        <span
+          v-for="p in paramRows"
+          :key="p.key"
+        ><b>{{ p.key }}</b>: {{ p.value }}</span>
+      </div>
+    </section>
+
+    <section>
+      <h2>Summary</h2>
+      <div class="headline-row">
+        <div
+          v-for="h in headline"
+          :key="h.key"
+          class="headline-card"
+        >
+          <div class="headline-value">
+            {{ h.value }}
+          </div>
+          <div class="headline-label">
+            {{ h.label }}
+          </div>
+        </div>
+      </div>
+      <div class="group-row">
+        <table
+          v-for="group in groups"
+          :key="group.name"
+          class="report-table compact"
+        >
+          <thead>
+            <tr>
+              <th colspan="2">
+                {{ group.name }}
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr
+              v-for="r in group.rows"
+              :key="r.key"
+            >
+              <td>{{ r.label }}</td>
+              <td class="num">
+                {{ r.value }}
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+    </section>
+
+    <section v-if="classRows.length">
+      <h2>Per class</h2>
+      <table class="report-table">
+        <thead>
+          <tr>
+            <th>Class</th>
+            <th
+              v-for="c in classColumns"
+              :key="c"
+              class="num"
+            >
+              {{ c }}
+            </th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr
+            v-for="r in classRows"
+            :key="r.name"
+          >
+            <td>{{ r.name }}</td>
+            <td
+              v-for="(cell, i) in r.cells"
+              :key="i"
+              class="num"
+            >
+              {{ cell }}
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </section>
+
+    <section
+      v-if="metrics.confusionMatrix"
+      class="keep-together"
+    >
+      <h2>Confusion matrix</h2>
+      <ScoringHeatmap
+        :row-labels="metrics.confusionMatrix.classNames"
+        :col-labels="metrics.confusionMatrix.classNames"
+        :counts="metrics.confusionMatrix.matrix"
+        :fractions="metrics.confusionMatrix.normalized"
+        :background-index="metrics.confusionMatrix.classNames.indexOf('background')"
+        light
+      />
+      <div class="note">
+        Rows are truth classes, columns are computed classes; the background row holds
+        false positives and the background column missed objects.
+      </div>
+    </section>
+
+    <section
+      v-if="prSeriesList.length"
+      class="keep-together"
+    >
+      <h2>Precision / recall</h2>
+      <div class="chart-row">
+        <div class="chart-box">
+          <ScoringLineChart
+            :series="prSeriesList"
+            x-label="Recall"
+            y-label="Precision"
+            :x-domain="[0, 1]"
+            :y-domain="[0, 1.02]"
+            :height="260"
+            light
+          />
+        </div>
+        <div
+          v-if="rocSeries.length"
+          class="chart-box"
+        >
+          <ScoringLineChart
+            :series="rocSeries"
+            x-label="False alarms per frame"
+            y-label="Probability of detection"
+            :y-domain="[0, 1.02]"
+            :height="260"
+            light
+          />
+        </div>
+      </div>
+      <table class="report-table compact">
+        <thead>
+          <tr>
+            <th>Curve</th><th class="num">
+              AP
+            </th><th class="num">
+              Max F1
+            </th><th class="num">
+              at threshold
+            </th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr
+            v-for="r in apRows"
+            :key="r.name"
+          >
+            <td>{{ r.name }}</td>
+            <td class="num">
+              {{ fmt(r.ap) }}
+            </td>
+            <td class="num">
+              {{ fmt(r.maxF1) }}
+            </td>
+            <td class="num">
+              {{ fmt(r.at) }}
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </section>
+
+    <section
+      v-if="sweep"
+      class="keep-together"
+    >
+      <h2>Threshold sweep ({{ sweepCurveName }})</h2>
+      <div class="chart-box">
+        <ScoringLineChart
+          :series="sweepSeries"
+          x-label="Confidence threshold"
+          y-label="Score"
+          :x-domain="[0, 1]"
+          :height="240"
+          light
+        />
+      </div>
+      <table class="report-table compact">
+        <thead>
+          <tr>
+            <th>Curve</th><th class="num">
+              Best IDF1
+            </th><th class="num">
+              at
+            </th><th class="num">
+              Best MOTA
+            </th><th class="num">
+              at
+            </th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr
+            v-for="r in sweepRows"
+            :key="r.name"
+          >
+            <td>{{ r.name }}</td>
+            <td class="num">
+              {{ fmt(r.idf1) }}
+            </td>
+            <td class="num">
+              {{ fmt(r.idf1Thresh) }}
+            </td>
+            <td class="num">
+              {{ fmt(r.mota) }}
+            </td>
+            <td class="num">
+              {{ fmt(r.motaThresh) }}
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </section>
+
+    <section v-if="counts.tp + counts.fp + counts.fn > 0">
+      <h2>Errors</h2>
+      <div class="note">
+        {{ counts.tp }} matched · {{ counts.fp }} false positives · {{ counts.fn }} missed.
+        Highest-confidence false positives and the missed objects, up to {{ errorRows.length }} rows.
+      </div>
+      <table class="report-table compact">
+        <thead>
+          <tr>
+            <th v-if="multiSequence">
+              Sequence
+            </th>
+            <th class="num">
+              Frame
+            </th><th>Status</th><th class="num">
+              Id
+            </th><th>Class</th><th class="num">
+              Confidence
+            </th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr
+            v-for="(r, i) in errorRows"
+            :key="i"
+          >
+            <td v-if="multiSequence">
+              {{ r.sequence }}
+            </td>
+            <td class="num">
+              {{ r.frame }}
+            </td>
+            <td>{{ r.status }}</td>
+            <td class="num">
+              {{ r.id }}
+            </td>
+            <td>{{ r.klass }}</td>
+            <td class="num">
+              {{ r.confidence }}
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </section>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.scoring-report {
+  background: white;
+  color: #111;
+  padding: 24px 32px;
+  max-width: 1000px;
+  font-size: 12px;
+
+  h1 {
+    font-size: 22px;
+    margin: 0;
+  }
+
+  h2 {
+    font-size: 15px;
+    margin: 18px 0 6px;
+    border-bottom: 1px solid #999;
+  }
+
+  .subtitle {
+    color: #444;
+    margin-bottom: 8px;
+  }
+
+  section {
+    margin-bottom: 12px;
+  }
+
+  .keep-together {
+    break-inside: avoid;
+  }
+
+  .note {
+    color: #444;
+    margin: 4px 0;
+  }
+
+  .param-grid {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 2px 16px;
+  }
+
+  .headline-row {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+    margin-bottom: 8px;
+  }
+
+  .headline-card {
+    border: 1px solid #bbb;
+    border-radius: 4px;
+    padding: 4px 12px;
+    min-width: 80px;
+    text-align: center;
+
+    .headline-value {
+      font-size: 17px;
+      font-weight: bold;
+    }
+
+    .headline-label {
+      font-size: 10px;
+      color: #555;
+    }
+  }
+
+  .group-row {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 12px;
+    align-items: flex-start;
+
+    .report-table {
+      flex: 0 0 auto;
+      width: 230px;
+    }
+  }
+
+  .report-table {
+    border-collapse: collapse;
+    margin-bottom: 6px;
+
+    th,
+    td {
+      border: 1px solid #ccc;
+      padding: 2px 8px;
+      text-align: left;
+    }
+
+    th {
+      background: #eee;
+    }
+
+    .num {
+      text-align: right;
+      font-variant-numeric: tabular-nums;
+    }
+
+    &.compact td,
+    &.compact th {
+      padding: 1px 8px;
+    }
+  }
+
+  .chart-row {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 12px;
+  }
+
+  .chart-box {
+    flex: 1 1 380px;
+    min-width: 320px;
+    max-width: 480px;
+  }
+}
+</style>
diff --git a/client/dive-common/components/Scoring/ScoringSourceDialog.vue b/client/dive-common/components/Scoring/ScoringSourceDialog.vue
new file mode 100644
index 000000000..4bb1f8c63
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringSourceDialog.vue
@@ -0,0 +1,255 @@
+<script lang="ts">
+import {
+  computed, defineComponent, PropType, ref, watch,
+} from 'vue';
+import { useApi } from 'dive-common/apispec';
+import { useScoring } from 'dive-common/use/useScoring';
+import type { ScoringSource, ScoringSourceOptions } from 'dive-common/scoring/types';
+
+export default defineComponent({
+  name: 'ScoringSourceDialog',
+  props: {
+    value: {
+      type: Boolean,
+      default: false,
+    },
+    title: {
+      type: String,
+      default: 'Annotation source',
+    },
+    source: {
+      type: Object as PropType<ScoringSource>,
+      required: true,
+    },
+  },
+  setup(props, { emit }) {
+    const scoring = useScoring();
+    const { openFromDisk } = useApi();
+
+    const datasetId = ref(props.source.datasetId);
+    const kind = ref<'current' | 'set' | 'revision' | 'file'>('current');
+    const set = ref<string>(props.source.set || '');
+    const revision = ref<number | null>(props.source.revision ?? null);
+    const file = ref<string>(props.source.file || '');
+    const options = ref<ScoringSourceOptions>({ sets: [], revisions: [], files: [] });
+    const loadingOptions = ref(false);
+    const fileMessage = ref<string | null>(null);
+
+    function syncFromSource() {
+      datasetId.value = props.source.datasetId;
+      set.value = props.source.set || '';
+      revision.value = props.source.revision ?? null;
+      file.value = props.source.file || '';
+      if (props.source.file) kind.value = 'file';
+      else if (props.source.revision !== undefined) kind.value = 'revision';
+      else if (props.source.set) kind.value = 'set';
+      else kind.value = 'current';
+    }
+
+    async function loadOptions() {
+      loadingOptions.value = true;
+      options.value = await scoring.sourceOptions(datasetId.value);
+      loadingOptions.value = false;
+    }
+
+    watch(() => props.value, (open) => {
+      if (open) {
+        syncFromSource();
+        scoring.refreshDatasets();
+        loadOptions();
+      }
+    });
+    watch(datasetId, (next, previous) => {
+      if (next === previous) return;
+      set.value = '';
+      revision.value = null;
+      file.value = '';
+      kind.value = 'current';
+      loadOptions();
+    });
+
+    const datasetItems = computed(() => {
+      const items = scoring.datasets.value.map((d) => ({ value: d.id, text: d.name }));
+      if (!items.some((i) => i.value === props.source.datasetId)) {
+        items.unshift({ value: props.source.datasetId, text: scoring.datasetName(props.source.datasetId) });
+      }
+      return items;
+    });
+
+    const kinds = computed(() => {
+      const list = [{ value: 'current', text: 'Current annotations' }];
+      if (options.value.sets.length) list.push({ value: 'set', text: 'Annotation set' });
+      if (options.value.revisions.length) list.push({ value: 'revision', text: 'Earlier revision' });
+      if (options.value.files.length || options.value.allowFilePaths) list.push({ value: 'file', text: 'Annotation file' });
+      return list;
+    });
+
+    const revisionItems = computed(() => options.value.revisions.map((r) => ({
+      value: r.revision,
+      text: `#${r.revision} · ${new Date(r.created).toLocaleString()} · ${r.description}${r.author ? ` (${r.author})` : ''}${r.set ? ` [${r.set}]` : ''}`,
+    })));
+
+    const fileItems = computed(() => options.value.files.map((f) => ({
+      value: f.path,
+      text: `${f.name} · ${new Date(f.modified).toLocaleString()}`,
+    })));
+
+    async function browse() {
+      fileMessage.value = null;
+      const picked = await openFromDisk('annotation');
+      if (picked.canceled || !picked.filePaths.length) return;
+      if (picked.fileList && picked.fileList.length) {
+        fileMessage.value = 'Browsing for files is only available on desktop; import the file as an annotation set instead.';
+        return;
+      }
+      [file.value] = picked.filePaths;
+    }
+
+    const valid = computed(() => {
+      if (kind.value === 'set') return !!set.value;
+      if (kind.value === 'revision') return revision.value !== null;
+      if (kind.value === 'file') return !!file.value;
+      return true;
+    });
+
+    function apply() {
+      const next: ScoringSource = { datasetId: datasetId.value };
+      if (kind.value === 'set') next.set = set.value;
+      if (kind.value === 'revision' && revision.value !== null) next.revision = revision.value;
+      if (kind.value === 'file') next.file = file.value;
+      emit('update:source', next);
+      emit('input', false);
+    }
+
+    return {
+      datasetId,
+      kind,
+      kinds,
+      set,
+      revision,
+      file,
+      options,
+      loadingOptions,
+      datasetItems,
+      revisionItems,
+      fileItems,
+      fileMessage,
+      browse,
+      valid,
+      apply,
+      canBrowse: computed(() => !!options.value.allowFilePaths),
+    };
+  },
+});
+</script>
+
+<template>
+  <v-dialog
+    :value="value"
+    max-width="560"
+    @input="$emit('input', $event)"
+  >
+    <v-card outlined>
+      <v-card-title class="text-h6">
+        {{ title }}
+      </v-card-title>
+      <v-card-text>
+        <v-autocomplete
+          v-model="datasetId"
+          :items="datasetItems"
+          label="Dataset"
+          dense
+          outlined
+          hide-details
+          class="mb-3"
+        />
+        <div class="text-caption grey--text mb-3">
+          Any dataset holding annotations of the same footage can stand in for either
+          side: another import of the same images or video, for example.
+        </div>
+        <v-select
+          v-model="kind"
+          :items="kinds"
+          label="Annotations"
+          dense
+          outlined
+          hide-details
+          :loading="loadingOptions"
+          class="mb-3"
+        />
+        <v-select
+          v-if="kind === 'set'"
+          v-model="set"
+          :items="options.sets"
+          label="Annotation set"
+          dense
+          outlined
+          hide-details
+          class="mb-3"
+        />
+        <v-select
+          v-if="kind === 'revision'"
+          v-model="revision"
+          :items="revisionItems"
+          label="Revision"
+          dense
+          outlined
+          hide-details
+          class="mb-3"
+        />
+        <template v-if="kind === 'file'">
+          <v-select
+            v-if="fileItems.length"
+            v-model="file"
+            :items="fileItems"
+            label="Earlier annotations of this dataset"
+            dense
+            outlined
+            hide-details
+            class="mb-2"
+          />
+          <div class="d-flex align-center">
+            <v-text-field
+              v-model="file"
+              label="File path"
+              dense
+              outlined
+              hide-details
+            />
+            <v-btn
+              v-if="canBrowse"
+              small
+              outlined
+              class="ml-2"
+              @click="browse"
+            >
+              Browse
+            </v-btn>
+          </div>
+          <div
+            v-if="fileMessage"
+            class="text-caption warning--text mt-1"
+          >
+            {{ fileMessage }}
+          </div>
+        </template>
+      </v-card-text>
+      <v-card-actions>
+        <v-spacer />
+        <v-btn
+          text
+          @click="$emit('input', false)"
+        >
+          Cancel
+        </v-btn>
+        <v-btn
+          color="primary"
+          :disabled="!valid"
+          @click="apply"
+        >
+          Use
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
diff --git a/client/dive-common/components/Scoring/ScoringSourceSelect.vue b/client/dive-common/components/Scoring/ScoringSourceSelect.vue
new file mode 100644
index 000000000..fe950f1f8
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringSourceSelect.vue
@@ -0,0 +1,140 @@
+<script lang="ts">
+import {
+  computed, defineComponent, onMounted, PropType, ref, watch,
+} from 'vue';
+import { useApi } from 'dive-common/apispec';
+import { useScoring } from 'dive-common/use/useScoring';
+import type { ScoringSource, ScoringSourceOptions } from 'dive-common/scoring/types';
+import ScoringSourceDialog from './ScoringSourceDialog.vue';
+
+const BROWSE = '__browse';
+const OTHER = '__other';
+const FOREIGN = '__foreign';
+
+function keyOf(source: ScoringSource, mediaDatasetId: string): string {
+  if (source.datasetId !== mediaDatasetId) return FOREIGN;
+  if (source.file) return `file:${source.file}`;
+  if (source.revision !== undefined) return `rev:${source.revision}`;
+  if (source.set) return `set:${source.set}`;
+  return 'current';
+}
+
+/**
+ * One cell of the sequence table: the annotations of the row's dataset that
+ * play this side, or, through the dialog, annotations from another dataset.
+ */
+export default defineComponent({
+  name: 'ScoringSourceSelect',
+  components: { ScoringSourceDialog },
+  props: {
+    source: {
+      type: Object as PropType<ScoringSource>,
+      required: true,
+    },
+    mediaDatasetId: {
+      type: String,
+      required: true,
+    },
+    title: {
+      type: String,
+      default: 'Annotation source',
+    },
+  },
+  setup(props, { emit }) {
+    const scoring = useScoring();
+    const { openFromDisk } = useApi();
+    const options = ref<ScoringSourceOptions>({ sets: [], revisions: [], files: [] });
+    const dialog = ref(false);
+    const selected = ref(keyOf(props.source, props.mediaDatasetId));
+
+    async function load() {
+      options.value = await scoring.sourceOptions(props.mediaDatasetId);
+    }
+    onMounted(load);
+    watch(() => props.mediaDatasetId, load);
+    watch(() => props.source, (s) => { selected.value = keyOf(s, props.mediaDatasetId); }, { deep: true });
+
+    const items = computed(() => {
+      const list: { value: string; text: string; divider?: boolean }[] = [
+        { value: 'current', text: 'Current annotations' },
+      ];
+      options.value.sets.forEach((s) => list.push({ value: `set:${s}`, text: `Set: ${s}` }));
+      options.value.revisions.forEach((r) => list.push({
+        value: `rev:${r.revision}`,
+        text: `Revision #${r.revision} · ${r.description || new Date(r.created).toLocaleString()}`,
+      }));
+      options.value.files.forEach((f) => list.push({ value: `file:${f.path}`, text: `Earlier: ${f.name}` }));
+      if (props.source.datasetId !== props.mediaDatasetId) {
+        list.push({ value: FOREIGN, text: scoring.sourceLabel(props.source) });
+      } else if (props.source.file && !options.value.files.some((f) => f.path === props.source.file)) {
+        list.push({ value: `file:${props.source.file}`, text: `File: ${props.source.file.split(/[\\/]/).pop()}` });
+      }
+      if (options.value.allowFilePaths) list.push({ value: BROWSE, text: 'Browse for a file…' });
+      list.push({ value: OTHER, text: 'Another dataset…' });
+      return list;
+    });
+
+    async function onChange(key: string) {
+      if (key === OTHER) {
+        selected.value = keyOf(props.source, props.mediaDatasetId);
+        dialog.value = true;
+        return;
+      }
+      if (key === BROWSE) {
+        selected.value = keyOf(props.source, props.mediaDatasetId);
+        const picked = await openFromDisk('annotation');
+        if (!picked.canceled && picked.filePaths.length && !(picked.fileList && picked.fileList.length)) {
+          emit('update:source', { datasetId: props.mediaDatasetId, file: picked.filePaths[0] });
+        }
+        return;
+      }
+      if (key === FOREIGN) return;
+      const next: ScoringSource = { datasetId: props.mediaDatasetId };
+      if (key.startsWith('set:')) next.set = key.slice(4);
+      else if (key.startsWith('rev:')) next.revision = Number(key.slice(4));
+      else if (key.startsWith('file:')) next.file = key.slice(5);
+      emit('update:source', next);
+    }
+
+    return {
+      items,
+      selected,
+      dialog,
+      onChange,
+    };
+  },
+});
+</script>
+
+<template>
+  <div>
+    <v-select
+      :value="selected"
+      :items="items"
+      dense
+      outlined
+      hide-details
+      class="source-select"
+      @change="onChange"
+    />
+    <ScoringSourceDialog
+      v-model="dialog"
+      :title="title"
+      :source="source"
+      @update:source="$emit('update:source', $event)"
+    />
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.source-select {
+  font-size: 13px;
+  min-width: 170px;
+}
+
+.source-select ::v-deep .v-select__selection {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+</style>
diff --git a/client/dive-common/components/Scoring/ScoringSummary.vue b/client/dive-common/components/Scoring/ScoringSummary.vue
new file mode 100644
index 000000000..24b7ae73d
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringSummary.vue
@@ -0,0 +1,212 @@
+<script lang="ts">
+import { computed, defineComponent, ref } from 'vue';
+import { useScoring } from 'dive-common/use/useScoring';
+import { formatMetric, METRIC_GROUPS } from 'dive-common/scoring/metrics';
+
+const HEADLINE = ['precision', 'recall', 'f1_score', 'average_precision', 'mota', 'idf1', 'hota', 'mean_iou'];
+
+export default defineComponent({
+  name: 'ScoringSummary',
+  setup() {
+    const scoring = useScoring();
+    const showText = ref(false);
+
+    const values = computed(() => scoring.metrics.value?.values || {});
+
+    const headline = computed(() => HEADLINE
+      .filter((key) => key in values.value)
+      .map((key) => {
+        const def = METRIC_GROUPS.flatMap((g) => g.metrics).find((m) => m.key === key);
+        return {
+          key,
+          label: def?.label || key,
+          description: def?.description || '',
+          value: formatMetric(values.value[key], def?.format || 'ratio'),
+        };
+      }));
+
+    const groups = computed(() => METRIC_GROUPS
+      .filter((group) => !group.requires || (values.value[group.requires] || 0) > 0)
+      .map((group) => ({
+        name: group.name,
+        rows: group.metrics
+          .filter((m) => m.key in values.value)
+          .map((m) => ({
+            key: m.key,
+            label: m.label,
+            description: m.description,
+            value: formatMetric(values.value[m.key], m.format),
+          })),
+      }))
+      .filter((group) => group.rows.length > 0));
+
+    const config = computed(() => scoring.metrics.value?.config || null);
+    const result = computed(() => scoring.result.value);
+
+    return {
+      scoring,
+      headline,
+      groups,
+      config,
+      result,
+      showText,
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="scoring-summary px-2">
+    <div class="d-flex flex-wrap headline-row">
+      <v-tooltip
+        v-for="item in headline"
+        :key="item.key"
+        bottom
+        open-delay="300"
+      >
+        <template #activator="{ on }">
+          <div
+            class="headline-card"
+            v-on="on"
+          >
+            <div class="headline-value">
+              {{ item.value }}
+            </div>
+            <div class="headline-label">
+              {{ item.label }}
+            </div>
+          </div>
+        </template>
+        <span>{{ item.description }}</span>
+      </v-tooltip>
+    </div>
+    <div
+      v-if="result"
+      class="text-caption grey--text px-1 pb-1"
+    >
+      <div
+        v-for="(pair, i) in result.pairs"
+        :key="i"
+      >
+        {{ scoring.sourceLabel(pair.computed) }} scored against {{ scoring.sourceLabel(pair.truth) }}
+      </div>
+      <span v-if="config">
+        IoU ≥ {{ config.iouThreshold }} · conf ≥ {{ config.confidenceThreshold }} · {{ config.matchMode }} matching
+      </span>
+    </div>
+    <div class="d-flex flex-wrap group-row">
+      <div
+        v-for="group in groups"
+        :key="group.name"
+        class="metric-group"
+      >
+        <div class="group-title">
+          {{ group.name }}
+        </div>
+        <table class="metric-table">
+          <tbody>
+            <tr
+              v-for="row in group.rows"
+              :key="row.key"
+            >
+              <td class="metric-label">
+                <v-tooltip
+                  bottom
+                  open-delay="400"
+                >
+                  <template #activator="{ on }">
+                    <span v-on="on">{{ row.label }}</span>
+                  </template>
+                  <span>{{ row.description }}</span>
+                </v-tooltip>
+              </td>
+              <td class="metric-value">
+                {{ row.value }}
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+    </div>
+    <div
+      v-if="result && result.summaryText"
+      class="px-1"
+    >
+      <a
+        class="text-caption"
+        @click="showText = !showText"
+      >{{ showText ? 'Hide' : 'Show' }} tool output</a>
+      <pre
+        v-if="showText"
+        class="summary-text"
+      >{{ result.summaryText }}</pre>
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.headline-row {
+  gap: 6px;
+  padding: 4px 0;
+}
+
+.headline-card {
+  background: #272727;
+  border: 1px solid #444;
+  border-radius: 4px;
+  padding: 4px 12px;
+  min-width: 84px;
+  text-align: center;
+
+  .headline-value {
+    font-size: 18px;
+    font-weight: bold;
+  }
+
+  .headline-label {
+    font-size: 11px;
+    color: #aaa;
+  }
+}
+
+.group-row {
+  gap: 12px;
+  align-items: flex-start;
+}
+
+.metric-group {
+  min-width: 190px;
+
+  .group-title {
+    font-weight: bold;
+    font-size: 12px;
+    color: #ccc;
+    border-bottom: 1px solid #444;
+    margin-bottom: 2px;
+  }
+}
+
+.metric-table {
+  border-collapse: collapse;
+  font-size: 12px;
+  width: 100%;
+
+  .metric-label {
+    color: #bbb;
+    padding-right: 10px;
+  }
+
+  .metric-value {
+    text-align: right;
+    font-variant-numeric: tabular-nums;
+  }
+}
+
+.summary-text {
+  font-size: 11px;
+  max-height: 300px;
+  overflow: auto;
+  background: #111;
+  padding: 4px;
+}
+</style>
diff --git a/client/dive-common/components/Scoring/ScoringSweep.vue b/client/dive-common/components/Scoring/ScoringSweep.vue
new file mode 100644
index 000000000..03081f0ab
--- /dev/null
+++ b/client/dive-common/components/Scoring/ScoringSweep.vue
@@ -0,0 +1,371 @@
+<script lang="ts">
+import {
+  computed, defineComponent, ref, watch,
+} from 'vue';
+import { useScoring } from 'dive-common/use/useScoring';
+import { METRIC_DEFINITIONS, type SweepCurve } from 'dive-common/scoring/metrics';
+import type { ScoringFilterEstimator } from 'dive-common/scoring/types';
+import ScoringLineChart from './charts/ScoringLineChart.vue';
+import type { ChartHover, ChartSeries } from './charts/chartTypes';
+
+const RATIO_METRICS = ['precision', 'recall', 'f1_score', 'mota', 'motp', 'idf1', 'hota', 'deta', 'assa'];
+const COUNT_METRICS = ['true_positives', 'false_positives', 'false_negatives', 'id_switches', 'fragmentations', 'mostly_tracked', 'mostly_lost'];
+const PALETTE = ['#4c9ac2', '#f4a261', '#2a9d8f', '#e76f51', '#e9c46a', '#a29bfe', '#fd79a8', '#81ecec', '#ffeaa7'];
+const AGGREGATE_NAMES = ['overall', 'default'];
+
+function estimateFilter(best: SweepCurve['best'], estimator: ScoringFilterEstimator): number | null {
+  const idf1 = best.idf1Thresh ?? 0;
+  const mota = best.motaThresh ?? 0;
+  switch (estimator) {
+    case 'min': return Math.min(idf1, mota);
+    case 'avg': return (idf1 + mota) / 2;
+    case 'avg_minus_1p': return Math.max((idf1 + mota) / 2 - 0.01, 0);
+    case 'idf1': return idf1;
+    case 'mota': return mota;
+    case 'none':
+    default: return null;
+  }
+}
+
+export default defineComponent({
+  name: 'ScoringSweep',
+  components: { ScoringLineChart },
+  setup() {
+    const scoring = useScoring();
+
+    const sweep = computed(() => scoring.metrics.value?.sweep || null);
+    const curveNames = computed(() => {
+      const names = Object.keys(sweep.value?.curves || {});
+      return [
+        ...names.filter((n) => AGGREGATE_NAMES.includes(n)),
+        ...names.filter((n) => !AGGREGATE_NAMES.includes(n)).sort(),
+      ];
+    });
+    const curveName = ref<string>('');
+    watch(curveNames, (names) => {
+      if (!names.includes(curveName.value)) curveName.value = names[0] || '';
+    }, { immediate: true });
+
+    const curve = computed(() => (sweep.value && curveName.value ? sweep.value.curves[curveName.value] : null));
+    const availableMetrics = computed(() => Object.keys(curve.value?.metrics || {}));
+    const selectedMetrics = ref<string[]>(['f1_score', 'mota', 'idf1', 'hota']);
+    const metricItems = computed(() => availableMetrics.value.map((key) => ({
+      value: key,
+      text: METRIC_DEFINITIONS[key]?.label || key,
+    })));
+
+    function seriesFor(keys: string[]): ChartSeries[] {
+      const c = curve.value;
+      if (!c) return [];
+      return keys
+        .filter((key) => c.metrics[key])
+        .map((key, i) => ({
+          name: METRIC_DEFINITIONS[key]?.label || key,
+          color: PALETTE[i % PALETTE.length],
+          points: c.thresholds.map((t, j) => ({ x: t, y: c.metrics[key][j] ?? 0, meta: { metric: key } }))
+            .filter((p) => Number.isFinite(p.y)),
+        }));
+    }
+
+    const ratioSeries = computed(() => seriesFor(selectedMetrics.value.filter((k) => !COUNT_METRICS.includes(k))));
+    const countSeries = computed(() => seriesFor(selectedMetrics.value.filter((k) => COUNT_METRICS.includes(k))));
+
+    const markers = computed(() => {
+      const c = curve.value;
+      if (!c) return [];
+      const out = [];
+      if (c.best.idf1Thresh !== null) out.push({ x: c.best.idf1Thresh, label: `best IDF1 ${c.best.idf1?.toFixed(2)}`, color: '#a29bfe' });
+      if (c.best.motaThresh !== null && c.best.motaThresh !== c.best.idf1Thresh) {
+        out.push({ x: c.best.motaThresh, label: `best MOTA ${c.best.mota?.toFixed(2)}`, color: '#2a9d8f' });
+      }
+      return out;
+    });
+
+    const currentFilter = computed(() => {
+      const filters = scoring.currentFilters.value;
+      if (AGGREGATE_NAMES.includes(curveName.value)) return filters.default ?? null;
+      return filters[curveName.value] ?? filters.default ?? null;
+    });
+
+    function tooltip(h: ChartHover): string[] {
+      const c = curve.value;
+      if (!c) return [];
+      const idx = c.thresholds.indexOf(h.point.x);
+      const lines = [`threshold ≥ ${h.point.x.toFixed(2)}`];
+      const keys = [...ratioSeries.value, ...countSeries.value].map((s) => String(s.points[0]?.meta?.metric));
+      keys.forEach((key) => {
+        const v = c.metrics[key]?.[idx];
+        let text = 'n/a';
+        if (v !== null && v !== undefined) {
+          text = COUNT_METRICS.includes(key) ? String(v) : v.toFixed(3);
+        }
+        lines.push(`${METRIC_DEFINITIONS[key]?.label || key}: ${text}`);
+      });
+      return lines;
+    }
+
+    const estimator = ref<ScoringFilterEstimator>(scoring.result.value?.params.filterEstimator || 'min');
+    watch(() => scoring.result.value, (r) => {
+      if (r) estimator.value = r.params.filterEstimator || 'min';
+    });
+
+    const recommended = computed(() => {
+      const s = sweep.value;
+      if (!s) return [];
+      const rows = Object.entries(s.curves)
+        .filter(([name]) => name !== 'overall')
+        .map(([name, c]) => ({
+          name: name === 'default' ? 'default' : name,
+          color: name === 'default' ? '#ccc' : scoring.classColor(name),
+          threshold: estimateFilter(c.best, estimator.value),
+          idf1: c.best.idf1,
+          idf1Thresh: c.best.idf1Thresh,
+          mota: c.best.mota,
+          motaThresh: c.best.motaThresh,
+        }));
+      const named = rows.filter((r) => r.threshold !== null && r.name !== 'default');
+      // Mirror the tool's dive.config.json: unlisted classes fall back to the
+      // least aggressive per-class value rather than going unfiltered.
+      if (named.length && !rows.some((r) => r.name === 'default')) {
+        const minimum = Math.min(...named.map((r) => r.threshold as number));
+        if (minimum > 0) {
+          rows.push({
+            name: 'default', color: '#ccc', threshold: minimum, idf1: null, idf1Thresh: null, mota: null, motaThresh: null,
+          });
+        }
+      }
+      return rows;
+    });
+
+    const applied = ref(false);
+    async function applyRecommended() {
+      const filters: Record<string, number> = {};
+      recommended.value.forEach((r) => {
+        if (r.threshold !== null) filters[r.name] = Math.round(r.threshold * 1000) / 1000;
+      });
+      await scoring.applyConfidenceFilters(filters);
+      applied.value = true;
+    }
+    watch([recommended, estimator], () => { applied.value = false; });
+
+    const estimatorItems: { value: ScoringFilterEstimator; text: string }[] = [
+      { value: 'min', text: 'min(IDF1, MOTA)' },
+      { value: 'avg', text: 'average' },
+      { value: 'avg_minus_1p', text: 'average − 0.01' },
+      { value: 'idf1', text: 'best IDF1' },
+      { value: 'mota', text: 'best MOTA' },
+    ];
+
+    return {
+      sweep,
+      curveNames,
+      curveName,
+      curve,
+      metricItems,
+      selectedMetrics,
+      ratioSeries,
+      countSeries,
+      markers,
+      currentFilter,
+      tooltip,
+      estimator,
+      estimatorItems,
+      recommended,
+      applied,
+      applyRecommended,
+      RATIO_METRICS,
+    };
+  },
+});
+</script>
+
+<template>
+  <div class="px-2 scoring-sweep">
+    <div
+      v-if="!sweep"
+      class="text-caption grey--text pa-2"
+    >
+      No threshold sweep in this result. Enable "Sweep thresholds" in the scoring parameters.
+    </div>
+    <template v-else>
+      <div class="d-flex align-center flex-wrap controls">
+        <v-select
+          v-model="curveName"
+          :items="curveNames"
+          dense
+          outlined
+          hide-details
+          label="Curve"
+          class="curve-select"
+        />
+        <v-select
+          v-model="selectedMetrics"
+          :items="metricItems"
+          dense
+          outlined
+          hide-details
+          multiple
+          small-chips
+          deletable-chips
+          label="Metrics"
+          class="metric-select"
+        />
+        <v-spacer />
+        <span
+          v-if="currentFilter !== null"
+          class="text-caption"
+        >Current filter for this curve: {{ currentFilter.toFixed(2) }} (yellow line)</span>
+      </div>
+      <div class="d-flex flex-wrap charts">
+        <div class="chart-col">
+          <ScoringLineChart
+            v-if="ratioSeries.length"
+            :series="ratioSeries"
+            x-label="Confidence threshold"
+            y-label="Score"
+            :x-domain="[0, 1]"
+            :markers="markers"
+            :selected-x="currentFilter"
+            :tooltip="tooltip"
+            :height="220"
+          />
+          <ScoringLineChart
+            v-if="countSeries.length"
+            :series="countSeries"
+            x-label="Confidence threshold"
+            y-label="Count"
+            :x-domain="[0, 1]"
+            :markers="markers"
+            :selected-x="currentFilter"
+            :tooltip="tooltip"
+            :height="180"
+            step
+          />
+        </div>
+        <div class="recommend-col">
+          <div class="d-flex align-center">
+            <span class="text-body-2 font-weight-bold">Recommended confidence filters</span>
+            <v-spacer />
+            <v-select
+              v-model="estimator"
+              :items="estimatorItems"
+              dense
+              hide-details
+              class="estimator-select"
+            />
+          </div>
+          <table class="recommend-table">
+            <thead>
+              <tr>
+                <th>Class</th>
+                <th>IDF1 @</th>
+                <th>MOTA @</th>
+                <th>Filter</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr
+                v-for="r in recommended"
+                :key="r.name"
+              >
+                <td>
+                  <span
+                    class="swatch"
+                    :style="{ background: r.color }"
+                  />{{ r.name }}
+                </td>
+                <td>{{ r.idf1 === null ? '—' : `${r.idf1.toFixed(2)} @ ${r.idf1Thresh === null ? '?' : r.idf1Thresh.toFixed(2)}` }}</td>
+                <td>{{ r.mota === null ? '—' : `${r.mota.toFixed(2)} @ ${r.motaThresh === null ? '?' : r.motaThresh.toFixed(2)}` }}</td>
+                <td class="font-weight-bold">
+                  {{ r.threshold === null ? '—' : r.threshold.toFixed(2) }}
+                </td>
+              </tr>
+            </tbody>
+          </table>
+          <v-btn
+            x-small
+            outlined
+            class="mt-2"
+            :color="applied ? 'success' : 'primary'"
+            :disabled="recommended.length === 0"
+            @click="applyRecommended"
+          >
+            {{ applied ? 'Applied to scored datasets' : 'Apply as confidence filters' }}
+          </v-btn>
+          <div class="text-caption grey--text mt-1">
+            Per-class filters are saved on every scored dataset's confidence settings;
+            the default filter applies to classes the sweep did not cover.
+          </div>
+        </div>
+      </div>
+    </template>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.controls {
+  gap: 8px;
+}
+
+.curve-select {
+  max-width: 200px;
+}
+
+.metric-select {
+  max-width: 520px;
+  min-width: 260px;
+}
+
+.charts {
+  gap: 8px;
+  align-items: flex-start;
+}
+
+.chart-col {
+  flex: 1 1 360px;
+  min-width: 300px;
+}
+
+.recommend-col {
+  flex: 0 1 420px;
+  min-width: 280px;
+  padding-top: 6px;
+}
+
+.estimator-select {
+  max-width: 170px;
+}
+
+.recommend-table {
+  border-collapse: collapse;
+  font-size: 12px;
+  width: 100%;
+
+  th {
+    color: #aaa;
+    font-weight: normal;
+    text-align: right;
+    border-bottom: 1px solid #444;
+    padding: 0 4px;
+  }
+
+  th:first-child,
+  td:first-child {
+    text-align: left;
+  }
+
+  td {
+    text-align: right;
+    padding: 1px 4px;
+    font-variant-numeric: tabular-nums;
+  }
+
+  .swatch {
+    display: inline-block;
+    width: 10px;
+    height: 10px;
+    border-radius: 2px;
+    margin-right: 5px;
+  }
+}
+</style>
diff --git a/client/dive-common/components/Scoring/charts/ScoringHeatmap.vue b/client/dive-common/components/Scoring/charts/ScoringHeatmap.vue
new file mode 100644
index 000000000..b630048e3
--- /dev/null
+++ b/client/dive-common/components/Scoring/charts/ScoringHeatmap.vue
@@ -0,0 +1,264 @@
+<script lang="ts">
+import {
+  computed, defineComponent, PropType, ref,
+} from 'vue';
+import * as d3 from 'd3';
+
+interface CellHover {
+  row: number;
+  col: number;
+  count: number;
+  fraction: number | null;
+}
+
+export default defineComponent({
+  name: 'ScoringHeatmap',
+  props: {
+    rowLabels: {
+      type: Array as PropType<string[]>,
+      required: true,
+    },
+    colLabels: {
+      type: Array as PropType<string[]>,
+      required: true,
+    },
+    counts: {
+      type: Array as PropType<number[][]>,
+      required: true,
+    },
+    fractions: {
+      type: Array as PropType<(number | null)[][]>,
+      default: () => [],
+    },
+    showFractions: {
+      type: Boolean,
+      default: false,
+    },
+    rowTitle: {
+      type: String,
+      default: 'Truth',
+    },
+    colTitle: {
+      type: String,
+      default: 'Computed',
+    },
+    /** Row/column index treated as background and drawn muted */
+    backgroundIndex: {
+      type: Number,
+      default: -1,
+    },
+    selected: {
+      type: Object as PropType<{ row: number; col: number } | null>,
+      default: null,
+    },
+    /** Pale cells and dark labels for printing on white */
+    light: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  setup(props, { emit }) {
+    const hover = ref<CellHover | null>(null);
+    const cellSize = computed(() => {
+      const n = Math.max(props.rowLabels.length, props.colLabels.length, 1);
+      return Math.max(28, Math.min(64, Math.floor(420 / n)));
+    });
+    const labelWidth = computed(() => {
+      const longest = Math.max(...props.rowLabels.map((l) => l.length), 4);
+      return Math.min(160, 8 + longest * 7);
+    });
+    const colLabelHeight = computed(() => {
+      const longest = Math.max(...props.colLabels.map((l) => l.length), 4);
+      return Math.min(140, 12 + longest * 6);
+    });
+    const width = computed(() => labelWidth.value + props.colLabels.length * cellSize.value + 4);
+    const height = computed(() => colLabelHeight.value + props.rowLabels.length * cellSize.value + 4);
+
+    const colorFor = computed(() => {
+      const maxCount = d3.max(props.counts.flat()) || 1;
+      return (r: number, c: number) => {
+        const isBackground = r === props.backgroundIndex || c === props.backgroundIndex;
+        const fraction = props.fractions[r]?.[c];
+        const t = props.showFractions && fraction !== null && fraction !== undefined
+          ? fraction
+          : (props.counts[r]?.[c] ?? 0) / maxCount;
+        const base = props.light ? '#ffffff' : '#262626';
+        if (r === c && !isBackground) {
+          return d3.interpolateRgb(props.light ? '#f1f8f1' : '#1e2a1e', '#4caf50')(Math.max(0.12, t));
+        }
+        if (isBackground) {
+          return d3.interpolateRgb(base, '#ff9800')(t * 0.9);
+        }
+        return d3.interpolateRgb(base, '#e53935')(t);
+      };
+    });
+
+    function cellText(r: number, c: number) {
+      const count = props.counts[r]?.[c] ?? 0;
+      if (props.showFractions) {
+        const f = props.fractions[r]?.[c];
+        return f === null || f === undefined ? '' : `${(f * 100).toFixed(0)}%`;
+      }
+      return String(count);
+    }
+
+    function onHover(r: number, c: number) {
+      hover.value = {
+        row: r,
+        col: c,
+        count: props.counts[r]?.[c] ?? 0,
+        fraction: props.fractions[r]?.[c] ?? null,
+      };
+    }
+
+    function onClick(r: number, c: number) {
+      emit('select', { row: r, col: c });
+    }
+
+    return {
+      hover,
+      cellSize,
+      labelWidth,
+      colLabelHeight,
+      width,
+      height,
+      colorFor,
+      cellText,
+      onHover,
+      onClick,
+    };
+  },
+});
+</script>
+
+<template>
+  <div
+    class="scoring-heatmap"
+    :class="{ light }"
+  >
+    <svg
+      :width="width"
+      :height="height"
+      @mouseleave="hover = null"
+    >
+      <text
+        :x="labelWidth + (colLabels.length * cellSize) / 2"
+        :y="12"
+        class="axis-title"
+        text-anchor="middle"
+      >{{ colTitle }}</text>
+      <text
+        :x="12"
+        :y="colLabelHeight + (rowLabels.length * cellSize) / 2"
+        class="axis-title"
+        text-anchor="middle"
+        :transform="`rotate(-90 12 ${colLabelHeight + (rowLabels.length * cellSize) / 2})`"
+      >{{ rowTitle }}</text>
+      <g
+        v-for="(label, c) in colLabels"
+        :key="`c${c}`"
+      >
+        <text
+          :x="labelWidth + c * cellSize + cellSize / 2"
+          :y="colLabelHeight - 6"
+          class="cell-label"
+          text-anchor="start"
+          :transform="`rotate(-45 ${labelWidth + c * cellSize + cellSize / 2} ${colLabelHeight - 6})`"
+        >{{ label }}</text>
+      </g>
+      <g
+        v-for="(label, r) in rowLabels"
+        :key="`r${r}`"
+      >
+        <text
+          :x="labelWidth - 6"
+          :y="colLabelHeight + r * cellSize + cellSize / 2 + 4"
+          class="cell-label"
+          text-anchor="end"
+        >{{ label }}</text>
+        <g
+          v-for="(_, c) in colLabels"
+          :key="`cell${r}-${c}`"
+          class="cell"
+          @mousemove="onHover(r, c)"
+          @click="onClick(r, c)"
+        >
+          <rect
+            :x="labelWidth + c * cellSize"
+            :y="colLabelHeight + r * cellSize"
+            :width="cellSize - 1"
+            :height="cellSize - 1"
+            :fill="colorFor(r, c)"
+            :stroke="selected && selected.row === r && selected.col === c ? '#ffeb3b' : (hover && hover.row === r && hover.col === c ? 'white' : 'none')"
+            stroke-width="1.5"
+          />
+          <text
+            :x="labelWidth + c * cellSize + cellSize / 2"
+            :y="colLabelHeight + r * cellSize + cellSize / 2 + 4"
+            class="cell-value"
+            text-anchor="middle"
+          >{{ cellText(r, c) }}</text>
+        </g>
+      </g>
+    </svg>
+    <div
+      v-if="hover"
+      class="heatmap-tooltip"
+    >
+      <b>{{ rowTitle }}: {{ rowLabels[hover.row] }}</b> → <b>{{ colTitle }}: {{ colLabels[hover.col] }}</b>
+      <div>
+        {{ hover.count }} object{{ hover.count === 1 ? '' : 's' }}
+        <span v-if="hover.fraction !== null">({{ (hover.fraction * 100).toFixed(1) }}% of this {{ rowTitle.toLowerCase() }} row)</span>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.scoring-heatmap {
+  display: inline-block;
+  position: relative;
+
+  .axis-title {
+    fill: #ccc;
+    font-size: 12px;
+    font-weight: bold;
+  }
+
+  .cell-label {
+    fill: #ddd;
+    font-size: 11px;
+  }
+
+  .cell {
+    cursor: pointer;
+  }
+
+  .cell-value {
+    fill: white;
+    font-size: 11px;
+    pointer-events: none;
+  }
+
+  .heatmap-tooltip {
+    font-size: 12px;
+    padding: 2px 6px;
+    color: #ddd;
+  }
+
+  &.light {
+    .axis-title,
+    .cell-label {
+      fill: #222;
+    }
+
+    .cell-value {
+      fill: #111;
+    }
+
+    .heatmap-tooltip {
+      color: #222;
+    }
+  }
+}
+</style>
diff --git a/client/dive-common/components/Scoring/charts/ScoringLineChart.vue b/client/dive-common/components/Scoring/charts/ScoringLineChart.vue
new file mode 100644
index 000000000..003a4b816
--- /dev/null
+++ b/client/dive-common/components/Scoring/charts/ScoringLineChart.vue
@@ -0,0 +1,561 @@
+<script lang="ts">
+import {
+  computed, defineComponent, onBeforeUnmount, onMounted, PropType, ref,
+} from 'vue';
+import {
+  curveLinear, curveStepAfter, line as d3Line, scaleLinear,
+} from 'd3';
+import type {
+  ChartHover, ChartMarker, ChartPoint, ChartSeries,
+} from './chartTypes';
+
+const MARGIN = {
+  top: 12, right: 16, bottom: 34, left: 46,
+};
+
+interface RenderedSeries {
+  series: ChartSeries;
+  path: string;
+}
+
+export default defineComponent({
+  name: 'ScoringLineChart',
+  props: {
+    series: {
+      type: Array as PropType<ChartSeries[]>,
+      required: true,
+    },
+    xLabel: {
+      type: String,
+      default: '',
+    },
+    yLabel: {
+      type: String,
+      default: '',
+    },
+    xDomain: {
+      type: Array as unknown as PropType<[number, number] | null>,
+      default: null,
+    },
+    yDomain: {
+      type: Array as unknown as PropType<[number, number] | null>,
+      default: null,
+    },
+    markers: {
+      type: Array as PropType<ChartMarker[]>,
+      default: () => [],
+    },
+    /** Draw a highlighted vertical rule at this x, e.g. the chosen threshold */
+    selectedX: {
+      type: Number as PropType<number | null>,
+      default: null,
+    },
+    height: {
+      type: Number,
+      default: 240,
+    },
+    /** Dark text and grid for printing on white */
+    light: {
+      type: Boolean,
+      default: false,
+    },
+    step: {
+      type: Boolean,
+      default: false,
+    },
+    /** Format one tooltip line per entry; defaults to x, y and every meta value */
+    tooltip: {
+      type: Function as PropType<(hover: ChartHover) => string[]>,
+      default: null,
+    },
+    xFormat: {
+      type: Function as PropType<(v: number) => string>,
+      default: (v: number) => v.toFixed(2),
+    },
+    yFormat: {
+      type: Function as PropType<(v: number) => string>,
+      default: (v: number) => v.toFixed(2),
+    },
+  },
+  setup(props, { emit }) {
+    const container = ref<HTMLDivElement | null>(null);
+    const width = ref(0);
+    const hidden = ref<Set<string>>(new Set());
+    const hover = ref<ChartHover | null>(null);
+
+    const innerWidth = computed(() => Math.max(0, width.value - MARGIN.left - MARGIN.right));
+    const innerHeight = computed(() => Math.max(0, props.height - MARGIN.top - MARGIN.bottom));
+
+    const visibleSeries = computed(() => props.series.filter((s) => !hidden.value.has(s.name)));
+    const allPoints = computed(() => visibleSeries.value.flatMap((s) => s.points));
+
+    const xScale = computed(() => {
+      let lo = props.xDomain ? props.xDomain[0] : Infinity;
+      let hi = props.xDomain ? props.xDomain[1] : -Infinity;
+      if (!props.xDomain) {
+        allPoints.value.forEach((p) => { lo = Math.min(lo, p.x); hi = Math.max(hi, p.x); });
+        if (!Number.isFinite(lo)) { lo = 0; hi = 1; }
+        if (lo === hi) hi = lo + 1;
+      }
+      return scaleLinear<number, number>().domain([lo, hi]).range([0, innerWidth.value]).nice();
+    });
+
+    const yScale = computed(() => {
+      const lo = props.yDomain ? props.yDomain[0] : 0;
+      let hi = props.yDomain ? props.yDomain[1] : 0;
+      if (!props.yDomain) {
+        allPoints.value.forEach((p) => { hi = Math.max(hi, p.y); });
+        hi = hi > 0 ? hi * 1.05 : 1;
+      }
+      return scaleLinear<number, number>().domain([lo, hi]).range([innerHeight.value, 0]).nice();
+    });
+
+    const sx = (v: number) => xScale.value(v) ?? 0;
+    const sy = (v: number) => yScale.value(v) ?? 0;
+
+    const xTicks = computed(() => xScale.value.ticks(6));
+    const yTicks = computed(() => yScale.value.ticks(5));
+
+    const rendered = computed<RenderedSeries[]>(() => {
+      const generator = d3Line<ChartPoint>()
+        .curve(props.step ? curveStepAfter : curveLinear)
+        .x((p) => sx(p.x))
+        .y((p) => sy(p.y));
+      return visibleSeries.value.map((series) => ({
+        series,
+        path: generator(series.points) || '',
+      }));
+    });
+
+    const visibleMarkers = computed(() => {
+      const [lo, hi] = xScale.value.domain();
+      return props.markers.filter((m) => m.x >= lo && m.x <= hi);
+    });
+
+    const selectedPx = computed(() => (props.selectedX !== null && Number.isFinite(props.selectedX)
+      ? sx(props.selectedX) : null));
+
+    function toggleSeries(name: string) {
+      const next = new Set(hidden.value);
+      if (next.has(name)) next.delete(name); else next.add(name);
+      hidden.value = next;
+    }
+
+    function tooltipLines(h: ChartHover): string[] {
+      if (props.tooltip) return props.tooltip(h);
+      const lines = [h.series.name, `${props.xLabel || 'x'}: ${props.xFormat(h.point.x)}`, `${props.yLabel || 'y'}: ${props.yFormat(h.point.y)}`];
+      Object.entries(h.point.meta || {}).forEach(([k, v]) => {
+        lines.push(`${k}: ${typeof v === 'number' ? v.toFixed(3) : String(v ?? 'n/a')}`);
+      });
+      return lines;
+    }
+
+    function nearest(mx: number, my: number): ChartHover | null {
+      let bestSeries: ChartSeries | null = null;
+      let bestPoint: ChartPoint | null = null;
+      let bestDist = Infinity;
+      visibleSeries.value.forEach((s) => {
+        s.points.forEach((p) => {
+          const dx = sx(p.x) - mx;
+          const dy = sy(p.y) - my;
+          // Weight x more: curves are read left to right and points bunch vertically
+          const dist = dx * dx + dy * dy * 0.25;
+          if (dist < bestDist) {
+            bestDist = dist;
+            bestSeries = s;
+            bestPoint = p;
+          }
+        });
+      });
+      return bestSeries && bestPoint ? { series: bestSeries, point: bestPoint } : null;
+    }
+
+    function localPoint(event: MouseEvent): [number, number] {
+      const rect = (event.currentTarget as SVGRectElement).getBoundingClientRect();
+      return [event.clientX - rect.left, event.clientY - rect.top];
+    }
+
+    function onMove(event: MouseEvent) {
+      const [mx, my] = localPoint(event);
+      const found = nearest(mx, my);
+      hover.value = found;
+      emit('hover', found);
+    }
+
+    function onLeave() {
+      hover.value = null;
+      emit('hover', null);
+    }
+
+    function onClick(event: MouseEvent) {
+      const [mx, my] = localPoint(event);
+      const found = nearest(mx, my);
+      if (found) emit('click', found);
+    }
+
+    const hoverX = computed(() => (hover.value ? sx(hover.value.point.x) : 0));
+    const hoverY = computed(() => (hover.value ? sy(hover.value.point.y) : 0));
+    const tooltipStyle = computed(() => {
+      if (!hover.value) return { display: 'none' };
+      const left = MARGIN.left + hoverX.value;
+      const flip = left > width.value * 0.6;
+      return {
+        top: `${Math.max(0, MARGIN.top + hoverY.value - 10)}px`,
+        ...(flip ? { right: `${width.value - left + 10}px` } : { left: `${left + 10}px` }),
+      };
+    });
+
+    let observer: ResizeObserver | null = null;
+    onMounted(() => {
+      if (container.value) {
+        width.value = container.value.clientWidth;
+        observer = new ResizeObserver((entries) => {
+          const next = Math.floor(entries[0]?.contentRect.width ?? 0);
+          if (next !== width.value) width.value = next;
+        });
+        observer.observe(container.value);
+      }
+    });
+    onBeforeUnmount(() => {
+      observer?.disconnect();
+    });
+
+    return {
+      container,
+      width,
+      hidden,
+      hover,
+      hoverX,
+      hoverY,
+      tooltipStyle,
+      tooltipLines,
+      toggleSeries,
+      innerWidth,
+      innerHeight,
+      sx,
+      sy,
+      xTicks,
+      yTicks,
+      rendered,
+      visibleMarkers,
+      selectedPx,
+      onMove,
+      onLeave,
+      onClick,
+      MARGIN,
+    };
+  },
+});
+</script>
+
+<template>
+  <div
+    class="scoring-line-chart"
+    :class="{ light }"
+  >
+    <div
+      ref="container"
+      class="chart-area"
+      :style="{ height: `${height}px` }"
+    >
+      <svg
+        v-if="width > 40"
+        :width="width"
+        :height="height"
+        style="display: block;"
+      >
+        <g :transform="`translate(${MARGIN.left},${MARGIN.top})`">
+          <g class="grid">
+            <line
+              v-for="t in yTicks"
+              :key="`g${t}`"
+              :x1="0"
+              :x2="innerWidth"
+              :y1="sy(t)"
+              :y2="sy(t)"
+            />
+          </g>
+          <g class="axis">
+            <line
+              :x1="0"
+              :x2="innerWidth"
+              :y1="innerHeight"
+              :y2="innerHeight"
+            />
+            <g
+              v-for="t in xTicks"
+              :key="`x${t}`"
+            >
+              <line
+                :x1="sx(t)"
+                :x2="sx(t)"
+                :y1="innerHeight"
+                :y2="innerHeight + 4"
+              />
+              <text
+                :x="sx(t)"
+                :y="innerHeight + 15"
+                text-anchor="middle"
+              >{{ xFormat(t) }}</text>
+            </g>
+            <line
+              :x1="0"
+              :x2="0"
+              :y1="0"
+              :y2="innerHeight"
+            />
+            <g
+              v-for="t in yTicks"
+              :key="`y${t}`"
+            >
+              <line
+                :x1="-4"
+                :x2="0"
+                :y1="sy(t)"
+                :y2="sy(t)"
+              />
+              <text
+                :x="-7"
+                :y="sy(t) + 3"
+                text-anchor="end"
+              >{{ yFormat(t) }}</text>
+            </g>
+          </g>
+          <text
+            v-if="xLabel"
+            class="axis-label"
+            :x="innerWidth / 2"
+            :y="innerHeight + 30"
+            text-anchor="middle"
+          >{{ xLabel }}</text>
+          <text
+            v-if="yLabel"
+            class="axis-label"
+            :transform="`rotate(-90) translate(${-innerHeight / 2}, -34)`"
+            text-anchor="middle"
+          >{{ yLabel }}</text>
+          <path
+            v-for="r in rendered"
+            :key="r.series.name"
+            class="series"
+            :d="r.path"
+            :style="{ stroke: r.series.color, strokeDasharray: r.series.dashed ? '4,3' : undefined }"
+          />
+          <g
+            v-for="m in visibleMarkers"
+            :key="`m${m.label}${m.x}`"
+          >
+            <line
+              class="marker"
+              :x1="sx(m.x)"
+              :x2="sx(m.x)"
+              :y1="0"
+              :y2="innerHeight"
+              :style="{ stroke: m.color || '#aaa' }"
+            />
+            <text
+              class="marker-label"
+              :x="sx(m.x) + 3"
+              :y="10"
+              :style="{ fill: m.color || '#aaa' }"
+            >{{ m.label }}</text>
+          </g>
+          <line
+            v-if="selectedPx !== null"
+            class="selected"
+            :x1="selectedPx"
+            :x2="selectedPx"
+            :y1="0"
+            :y2="innerHeight"
+          />
+          <g v-if="hover">
+            <line
+              class="crosshair"
+              :x1="hoverX"
+              :x2="hoverX"
+              :y1="0"
+              :y2="innerHeight"
+            />
+            <circle
+              class="hover-dot"
+              :cx="hoverX"
+              :cy="hoverY"
+              r="4"
+              :style="{ fill: hover.series.color }"
+            />
+          </g>
+          <rect
+            class="overlay"
+            :width="innerWidth"
+            :height="innerHeight"
+            @mousemove="onMove"
+            @mouseleave="onLeave"
+            @click="onClick"
+          />
+        </g>
+      </svg>
+    </div>
+    <div
+      v-if="hover"
+      class="chart-tooltip"
+      :style="tooltipStyle"
+    >
+      <div
+        v-for="(line, i) in tooltipLines(hover)"
+        :key="i"
+        :class="{ 'font-weight-bold': i === 0 }"
+      >
+        {{ line }}
+      </div>
+    </div>
+    <div
+      v-if="series.length > 1"
+      class="chart-legend"
+    >
+      <span
+        v-for="s in series"
+        :key="s.name"
+        class="legend-item"
+        :class="{ 'legend-hidden': hidden.has(s.name) }"
+        @click="toggleSeries(s.name)"
+      >
+        <span
+          class="legend-swatch"
+          :style="{ background: s.color, borderStyle: s.dashed ? 'dashed' : 'solid' }"
+        />
+        {{ s.name }}
+      </span>
+    </div>
+  </div>
+</template>
+
+<style lang="scss">
+.scoring-line-chart {
+  position: relative;
+  width: 100%;
+
+  .chart-area {
+    width: 100%;
+  }
+
+  .series {
+    fill: none;
+    stroke-width: 1.8px;
+  }
+
+  .grid line {
+    stroke: #444;
+  }
+
+  .axis {
+    font-size: 11px;
+
+    line {
+      stroke: #888;
+    }
+
+    text {
+      fill: #ccc;
+    }
+  }
+
+  .axis-label {
+    fill: #ccc;
+    font-size: 11px;
+  }
+
+  .marker {
+    stroke-dasharray: 3, 3;
+    stroke-width: 1px;
+  }
+
+  .marker-label {
+    font-size: 10px;
+  }
+
+  .selected {
+    stroke: #ffeb3b;
+    stroke-width: 1.5px;
+  }
+
+  .crosshair {
+    stroke: #888;
+    stroke-width: 1px;
+    pointer-events: none;
+  }
+
+  .hover-dot {
+    stroke: white;
+    stroke-width: 1px;
+    pointer-events: none;
+  }
+
+  .overlay {
+    fill: none;
+    pointer-events: all;
+  }
+
+  .chart-tooltip {
+    position: absolute;
+    background: rgba(0, 0, 0, 0.9);
+    border: 1px solid #888;
+    border-radius: 3px;
+    padding: 2px 6px;
+    font-size: 12px;
+    pointer-events: none;
+    white-space: nowrap;
+    z-index: 5;
+  }
+
+  &.light {
+    .grid line {
+      stroke: #ddd;
+    }
+
+    .axis line {
+      stroke: #666;
+    }
+
+    .axis text,
+    .axis-label {
+      fill: #222;
+    }
+
+    .selected {
+      stroke: #b8860b;
+    }
+
+    .chart-legend {
+      color: #222;
+    }
+  }
+
+  .chart-legend {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 4px 12px;
+    font-size: 12px;
+    padding: 2px 8px;
+
+    .legend-item {
+      cursor: pointer;
+      user-select: none;
+      display: inline-flex;
+      align-items: center;
+      gap: 4px;
+    }
+
+    .legend-hidden {
+      opacity: 0.4;
+      text-decoration: line-through;
+    }
+
+    .legend-swatch {
+      display: inline-block;
+      width: 14px;
+      height: 3px;
+      border-bottom: 2px solid transparent;
+    }
+  }
+}
+</style>
diff --git a/client/dive-common/components/Scoring/charts/chartTypes.ts b/client/dive-common/components/Scoring/charts/chartTypes.ts
new file mode 100644
index 000000000..03e103323
--- /dev/null
+++ b/client/dive-common/components/Scoring/charts/chartTypes.ts
@@ -0,0 +1,24 @@
+export interface ChartPoint {
+  x: number;
+  y: number;
+  /** Extra values shown in the hover tooltip, in insertion order */
+  meta?: Record<string, number | string | null>;
+}
+
+export interface ChartSeries {
+  name: string;
+  color: string;
+  points: ChartPoint[];
+  dashed?: boolean;
+}
+
+export interface ChartMarker {
+  x: number;
+  label: string;
+  color?: string;
+}
+
+export interface ChartHover {
+  series: ChartSeries;
+  point: ChartPoint;
+}
diff --git a/client/dive-common/scoring/export.spec.ts b/client/dive-common/scoring/export.spec.ts
new file mode 100644
index 000000000..a1c691815
--- /dev/null
+++ b/client/dive-common/scoring/export.spec.ts
@@ -0,0 +1,61 @@
+import { exportFilename, resultToCsv, resultToJson } from './export';
+import { DEFAULT_SCORING_PARAMS } from './metrics';
+import type { ScoringResultFile } from './types';
+
+const RESULT: ScoringResultFile = {
+  version: 1,
+  id: 'scoring_1.json',
+  datasetId: 'a',
+  created: '2026-09-06T14:05:09.000Z',
+  title: 'Alpha vs Beta',
+  pairs: [{ computed: { datasetId: 'a', label: 'Alpha' }, truth: { datasetId: 'b', label: 'Beta, GT' } }],
+  params: { ...DEFAULT_SCORING_PARAMS, labelSynonyms: '' },
+  metrics: {
+    precision: 0.5,
+    recall: 0.25,
+    custom_extra: 3,
+    per_class: { fish: { precision: 1, recall: 0.5, f1_score: 0.6667 } },
+    confusion_matrix: {
+      class_names: ['fish', 'background'],
+      matrix: [[2, 1], [3, 0]],
+      normalized_matrix: [[0.67, 0.33], [1, 0]],
+      per_class_accuracy: { fish: 0.67 },
+    },
+    sweep: {
+      interval: 2,
+      curves: {
+        overall: {
+          best: {
+            idf1: 0.5, idf1_thresh: 0.5, mota: 0.2, mota_thresh: 0,
+          },
+          thresholds: [0, 0.5],
+          mota: [0.2, 0.1],
+        },
+      },
+    },
+  },
+};
+
+describe('scoring exports', () => {
+  it('names files by the run timestamp', () => {
+    expect(exportFilename(RESULT, 'csv')).toMatch(/^scoring_2026\d{4}_\d{6}\.csv$/);
+  });
+
+  it('round-trips the run through JSON', () => {
+    expect(JSON.parse(resultToJson(RESULT))).toEqual(RESULT);
+  });
+
+  it('writes labelled summary, per-class, confusion and sweep blocks', () => {
+    const csv = resultToCsv(RESULT);
+    expect(csv).toContain('# Run\ntitle,Alpha vs Beta');
+    expect(csv).toContain('sequence 1 truth,"Beta, GT"');
+    expect(csv).toContain('param iouThreshold,0.5');
+    expect(csv).not.toContain('labelSynonyms');
+    expect(csv).toContain('precision,Precision,0.5');
+    expect(csv).toContain('custom_extra,custom_extra,3');
+    expect(csv).toContain('# Per class\nclass,total_gt');
+    expect(csv).toContain('\nfish,,,,,,1,0.5,0.6667,');
+    expect(csv).toContain('truth \\ computed,fish,background\nfish,2,1\nbackground,3,0');
+    expect(csv).toContain('overall,0.5,0.5,0.2,0');
+  });
+});
diff --git a/client/dive-common/scoring/export.ts b/client/dive-common/scoring/export.ts
new file mode 100644
index 000000000..0d38edd8a
--- /dev/null
+++ b/client/dive-common/scoring/export.ts
@@ -0,0 +1,119 @@
+import type { ScoringResultFile } from './types';
+import {
+  formatMetric, METRIC_GROUPS, parseScoringMetrics, ScoringMetrics,
+} from './metrics';
+
+const PER_CLASS_COLUMNS = [
+  'total_gt', 'total_computed', 'true_positives', 'false_positives', 'false_negatives',
+  'precision', 'recall', 'f1_score', 'average_precision', 'ap_any', 'ap50', 'ap75', 'ap50_95',
+];
+
+function csvCell(value: unknown): string {
+  if (value === null || value === undefined) return '';
+  const text = typeof value === 'number' ? String(value) : String(value);
+  return /[",\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+
+function row(...cells: unknown[]): string {
+  return cells.map(csvCell).join(',');
+}
+
+function timestampSlug(created: string): string {
+  const d = new Date(created);
+  const pad = (n: number) => String(n).padStart(2, '0');
+  if (Number.isNaN(d.getTime())) return 'run';
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}_${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+
+export function exportFilename(result: ScoringResultFile, extension: string): string {
+  return `scoring_${timestampSlug(result.created)}.${extension}`;
+}
+
+/** The run exactly as stored: parameters, sequences, tool metrics and matches. */
+export function resultToJson(result: ScoringResultFile): string {
+  return JSON.stringify(result, null, 2);
+}
+
+/**
+ * Spreadsheet-friendly blocks: the run, every summary metric with its label,
+ * the per-class table, the confusion matrix and the sweep's best thresholds.
+ * Blocks are separated by a blank line and introduced by a `#` heading row.
+ */
+export function resultToCsv(result: ScoringResultFile, parsed?: ScoringMetrics): string {
+  const metrics = parsed || parseScoringMetrics(result.metrics);
+  const lines: string[] = [];
+
+  lines.push('# Run');
+  lines.push(row('title', result.title));
+  lines.push(row('created', result.created));
+  result.pairs.forEach((pair, i) => {
+    lines.push(row(`sequence ${i + 1} computed`, pair.computed.label || pair.computed.datasetId));
+    lines.push(row(`sequence ${i + 1} truth`, pair.truth.label || pair.truth.datasetId));
+  });
+  Object.entries(result.params).forEach(([key, value]) => {
+    if (key === 'labelSynonyms' && !value) return;
+    lines.push(row(`param ${key}`, value));
+  });
+
+  lines.push('');
+  lines.push('# Summary');
+  lines.push(row('metric', 'label', 'value'));
+  const seen = new Set<string>();
+  METRIC_GROUPS.forEach((group) => {
+    group.metrics.forEach((m) => {
+      if (m.key in metrics.values) {
+        seen.add(m.key);
+        lines.push(row(m.key, m.label, metrics.values[m.key]));
+      }
+    });
+  });
+  Object.entries(metrics.values).forEach(([key, value]) => {
+    if (!seen.has(key)) lines.push(row(key, key, value));
+  });
+
+  const classNames = Object.keys(metrics.perClass).sort();
+  if (classNames.length) {
+    lines.push('');
+    lines.push('# Per class');
+    lines.push(row('class', ...PER_CLASS_COLUMNS));
+    classNames.forEach((name) => {
+      lines.push(row(name, ...PER_CLASS_COLUMNS.map((key) => metrics.perClass[name][key])));
+    });
+  }
+
+  const cm = metrics.confusionMatrix;
+  if (cm) {
+    lines.push('');
+    lines.push('# Confusion matrix (rows: truth, columns: computed)');
+    lines.push(row('truth \\ computed', ...cm.classNames));
+    cm.classNames.forEach((name, r) => {
+      lines.push(row(name, ...(cm.matrix[r] || [])));
+    });
+  }
+
+  if (metrics.sweep) {
+    lines.push('');
+    lines.push('# Sweep best thresholds');
+    lines.push(row('curve', 'idf1', 'idf1_threshold', 'mota', 'mota_threshold'));
+    Object.entries(metrics.sweep.curves).forEach(([name, curve]) => {
+      lines.push(row(name, curve.best.idf1, curve.best.idf1Thresh, curve.best.mota, curve.best.motaThresh));
+    });
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+/** Browser download of a text file, the fallback when the platform offers no save dialog. */
+export function downloadTextFile(filename: string, content: string, mime: string) {
+  const blob = new Blob([content], { type: mime });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement('a');
+  anchor.href = url;
+  anchor.download = filename;
+  document.body.appendChild(anchor);
+  anchor.click();
+  anchor.remove();
+  URL.revokeObjectURL(url);
+}
+
+export { formatMetric };
diff --git a/client/dive-common/scoring/metrics.spec.ts b/client/dive-common/scoring/metrics.spec.ts
new file mode 100644
index 000000000..9c106b8ce
--- /dev/null
+++ b/client/dive-common/scoring/metrics.spec.ts
@@ -0,0 +1,192 @@
+import {
+  DEFAULT_SCORING_PARAMS,
+  headlineMetrics,
+  parseScoringMatches,
+  parseScoringMetrics,
+  perFrameErrorCounts,
+  scoringCliArgs,
+  summarizeResult,
+} from './metrics';
+import type { RawScoringMatches, ScoringResultFile } from './types';
+
+const RAW_METRICS = {
+  precision: 0.5,
+  recall: 0.25,
+  f1_score: 0.3333,
+  mota: null,
+  hota: Number.NaN,
+  true_positives: 3,
+  config: {
+    iou_threshold: 0.5, confidence_threshold: 0, match_mode: 'polygon', keypoint_threshold: 0.1, per_class: true, tracking: true,
+  },
+  per_class: { fish: { precision: 1, recall: 0.5, ap50: null } },
+  confusion_matrix: {
+    class_names: ['fish', 'background'],
+    matrix: [[2, 1], [3, 0]],
+    normalized_matrix: [[0.6667, 0.3333], [1, 0]],
+    per_class_accuracy: { fish: 0.6667 },
+  },
+  pr_curve: {
+    average_precision: 0.4,
+    max_f1: 0.5,
+    best_threshold: 0.3,
+    points: [{
+      recall: 0, precision: 1, confidence: 0.9, f1: 0, tp: 0, fp: 0, fn: 4,
+    }, {
+      recall: 0.5, precision: 0.5, confidence: 0.3, f1: 0.5, tp: 2, fp: 2, fn: 2,
+    }],
+  },
+  roc_curve: { mean_pd: 0.4, max_false_alarms_per_frame: 1, points: [{ false_alarms_per_frame: 0, true_positive_rate: 0, confidence: null }] },
+  per_class_pr_curves: {
+    fish: {
+      average_precision: 0.4, max_f1: 0.5, best_threshold: 0.3, points: [],
+    },
+  },
+  sweep: {
+    interval: 2,
+    curves: {
+      overall: {
+        best: {
+          idf1: 0.5, idf1_thresh: 0.5, mota: 0.2, mota_thresh: 0,
+        },
+        thresholds: [0, 0.5],
+        mota: [0.2, 0.1],
+        idf1: [0.4, 0.5],
+      },
+    },
+  },
+};
+
+const RAW_MATCHES: RawScoringMatches = {
+  columns: ['sequence', 'frame', 'status', 'computed_id', 'gt_id', 'iou', 'confidence', 'computed_class', 'gt_class'],
+  frame_names: [[0, 0, 'a.png'], [0, 2, 'c.png']],
+  rows: [
+    [0, 0, 'tp', 1, 7, 0.8, 0.9, 'fish', 'fish'],
+    [0, 0, 'fp', 2, -1, 0, 0.4, 'fish', ''],
+    [0, 2, 'fn', -1, 8, 0, 0, '', 'fish'],
+    [0, 2, 'fn', -1, 9, 0, 0, '', 'fish'],
+  ],
+};
+
+describe('scoringCliArgs', () => {
+  const paths = {
+    computed: '/c.csv', truth: '/t.csv', metricsOut: '/m.json', matchesOut: '/x.json', sweepDir: '/sweep',
+  };
+
+  it('emits the sweep, match and curve flags for the defaults', () => {
+    const args = scoringCliArgs(DEFAULT_SCORING_PARAMS, paths);
+    expect(args.slice(0, 6)).toEqual(['-c', '/c.csv', '-t', '/t.csv', '-o', '/m.json']);
+    expect(args).toContain('--json-curves');
+    expect(args).toContain('--per-class');
+    expect(args).toContain('--sweep-thresholds');
+    expect(args).toContain('--output-sweep');
+    expect(args).toContain('--output-matches');
+    expect(args).not.toContain('--no-tracking');
+    expect(args).not.toContain('--labels');
+    expect(args[args.indexOf('--match-mode') + 1]).toBe('box');
+  });
+
+  it('drops the sweep and tracking flags when disabled and adds the labels file', () => {
+    const args = scoringCliArgs({
+      ...DEFAULT_SCORING_PARAMS, sweep: false, tracking: false, matchMode: 'polygon', defaultLabel: 'fish',
+    }, { ...paths, labelsFile: '/labels.txt' });
+    expect(args).not.toContain('--sweep-thresholds');
+    expect(args).toContain('--no-tracking');
+    expect(args[args.indexOf('--match-mode') + 1]).toBe('polygon');
+    expect(args[args.indexOf('--labels') + 1]).toBe('/labels.txt');
+    expect(args[args.indexOf('--defaultlabel') + 1]).toBe('fish');
+  });
+});
+
+describe('parseScoringMetrics', () => {
+  const parsed = parseScoringMetrics(RAW_METRICS);
+
+  it('separates flat values from the structured sections', () => {
+    expect(parsed.values.precision).toBe(0.5);
+    expect(parsed.values.mota).toBeNull();
+    expect(parsed.values.hota).toBeNull();
+    expect(parsed.values.config).toBeUndefined();
+    expect(parsed.config?.matchMode).toBe('polygon');
+    expect(parsed.perClass.fish.ap50).toBeNull();
+  });
+
+  it('parses the confusion matrix, curves and sweep', () => {
+    expect(parsed.confusionMatrix?.classNames).toEqual(['fish', 'background']);
+    expect(parsed.confusionMatrix?.matrix[1][0]).toBe(3);
+    expect(parsed.prCurve?.points).toHaveLength(2);
+    expect(parsed.prCurve?.points[1].confidence).toBe(0.3);
+    expect(parsed.rocCurve?.points[0].confidence).toBeNull();
+    expect(Object.keys(parsed.perClassPrCurves)).toEqual(['fish']);
+    expect(parsed.sweep?.curves.overall.thresholds).toEqual([0, 0.5]);
+    expect(parsed.sweep?.curves.overall.metrics.mota).toEqual([0.2, 0.1]);
+    expect(parsed.sweep?.curves.overall.metrics.best).toBeUndefined();
+    expect(parsed.sweep?.curves.overall.best.idf1Thresh).toBe(0.5);
+  });
+
+  it('tolerates a metrics file with none of the optional sections', () => {
+    const minimal = parseScoringMetrics({ precision: 1 });
+    expect(minimal.confusionMatrix).toBeNull();
+    expect(minimal.prCurve).toBeNull();
+    expect(minimal.sweep).toBeNull();
+    expect(minimal.perClass).toEqual({});
+  });
+});
+
+describe('parseScoringMatches', () => {
+  const matches = parseScoringMatches(RAW_MATCHES);
+
+  it('resolves frame names and turns -1 ids into nulls', () => {
+    expect(matches).toHaveLength(4);
+    expect(matches[0]).toMatchObject({
+      frame: 0, frameName: 'a.png', status: 'tp', computedId: 1, gtId: 7, iou: 0.8,
+    });
+    expect(matches[1].gtId).toBeNull();
+    expect(matches[2].computedId).toBeNull();
+    expect(matches[2].frameName).toBe('c.png');
+  });
+
+  it('tallies per frame in frame order', () => {
+    expect(perFrameErrorCounts(matches)).toEqual([
+      {
+        frame: 0, tp: 1, fp: 1, fn: 0,
+      },
+      {
+        frame: 2, tp: 0, fp: 0, fn: 2,
+      },
+    ]);
+  });
+
+  it('returns nothing for a missing payload', () => {
+    expect(parseScoringMatches(undefined)).toEqual([]);
+  });
+});
+
+describe('summaries', () => {
+  it('keeps only finite headline numbers', () => {
+    const headline = headlineMetrics(RAW_METRICS);
+    expect(headline.precision).toBe(0.5);
+    expect(headline.mota).toBeNull();
+    expect(headline.hota).toBeNull();
+    expect('config' in headline).toBe(false);
+  });
+
+  it('summarizes a result file without its payloads', () => {
+    const file: ScoringResultFile = {
+      version: 1,
+      id: 'scoring_1.json',
+      datasetId: 'a',
+      created: '2026-09-06T00:00:00.000Z',
+      title: 'a vs b',
+      pairs: [{ computed: { datasetId: 'a' }, truth: { datasetId: 'b' } }],
+      params: DEFAULT_SCORING_PARAMS,
+      metrics: RAW_METRICS,
+      matches: RAW_MATCHES,
+    };
+    const summary = summarizeResult(file);
+    expect(summary.headline.precision).toBe(0.5);
+    expect(summary.datasetId).toBe('a');
+    expect(summary.pairs).toHaveLength(1);
+    expect('metrics' in summary).toBe(false);
+    expect('matches' in summary).toBe(false);
+  });
+});
diff --git a/client/dive-common/scoring/metrics.ts b/client/dive-common/scoring/metrics.ts
new file mode 100644
index 000000000..6bbca5301
--- /dev/null
+++ b/client/dive-common/scoring/metrics.ts
@@ -0,0 +1,643 @@
+import type {
+  RawScoringMatches,
+  RawScoringMetrics,
+  ScoringParams,
+  ScoringResultFile,
+  ScoringResultSummary,
+} from './types';
+
+export const DEFAULT_SCORING_PARAMS: ScoringParams = {
+  iouThreshold: 0.5,
+  confidenceThreshold: 0.0,
+  matchMode: 'box',
+  perClass: true,
+  topClass: false,
+  auxConfidence: false,
+  tracking: true,
+  keypointThreshold: 0.1,
+  sweep: true,
+  sweepInterval: 50,
+  filterEstimator: 'min',
+  defaultLabel: '',
+  labelSynonyms: '',
+};
+
+export const FILTER_ESTIMATORS: { value: ScoringParams['filterEstimator']; text: string }[] = [
+  { value: 'min', text: 'Lower of the IDF1 and MOTA thresholds' },
+  { value: 'avg', text: 'Average of the IDF1 and MOTA thresholds' },
+  { value: 'avg_minus_1p', text: 'Average minus 0.01' },
+  { value: 'idf1', text: 'Threshold maximising IDF1' },
+  { value: 'mota', text: 'Threshold maximising MOTA' },
+  { value: 'none', text: 'Do not recommend a filter' },
+];
+
+export interface ScoringCliPaths {
+  computed: string;
+  truth: string;
+  metricsOut: string;
+  matchesOut?: string;
+  sweepDir?: string;
+  labelsFile?: string;
+}
+
+/**
+ * The `viame score` argument list for a parameter set. Tokens are returned
+ * unquoted so each platform can quote for its own shell; paths are passed
+ * through untouched.
+ */
+export function scoringCliArgs(params: ScoringParams, paths: ScoringCliPaths): string[] {
+  const args = [
+    '-c', paths.computed,
+    '-t', paths.truth,
+    '-o', paths.metricsOut,
+    '--json-curves',
+    '--iou', String(params.iouThreshold),
+    '--conf', String(params.confidenceThreshold),
+    '--match-mode', params.matchMode,
+    '--keypoint-threshold', String(params.keypointThreshold),
+  ];
+  if (params.perClass) args.push('--per-class');
+  if (params.topClass) args.push('--top-class');
+  if (params.auxConfidence) args.push('--aux-confidence');
+  if (!params.tracking) args.push('--no-tracking');
+  if (params.defaultLabel) args.push('--defaultlabel', params.defaultLabel);
+  if (paths.labelsFile) args.push('--labels', paths.labelsFile);
+  if (paths.matchesOut) args.push('--output-matches', paths.matchesOut);
+  if (params.sweep) {
+    args.push('--sweep-thresholds', '--sweep-interval', String(params.sweepInterval));
+    args.push('--filter-estimator', params.filterEstimator);
+    if (paths.sweepDir) args.push('--output-sweep', paths.sweepDir);
+  }
+  return args;
+}
+
+export const HEADLINE_METRIC_KEYS = [
+  'precision', 'recall', 'f1_score', 'average_precision', 'ap50', 'mean_ap',
+  'mota', 'idf1', 'hota', 'mean_iou', 'mean_polygon_iou', 'keypoint_pck', 'length_mape',
+  'true_positives', 'false_positives', 'false_negatives',
+];
+
+function asNumberOrNull(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+export function headlineMetrics(raw: RawScoringMetrics): Record<string, number | null> {
+  const out: Record<string, number | null> = {};
+  HEADLINE_METRIC_KEYS.forEach((key) => {
+    if (key in raw) out[key] = asNumberOrNull(raw[key]);
+  });
+  return out;
+}
+
+export function summarizeResult(file: ScoringResultFile): ScoringResultSummary {
+  return {
+    id: file.id,
+    datasetId: file.datasetId,
+    created: file.created,
+    title: file.title,
+    pairs: file.pairs,
+    params: file.params,
+    headline: headlineMetrics(file.metrics),
+  };
+}
+
+/** Stable, distinguishable colors for class names outside the annotator's style manager. */
+export const CLASS_PALETTE = [
+  '#4c9ac2', '#f4a261', '#2a9d8f', '#e76f51', '#e9c46a', '#a29bfe', '#fd79a8',
+  '#81ecec', '#ffeaa7', '#55efc4', '#fab1a0', '#74b9ff', '#dfe6e9', '#ff7675',
+];
+
+// ---------------------------------------------------------------------------
+// Structured view of the metrics JSON
+
+export interface PRCurvePoint {
+  recall: number; precision: number; confidence: number; f1: number;
+  tp: number; fp: number; fn: number;
+}
+export interface PRCurve {
+  averagePrecision: number | null;
+  maxF1: number | null;
+  bestThreshold: number | null;
+  points: PRCurvePoint[];
+}
+export interface ROCCurvePoint {
+  falseAlarmsPerFrame: number; truePositiveRate: number; confidence: number | null;
+}
+export interface ROCCurve {
+  meanPd: number | null;
+  maxFalseAlarmsPerFrame: number | null;
+  points: ROCCurvePoint[];
+}
+export interface ConfusionMatrix {
+  classNames: string[];
+  matrix: number[][];
+  normalized: (number | null)[][];
+  perClassAccuracy: Record<string, number | null>;
+}
+export interface SweepCurve {
+  thresholds: number[];
+  metrics: Record<string, (number | null)[]>;
+  best: { idf1: number | null; idf1Thresh: number | null; mota: number | null; motaThresh: number | null };
+}
+export interface ScoringRunConfig {
+  iouThreshold: number | null;
+  confidenceThreshold: number | null;
+  matchMode: string;
+  keypointThreshold: number | null;
+  perClass: boolean;
+  tracking: boolean;
+}
+export interface ScoringMetrics {
+  values: Record<string, number | null>;
+  config: ScoringRunConfig | null;
+  perClass: Record<string, Record<string, number | null>>;
+  confusionMatrix: ConfusionMatrix | null;
+  prCurve: PRCurve | null;
+  rocCurve: ROCCurve | null;
+  perClassPrCurves: Record<string, PRCurve>;
+  sweep: { interval: number; curves: Record<string, SweepCurve> } | null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function parsePrCurve(raw: unknown): PRCurve | null {
+  if (!isRecord(raw) || !Array.isArray(raw.points)) return null;
+  return {
+    averagePrecision: asNumberOrNull(raw.average_precision),
+    maxF1: asNumberOrNull(raw.max_f1),
+    bestThreshold: asNumberOrNull(raw.best_threshold),
+    points: raw.points.filter(isRecord).map((p) => ({
+      recall: asNumberOrNull(p.recall) ?? 0,
+      precision: asNumberOrNull(p.precision) ?? 0,
+      confidence: asNumberOrNull(p.confidence) ?? 0,
+      f1: asNumberOrNull(p.f1) ?? 0,
+      tp: asNumberOrNull(p.tp) ?? 0,
+      fp: asNumberOrNull(p.fp) ?? 0,
+      fn: asNumberOrNull(p.fn) ?? 0,
+    })),
+  };
+}
+
+function parseRocCurve(raw: unknown): ROCCurve | null {
+  if (!isRecord(raw) || !Array.isArray(raw.points)) return null;
+  return {
+    meanPd: asNumberOrNull(raw.mean_pd),
+    maxFalseAlarmsPerFrame: asNumberOrNull(raw.max_false_alarms_per_frame),
+    points: raw.points.filter(isRecord).map((p) => ({
+      falseAlarmsPerFrame: asNumberOrNull(p.false_alarms_per_frame) ?? 0,
+      truePositiveRate: asNumberOrNull(p.true_positive_rate) ?? 0,
+      confidence: asNumberOrNull(p.confidence),
+    })),
+  };
+}
+
+function parseNumberMap(raw: unknown): Record<string, number | null> {
+  const out: Record<string, number | null> = {};
+  if (isRecord(raw)) {
+    Object.entries(raw).forEach(([k, v]) => { out[k] = asNumberOrNull(v); });
+  }
+  return out;
+}
+
+export function parseScoringMetrics(raw: RawScoringMetrics): ScoringMetrics {
+  const values: Record<string, number | null> = {};
+  Object.entries(raw).forEach(([key, value]) => {
+    if (typeof value === 'number' || value === null) values[key] = asNumberOrNull(value);
+  });
+
+  const perClass: Record<string, Record<string, number | null>> = {};
+  if (isRecord(raw.per_class)) {
+    Object.entries(raw.per_class).forEach(([name, metrics]) => {
+      perClass[name] = parseNumberMap(metrics);
+    });
+  }
+
+  let confusionMatrix: ConfusionMatrix | null = null;
+  if (isRecord(raw.confusion_matrix) && Array.isArray(raw.confusion_matrix.class_names)) {
+    const cm = raw.confusion_matrix;
+    confusionMatrix = {
+      classNames: (cm.class_names as unknown[]).map(String),
+      matrix: Array.isArray(cm.matrix)
+        ? (cm.matrix as unknown[][]).map((row) => row.map((v) => asNumberOrNull(v) ?? 0)) : [],
+      normalized: Array.isArray(cm.normalized_matrix)
+        ? (cm.normalized_matrix as unknown[][]).map((row) => row.map(asNumberOrNull)) : [],
+      perClassAccuracy: parseNumberMap(cm.per_class_accuracy),
+    };
+  }
+
+  const perClassPrCurves: Record<string, PRCurve> = {};
+  if (isRecord(raw.per_class_pr_curves)) {
+    Object.entries(raw.per_class_pr_curves).forEach(([name, curve]) => {
+      const parsed = parsePrCurve(curve);
+      if (parsed) perClassPrCurves[name] = parsed;
+    });
+  }
+
+  let sweep: ScoringMetrics['sweep'] = null;
+  if (isRecord(raw.sweep) && isRecord(raw.sweep.curves)) {
+    const curves: Record<string, SweepCurve> = {};
+    Object.entries(raw.sweep.curves).forEach(([name, curve]) => {
+      if (!isRecord(curve) || !Array.isArray(curve.thresholds)) return;
+      const metrics: Record<string, (number | null)[]> = {};
+      Object.entries(curve).forEach(([key, series]) => {
+        if (key !== 'thresholds' && key !== 'best' && Array.isArray(series)) {
+          metrics[key] = series.map(asNumberOrNull);
+        }
+      });
+      const best = isRecord(curve.best) ? curve.best : {};
+      curves[name] = {
+        thresholds: (curve.thresholds as unknown[]).map((t) => asNumberOrNull(t) ?? 0),
+        metrics,
+        best: {
+          idf1: asNumberOrNull(best.idf1),
+          idf1Thresh: asNumberOrNull(best.idf1_thresh),
+          mota: asNumberOrNull(best.mota),
+          motaThresh: asNumberOrNull(best.mota_thresh),
+        },
+      };
+    });
+    sweep = { interval: asNumberOrNull(raw.sweep.interval) ?? 0, curves };
+  }
+
+  let config: ScoringRunConfig | null = null;
+  if (isRecord(raw.config)) {
+    config = {
+      iouThreshold: asNumberOrNull(raw.config.iou_threshold),
+      confidenceThreshold: asNumberOrNull(raw.config.confidence_threshold),
+      matchMode: String(raw.config.match_mode ?? 'box'),
+      keypointThreshold: asNumberOrNull(raw.config.keypoint_threshold),
+      perClass: raw.config.per_class === true,
+      tracking: raw.config.tracking !== false,
+    };
+  }
+
+  return {
+    values,
+    config,
+    perClass,
+    confusionMatrix,
+    prCurve: parsePrCurve(raw.pr_curve),
+    rocCurve: parseRocCurve(raw.roc_curve),
+    perClassPrCurves,
+    sweep,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Matches
+
+export type ScoringMatchStatus = 'tp' | 'fp' | 'fn';
+
+export interface ScoringMatch {
+  sequence: number;
+  frame: number;
+  frameName: string;
+  status: ScoringMatchStatus;
+  computedId: number | null;
+  gtId: number | null;
+  iou: number;
+  confidence: number;
+  computedClass: string;
+  gtClass: string;
+}
+
+export function parseScoringMatches(raw: RawScoringMatches | undefined): ScoringMatch[] {
+  if (!raw || !Array.isArray(raw.rows)) return [];
+  const names = new Map<string, string>();
+  (raw.frame_names || []).forEach(([seq, frame, name]) => names.set(`${seq}:${frame}`, name));
+  const col = (name: string) => raw.columns.indexOf(name);
+  const idx = {
+    sequence: col('sequence'),
+    frame: col('frame'),
+    status: col('status'),
+    computedId: col('computed_id'),
+    gtId: col('gt_id'),
+    iou: col('iou'),
+    confidence: col('confidence'),
+    computedClass: col('computed_class'),
+    gtClass: col('gt_class'),
+  };
+  const num = (row: (number | string | null)[], i: number) => asNumberOrNull(row[i]);
+  const str = (row: (number | string | null)[], i: number) => (i >= 0 && row[i] != null ? String(row[i]) : '');
+  return raw.rows.map((row) => {
+    const sequence = num(row, idx.sequence) ?? 0;
+    const frame = num(row, idx.frame) ?? 0;
+    const status = str(row, idx.status) as ScoringMatchStatus;
+    const computedId = num(row, idx.computedId);
+    const gtId = num(row, idx.gtId);
+    return {
+      sequence,
+      frame,
+      frameName: names.get(`${sequence}:${frame}`) ?? '',
+      status,
+      computedId: computedId !== null && computedId >= 0 ? computedId : null,
+      gtId: gtId !== null && gtId >= 0 ? gtId : null,
+      iou: num(row, idx.iou) ?? 0,
+      confidence: num(row, idx.confidence) ?? 0,
+      computedClass: str(row, idx.computedClass),
+      gtClass: str(row, idx.gtClass),
+    };
+  });
+}
+
+export interface FrameErrorCount {
+  frame: number;
+  tp: number;
+  fp: number;
+  fn: number;
+}
+
+/** Per-frame tallies in frame order, one entry per frame that carries any object. */
+export function perFrameErrorCounts(matches: ScoringMatch[]): FrameErrorCount[] {
+  const byFrame = new Map<number, FrameErrorCount>();
+  matches.forEach((m) => {
+    let entry = byFrame.get(m.frame);
+    if (!entry) {
+      entry = {
+        frame: m.frame, tp: 0, fp: 0, fn: 0,
+      };
+      byFrame.set(m.frame, entry);
+    }
+    entry[m.status] += 1;
+  });
+  return Array.from(byFrame.values()).sort((a, b) => a.frame - b.frame);
+}
+
+// ---------------------------------------------------------------------------
+// Display definitions
+
+export interface MetricDefinition {
+  key: string;
+  label: string;
+  description: string;
+  format: 'ratio' | 'count' | 'pixels' | 'frames' | 'number';
+  higherIsBetter?: boolean;
+}
+
+export interface MetricGroup {
+  name: string;
+  /** Show the group only when this metric is present and non-zero */
+  requires?: string;
+  metrics: MetricDefinition[];
+}
+
+export const METRIC_GROUPS: MetricGroup[] = [
+  {
+    name: 'Detection',
+    metrics: [
+      {
+        key: 'precision', label: 'Precision', description: 'Fraction of computed objects that matched truth', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'recall', label: 'Recall', description: 'Fraction of truth objects that were found', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'f1_score', label: 'F1', description: 'Harmonic mean of precision and recall', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'average_precision', label: 'AP', description: 'Area under the precision-recall curve at the configured IoU', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'ap50', label: 'AP@50', description: 'Average precision at IoU 0.5', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'ap75', label: 'AP@75', description: 'Average precision at IoU 0.75', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'ap50_95', label: 'AP@[.5:.95]', description: 'COCO-style average precision over IoU 0.5 to 0.95', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'ap_any', label: 'AP@any', description: 'Average precision counting any overlap as a hit', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'mean_ap', label: 'mAP', description: 'Mean of the per-class average precisions', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'mcc', label: 'MCC', description: 'Matthews correlation coefficient', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'true_positives', label: 'True positives', description: 'Computed objects matched to truth', format: 'count',
+      },
+      {
+        key: 'false_positives', label: 'False positives', description: 'Computed objects with no matching truth', format: 'count', higherIsBetter: false,
+      },
+      {
+        key: 'false_negatives', label: 'False negatives', description: 'Truth objects that were missed', format: 'count', higherIsBetter: false,
+      },
+    ],
+  },
+  {
+    name: 'Localization',
+    metrics: [
+      {
+        key: 'mean_iou', label: 'Mean IoU', description: 'Mean overlap of matched pairs', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'median_iou', label: 'Median IoU', description: 'Median overlap of matched pairs', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'mean_center_distance', label: 'Center distance', description: 'Mean distance between matched box centers', format: 'pixels', higherIsBetter: false,
+      },
+      {
+        key: 'mean_size_error', label: 'Size error', description: 'Mean relative area error of matched boxes', format: 'ratio', higherIsBetter: false,
+      },
+    ],
+  },
+  {
+    name: 'Segmentation',
+    requires: 'polygon_pairs',
+    metrics: [
+      {
+        key: 'polygon_pairs', label: 'Polygon pairs', description: 'Matched pairs with a polygon on both sides', format: 'count',
+      },
+      {
+        key: 'mean_polygon_iou', label: 'Mean polygon IoU', description: 'Mean mask overlap of those pairs', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'median_polygon_iou', label: 'Median polygon IoU', description: 'Median mask overlap of those pairs', format: 'ratio', higherIsBetter: true,
+      },
+    ],
+  },
+  {
+    name: 'Keypoints',
+    requires: 'keypoint_pairs',
+    metrics: [
+      {
+        key: 'keypoint_pairs', label: 'Keypoint pairs', description: 'Matched pairs with head or tail on both sides', format: 'count',
+      },
+      {
+        key: 'keypoint_pck', label: 'PCK', description: 'Fraction of keypoints within the tolerance', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'head_pck', label: 'Head PCK', description: 'Fraction of head points within the tolerance', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'tail_pck', label: 'Tail PCK', description: 'Fraction of tail points within the tolerance', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'keypoint_mean_error', label: 'Mean error', description: 'Mean keypoint distance from truth', format: 'pixels', higherIsBetter: false,
+      },
+      {
+        key: 'head_mean_error', label: 'Head error', description: 'Mean head distance from truth', format: 'pixels', higherIsBetter: false,
+      },
+      {
+        key: 'tail_mean_error', label: 'Tail error', description: 'Mean tail distance from truth', format: 'pixels', higherIsBetter: false,
+      },
+    ],
+  },
+  {
+    name: 'Length',
+    requires: 'length_pairs',
+    metrics: [
+      {
+        key: 'length_pairs', label: 'Length pairs', description: 'Matched pairs with a length on both sides', format: 'count',
+      },
+      {
+        key: 'length_mae', label: 'MAE', description: 'Mean absolute length error', format: 'number', higherIsBetter: false,
+      },
+      {
+        key: 'length_mape', label: 'MAPE', description: 'Mean absolute length error relative to truth', format: 'ratio', higherIsBetter: false,
+      },
+      {
+        key: 'length_rmse', label: 'RMSE', description: 'Root mean square length error', format: 'number', higherIsBetter: false,
+      },
+      {
+        key: 'length_bias', label: 'Bias', description: 'Mean signed length error, computed minus truth', format: 'number',
+      },
+    ],
+  },
+  {
+    name: 'Tracking',
+    requires: 'total_gt_tracks',
+    metrics: [
+      {
+        key: 'mota', label: 'MOTA', description: 'Multiple object tracking accuracy', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'motp', label: 'MOTP', description: 'Mean IoU of matches (higher is better)', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'hota', label: 'HOTA', description: 'Higher order tracking accuracy', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'deta', label: 'DetA', description: 'HOTA detection accuracy', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'assa', label: 'AssA', description: 'HOTA association accuracy', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'loca', label: 'LocA', description: 'HOTA localization accuracy', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'idf1', label: 'IDF1', description: 'Identity F1', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'idp', label: 'IDP', description: 'Identity precision', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'idr', label: 'IDR', description: 'Identity recall', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'id_switches', label: 'ID switches', description: 'Times a truth track changed computed identity', format: 'count', higherIsBetter: false,
+      },
+      {
+        key: 'fragmentations', label: 'Fragmentations', description: 'Times a truth track lost and regained coverage', format: 'count', higherIsBetter: false,
+      },
+      {
+        key: 'mostly_tracked', label: 'Mostly tracked', description: 'Truth tracks covered at least 80% of their span', format: 'count', higherIsBetter: true,
+      },
+      {
+        key: 'partially_tracked', label: 'Partially tracked', description: 'Truth tracks covered 20% to 80% of their span', format: 'count',
+      },
+      {
+        key: 'mostly_lost', label: 'Mostly lost', description: 'Truth tracks covered under 20% of their span', format: 'count', higherIsBetter: false,
+      },
+      {
+        key: 'faf', label: 'False alarms / frame', description: 'False positives per frame', format: 'number', higherIsBetter: false,
+      },
+      {
+        key: 'avg_track_continuity', label: 'Track continuity', description: 'KWANT continuity of computed tracks', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'avg_track_purity', label: 'Track purity', description: 'KWANT purity of computed tracks', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'avg_target_continuity', label: 'Target continuity', description: 'KWANT continuity of truth tracks', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'avg_target_purity', label: 'Target purity', description: 'KWANT purity of truth tracks', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'track_pd', label: 'Track Pd', description: 'Fraction of truth tracks detected', format: 'ratio', higherIsBetter: true,
+      },
+      {
+        key: 'track_fa', label: 'Track FA', description: 'Computed tracks matching no truth', format: 'count', higherIsBetter: false,
+      },
+      {
+        key: 'avg_track_length', label: 'Avg track length', description: 'Mean computed track length', format: 'frames',
+      },
+      {
+        key: 'avg_gt_track_length', label: 'Avg truth length', description: 'Mean truth track length', format: 'frames',
+      },
+      {
+        key: 'track_completeness', label: 'Completeness', description: 'Mean truth coverage by the best computed track', format: 'ratio', higherIsBetter: true,
+      },
+    ],
+  },
+  {
+    name: 'Dataset',
+    metrics: [
+      {
+        key: 'total_frames', label: 'Frames', description: 'Frames carrying any object', format: 'count',
+      },
+      {
+        key: 'total_gt_objects', label: 'Truth objects', description: 'Truth objects scored', format: 'count',
+      },
+      {
+        key: 'total_computed', label: 'Computed objects', description: 'Computed objects scored', format: 'count',
+      },
+      {
+        key: 'total_gt_tracks', label: 'Truth tracks', description: 'Distinct truth track ids', format: 'count',
+      },
+      {
+        key: 'total_computed_tracks', label: 'Computed tracks', description: 'Distinct computed track ids', format: 'count',
+      },
+      {
+        key: 'classification_accuracy', label: 'Classification accuracy', description: 'Matched pairs whose classes agree', format: 'ratio', higherIsBetter: true,
+      },
+    ],
+  },
+];
+
+export const METRIC_DEFINITIONS: Record<string, MetricDefinition> = Object.fromEntries(
+  METRIC_GROUPS.flatMap((group) => group.metrics.map((m) => [m.key, m])),
+);
+
+export function formatMetric(value: number | null | undefined, format: MetricDefinition['format'] = 'ratio'): string {
+  if (value === null || value === undefined || !Number.isFinite(value)) return 'n/a';
+  switch (format) {
+    case 'count':
+      return String(Math.round(value));
+    case 'frames':
+      return `${value.toFixed(1)} f`;
+    case 'pixels':
+      return `${value.toFixed(1)} px`;
+    case 'number':
+      return value.toFixed(3);
+    case 'ratio':
+    default:
+      return value.toFixed(3);
+  }
+}
+
+/** Compact label for a source, used in chips and result titles. */
+export function describeSource(source: { datasetId: string; set?: string; revision?: number; file?: string; label?: string }, datasetName?: string): string {
+  if (source.label) return source.label;
+  const parts = [datasetName || source.datasetId];
+  if (source.set) parts.push(`set ${source.set}`);
+  if (source.revision !== undefined) parts.push(`rev ${source.revision}`);
+  if (source.file) parts.push(source.file.split(/[\\/]/).pop() || source.file);
+  return parts.join(' · ');
+}
diff --git a/client/dive-common/scoring/types.ts b/client/dive-common/scoring/types.ts
new file mode 100644
index 000000000..3a855847b
--- /dev/null
+++ b/client/dive-common/scoring/types.ts
@@ -0,0 +1,144 @@
+/**
+ * Scoring mode: contract shared by the viewer panel, the web platform and the
+ * desktop platform. Both platforms run the `viame score` applet on two VIAME
+ * CSV exports and store its output verbatim inside a {@link ScoringResultFile}.
+ */
+
+export type ScoringMatchMode = 'box' | 'polygon';
+
+export type ScoringFilterEstimator = 'none' | 'min' | 'avg' | 'avg_minus_1p' | 'idf1' | 'mota';
+
+/** Every `viame score` option the panel exposes. */
+export interface ScoringParams {
+  /** IoU needed for a computed object to match a truth object (--iou) */
+  iouThreshold: number;
+  /** Computed objects below this confidence are dropped before scoring (--conf) */
+  confidenceThreshold: number;
+  /** Overlap boxes, or polygons where both sides carry one (--match-mode) */
+  matchMode: ScoringMatchMode;
+  /** Also report every class on its own (--per-class) */
+  perClass: boolean;
+  /** Offer each detection only to its best class in per-class scoring (--top-class) */
+  topClass: boolean;
+  /** Rank on the detection confidence column rather than the class score (--aux-confidence) */
+  auxConfidence: boolean;
+  /** Compute MOT, HOTA and KWANT track metrics (omits --no-tracking) */
+  tracking: boolean;
+  /** Keypoint tolerance as a fraction of the truth length (--keypoint-threshold) */
+  keypointThreshold: number;
+  /** Score across a range of confidence thresholds (--sweep-thresholds) */
+  sweep: boolean;
+  /** Number of thresholds in the sweep (--sweep-interval) */
+  sweepInterval: number;
+  /** How swept thresholds become a recommended confidence filter (--filter-estimator) */
+  filterEstimator: ScoringFilterEstimator;
+  /** Class reported for objects that carry none (--defaultlabel) */
+  defaultLabel?: string;
+  /** Class synonym file content, one `canonical: alias, alias` per line (--labels) */
+  labelSynonyms?: string;
+}
+
+/**
+ * One side of a comparison. The dataset supplies the media, so two sources
+ * naming the same dataset compare two annotation sets of one sequence, and two
+ * naming different datasets compare separately imported annotations of the
+ * same footage.
+ */
+export interface ScoringSource {
+  datasetId: string;
+  /** Web annotation set; the default set when empty */
+  set?: string;
+  /** Web revision to score at; the latest when omitted */
+  revision?: number;
+  /**
+   * Desktop annotation file: an earlier `result_*.json` rotated into the
+   * project's auxiliary folder, or any annotation file on disk. The dataset's
+   * current annotations when omitted.
+   */
+  file?: string;
+  /** Shown in the results view in place of the raw identifiers */
+  label?: string;
+}
+
+/** One sequence to score: computed annotations against the truth for the same footage. */
+export interface ScoringPair {
+  computed: ScoringSource;
+  truth: ScoringSource;
+}
+
+/**
+ * A run scores every pair together, so the metrics aggregate across sequences
+ * the way `viame score` does for a folder of files. The result is stored on
+ * the first pair's computed dataset.
+ */
+export interface ScoringJobArgs {
+  pairs: ScoringPair[];
+  params: ScoringParams;
+  title?: string;
+}
+
+/** Choices a platform can offer for a source on a given dataset. */
+export interface ScoringSourceOptions {
+  sets: string[];
+  revisions: {
+    revision: number;
+    description: string;
+    created: string;
+    author?: string;
+    set?: string;
+  }[];
+  files: {
+    path: string;
+    name: string;
+    modified: string;
+  }[];
+  /** The platform can score any annotation file the user browses to */
+  allowFilePaths?: boolean;
+}
+
+export interface ScoringDatasetSummary {
+  id: string;
+  name: string;
+  type?: string;
+}
+
+/** The metrics JSON `viame score -o` writes, kept exactly as emitted. */
+export type RawScoringMetrics = Record<string, unknown>;
+
+/** The JSON `viame score --output-matches` writes, kept exactly as emitted. */
+export interface RawScoringMatches {
+  columns: string[];
+  frame_names: [number, number, string][];
+  rows: (number | string | null)[][];
+}
+
+export const SCORING_RESULT_VERSION = 1;
+
+/** What a platform persists for one run; also what it hands back on load. */
+export interface ScoringResultFile {
+  version: number;
+  id: string;
+  /** Dataset the result is stored on: the first pair's computed dataset */
+  datasetId: string;
+  created: string;
+  title: string;
+  /** In the order they were scored; the matches' sequence index refers to this */
+  pairs: ScoringPair[];
+  params: ScoringParams;
+  metrics: RawScoringMetrics;
+  matches?: RawScoringMatches;
+  summaryText?: string;
+}
+
+/** Listing entry: everything but the bulky payloads, plus headline numbers. */
+export interface ScoringResultSummary {
+  id: string;
+  datasetId: string;
+  created: string;
+  title: string;
+  pairs: ScoringPair[];
+  params: ScoringParams;
+  headline: Record<string, number | null>;
+}
+
+export type ScoringResult = ScoringResultFile;
diff --git a/client/dive-common/use/useScoring.spec.ts b/client/dive-common/use/useScoring.spec.ts
new file mode 100644
index 000000000..b3bdc3edc
--- /dev/null
+++ b/client/dive-common/use/useScoring.spec.ts
@@ -0,0 +1,97 @@
+import { createScoringService, ScoringApi } from './useScoring';
+import type { ScoringResultFile, ScoringResultSummary } from '../scoring/types';
+import { DEFAULT_SCORING_PARAMS } from '../scoring/metrics';
+
+function makeApi(overrides: Partial<ScoringApi> = {}): ScoringApi {
+  const stored: ScoringResultFile = {
+    version: 1,
+    id: 'scoring_1.json',
+    datasetId: 'a',
+    created: '2026-09-06T00:00:00.000Z',
+    title: 'a vs b',
+    pairs: [{ computed: { datasetId: 'a' }, truth: { datasetId: 'b' } }],
+    params: { ...DEFAULT_SCORING_PARAMS, iouThreshold: 0.7 },
+    metrics: { precision: 1 },
+  };
+  const summary: ScoringResultSummary = {
+    id: stored.id,
+    datasetId: 'a',
+    created: stored.created,
+    title: stored.title,
+    pairs: stored.pairs,
+    params: stored.params,
+    headline: { precision: 1 },
+  };
+  return {
+    runScoring: vi.fn(async () => undefined),
+    listScoringResults: vi.fn(async () => [summary]),
+    loadScoringResult: vi.fn(async () => stored),
+    deleteScoringResult: vi.fn(async () => undefined),
+    listScoringSources: vi.fn(async (id: string) => ({
+      sets: id === 'a' ? ['default', 'groundTruth'] : [],
+      revisions: [],
+      files: [],
+    })),
+    listScoringDatasets: vi.fn(async () => [{ id: 'a', name: 'Alpha' }, { id: 'b', name: 'Beta' }]),
+    loadConfig: vi.fn(async () => ({ confidenceFilters: { default: 0.1 } } as never)),
+    saveConfig: vi.fn(async () => undefined),
+    openFromDisk: vi.fn(async () => ({ filePaths: [] })),
+    ...overrides,
+  };
+}
+
+describe('createScoringService', () => {
+  it('defaults the truth side to a ground-truth-named set when one exists', async () => {
+    const service = createScoringService({ api: makeApi() });
+    await service.setDatasets(['a', 'b', 'a']);
+    expect(service.pairs.value).toHaveLength(2);
+    expect(service.pairs.value[0].truth).toEqual({ datasetId: 'a', set: 'groundTruth' });
+    expect(service.pairs.value[1].truth).toEqual({ datasetId: 'b' });
+  });
+
+  it('refuses to run a pair whose sides are identical', async () => {
+    const api = makeApi();
+    const service = createScoringService({ api });
+    await service.setDatasets(['b']);
+    await service.run();
+    expect(api.runScoring).not.toHaveBeenCalled();
+    expect(service.error.value).toContain('same annotations');
+  });
+
+  it('launches every pair as one job stored on the first computed dataset', async () => {
+    const api = makeApi({ watchScoringJob: vi.fn(async () => ({ ok: true })) });
+    const service = createScoringService({ api });
+    await service.refreshDatasets();
+    await service.setDatasets(['a']);
+    service.setTruth(0, { datasetId: 'b' });
+    service.swapPair(0);
+    expect(service.pairs.value[0].computed.datasetId).toBe('b');
+    await service.run();
+    const args = (api.runScoring as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(args.pairs).toHaveLength(1);
+    expect(args.pairs[0].computed.label).toBe('Beta');
+    expect(args.title).toBe('Beta vs Alpha');
+    expect(api.watchScoringJob).toHaveBeenCalledWith('b');
+    expect(service.selectedResultId.value).toBe('scoring_1.json');
+    expect(service.result.value?.title).toBe('a vs b');
+  });
+
+  it('applies confidence filters to every computed dataset of the loaded result', async () => {
+    const api = makeApi();
+    const service = createScoringService({ api });
+    await service.refreshResults();
+    await service.selectResult('scoring_1.json');
+    expect(service.currentFilters.value).toEqual({ default: 0.1 });
+    await service.applyConfidenceFilters({ fish: 0.4 });
+    expect(api.saveConfig).toHaveBeenCalledWith('a', { confidenceFilters: { default: 0.1, fish: 0.4 } });
+  });
+
+  it('restores a run\'s sequences and parameters into the form', async () => {
+    const service = createScoringService({ api: makeApi() });
+    await service.refreshResults();
+    await service.selectResult('scoring_1.json');
+    service.useResultSetup();
+    expect(service.pairs.value[0].truth.datasetId).toBe('b');
+    expect(service.params.iouThreshold).toBe(0.7);
+  });
+});
diff --git a/client/dive-common/use/useScoring.ts b/client/dive-common/use/useScoring.ts
new file mode 100644
index 000000000..15fa4b8b2
--- /dev/null
+++ b/client/dive-common/use/useScoring.ts
@@ -0,0 +1,449 @@
+import {
+  computed, inject, provide, reactive, ref, Ref, watch,
+} from 'vue';
+import type { Api } from 'dive-common/apispec';
+import type {
+  ScoringDatasetSummary,
+  ScoringJobArgs,
+  ScoringPair,
+  ScoringParams,
+  ScoringResult,
+  ScoringResultSummary,
+  ScoringSource,
+  ScoringSourceOptions,
+} from 'dive-common/scoring/types';
+import {
+  CLASS_PALETTE,
+  DEFAULT_SCORING_PARAMS,
+  describeSource,
+  parseScoringMatches,
+  parseScoringMetrics,
+  ScoringMatch,
+  ScoringMetrics,
+} from 'dive-common/scoring/metrics';
+
+const PARAMS_STORAGE_KEY = 'dive.scoring.params';
+const POLL_INTERVAL_MS = 5000;
+const POLL_TIMEOUT_MS = 30 * 60 * 1000;
+
+export const TRUTH_SET_NAMES = ['groundTruth', 'GT', 'ground_truth', 'Groundtruth', 'GroundTruth', 'gt', 'truth'];
+
+export type ScoringApi = Pick<Api,
+  'runScoring' | 'watchScoringJob' | 'listScoringResults' | 'loadScoringResult'
+  | 'deleteScoringResult' | 'listScoringSources' | 'listScoringDatasets' | 'pickScoringDataset'
+  | 'openFromDisk' | 'loadConfig' | 'saveConfig'>;
+
+export interface ScoringServiceDeps {
+  api: ScoringApi;
+}
+
+export interface ScoringService {
+  available: Readonly<Ref<boolean>>;
+  pairs: Ref<ScoringPair[]>;
+  params: ScoringParams;
+  datasets: Readonly<Ref<ScoringDatasetSummary[]>>;
+  results: Readonly<Ref<ScoringResultSummary[]>>;
+  selectedResultId: Readonly<Ref<string | null>>;
+  result: Readonly<Ref<ScoringResult | null>>;
+  metrics: Readonly<Ref<ScoringMetrics | null>>;
+  matches: Readonly<Ref<ScoringMatch[]>>;
+  /** Confidence filters currently saved on the loaded result's primary computed dataset */
+  currentFilters: Readonly<Ref<Record<string, number>>>;
+  running: Readonly<Ref<boolean>>;
+  loading: Readonly<Ref<boolean>>;
+  status: Readonly<Ref<string | null>>;
+  error: Readonly<Ref<string | null>>;
+  datasetName(id: string): string;
+  sourceLabel(source: ScoringSource): string;
+  classColor(name: string): string;
+  sourceOptions(datasetId: string): Promise<ScoringSourceOptions>;
+  refreshDatasets(): Promise<void>;
+  refreshResults(): Promise<void>;
+  selectResult(id: string | null): Promise<void>;
+  deleteResult(id: string): Promise<void>;
+  addDataset(datasetId: string, summary?: ScoringDatasetSummary): Promise<void>;
+  setDatasets(datasetIds: string[]): Promise<void>;
+  removePair(index: number): void;
+  swapPair(index: number): void;
+  setComputed(index: number, source: ScoringSource): void;
+  setTruth(index: number, source: ScoringSource): void;
+  useResultSetup(): void;
+  resetParams(): void;
+  run(): Promise<void>;
+  applyConfidenceFilters(filters: Record<string, number>): Promise<void>;
+  clearError(): void;
+}
+
+function loadStoredParams(): ScoringParams {
+  try {
+    const raw = window.localStorage.getItem(PARAMS_STORAGE_KEY);
+    if (raw) {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === 'object') {
+        return { ...DEFAULT_SCORING_PARAMS, ...parsed };
+      }
+    }
+  } catch {
+    // Storage may be unavailable; defaults are fine.
+  }
+  return { ...DEFAULT_SCORING_PARAMS };
+}
+
+function storeParams(params: ScoringParams) {
+  try {
+    window.localStorage.setItem(PARAMS_STORAGE_KEY, JSON.stringify(params));
+  } catch {
+    // Ignore storage failures.
+  }
+}
+
+export function sameSource(a: ScoringSource, b: ScoringSource) {
+  return a.datasetId === b.datasetId
+    && (a.set || '') === (b.set || '')
+    && a.revision === b.revision
+    && (a.file || '') === (b.file || '');
+}
+
+export function createScoringService(deps: ScoringServiceDeps): ScoringService {
+  const { api } = deps;
+  const available = computed(() => typeof api.runScoring === 'function'
+    && typeof api.listScoringResults === 'function'
+    && typeof api.loadScoringResult === 'function');
+
+  const pairs = ref<ScoringPair[]>([]);
+  const params = reactive<ScoringParams>(loadStoredParams());
+  watch(params, () => storeParams({ ...params }), { deep: true });
+
+  const datasets = ref<ScoringDatasetSummary[]>([]);
+  const optionsCache = new Map<string, ScoringSourceOptions>();
+  const results = ref<ScoringResultSummary[]>([]);
+  const selectedResultId = ref<string | null>(null);
+  const result = ref<ScoringResult | null>(null);
+  const currentFilters = ref<Record<string, number>>({});
+  const running = ref(false);
+  const loading = ref(false);
+  const status = ref<string | null>(null);
+  const error = ref<string | null>(null);
+
+  const metrics = computed(() => (result.value ? parseScoringMetrics(result.value.metrics) : null));
+  const matches = computed(() => (result.value ? parseScoringMatches(result.value.matches) : []));
+
+  const classColors = new Map<string, string>();
+  function classColor(name: string) {
+    let color = classColors.get(name);
+    if (!color) {
+      color = CLASS_PALETTE[classColors.size % CLASS_PALETTE.length];
+      classColors.set(name, color);
+    }
+    return color;
+  }
+
+  function datasetName(id: string) {
+    return datasets.value.find((d) => d.id === id)?.name || id;
+  }
+
+  function sourceLabel(source: ScoringSource) {
+    return describeSource(source, datasetName(source.datasetId));
+  }
+
+  function fail(reason: unknown, fallback: string) {
+    const message = reason instanceof Error ? reason.message : String(reason || fallback);
+    error.value = message || fallback;
+  }
+
+  async function refreshDatasets() {
+    if (!api.listScoringDatasets) return;
+    try {
+      datasets.value = await api.listScoringDatasets();
+    } catch (err) {
+      fail(err, 'Could not list datasets');
+    }
+  }
+
+  async function sourceOptions(datasetId: string): Promise<ScoringSourceOptions> {
+    const cached = optionsCache.get(datasetId);
+    if (cached) return cached;
+    const empty: ScoringSourceOptions = { sets: [], revisions: [], files: [] };
+    if (!api.listScoringSources) return empty;
+    try {
+      const options = await api.listScoringSources(datasetId);
+      optionsCache.set(datasetId, options);
+      return options;
+    } catch (err) {
+      fail(err, 'Could not list annotation sources');
+      return empty;
+    }
+  }
+
+  async function refreshResults() {
+    if (!api.listScoringResults) return;
+    loading.value = true;
+    try {
+      const list = await api.listScoringResults();
+      results.value = [...list].sort((a, b) => b.created.localeCompare(a.created));
+      if (selectedResultId.value && !results.value.some((r) => r.id === selectedResultId.value)) {
+        selectedResultId.value = null;
+        result.value = null;
+      }
+    } catch (err) {
+      fail(err, 'Could not list scoring results');
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function loadCurrentFilters() {
+    currentFilters.value = {};
+    const primary = result.value?.pairs[0]?.computed.datasetId;
+    if (!primary) return;
+    try {
+      const config = await api.loadConfig(primary);
+      currentFilters.value = { ...(config.confidenceFilters || {}) };
+    } catch {
+      // The dataset may be gone; the charts simply omit the current-filter line.
+    }
+  }
+
+  async function selectResult(id: string | null) {
+    selectedResultId.value = id;
+    if (!id || !api.loadScoringResult) {
+      result.value = null;
+      currentFilters.value = {};
+      return;
+    }
+    const summary = results.value.find((r) => r.id === id);
+    if (!summary) {
+      result.value = null;
+      return;
+    }
+    loading.value = true;
+    try {
+      result.value = await api.loadScoringResult(summary.datasetId, id);
+      await loadCurrentFilters();
+    } catch (err) {
+      result.value = null;
+      fail(err, 'Could not load the scoring result');
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function deleteResult(id: string) {
+    if (!api.deleteScoringResult) return;
+    const summary = results.value.find((r) => r.id === id);
+    if (!summary) return;
+    try {
+      await api.deleteScoringResult(summary.datasetId, id);
+      if (selectedResultId.value === id) {
+        selectedResultId.value = null;
+        result.value = null;
+      }
+      await refreshResults();
+    } catch (err) {
+      fail(err, 'Could not delete the scoring result');
+    }
+  }
+
+  /**
+   * A set named like ground truth is the obvious truth side when the platform
+   * has sets; otherwise both sides start on the current annotations and the
+   * user picks a revision, file or other dataset for one of them.
+   */
+  async function defaultPair(datasetId: string): Promise<ScoringPair> {
+    const options = await sourceOptions(datasetId);
+    const gtSet = options.sets.find((s) => TRUTH_SET_NAMES.includes(s));
+    return {
+      computed: { datasetId },
+      truth: gtSet ? { datasetId, set: gtSet } : { datasetId },
+    };
+  }
+
+  function rememberDataset(summary?: ScoringDatasetSummary) {
+    if (!summary || datasets.value.some((d) => d.id === summary.id)) return;
+    datasets.value = [...datasets.value, summary];
+  }
+
+  async function addDataset(datasetId: string, summary?: ScoringDatasetSummary) {
+    if (pairs.value.some((p) => p.computed.datasetId === datasetId)) return;
+    rememberDataset(summary);
+    pairs.value = [...pairs.value, await defaultPair(datasetId)];
+  }
+
+  async function setDatasets(datasetIds: string[]) {
+    const unique = Array.from(new Set(datasetIds.filter(Boolean)));
+    pairs.value = await Promise.all(unique.map(defaultPair));
+  }
+
+  function removePair(index: number) {
+    pairs.value = pairs.value.filter((_, i) => i !== index);
+  }
+
+  function swapPair(index: number) {
+    pairs.value = pairs.value.map((p, i) => (i === index ? { computed: p.truth, truth: p.computed } : p));
+  }
+
+  function setComputed(index: number, source: ScoringSource) {
+    pairs.value = pairs.value.map((p, i) => (i === index ? { ...p, computed: source } : p));
+  }
+
+  function setTruth(index: number, source: ScoringSource) {
+    pairs.value = pairs.value.map((p, i) => (i === index ? { ...p, truth: source } : p));
+  }
+
+  function useResultSetup() {
+    if (!result.value) return;
+    pairs.value = result.value.pairs.map((p) => ({ computed: { ...p.computed }, truth: { ...p.truth } }));
+    Object.assign(params, DEFAULT_SCORING_PARAMS, result.value.params);
+  }
+
+  function resetParams() {
+    Object.assign(params, DEFAULT_SCORING_PARAMS);
+  }
+
+  function clearError() {
+    error.value = null;
+  }
+
+  function sleep(ms: number) {
+    return new Promise<void>((resolve) => { setTimeout(resolve, ms); });
+  }
+
+  /**
+   * Without a job feed the only signal that a run finished is its result
+   * appearing in the listing, so poll for an entry newer than the launch.
+   */
+  async function pollForResult(startedAt: string): Promise<ScoringResultSummary | null> {
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      // eslint-disable-next-line no-await-in-loop
+      await sleep(POLL_INTERVAL_MS);
+      // eslint-disable-next-line no-await-in-loop
+      await refreshResults();
+      const fresh = results.value.find((r) => r.created >= startedAt);
+      if (fresh) return fresh;
+    }
+    return null;
+  }
+
+  function validatePairs(): string | null {
+    if (pairs.value.length === 0) return 'Add at least one sequence to score.';
+    const bad = pairs.value.find((p) => sameSource(p.computed, p.truth));
+    if (bad) {
+      return `${datasetName(bad.computed.datasetId)}: computed and truth point at the same annotations; pick a different set, revision, file or dataset for one of them.`;
+    }
+    return null;
+  }
+
+  async function run() {
+    if (!api.runScoring || running.value) return;
+    const problem = validatePairs();
+    if (problem) {
+      error.value = problem;
+      return;
+    }
+    error.value = null;
+    running.value = true;
+    status.value = 'Launching scoring job';
+    const startedAt = new Date().toISOString();
+    const labelled = pairs.value.map((p) => ({
+      computed: { ...p.computed, label: sourceLabel(p.computed) },
+      truth: { ...p.truth, label: sourceLabel(p.truth) },
+    }));
+    const first = labelled[0];
+    const title = labelled.length === 1
+      ? `${first.computed.label} vs ${first.truth.label}`
+      : `${first.computed.label} vs ${first.truth.label} (+${labelled.length - 1} more)`;
+    const args: ScoringJobArgs = { pairs: labelled, params: { ...params }, title };
+    const primary = first.computed.datasetId;
+    try {
+      await api.runScoring(args);
+      status.value = `Scoring ${labelled.length} sequence${labelled.length === 1 ? '' : 's'}`;
+      let newest: ScoringResultSummary | null = null;
+      if (api.watchScoringJob) {
+        const outcome = await api.watchScoringJob(primary);
+        if (!outcome.ok) {
+          throw new Error(outcome.message || 'The scoring job failed; see the Jobs tab for its log.');
+        }
+        await refreshResults();
+        newest = results.value.find((r) => r.created >= startedAt && r.datasetId === primary)
+          || results.value[0] || null;
+      } else {
+        newest = await pollForResult(startedAt);
+        if (!newest) throw new Error('Timed out waiting for the scoring result.');
+      }
+      if (newest) await selectResult(newest.id);
+      status.value = null;
+    } catch (err) {
+      status.value = null;
+      fail(err, 'Scoring failed');
+    } finally {
+      running.value = false;
+    }
+  }
+
+  /** Save the filters on every computed dataset of the loaded result. */
+  async function applyConfidenceFilters(filters: Record<string, number>) {
+    const targets = Array.from(new Set((result.value?.pairs || []).map((p) => p.computed.datasetId)));
+    try {
+      await Promise.all(targets.map(async (datasetId) => {
+        const config = await api.loadConfig(datasetId);
+        await api.saveConfig(datasetId, {
+          confidenceFilters: { ...(config.confidenceFilters || {}), ...filters },
+        });
+      }));
+      await loadCurrentFilters();
+    } catch (err) {
+      fail(err, 'Could not save the confidence filters');
+    }
+  }
+
+  return {
+    available,
+    pairs,
+    params,
+    datasets,
+    results,
+    selectedResultId,
+    result,
+    metrics,
+    matches,
+    currentFilters,
+    running,
+    loading,
+    status,
+    error,
+    datasetName,
+    sourceLabel,
+    classColor,
+    sourceOptions,
+    refreshDatasets,
+    refreshResults,
+    selectResult,
+    deleteResult,
+    addDataset,
+    setDatasets,
+    removePair,
+    swapPair,
+    setComputed,
+    setTruth,
+    useResultSetup,
+    resetParams,
+    run,
+    applyConfidenceFilters,
+    clearError,
+  };
+}
+
+const ScoringSymbol = Symbol('scoring');
+
+export function provideScoring(service: ScoringService) {
+  provide(ScoringSymbol, service);
+}
+
+export function useScoring(): ScoringService {
+  const service = inject<ScoringService | null>(ScoringSymbol, null);
+  if (!service) {
+    throw new Error('Scoring service not provided');
+  }
+  return service;
+}
diff --git a/client/package.json b/client/package.json
index 3603cac89..0baa7f024 100644
--- a/client/package.json
+++ b/client/package.json
@@ -13,7 +13,7 @@
     "dev:electron": "npm run serve:electron",
     "dev:electron:windows": "npm run serve:electron:windows",
     "serve": "vite",
-    "serve:electron": "mkdir -p /tmp/dive-electron && cross-env ELECTRON_RUN_AS_NODE= ELECTRON_DISABLE_SECURITY_WARNINGS=true TMPDIR=/tmp/dive-electron XDG_RUNTIME_DIR=/tmp/dive-electron electron-vite dev --entry=.electron/main/background.js",
+    "serve:electron": "mkdir -p /tmp/dive-electron && cross-env ELECTRON_RUN_AS_NODE= ELECTRON_DISABLE_SECURITY_WARNINGS=true TMPDIR=/tmp/dive-electron electron-vite dev --entry=.electron/main/background.js",
     "serve:electron:windows": "cross-env ELECTRON_DISABLE_SECURITY_WARNINGS=true electron-vite dev --entry=.electron/main/background.js",
     "build:web": "vite build",
     "build:electron": "electron-vite build && electron-builder --config electron-builder.json",
diff --git a/client/platform/desktop/backend/ipcService.ts b/client/platform/desktop/backend/ipcService.ts
index a890d6f59..ae2a29a60 100644
--- a/client/platform/desktop/backend/ipcService.ts
+++ b/client/platform/desktop/backend/ipcService.ts
@@ -14,6 +14,7 @@ import {
   ExportTrainedPipeline,
   ConversionArgs,
   DesktopJob,
+  RunScoring,
 } from 'platform/desktop/constants';
 import { convertMedia } from 'platform/desktop/backend/native/mediaJobs';
 import { closeChildById } from 'platform/desktop/backend/native/processManager';
@@ -132,6 +133,15 @@ export default function register() {
   ipcMain.on('update-settings', async (_, s: Settings) => {
     settings.set(s);
   });
+  ipcMain.handle('write-text-file', async (_, args: { path: string; content: string }) => {
+    await fs.promises.writeFile(args.path, args.content, 'utf-8');
+    return args.path;
+  });
+  ipcMain.handle('print-to-pdf', async (event, args: { path: string }) => {
+    const data = await event.sender.printToPDF({ printBackground: true, pageSize: 'Letter' });
+    await fs.promises.writeFile(args.path, data);
+    return args.path;
+  });
   ipcMain.handle('export-dataset', async (_, args: ExportDatasetArgs) => {
     const ret = await common.exportDataset(settings.get(), args);
     return ret;
@@ -351,6 +361,29 @@ export default function register() {
     };
     return currentPlatform.train(settings.get(), args, updater);
   });
+  ipcMain.handle('run-scoring', async (event, args: RunScoring) => {
+    const updater = (update: DesktopJobUpdate) => {
+      event.sender.send('job-update', update);
+    };
+    return currentPlatform.runScoring(settings.get(), args, updater);
+  });
+  ipcMain.handle('list-scoring-sources', async (_, { datasetId }: { datasetId: string }) => (
+    common.listScoringSources(settings.get(), datasetId)
+  ));
+  ipcMain.handle('list-scoring-datasets', async () => common.listScoringDatasets(settings.get()));
+  ipcMain.handle('list-scoring-results', async (_, { datasetId }: { datasetId?: string } = {}) => (
+    common.listScoringResults(settings.get(), datasetId)
+  ));
+  ipcMain.handle('load-scoring-result', async (
+    _,
+    { datasetId, resultId }: { datasetId: string; resultId: string },
+  ) => common.loadScoringResult(settings.get(), datasetId, resultId));
+  ipcMain.handle('delete-scoring-result', async (
+    _,
+    { datasetId, resultId }: { datasetId: string; resultId: string },
+  ) => {
+    await common.deleteScoringResult(settings.get(), datasetId, resultId);
+  });
   ipcMain.handle('list-resumable-training', async () => common.findResumableTrainingJobs(settings.get()));
   ipcMain.handle('discard-resumable-training', async (_event, workingDir: string) => {
     await common.discardResumableTraining(settings.get(), workingDir);
diff --git a/client/platform/desktop/backend/native/common.spec.ts b/client/platform/desktop/backend/native/common.spec.ts
index 856fba60d..8b9bfa327 100644
--- a/client/platform/desktop/backend/native/common.spec.ts
+++ b/client/platform/desktop/backend/native/common.spec.ts
@@ -134,6 +134,61 @@ const console = new Console(process.stdout, process.stderr);
 
 const emptyCsvString = '# comment line\n# metadata,fps: 32,"whatever"\n#comment line';
 
+const scoringTrackFixture = {
+  version: AnnotationsCurrentVersion,
+  groups: {},
+  tracks: {
+    1: {
+      id: 1,
+      begin: 0,
+      end: 0,
+      attributes: {},
+      confidencePairs: [['shark', 0.9]],
+      features: [{ frame: 0, bounds: [0, 0, 1, 1] }],
+    },
+  },
+};
+
+const scoringResultFixture = {
+  version: 1,
+  id: 'ignored-on-load',
+  datasetId: 'projectidScoring',
+  created: '2026-01-02T03:04:05.000Z',
+  title: 'current vs old',
+  pairs: [{
+    computed: { datasetId: 'projectidScoring' },
+    truth: { datasetId: 'projectidScoring', file: '/home/user/viamedata/DIVE_Projects/projectidScoring/auxiliary/result_old.json' },
+  }],
+  params: {
+    iouThreshold: 0.5,
+    confidenceThreshold: 0,
+    matchMode: 'box',
+    perClass: true,
+    topClass: false,
+    auxConfidence: false,
+    tracking: true,
+    keypointThreshold: 0.1,
+    sweep: false,
+    sweepInterval: 50,
+    filterEstimator: 'min',
+  },
+  metrics: { precision: 0.5, recall: 1, per_class: { shark: { precision: 0.5 } } },
+};
+
+/** Written before results recorded their storage dataset, and scoring two sequences. */
+const legacyScoringResultFixture = {
+  version: 1,
+  id: 'ignored-on-load',
+  created: '2025-12-31T00:00:00.000Z',
+  title: 'two sequences',
+  pairs: [
+    { computed: { datasetId: 'projectidScoring2' }, truth: { datasetId: 'projectidScoring' } },
+    { computed: { datasetId: 'projectidScoring' }, truth: { datasetId: 'projectidScoring2' } },
+  ],
+  params: scoringResultFixture.params,
+  metrics: { precision: 0.25 },
+};
+
 function cocoWithRle(trackId: number, categoryName = 'fish') {
   return JSON.stringify({
     images: [{ id: 1, file_name: 'frame_000001.jpg', frame_index: 0 }],
@@ -870,6 +925,46 @@ beforeEach(() => {
           'result_whatever.json': JSON.stringify({}),
           auxiliary: {},
         },
+        projectidScoring: {
+          'dataset.json': JSON.stringify({
+            version: 1,
+            id: 'projectidScoring',
+            name: 'Scoring Project',
+            type: 'image-sequence',
+            fps: 5,
+            originalBasePath: '/home/user/media/scoring',
+            originalImageFiles: ['a.png'],
+          } as JsonConfig),
+          'result_current.json': JSON.stringify(scoringTrackFixture),
+          auxiliary: {
+            'scoring_2026-01-02_03-04-05.000.json': JSON.stringify(scoringResultFixture),
+            'scoring_broken.json': '{not json',
+            'result_old.json': mockfs.file({
+              content: JSON.stringify(scoringTrackFixture),
+              mtime: new Date('2026-01-01T00:00:00Z'),
+            }),
+            'imported_annotations.csv': mockfs.file({
+              content: emptyCsvString,
+              mtime: new Date('2026-01-03T00:00:00Z'),
+            }),
+            'flight_log.csv': '',
+          },
+        },
+        projectidScoring2: {
+          'dataset.json': JSON.stringify({
+            version: 1,
+            id: 'projectidScoring2',
+            name: 'Second Scoring Project',
+            type: 'image-sequence',
+            fps: 5,
+            originalBasePath: '/home/user/media/scoring2',
+            originalImageFiles: ['a.png'],
+          } as JsonConfig),
+          'result_current.json': JSON.stringify(scoringTrackFixture),
+          auxiliary: {
+            'scoring_2025-12-31_00-00-00.000.json': JSON.stringify(legacyScoringResultFixture),
+          },
+        },
         projectid5missingMultiCam: {
           'meta.json': JSON.stringify({
             version: 1,
@@ -2980,6 +3075,105 @@ describe('frame metadata import gates', () => {
   });
 });
 
+describe('scoring results and sources', () => {
+  const projectDir = '/home/user/viamedata/DIVE_Projects/projectidScoring';
+
+  it('listScoringResults summarizes readable result files and skips broken ones', async () => {
+    const warn = vi.spyOn(globalThis.console, 'warn').mockImplementation(() => undefined);
+    const results = await common.listScoringResults(settings, 'projectidScoring');
+    expect(results).toHaveLength(1);
+    expect(results[0].id).toBe('scoring_2026-01-02_03-04-05.000.json');
+    expect(results[0].datasetId).toBe('projectidScoring');
+    expect(results[0].title).toBe('current vs old');
+    expect(results[0].pairs).toEqual(scoringResultFixture.pairs);
+    expect(results[0].headline.precision).toBe(0.5);
+    expect(results[0]).not.toHaveProperty('metrics');
+    expect(warn).toHaveBeenCalledTimes(1);
+    warn.mockRestore();
+  });
+
+  it('listScoringResults without a dataset gathers every project newest first', async () => {
+    const warn = vi.spyOn(globalThis.console, 'warn').mockImplementation(() => undefined);
+    const results = await common.listScoringResults(settings);
+    expect(results.map((r) => [r.id, r.datasetId])).toEqual([
+      ['scoring_2026-01-02_03-04-05.000.json', 'projectidScoring'],
+      ['scoring_2025-12-31_00-00-00.000.json', 'projectidScoring2'],
+    ]);
+    expect(results[1].pairs).toHaveLength(2);
+    expect(results[1].headline.precision).toBe(0.25);
+    expect(warn).toHaveBeenCalledTimes(1);
+    warn.mockRestore();
+  });
+
+  it('loadScoringResult returns the file with its basename as id', async () => {
+    const result = await common.loadScoringResult(
+      settings,
+      'projectidScoring',
+      'scoring_2026-01-02_03-04-05.000.json',
+    );
+    expect(result.id).toBe('scoring_2026-01-02_03-04-05.000.json');
+    expect(result.metrics.per_class).toEqual({ shark: { precision: 0.5 } });
+    expect(result.pairs[0].truth.file).toBe(`${projectDir}/auxiliary/result_old.json`);
+  });
+
+  it('deleteScoringResult rejects ids that are not result files inside auxiliary', async () => {
+    await expect(common.deleteScoringResult(settings, 'projectidScoring', '../result_current.json'))
+      .rejects.toThrow('not a scoring result id');
+    await expect(common.deleteScoringResult(settings, 'projectidScoring', 'scoring_../dataset.json'))
+      .rejects.toThrow('not a scoring result id');
+    await expect(common.deleteScoringResult(settings, 'projectidScoring', 'result_old.json'))
+      .rejects.toThrow('not a scoring result id');
+    expect(fs.existsSync(`${projectDir}/result_current.json`)).toBe(true);
+    expect(fs.existsSync(`${projectDir}/auxiliary/result_old.json`)).toBe(true);
+
+    await common.deleteScoringResult(settings, 'projectidScoring', 'scoring_2026-01-02_03-04-05.000.json');
+    expect(fs.existsSync(`${projectDir}/auxiliary/scoring_2026-01-02_03-04-05.000.json`)).toBe(false);
+  });
+
+  it('listScoringSources lists rotated and imported annotation files newest first', async () => {
+    const options = await common.listScoringSources(settings, 'projectidScoring');
+    expect(options.sets).toEqual([]);
+    expect(options.revisions).toEqual([]);
+    expect(options.files.map((f) => f.name)).toEqual(['imported_annotations.csv', 'result_old.json']);
+    expect(options.files[1]).toEqual({
+      path: `${projectDir}/auxiliary/result_old.json`,
+      name: 'result_old.json',
+      modified: '2026-01-01T00:00:00.000Z',
+    });
+  });
+
+  it('listScoringDatasets reports every loadable project', async () => {
+    const datasets = await common.listScoringDatasets(settings);
+    expect(datasets).toContainEqual({ id: 'projectidScoring', name: 'Scoring Project', type: 'image-sequence' });
+    expect(datasets.find((d) => d.id === 'projectid2Bad')).toBeUndefined();
+  });
+
+  it('exportScoringSourceCsv writes current annotations, a rotated json, or copies a csv', async () => {
+    const current = '/home/user/output/current.csv';
+    await common.exportScoringSourceCsv(settings, { datasetId: 'projectidScoring' }, current);
+    expect(await fs.readFile(current, 'utf-8')).toContain('shark');
+
+    const rotated = '/home/user/output/rotated.csv';
+    await common.exportScoringSourceCsv(settings, {
+      datasetId: 'projectidScoring',
+      file: `${projectDir}/auxiliary/result_old.json`,
+    }, rotated);
+    expect(await fs.readFile(rotated, 'utf-8')).toContain('shark');
+
+    const copied = '/home/user/output/copied.csv';
+    await common.exportScoringSourceCsv(settings, {
+      datasetId: 'projectidScoring',
+      file: `${projectDir}/auxiliary/imported_annotations.csv`,
+    }, copied);
+    expect(await fs.readFile(copied, 'utf-8')).toBe(emptyCsvString);
+
+    await expect(common.exportScoringSourceCsv(settings, {
+      datasetId: 'projectidScoring',
+      file: `${projectDir}/auxiliary/flight_log.txt`,
+    }, '/home/user/output/bad.csv')).rejects.toThrow('not a CSV or JSON');
+  });
+});
+
 afterEach(() => {
   mockfs.restore();
 });
diff --git a/client/platform/desktop/backend/native/common.ts b/client/platform/desktop/backend/native/common.ts
index cbca22399..1fa16dec5 100644
--- a/client/platform/desktop/backend/native/common.ts
+++ b/client/platform/desktop/backend/native/common.ts
@@ -37,6 +37,11 @@ import {
   METADATA_ATTACHMENT_UNAVAILABLE, isFrameMetadataReadableName,
 } from 'dive-common/frameMetadata/readability';
 import { parentDatasetId, parseCompositeDatasetId } from 'dive-common/compositeDatasetId';
+import type {
+  ScoringDatasetSummary, ScoringResultFile, ScoringResultSummary,
+  ScoringSource, ScoringSourceOptions,
+} from 'dive-common/scoring/types';
+import { summarizeResult } from 'dive-common/scoring/metrics';
 import * as viameSerializers from 'platform/desktop/backend/serializers/viame';
 import * as nistSerializers from 'platform/desktop/backend/serializers/nist';
 import * as dive from 'platform/desktop/backend/serializers/dive';
@@ -96,6 +101,8 @@ const PortableConfigFileName = 'config.json';
 const DiveJobManifestName = 'dive_job_manifest.json';
 const PortableConfigFileNameLegacy = 'meta.json';
 const CsvFileName = /^.*\.csv$/i;
+const ImportedAnnotationFileName = /^imported_.+/i;
+const ScoringResultFileName = /^scoring_[\w.-]+\.json$/;
 const YAMLFileName = /^.*\.ya?ml$/i;
 
 const invalidHierarchyMessage = (reason: string) => (
@@ -2785,6 +2792,125 @@ async function exportDataset(settings: Settings, args: ExportDatasetArgs) {
   });
 }
 
+/**
+ * Annotation files a desktop scoring source can point at: track files rotated
+ * into auxiliary by earlier saves, and copies of imported annotation files.
+ */
+async function listScoringSources(
+  settings: Settings,
+  datasetId: string,
+): Promise<ScoringSourceOptions> {
+  const projectInfo = await getValidatedProjectDir(settings, datasetId);
+  const names = await fs.readdir(projectInfo.auxDirAbsPath);
+  const files = await Promise.all(names
+    .filter((name) => JsonTrackFileName.test(name) || ImportedAnnotationFileName.test(name))
+    .map(async (name) => {
+      const path = npath.join(projectInfo.auxDirAbsPath, name);
+      const stat = await fs.stat(path);
+      return stat.isFile() ? { path, name, modified: stat.mtime.toISOString() } : null;
+    }));
+  return {
+    sets: [],
+    revisions: [],
+    files: files
+      .filter((file): file is NonNullable<typeof file> => file !== null)
+      .sort((a, b) => b.modified.localeCompare(a.modified)),
+    allowFilePaths: true,
+  };
+}
+
+async function listScoringDatasets(settings: Settings): Promise<ScoringDatasetSummary[]> {
+  const metas = await autodiscoverData(settings);
+  return metas.map(({ id, name, type }) => ({ id, name, type }));
+}
+
+async function summarizeScoringResultsIn(
+  auxDirAbsPath: string,
+  datasetId: string,
+): Promise<ScoringResultSummary[]> {
+  const names = await listNames(auxDirAbsPath);
+  const summaries: ScoringResultSummary[] = [];
+  await Promise.all(names.filter((name) => ScoringResultFileName.test(name)).map(async (name) => {
+    try {
+      const file = await fs.readJson(npath.join(auxDirAbsPath, name)) as ScoringResultFile;
+      // Files written before datasetId existed live in the dataset they belong to.
+      summaries.push(summarizeResult({ ...file, id: name, datasetId: file.datasetId || datasetId }));
+    } catch (err) {
+      console.warn(`Skipping unreadable scoring result ${name}:`, err);
+    }
+  }));
+  return summaries;
+}
+
+/** Runs stored on one dataset, or on every project when no dataset is given. */
+async function listScoringResults(
+  settings: Settings,
+  datasetId?: string,
+): Promise<ScoringResultSummary[]> {
+  let summaries: ScoringResultSummary[];
+  if (datasetId) {
+    const projectInfo = await getValidatedProjectDir(settings, datasetId);
+    summaries = await summarizeScoringResultsIn(projectInfo.auxDirAbsPath, datasetId);
+  } else {
+    const projectIds = await listNames(npath.join(settings.dataPath, ProjectsFolderName));
+    summaries = (await Promise.all(projectIds.map((id) => (
+      summarizeScoringResultsIn(getProjectDir(settings, id).auxDirAbsPath, id)
+    )))).flat();
+  }
+  return summaries.sort((a, b) => b.created.localeCompare(a.created));
+}
+
+async function scoringResultPath(settings: Settings, datasetId: string, resultId: string) {
+  if (!ScoringResultFileName.test(resultId)) {
+    throw new Error(`${resultId} is not a scoring result id`);
+  }
+  const projectInfo = await getValidatedProjectDir(settings, datasetId);
+  const path = npath.resolve(projectInfo.auxDirAbsPath, resultId);
+  if (npath.dirname(path) !== npath.resolve(projectInfo.auxDirAbsPath)) {
+    throw new Error(`${resultId} is not a scoring result id`);
+  }
+  return path;
+}
+
+async function loadScoringResult(
+  settings: Settings,
+  datasetId: string,
+  resultId: string,
+): Promise<ScoringResultFile> {
+  const path = await scoringResultPath(settings, datasetId, resultId);
+  const file = await fs.readJson(path) as ScoringResultFile;
+  return { ...file, id: npath.basename(path), datasetId: file.datasetId || datasetId };
+}
+
+async function deleteScoringResult(settings: Settings, datasetId: string, resultId: string) {
+  await fs.unlink(await scoringResultPath(settings, datasetId, resultId));
+}
+
+/**
+ * Write one side of a scoring comparison as VIAME CSV. Every detection is
+ * kept so the scorer, not the dataset's display filter, applies thresholds.
+ */
+async function exportScoringSourceCsv(settings: Settings, source: ScoringSource, outPath: string) {
+  if (source.file && CsvFileName.test(source.file)) {
+    await fs.copy(source.file, outPath);
+    return;
+  }
+  const projectInfo = await getValidatedProjectDir(settings, source.datasetId);
+  let trackFile = projectInfo.trackFileAbsPath;
+  if (source.file) {
+    if (!JsonFileName.test(source.file)) {
+      throw new Error(`${source.file} is not a CSV or JSON annotation file`);
+    }
+    trackFile = source.file;
+  }
+  const meta = await loadJsonConfig(projectInfo.datasetFileAbsPath);
+  const data = await loadAnnotationFile(trackFile);
+  await viameSerializers.serializeFile(outPath, data, meta, new Set(), {
+    excludeBelowThreshold: false,
+    header: true,
+  });
+}
+
 async function exportConfiguration(settings: Settings, args: ExportConfigurationArgs) {
   const projectDirInfo = await getValidatedProjectDir(settings, args.id);
   const meta = await loadJsonConfig(projectDirInfo.datasetFileAbsPath);
@@ -2824,6 +2950,12 @@ export {
   checkDataset,
   exportConfiguration,
   exportDataset,
+  exportScoringSourceCsv,
+  listScoringSources,
+  listScoringDatasets,
+  listScoringResults,
+  loadScoringResult,
+  deleteScoringResult,
   finalizeMediaImport,
   getPipelineList,
   deleteTrainedPipeline,
diff --git a/client/platform/desktop/backend/native/linux.ts b/client/platform/desktop/backend/native/linux.ts
index 1bc3a077e..e7ca52d67 100644
--- a/client/platform/desktop/backend/native/linux.ts
+++ b/client/platform/desktop/backend/native/linux.ts
@@ -14,6 +14,7 @@ import {
   RunTraining,
   DesktopJobUpdater,
   ExportTrainedPipeline,
+  RunScoring,
 } from 'platform/desktop/constants';
 import { observeChild } from 'platform/desktop/backend/native/processManager';
 import * as viame from './viame';
@@ -133,6 +134,14 @@ async function train(
   return viame.train(settings, runTrainingArgs, updater, validateViamePath, getViameConstants(settings));
 }
 
+async function runScoring(
+  settings: Settings,
+  runScoringArgs: RunScoring,
+  updater: DesktopJobUpdater,
+): Promise<DesktopJob> {
+  return viame.runScoring(settings, runScoringArgs, updater, validateViamePath, getViameConstants(settings));
+}
+
 // Based on https://github.com/chrisallenlane/node-nvidia-smi
 async function nvidiaSmi(): Promise<NvidiaSmiReply> {
   return new Promise((resolve) => {
@@ -168,6 +177,7 @@ export default {
   runPipeline,
   exportTrainedPipeline,
   train,
+  runScoring,
   validateViamePath,
   getViameConstants,
   getViamePythonExe,
diff --git a/client/platform/desktop/backend/native/viame.ts b/client/platform/desktop/backend/native/viame.ts
index e248d1c73..9649a1e50 100644
--- a/client/platform/desktop/backend/native/viame.ts
+++ b/client/platform/desktop/backend/native/viame.ts
@@ -1,6 +1,7 @@
 import npath from 'path';
 import { spawn } from 'child_process';
 import fs from 'fs-extra';
+import moment from 'moment';
 
 import {
   Settings, DesktopJob, RunPipeline, RunTraining,
@@ -8,6 +9,7 @@ import {
   ExportTrainedPipeline,
   JsonConfig,
   JobsOutputFolderName,
+  RunScoring,
 } from 'platform/desktop/constants';
 import { cleanString } from 'platform/desktop/sharedUtils';
 import { serialize } from 'platform/desktop/backend/serializers/viame';
@@ -28,6 +30,9 @@ import {
   isTranscodePipeline,
   pipelineCreatesNewDataset,
 } from 'dive-common/pipelineCreatesDataset';
+import { describeSource, scoringCliArgs } from 'dive-common/scoring/metrics';
+import { SCORING_RESULT_VERSION } from 'dive-common/scoring/types';
+import type { RawScoringMatches, ScoringResultFile } from 'dive-common/scoring/types';
 import * as common from './common';
 import {
   jobFileEchoMiddleware, createWorkingDirectory, createCustomWorkingDirectory, splitExt,
@@ -1025,9 +1030,168 @@ async function train(
   return jobBase;
 }
 
+/** Quote a `viame score` token for the platform shell; bare flags and numbers stay as-is. */
+function shellToken(token: string) {
+  return /^[\w.-]+$/.test(token) ? token : `"${token}"`;
+}
+
+/** Keep only the last part of the scorer's stdout for the stored summary. */
+const ScoringSummaryTailBytes = 64 * 1024;
+
+/**
+ * Run the `viame score` applet over every pair in one invocation and store
+ * its output as a result file in the first pair's computed dataset.
+ */
+async function runScoring(
+  settings: Settings,
+  args: RunScoring,
+  updater: DesktopJobUpdater,
+  validateViamePath: (settings: Settings) => Promise<true | string>,
+  viameConstants: ViameConstants,
+): Promise<DesktopJob> {
+  const isValid = await validateViamePath(settings);
+  if (isValid !== true) {
+    throw new Error(isValid);
+  }
+  const { pairs, params } = args;
+  if (pairs.length === 0) {
+    throw new Error('Scoring needs at least one computed/truth pair');
+  }
+  const storageDatasetId = pairs[0].computed.datasetId;
+  const projectInfo = await common.getValidatedProjectDir(settings, storageDatasetId);
+  const jobWorkDir = await createCustomWorkingDirectory(settings, 'Scoring', storageDatasetId);
+  const joblog = npath.join(jobWorkDir, 'runlog.txt');
+
+  // Folder mode pairs computed and truth files by basename.
+  const computedDir = npath.join(jobWorkDir, 'computed');
+  const truthDir = npath.join(jobWorkDir, 'truth');
+  await fs.ensureDir(computedDir);
+  await fs.ensureDir(truthDir);
+  await Promise.all(pairs.map(async (pair, i) => {
+    const name = `seq_${String(i).padStart(3, '0')}.csv`;
+    await common.exportScoringSourceCsv(settings, pair.computed, npath.join(computedDir, name));
+    await common.exportScoringSourceCsv(settings, pair.truth, npath.join(truthDir, name));
+  }));
+
+  let labelsFile: string | undefined;
+  if (params.labelSynonyms) {
+    labelsFile = npath.join(jobWorkDir, 'labels.txt');
+    await fs.writeFile(labelsFile, params.labelSynonyms);
+  }
+
+  const metricsOut = npath.join(jobWorkDir, 'metrics.json');
+  const matchesOut = npath.join(jobWorkDir, 'matches.json');
+  const command = [
+    `${viameConstants.setupScriptAbs} &&`,
+    `"${viameConstants.viameExe}" score`,
+    ...scoringCliArgs(params, {
+      computed: computedDir,
+      truth: truthDir,
+      metricsOut,
+      matchesOut,
+      sweepDir: npath.join(jobWorkDir, 'sweep'),
+      labelsFile,
+    }).map(shellToken),
+    '--input-ext', '.csv',
+  ];
+
+  const job = observeChild(spawn(command.join(' '), {
+    shell: viameConstants.shell,
+    cwd: jobWorkDir,
+  }));
+  if (job.pid === undefined) {
+    throw new Error('Failed to spawn scoring process');
+  }
+
+  let { title } = args;
+  if (!title) {
+    title = `${describeSource(pairs[0].computed)} vs ${describeSource(pairs[0].truth)}`;
+    if (pairs.length > 1) {
+      title += ` (+${pairs.length - 1} more)`;
+    }
+  }
+  const datasetIds = [...new Set(pairs.flatMap((pair) => [pair.computed.datasetId, pair.truth.datasetId]))];
+  const jobBase: DesktopJob = {
+    key: `scoring_${job.pid}_${jobWorkDir}`,
+    command: command.join(' '),
+    jobType: 'scoring',
+    pid: job.pid,
+    args,
+    title: `Scoring ${title}`,
+    workingDir: jobWorkDir,
+    datasetIds,
+    exitCode: job.exitCode,
+    startTime: new Date(),
+  };
+  const manifestPath = npath.join(jobWorkDir, DiveJobManifestName);
+  fs.writeFile(manifestPath, JSON.stringify(jobBase, null, 2));
+
+  updater({
+    ...jobBase,
+    body: [''],
+  });
+
+  let stdoutTail = '';
+  const echo = jobFileEchoMiddleware(jobBase, updater, joblog);
+  job.stdout.on('data', (chunk: Buffer) => {
+    stdoutTail = (stdoutTail + chunk.toString('utf-8')).slice(-ScoringSummaryTailBytes);
+    echo(chunk);
+  });
+  job.stderr.on('data', echo);
+
+  job.on('exit', async (code) => {
+    let existingManifest: DesktopJob | undefined;
+    try {
+      if (await fs.pathExists(manifestPath)) {
+        existingManifest = await fs.readJson(manifestPath) as DesktopJob;
+      }
+    } catch {
+      // fall through and record process exit status
+    }
+
+    let exitCode = code;
+    const bodyText = [''];
+    if (!existingManifest?.cancelledJob && code === 0) {
+      try {
+        const created = moment();
+        const id = `scoring_${created.format('YYYY-MM-DD_HH-mm-ss.SSS')}.json`;
+        const result: ScoringResultFile = {
+          version: SCORING_RESULT_VERSION,
+          id,
+          datasetId: storageDatasetId,
+          created: created.toISOString(),
+          title,
+          pairs,
+          params,
+          metrics: await fs.readJson(metricsOut),
+          summaryText: stdoutTail.trim() || undefined,
+        };
+        if (await fs.pathExists(matchesOut)) {
+          result.matches = await fs.readJson(matchesOut) as RawScoringMatches;
+        }
+        await fs.writeJson(npath.join(projectInfo.auxDirAbsPath, id), result);
+      } catch (err) {
+        const message = `Failed to record scoring result: ${err instanceof Error ? err.message : String(err)}`;
+        console.error(err);
+        await fs.appendFile(joblog, `\n${message}\n`).catch(() => undefined);
+        exitCode = 1;
+        bodyText.unshift(message);
+      }
+    }
+    const finalJob = buildTrainingExitManifest(jobBase, exitCode, new Date(), existingManifest);
+    fs.writeFile(manifestPath, JSON.stringify(finalJob, null, 2));
+    updater({
+      ...finalJob,
+      body: bodyText,
+    });
+  });
+  return jobBase;
+}
+
 export {
   runPipeline,
   exportTrainedPipeline,
   train,
+  runScoring,
   DEFAULT_CALIBRATION_KEYS,
 };
diff --git a/client/platform/desktop/backend/native/windows.ts b/client/platform/desktop/backend/native/windows.ts
index 45dc630e0..1ad31243f 100644
--- a/client/platform/desktop/backend/native/windows.ts
+++ b/client/platform/desktop/backend/native/windows.ts
@@ -13,6 +13,7 @@ import {
   DesktopJob, RunPipeline, NvidiaSmiReply, RunTraining,
   DesktopJobUpdater,
   ExportTrainedPipeline,
+  RunScoring,
 } from 'platform/desktop/constants';
 import * as viame from './viame';
 
@@ -126,6 +127,14 @@ async function train(
   return viame.train(settings, runTrainingArgs, updater, validateFake, getViameConstants(settings));
 }
 
+async function runScoring(
+  settings: Settings,
+  runScoringArgs: RunScoring,
+  updater: DesktopJobUpdater,
+): Promise<DesktopJob> {
+  return viame.runScoring(settings, runScoringArgs, updater, validateFake, getViameConstants(settings));
+}
+
 function checkDefaultNvidiaSmi(resolve: (value: NvidiaSmiReply) => void) {
   const smi = observeChild(spawn(
     `"${programFiles}\\NVIDIA Corporation\\NVSMI\\nvidia-smi.exe"`,
@@ -194,6 +203,7 @@ export default {
   runPipeline,
   exportTrainedPipeline,
   train,
+  runScoring,
   nvidiaSmi,
   initialize,
   getViameConstants,
diff --git a/client/platform/desktop/constants.ts b/client/platform/desktop/constants.ts
index 49c81c007..53caafd73 100644
--- a/client/platform/desktop/constants.ts
+++ b/client/platform/desktop/constants.ts
@@ -5,6 +5,7 @@ import type {
 import { Attribute } from 'vue-media-annotator/use/AttributeTypes';
 import { AttributeTrackFilter } from 'vue-media-annotator/AttributeTrackFilterControls';
 import { ImageEnhancements } from 'vue-media-annotator/use/useImageEnhancements';
+import type { ScoringJobArgs } from 'dive-common/scoring/types';
 
 export const JsonConfigCurrentVersion = 1;
 export const SettingsCurrentVersion = 1;
@@ -189,6 +190,7 @@ export enum JobType {
   ExportTrainedPipeline,
   RunPipeline,
   RunTraining,
+  RunScoring,
 }
 
 export interface JobArgs {
@@ -234,6 +236,10 @@ export interface RunTraining extends JobArgs {
   resumeWorkingDir?: string;
 }
 
+export interface RunScoring extends JobArgs, ScoringJobArgs {
+  type: JobType.RunScoring;
+}
+
 export interface ConversionArgs extends JobArgs {
   type: JobType.Conversion;
   meta: JsonConfig;
@@ -248,7 +254,7 @@ export interface CliTranscodingNotice {
   mediaCount: number;
 }
 
-export type Job = ConversionArgs | RunPipeline | RunTraining | ExportTrainedPipeline;
+export type Job = ConversionArgs | RunPipeline | RunTraining | ExportTrainedPipeline | RunScoring;
 
 export interface DesktopJob {
   // key unique identifier for this job
@@ -256,11 +262,11 @@ export interface DesktopJob {
   // command that was run
   command: string;
   // jobType identify type of job
-  jobType: 'pipeline' | 'training' | 'conversion' | 'export';
+  jobType: 'pipeline' | 'training' | 'conversion' | 'export' | 'scoring';
   // title whatever humans should see this job called
   title: string;
   // arguments to creation
-  args: RunPipeline | RunTraining | ExportTrainedPipeline | ConversionArgs;
+  args: RunPipeline | RunTraining | ExportTrainedPipeline | ConversionArgs | RunScoring;
   // datasetIds of the involved datasets
   datasetIds: string[];
   // pid of the process spawned
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
index 9b9a60c28..1afed360a 100644
--- a/client/platform/desktop/frontend/api.ts
+++ b/client/platform/desktop/frontend/api.ts
@@ -11,6 +11,7 @@ import type {
   SegmentationStereoSegmentRequest, SegmentationStereoSegmentResponse,
   TextQueryRequest, TextQueryResponse, RefineDetectionsRequest, RefineDetectionsResponse,
   PipelineJobResult,
+  ScoringDatasetSummary, ScoringJobArgs, ScoringResult, ScoringResultSummary, ScoringSourceOptions,
 } from 'dive-common/apispec';
 
 import {
@@ -26,6 +27,7 @@ import {
   DesktopMediaImportResponse, ConversionArgs, JobType,
   DesktopJob,
   MultiCamBatchScanResult,
+  RunScoring,
 } from 'platform/desktop/constants';
 
 import { gpuJobQueue, cpuJobQueue, jobHistory } from './store/jobs';
@@ -176,19 +178,20 @@ async function runPipeline(itemId: string, pipeline: Pipe, pipelineParams?: Pipe
 }
 
 /**
- * Resolve when the pipeline job for this dataset finishes.
+ * Resolve when the first job matching `matches` that started at or after this
+ * call finishes.
  *
- * The job store is the only place that knows a job ended: a pipeline's own
+ * The job store is the only place that knows a job ended: a job's own
  * artifacts cannot say it, because a deterministic re-run writes byte-identical
  * output and a job that fails writes none at all. Both look exactly like "still
  * running" to anything watching the output.
  *
  * Only jobs starting at or after this call are considered, so an earlier run of
- * the same pipe on the same dataset (still in the history) is never mistaken for
- * this one. Resolution waits out the queue: `runPipeline` enqueues, so the job
- * may not exist for as long as the jobs ahead of it take.
+ * the same job (still in the history) is never mistaken for this one.
+ * Resolution waits out the queue: the run functions enqueue, so the job may not
+ * exist for as long as the jobs ahead of it take.
  */
-function watchPipelineJob(datasetId: string, pipeline: Pipe): Promise<PipelineJobResult> {
+function watchJob(matches: (job: DesktopJob) => boolean): Promise<PipelineJobResult> {
   const startedAt = Date.now();
   return new Promise<PipelineJobResult>((resolve) => {
     let key: string | null = null;
@@ -208,10 +211,7 @@ function watchPipelineJob(datasetId: string, pipeline: Pipe): Promise<PipelineJo
     stop = watch(jobHistory, () => {
       const entries = Object.values(jobHistory.value);
       if (key === null) {
-        const match = entries.find((entry) => entry.job.jobType === 'pipeline'
-          && 'pipeline' in entry.job.args
-          && entry.job.args.pipeline.pipe === pipeline.pipe
-          && entry.job.datasetIds.includes(datasetId)
+        const match = entries.find((entry) => matches(entry.job)
           // A job update carries the start time as an ISO string once it has
           // crossed the IPC boundary, so normalize before comparing.
           && new Date(entry.job.startTime).getTime() >= startedAt);
@@ -241,6 +241,14 @@ function watchPipelineJob(datasetId: string, pipeline: Pipe): Promise<PipelineJo
   });
 }
 
+/** Resolve when the pipeline job for this dataset finishes. */
+function watchPipelineJob(datasetId: string, pipeline: Pipe): Promise<PipelineJobResult> {
+  return watchJob((job) => job.jobType === 'pipeline'
+    && 'pipeline' in job.args
+    && job.args.pipeline.pipe === pipeline.pipe
+    && job.datasetIds.includes(datasetId));
+}
+
 async function exportTrainedPipeline(path: string, pipeline: Pipe): Promise<void> {
   const args: ExportTrainedPipeline = {
     type: JobType.ExportTrainedPipeline,
@@ -275,6 +283,41 @@ async function runTraining(
   gpuJobQueue.enqueue(args);
 }
 
+/**
+ * Scoring API
+ */
+
+async function runScoring(args: ScoringJobArgs): Promise<void> {
+  const spec: RunScoring = { type: JobType.RunScoring, ...args };
+  cpuJobQueue.enqueue(spec);
+}
+
+/** Resolve when the scoring job involving this dataset, launched after this call, finishes. */
+function watchScoringJob(datasetId: string): Promise<PipelineJobResult> {
+  return watchJob((job) => job.jobType === 'scoring' && job.datasetIds.includes(datasetId));
+}
+
+function listScoringSources(datasetId: string): Promise<ScoringSourceOptions> {
+  return invoke<ScoringSourceOptions>('list-scoring-sources', { datasetId });
+}
+
+function listScoringDatasets(): Promise<ScoringDatasetSummary[]> {
+  return invoke<ScoringDatasetSummary[]>('list-scoring-datasets');
+}
+
+/** Runs stored on one dataset, or every run across all projects when omitted. */
+function listScoringResults(datasetId?: string): Promise<ScoringResultSummary[]> {
+  return invoke<ScoringResultSummary[]>('list-scoring-results', { datasetId });
+}
+
+function loadScoringResult(datasetId: string, resultId: string): Promise<ScoringResult> {
+  return invoke<ScoringResult>('load-scoring-result', { datasetId, resultId });
+}
+
+function deleteScoringResult(datasetId: string, resultId: string): Promise<void> {
+  return invoke<void>('delete-scoring-result', { datasetId, resultId });
+}
+
 async function deleteTrainedPipeline(pipeline: Pipe): Promise<void> {
   return invoke<void>('delete-trained-pipeline', pipeline);
 }
@@ -396,6 +439,29 @@ async function exportDataset(id: string, exclude: boolean, typeFilter: readonly
   return '';
 }
 
+async function saveScoringExport(
+  { filename, content }: { filename: string; mime: string; content: string },
+): Promise<boolean> {
+  const location = await window.diveDesktop.showSaveDialog({
+    title: 'Export Scoring Run',
+    defaultPath: joinPath(await window.diveDesktop.getAppPath('home'), filename),
+  });
+  if (location.canceled || !location.filePath) return false;
+  await invoke<string>('write-text-file', { path: location.filePath, content });
+  return true;
+}
+
+async function exportScoringPdf(filename: string): Promise<boolean> {
+  const location = await window.diveDesktop.showSaveDialog({
+    title: 'Save Scoring Report',
+    defaultPath: joinPath(await window.diveDesktop.getAppPath('home'), filename),
+    filters: [{ name: 'PDF', extensions: ['pdf'] }],
+  });
+  if (location.canceled || !location.filePath) return false;
+  await invoke<string>('print-to-pdf', { path: location.filePath });
+  return true;
+}
+
 async function exportConfiguration(id: string): Promise<string> {
   const location = await window.diveDesktop.showSaveDialog({
     title: 'Export Configuration',
@@ -836,6 +902,8 @@ function deleteCalibration(datasetId: string): Promise<void> {
 }
 
 export {
+  saveScoringExport,
+  exportScoringPdf,
   /* Standard Specification APIs */
   loadConfig,
   loadDetections,
@@ -850,6 +918,13 @@ export {
   listResumableTrainingJobs,
   resumeTraining,
   discardResumableTraining,
+  runScoring,
+  watchScoringJob,
+  listScoringSources,
+  listScoringDatasets,
+  listScoringResults,
+  loadScoringResult,
+  deleteScoringResult,
   saveConfig,
   saveDetections,
   saveAttributes,
diff --git a/client/platform/desktop/frontend/components/JobsQueued.vue b/client/platform/desktop/frontend/components/JobsQueued.vue
index 649a1348e..fd0057799 100644
--- a/client/platform/desktop/frontend/components/JobsQueued.vue
+++ b/client/platform/desktop/frontend/components/JobsQueued.vue
@@ -16,10 +16,15 @@ import {
   removeJobFromQueue,
   // removeJobFromQueue,
 } from 'platform/desktop/frontend/store/jobs';
+import type { ScoringSource } from 'dive-common/scoring/types';
 import { datasets } from '../store/dataset';
 
 export default defineComponent({
   setup() {
+    function datasetName(id: string) {
+      return datasets.value[id]?.name || id;
+    }
+
     const queuedJobSpecs: Ref<Job[]> = ref([]);
     function updateQueuedJobSpecs() {
       queuedJobSpecs.value = [];
@@ -39,12 +44,24 @@ export default defineComponent({
         return `export trained pipeline: ${jobSpec.path}`;
       }
       if (jobSpec.type === JobType.RunTraining) {
-        const title = `training: ${datasets.value[jobSpec.datasetIds[0]]?.name || jobSpec.datasetIds[0]}`;
+        const title = `training: ${datasetName(jobSpec.datasetIds[0])}`;
         if (jobSpec.datasetIds.length > 1) {
           return `${title} (and ${jobSpec.datasetIds.length - 1} more)`;
         }
         return title;
       }
+      if (jobSpec.type === JobType.RunScoring) {
+        const label = (source: ScoringSource) => source.label || datasetName(source.datasetId);
+        const [first] = jobSpec.pairs;
+        let { title } = jobSpec;
+        if (!title && first) {
+          title = `${label(first.computed)} vs ${label(first.truth)}`;
+          if (jobSpec.pairs.length > 1) {
+            title += ` (+${jobSpec.pairs.length - 1} more)`;
+          }
+        }
+        return `scoring: ${title || 'no sequences'}`;
+      }
       return 'queued job';
     }
 
@@ -58,6 +75,9 @@ export default defineComponent({
       if (jobSpec.type === JobType.RunTraining) {
         return jobSpec.datasetIds;
       }
+      if (jobSpec.type === JobType.RunScoring) {
+        return [...new Set(jobSpec.pairs.flatMap((pair) => [pair.computed.datasetId, pair.truth.datasetId]))];
+      }
       return [];
     }
 
@@ -69,6 +89,7 @@ export default defineComponent({
       JobType,
       queuedJobSpecs,
       datasets,
+      datasetName,
       getQueuedJobTitle,
       getJobDatasets,
       removeJobFromQueue,
@@ -114,7 +135,7 @@ export default defineComponent({
                             class="mr-1"
                             :to="{ name: 'viewer', params: { id: dataset } }"
                           >
-                            {{ datasets[dataset].name }}
+                            {{ datasetName(dataset) }}
                           </router-link>
                         </span>
                       </td>
diff --git a/client/platform/desktop/frontend/components/NavigationBar.vue b/client/platform/desktop/frontend/components/NavigationBar.vue
index af89be7cb..f3907c753 100644
--- a/client/platform/desktop/frontend/components/NavigationBar.vue
+++ b/client/platform/desktop/frontend/components/NavigationBar.vue
@@ -31,6 +31,9 @@ export default defineComponent({
       <v-tab :to="{ name: 'pipeline' }">
         Pipeline<v-icon>mdi-pipe</v-icon>
       </v-tab>
+      <v-tab :to="{ name: 'scoring' }">
+        Scoring<v-icon>mdi-chart-box-outline</v-icon>
+      </v-tab>
       <v-tab :to="{ name: 'settings' }">
         Settings<v-icon>mdi-cog</v-icon>
       </v-tab>
diff --git a/client/platform/desktop/frontend/components/Recent.vue b/client/platform/desktop/frontend/components/Recent.vue
index 602b99fe0..27630ab0b 100644
--- a/client/platform/desktop/frontend/components/Recent.vue
+++ b/client/platform/desktop/frontend/components/Recent.vue
@@ -261,6 +261,10 @@ export default defineComponent({
     function runTrainingOnSelected() {
       router.push({ name: 'training', query: selectedIdsQuery() });
     }
+
+    function scoreSelected() {
+      router.push({ name: 'scoring', query: selectedIdsQuery() });
+    }
     function getTypeIcon(recent: JsonConfigCache) {
       if (recent.subType) {
         if (recent.subType === 'stereo') {
@@ -355,6 +359,7 @@ export default defineComponent({
       confirmDeleteSelected,
       runPipelineOnSelected,
       runTrainingOnSelected,
+      scoreSelected,
       isSelected,
       toggleSelected,
       toggleSelectAll,
@@ -623,6 +628,27 @@ export default defineComponent({
                   </template>
                   <span>Train a model on the selected datasets</span>
                 </v-tooltip>
+                <v-tooltip bottom>
+                  <template #activator="{ on }">
+                    <v-btn
+                      class="ml-2 align-self-center"
+                      color="primary"
+                      outlined
+                      small
+                      v-on="on"
+                      @click="scoreSelected"
+                    >
+                      <v-icon
+                        left
+                        small
+                      >
+                        mdi-chart-box-outline
+                      </v-icon>
+                      Score
+                    </v-btn>
+                  </template>
+                  <span>Score the selected datasets against ground truth</span>
+                </v-tooltip>
                 <v-tooltip bottom>
                   <template #activator="{ on }">
                     <v-btn
diff --git a/client/platform/desktop/frontend/components/ScoringPage.vue b/client/platform/desktop/frontend/components/ScoringPage.vue
new file mode 100644
index 000000000..b6f8ddfe1
--- /dev/null
+++ b/client/platform/desktop/frontend/components/ScoringPage.vue
@@ -0,0 +1,32 @@
+<script setup lang="ts">
+import { computed } from 'vue';
+import { useRoute, useRouter } from 'vue-router/composables';
+import SharedScoringPage from 'dive-common/components/Scoring/ScoringPage.vue';
+import NavigationBar from './NavigationBar.vue';
+
+const route = useRoute();
+const router = useRouter();
+
+/** Dataset ids handed off by another page (e.g. the Library selection). */
+const initialDatasetIds = computed(() => {
+  const query = route.query.datasetIds;
+  const values = Array.isArray(query) ? query : [query];
+  return values.flatMap((value) => (value || '').split(',')).filter(Boolean);
+});
+
+function openViewer(id: string) {
+  router.push({ name: 'viewer', params: { id } });
+}
+</script>
+
+<template>
+  <v-main>
+    <navigation-bar />
+    <v-container fluid>
+      <shared-scoring-page
+        :initial-dataset-ids="initialDatasetIds"
+        @open-viewer="openViewer"
+      />
+    </v-container>
+  </v-main>
+</template>
diff --git a/client/platform/desktop/frontend/components/ViewerLoader.vue b/client/platform/desktop/frontend/components/ViewerLoader.vue
index 06cae1aa8..5b1c082d7 100644
--- a/client/platform/desktop/frontend/components/ViewerLoader.vue
+++ b/client/platform/desktop/frontend/components/ViewerLoader.vue
@@ -178,8 +178,10 @@ export default defineComponent({
       const results: string[] = [];
       // Check if any running job contains the root props.id
       // for multicam this is why we use the reduce to check each id
+      // Scoring only reads annotations, so it never locks the viewer.
       if (runningJobs.value.find(
-        (item) => item.job.datasetIds.reduce((prev: boolean, current) => (current.includes(props.id) && prev), true),
+        (item) => item.job.jobType !== 'scoring'
+          && item.job.datasetIds.reduce((prev: boolean, current) => (current.includes(props.id) && prev), true),
       )) {
         results.push(props.id);
       }
@@ -2044,6 +2046,9 @@ export default defineComponent({
           <v-tab :to="{ name: 'training' }">
             Training<v-icon>mdi-brain</v-icon>
           </v-tab>
+          <v-tab :to="{ name: 'scoring' }">
+            Scoring<v-icon>mdi-chart-box-outline</v-icon>
+          </v-tab>
           <v-tab :to="{ name: 'settings' }">
             Settings<v-icon>mdi-cog</v-icon>
           </v-tab>
diff --git a/client/platform/desktop/frontend/store/jobs.ts b/client/platform/desktop/frontend/store/jobs.ts
index 7334c1efc..8149b8103 100644
--- a/client/platform/desktop/frontend/store/jobs.ts
+++ b/client/platform/desktop/frontend/store/jobs.ts
@@ -14,6 +14,7 @@ import {
   JobType,
   RunPipeline,
   RunTraining,
+  RunScoring,
   JsonConfig,
 } from 'platform/desktop/constants';
 import { usePrompt } from 'dive-common/vue-utilities/prompt-service';
@@ -202,7 +203,8 @@ function removeJobFromQueue(jobArgs: JobArgs) {
   switch (jobArgs.type) {
     case JobType.Conversion:
     case JobType.ExportTrainedPipeline:
-      cpuJobQueue.removeJobFromQueue(jobArgs as ConversionArgs | ExportTrainedPipeline);
+    case JobType.RunScoring:
+      cpuJobQueue.removeJobFromQueue(jobArgs as ConversionArgs | ExportTrainedPipeline | RunScoring);
       break;
     case JobType.RunPipeline:
     case JobType.RunTraining:
diff --git a/client/platform/desktop/frontend/store/queues/asyncCpuJobQueue.ts b/client/platform/desktop/frontend/store/queues/asyncCpuJobQueue.ts
index 4ceaad333..ce84abd3b 100644
--- a/client/platform/desktop/frontend/store/queues/asyncCpuJobQueue.ts
+++ b/client/platform/desktop/frontend/store/queues/asyncCpuJobQueue.ts
@@ -2,33 +2,53 @@ import {
   JobType,
   ConversionArgs,
   ExportTrainedPipeline,
+  RunScoring,
   DesktopJob,
 } from 'platform/desktop/constants';
+import type { ScoringPair, ScoringSource } from 'dive-common/scoring/types';
 import AsyncJobQueue from './asyncJobQueue';
 
-export default class AsyncCpuJobQueue extends AsyncJobQueue<ConversionArgs | ExportTrainedPipeline> {
-  async beginJob(spec: ConversionArgs | ExportTrainedPipeline) {
+type CpuJob = ConversionArgs | ExportTrainedPipeline | RunScoring;
+
+function sameScoringSource(a: ScoringSource, b: ScoringSource) {
+  return a.datasetId === b.datasetId && a.file === b.file && a.set === b.set && a.revision === b.revision;
+}
+
+function sameScoringPairs(a: ScoringPair[], b: ScoringPair[]) {
+  return a.length === b.length && a.every((pair, i) => (
+    sameScoringSource(pair.computed, b[i].computed) && sameScoringSource(pair.truth, b[i].truth)
+  ));
+}
+
+export default class AsyncCpuJobQueue extends AsyncJobQueue<CpuJob> {
+  async beginJob(spec: CpuJob) {
     let newJob: DesktopJob;
     if (spec.type === JobType.Conversion) {
       newJob = await this.ipcRenderer.invoke<DesktopJob>('convert', spec);
     } else if (spec.type === JobType.ExportTrainedPipeline) {
       newJob = await this.ipcRenderer.invoke<DesktopJob>('export-trained-pipeline', spec);
+    } else if (spec.type === JobType.RunScoring) {
+      newJob = await this.ipcRenderer.invoke<DesktopJob>('run-scoring', spec);
     } else {
       throw new Error('CPU job type not able to be queued');
     }
     this.processingJobs.push(newJob);
   }
 
-  removeJobFromQueue(removeSpec: ConversionArgs | ExportTrainedPipeline): void {
+  removeJobFromQueue(removeSpec: CpuJob): void {
     let removeSpecIndex = -1;
     if (removeSpec.type === JobType.Conversion) {
-      removeSpecIndex = this.jobSpecs.findIndex((spec: ConversionArgs | ExportTrainedPipeline) => (
+      removeSpecIndex = this.jobSpecs.findIndex((spec: CpuJob) => (
         spec.type === JobType.Conversion
         && spec.meta.id === removeSpec.meta.id));
     } else if (removeSpec.type === JobType.ExportTrainedPipeline) {
-      removeSpecIndex = this.jobSpecs.findIndex((spec: ConversionArgs | ExportTrainedPipeline) => (spec.type === JobType.ExportTrainedPipeline
+      removeSpecIndex = this.jobSpecs.findIndex((spec: CpuJob) => (spec.type === JobType.ExportTrainedPipeline
         && (spec.path !== removeSpec.path && spec.pipeline.pipe !== removeSpec.pipeline.pipe)
       ));
+    } else if (removeSpec.type === JobType.RunScoring) {
+      removeSpecIndex = this.jobSpecs.findIndex((spec: CpuJob) => (spec.type === JobType.RunScoring
+        && sameScoringPairs(spec.pairs, removeSpec.pairs)
+      ));
     }
     if (removeSpecIndex !== -1) {
       this.jobSpecs.splice(removeSpecIndex, 1);
diff --git a/client/platform/desktop/router.ts b/client/platform/desktop/router.ts
index 232b80957..77ef9aeac 100644
--- a/client/platform/desktop/router.ts
+++ b/client/platform/desktop/router.ts
@@ -7,6 +7,7 @@ import Settings from './frontend/components/Settings.vue';
 import TrainingPage from './frontend/components/TrainingPage.vue';
 import ViewerLoader from './frontend/components/ViewerLoader.vue';
 import PipelinePage from './frontend/components/PipelinePage.vue';
+import ScoringPage from './frontend/components/ScoringPage.vue';
 
 Vue.use(Router);
 
@@ -32,6 +33,11 @@ export default new Router({
       name: 'pipeline',
       component: PipelinePage,
     },
+    {
+      path: '/scoring',
+      name: 'scoring',
+      component: ScoringPage,
+    },
     {
       path: '/jobs',
       name: 'jobs',
diff --git a/client/platform/web-girder/App.vue b/client/platform/web-girder/App.vue
index ed2153977..6bf18cbac 100644
--- a/client/platform/web-girder/App.vue
+++ b/client/platform/web-girder/App.vue
@@ -1,6 +1,7 @@
 <template>
   <v-app>
     <router-view />
+    <ScoringDatasetPickerDialog />
   </v-app>
 </template>
 
@@ -37,7 +38,18 @@ import {
   hasCalibrationFile,
   downloadCalibration,
   deleteCalibration,
+  runScoring,
+  watchScoringJob,
+  listScoringResults,
+  loadScoringResult,
+  deleteScoringResult,
+  listScoringSources,
+  listScoringDatasets,
+  saveScoringExport,
+  exportScoringPdf,
+  pickScoringDataset,
 } from './api';
+import ScoringDatasetPickerDialog from './components/ScoringDatasetPickerDialog.vue';
 import {
   getLastCalibration,
   openFromDiskWithRegistry,
@@ -50,7 +62,7 @@ import { reportHandledPromiseRejection } from './reportHandledPromiseRejection';
 
 export default defineComponent({
   name: 'App',
-  components: {},
+  components: { ScoringDatasetPickerDialog },
   setup() {
     const route = useRoute();
     const { loadDataset } = useDataset();
@@ -95,6 +107,16 @@ export default defineComponent({
       getTiles,
       getTileURL,
       getTileHistogram,
+      runScoring: unwrap(runScoring),
+      watchScoringJob,
+      listScoringResults: unwrap(listScoringResults),
+      loadScoringResult: unwrap(loadScoringResult),
+      deleteScoringResult,
+      listScoringSources: unwrap(listScoringSources),
+      listScoringDatasets,
+      pickScoringDataset,
+      saveScoringExport,
+      exportScoringPdf,
     });
   },
 });
diff --git a/client/platform/web-girder/api/index.ts b/client/platform/web-girder/api/index.ts
index 5e0a9eb65..9bcca84e4 100644
--- a/client/platform/web-girder/api/index.ts
+++ b/client/platform/web-girder/api/index.ts
@@ -12,8 +12,10 @@ export { default as loadFrameMetadata } from './frameMetadata.service';
 export * from './girder.service';
 export * from './multicamResolve';
 export * from './rpc.service';
+export * from './scoring.service';
+export { pickScoringDataset } from './scoringDatasetPicker';
 export * from './waitForFolderDatasetReady';
-export { default as watchPipelineJob } from './watchPipelineJob';
+export { default as watchPipelineJob, watchScoringJob } from './watchPipelineJob';
 export * from './largeImage.service';
 
 /**
diff --git a/client/platform/web-girder/api/scoring.service.spec.ts b/client/platform/web-girder/api/scoring.service.spec.ts
new file mode 100644
index 000000000..752a011f6
--- /dev/null
+++ b/client/platform/web-girder/api/scoring.service.spec.ts
@@ -0,0 +1,110 @@
+import {
+  beforeEach, describe, expect, it, vi,
+} from 'vitest';
+
+import { DEFAULT_SCORING_PARAMS } from 'dive-common/scoring/metrics';
+import girderRest from 'platform/web-girder/plugins/girder';
+import { clearMultiCamMetaCache } from './multicamResolve';
+import {
+  deleteScoringResult, listScoringDatasets, listScoringResults, runScoring,
+} from './scoring.service';
+
+vi.mock('platform/web-girder/plugins/girder', () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+    delete: vi.fn(),
+  },
+}));
+
+describe('scoring.service', () => {
+  beforeEach(() => {
+    vi.mocked(girderRest.get).mockReset();
+    vi.mocked(girderRest.post).mockReset();
+    vi.mocked(girderRest.delete).mockReset();
+    clearMultiCamMetaCache();
+  });
+
+  it('posts every pair with composite camera ids resolved to camera folders', async () => {
+    vi.mocked(girderRest.get).mockResolvedValue({
+      data: {
+        meta: {
+          multiCam: {
+            defaultDisplay: 'left',
+            cameras: { left: { folderId: 'left-folder' }, right: { folderId: 'right-folder' } },
+          },
+        },
+      },
+    });
+    vi.mocked(girderRest.post).mockResolvedValueOnce({ data: { _id: 'job' } });
+
+    await runScoring({
+      pairs: [
+        {
+          computed: { datasetId: 'parent/left', set: 'detector' },
+          truth: { datasetId: 'truth-id', revision: 4 },
+        },
+        {
+          computed: { datasetId: 'parent/right', set: 'detector' },
+          truth: { datasetId: 'parent/right' },
+        },
+      ],
+      params: DEFAULT_SCORING_PARAMS,
+      title: 'left vs truth (+1 more)',
+    });
+
+    expect(girderRest.post).toHaveBeenCalledWith('dive_rpc/score', {
+      pairs: [
+        {
+          computed: { datasetId: 'left-folder', set: 'detector' },
+          truth: { datasetId: 'truth-id', revision: 4 },
+        },
+        {
+          computed: { datasetId: 'right-folder', set: 'detector' },
+          truth: { datasetId: 'right-folder' },
+        },
+      ],
+      params: DEFAULT_SCORING_PARAMS,
+      title: 'left vs truth (+1 more)',
+    });
+  });
+
+  it('lists every readable result when no dataset is given', async () => {
+    vi.mocked(girderRest.get).mockResolvedValueOnce({ data: [] });
+
+    await listScoringResults();
+
+    expect(girderRest.get).toHaveBeenCalledWith('dive_scoring');
+  });
+
+  it('lists one dataset\'s results through the dataset route', async () => {
+    vi.mocked(girderRest.get).mockResolvedValueOnce({ data: [] });
+
+    await listScoringResults('ds');
+
+    expect(girderRest.get).toHaveBeenCalledWith('dive_dataset/ds/scoring');
+  });
+
+  it('lists datasets the score tool can read, leaving out multicamera parents', async () => {
+    vi.mocked(girderRest.get).mockResolvedValueOnce({
+      data: [
+        { _id: 'a', name: 'A', meta: { type: 'video' } },
+        { _id: 'm', name: 'M', meta: { type: 'multi' } },
+        { _id: 'b', name: 'B', meta: {} },
+      ],
+    });
+
+    await expect(listScoringDatasets()).resolves.toEqual([
+      { id: 'a', name: 'A', type: 'video' },
+      { id: 'b', name: 'B', type: undefined },
+    ]);
+  });
+
+  it('deletes a result through the dataset route', async () => {
+    vi.mocked(girderRest.delete).mockResolvedValueOnce({ data: null });
+
+    await expect(deleteScoringResult('ds', 'res')).resolves.toBeUndefined();
+
+    expect(girderRest.delete).toHaveBeenCalledWith('dive_dataset/ds/scoring/res');
+  });
+});
diff --git a/client/platform/web-girder/api/scoring.service.ts b/client/platform/web-girder/api/scoring.service.ts
new file mode 100644
index 000000000..6f540bc2e
--- /dev/null
+++ b/client/platform/web-girder/api/scoring.service.ts
@@ -0,0 +1,104 @@
+import type {
+  ScoringDatasetSummary,
+  ScoringJobArgs,
+  ScoringPair,
+  ScoringResult,
+  ScoringResultSummary,
+  ScoringSourceOptions,
+} from 'dive-common/apispec';
+import type { ScoringSource } from 'dive-common/scoring/types';
+import girderRest from 'platform/web-girder/plugins/girder';
+import { getDatasetList } from './dataset.service';
+import { resolveDatasetFolderId } from './multicamResolve';
+
+/** Datasets offered as the other side of a comparison; enough for one listing. */
+const SCORING_DATASET_LIMIT = 500;
+
+async function resolveSource(source: ScoringSource): Promise<ScoringSource> {
+  // Composite multicam ids (parent/camera) resolve to the camera folder, which
+  // is where that camera's annotations live.
+  const { folderId } = await resolveDatasetFolderId(source.datasetId);
+  return { ...source, datasetId: folderId };
+}
+
+async function resolvePair(pair: ScoringPair): Promise<ScoringPair> {
+  const [computed, truth] = await Promise.all([
+    resolveSource(pair.computed),
+    resolveSource(pair.truth),
+  ]);
+  return { computed, truth };
+}
+
+async function runScoring(args: ScoringJobArgs) {
+  const pairs = await Promise.all(args.pairs.map(resolvePair));
+  return girderRest.post('dive_rpc/score', { ...args, pairs });
+}
+
+async function listScoringResults(datasetId?: string) {
+  if (datasetId === undefined) {
+    return girderRest.get<ScoringResultSummary[]>('dive_scoring');
+  }
+  const { folderId } = await resolveDatasetFolderId(datasetId);
+  return girderRest.get<ScoringResultSummary[]>(`dive_dataset/${folderId}/scoring`);
+}
+
+async function loadScoringResult(datasetId: string, resultId: string) {
+  const { folderId } = await resolveDatasetFolderId(datasetId);
+  return girderRest.get<ScoringResult>(`dive_dataset/${folderId}/scoring/${resultId}`);
+}
+
+async function deleteScoringResult(datasetId: string, resultId: string): Promise<void> {
+  const { folderId } = await resolveDatasetFolderId(datasetId);
+  await girderRest.delete(`dive_dataset/${folderId}/scoring/${resultId}`);
+}
+
+async function listScoringSources(datasetId: string) {
+  const { folderId } = await resolveDatasetFolderId(datasetId);
+  return girderRest.get<ScoringSourceOptions>(`dive_dataset/${folderId}/scoring_sources`);
+}
+
+async function listScoringDatasets(): Promise<ScoringDatasetSummary[]> {
+  const { data } = await getDatasetList(SCORING_DATASET_LIMIT, 0, 'name', 1);
+  return data
+    // A multicamera parent exports its annotations as a zip of per-camera
+    // files, which the score tool cannot read; its cameras are listed instead.
+    .filter((folder) => folder.meta?.type !== 'multi')
+    .map((folder) => ({
+      id: folder._id,
+      name: folder.name,
+      type: typeof folder.meta?.type === 'string' ? folder.meta.type : undefined,
+    }));
+}
+
+export {
+  runScoring,
+  listScoringResults,
+  loadScoringResult,
+  deleteScoringResult,
+  listScoringSources,
+  listScoringDatasets,
+};
+
+/** Browser download; the user's download settings decide the destination. */
+async function saveScoringExport(
+  { filename, mime, content }: { filename: string; mime: string; content: string },
+): Promise<boolean> {
+  const blob = new Blob([content], { type: mime });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement('a');
+  anchor.href = url;
+  anchor.download = filename;
+  document.body.appendChild(anchor);
+  anchor.click();
+  anchor.remove();
+  URL.revokeObjectURL(url);
+  return true;
+}
+
+/** The browser's print dialog offers "Save as PDF"; the page carries print styles. */
+async function exportScoringPdf(): Promise<boolean> {
+  window.print();
+  return true;
+}
+
+export { saveScoringExport, exportScoringPdf };
diff --git a/client/platform/web-girder/api/scoringDatasetPicker.ts b/client/platform/web-girder/api/scoringDatasetPicker.ts
new file mode 100644
index 000000000..de007fda1
--- /dev/null
+++ b/client/platform/web-girder/api/scoringDatasetPicker.ts
@@ -0,0 +1,27 @@
+import type { ScoringDatasetSummary } from 'dive-common/scoring/types';
+import { reactive } from 'vue';
+
+export const scoringDatasetPickerState = reactive({
+  open: false,
+  excludeIds: [] as string[],
+});
+
+let pendingResolve: ((value: ScoringDatasetSummary | null) => void) | null = null;
+
+export function pickScoringDataset(excludeIds: string[]): Promise<ScoringDatasetSummary | null> {
+  return new Promise((resolve) => {
+    if (pendingResolve) {
+      pendingResolve(null);
+    }
+    pendingResolve = resolve;
+    scoringDatasetPickerState.excludeIds = [...excludeIds];
+    scoringDatasetPickerState.open = true;
+  });
+}
+
+export function finishScoringDatasetPicker(dataset: ScoringDatasetSummary | null) {
+  scoringDatasetPickerState.open = false;
+  scoringDatasetPickerState.excludeIds = [];
+  pendingResolve?.(dataset);
+  pendingResolve = null;
+}
diff --git a/client/platform/web-girder/api/watchPipelineJob.ts b/client/platform/web-girder/api/watchPipelineJob.ts
index ff4d69f57..61cd4f9a9 100644
--- a/client/platform/web-girder/api/watchPipelineJob.ts
+++ b/client/platform/web-girder/api/watchPipelineJob.ts
@@ -1,5 +1,6 @@
 import { watch } from 'vue';
 import type { PipelineJobResult } from 'dive-common/apispec';
+import { parentDatasetId } from 'dive-common/compositeDatasetId';
 import {
   isJobFinished, jobCanceled, jobSucceeded, useJobs,
 } from 'platform/web-girder/store/useJobs';
@@ -61,3 +62,11 @@ export default function watchPipelineJob(datasetId: string): Promise<PipelineJob
     }
   });
 }
+
+/**
+ * Scoring jobs are attributed to the computed dataset the same way pipeline
+ * jobs are: a camera folder's job is keyed by its multicam parent.
+ */
+export function watchScoringJob(datasetId: string): Promise<PipelineJobResult> {
+  return watchPipelineJob(parentDatasetId(datasetId));
+}
diff --git a/client/platform/web-girder/components/ScoringDatasetPickerDialog.vue b/client/platform/web-girder/components/ScoringDatasetPickerDialog.vue
new file mode 100644
index 000000000..814ad0681
--- /dev/null
+++ b/client/platform/web-girder/components/ScoringDatasetPickerDialog.vue
@@ -0,0 +1,203 @@
+<script lang="ts">
+import {
+  computed, defineComponent, ref, watch,
+} from 'vue';
+import { GirderFileManager, GirderModelType } from '@girder/components/src';
+import type { ScoringDatasetSummary } from 'dive-common/scoring/types';
+import { useGirderRest } from 'platform/web-girder/plugins/girder';
+import {
+  finishScoringDatasetPicker,
+  scoringDatasetPickerState,
+} from 'platform/web-girder/api/scoringDatasetPicker';
+import { useLocation } from 'platform/web-girder/store/useLocation';
+import type { LocationType } from 'platform/web-girder/store/types';
+import { isGirderModel } from 'platform/web-girder/store/types';
+
+type BrowserLocation = {
+  _id: string;
+  _modelType: GirderModelType;
+  name?: string;
+  login?: string;
+  meta?: { annotate?: boolean | string; type?: string };
+};
+
+function isScoringDataset(loc: BrowserLocation): boolean {
+  return loc._modelType === 'folder'
+    && !!loc.meta?.annotate
+    && loc.meta?.type !== 'multi';
+}
+
+function toSummary(loc: BrowserLocation): ScoringDatasetSummary {
+  return {
+    id: loc._id,
+    name: loc.name || loc._id,
+    type: typeof loc.meta?.type === 'string' ? loc.meta.type : undefined,
+  };
+}
+
+export default defineComponent({
+  name: 'ScoringDatasetPickerDialog',
+  components: { GirderFileManager },
+  setup() {
+    const girderRest = useGirderRest();
+    const { getLocation } = useLocation();
+    const location = ref<LocationType | null>(null);
+    const selected = ref<BrowserLocation | null>(null);
+
+    function defaultUserLocation(): LocationType | null {
+      return girderRest.user?._id
+        ? {
+          _id: girderRest.user._id,
+          _modelType: 'user',
+          login: girderRest.user.login,
+        }
+        : null;
+    }
+
+    function reset() {
+      selected.value = null;
+      const browseLocation = getLocation();
+      location.value = browseLocation ?? defaultUserLocation();
+      if (browseLocation && isGirderModel(browseLocation) && isScoringDataset(browseLocation)) {
+        selected.value = browseLocation;
+      }
+    }
+
+    watch(() => scoringDatasetPickerState.open, (open) => {
+      if (open) {
+        reset();
+      }
+    });
+
+    function setLocation(newLoc: BrowserLocation) {
+      if (isScoringDataset(newLoc)) {
+        selected.value = newLoc;
+        return;
+      }
+      location.value = newLoc;
+      selected.value = null;
+    }
+
+    const excluded = computed(
+      () => !!selected.value
+        && scoringDatasetPickerState.excludeIds.includes(selected.value._id),
+    );
+
+    const invalidSelection = computed(() => {
+      if (!selected.value) return null;
+      if (excluded.value) return 'This dataset is already in the list.';
+      if (selected.value.meta?.type === 'multi') {
+        return 'Multicamera parent folders cannot be scored; choose a camera dataset instead.';
+      }
+      if (!selected.value.meta?.annotate) {
+        return 'Choose a DIVE dataset folder.';
+      }
+      return null;
+    });
+
+    const canAdd = computed(
+      () => !!selected.value && isScoringDataset(selected.value) && !excluded.value,
+    );
+
+    function cancel() {
+      finishScoringDatasetPicker(null);
+    }
+
+    function onDialogInput(open: boolean) {
+      if (!open) {
+        cancel();
+      }
+    }
+
+    function confirm() {
+      if (!canAdd.value || !selected.value) return;
+      finishScoringDatasetPicker(toSummary(selected.value));
+    }
+
+    return {
+      scoringDatasetPickerState,
+      location,
+      selected,
+      setLocation,
+      invalidSelection,
+      canAdd,
+      cancel,
+      onDialogInput,
+      confirm,
+    };
+  },
+});
+</script>
+
+<template>
+  <v-dialog
+    :value="scoringDatasetPickerState.open"
+    max-width="800"
+    :overlay-opacity="0.95"
+    @input="onDialogInput"
+  >
+    <v-card v-if="location">
+      <v-card-title>
+        Choose a dataset
+      </v-card-title>
+      <v-card-text>
+        Browse to a DIVE dataset and select it to score. Multicamera parent folders
+        are not listed as scorable sequences.
+        <v-card
+          outlined
+          flat
+          class="mt-3"
+        >
+          <GirderFileManager
+            root-location-disabled
+            no-access-control
+            :location="location"
+            @update:location="setLocation"
+          >
+            <template #row="{ item }">
+              <span>{{ item.name }}</span>
+              <v-chip
+                v-if="(item.meta && item.meta.annotate)"
+                color="white"
+                x-small
+                outlined
+                class="mx-3"
+              >
+                dataset
+              </v-chip>
+            </template>
+          </GirderFileManager>
+        </v-card>
+        <div
+          v-if="selected"
+          class="text-body-2 mt-3"
+        >
+          Selected:
+          <strong>{{ selected.name || selected._id }}</strong>
+        </div>
+        <div
+          v-if="invalidSelection"
+          class="text-caption warning--text mt-1"
+        >
+          {{ invalidSelection }}
+        </div>
+      </v-card-text>
+      <v-card-actions>
+        <v-spacer />
+        <v-btn
+          text
+          @click="cancel"
+        >
+          Cancel
+        </v-btn>
+        <v-btn
+          color="primary"
+          :disabled="!canAdd"
+          @click="confirm"
+        >
+          Add sequence
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
diff --git a/client/platform/web-girder/router.ts b/client/platform/web-girder/router.ts
index 26033a4b6..98568bb60 100644
--- a/client/platform/web-girder/router.ts
+++ b/client/platform/web-girder/router.ts
@@ -5,6 +5,7 @@ import girderRest from './plugins/girder';
 import Home from './views/Home.vue';
 import Jobs from './views/Jobs.vue';
 import TrainedModels from './views/TrainedModels.vue';
+import Scoring from './views/Scoring.vue';
 import Login from './views/Login.vue';
 import RouterPage from './views/RouterPage.vue';
 import AdminPage from './views/AdminPage.vue';
@@ -98,6 +99,12 @@ const router = new Router({
           component: TrainedModels,
           beforeEnter,
         },
+        {
+          path: 'scoring',
+          name: 'scoring',
+          component: Scoring,
+          beforeEnter,
+        },
         {
           path: '',
           component: Home,
diff --git a/client/platform/web-girder/store/useJobs.ts b/client/platform/web-girder/store/useJobs.ts
index f888fb9b2..69f55dc51 100644
--- a/client/platform/web-girder/store/useJobs.ts
+++ b/client/platform/web-girder/store/useJobs.ts
@@ -133,7 +133,10 @@ function updateJobFromMessage(job: GirderJob & { type?: string; title?: string }
       status: job.status,
       jobId: job._id,
     });
-    if (['pipelines', 'convert'].includes(job.type || '') && NonRunningStates.includes(job.status)) {
+    if (
+      ['pipelines', 'convert', 'scoring'].includes(job.type || '')
+      && NonRunningStates.includes(job.status)
+    ) {
       jobs.setCompleteJobsInfo({
         datasetId: job.dataset_id,
         type: job.type || '',
diff --git a/client/platform/web-girder/views/Home.vue b/client/platform/web-girder/views/Home.vue
index 5234c764b..5612df413 100644
--- a/client/platform/web-girder/views/Home.vue
+++ b/client/platform/web-girder/views/Home.vue
@@ -171,6 +171,12 @@ export default defineComponent({
     };
   },
   methods: {
+    scoreSelection() {
+      this.$router.push({
+        name: 'scoring',
+        query: { datasetIds: this.selectedViameFolderIds.join(',') },
+      });
+    },
     async deleteSelection() {
       const result = await this.prompt({
         title: 'Confirm',
@@ -253,6 +259,18 @@ export default defineComponent({
                   :jobs-disabled="jobsDisabled"
                   :jobs-disabled-message="jobsDisabledMessage"
                 />
+                <v-btn
+                  v-if="pipelinesEnabled && selectedViameFolderIds.length > 0"
+                  v-bind="buttonOptions"
+                  @click="scoreSelection"
+                >
+                  <v-icon>
+                    mdi-chart-box-outline
+                  </v-icon>
+                  <span class="pl-1">
+                    Score
+                  </span>
+                </v-btn>
                 <export
                   v-bind="{ buttonOptions, menuOptions }"
                   :dataset-ids="locationInputs"
diff --git a/client/platform/web-girder/views/NavigationBar.vue b/client/platform/web-girder/views/NavigationBar.vue
index fee114352..475542196 100644
--- a/client/platform/web-girder/views/NavigationBar.vue
+++ b/client/platform/web-girder/views/NavigationBar.vue
@@ -82,6 +82,12 @@ export default defineComponent({
         >
           Models <v-icon>mdi-brain</v-icon>
         </v-tab>
+        <v-tab
+          v-if="pipelinesEnabled"
+          to="/scoring"
+        >
+          Scoring <v-icon>mdi-chart-box-outline</v-icon>
+        </v-tab>
         <v-tab
           v-if="isAdmin"
           to="/admin"
diff --git a/client/platform/web-girder/views/Scoring.vue b/client/platform/web-girder/views/Scoring.vue
new file mode 100644
index 000000000..639abe844
--- /dev/null
+++ b/client/platform/web-girder/views/Scoring.vue
@@ -0,0 +1,35 @@
+<script lang="ts">
+import { computed, defineComponent } from 'vue';
+import { useRoute, useRouter } from 'vue-router/composables';
+import ScoringPage from 'dive-common/components/Scoring/ScoringPage.vue';
+
+export default defineComponent({
+  name: 'Scoring',
+  components: { ScoringPage },
+  setup() {
+    const route = useRoute();
+    const router = useRouter();
+
+    const initialDatasetIds = computed(() => {
+      const raw = route.query.datasetIds;
+      const joined = Array.isArray(raw) ? raw.join(',') : raw;
+      return typeof joined === 'string' ? joined.split(',').filter((id) => id) : [];
+    });
+
+    function openViewer(id: string) {
+      router.push({ name: 'viewer', params: { id } });
+    }
+
+    return { initialDatasetIds, openViewer };
+  },
+});
+</script>
+
+<template>
+  <v-container fluid>
+    <ScoringPage
+      :initial-dataset-ids="initialDatasetIds"
+      @open-viewer="openViewer"
+    />
+  </v-container>
+</template>
diff --git a/client/platform/web-girder/views/ViewerLoader.vue b/client/platform/web-girder/views/ViewerLoader.vue
index b4b1a68d3..25eee9761 100644
--- a/client/platform/web-girder/views/ViewerLoader.vue
+++ b/client/platform/web-girder/views/ViewerLoader.vue
@@ -330,6 +330,11 @@ export default defineComponent({
 
     watch(currentJob, async () => {
       if (currentJob.value !== false && currentJob.value !== undefined) {
+        if (currentJob.value.type === 'scoring') {
+          // Scoring never touches the annotations; the scoring page picks up the result
+          jobs.removeCompleteJob({ datasetId: parentDatasetId(props.id) });
+          return;
+        }
         if (currentJob.value.success) {
           const result = await prompt({
             title: 'Pipeline Finished',
diff --git a/samples/scripts/scoring/.gitignore b/samples/scripts/scoring/.gitignore
new file mode 100644
index 000000000..c553f4b3f
--- /dev/null
+++ b/samples/scripts/scoring/.gitignore
@@ -0,0 +1,3 @@
+*.json
+*.mp4
+scoring-sample/
diff --git a/samples/scripts/scoring/README.md b/samples/scripts/scoring/README.md
new file mode 100644
index 000000000..86240f831
--- /dev/null
+++ b/samples/scripts/scoring/README.md
@@ -0,0 +1,67 @@
+# Scoring Sample Dataset
+
+Generate a small DIVE dataset for testing the scoring workflow: an H.264 video, ground-truth annotations, a simulated detector run, and a type configuration file.
+
+## Prerequisites
+
+- [uv](https://docs.astral.sh/uv/) for running the script
+- `ffmpeg` installed and available in your PATH
+
+## Usage
+
+From this directory:
+
+```bash
+uv run --script generate_dataset.py
+```
+
+Options:
+
+- `--output` / `-o`: Output directory (default: `./scoring-sample`)
+- `--types` / `-n`: Number of distinct track types; names are generated with Faker (default: `5`)
+- `--tracks` / `-t`: Number of ground-truth tracks (default: `20`)
+- `--duration` / `-d`: Video length in seconds (default: `120`)
+- `--seed`: Random seed for reproducible output (default: `42`)
+
+Example with a shorter clip and fewer tracks:
+
+```bash
+uv run --script generate_dataset.py -o ./my-scoring-data -t 10 -d 60 -n 3
+```
+
+## Files
+
+- `sample_video.mp4` — H.264 video (no transcoding required)
+- `ground_truth.dive.json` — ground-truth tracks
+- `test.dive.json` — simulated detector output for scoring
+- `result.json` — same as ground truth; auto-imported when opening the folder
+- `config.json` — type styling and confidence filters
+
+## Import
+
+### Desktop
+
+1. Import `sample_video.mp4` from the output folder.
+2. DIVE should auto-attach `result.json` and `config.json`.
+3. Annotations appear on the **default** set immediately (up to six tracks on frame 0).
+
+To load the test run later: **Import Annotations** → choose `test.dive.json` (overwrite or additive).
+
+### Web (annotation sets)
+
+Annotation sets are **web-only**. If you import `ground_truth.dive.json` into a named set such as `groundTruth`, switch to that set in the viewer (chip next to the dataset name) before expecting to see tracks. The `default` set stays empty until you import something into it.
+
+**Important:** Re-import the updated annotation files after pulling the latest DIVE server (annotation JSON with `fps` is no longer misclassified as configuration).
+
+Suggested scoring layout:
+
+1. Import the video (or upload the folder).
+2. Import `ground_truth.dive.json` into set `groundTruth`.
+3. Import `test.dive.json` into set `default`.
+4. In Scoring, use `default` as computed and `groundTruth` as truth.
+
+## Notes
+
+- Annotation FPS matches the video at **30** (e.g. 3600 frames over a 2-minute clip). The dive JSON includes `"fps": 30` so the dataset timeline matches.
+- Tracks are spread across the full timeline; scrub or play to see them all.
+- Track type names are random English words from Faker; use `--seed` to reproduce a specific set of names.
diff --git a/samples/scripts/scoring/generate_dataset.py b/samples/scripts/scoring/generate_dataset.py
new file mode 100644
index 000000000..7939de5f6
--- /dev/null
+++ b/samples/scripts/scoring/generate_dataset.py
@@ -0,0 +1,462 @@
+# /// script
+# requires-python = ">=3.8"
+# dependencies = [
+#     "click",
+#     "faker",
+# ]
+# ///
+"""Generate a DIVE scoring sample dataset with ground truth and test data."""
+
+from __future__ import annotations
+
+import json
+import math
+import random
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import click
+from faker import Faker
+
+FRAME_WIDTH = 1280
+FRAME_HEIGHT = 720
+VIDEO_FPS = 30
+
+DEFAULT_TYPE_COLORS = [
+    "#4CAF50",
+    "#F44336",
+    "#9E9E9E",
+    "#FF9800",
+    "#795548",
+    "#2196F3",
+    "#E91E63",
+    "#9C27B0",
+    "#00BCD4",
+    "#8BC34A",
+]
+
+
+def generate_track_types(count: int, seed: int) -> list[str]:
+    """Return ``count`` unique lowercase type names from Faker."""
+    fake = Faker()
+    fake.seed_instance(seed)
+    types: set[str] = set()
+    while len(types) < count:
+        types.add(fake.word().lower())
+    return sorted(types)
+
+
+def type_colors(count: int) -> list[str]:
+    """Return ``count`` distinct hex colors for custom type styling."""
+    if count <= len(DEFAULT_TYPE_COLORS):
+        return DEFAULT_TYPE_COLORS[:count]
+    colors = list(DEFAULT_TYPE_COLORS)
+    for i in range(len(DEFAULT_TYPE_COLORS), count):
+        hue = (i * 137.508) % 360
+        colors.append(_hsl_to_hex(hue, 0.65, 0.5))
+    return colors
+
+
+def _hsl_to_hex(h: float, s: float, lightness: float) -> str:
+    c = (1 - abs(2 * lightness - 1)) * s
+    x = c * (1 - abs((h / 60) % 2 - 1))
+    m = lightness - c / 2
+    if h < 60:
+        r, g, b = c, x, 0
+    elif h < 120:
+        r, g, b = x, c, 0
+    elif h < 180:
+        r, g, b = 0, c, x
+    elif h < 240:
+        r, g, b = 0, x, c
+    elif h < 300:
+        r, g, b = x, 0, c
+    else:
+        r, g, b = c, 0, x
+    return "#{:02X}{:02X}{:02X}".format(
+        int((r + m) * 255),
+        int((g + m) * 255),
+        int((b + m) * 255),
+    )
+
+
+def create_video(path: Path, duration_seconds: int) -> None:
+    """Create an H.264 MP4 that DIVE can play without transcoding."""
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-f",
+        "lavfi",
+        "-i",
+        f"testsrc=size={FRAME_WIDTH}x{FRAME_HEIGHT}:rate={VIDEO_FPS}",
+        "-t",
+        str(duration_seconds),
+        "-c:v",
+        "libx264",
+        "-pix_fmt",
+        "yuv420p",
+        "-profile:v",
+        "main",
+        "-movflags",
+        "+faststart",
+        "-aspect",
+        "16:9",
+        str(path),
+    ]
+    subprocess.run(cmd, check=True, capture_output=True)
+
+
+def rectangle_bounds(cx: float, cy: float, half_size: float) -> list[int]:
+    """Return axis-aligned rectangle bounds [x1, y1, x2, y2]."""
+    return [
+        int(round(cx - half_size)),
+        int(round(cy - half_size)),
+        int(round(cx + half_size)),
+        int(round(cy + half_size)),
+    ]
+
+
+def clamp(value: float, low: float, high: float) -> float:
+    return max(low, min(high, value))
+
+
+def build_track(
+    track_id: int,
+    begin: int,
+    end: int,
+    rng: random.Random,
+    track_types: list[str],
+    *,
+    confidence: Optional[float] = None,
+) -> dict:
+    track_type = rng.choice(track_types)
+    if confidence is None:
+        confidence = round(rng.uniform(0.75, 0.99), 3)
+
+    margin = 80
+    x = rng.uniform(margin, FRAME_WIDTH - margin)
+    y = rng.uniform(margin, FRAME_HEIGHT - margin)
+    dx = rng.choice([-4.0, -3.0, 3.0, 4.0])
+    dy = rng.choice([-3.0, -2.0, 2.0, 3.0])
+    base_size = rng.uniform(35, 90)
+    growth_rate = rng.uniform(0.04, 0.12)
+
+    features = []
+    for frame in range(begin, end + 1):
+        x += dx
+        y += dy
+        if x < margin or x > FRAME_WIDTH - margin:
+            dx *= -1
+            x = clamp(x, margin, FRAME_WIDTH - margin)
+        if y < margin or y > FRAME_HEIGHT - margin:
+            dy *= -1
+            y = clamp(y, margin, FRAME_HEIGHT - margin)
+
+        half_size = base_size * (0.75 + 0.25 * (1 + math.sin(growth_rate * frame)))
+        features.append({
+            "frame": frame,
+            "bounds": rectangle_bounds(x, y, half_size),
+        })
+
+    return {
+        "id": track_id,
+        "confidencePairs": [[track_type, confidence]],
+        "begin": begin,
+        "end": end,
+        "features": features,
+    }
+
+
+def build_ground_truth_tracks(
+    rng: random.Random,
+    num_frames: int,
+    num_tracks: int,
+    track_types: list[str],
+) -> dict:
+    tracks = {}
+    occupied = []
+
+    slot_count = num_tracks
+    slot_size = max(1, num_frames // slot_count)
+    min_duration = max(5, num_frames // 12)
+    max_duration = max(min_duration + 1, min(num_frames - 1, num_frames // 2))
+
+    for track_id in range(num_tracks):
+        duration = rng.randint(min_duration, max_duration)
+        slot_begin = (track_id * slot_size) + rng.randint(
+            0, max(0, slot_size // 3)
+        )
+        latest_start = max(0, num_frames - duration - 1)
+        begin = min(slot_begin, latest_start)
+        if track_id < min(6, num_tracks):
+            begin = 0
+        end = min(num_frames - 1, begin + duration)
+
+        for _ in range(20):
+            overlap = sum(1 for b, e in occupied if not (end < b or begin > e))
+            if overlap < 3:
+                break
+            begin = min(rng.randint(0, latest_start), latest_start)
+            if track_id < min(6, num_tracks):
+                begin = 0
+            end = min(num_frames - 1, begin + duration)
+        occupied.append((begin, end))
+
+        tracks[str(track_id)] = build_track(
+            track_id,
+            begin,
+            end,
+            rng,
+            track_types,
+        )
+    return tracks
+
+
+def shift_bounds(
+    bounds: list, dx: float, dy: float, scale: float = 1.0
+) -> list:
+    x1, y1, x2, y2 = bounds
+    cx = (x1 + x2) / 2
+    cy = (y1 + y2) / 2
+    half_w = (x2 - x1) / 2 * scale
+    half_h = (y2 - y1) / 2 * scale
+    return [
+        int(round(cx - half_w + dx)),
+        int(round(cy - half_h + dy)),
+        int(round(cx + half_w + dx)),
+        int(round(cy + half_h + dy)),
+    ]
+
+
+def mutation_list(num_tracks: int) -> list[str]:
+    """Build a shuffled list of test mutations scaled to ``num_tracks``."""
+    matched = max(0, num_tracks - 3)
+    if matched == 0:
+        return []
+    scale = matched / 17
+    counts = {
+        "high_iou": max(1, round(8 * scale)),
+        "marginal_iou": max(0, round(4 * scale)),
+        "low_iou": max(0, round(2 * scale)),
+        "label_swap": max(0, round(2 * scale)),
+        "shortened": max(0, round(2 * scale)),
+    }
+    mutations: list[str] = []
+    for name, count in counts.items():
+        mutations.extend([name] * count)
+    while len(mutations) < matched:
+        mutations.append("high_iou")
+    return mutations[:matched]
+
+
+def mutate_track_for_test(
+    gt_track: dict,
+    rng: random.Random,
+    mutation: str,
+    track_types: list[str],
+) -> dict:
+    track = json.loads(json.dumps(gt_track))
+
+    if mutation == "high_iou":
+        dx, dy = rng.uniform(-8, 8), rng.uniform(-8, 8)
+        scale = rng.uniform(0.92, 1.05)
+        confidence = round(rng.uniform(0.7, 0.95), 3)
+    elif mutation == "marginal_iou":
+        dx, dy = rng.uniform(-25, 25), rng.uniform(-25, 25)
+        scale = rng.uniform(0.75, 0.9)
+        confidence = round(rng.uniform(0.45, 0.7), 3)
+    elif mutation == "low_iou":
+        dx, dy = rng.uniform(-60, 60), rng.uniform(-60, 60)
+        scale = rng.uniform(0.55, 0.75)
+        confidence = round(rng.uniform(0.35, 0.6), 3)
+    elif mutation == "label_swap":
+        dx, dy = rng.uniform(-6, 6), rng.uniform(-6, 6)
+        scale = rng.uniform(0.95, 1.02)
+        confidence = round(rng.uniform(0.65, 0.9), 3)
+        current = track["confidencePairs"][0][0]
+        alternatives = [t for t in track_types if t != current]
+        track["confidencePairs"] = [[rng.choice(alternatives), confidence]]
+    elif mutation == "shortened":
+        dx, dy = rng.uniform(-10, 10), rng.uniform(-10, 10)
+        scale = rng.uniform(0.9, 1.0)
+        confidence = round(rng.uniform(0.6, 0.9), 3)
+        trim = rng.randint(3, 8)
+        track["begin"] += trim
+        track["features"] = [
+            f for f in track["features"] if f["frame"] >= track["begin"]
+        ]
+        if track["features"]:
+            track["end"] = track["features"][-1]["frame"]
+    else:
+        dx, dy, scale = 0.0, 0.0, 1.0
+        confidence = track["confidencePairs"][0][1]
+
+    if mutation != "label_swap" and track["confidencePairs"]:
+        label = track["confidencePairs"][0][0]
+        track["confidencePairs"] = [[label, confidence]]
+
+    for feature in track["features"]:
+        feature["bounds"] = shift_bounds(feature["bounds"], dx, dy, scale)
+
+    return track
+
+
+def build_test_tracks(
+    gt_tracks: dict,
+    rng: random.Random,
+    num_frames: int,
+    num_tracks: int,
+    track_types: list[str],
+) -> dict:
+    mutations = mutation_list(num_tracks)
+    rng.shuffle(mutations)
+
+    test_tracks = {}
+    next_id = 1000
+
+    gt_ids = sorted(gt_tracks.keys(), key=int)
+    omit_count = min(3, len(gt_ids))
+    omitted = set(rng.sample(gt_ids, omit_count)) if omit_count else set()
+
+    for gt_id in gt_ids:
+        if gt_id in omitted:
+            continue
+        mutation = mutations.pop() if mutations else "high_iou"
+        test_tracks[gt_id] = mutate_track_for_test(
+            gt_tracks[gt_id], rng, mutation, track_types
+        )
+
+    false_positive_count = max(1, num_tracks // 4)
+    min_duration = max(5, num_frames // 15)
+    max_duration = max(min_duration + 1, min(num_frames - 1, num_frames // 3))
+    for _ in range(false_positive_count):
+        duration = rng.randint(min_duration, max_duration)
+        begin = rng.randint(0, max(0, num_frames - duration - 1))
+        end = min(num_frames - 1, begin + duration)
+        test_tracks[str(next_id)] = build_track(
+            next_id,
+            begin,
+            end,
+            rng,
+            track_types,
+            confidence=round(rng.uniform(0.4, 0.85), 3),
+        )
+        next_id += 1
+
+    return test_tracks
+
+
+def write_dive_json(tracks: dict, path: Path, fps: int = VIDEO_FPS) -> None:
+    payload = {
+        "version": 2,
+        "fps": fps,
+        "tracks": tracks,
+        "groups": {},
+    }
+    path.write_text(
+        json.dumps(payload, separators=(",", ":")),
+        encoding="utf-8",
+    )
+
+
+def write_config(path: Path, track_types: list[str]) -> None:
+    colors = type_colors(len(track_types))
+    payload = {
+        "version": 1,
+        "confidenceFilters": {
+            "default": 0.1,
+            **{track_type: 0.5 for track_type in track_types},
+        },
+        "customTypeStyling": {
+            track_type: {"color": color}
+            for track_type, color in zip(track_types, colors)
+        },
+    }
+    path.write_text(
+        json.dumps(payload, separators=(",", ":")),
+        encoding="utf-8",
+    )
+
+
+@click.command()
+@click.option(
+    "--output",
+    "-o",
+    default="./scoring-sample",
+    show_default=True,
+    type=click.Path(file_okay=False),
+    help="Output directory for the generated dataset",
+)
+@click.option(
+    "--types",
+    "-n",
+    default=5,
+    show_default=True,
+    type=click.IntRange(1),
+    help="Number of distinct track types (names generated with Faker)",
+)
+@click.option(
+    "--tracks",
+    "-t",
+    default=20,
+    show_default=True,
+    type=click.IntRange(1),
+    help="Number of ground-truth tracks",
+)
+@click.option(
+    "--duration",
+    "-d",
+    default=120,
+    show_default=True,
+    type=click.IntRange(1),
+    help="Video duration in seconds",
+)
+@click.option(
+    "--seed",
+    default=42,
+    show_default=True,
+    help="Random seed for reproducible output",
+)
+def main(
+    output: str, types: int, tracks: int, duration: int, seed: int
+) -> None:
+    output_dir = Path(output)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    video_path = output_dir / "sample_video.mp4"
+
+    track_types = generate_track_types(types, seed)
+    rng = random.Random(seed)
+    num_frames = duration * VIDEO_FPS
+
+    click.echo(f"Track types: {', '.join(track_types)}")
+    click.echo(f"Creating video at {video_path} ...")
+    create_video(video_path, duration)
+
+    click.echo("Building ground truth annotations ...")
+    gt_tracks = build_ground_truth_tracks(rng, num_frames, tracks, track_types)
+    write_dive_json(gt_tracks, output_dir / "ground_truth.dive.json")
+    # DIVE auto-discovers result*.json beside the video during import.
+    write_dive_json(gt_tracks, output_dir / "result.json")
+
+    click.echo("Building test run annotations ...")
+    test_rng = random.Random(seed + 1)
+    test_tracks = build_test_tracks(
+        gt_tracks, test_rng, num_frames, tracks, track_types
+    )
+    write_dive_json(test_tracks, output_dir / "test.dive.json")
+
+    write_config(output_dir / "config.json", track_types)
+
+    click.echo("Done.")
+    click.echo(
+        f"  Video: {video_path.name} ({duration}s, H.264, {VIDEO_FPS} fps)"
+    )
+    click.echo(f"  Ground truth tracks: {len(gt_tracks)}")
+    click.echo(f"  Test tracks: {len(test_tracks)}")
+    click.echo(f"  Annotation fps: {VIDEO_FPS} ({num_frames} frames)")
+    click.echo(f"  Output: {output_dir.resolve()}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/server/dive_server/__init__.py b/server/dive_server/__init__.py
index 00efc306e..0cda82a9c 100644
--- a/server/dive_server/__init__.py
+++ b/server/dive_server/__init__.py
@@ -24,6 +24,7 @@
     use_private_queue,
 )
 from .views_rpc import RpcResource
+from .views_scoring import ScoringResource
 
 logger = logging.getLogger(__name__)
 
@@ -38,6 +39,7 @@ def load(self, info):
         info["apiRoot"].dive_configuration = ConfigurationResource("dive_configuration")
         info["apiRoot"].dive_dataset = DatasetResource("dive_dataset")
         info["apiRoot"].dive_rpc = RpcResource("dive_rpc")
+        info["apiRoot"].dive_scoring = ScoringResource("dive_scoring")
         # required because girder doesn't load plugins in order so we need to manually load first.
         getPlugin('jobs').load(info)
         # Setup route additions for exsting resources
diff --git a/server/dive_server/crud_annotation.py b/server/dive_server/crud_annotation.py
index e9753d7cc..a4a12f482 100644
--- a/server/dive_server/crud_annotation.py
+++ b/server/dive_server/crud_annotation.py
@@ -160,6 +160,7 @@ def get_annotation_csv_generator(
     excludeBelowThreshold=False,
     typeFilter=None,
     revision=None,
+    set: Optional[str] = None,
 ) -> Tuple[str, Callable[[], Generator[str, None, None]]]:
     """Get the annotation generator for a folder"""
     fps = None
@@ -175,7 +176,7 @@ def get_annotation_csv_generator(
     datasetInfo = fromMeta(folder, "datasetInfo", {})
 
     def downloadGenerator():
-        datalist = TrackItem().list(folder, revision=revision)
+        datalist = TrackItem().list(folder, revision=revision, set=set)
         for data in viame.export_tracks_as_csv(
             datalist,
             excludeBelowThreshold,
diff --git a/server/dive_server/crud_rpc.py b/server/dive_server/crud_rpc.py
index 566998d7f..13597d3ce 100644
--- a/server/dive_server/crud_rpc.py
+++ b/server/dive_server/crud_rpc.py
@@ -12,7 +12,7 @@
 from girder.notification import Notification
 from girder_jobs.models.job import Job, JobStatus
 from girder_plugin_worker.status import CustomJobStatus
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 import pymongo
 from typing_extensions import NotRequired
 
@@ -36,6 +36,7 @@
     types,
 )
 from dive_utils.constants import TrainingModelExtensions
+from dive_utils.scoring import DEFAULT_SCORING_PARAMS
 from dive_utils.serializers import dive, kpf, kwcoco, viame
 from dive_utils.type_hierarchy import (
     HierarchyWrite,
@@ -52,6 +53,52 @@ class RunTrainingArgs(BaseModel):
     fineTuneModel: Optional[types.TrainingModelTuneArgs]
 
 
+class ScoringSourceModel(BaseModel):
+    datasetId: str
+    set: Optional[str]
+    revision: Optional[int]
+    file: Optional[str]
+    label: Optional[str]
+
+    class Config:
+        extra = 'ignore'
+
+
+class ScoringParamsModel(BaseModel):
+    iouThreshold: float = DEFAULT_SCORING_PARAMS['iouThreshold']
+    confidenceThreshold: float = DEFAULT_SCORING_PARAMS['confidenceThreshold']
+    matchMode: Literal['box', 'polygon'] = DEFAULT_SCORING_PARAMS['matchMode']
+    perClass: bool = DEFAULT_SCORING_PARAMS['perClass']
+    topClass: bool = DEFAULT_SCORING_PARAMS['topClass']
+    auxConfidence: bool = DEFAULT_SCORING_PARAMS['auxConfidence']
+    tracking: bool = DEFAULT_SCORING_PARAMS['tracking']
+    keypointThreshold: float = DEFAULT_SCORING_PARAMS['keypointThreshold']
+    sweep: bool = DEFAULT_SCORING_PARAMS['sweep']
+    sweepInterval: int = DEFAULT_SCORING_PARAMS['sweepInterval']
+    filterEstimator: Literal['none', 'min', 'avg', 'avg_minus_1p', 'idf1', 'mota'] = (
+        DEFAULT_SCORING_PARAMS['filterEstimator']
+    )
+    defaultLabel: Optional[str] = DEFAULT_SCORING_PARAMS['defaultLabel']
+    labelSynonyms: Optional[str] = DEFAULT_SCORING_PARAMS['labelSynonyms']
+
+    class Config:
+        extra = 'ignore'
+
+
+class ScoringPairModel(BaseModel):
+    computed: ScoringSourceModel
+    truth: ScoringSourceModel
+
+    class Config:
+        extra = 'ignore'
+
+
+class RunScoringArgs(BaseModel):
+    pairs: List[ScoringPairModel] = Field(..., min_items=1)
+    params: ScoringParamsModel = Field(default_factory=ScoringParamsModel)
+    title: Optional[str]
+
+
 def _get_queue_name(user: types.GirderUserModel, default="celery") -> str:
     if user.get(constants.UserPrivateQueueEnabledMarker, False):
         return f'{user["login"]}@private'
@@ -641,6 +688,126 @@ def run_training(
     )
 
 
+def _scoring_source_dict(source: ScoringSourceModel) -> types.ScoringSourceJob:
+    return cast(
+        types.ScoringSourceJob,
+        {key: value for key, value in source.dict().items() if value is not None},
+    )
+
+
+def _scoring_pair_dict(pair: ScoringPairModel) -> types.ScoringPairJob:
+    return {
+        'computed': _scoring_source_dict(pair.computed),
+        'truth': _scoring_source_dict(pair.truth),
+    }
+
+
+def _load_scoring_dataset(
+    user: types.GirderUserModel, dataset_id: str, level: int
+) -> types.GirderModel:
+    folder = Folder().load(dataset_id, level=level, user=user)
+    if folder is None:
+        raise RestException(f"Cannot access dataset {dataset_id}", code=404)
+    crud.verify_dataset(folder)
+    if fromMeta(folder, constants.TypeMarker) == constants.MultiType:
+        raise RestException(
+            'Scoring runs on one camera at a time; choose a camera of the multicamera dataset',
+            code=400,
+        )
+    return folder
+
+
+def _describe_scoring_source(folder: types.GirderModel, source: types.ScoringSourceJob) -> str:
+    if source.get('label'):
+        return str(source['label'])
+    parts = [str(folder['name'])]
+    if source.get('set'):
+        parts.append(f"set {source['set']}")
+    if source.get('revision') is not None:
+        parts.append(f"rev {source['revision']}")
+    return ' · '.join(parts)
+
+
+def run_scoring(
+    user: types.GirderUserModel,
+    token: types.GirderModel,
+    args: RunScoringArgs,
+) -> types.GirderModel:
+    """Score every pair together; the result is stored on the first pair's computed dataset."""
+    storage_dataset_id = args.pairs[0].computed.datasetId
+    storage_folder = _load_scoring_dataset(user, storage_dataset_id, AccessType.WRITE)
+    storage_id = str(storage_folder['_id'])
+    folders: Dict[str, types.GirderModel] = {storage_dataset_id: storage_folder}
+    for pair in args.pairs:
+        for source in (pair.computed, pair.truth):
+            if source.datasetId not in folders:
+                folders[source.datasetId] = _load_scoring_dataset(
+                    user, source.datasetId, AccessType.READ
+                )
+
+    # Attribute the job the way run_pipeline does so the viewer's running-job
+    # state (keyed by the multicam parent for camera folders) sees it.
+    multicam_parent = crud.get_multicam_parent_folder(storage_folder, user)
+    job_dataset_id = str(multicam_parent['_id']) if multicam_parent is not None else storage_id
+    if _check_running_jobs(job_dataset_id) or (
+        job_dataset_id != storage_id and _check_running_jobs(storage_id)
+    ):
+        raise RestException(
+            (
+                f"A job for {job_dataset_id} is already running. "
+                "Only one outstanding job may be run at a time for "
+                "a dataset."
+            )
+        )
+
+    pairs = [_scoring_pair_dict(pair) for pair in args.pairs]
+    if args.title:
+        title = args.title
+    else:
+        first = pairs[0]
+        computed_name = _describe_scoring_source(
+            folders[first['computed']['datasetId']], first['computed']
+        )
+        truth_name = _describe_scoring_source(folders[first['truth']['datasetId']], first['truth'])
+        title = f"{computed_name} vs {truth_name}"
+        if len(pairs) > 1:
+            title += f" (+{len(pairs) - 1} more)"
+    params: types.ScoringJob = {
+        'pairs': pairs,
+        'params': args.params.dict(),
+        'title': title,
+        'results_folder_id': storage_id,
+        'user_id': str(user['_id']),
+        'user_login': user.get('login', 'unknown'),
+    }
+    job_is_private = user.get(constants.UserPrivateQueueEnabledMarker, False)
+    newjob = tasks.run_scoring.apply_async(
+        queue=_get_queue_name(user, "pipelines"),
+        kwargs=dict(
+            params=params,
+            girder_job_title=f"Scoring {title}",
+            girder_client_token=str(token["_id"]),
+            girder_job_type="private" if job_is_private else "scoring",
+        ),
+    )
+    job = _persist_async_job_metadata(
+        newjob,
+        access_source=storage_folder,
+        **{
+            constants.JOBCONST_PRIVATE_QUEUE: job_is_private,
+            constants.JOBCONST_DATASET_ID: job_dataset_id,
+            constants.JOBCONST_PARAMS: params,
+            constants.JOBCONST_CREATOR: str(user['_id']),
+        },
+    )
+    Notification(
+        type='job_status',
+        data=job,
+        user=user,
+    ).flush()
+    return job
+
+
 GetDataReturnType = TypedDict(
     'GetDataReturnType',
     {
diff --git a/server/dive_server/crud_scoring.py b/server/dive_server/crud_scoring.py
new file mode 100644
index 000000000..e3dd0ebff
--- /dev/null
+++ b/server/dive_server/crud_scoring.py
@@ -0,0 +1,124 @@
+"""Scoring results persisted by dive_tasks.run_scoring in a dataset's auxiliary folder."""
+
+from datetime import datetime
+import json
+from typing import Any, Dict, List, Optional
+
+from girder.constants import AccessType
+from girder.exceptions import RestException
+from girder.models.file import File
+from girder.models.folder import Folder
+from girder.models.item import Item
+
+from dive_server.crud_annotation import RevisionLogItem
+from dive_utils import constants, types
+from dive_utils.scoring import SCORING_RESULT_META
+
+# Enough for the cross-dataset listing without paging.
+ALL_RESULTS_LIMIT = 200
+
+
+def _auxiliary_folder(folder: types.GirderModel) -> Optional[types.GirderModel]:
+    return Folder().findOne(
+        {
+            'parentId': folder['_id'],
+            'parentCollection': 'folder',
+            'name': constants.AuxiliaryFolderName,
+        }
+    )
+
+
+def _isoformat(value: Any) -> str:
+    if isinstance(value, datetime):
+        return value.isoformat()
+    return str(value)
+
+
+def _dataset_id_of_item(item: types.GirderModel) -> str:
+    """The dataset whose auxiliary folder holds the result item."""
+    auxiliary = Folder().load(item['folderId'], force=True)
+    return str(auxiliary['parentId']) if auxiliary else ''
+
+
+def _summary_from_item(item: types.GirderModel, dataset_id: Optional[str] = None) -> Dict[str, Any]:
+    meta = item['meta'][SCORING_RESULT_META]
+    pairs = meta.get('pairs')
+    if pairs is None and meta.get('computed') and meta.get('truth'):
+        # Results written before a run scored a list of sequences
+        pairs = [{'computed': meta['computed'], 'truth': meta['truth']}]
+    return {
+        'id': str(item['_id']),
+        'datasetId': meta.get('datasetId') or dataset_id or _dataset_id_of_item(item),
+        'created': meta.get('created') or _isoformat(item['created']),
+        'title': meta.get('title') or item['name'],
+        'pairs': pairs or [],
+        'params': meta.get('params') or {},
+        'headline': meta.get('headline') or {},
+    }
+
+
+def list_results(folder: types.GirderModel) -> List[Dict[str, Any]]:
+    auxiliary = _auxiliary_folder(folder)
+    if auxiliary is None:
+        return []
+    items = Item().find(
+        {'folderId': auxiliary['_id'], f'meta.{SCORING_RESULT_META}': {'$exists': True}},
+        sort=[('created', -1)],
+    )
+    return [_summary_from_item(item, str(folder['_id'])) for item in items]
+
+
+def list_all_results(user: types.GirderUserModel) -> List[Dict[str, Any]]:
+    """Every scoring result the user can read, newest first."""
+    items = Item().findWithPermissions(
+        {f'meta.{SCORING_RESULT_META}': {'$exists': True}},
+        user=user,
+        level=AccessType.READ,
+        sort=[('created', -1)],
+        limit=ALL_RESULTS_LIMIT,
+    )
+    return [_summary_from_item(item) for item in items]
+
+
+def _verify_result_item(folder: types.GirderModel, item: types.GirderModel):
+    auxiliary = _auxiliary_folder(folder)
+    if (
+        auxiliary is None
+        or item['folderId'] != auxiliary['_id']
+        or SCORING_RESULT_META not in (item.get('meta') or {})
+    ):
+        raise RestException('Scoring result not found in this dataset', code=404)
+
+
+def load_result(folder: types.GirderModel, item: types.GirderModel) -> Dict[str, Any]:
+    _verify_result_item(folder, item)
+    file = next(Item().childFiles(item), None)
+    if file is None:
+        raise RestException('Scoring result has no file', code=404)
+    content = b"".join(File().download(file, headers=False)())
+    result = json.loads(content.decode('utf-8'))
+    result['id'] = str(item['_id'])
+    return result
+
+
+def delete_result(folder: types.GirderModel, item: types.GirderModel):
+    _verify_result_item(folder, item)
+    Item().remove(item)
+
+
+def source_options(folder: types.GirderModel) -> Dict[str, Any]:
+    sets = [name for name in RevisionLogItem().sets(folder) if name]
+    cursor, _ = RevisionLogItem().list(folder)
+    revisions = []
+    for entry in cursor:
+        revision = {
+            'revision': entry['revision'],
+            'description': entry.get('description') or '',
+            'created': _isoformat(entry.get('created')),
+        }
+        if entry.get('author_name'):
+            revision['author'] = entry['author_name']
+        if entry.get('set'):
+            revision['set'] = entry['set']
+        revisions.append(revision)
+    return {'sets': sets, 'revisions': revisions, 'files': []}
diff --git a/server/dive_server/views_annotation.py b/server/dive_server/views_annotation.py
index a9a686823..913df8f37 100644
--- a/server/dive_server/views_annotation.py
+++ b/server/dive_server/views_annotation.py
@@ -126,6 +126,14 @@ def get_sets(self, limit: int, offset: int, sort, folder):
             default=None,
             requireArray=True,
         )
+        .param(
+            "set",
+            "Annotation set to export (viame_csv only).  Default is the default set.",
+            paramType="query",
+            dataType="string",
+            default=None,
+            required=False,
+        )
     )
     def export(
         self,
@@ -134,6 +142,7 @@ def export(
         revisionId: int,
         format: str,
         typeFilter: Optional[List[str]],
+        set: Optional[str],
     ):
         crud.verify_dataset(folder)
 
@@ -156,6 +165,7 @@ def export(
                 excludeBelowThreshold=excludeBelowThreshold,
                 typeFilter=typeFilter,
                 revision=revisionId,
+                set=set or None,
             )
             setContentDisposition(filename, mime='text/csv')
             return gen
diff --git a/server/dive_server/views_dataset.py b/server/dive_server/views_dataset.py
index 13abdf30a..e71e558d9 100644
--- a/server/dive_server/views_dataset.py
+++ b/server/dive_server/views_dataset.py
@@ -14,7 +14,7 @@
 from dive_utils import constants, setContentDisposition
 from dive_utils.models import MetadataMutable
 
-from . import crud, crud_dataset
+from . import crud, crud_dataset, crud_scoring
 
 DatasetModelParam = {
     'description': "dataset id",
@@ -51,6 +51,10 @@ def __init__(self, resourceName):
         self.route("POST", (":id", "metadata_file"), self.set_dataset_metadata_file)
         self.route("GET", (":id", "media"), self.get_media)
         self.route("GET", (":id", "frame_metadata_sources"), self.get_frame_metadata_sources)
+        self.route("GET", (":id", "scoring"), self.list_scoring_results)
+        self.route("GET", (":id", "scoring", ":resultId"), self.get_scoring_result)
+        self.route("DELETE", (":id", "scoring", ":resultId"), self.delete_scoring_result)
+        self.route("GET", (":id", "scoring_sources"), self.get_scoring_sources)
         self.route("GET", ("export",), self.export)
         self.route("GET", (":id", "configuration"), self.get_configuration)
         self.route("GET", (":id", "media", ":mediaId", "download"), self.download_media)
@@ -300,6 +304,56 @@ def get_media(self, folder):
     def get_frame_metadata_sources(self, folder):
         return crud_dataset.load_frame_metadata_sources(folder, self.getCurrentUser())
 
+    @access.user
+    @autoDescribeRoute(
+        Description("List scoring results stored on a dataset, newest first").modelParam(
+            "id", level=AccessType.READ, **DatasetModelParam
+        )
+    )
+    def list_scoring_results(self, folder):
+        return crud_scoring.list_results(folder)
+
+    @access.user
+    @autoDescribeRoute(
+        Description("Load one scoring result")
+        .modelParam("id", level=AccessType.READ, **DatasetModelParam)
+        .modelParam(
+            "resultId",
+            description="scoring result item id",
+            model=Item,
+            paramType='path',
+            level=AccessType.READ,
+            required=True,
+        )
+    )
+    def get_scoring_result(self, folder, item):
+        return crud_scoring.load_result(folder, item)
+
+    @access.user
+    @autoDescribeRoute(
+        Description("Delete one scoring result")
+        .modelParam("id", level=AccessType.WRITE, **DatasetModelParam)
+        .modelParam(
+            "resultId",
+            description="scoring result item id",
+            model=Item,
+            paramType='path',
+            level=AccessType.WRITE,
+            required=True,
+        )
+    )
+    def delete_scoring_result(self, folder, item):
+        crud_scoring.delete_result(folder, item)
+
+    @access.user
+    @autoDescribeRoute(
+        Description("Annotation sets and revisions a scoring source can use").modelParam(
+            "id", level=AccessType.READ, **DatasetModelParam
+        )
+    )
+    def get_scoring_sources(self, folder):
+        return crud_scoring.source_options(folder)
+
     @access.public(scope=TokenScope.DATA_READ, cookie=True)
     @autoDescribeRoute(
         Description("Export all selected datasets")
diff --git a/server/dive_server/views_rpc.py b/server/dive_server/views_rpc.py
index 85d8b7420..29ffe3cbe 100644
--- a/server/dive_server/views_rpc.py
+++ b/server/dive_server/views_rpc.py
@@ -25,6 +25,7 @@ def __init__(self, resourceName):
         self.route("POST", ("pipeline",), self.run_pipeline_task)
         self.route("POST", ("export",), self.export_pipeline_onnx)
         self.route("POST", ("train",), self.run_training)
+        self.route("POST", ("score",), self.run_scoring)
         self.route("POST", ("postprocess", ":id"), self.postprocess)
         self.route("POST", ("convert_dive", ":id"), self.convert_dive)
         self.route("POST", ("convert_large_image", ":id"), self.convert_large_image)
@@ -158,6 +159,26 @@ def run_training(self, body, pipelineName, config, annotatedFramesOnly, forceTra
             forceTranscoded,
         )
 
+    @access.user
+    @autoDescribeRoute(
+        Description("Score a list of sequence pairs together with viame score").jsonParam(
+            "body",
+            description=(
+                "schema: RunScoringArgs. Each pair's computed and truth name a dataset plus an "
+                "optional annotation set and revision; the result is stored on the first "
+                "pair's computed dataset."
+            ),
+            paramType="body",
+            requireObject=True,
+        )
+    )
+    def run_scoring(self, body):
+        worker_capabilities.require_pipeline_worker()
+        user = self.getCurrentUser()
+        token = Token().createToken(user=user, days=14)
+        run_scoring_args = crud.get_validated_model(crud_rpc.RunScoringArgs, **body)
+        return crud_rpc.run_scoring(user, token, run_scoring_args)
+
     @access.user
     @autoDescribeRoute(
         Description("Post-processing to be run after media/annotation import")
diff --git a/server/dive_server/views_scoring.py b/server/dive_server/views_scoring.py
new file mode 100644
index 000000000..8b9cca0be
--- /dev/null
+++ b/server/dive_server/views_scoring.py
@@ -0,0 +1,20 @@
+from girder.api import access
+from girder.api.describe import Description, autoDescribeRoute
+from girder.api.rest import Resource
+
+from . import crud_scoring
+
+
+class ScoringResource(Resource):
+    """Scoring results across every dataset the user can read."""
+
+    def __init__(self, resourceName):
+        super(ScoringResource, self).__init__()
+        self.resourceName = resourceName
+
+        self.route("GET", (), self.list_results)
+
+    @access.user
+    @autoDescribeRoute(Description("List every scoring result the user can read, newest first"))
+    def list_results(self):
+        return crud_scoring.list_all_results(self.getCurrentUser())
diff --git a/server/dive_tasks/__init__.py b/server/dive_tasks/__init__.py
index 6a13743dc..0bf12f01c 100644
--- a/server/dive_tasks/__init__.py
+++ b/server/dive_tasks/__init__.py
@@ -18,6 +18,7 @@ def task_imports(self):
             'dive_tasks.upgrade_pipelines',
             'dive_tasks.run_pipeline',
             'dive_tasks.run_training',
+            'dive_tasks.run_scoring',
             'dive_tasks.convert_video',
             'dive_tasks.convert_images',
             'dive_tasks.tasks',
diff --git a/server/dive_tasks/run_scoring.py b/server/dive_tasks/run_scoring.py
new file mode 100644
index 000000000..dfd99fb70
--- /dev/null
+++ b/server/dive_tasks/run_scoring.py
@@ -0,0 +1,198 @@
+from contextlib import suppress
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import shlex
+import tempfile
+from typing import Any, Dict, List, Tuple
+
+from girder_client import GirderClient
+from girder_worker.app import app
+from girder_worker.task import Task
+from girder_worker.utils import JobManager, JobStatus
+
+from dive_tasks import utils
+from dive_tasks.manager import patch_manager
+from dive_tasks.viame_config import Config
+from dive_utils import constants
+from dive_utils.scoring import (
+    DEFAULT_SCORING_PARAMS,
+    SCORING_RESULT_META,
+    SCORING_RESULT_VERSION,
+    result_summary,
+)
+from dive_utils.types import ScoringJob, ScoringPairJob
+
+INPUT_EXT = '.csv'
+
+
+def build_score_args(params: Dict[str, Any], paths: Dict[str, str]) -> List[str]:
+    """Unquoted ``viame score`` arguments; mirrors scoringCliArgs in metrics.ts.
+
+    ``paths`` carries ``computed`` and ``truth`` (a file each, or a folder each
+    whose files pair by basename), ``metricsOut``, plus optional ``matchesOut``,
+    ``sweepDir`` and ``labelsFile``.
+    """
+    p = {**DEFAULT_SCORING_PARAMS, **params}
+    args = [
+        '-c',
+        paths['computed'],
+        '-t',
+        paths['truth'],
+        '--input-ext',
+        INPUT_EXT,
+        '-o',
+        paths['metricsOut'],
+        '--json-curves',
+        '--iou',
+        str(p['iouThreshold']),
+        '--conf',
+        str(p['confidenceThreshold']),
+        '--match-mode',
+        str(p['matchMode']),
+        '--keypoint-threshold',
+        str(p['keypointThreshold']),
+    ]
+    if p['perClass']:
+        args.append('--per-class')
+    if p['topClass']:
+        args.append('--top-class')
+    if p['auxConfidence']:
+        args.append('--aux-confidence')
+    if not p['tracking']:
+        args.append('--no-tracking')
+    if p.get('defaultLabel'):
+        args += ['--defaultlabel', str(p['defaultLabel'])]
+    if paths.get('labelsFile'):
+        args += ['--labels', paths['labelsFile']]
+    if paths.get('matchesOut'):
+        args += ['--output-matches', paths['matchesOut']]
+    if p['sweep']:
+        args += ['--sweep-thresholds', '--sweep-interval', str(int(p['sweepInterval']))]
+        args += ['--filter-estimator', str(p['filterEstimator'])]
+        if paths.get('sweepDir'):
+            args += ['--output-sweep', paths['sweepDir']]
+    return args
+
+
+def download_pair_inputs(
+    gc: GirderClient, pairs: List[ScoringPairJob], input_path: Path
+) -> Tuple[Path, Path]:
+    """Fetch every pair's CSVs into a computed folder and a truth folder.
+
+    ``viame score`` pairs the files of two folders by basename, so pair ``i``
+    is ``seq_<i>.csv`` on both sides; its index is the matches' sequence index.
+    """
+    computed_dir = utils.make_directory(input_path / 'computed')
+    truth_dir = utils.make_directory(input_path / 'truth')
+    for index, pair in enumerate(pairs):
+        name = f'seq_{index:03d}{INPUT_EXT}'
+        for source, directory in ((pair['computed'], computed_dir), (pair['truth'], truth_dir)):
+            utils.download_annotation_csv(
+                gc,
+                source['datasetId'],
+                directory / name,
+                revision=source.get('revision'),
+                set=source.get('set'),
+            )
+    return computed_dir, truth_dir
+
+
+def _read_json(path: Path) -> Any:
+    with open(path, 'r', encoding='utf-8') as fh:
+        return json.load(fh)
+
+
+@app.task(bind=True, acks_late=True, ignore_result=True)
+def run_scoring(self: Task, params: ScoringJob):
+    """Score a list of sequence pairs together with ``viame score``."""
+    conf = Config()
+    conf.require_viame_install()
+    context: dict = {}
+    manager: JobManager = patch_manager(self.job_manager)
+    if utils.check_canceled(self, context):
+        manager.updateStatus(JobStatus.CANCELED)
+        return
+
+    gc: GirderClient = self.girder_client
+    utils.authenticate_urllib(gc)
+    manager.updateStatus(JobStatus.FETCHING_INPUT)
+
+    pairs = params['pairs']
+    scoring_params = {**DEFAULT_SCORING_PARAMS, **(params.get('params') or {})}
+    results_folder_id = params['results_folder_id']
+    title = params['title']
+
+    with tempfile.TemporaryDirectory() as _working_directory, suppress(utils.CanceledError):
+        working_directory = Path(_working_directory)
+        input_path = utils.make_directory(working_directory / 'input')
+        output_path = utils.make_directory(working_directory / 'output')
+
+        computed_dir, truth_dir = download_pair_inputs(gc, pairs, input_path)
+
+        paths = {
+            'computed': str(computed_dir),
+            'truth': str(truth_dir),
+            'metricsOut': str(output_path / 'metrics.json'),
+            'matchesOut': str(output_path / 'matches.json'),
+            'sweepDir': str(utils.make_directory(output_path / 'sweep')),
+        }
+        label_synonyms = scoring_params.get('labelSynonyms')
+        if label_synonyms:
+            labels_path = input_path / 'labels.txt'
+            labels_path.write_text(label_synonyms, encoding='utf-8')
+            paths['labelsFile'] = str(labels_path)
+
+        command = [
+            f". {shlex.quote(str(conf.viame_setup_script))} &&",
+            f"KWIVER_DEFAULT_LOG_LEVEL={shlex.quote(conf.kwiver_log_level)}",
+            f"{shlex.quote(str(conf.viame_executable))} score",
+            *(shlex.quote(arg) for arg in build_score_args(scoring_params, paths)),
+        ]
+
+        manager.updateStatus(JobStatus.RUNNING)
+        popen_kwargs = {
+            'args': " ".join(command),
+            'shell': True,
+            'executable': '/bin/bash',
+            'cwd': output_path,
+            'env': conf.gpu_process_env,
+        }
+        summary_text = utils.stream_subprocess(
+            self, context, manager, popen_kwargs, keep_stdout=True
+        )
+
+        metrics_path = Path(paths['metricsOut'])
+        if not metrics_path.is_file():
+            raise RuntimeError(
+                'viame score finished without writing metrics.json; see the job log above'
+            )
+        metrics = _read_json(metrics_path)
+        matches_path = Path(paths['matchesOut'])
+        matches = _read_json(matches_path) if matches_path.is_file() else None
+
+        created = datetime.now(timezone.utc)
+        result: Dict[str, Any] = {
+            'version': SCORING_RESULT_VERSION,
+            'id': '',
+            'datasetId': results_folder_id,
+            'created': created.isoformat(),
+            'title': title,
+            'pairs': pairs,
+            'params': scoring_params,
+            'metrics': metrics,
+            'summaryText': summary_text,
+        }
+        if matches is not None:
+            result['matches'] = matches
+
+        result_path = output_path / f"scoring_{created.strftime('%Y%m%d_%H%M%S')}.json"
+        with open(result_path, 'w', encoding='utf-8') as fh:
+            json.dump(result, fh)
+
+        manager.updateStatus(JobStatus.PUSHING_OUTPUT)
+        auxiliary = gc.createFolder(
+            results_folder_id, constants.AuxiliaryFolderName, reuseExisting=True
+        )
+        uploaded = gc.uploadFileToFolder(auxiliary['_id'], str(result_path))
+        gc.addMetadataToItem(uploaded['itemId'], {SCORING_RESULT_META: result_summary(result)})
diff --git a/server/dive_tasks/tasks.py b/server/dive_tasks/tasks.py
index 5e8762943..931348ac5 100644
--- a/server/dive_tasks/tasks.py
+++ b/server/dive_tasks/tasks.py
@@ -1,8 +1,8 @@
 """Compatibility barrel re-exporting Celery tasks and helpers.
 
 Prefer importing from the focused modules directly in new code:
-``convert_video``, ``convert_images``, ``run_pipeline``, ``run_training``,
-``upgrade_pipelines``, and ``viame_config``.
+``convert_video``, ``convert_images``, ``run_pipeline``, ``run_scoring``,
+``run_training``, ``upgrade_pipelines``, and ``viame_config``.
 """
 
 from dive_tasks.convert_images import (
@@ -18,6 +18,7 @@
     filter_image_list_by_frame_range,
     run_pipeline,
 )
+from dive_tasks.run_scoring import build_score_args, run_scoring
 from dive_tasks.run_training import export_trained_pipeline, train_pipeline
 from dive_tasks.upgrade_pipelines import (
     UPGRADE_JOB_DEFAULT_URLS,
@@ -34,6 +35,7 @@
     'UPGRADE_JOB_DEFAULT_URLS',
     '_addon_zip_path_for_url',
     '_inject_dataset_metadata_file',
+    'build_score_args',
     'convert_calibration',
     'convert_images',
     'convert_large_images',
@@ -47,6 +49,7 @@
     'is_google_drive_addon_url',
     'resolve_annotation_fps',
     'run_pipeline',
+    'run_scoring',
     'train_pipeline',
     'upgrade_pipelines',
 ]
diff --git a/server/dive_tasks/utils.py b/server/dive_tasks/utils.py
index c26934813..3fd366358 100644
--- a/server/dive_tasks/utils.py
+++ b/server/dive_tasks/utils.py
@@ -541,6 +541,27 @@ def download_revision_csv(gc: GirderClient, dataset_id: str, revision: int, path
     request.urlretrieve(url, filename=path)
 
 
+def download_annotation_csv(
+    gc: GirderClient,
+    dataset_id: str,
+    path: Path,
+    revision: Optional[int] = None,
+    set: Optional[str] = None,
+):
+    """Download the VIAME CSV for a dataset at a revision and annotation set.
+
+    Nothing is dropped below the dataset's confidence filters: scoring sweeps the
+    confidence range itself, so every computed detection has to be present.
+    """
+    args: dict = {'folderId': dataset_id, 'excludeBelowThreshold': False}
+    if revision is not None:
+        args['revisionId'] = revision
+    if set:
+        args['set'] = set
+    url = urljoin(urljoin(gc.urlBase, 'dive_annotation/export'), f'?{urlencode(args)}')
+    request.urlretrieve(url, filename=path)
+
+
 def download_source_media(
     girder_client: GirderClient, datasetId: str, dest: Path, force_transcoded=False
 ) -> Tuple[List[str], str]:
diff --git a/server/dive_utils/models.py b/server/dive_utils/models.py
index 5732a9af2..239f56903 100644
--- a/server/dive_utils/models.py
+++ b/server/dive_utils/models.py
@@ -305,6 +305,10 @@ def is_dive_configuration(value: dict):
         """
         Check if value is a configuration file if at lease one of the config options is populated
         """
+        # Annotation documents may carry annotation fps alongside tracks/groups.
+        if 'tracks' in value or 'groups' in value:
+            return False
+
         keys = list(MetadataMutable.schema()['properties'].keys())
 
         # Remove version: its appearance is not enough to indicate that
diff --git a/server/dive_utils/scoring.py b/server/dive_utils/scoring.py
new file mode 100644
index 000000000..d9a9010fd
--- /dev/null
+++ b/server/dive_utils/scoring.py
@@ -0,0 +1,71 @@
+"""Scoring mode constants shared by the REST layer and the worker task.
+
+Mirrors client/dive-common/scoring/{types,metrics}.ts; keep the two in step.
+"""
+
+import math
+from typing import Any, Dict, Optional
+
+SCORING_RESULT_VERSION = 1
+
+# Item metadata key carrying the ScoringResultSummary for a persisted result.
+SCORING_RESULT_META = 'scoringResult'
+
+DEFAULT_SCORING_PARAMS: Dict[str, Any] = {
+    'iouThreshold': 0.5,
+    'confidenceThreshold': 0.0,
+    'matchMode': 'box',
+    'perClass': True,
+    'topClass': False,
+    'auxConfidence': False,
+    'tracking': True,
+    'keypointThreshold': 0.1,
+    'sweep': True,
+    'sweepInterval': 50,
+    'filterEstimator': 'min',
+    'defaultLabel': '',
+    'labelSynonyms': '',
+}
+
+HEADLINE_METRIC_KEYS = [
+    'precision',
+    'recall',
+    'f1_score',
+    'average_precision',
+    'ap50',
+    'mean_ap',
+    'mota',
+    'idf1',
+    'hota',
+    'mean_iou',
+    'mean_polygon_iou',
+    'keypoint_pck',
+    'length_mape',
+    'true_positives',
+    'false_positives',
+    'false_negatives',
+]
+
+
+def _as_number_or_none(value: Any) -> Optional[float]:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    if not math.isfinite(value):
+        return None
+    return value
+
+
+def headline_metrics(raw: Dict[str, Any]) -> Dict[str, Optional[float]]:
+    return {key: _as_number_or_none(raw[key]) for key in HEADLINE_METRIC_KEYS if key in raw}
+
+
+def result_summary(result: Dict[str, Any]) -> Dict[str, Any]:
+    """The ScoringResultSummary fields of a ScoringResultFile, minus ``id``."""
+    return {
+        'created': result['created'],
+        'title': result['title'],
+        'datasetId': result['datasetId'],
+        'pairs': result['pairs'],
+        'params': result['params'],
+        'headline': headline_metrics(result.get('metrics') or {}),
+    }
diff --git a/server/dive_utils/types.py b/server/dive_utils/types.py
index d840f52c6..a7d066ce4 100644
--- a/server/dive_utils/types.py
+++ b/server/dive_utils/types.py
@@ -14,6 +14,9 @@
     "PipelineJob",
     "PipelineCategory",
     "PipeMetadata",
+    "ScoringJob",
+    "ScoringPairJob",
+    "ScoringSourceJob",
     "Warnings",
 ]
 
@@ -207,6 +210,34 @@ class TrainingJob(TypedDict):
     force_transcoded: Optional[bool]  # Force using the transcoded version
 
 
+class ScoringSourceJob(TypedDict):
+    """One side of a scoring comparison (mirrors the client's ScoringSource)."""
+
+    datasetId: str
+    set: NotRequired[Optional[str]]
+    revision: NotRequired[Optional[int]]
+    file: NotRequired[Optional[str]]
+    label: NotRequired[Optional[str]]
+
+
+class ScoringPairJob(TypedDict):
+    """One sequence to score: computed annotations against the truth for the same footage."""
+
+    computed: ScoringSourceJob
+    truth: ScoringSourceJob
+
+
+class ScoringJob(TypedDict):
+    """Describes the parameters for scoring a list of sequence pairs together."""
+
+    pairs: List[ScoringPairJob]
+    params: Dict[str, Any]  # ScoringParams as validated by crud_rpc.ScoringParamsModel
+    title: str
+    results_folder_id: str  # The first pair's computed dataset; receives the result item
+    user_id: str
+    user_login: str
+
+
 class ExportTrainedPipelineJob(TypedDict):
     """Describes the parameters for exporting a pipeline"""
 
diff --git a/server/tests/test_run_scoring.py b/server/tests/test_run_scoring.py
new file mode 100644
index 000000000..e87d78c60
--- /dev/null
+++ b/server/tests/test_run_scoring.py
@@ -0,0 +1,169 @@
+from pathlib import Path
+
+from dive_tasks import run_scoring, utils
+from dive_tasks.run_scoring import build_score_args, download_pair_inputs
+from dive_utils.scoring import DEFAULT_SCORING_PARAMS, headline_metrics, result_summary
+
+PATHS = {
+    'computed': '/work/input/computed',
+    'truth': '/work/input/truth',
+    'metricsOut': '/work/metrics.json',
+    'matchesOut': '/work/matches.json',
+    'sweepDir': '/work/sweep',
+}
+
+
+def test_default_params_produce_the_client_argument_list():
+    assert build_score_args(DEFAULT_SCORING_PARAMS, PATHS) == [
+        '-c',
+        '/work/input/computed',
+        '-t',
+        '/work/input/truth',
+        '--input-ext',
+        '.csv',
+        '-o',
+        '/work/metrics.json',
+        '--json-curves',
+        '--iou',
+        '0.5',
+        '--conf',
+        '0.0',
+        '--match-mode',
+        'box',
+        '--keypoint-threshold',
+        '0.1',
+        '--per-class',
+        '--output-matches',
+        '/work/matches.json',
+        '--sweep-thresholds',
+        '--sweep-interval',
+        '50',
+        '--filter-estimator',
+        'min',
+        '--output-sweep',
+        '/work/sweep',
+    ]
+
+
+def test_missing_params_fall_back_to_defaults():
+    assert build_score_args({}, PATHS) == build_score_args(DEFAULT_SCORING_PARAMS, PATHS)
+
+
+def test_sweep_flags_only_when_sweep_is_on():
+    args = build_score_args({**DEFAULT_SCORING_PARAMS, 'sweep': False}, PATHS)
+    assert '--sweep-thresholds' not in args
+    assert '--sweep-interval' not in args
+    assert '--filter-estimator' not in args
+    assert '--output-sweep' not in args
+
+
+def test_no_tracking_when_tracking_is_off():
+    assert '--no-tracking' not in build_score_args(DEFAULT_SCORING_PARAMS, PATHS)
+    assert '--no-tracking' in build_score_args({**DEFAULT_SCORING_PARAMS, 'tracking': False}, PATHS)
+
+
+def test_labels_only_with_a_labels_file():
+    assert '--labels' not in build_score_args(DEFAULT_SCORING_PARAMS, PATHS)
+    args = build_score_args(DEFAULT_SCORING_PARAMS, {**PATHS, 'labelsFile': '/work/labels.txt'})
+    assert args[args.index('--labels') + 1] == '/work/labels.txt'
+
+
+def test_polygon_match_mode():
+    args = build_score_args({**DEFAULT_SCORING_PARAMS, 'matchMode': 'polygon'}, PATHS)
+    assert args[args.index('--match-mode') + 1] == 'polygon'
+
+
+def test_optional_flags():
+    params = {
+        **DEFAULT_SCORING_PARAMS,
+        'perClass': False,
+        'topClass': True,
+        'auxConfidence': True,
+        'defaultLabel': 'fish',
+    }
+    args = build_score_args(params, PATHS)
+    assert '--per-class' not in args
+    assert '--top-class' in args
+    assert '--aux-confidence' in args
+    assert args[args.index('--defaultlabel') + 1] == 'fish'
+
+
+def test_matches_output_omitted_without_a_path():
+    paths = {key: value for key, value in PATHS.items() if key != 'matchesOut'}
+    assert '--output-matches' not in build_score_args(DEFAULT_SCORING_PARAMS, paths)
+
+
+def test_pair_inputs_share_a_basename_across_the_two_folders(tmp_path: Path, monkeypatch):
+    downloads = []
+
+    def fake_download(gc, dataset_id, path, revision=None, set=None):
+        downloads.append((dataset_id, Path(path), revision, set))
+        Path(path).write_text('', encoding='utf-8')
+
+    monkeypatch.setattr(utils, 'download_annotation_csv', fake_download)
+    pairs = [
+        {'computed': {'datasetId': 'a', 'set': 'detector'}, 'truth': {'datasetId': 'a'}},
+        {'computed': {'datasetId': 'b', 'revision': 3}, 'truth': {'datasetId': 'c', 'set': 'gt'}},
+    ]
+
+    computed_dir, truth_dir = download_pair_inputs(object(), pairs, tmp_path)
+
+    assert computed_dir == tmp_path / 'computed'
+    assert truth_dir == tmp_path / 'truth'
+    assert downloads == [
+        ('a', computed_dir / 'seq_000.csv', None, 'detector'),
+        ('a', truth_dir / 'seq_000.csv', None, None),
+        ('b', computed_dir / 'seq_001.csv', 3, None),
+        ('c', truth_dir / 'seq_001.csv', None, 'gt'),
+    ]
+    assert sorted(p.name for p in computed_dir.iterdir()) == ['seq_000.csv', 'seq_001.csv']
+    assert sorted(p.name for p in truth_dir.iterdir()) == ['seq_000.csv', 'seq_001.csv']
+
+
+def test_input_ext_matches_the_downloaded_files():
+    assert build_score_args({}, PATHS)[5] == run_scoring.INPUT_EXT == '.csv'
+
+
+def test_headline_metrics_keeps_finite_numbers_only():
+    raw = {
+        'precision': 0.75,
+        'recall': None,
+        'f1_score': float('nan'),
+        'mota': True,
+        'true_positives': 12,
+        'per_class': {'fish': {'precision': 1.0}},
+    }
+    assert headline_metrics(raw) == {
+        'precision': 0.75,
+        'recall': None,
+        'f1_score': None,
+        'mota': None,
+        'true_positives': 12,
+    }
+
+
+def test_result_summary_drops_payloads():
+    pairs = [
+        {'computed': {'datasetId': 'a', 'set': 'detector'}, 'truth': {'datasetId': 'b'}},
+        {'computed': {'datasetId': 'c'}, 'truth': {'datasetId': 'c', 'set': 'gt'}},
+    ]
+    result = {
+        'version': 1,
+        'id': '',
+        'datasetId': 'a',
+        'created': '2026-09-06T12:00:00+00:00',
+        'title': 'a vs b (+1 more)',
+        'pairs': pairs,
+        'params': DEFAULT_SCORING_PARAMS,
+        'metrics': {'precision': 0.5, 'pr_curve': {'points': []}},
+        'matches': {'columns': [], 'frame_names': [], 'rows': []},
+        'summaryText': '--- Detection Metrics ---',
+    }
+    assert result_summary(result) == {
+        'created': '2026-09-06T12:00:00+00:00',
+        'title': 'a vs b (+1 more)',
+        'datasetId': 'a',
+        'pairs': pairs,
+        'params': DEFAULT_SCORING_PARAMS,
+        'headline': {'precision': 0.5},
+    }
diff --git a/server/tests/test_update_metadata.py b/server/tests/test_update_metadata.py
index d7b27050a..df510804d 100644
--- a/server/tests/test_update_metadata.py
+++ b/server/tests/test_update_metadata.py
@@ -323,6 +323,15 @@ def test_metadata_mutable_does_not_classify_unrelated_json_as_config():
     assert models.MetadataMutable.is_dive_configuration({'tracks': {}, 'groups': {}}) is False
 
 
+def test_metadata_mutable_does_not_classify_dive_annotation_json_as_config():
+    assert (
+        models.MetadataMutable.is_dive_configuration(
+            {'version': 2, 'fps': 5, 'tracks': {'0': {}}, 'groups': {}}
+        )
+        is False
+    )
+
+
 @pytest.mark.parametrize(
     'media_type',
     [