diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index 57ba46287..0ad0d0bb9 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -9,7 +9,7 @@ import { CustomStyle } from 'vue-media-annotator/StyleManager';
 import { AttributeTrackFilter } from 'vue-media-annotator/AttributeTrackFilterControls';
 import { ImageEnhancements } from 'vue-media-annotator/use/useImageEnhancements';
 import type {
-  CameraHomographies, CameraCorrespondences, CameraTransformTypes, RegistrationSource,
+  CameraHomographies, CameraObservations, CameraTransformTypes, RegistrationSource,
 } from 'vue-media-annotator/alignedView/CameraRegistrationStore';
 import type { PercentileStretch } from 'vue-media-annotator/use/useImageEnhancements';
 
@@ -82,6 +82,15 @@ interface PipeMetadata {
 
 interface PipelineRuntimeParams {
   frameRange?: [number, number] | null;
+  /**
+   * Multicam registration subset: camera name -> ordered image identifiers
+   * for exactly the frames the job should process. Row i of one camera's
+   * list pairs with row i of every other's. Identifiers are the camera's
+   * own image names (the platform backend resolves them to real paths) or
+   * `frame://N` pseudo-names for video cameras (the backend extracts those
+   * frames to temp images before the job).
+   */
+  imagePairs?: Record<string, string[]>;
 }
 
 interface PipelineParams {
@@ -266,7 +275,12 @@ interface DatasetConfigMutable {
   attributeTrackFilters?: Readonly<Record<string, AttributeTrackFilter>>;
   datasetInfo?: DatasetInfoFields;
   cameraHomographies?: CameraHomographies;
-  cameraCorrespondences?: CameraCorrespondences;
+  /**
+   * Per-image-pair correspondence observations, keyed by directional
+   * "left::right". Each entry lists the observations (image-pair identity,
+   * enabled flag, producer source, stats, and points) behind that pair's fit.
+   */
+  cameraCorrespondences?: CameraObservations;
   cameraTransformTypes?: CameraTransformTypes;
   /** Producer provenance of the camera registration (see RegistrationSource). */
   cameraRegistrationSource?: RegistrationSource | null;
@@ -698,4 +712,4 @@ export type {
   MediaImportResponse,
 };
 
-export type { PercentileStretch, CameraCorrespondences };
+export type { PercentileStretch, CameraObservations };
diff --git a/client/dive-common/autoRegisterSelection.spec.ts b/client/dive-common/autoRegisterSelection.spec.ts
new file mode 100644
index 000000000..d2f532e50
--- /dev/null
+++ b/client/dive-common/autoRegisterSelection.spec.ts
@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+
+import proposeRegistrationFrames from './autoRegisterSelection';
+
+describe('proposeRegistrationFrames', () => {
+  it('spreads candidates across every temporal bin (no single-scene bias)', () => {
+    const frames = proposeRegistrationFrames({
+      counts: [1200, 1200],
+      bins: 12,
+      perBin: 2,
+    });
+    expect(frames.length).toBe(24);
+    // Every 100-frame bin contributes exactly its share: a scene-rich
+    // stretch can never supply all the candidates.
+    for (let bin = 0; bin < 12; bin += 1) {
+      const inBin = frames.filter((f) => f >= bin * 100 && f < (bin + 1) * 100);
+      expect(inBin.length).toBe(2);
+    }
+    expect(frames).toEqual([...frames].sort((a, b) => a - b));
+  });
+
+  it('spans only the shortest camera', () => {
+    const frames = proposeRegistrationFrames({
+      counts: [1000, 300],
+      bins: 10,
+      perBin: 1,
+    });
+    expect(Math.max(...frames)).toBeLessThan(300);
+    expect(frames.length).toBe(10);
+  });
+
+  it('ranks within a bin by inter-camera timestamp skew', () => {
+    // Two cameras, 10 frames, one bin: frame 6 is perfectly synced, frame 3
+    // is close, everything else is badly skewed.
+    const base = 1_700_000_000;
+    const camA = Array.from({ length: 10 }, (_, i) => base + i);
+    const camB = camA.map((t, i) => {
+      if (i === 6) return t;
+      if (i === 3) return t + 0.1;
+      return t + 5;
+    });
+    const frames = proposeRegistrationFrames({
+      counts: [10, 10],
+      timestamps: [camA, camB],
+      bins: 1,
+      perBin: 2,
+      maxSkewSeconds: 0.5,
+    });
+    expect(frames).toEqual([3, 6]);
+  });
+
+  it('drops candidates whose skew exceeds the threshold entirely', () => {
+    const base = 1_700_000_000;
+    const camA = Array.from({ length: 4 }, (_, i) => base + i);
+    const camB = camA.map((t) => t + 10); // hopeless sync everywhere
+    const frames = proposeRegistrationFrames({
+      counts: [4, 4],
+      timestamps: [camA, camB],
+      bins: 1,
+      perBin: 2,
+      maxSkewSeconds: 0.5,
+    });
+    expect(frames).toEqual([]);
+  });
+
+  it('falls back to even spread for frames without timestamps', () => {
+    const frames = proposeRegistrationFrames({
+      counts: [100, 100],
+      timestamps: [
+        Array.from({ length: 100 }, () => undefined),
+        Array.from({ length: 100 }, () => undefined),
+      ],
+      bins: 2,
+      perBin: 2,
+    });
+    expect(frames.length).toBe(4);
+    expect(frames.filter((f) => f < 50).length).toBe(2);
+    expect(frames.filter((f) => f >= 50).length).toBe(2);
+  });
+
+  it('handles degenerate inputs', () => {
+    expect(proposeRegistrationFrames({ counts: [0, 10], bins: 5, perBin: 2 })).toEqual([]);
+    expect(proposeRegistrationFrames({ counts: [], bins: 5, perBin: 2 })).toEqual([]);
+    // More bins than frames: every frame proposed once.
+    const tiny = proposeRegistrationFrames({ counts: [3, 3], bins: 12, perBin: 2 });
+    expect(tiny).toEqual([0, 1, 2]);
+  });
+});
diff --git a/client/dive-common/autoRegisterSelection.ts b/client/dive-common/autoRegisterSelection.ts
new file mode 100644
index 000000000..1d93124d7
--- /dev/null
+++ b/client/dive-common/autoRegisterSelection.ts
@@ -0,0 +1,108 @@
+/**
+ * Candidate-frame proposal for the auto-register pipeline (stage 0 of the
+ * selection contract): DIVE picks for diversity and synchronization, VIAME
+ * picks for image quality.
+ *
+ * Stratified, not "evenly spread" and not "most featureful": the flight is
+ * divided into `bins` equal time bins and `perBin` candidates are proposed
+ * within each, so temporal spread is guaranteed structurally -- a single
+ * scene-rich stretch can never supply every frame, which would reconstitute
+ * exactly the single-scene bias the multi-pair restructure exists to remove.
+ * The pipeline then keeps the best candidate per bin by image quality
+ * (`max_frames` is the bin count), so oversampling here is deliberate.
+ *
+ * Within a bin, candidates rank by inter-camera timestamp skew when every
+ * camera carries per-frame timestamps: on a survey aircraft at ~100 kt,
+ * 100 ms of desync is ~5 m of ground motion baked straight into the "ground
+ * truth" points, and RANSAC cannot reject it because it is consistent
+ * within the frame. Without timestamps (positional alignment), candidates
+ * spread evenly within the bin and skew is unknowable -- no threshold
+ * applies.
+ */
+
+export interface ProposalOptions {
+  /** Per-camera usable frame counts; the proposal spans [0, min(counts)). */
+  counts: number[];
+  /**
+   * Optional per-camera per-frame capture timestamps (epoch seconds;
+   * undefined entries = unknown). Skew ranking applies only when every
+   * camera has a timestamp for the frame under consideration.
+   */
+  timestamps?: (number | undefined)[][];
+  /** Number of temporal bins (the pipeline's max_frames budget). */
+  bins: number;
+  /** Candidates proposed per bin. */
+  perBin: number;
+  /** Candidates with a larger inter-camera skew (seconds) are dropped. */
+  maxSkewSeconds?: number;
+}
+
+/** Largest pairwise timestamp difference across cameras, or null if unknowable. */
+function frameSkew(
+  timestamps: (number | undefined)[][],
+  frame: number,
+): number | null {
+  const stamps: number[] = [];
+  for (let cam = 0; cam < timestamps.length; cam += 1) {
+    const t = timestamps[cam]?.[frame];
+    if (t === undefined) {
+      return null;
+    }
+    stamps.push(t);
+  }
+  return Math.max(...stamps) - Math.min(...stamps);
+}
+
+/**
+ * Propose candidate frame indices, sorted ascending. Returns at most
+ * `bins * perBin` frames; short datasets simply yield fewer.
+ */
+export default function proposeRegistrationFrames(options: ProposalOptions): number[] {
+  const usable = Math.min(...options.counts);
+  if (!Number.isFinite(usable) || usable <= 0 || options.bins <= 0 || options.perBin <= 0) {
+    return [];
+  }
+  const bins = Math.min(options.bins, usable);
+  const { timestamps } = options;
+  const maxSkew = options.maxSkewSeconds ?? 0.5;
+  const chosen = new Set<number>();
+  for (let bin = 0; bin < bins; bin += 1) {
+    const start = Math.floor((bin * usable) / bins);
+    const end = Math.floor(((bin + 1) * usable) / bins); // exclusive
+    // bins <= usable, so every bin spans at least one frame.
+    const size = end - start;
+    const perBin = Math.min(options.perBin, size);
+    if (timestamps && timestamps.length) {
+      // Rank the whole bin by skew; unknowable-skew frames rank after
+      // measured ones (evenly spread among themselves), over-threshold
+      // frames are dropped outright.
+      const measured: { frame: number; skew: number }[] = [];
+      const unknowable: number[] = [];
+      for (let frame = start; frame < end; frame += 1) {
+        const skew = frameSkew(timestamps, frame);
+        if (skew === null) {
+          unknowable.push(frame);
+        } else if (skew <= maxSkew) {
+          measured.push({ frame, skew });
+        }
+      }
+      measured.sort((a, b) => a.skew - b.skew || a.frame - b.frame);
+      measured.slice(0, perBin).forEach(({ frame }) => chosen.add(frame));
+      let still = perBin - Math.min(measured.length, perBin);
+      if (still > 0 && unknowable.length) {
+        const step = unknowable.length / still;
+        for (let i = 0; i < still; i += 1) {
+          chosen.add(unknowable[Math.floor(i * step)]);
+        }
+        still = 0;
+      }
+    } else {
+      // No timeline: spread evenly within the bin.
+      const step = size / perBin;
+      for (let i = 0; i < perBin; i += 1) {
+        chosen.add(start + Math.floor(i * step + step / 2));
+      }
+    }
+  }
+  return [...chosen].sort((a, b) => a - b);
+}
diff --git a/client/dive-common/components/CameraRegistration/AutoRegisterDialog.vue b/client/dive-common/components/CameraRegistration/AutoRegisterDialog.vue
new file mode 100644
index 000000000..47f141e01
--- /dev/null
+++ b/client/dive-common/components/CameraRegistration/AutoRegisterDialog.vue
@@ -0,0 +1,203 @@
+<script lang="ts">
+import {
+  computed, defineComponent, ref,
+} from 'vue';
+import type { AutoRegisterRunOptions } from 'dive-common/use/useAutoRegisterJob';
+
+/**
+ * Launch dialog for the auto-register pipeline: only the knobs worth
+ * changing. The candidate spread itself is proposed automatically
+ * (stratified time bins, ranked by camera sync where timestamps exist) and
+ * reviewed after the matching -- the matcher is the best measurement of
+ * whether a frame has usable dense features, and excluding a frame
+ * afterwards is a free client-side refit.
+ */
+export default defineComponent({
+  name: 'AutoRegisterDialog',
+  props: {
+    value: {
+      type: Boolean,
+      default: false,
+    },
+    cameraCount: {
+      type: Number,
+      required: true,
+    },
+    running: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  setup(props, { emit }) {
+    const maxFrames = ref(12);
+    const candidatesPerBin = ref(2);
+    const minInliers = ref(30);
+    const pairMode = ref<'all' | 'star'>('all');
+    const replaceExisting = ref(false);
+
+    const isTriplet = computed(() => props.cameraCount >= 3);
+    const candidateTotal = computed(() => maxFrames.value * candidatesPerBin.value);
+    const matcherRuns = computed(() => {
+      let pairCount = 1;
+      if (isTriplet.value) {
+        pairCount = pairMode.value === 'all' ? 3 : 2;
+      }
+      return maxFrames.value * pairCount;
+    });
+
+    function close() {
+      emit('input', false);
+    }
+    function run() {
+      const options: AutoRegisterRunOptions = {
+        maxFrames: maxFrames.value,
+        candidatesPerBin: candidatesPerBin.value,
+        minInliers: minInliers.value,
+        replaceExisting: replaceExisting.value,
+        // A star to the reference (inputs 1-2, 1-3) is the minimum a
+        // spanning tree needs; all-pairs additionally buys the
+        // loop-closure consistency check.
+        ...(isTriplet.value && pairMode.value === 'star' ? { pairs: '1-2,1-3' } : {}),
+      };
+      emit('run', options);
+      close();
+    }
+    return {
+      maxFrames,
+      candidatesPerBin,
+      minInliers,
+      pairMode,
+      replaceExisting,
+      isTriplet,
+      candidateTotal,
+      matcherRuns,
+      close,
+      run,
+    };
+  },
+});
+</script>
+
+<template>
+  <v-dialog
+    :value="value"
+    max-width="420"
+    @input="$emit('input', $event)"
+  >
+    <v-card>
+      <v-card-title>Auto Register Frames</v-card-title>
+      <v-card-text>
+        <p class="text-body-2">
+          Proposes {{ candidateTotal }} candidate frames spread across the
+          whole {{ isTriplet ? 'rig' : 'sequence' }} (ranked by camera sync
+          where timestamps exist), matches the best one per time bin, and
+          pools one transform per camera pair over every kept frame. Results
+          merge with existing points frame by frame; review and exclude
+          frames afterwards from the panel's frame list.
+        </p>
+        <v-text-field
+          v-model.number="maxFrames"
+          label="Registration frames (time bins)"
+          type="number"
+          min="1"
+          max="50"
+          dense
+          outlined
+          persistent-hint
+          hint="10-20 is usually right: the pooled fit converges by about 10
+                frames, and beyond that extra frames mainly tighten triplet
+                consistency. Cost is roughly linear in frames."
+          class="mb-3"
+        />
+        <v-alert
+          v-if="maxFrames < 5"
+          dense
+          outlined
+          type="warning"
+          class="text-caption py-1 mb-3"
+        >
+          Very few frames overfit. One frame fits its own points perfectly --
+          100% inliers, near-zero RMS -- while producing the least consistent
+          rig of any setting, so the quality readouts will look their best
+          exactly when they are least trustworthy.
+        </v-alert>
+        <v-text-field
+          v-model.number="candidatesPerBin"
+          label="Candidates per bin"
+          type="number"
+          min="1"
+          max="5"
+          dense
+          outlined
+          hide-details
+          class="mb-3"
+        />
+        <v-text-field
+          v-model.number="minInliers"
+          label="Min inliers per frame"
+          type="number"
+          min="4"
+          max="500"
+          dense
+          outlined
+          hide-details
+          class="mb-3"
+        />
+        <v-radio-group
+          v-if="isTriplet"
+          v-model="pairMode"
+          dense
+          hide-details
+          class="mt-0 mb-3"
+        >
+          <template #label>
+            <span class="text-caption">
+              Camera pairs ({{ matcherRuns }} matcher runs)
+            </span>
+          </template>
+          <v-radio
+            value="all"
+            label="All pairs (adds the triplet consistency check)"
+          />
+          <v-radio
+            value="star"
+            label="Star to the reference camera (faster; minimum spanning set)"
+          />
+        </v-radio-group>
+        <v-checkbox
+          v-model="replaceExisting"
+          label="Replace previous auto-registered frames"
+          dense
+          hide-details
+          class="mt-0"
+        />
+        <span class="text-caption grey--text d-block mt-1">
+          Hand-picked points always survive; this only clears earlier
+          matcher results before the new run.
+        </span>
+      </v-card-text>
+      <v-card-actions>
+        <v-spacer />
+        <v-btn
+          text
+          @click="close"
+        >
+          Cancel
+        </v-btn>
+        <v-btn
+          color="primary"
+          :disabled="running"
+          @click="run"
+        >
+          <v-icon
+            small
+            left
+          >
+            mdi-auto-fix
+          </v-icon>
+          Run
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
diff --git a/client/dive-common/components/CameraRegistration/RegistrationFrameList.vue b/client/dive-common/components/CameraRegistration/RegistrationFrameList.vue
new file mode 100644
index 000000000..12fc7d582
--- /dev/null
+++ b/client/dive-common/components/CameraRegistration/RegistrationFrameList.vue
@@ -0,0 +1,191 @@
+<script lang="ts">
+import { defineComponent, PropType } from 'vue';
+import TooltipBtn from 'vue-media-annotator/components/TooltipButton.vue';
+
+/**
+ * One row of the registration-frames list: an observation (image pair) of
+ * the active camera pair, with its fit-inclusion toggle and quality readout.
+ */
+export interface FrameRow {
+  /** The pair's camA-local frame: the identity every panel action works in. */
+  frame: number | null;
+  /**
+   * The same capture as a global aligned-timeline slot -- what the frame
+   * readout and scrubber display. Shown instead of `frame` so the panel agrees
+   * with the rest of the viewer; they differ by however many frames camA has
+   * dropped. Falls back to `frame` when there is no aligned timeline.
+   */
+  displayFrame: number | null;
+  imageA: string;
+  imageB: string;
+  enabled: boolean;
+  source: string;
+  count: number;
+  /** Reprojection RMS of this observation's points against the pooled fit. */
+  rmsPx: number | null;
+  /** Machine-readable reason a producer rejected this candidate, if any. */
+  skipped: string | null;
+  /** Whether the viewer currently displays this image pair. */
+  current: boolean;
+}
+
+/**
+ * The registration-frames list (multi-image-pair selector AND quality
+ * readout) for the active camera pair: one row per observation with its
+ * point count, per-frame agreement with the pooled fit (colored dot + RMS),
+ * an enable checkbox that excludes the frame from the fit without deleting
+ * its points, jump-to-frame, and per-frame delete. Unresolved rows (images
+ * not in this dataset) are listed with a warning instead of a frame number.
+ */
+export default defineComponent({
+  name: 'RegistrationFrameList',
+  components: { TooltipBtn },
+  props: {
+    rows: {
+      type: Array as PropType<FrameRow[]>,
+      required: true,
+    },
+  },
+  setup(props, { emit }) {
+    /**
+     * Agreement dot: green when the observation tracks the pooled fit,
+     * yellow when it strains it, red when it disagrees, grey with no fit
+     * (or no points to measure).
+     */
+    function rmsColor(row: FrameRow): string {
+      if (row.rmsPx === null) {
+        return 'grey';
+      }
+      if (row.rmsPx < 3) {
+        return 'success';
+      }
+      if (row.rmsPx < 6) {
+        return 'warning';
+      }
+      return 'error';
+    }
+    function toggle(row: FrameRow, enabled: unknown) {
+      emit('toggle', row, Boolean(enabled));
+    }
+    function jump(row: FrameRow) {
+      if (row.frame !== null) {
+        emit('jump', row.frame);
+      }
+    }
+    function remove(row: FrameRow) {
+      emit('remove', row);
+    }
+    return {
+      rmsColor, toggle, jump, remove,
+    };
+  },
+});
+</script>
+
+<template>
+  <div>
+    <div
+      v-for="row in rows"
+      :key="`${row.imageA}::${row.imageB}::${row.source}`"
+      class="d-flex align-center text-caption frame-row"
+      :class="{ 'frame-row--current': row.current }"
+    >
+      <v-simple-checkbox
+        :value="row.enabled"
+        :disabled="row.count === 0"
+        :ripple="false"
+        dense
+        class="mr-0"
+        @input="toggle(row, $event)"
+      />
+      <span
+        v-if="row.displayFrame !== null"
+        class="frame-label"
+      >
+        {{ row.displayFrame }}
+      </span>
+      <v-tooltip
+        v-else
+        bottom
+        open-delay="200"
+      >
+        <template #activator="{ on }">
+          <span
+            class="frame-label warning--text"
+            v-on="on"
+          >
+            <v-icon
+              x-small
+              color="warning"
+            >
+              mdi-alert
+            </v-icon>
+          </span>
+        </template>
+        <span>
+          Images not in this dataset ({{ row.imageA }} / {{ row.imageB }}) —
+          these points don't render here but stay in the file.
+        </span>
+      </v-tooltip>
+      <span class="mx-1">{{ row.count }} pts</span>
+      <template v-if="row.skipped">
+        <v-tooltip
+          bottom
+          open-delay="200"
+        >
+          <template #activator="{ on }">
+            <span
+              class="grey--text mx-1"
+              v-on="on"
+            >
+              skipped: {{ row.skipped }}
+            </span>
+          </template>
+          <span>The auto-register job rejected this candidate ({{ row.skipped }}).</span>
+        </v-tooltip>
+      </template>
+      <template v-else>
+        <span
+          class="mx-1"
+          :class="`${rmsColor(row)}--text`"
+        >
+          {{ row.rmsPx !== null ? `rms ${row.rmsPx.toFixed(1)} px` : '—' }}
+        </span>
+        <v-icon
+          x-small
+          :color="rmsColor(row)"
+        >
+          mdi-circle
+        </v-icon>
+      </template>
+      <v-spacer />
+      <tooltip-btn
+        icon="mdi-target"
+        :disabled="row.frame === null"
+        tooltip-text="Jump to this frame"
+        @click="jump(row)"
+      />
+      <tooltip-btn
+        color="error"
+        icon="mdi-close"
+        tooltip-text="Remove this frame's points from the registration"
+        @click="remove(row)"
+      />
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.frame-row {
+  min-height: 26px;
+}
+.frame-row--current {
+  background-color: rgba(255, 255, 255, 0.08);
+  border-radius: 2px;
+}
+.frame-label {
+  font-family: monospace;
+  min-width: 42px;
+  display: inline-block;
+}
+</style>
diff --git a/client/dive-common/components/CameraRegistration/RegistrationTools.vue b/client/dive-common/components/CameraRegistration/RegistrationTools.vue
index 23481ccf7..a1771a1e1 100644
--- a/client/dive-common/components/CameraRegistration/RegistrationTools.vue
+++ b/client/dive-common/components/CameraRegistration/RegistrationTools.vue
@@ -13,14 +13,30 @@ import {
 } from 'vue-media-annotator/alignedView/transform';
 import { unresolvedCameras } from 'vue-media-annotator/alignedView/alignedView';
 import { buildPerCameraRegistrationFiles } from 'vue-media-annotator/alignedView/cameraRegistrationFiles';
+import { MANUAL_SOURCE } from 'vue-media-annotator/alignedView/CameraRegistrationStore';
 import TooltipBtn from 'vue-media-annotator/components/TooltipButton.vue';
+import { injectAggregateController } from 'vue-media-annotator/components/annotators/useMediaController';
 import { useApi } from 'dive-common/apispec';
 import { usePrompt } from 'dive-common/vue-utilities/prompt-service';
+import { AutoRegisterRunOptions, useAutoRegisterJob } from 'dive-common/use/useAutoRegisterJob';
+import { loopClosureResidual, Matrix3 } from 'vue-media-annotator/alignedView/homography';
+
+import RegistrationFrameList, { FrameRow } from './RegistrationFrameList.vue';
+import AutoRegisterDialog from './AutoRegisterDialog.vue';
+/**
+ * A solved triplet is "consistent" when the direct and routed transforms
+ * agree to within this fraction of the last camera's width. 0.001 keeps the
+ * behaviour the old fixed 5px threshold happened to have on a ~5000px-wide
+ * camera, while meaning the same thing on rigs whose cameras are far larger
+ * or smaller. Measured on a KAMERA calibration flight: a converged 10-100
+ * frame fit sits near 0.05%, a single-frame (overfit) rig at 0.15%.
+ */
+const LOOP_CLOSURE_MAX_FRACTION = 0.001;
 
 export default defineComponent({
   name: 'CameraRegistration',
   description: 'Camera Registration',
-  components: { TooltipBtn },
+  components: { AutoRegisterDialog, TooltipBtn, RegistrationFrameList },
   setup() {
     const cameraStore = useCameraStore();
     const registration = useCameraRegistration();
@@ -28,8 +44,18 @@ export default defineComponent({
     const alignedView = useAlignedView();
     const { saveConfig } = useApi();
     const { prompt } = usePrompt();
+    const aggregateController = injectAggregateController();
 
-    const cameras = computed(() => [...cameraStore.camMap.value.keys()]);
+    /**
+     * The rig in persisted display order. Not camMap's key order: that is
+     * insertion order from an awaited per-camera load loop and can carry
+     * entries across a dataset switch, and both the reference camera below
+     * and the direction of the loop-closure residual depend on which camera
+     * is first and last.
+     */
+    // orderedCameraNames reads camMap and displayOrder, so the computed picks
+    // up both as dependencies without touching them explicitly.
+    const cameras = computed(() => cameraStore.orderedCameraNames());
     /**
      * Per-camera alignment status for the whole rig, driving the status block:
      * the first camera (display order) is the reference (identity); every other
@@ -64,7 +90,7 @@ export default defineComponent({
       return {
         icon: complete ? 'mdi-check-circle' : 'mdi-alert',
         color: complete ? 'success' : 'warning',
-        text: `${total - unresolvedCount}/${total} cameras registered`,
+        text: `${total - unresolvedCount}/${total} cameras ready`,
       };
     });
     const camLeft = ref<string | null>(null);
@@ -79,7 +105,7 @@ export default defineComponent({
     /**
      * Author-vs-review posture: picking defaults on for a pair that still
      * needs points, and off for one whose transform came from a registration
-     * file (review it; the "Pick points" toggle opts back in to refine).
+     * file (review it; the "Edit points" toggle opts back in to refine).
      * Re-applied whenever the active pair changes identity, so it overrides a
      * manual toggle on pair switch -- each pair opens in its own posture.
      */
@@ -137,8 +163,238 @@ export default defineComponent({
     const activeKey = computed(() => registration.activePairKey());
     const correspondences = computed(() => {
       const key = activeKey.value;
-      return key ? (registration.correspondences.value[key] || []) : [];
+      // Pooled across every enabled observation -- the fit input.
+      return key ? registration.enabledPoints(key) : [];
+    });
+    /** Pooled fit quality: per-frame agreement with the pair's consensus. */
+    const pairStats = computed(() => (
+      activeKey.value ? registration.pairFitStats(activeKey.value) : null));
+    /** The camA-space frame the viewer currently displays for this pair. */
+    const currentPairFrame = computed(() => {
+      // Touch currentFrame so scrubbing recomputes the readouts.
+      // eslint-disable-next-line no-void
+      void registration.currentFrame.value;
+      const key = activeKey.value;
+      return key !== null ? registration.currentFrameForPair(key) : null;
+    });
+    /**
+     * The registration-frames list: the multi-image-pair selector AND the
+     * quality readout, one row per observation with its agreement dot.
+     */
+    const frameRows = computed<FrameRow[]>(() => {
+      const key = activeKey.value;
+      if (!key) {
+        return [];
+      }
+      const stats = registration.pairFitStats(key);
+      const rmsByIdentity = new Map(stats.perObservation.map((obs) => [
+        `${obs.imageA}::${obs.imageB}`, obs.rmsPx,
+      ]));
+      // camA-local drives every action in this panel, but the number shown must
+      // match the frame readout / scrubber, which count global slots.
+      const [camA] = key.split('::');
+      const toSlot = (frame: number | null) => (
+        frame === null ? null : aggregateController.value.cameraFrameToSlot(camA, frame) ?? frame
+      );
+      return registration.framesForPair(key).map((row) => ({
+        frame: row.frame,
+        displayFrame: toSlot(row.frame),
+        imageA: row.imageA,
+        imageB: row.imageB,
+        enabled: row.enabled,
+        source: row.source,
+        count: row.count,
+        rmsPx: rmsByIdentity.get(`${row.imageA}::${row.imageB}`) ?? null,
+        skipped: (row.stats && typeof row.stats.skipped === 'string')
+          ? row.stats.skipped as string : null,
+        current: row.frame !== null && row.frame === currentPairFrame.value,
+      }));
+    });
+    /**
+     * Skipped rows are candidates a producer rejected -- overwhelmingly
+     * "pruned", the oversampling remainder from proposing candidatesPerBin per
+     * bin and keeping the best. They carry no points and support no action, so
+     * they are counted, not listed.
+     */
+    const skippedCount = computed(() => frameRows.value.filter((row) => row.skipped).length);
+    const listedRows = computed(() => frameRows.value.filter((row) => !row.skipped));
+    const autoRows = computed(() => listedRows.value.filter((row) => row.source !== MANUAL_SOURCE));
+    const manualRows = computed(
+      () => listedRows.value.filter((row) => row.source === MANUAL_SOURCE),
+    );
+    /** Enabled count + mean agreement with the pooled fit, for a section header. */
+    function sectionSummary(rows: FrameRow[]) {
+      const enabled = rows.filter((row) => row.enabled);
+      const measured = enabled
+        .map((row) => row.rmsPx)
+        .filter((rms): rms is number => rms !== null);
+      return {
+        total: rows.length,
+        enabled: enabled.length,
+        rmsPx: measured.length
+          ? measured.reduce((sum, rms) => sum + rms, 0) / measured.length
+          : null,
+      };
+    }
+    const autoSummary = computed(() => sectionSummary(autoRows.value));
+    const manualSummary = computed(() => sectionSummary(manualRows.value));
+
+    /**
+     * Captures queued for the next matcher run, as global aligned-timeline
+     * slots (what the frame readout shows). The user picks the captures, so
+     * the run matches exactly these rather than proposing a spread.
+     */
+    const queuedSlots = ref<number[]>([]);
+    const currentSlot = computed(() => {
+      const pair = registration.activePair.value;
+      const frame = currentPairFrame.value;
+      if (!pair || frame === null) {
+        return null;
+      }
+      return aggregateController.value.cameraFrameToSlot(pair.camA, frame) ?? frame;
     });
+    const currentQueued = computed(() => (
+      currentSlot.value !== null && queuedSlots.value.includes(currentSlot.value)
+    ));
+    function queueCurrentFrame() {
+      const slot = currentSlot.value;
+      if (slot !== null && !queuedSlots.value.includes(slot)) {
+        queuedSlots.value = [...queuedSlots.value, slot].sort((a, b) => a - b);
+      }
+    }
+    function unqueueSlot(slot: number) {
+      queuedSlots.value = queuedSlots.value.filter((queued) => queued !== slot);
+    }
+    /**
+     * Every observation of a section, INCLUDING the skipped ones the list
+     * hides: they are still stored and still travel into the saved
+     * registration file, so a "clear all" that left them behind would leave
+     * invisible cruft the user has no way to see or remove.
+     */
+    const autoAll = computed(
+      () => frameRows.value.filter((row) => row.source !== MANUAL_SOURCE),
+    );
+    const manualAll = computed(
+      () => frameRows.value.filter((row) => row.source === MANUAL_SOURCE),
+    );
+    async function clearRows(rows: FrameRow[], label: string) {
+      const key = activeKey.value;
+      if (!key || !rows.length) {
+        return;
+      }
+      const doomed = [...rows];
+      const points = doomed.reduce((sum, row) => sum + row.count, 0);
+      const hidden = doomed.filter((row) => row.skipped).length;
+      const confirmed = await prompt({
+        title: `Clear ${label} Frames`,
+        text: `Remove all ${doomed.length} ${label.toLowerCase()} frame(s)`
+          + `${hidden ? ` (${hidden} hidden as rejected candidates)` : ''}`
+          + ` and their ${points} point pair(s) from this pair's registration?`,
+        positiveButton: 'Remove all',
+        negativeButton: 'Cancel',
+        confirm: true,
+      });
+      if (!confirmed) {
+        return;
+      }
+      doomed.forEach(
+        (row) => registration.removeObservation(key, row.imageA, row.imageB, row.source),
+      );
+    }
+    const clearAuto = () => clearRows(autoAll.value, 'Auto');
+    const clearManual = () => clearRows(manualAll.value, 'Manual');
+    function clearQueue() {
+      queuedSlots.value = [];
+    }
+    function runQueuedFrames() {
+      autoRegisterJob?.run({
+        maxFrames: queuedSlots.value.length,
+        candidatesPerBin: 1,
+        slots: [...queuedSlots.value],
+      });
+      queuedSlots.value = [];
+    }
+
+    /** Point pairs picked/matched on the frame currently being viewed. */
+    const frameCorrespondences = computed(() => {
+      const key = activeKey.value;
+      if (!key) {
+        return [];
+      }
+      return registration.correspondencesForFrame(key, currentPairFrame.value);
+    });
+    function toggleFrameRow(row: FrameRow, enabled: boolean) {
+      const key = activeKey.value;
+      if (key) {
+        registration.setObservationEnabled(key, row.imageA, row.imageB, enabled);
+      }
+    }
+    /**
+     * Seek a camA-local frame. markerFrames / currentPairFrame are all in the
+     * active pair's camA space (see CameraRegistrationStore.currentPairFrame),
+     * so every seek out of this panel goes through camA rather than whichever
+     * camera happens to be selected.
+     */
+    function seekPairFrame(frame: number) {
+      const pair = registration.activePair.value;
+      if (!pair) {
+        return;
+      }
+      aggregateController.value.seekCameraFrame(pair.camA, frame);
+    }
+    function jumpToFrame(frame: number) {
+      // Observation frames are camA-local, but handler.seekFrame() interprets
+      // its argument in the SELECTED camera's local space -- wrong whenever
+      // the rig's cameras drop frames independently. Seek camA's own frame
+      // instead; seekCameraFrame translates through the aligned timeline so
+      // every camera lands on the same capture.
+      seekPairFrame(frame);
+    }
+    async function removeFrameRow(row: FrameRow) {
+      const key = activeKey.value;
+      if (!key) {
+        return;
+      }
+      if (row.count > 0) {
+        const confirmed = await prompt({
+          title: 'Remove Registration Frame',
+          text: `Remove the ${row.count} point pair(s) from `
+            + `${row.displayFrame !== null ? `frame ${row.displayFrame}` : 'this frame'}? `
+            + 'To exclude the frame from the fit without deleting its points, '
+            + 'uncheck it instead.',
+          positiveButton: 'Remove',
+          negativeButton: 'Cancel',
+          confirm: true,
+        });
+        if (!confirmed) {
+          return;
+        }
+      }
+      registration.removeObservation(key, row.imageA, row.imageB, row.source);
+    }
+    /** Frames carrying registration points, for prev/next navigation. */
+    const markerFrames = computed(() => frameRows.value
+      .map((row) => row.frame)
+      .filter((frameNum): frameNum is number => frameNum !== null)
+      .sort((a, b) => a - b));
+    function seekPrevMarker() {
+      const current = currentPairFrame.value ?? 0;
+      const prev = [...markerFrames.value].reverse().find((frameNum) => frameNum < current);
+      if (prev !== undefined) {
+        seekPairFrame(prev);
+      }
+    }
+    function seekNextMarker() {
+      const current = currentPairFrame.value ?? 0;
+      const next = markerFrames.value.find((frameNum) => frameNum > current);
+      if (next !== undefined) {
+        seekPairFrame(next);
+      }
+    }
+    /** One-click way to start contributing the current frame: enable picking. */
+    function addCurrentFrame() {
+      registration.pickingEnabled.value = true;
+    }
     const transformType = computed<TransformType>(
       () => (activeKey.value
         ? registration.transformTypeForPair(activeKey.value)
@@ -202,10 +458,14 @@ export default defineComponent({
         };
       }
       if (canFit.value) {
+        const stats = pairStats.value;
+        const frames = stats ? stats.frameCount : 0;
+        const rms = stats && stats.rmsPx !== null ? ` — rms ${stats.rmsPx.toFixed(1)} px` : '';
         return {
           icon: 'mdi-check-circle',
           color: fitQualityColor.value,
-          text: `Transform fit from ${correspondences.value.length} point pairs`,
+          text: `Transform fit from ${frames} frame${frames === 1 ? '' : 's'} / `
+            + `${correspondences.value.length} point pairs${rms}`,
         };
       }
       return {
@@ -323,7 +583,7 @@ export default defineComponent({
       const nextFiles = new Map(buildPerCameraRegistrationFiles(
         {
           homographies: registration.homographies.value,
-          correspondences: registration.correspondences.value,
+          observations: registration.observations.value,
           transformTypes: registration.transformTypes.value,
           source: registration.source.value,
         },
@@ -359,7 +619,7 @@ export default defineComponent({
       try {
         await saveConfig(datasetId.value, {
           cameraHomographies: registration.homographies.value,
-          cameraCorrespondences: registration.correspondences.value,
+          cameraCorrespondences: registration.observations.value,
           cameraTransformTypes: registration.transformTypes.value,
           cameraRegistrationSource: registration.source.value,
         });
@@ -369,6 +629,104 @@ export default defineComponent({
       }
     }
 
+    /**
+     * Auto Register Frames: launch the align_cameras pipeline over a
+     * stratified spread of candidate frames (one job registers the whole
+     * rig; a triplet solves up to three pairs at once). The service is
+     * provided by the viewer; availability tracks whether the align pipes
+     * are installed, which hides the button entirely when they aren't.
+     */
+    const autoRegisterJob = useAutoRegisterJob();
+    const autoRegisterAvailable = computed(() => !!autoRegisterJob?.available.value);
+    const autoRegistering = computed(() => !!autoRegisterJob?.running.value);
+    const autoRegisterError = computed(() => autoRegisterJob?.error.value ?? null);
+    const autoRegisterStatus = computed(() => autoRegisterJob?.status.value ?? null);
+    const autoRegisterDialog = ref(false);
+
+    function openAutoRegisterDialog() {
+      autoRegisterDialog.value = true;
+    }
+    function runAutoRegister(options: AutoRegisterRunOptions) {
+      autoRegisterJob?.run(options);
+    }
+
+    /**
+     * Rig-level consistency readout for a solved triplet: with all three
+     * pairs fitted, compare the direct A->C transform against the A->B->C
+     * route. This is the whole reason to solve the redundant third pair --
+     * three individually plausible fits can still disagree as a rig.
+     *
+     * The residual comes out in the LAST camera's native pixels (the grid is
+     * pushed from camera 1 into camera 3), so both halves of this have to
+     * respect real image sizes:
+     *
+     *  - Sample over camera 1's actual frame. The default nominal 1000x1000
+     *    grid only covers a corner of a 12768x9564 EO frame, so it measured
+     *    agreement over a fraction of the field of view and missed exactly
+     *    the divergence at the edges that matters.
+     *  - Judge the result relative to camera 3's width, not against a fixed
+     *    pixel count. The same rig error reads ~7.6x larger against a
+     *    4864-wide UV camera than a 640-wide IR one, so a fixed threshold
+     *    silently means something different per rig -- and flags a rig
+     *    inconsistent for nothing more than having a large last camera.
+     */
+    /**
+     * A camera's native frame size, or null until its annotator has actually
+     * drawn a frame. originalBounds starts life as a 1x1 placeholder
+     * (useMediaController's reactive state), so "not ready" has to be
+     * detected by an implausibly small box rather than a zero -- a 1x1 box
+     * read as a real size collapses the loop-closure sample grid onto a
+     * single corner pixel and yields a meaningless residual.
+     */
+    function nativeSize(camera: string): [number, number] | null {
+      try {
+        const bounds = aggregateController.value.getController(camera).originalBounds.value;
+        const width = bounds.right - bounds.left;
+        const height = bounds.bottom - bounds.top;
+        return (width > 1 && height > 1) ? [width, height] : null;
+      } catch {
+        return null;
+      }
+    }
+    const loopClosure = computed(() => {
+      const list = cameras.value;
+      if (list.length !== 3) {
+        return null;
+      }
+      const directed = (a: string, b: string): Matrix3 | null => {
+        const forward = registration.homographies.value[registration.pairKey(a, b)];
+        if (forward) {
+          return forward.AtoB;
+        }
+        const reverse = registration.homographies.value[registration.pairKey(b, a)];
+        return reverse ? reverse.BtoA : null;
+      };
+      const h01 = directed(list[0], list[1]);
+      const h12 = directed(list[1], list[2]);
+      const h02 = directed(list[0], list[2]);
+      if (!h01 || !h12 || !h02) {
+        return null;
+      }
+      // Both ends must be measurable: the grid is sampled over the source
+      // camera's frame and the residual judged against the target camera's
+      // width, so a placeholder size on either side makes the ratio
+      // meaningless. Report nothing while the panes are still coming up
+      // rather than a confident-looking wrong verdict.
+      const sourceSize = nativeSize(list[0]);
+      const targetSize = nativeSize(list[2]);
+      if (!sourceSize || !targetSize) {
+        return null;
+      }
+      const residual = loopClosureResidual(h01, h12, h02, sourceSize);
+      const fraction = residual.meanPx / targetSize[0];
+      return {
+        ...residual,
+        fraction,
+        consistent: fraction <= LOOP_CLOSURE_MAX_FRACTION,
+        route: `${list[0]}↔${list[2]} vs ${list[0]}↔${list[1]}↔${list[2]}`,
+      };
+    });
+
     return {
       cameras,
       cameraAlignmentStatuses,
@@ -383,6 +741,33 @@ export default defineComponent({
       deleteSelectedCorrespondence,
       cursorReadout,
       correspondences,
+      pairStats,
+      currentPairFrame,
+      frameRows,
+      frameCorrespondences,
+      markerFrames,
+      toggleFrameRow,
+      jumpToFrame,
+      removeFrameRow,
+      seekPrevMarker,
+      seekNextMarker,
+      addCurrentFrame,
+      skippedCount,
+      autoRows,
+      manualRows,
+      autoSummary,
+      manualSummary,
+      queuedSlots,
+      currentSlot,
+      currentQueued,
+      queueCurrentFrame,
+      unqueueSlot,
+      runQueuedFrames,
+      autoAll,
+      manualAll,
+      clearAuto,
+      clearManual,
+      clearQueue,
       transformType,
       transformTypeItems: TRANSFORM_TYPES,
       minPoints,
@@ -404,6 +789,14 @@ export default defineComponent({
       setTransformType,
       setAlignmentMode,
       save,
+      autoRegisterAvailable,
+      autoRegistering,
+      autoRegisterError,
+      autoRegisterStatus,
+      autoRegisterDialog,
+      openAutoRegisterDialog,
+      runAutoRegister,
+      loopClosure,
     };
   },
 });
@@ -429,14 +822,23 @@ export default defineComponent({
     >
       Source: {{ sourceReadout }}
     </span>
+    <!-- Persistent divergence status (survives save by design); only the
+         action hint tracks the save state so it never asks for a save
+         that's already done. -->
     <span
       v-if="refinedFromSource"
       class="text-caption warning--text d-block"
     >
       This pair has been refined in-app since the source registration was
-      produced. Save, then download the camera's registration from the
-      Export menu to hand the refinement (and its points) back to the
-      producer.
+      produced.
+      <template v-if="dirty">
+        Save, then download the camera's registration from the Export menu
+        to hand the refinement (and its points) back to the producer.
+      </template>
+      <template v-else>
+        Download the camera's registration from the Export menu to hand the
+        refinement (and its points) back to the producer.
+      </template>
     </span>
 
     <div
@@ -480,6 +882,28 @@ export default defineComponent({
           {{ cam.name }}{{ cam.status === 'reference' ? ' · reference' : '' }}
         </v-chip>
       </div>
+      <div
+        v-if="loopClosure"
+        class="d-flex align-center text-caption"
+        :class="loopClosure.consistent ? 'success--text' : 'warning--text'"
+      >
+        <v-icon
+          small
+          :color="loopClosure.consistent ? 'success' : 'warning'"
+          class="mr-1"
+        >
+          {{ loopClosure.consistent ? 'mdi-vector-triangle' : 'mdi-alert' }}
+        </v-icon>
+        <template v-if="loopClosure.consistent">
+          triplet consistent — {{ loopClosure.meanPx.toFixed(1) }} px loop closure
+          ({{ (loopClosure.fraction * 100).toFixed(3) }}% of {{ cameras[2] }} width)
+        </template>
+        <template v-else>
+          {{ loopClosure.meanPx.toFixed(1) }} px loop closure
+          ({{ (loopClosure.fraction * 100).toFixed(3) }}% of {{ cameras[2] }} width)
+          — {{ loopClosure.route }} disagree
+        </template>
+      </div>
     </div>
     <v-divider class="my-3" />
 
@@ -522,6 +946,226 @@ export default defineComponent({
       points is optional: fitting {{ minPoints }} or more pairs replaces it.
     </span>
 
+    <template v-if="camLeft && camRight && camLeft !== camRight">
+      <v-divider class="my-3" />
+      <div class="d-flex align-center">
+        <h4>Registration Frames</h4>
+        <v-spacer />
+        <tooltip-btn
+          icon="mdi-chevron-left"
+          :disabled="!markerFrames.length"
+          tooltip-text="Previous registration frame"
+          @click="seekPrevMarker"
+        />
+        <tooltip-btn
+          icon="mdi-chevron-right"
+          :disabled="!markerFrames.length"
+          tooltip-text="Next registration frame"
+          @click="seekNextMarker"
+        />
+      </div>
+      <span class="text-caption grey--text d-block mb-2">
+        The fit pools points from every checked frame, auto and manual alike.
+        Uncheck a frame to exclude it without deleting its points.
+      </span>
+
+      <!-- Auto: matched frames, and the queue for the next run -->
+      <div class="d-flex align-center section-head">
+        <v-icon
+          x-small
+          class="mr-1"
+        >
+          mdi-auto-fix
+        </v-icon>
+        <span class="font-weight-medium">Auto</span>
+        <span class="text-caption grey--text mx-2">
+          {{ autoSummary.enabled }}/{{ autoSummary.total }} frames
+          <template v-if="autoSummary.rmsPx !== null">
+            · rms {{ autoSummary.rmsPx.toFixed(1) }} px
+          </template>
+        </span>
+        <v-spacer />
+        <tooltip-btn
+          icon="mdi-delete-sweep-outline"
+          color="error"
+          :disabled="!autoAll.length"
+          tooltip-text="Clear all auto-registered frames for this pair"
+          @click="clearAuto"
+        />
+        <tooltip-btn
+          v-if="autoRegisterAvailable"
+          icon="mdi-cog-outline"
+          :disabled="cameras.length < 2 || autoRegistering"
+          tooltip-text="Auto Register: match a spread of frames across the sequence"
+          @click="openAutoRegisterDialog"
+        />
+      </div>
+      <registration-frame-list
+        :rows="autoRows"
+        @toggle="toggleFrameRow"
+        @jump="jumpToFrame"
+        @remove="removeFrameRow"
+      />
+      <div
+        v-if="!autoRows.length"
+        class="ml-2 mb-1"
+      >
+        <span class="text-caption grey--text d-block">
+          No auto-registered frames yet.
+        </span>
+        <v-btn
+          v-if="autoRegisterAvailable"
+          outlined
+          x-small
+          color="primary"
+          class="mt-1"
+          :disabled="cameras.length < 2 || autoRegistering"
+          :loading="autoRegistering"
+          @click="openAutoRegisterDialog"
+        >
+          <template #loader>
+            <v-progress-circular
+              indeterminate
+              size="14"
+              width="2"
+            />
+          </template>
+          <v-icon
+            x-small
+            left
+          >
+            mdi-auto-fix
+          </v-icon>
+          Auto Register Frames…
+        </v-btn>
+      </div>
+
+      <!-- Queue: captures the user picked for the next matcher run -->
+      <div class="d-flex align-center flex-wrap ml-2 mt-1">
+        <tooltip-btn
+          icon="mdi-plus"
+          :disabled="currentSlot === null || currentQueued"
+          :tooltip-text="currentQueued
+            ? 'This frame is already queued'
+            : 'Queue the current frame for the next matcher run'"
+          @click="queueCurrentFrame"
+        />
+        <span
+          v-if="!queuedSlots.length"
+          class="text-caption grey--text"
+        >
+          Queue frames to match
+        </span>
+        <v-chip
+          v-for="slot in queuedSlots"
+          :key="`queued-${slot}`"
+          x-small
+          label
+          close
+          class="mr-1 mb-1"
+          @click:close="unqueueSlot(slot)"
+        >
+          {{ slot }}
+        </v-chip>
+      </div>
+      <div
+        v-if="queuedSlots.length"
+        class="d-flex align-center mt-1"
+      >
+        <v-btn
+          outlined
+          x-small
+          color="primary"
+          class="flex-grow-1"
+          :disabled="autoRegistering"
+          :loading="autoRegistering"
+          @click="runQueuedFrames"
+        >
+          <template #loader>
+            <v-progress-circular
+              indeterminate
+              size="14"
+              width="2"
+            />
+          </template>
+          Run matcher on {{ queuedSlots.length }} frame(s)
+        </v-btn>
+        <tooltip-btn
+          icon="mdi-close"
+          tooltip-text="Clear the queue"
+          @click="clearQueue"
+        />
+      </div>
+
+      <!-- Manual: hand-picked points -->
+      <div class="d-flex align-center section-head mt-3">
+        <v-icon
+          x-small
+          class="mr-1"
+        >
+          mdi-cursor-default-click-outline
+        </v-icon>
+        <span class="font-weight-medium">Manual</span>
+        <span class="text-caption grey--text mx-2">
+          {{ manualSummary.enabled }}/{{ manualSummary.total }} frames
+          <template v-if="manualSummary.rmsPx !== null">
+            · rms {{ manualSummary.rmsPx.toFixed(1) }} px
+          </template>
+        </span>
+        <v-spacer />
+        <tooltip-btn
+          icon="mdi-delete-sweep-outline"
+          color="error"
+          :disabled="!manualAll.length"
+          tooltip-text="Clear all hand-picked frames for this pair"
+          @click="clearManual"
+        />
+        <tooltip-btn
+          icon="mdi-plus"
+          tooltip-text="Pick points on the current frame"
+          @click="addCurrentFrame"
+        />
+      </div>
+      <registration-frame-list
+        :rows="manualRows"
+        @toggle="toggleFrameRow"
+        @jump="jumpToFrame"
+        @remove="removeFrameRow"
+      />
+      <span
+        v-if="!manualRows.length"
+        class="text-caption grey--text d-block ml-2 mb-1"
+      >
+        No hand-picked frames.
+      </span>
+
+      <span
+        v-if="skippedCount"
+        class="text-caption grey--text d-block mt-1"
+      >
+        {{ skippedCount }} candidate(s) the matcher rejected are not listed.
+      </span>
+    </template>
+
+    <auto-register-dialog
+      v-model="autoRegisterDialog"
+      :camera-count="cameras.length"
+      :running="autoRegistering"
+      @run="runAutoRegister"
+    />
+    <span
+      v-if="autoRegisterError"
+      class="text-caption error--text d-block mt-1"
+    >
+      {{ autoRegisterError }}
+    </span>
+    <span
+      v-else-if="autoRegisterStatus"
+      class="text-caption success--text d-block mt-1"
+    >
+      {{ autoRegisterStatus }}
+    </span>
+
     <v-checkbox
       :input-value="linkedNav"
       :disabled="!hasTransform"
@@ -537,7 +1181,7 @@ export default defineComponent({
 
     <v-switch
       v-model="pickingEnabled"
-      label="Pick points"
+      label="Edit points"
       dense
       hide-details
       class="mt-0"
@@ -560,7 +1204,9 @@ export default defineComponent({
       >
         <v-expansion-panel>
           <v-expansion-panel-header class="px-1">
-            Correspondences ({{ correspondences.length }})
+            Correspondences on frame
+            {{ currentPairFrame !== null ? currentPairFrame : '—' }}
+            ({{ frameCorrespondences.length }})
           </v-expansion-panel-header>
           <v-expansion-panel-content class="px-0">
             <div class="d-flex justify-end mb-1">
@@ -579,7 +1225,7 @@ export default defineComponent({
               />
             </div>
             <v-simple-table
-              v-if="correspondences.length"
+              v-if="frameCorrespondences.length"
               dense
               class="mb-2"
             >
@@ -594,7 +1240,7 @@ export default defineComponent({
                 </thead>
                 <tbody>
                   <tr
-                    v-for="(c, i) in correspondences"
+                    v-for="(c, i) in frameCorrespondences"
                     :key="c.id"
                     :style="c.id === selectedCorrespondenceId
                       ? { backgroundColor: 'rgba(255, 152, 0, 0.25)' }
@@ -627,7 +1273,9 @@ export default defineComponent({
               v-else
               class="text-caption grey--text"
             >
-              No correspondences yet. At least {{ minPoints }} required for the selected transform.
+              No correspondences on this frame yet
+              ({{ correspondences.length }} total across all frames; at least
+              {{ minPoints }} required for the selected transform).
             </span>
           </v-expansion-panel-content>
         </v-expansion-panel>
diff --git a/client/dive-common/components/ControlsContainer.vue b/client/dive-common/components/ControlsContainer.vue
index f80139917..3baade77c 100644
--- a/client/dive-common/components/ControlsContainer.vue
+++ b/client/dive-common/components/ControlsContainer.vue
@@ -14,9 +14,11 @@ import {
   Timeline,
 } from 'vue-media-annotator/components';
 import { clientSettings } from 'dive-common/store/settings';
+import context from 'dive-common/store/context';
 import {
   useHandler,
   useAttributesFilters,
+  useCameraRegistration,
   useCameraStore,
   useSelectedCamera,
   useTime,
@@ -131,6 +133,49 @@ export default defineComponent({
     const {
       volume, setVolume, setSpeed, speed,
     } = aggregateController.value;
+    /**
+     * Registration-frame markers for the Timeline work-area, shown ONLY
+     * while the Camera Registration panel is open (the same signal the
+     * viewer's registrationActive keys off) -- outside that tab the timeline
+     * stays exactly as it is today.
+     *
+     * Observation frames are camA-local, but the Timeline draws in the
+     * SELECTED camera's local frame space. Those two spaces only coincide
+     * when the rig drops no frames (or when camA happens to be selected):
+     * a rig whose cameras drop frames independently accumulates an offset,
+     * putting every marker a frame or two off. Translate through the aligned
+     * timeline, and drop markers whose capture has no frame on the selected
+     * camera -- there is no honest place to draw those.
+     */
+    const cameraRegistration = useCameraRegistration();
+    const registrationMarkers = computed(() => {
+      if (context.state.active !== 'CameraRegistration') {
+        return [];
+      }
+      const key = cameraRegistration.activePairKey();
+      // Touch observations so edits recompute the markers.
+      // eslint-disable-next-line no-void
+      void cameraRegistration.observations.value;
+      if (!key) {
+        return [];
+      }
+      const [camA] = key.split('::');
+      const target = selectedCamera.value;
+      return cameraRegistration.framesForPair(key)
+        // Only frames that actually carry points. A producer records the
+        // candidates it considered and discarded too (auto-register proposes
+        // more frames than it matches, then prunes) -- those have no points
+        // and nothing to toggle, so a marker for them is just noise on the
+        // scrubber. The frame list still lists them with their skip reason.
+        .filter((row) => row.frame !== null && row.count > 0)
+        .map((row) => ({
+          frame: aggregateController.value.translateCameraFrame(camA, row.frame as number, target),
+          enabled: row.enabled,
+        }))
+        .filter((marker): marker is { frame: number; enabled: boolean } => (
+          marker.frame !== undefined
+        ));
+    });
     // The timeline charts (line/event charts) are built from trackStores in
     // the selected camera's own local frame space. Under an aligned timeline
     // (SEAL feature 5) the aggregate controller's frame/maxFrame/seek operate
@@ -167,6 +212,7 @@ export default defineComponent({
       ticks,
       hasGroups,
       attributeData,
+      registrationMarkers,
       timelineEnabled,
       activeCountSettings,
       clientSettings,
@@ -466,6 +512,7 @@ export default defineComponent({
       :display="!collapsed"
       :dataset-type="datasetType"
       :bottom-layout="bottomLayout"
+      :markers="registrationMarkers"
       @seek="seek"
     >
       <template
diff --git a/client/dive-common/components/ImportAnnotations.vue b/client/dive-common/components/ImportAnnotations.vue
index ddd518562..ad96f408f 100644
--- a/client/dive-common/components/ImportAnnotations.vue
+++ b/client/dive-common/components/ImportAnnotations.vue
@@ -89,7 +89,7 @@ export default defineComponent({
       }
       const progress = alignedView.registrationProgress.value;
       return progress
-        ? `${progress.registered}/${progress.total} cameras registered`
+        ? `${progress.registered}/${progress.total} cameras ready`
         : '';
     });
     const activeCameraName = computed(() => {
@@ -136,7 +136,7 @@ export default defineComponent({
       }
       const pairKeys = [
         ...Object.keys(cameraRegistration.homographies.value),
-        ...Object.keys(cameraRegistration.correspondences.value),
+        ...Object.keys(cameraRegistration.observations.value),
       ];
       const cams = [...cameraStore.camMap.value.keys()];
       const reference = alignedView.reference.value ?? cams[0];
@@ -347,7 +347,7 @@ export default defineComponent({
           // review posture -- picking stays off for a file-loaded transform.
           const pairKeys = [
             ...Object.keys(cameraRegistration.homographies.value),
-            ...Object.keys(cameraRegistration.correspondences.value),
+            ...Object.keys(cameraRegistration.observations.value),
           ];
           // Pair bodies name their own cameras, so a pair can reference one
           // missing from this dataset; only select a pair the panel can show.
diff --git a/client/dive-common/components/Viewer.vue b/client/dive-common/components/Viewer.vue
index 3c0eb9855..cbc470dd8 100644
--- a/client/dive-common/components/Viewer.vue
+++ b/client/dive-common/components/Viewer.vue
@@ -62,6 +62,7 @@ import ControlsContainer from 'dive-common/components/ControlsContainer.vue';
 import Sidebar from 'dive-common/components/Sidebar.vue';
 import BottomPanel from 'dive-common/components/BottomPanel.vue';
 import { useModeManager, useSave, useLassoMode } from 'dive-common/use';
+import { createAutoRegisterJobService, provideAutoRegisterJob } from 'dive-common/use/useAutoRegisterJob';
 import type {
   StereoAnnotationCompleteParams,
   StereoAnnotationResetParams,
@@ -197,6 +198,7 @@ export default defineComponent({
     const {
       loadDetections, loadConfig, saveConfig, getTiles, getTileURL, getTileHistogram,
       loadGlobalStyleSettings, saveGlobalStyleSettings,
+      getPipelineList, runPipeline,
     } = useApi();
     const progress = reactive({
       // Loaded flag prevents annotator window from populating
@@ -330,25 +332,23 @@ export default defineComponent({
     });
     const showUserSettingsDialog = ref(false);
 
-    // When the Camera Registration panel opens, minimize the workspace chrome to
-    // give the picking view more room: collapse the left type-filter sidebar and
-    // the bottom detections graph. This is a soft default -- the normal sidebar
-    // and timeline toggles still work while registering, so the user can bring
-    // either back -- and whatever layout they had before is restored on close.
+    // When the Camera Registration panel opens, minimize the workspace chrome
+    // to give the picking view more room: collapse the left type-filter
+    // sidebar. The bottom controls deliberately stay as they are -- the
+    // timeline hosts the registration-frame marker row, which is most useful
+    // exactly while this panel is open. This is a soft default -- the normal
+    // sidebar toggle still works while registering -- and whatever layout the
+    // user had before is restored on close.
     const registrationActive = computed(() => context.state.active === RegistrationToolsVue.name);
     let preRegistrationSidebarMode: 'left' | 'bottom' | 'collapsed' | null = null;
-    let preRegistrationControlsCollapsed = false;
     watch(registrationActive, (active) => {
       if (active) {
         preRegistrationSidebarMode = sidebarMode.value;
-        preRegistrationControlsCollapsed = controlsCollapsed.value;
         if (sidebarMode.value === 'left') {
           sidebarMode.value = 'collapsed';
         }
-        controlsCollapsed.value = true;
       } else if (preRegistrationSidebarMode !== null) {
         sidebarMode.value = preRegistrationSidebarMode;
-        controlsCollapsed.value = preRegistrationControlsCollapsed;
         preRegistrationSidebarMode = null;
       }
     });
@@ -564,6 +564,44 @@ export default defineComponent({
       alignedView.setRegistrationProgress(null);
       cameraRegistration.hydrate();
     }
+    // Keep the registration store's current frame in sync so newly picked
+    // points are stamped with the image pair they were picked on.
+    watch(() => aggregateController.value.frame.value, (frameNum) => {
+      cameraRegistration.currentFrame.value = frameNum;
+    }, { immediate: true });
+    /**
+     * Publish the frame/image bridge the registration store resolves
+     * observation identities with: image-sequence cameras resolve to real
+     * file names; video cameras resolve to stable frame://N pseudo-names so
+     * the persisted schema stays uniform across media types. Frames resolve
+     * in each camera's own local frame space.
+     */
+    function publishRegistrationFrameResolver() {
+      cameraRegistration.setFrameResolver({
+        currentImageName: (camera: string) => {
+          let cameraFrame: number;
+          try {
+            cameraFrame = aggregateController.value.getController(camera).frame.value;
+          } catch {
+            cameraFrame = aggregateController.value.frame.value;
+          }
+          return imageData.value[camera]?.[cameraFrame]?.filename
+            ?? `frame://${cameraFrame}`;
+        },
+        frameForImage: (camera: string, imageName: string) => {
+          const pseudo = /^frame:\/\/(\d+)$/.exec(imageName);
+          if (pseudo) {
+            return Number(pseudo[1]);
+          }
+          const images = imageData.value[camera];
+          if (!images || !images.length) {
+            return null;
+          }
+          const index = images.findIndex((image) => image.filename === imageName);
+          return index >= 0 ? index : null;
+        },
+      });
+    }
 
     const alignedResolution = computed(() => {
       if (!isMultiCameraDataset.value) {
@@ -582,7 +620,7 @@ export default defineComponent({
     });
     // Publish how much of the rig resolves so UI outside the viewer core
     // (e.g. the import menu's "Import to all cameras" checkbox) shows the
-    // same "N/M cameras registered" status as the Align View toggle.
+    // same "N/M cameras ready" status as the Align View toggle.
     const registrationProgress = computed(() => {
       if (!isMultiCameraDataset.value) {
         return null;
@@ -614,7 +652,7 @@ export default defineComponent({
      * Camera panes currently displayed. While the Camera Registration panel is
      * open with an active pair on a 3+ camera dataset, only the pair's two
      * panes show, so the left/right alignment flow reads without unrelated
-     * panes in between (regardless of whether Pick points is toggled on).
+     * panes in between (regardless of whether Edit points is toggled on).
      * Panes are hidden (v-show), not unmounted, so their viewers keep state.
      */
     const displayedCameras = computed(() => {
@@ -691,6 +729,62 @@ export default defineComponent({
     const lassoMode = useLassoMode();
     provide(LassoModeSymbol, lassoMode);
 
+    // Auto-register job bridge for the Camera Registration panel: proposes a
+    // stratified candidate spread, launches the utility_align_cameras pipe
+    // over exactly those frames, and refreshes the registration store when
+    // the merged result lands in the dataset meta. Availability is "is the
+    // align pipe in the pipeline list" -- truthful on both platforms because
+    // the add-on pack installs the pipes together with the matcher weights.
+    const autoRegisterJob = createAutoRegisterJobService({
+      datasetId,
+      cameras: multiCamList,
+      frameCount: (camera: string) => {
+        const images = imageData.value[camera];
+        if (images && images.length) {
+          return images.length;
+        }
+        try {
+          return aggregateController.value.getController(camera).maxFrame.value + 1;
+        } catch {
+          return 0;
+        }
+      },
+      timestampsFor: (camera: string) => {
+        const images = imageData.value[camera];
+        if (!images || !images.length
+          || !images.some((image) => image.timestamp !== undefined)) {
+          return null;
+        }
+        return images.map((image) => image.timestamp);
+      },
+      // Register through the same timeline playback uses, so a candidate
+      // "frame" is one capture across the rig rather than one index reused on
+      // cameras that may have dropped different frames.
+      alignedSlots: () => {
+        const result = alignedTimeline.value;
+        return result.aligned ? result.slots : null;
+      },
+      resolveImagePaths: async (camera: string, frames: number[]) => {
+        const images = imageData.value[camera];
+        return frames.map((frameNum) => images?.[frameNum]?.filename ?? `frame://${frameNum}`);
+      },
+      getPipelineList,
+      runPipeline,
+      loadMetadata: loadConfig,
+      registration: cameraRegistration,
+      confirmReload: () => prompt({
+        title: 'Auto Register Finished',
+        text: 'The auto-register job finished, but this registration has '
+          + 'unsaved edits. Load the job results (replacing the unsaved '
+          + 'edits)?',
+        positiveButton: 'Load results',
+        negativeButton: 'Keep my edits',
+        confirm: true,
+      }),
+    });
+    provideAutoRegisterJob(autoRegisterJob);
+    onBeforeUnmount(() => autoRegisterJob.dispose());
+
     // Provides wrappers for actions to integrate with settings
     const {
       linkingTrack,
@@ -1293,7 +1387,7 @@ export default defineComponent({
       cameraRegistration.maybeFitActivePair();
       await saveConfig(datasetId.value, {
         cameraHomographies: cameraRegistration.homographies.value,
-        cameraCorrespondences: cameraRegistration.correspondences.value,
+        cameraCorrespondences: cameraRegistration.observations.value,
         cameraTransformTypes: cameraRegistration.transformTypes.value,
         cameraRegistrationSource: cameraRegistration.source.value,
       });
@@ -1534,6 +1628,9 @@ export default defineComponent({
         if (meta.multiCamMedia) {
           /* We're loading a multicamera dataset */
           multiCamList.value = orderedMultiCamCameraNames(meta.multiCamMedia);
+          // Publish the persisted rig order for consumers that need to know
+          // which camera is first/last (see CameraStore.displayOrder).
+          cameraStore.displayOrder.value = multiCamList.value;
           defaultCamera.value = meta.multiCamMedia.defaultDisplay;
           changeCamera(defaultCamera.value);
           baseMulticamDatasetId.value = datasetId.value;
@@ -1542,6 +1639,9 @@ export default defineComponent({
           }
         } else {
           multiCamList.value = ['singleCam'];
+          // Clear any order carried over from a previously loaded multicam
+          // dataset, so orderedCameraNames falls back to camMap.
+          cameraStore.displayOrder.value = [];
           resetMulticamAlignment();
         }
         cameraStore.setCameraOrder(multiCamList.value);
@@ -1822,6 +1922,11 @@ export default defineComponent({
             meta.cameraTransformTypes,
             meta.cameraRegistrationSource,
           );
+          // Media is loaded at this point: resolve observation frames from
+          // their image names against this dataset's own frame ordering.
+          publishRegistrationFrameResolver();
+          // Probe for the align_cameras pipes (fire and forget).
+          autoRegisterJob.refreshAvailability();
           // Reset the aligned-view toggle for the newly loaded dataset (no
           // persistence this phase).
           alignedView.setEnabled(false);
diff --git a/client/dive-common/components/alignedViewTooltip.spec.ts b/client/dive-common/components/alignedViewTooltip.spec.ts
index cba2be334..e0d89f99a 100644
--- a/client/dive-common/components/alignedViewTooltip.spec.ts
+++ b/client/dive-common/components/alignedViewTooltip.spec.ts
@@ -25,7 +25,7 @@ describe('alignedViewTooltipText', () => {
       enabled: false,
       sourceIsMixed: false,
       progress: { registered: 1, total: 3 },
-    })).toBe('Align View — 1/3 cameras registered');
+    })).toBe('Align View — 1/3 cameras ready');
   });
 
   it('appends a mixed-calibration warning', () => {
diff --git a/client/dive-common/components/alignedViewTooltip.ts b/client/dive-common/components/alignedViewTooltip.ts
index 3a3ae4541..c0cc3cec4 100644
--- a/client/dive-common/components/alignedViewTooltip.ts
+++ b/client/dive-common/components/alignedViewTooltip.ts
@@ -26,7 +26,7 @@ export default function alignedViewTooltipText(options: {
     return `Align View on (draw/edit on any camera)${mixedNote}`;
   }
   if (progress && progress.registered < progress.total) {
-    return `Align View — ${progress.registered}/${progress.total} cameras registered${mixedNote}`;
+    return `Align View — ${progress.registered}/${progress.total} cameras ready${mixedNote}`;
   }
   return `Align View${mixedNote}`;
 }
diff --git a/client/dive-common/registrationMarkerFrames.spec.ts b/client/dive-common/registrationMarkerFrames.spec.ts
new file mode 100644
index 000000000..e8f647d5f
--- /dev/null
+++ b/client/dive-common/registrationMarkerFrames.spec.ts
@@ -0,0 +1,156 @@
+/**
+ * Cross-camera frame translation for registration UI (markers, seeks).
+ *
+ * Registration observations resolve their frame in the pair's camA space, but
+ * the Timeline draws -- and handler.seekFrame() seeks -- in the SELECTED
+ * camera's space. Cameras drop frames independently, so those spaces drift
+ * apart and everything drawn from an observation lands a frame or two off.
+ *
+ * Fixture is the real KAMERA fl09 center_view shape: 277 captures at 1s, RGB
+ * missing 3 of them, IR/UV missing 3 different ones, so each modality has
+ * exactly 274 frames over mismatched timelines.
+ */
+
+import { describe, expect, it } from 'vitest';
+import type { FrameImage } from 'dive-common/apispec';
+import { attachFrameTimestamps } from 'dive-common/frameTimestamp';
+import {
+  buildAlignedTimeline, buildInverseAlignedIndex, AlignedSlot,
+} from 'dive-common/alignedTimeline';
+
+const BASE_EPOCH_MS = Date.UTC(2024, 5, 12, 20, 40, 5, 0);
+const UNION_LENGTH = 277;
+const MISSING_FROM_RGB = new Set([93, 189, 276]);
+const MISSING_FROM_IR = new Set([0, 94, 190]);
+
+function frameName(unionIndex: number, modality: string, ext: string): string {
+  const iso = new Date(BASE_EPOCH_MS + unionIndex * 1000).toISOString();
+  const date = iso.slice(0, 10).replace(/-/g, '');
+  const time = iso.slice(11, 19).replace(/:/g, '');
+  return `kamera_calibration_fl09_C_${date}_${time}.607980_${modality}.${ext}`;
+}
+
+function cameraFrames(missing: Set<number>, modality: string, ext: string): FrameImage[] {
+  const frames: FrameImage[] = [];
+  for (let i = 0; i < UNION_LENGTH; i += 1) {
+    if (!missing.has(i)) {
+      frames.push({ url: '', filename: frameName(i, modality, ext) });
+    }
+  }
+  attachFrameTimestamps(frames);
+  return frames;
+}
+
+const IMAGES: Record<string, FrameImage[]> = {
+  rgb: cameraFrames(MISSING_FROM_RGB, 'rgb', 'jpg'),
+  ir: cameraFrames(MISSING_FROM_IR, 'ir', 'png'),
+  uv: cameraFrames(MISSING_FROM_IR, 'uv', 'jpg'),
+};
+
+const timeline = buildAlignedTimeline(IMAGES) as { aligned: true; slots: AlignedSlot[] };
+const { slots } = timeline;
+const inverse = buildInverseAlignedIndex(slots);
+
+/** The production implementation, mirrored (useMediaController.aggregateTranslateCameraFrame). */
+function translateCameraFrame(from: string, localFrame: number, to: string): number | undefined {
+  if (from === to) {
+    return localFrame;
+  }
+  const slot = inverse[from]?.get(localFrame);
+  return slot === undefined ? undefined : slots[slot][to];
+}
+
+function stamp(camera: string, localFrame: number): number {
+  return IMAGES[camera][localFrame].timestamp as number;
+}
+
+describe('registration marker frame translation', () => {
+  it('untranslated camA frames land on the wrong capture in another camera', () => {
+    // What the markers did before: draw the camA-local index as-is.
+    const wrong = IMAGES.rgb.filter((frame, rgbLocal) => (
+      IMAGES.ir[rgbLocal] !== undefined
+      && stamp('ir', rgbLocal) !== (frame.timestamp as number)
+    ));
+    expect(wrong.length).toBe(274);
+  });
+
+  it('translates every camA frame onto the same capture in the target camera', () => {
+    let translated = 0;
+    IMAGES.rgb.forEach((frame, rgbLocal) => {
+      const irLocal = translateCameraFrame('rgb', rgbLocal, 'ir');
+      if (irLocal !== undefined) {
+        expect(stamp('ir', irLocal)).toBe(frame.timestamp);
+        translated += 1;
+      }
+    });
+    // 271 shared captures; the 3 RGB-only frames have no IR counterpart.
+    expect(translated).toBe(271);
+  });
+
+  it('returns undefined for a capture the target camera is missing', () => {
+    // Union 0 is RGB-only -> rgb local 0 has no IR frame.
+    expect(translateCameraFrame('rgb', 0, 'ir')).toBeUndefined();
+    const missing = IMAGES.rgb.filter(
+      (_, i) => translateCameraFrame('rgb', i, 'ir') === undefined,
+    );
+    expect(missing).toHaveLength(3);
+  });
+
+  it('is identity for the same camera', () => {
+    expect(translateCameraFrame('ir', 42, 'ir')).toBe(42);
+  });
+
+  it('agrees in both directions', () => {
+    IMAGES.ir.forEach((_, irLocal) => {
+      const rgbLocal = translateCameraFrame('ir', irLocal, 'rgb');
+      if (rgbLocal !== undefined) {
+        expect(translateCameraFrame('rgb', rgbLocal, 'ir')).toBe(irLocal);
+      }
+    });
+  });
+
+  it('is a passthrough between cameras with identical timelines (ir/uv)', () => {
+    IMAGES.ir.forEach((_, irLocal) => {
+      expect(translateCameraFrame('ir', irLocal, 'uv')).toBe(irLocal);
+    });
+  });
+});
+
+/**
+ * The frame readout above the timeline shows the aggregate controller's frame,
+ * which under an aligned timeline is the global slot. A registration frame
+ * number derived from camA is in camA's local space, so displaying it raw puts
+ * two different numbers on one capture -- both correctly "selected", which is
+ * what makes the disagreement so confusing.
+ */
+describe('registration frame numbers shown in slot space', () => {
+  /** The production lookup (useMediaController.aggregateCameraFrameToSlot). */
+  function cameraFrameToSlot(camera: string, localFrame: number): number | undefined {
+    return inverse[camera]?.get(localFrame);
+  }
+
+  it('camA-local and the slot readout disagree by the drops so far', () => {
+    // Slot 140 is the reported case: rgb is one frame behind, ir/uv two.
+    expect(slots[140]).toEqual({ rgb: 139, ir: 138, uv: 138 });
+    expect(cameraFrameToSlot('rgb', 139)).toBe(140);
+    expect(cameraFrameToSlot('ir', 138)).toBe(140);
+  });
+
+  it('publishes every camera onto the one number the readout shows', () => {
+    slots.forEach((slot, slotIndex) => {
+      Object.entries(slot).forEach(([camera, localFrame]) => {
+        if (localFrame !== undefined) {
+          expect(cameraFrameToSlot(camera, localFrame)).toBe(slotIndex);
+        }
+      });
+    });
+  });
+
+  it('disagrees for most of the flight if left untranslated', () => {
+    const mismatched = slots.filter((slot, slotIndex) => (
+      slot.rgb !== undefined && slot.rgb !== slotIndex
+    ));
+    // Every capture after the first RGB-only frame is off by at least one.
+    expect(mismatched.length).toBeGreaterThan(180);
+  });
+});
diff --git a/client/dive-common/registrationParentFolder.spec.ts b/client/dive-common/registrationParentFolder.spec.ts
index c41ee9080..92d7c42bf 100644
--- a/client/dive-common/registrationParentFolder.spec.ts
+++ b/client/dive-common/registrationParentFolder.spec.ts
@@ -12,9 +12,9 @@ function mk(relativePath: string, content: string): File {
 
 const commonPathPrefix = () => 'collect';
 
-const untypedRegistration = JSON.stringify({ version: 1, pairs: [] });
+const untypedRegistration = JSON.stringify({ version: 2, pairs: [] });
 const typedRegistration = JSON.stringify({
-  type: 'dive-camera-registration', version: 1, pairs: [],
+  type: 'dive-camera-registration', version: 2, pairs: [],
 });
 
 describe('findRegistrationFilesInFileList', () => {
@@ -38,7 +38,7 @@ describe('findRegistrationFilesInFileList', () => {
 
   it('rejects a registration-named file without a pairs list', async () => {
     const found = await findRegistrationFilesInFileList([
-      mk('collect/no_pairs_registration.json', JSON.stringify({ version: 1 })),
+      mk('collect/no_pairs_registration.json', JSON.stringify({ version: 2 })),
     ], 'collect', commonPathPrefix);
     expect(found).toStrictEqual([]);
   });
diff --git a/client/dive-common/use/useAutoRegisterJob.spec.ts b/client/dive-common/use/useAutoRegisterJob.spec.ts
new file mode 100644
index 000000000..4e25f6058
--- /dev/null
+++ b/client/dive-common/use/useAutoRegisterJob.spec.ts
@@ -0,0 +1,356 @@
+/**
+ * Candidate selection across an aligned timeline.
+ *
+ * Modelled on a real KAMERA flight (2024_AOC_AK_Calibration/fl09, center_view):
+ * 277 captures at a 1s cadence, RGB missing 3 of them and IR/UV missing 3
+ * different ones, so every modality lands on exactly 274 frames. Equal counts,
+ * mismatched timelines -- and because each RGB drop is shadowed by an IR drop
+ * one capture later, the local-index offset never re-syncs. Pairing by raw
+ * frame index picks images a full cadence apart for all 274 frames; the
+ * aligned timeline's slots are what make index i mean one instant.
+ */
+
+import {
+  describe, expect, it, vi,
+} from 'vitest';
+import { ref } from 'vue';
+import type { FrameImage } from 'dive-common/apispec';
+import { attachFrameTimestamps } from 'dive-common/frameTimestamp';
+import { buildAlignedTimeline, AlignedSlot } from 'dive-common/alignedTimeline';
+import type CameraRegistrationStore from 'vue-media-annotator/alignedView/CameraRegistrationStore';
+import { createAutoRegisterJobService, AlignPipe } from './useAutoRegisterJob';
+
+const BASE_EPOCH_MS = Date.UTC(2024, 5, 12, 20, 40, 5, 0);
+const UNION_LENGTH = 277;
+const MISSING_FROM_RGB = new Set([93, 189, 276]);
+const MISSING_FROM_IR = new Set([0, 94, 190]);
+const CAMERAS = ['rgb', 'ir', 'uv'];
+
+function frameName(unionIndex: number, modality: string, ext: string): string {
+  const iso = new Date(BASE_EPOCH_MS + unionIndex * 1000).toISOString();
+  const date = iso.slice(0, 10).replace(/-/g, '');
+  const time = iso.slice(11, 19).replace(/:/g, '');
+  return `kamera_calibration_fl09_C_${date}_${time}.607980_${modality}.${ext}`;
+}
+
+function cameraFrames(missing: Set<number>, modality: string, ext: string): FrameImage[] {
+  const frames: FrameImage[] = [];
+  for (let i = 0; i < UNION_LENGTH; i += 1) {
+    if (!missing.has(i)) {
+      frames.push({ url: '', filename: frameName(i, modality, ext) });
+    }
+  }
+  attachFrameTimestamps(frames);
+  return frames;
+}
+
+const IMAGES: Record<string, FrameImage[]> = {
+  rgb: cameraFrames(MISSING_FROM_RGB, 'rgb', 'jpg'),
+  ir: cameraFrames(MISSING_FROM_IR, 'ir', 'png'),
+  uv: cameraFrames(MISSING_FROM_IR, 'uv', 'jpg'),
+};
+
+const ALIGN_PIPE: AlignPipe = {
+  name: 'Align Cameras 3-cam', pipe: 'utility_align_cameras_3-cam.pipe', type: 'utility',
+};
+
+/** Captures the imagePairs the service would hand the pipeline. */
+function buildService(slots: AlignedSlot[] | null) {
+  const sent: {
+    imagePairs?: Record<string, string[]>;
+    kwiverParams?: Record<string, string>;
+  } = {};
+  const service = createAutoRegisterJobService({
+    datasetId: ref('ds1'),
+    cameras: ref(CAMERAS),
+    frameCount: (camera: string) => IMAGES[camera].length,
+    timestampsFor: (camera: string) => IMAGES[camera].map((frame) => frame.timestamp),
+    alignedSlots: () => slots,
+    resolveImagePaths: async (camera: string, frames: number[]) => (
+      frames.map((n) => IMAGES[camera][n]?.filename ?? `missing://${n}`)
+    ),
+    getPipelineList: async () => ({ utility: { pipes: [ALIGN_PIPE] } }),
+    runPipeline: async (_id, _pipe, params) => {
+      sent.imagePairs = params.runtimeParams?.imagePairs;
+      sent.kwiverParams = params.kwiverParams;
+      // Reject so run() settles without entering the result poll loop.
+      throw new Error('stop-after-launch');
+    },
+    loadMetadata: async () => ({ cameraCorrespondences: {} }),
+    registration: {
+      observations: ref({}),
+      dirty: ref(false),
+    } as unknown as CameraRegistrationStore,
+    confirmReload: async () => true,
+  });
+  return { service, sent };
+}
+
+function timestampOf(camera: string, filename: string): number {
+  return IMAGES[camera].find((frame) => frame.filename === filename)?.timestamp as number;
+}
+
+describe('auto-register candidate selection', () => {
+  const timeline = buildAlignedTimeline(IMAGES);
+  const { slots } = (timeline as { aligned: true; slots: AlignedSlot[] });
+
+  it('the fixture reproduces equal counts over mismatched timelines', () => {
+    expect(IMAGES.rgb).toHaveLength(274);
+    expect(IMAGES.ir).toHaveLength(274);
+    const mispaired = IMAGES.rgb.filter(
+      (frame, i) => Math.abs((frame.timestamp as number) - (IMAGES.ir[i].timestamp as number)) > 0.5,
+    );
+    expect(mispaired).toHaveLength(274);
+  });
+
+  it('sends one capture per candidate when a timeline is available', async () => {
+    const { service, sent } = buildService(slots);
+    await service.refreshAvailability();
+    await service.run({ maxFrames: 12, candidatesPerBin: 2 });
+
+    const pairs = sent.imagePairs as Record<string, string[]>;
+    expect(Object.keys(pairs).sort()).toEqual(['ir', 'rgb', 'uv']);
+    expect(pairs.rgb.length).toBeGreaterThan(0);
+    pairs.rgb.forEach((name, i) => {
+      // Every camera in a candidate must be the same instant.
+      expect(timestampOf('ir', pairs.ir[i])).toBe(timestampOf('rgb', name));
+      expect(timestampOf('uv', pairs.uv[i])).toBe(timestampOf('rgb', name));
+    });
+  });
+
+  it('never proposes a capture that is missing on some camera', async () => {
+    const { service, sent } = buildService(slots);
+    await service.refreshAvailability();
+    await service.run({ maxFrames: 24, candidatesPerBin: 4 });
+
+    const pairs = sent.imagePairs as Record<string, string[]>;
+    CAMERAS.forEach((camera) => {
+      pairs[camera].forEach((name) => expect(name.startsWith('missing://')).toBe(false));
+    });
+    // Gap captures (union 0/93/94/189/190/276) can never appear.
+    const gapStamps = [0, 93, 94, 189, 190, 276]
+      .map((i) => (BASE_EPOCH_MS + i * 1000) / 1000);
+    pairs.rgb.forEach((name) => {
+      expect(gapStamps).not.toContain(timestampOf('rgb', name));
+    });
+  });
+
+  /**
+   * Without the timeline this dataset produces nothing at all: candidates are
+   * ranked by inter-camera skew read off raw local indices, every index is a
+   * full 1s cadence out, and the 0.5s gate drops all of them. That is the
+   * pre-fix behavior a user hit -- "No candidate frames could be proposed" on
+   * a flight whose captures are in fact 271-deep.
+   */
+  it('proposes nothing without a timeline, and never launches', async () => {
+    const { service, sent } = buildService(null);
+    await service.refreshAvailability();
+    await service.run({ maxFrames: 12, candidatesPerBin: 2 });
+
+    expect(sent.imagePairs).toBeUndefined();
+    expect(service.error.value).toMatch(/No candidate frames/);
+  });
+});
+
+/**
+ * Queued frames: the user has already chosen the captures, so the stratified
+ * proposal (temporal bins, per-bin oversampling, skew ranking) does not apply.
+ * Every queued capture is matched; only captures a camera is missing get
+ * dropped, because the pipeline reads image lists off disk and a gap has no
+ * path to send.
+ */
+describe('running an explicitly queued frame set', () => {
+  const timeline = buildAlignedTimeline(IMAGES);
+  const { slots } = (timeline as { aligned: true; slots: AlignedSlot[] });
+
+  it('matches exactly the queued captures, in slot order', async () => {
+    const { service, sent } = buildService(slots);
+    await service.refreshAvailability();
+    await service.run({
+      maxFrames: 3, candidatesPerBin: 1, slots: [140, 141, 200],
+    });
+
+    const pairs = sent.imagePairs as Record<string, string[]>;
+    expect(pairs.rgb).toHaveLength(3);
+    // Slot 140 is rgb-local 139 / ir-local 138 (the drops so far).
+    expect(pairs.rgb[0]).toBe(IMAGES.rgb[139].filename);
+    expect(pairs.ir[0]).toBe(IMAGES.ir[138].filename);
+    pairs.rgb.forEach((name, i) => {
+      expect(timestampOf('ir', pairs.ir[i])).toBe(timestampOf('rgb', name));
+      expect(timestampOf('uv', pairs.uv[i])).toBe(timestampOf('rgb', name));
+    });
+  });
+
+  it('gives the pipeline one bin per queued frame so none are pruned', async () => {
+    const { service, sent } = buildService(slots);
+    await service.refreshAvailability();
+    await service.run({
+      maxFrames: 99, candidatesPerBin: 7, slots: [140, 141, 200],
+    });
+
+    // maxFrames/candidatesPerBin are the proposal's knobs and must not leak in.
+    expect(sent.kwiverParams?.['register:max_frames']).toBe('3');
+  });
+
+  it('drops queued captures a camera is missing', async () => {
+    const { service, sent } = buildService(slots);
+    await service.refreshAvailability();
+    // Slot 0 is RGB-only; 93 has no RGB. Only 140 is registerable.
+    await service.run({
+      maxFrames: 3, candidatesPerBin: 1, slots: [0, 93, 140],
+    });
+
+    const pairs = sent.imagePairs as Record<string, string[]>;
+    expect(pairs.rgb).toHaveLength(1);
+    expect(pairs.rgb[0]).toBe(IMAGES.rgb[139].filename);
+  });
+
+  it('errors rather than launching when no queued capture is registerable', async () => {
+    const { service, sent } = buildService(slots);
+    await service.refreshAvailability();
+    await service.run({ maxFrames: 2, candidatesPerBin: 1, slots: [0, 93] });
+
+    expect(sent.imagePairs).toBeUndefined();
+    expect(service.error.value).toMatch(/None of the queued frames/);
+  });
+});
+
+/**
+ * "Replace existing" drops the prior matcher observations from the in-memory
+ * store. Those removals are the run's own bookkeeping, so on their own they
+ * must not leave the store looking like it holds the user's unsaved edits --
+ * otherwise the completion path stops to ask whether to discard edits the
+ * user never made, on every single replace-mode run.
+ */
+describe('replaceExisting and the unsaved-edits baseline', () => {
+  const timeline = buildAlignedTimeline(IMAGES);
+  const { slots } = (timeline as { aligned: true; slots: AlignedSlot[] });
+  const OBSERVATIONS = {
+    'rgb::ir': [
+      {
+        imageA: 'a.jpg', imageB: 'b.png', source: 'minima_loftr', enabled: true, points: [],
+      },
+      {
+        imageA: 'c.jpg', imageB: 'd.png', source: 'hand', enabled: true, points: [],
+      },
+    ],
+  };
+
+  function buildStoreService(dirtyBefore: boolean) {
+    const removed: string[] = [];
+    const calls = { markSaved: 0 };
+    const registration = {
+      observations: ref(OBSERVATIONS),
+      dirty: ref(dirtyBefore),
+      removeObservation: (_key: string, imageA: string, _imageB: string, source: string) => {
+        removed.push(`${imageA}:${source}`);
+      },
+      markSaved: () => { calls.markSaved += 1; },
+    } as unknown as CameraRegistrationStore;
+    const service = createAutoRegisterJobService({
+      datasetId: ref('ds1'),
+      cameras: ref(CAMERAS),
+      frameCount: (camera: string) => IMAGES[camera].length,
+      timestampsFor: (camera: string) => IMAGES[camera].map((frame) => frame.timestamp),
+      alignedSlots: () => slots,
+      resolveImagePaths: async (camera: string, frames: number[]) => (
+        frames.map((n) => IMAGES[camera][n].filename)
+      ),
+      getPipelineList: async () => ({ utility: { pipes: [ALIGN_PIPE] } }),
+      runPipeline: async () => { throw new Error('stop-after-launch'); },
+      loadMetadata: async () => ({ cameraCorrespondences: {} }),
+      registration,
+      confirmReload: async () => true,
+    });
+    return { service, removed, calls };
+  }
+
+  it('re-baselines a clean store so its own removals do not read as edits', async () => {
+    const { service, removed, calls } = buildStoreService(false);
+    await service.refreshAvailability();
+    await service.run({ maxFrames: 6, candidatesPerBin: 2, replaceExisting: true });
+
+    // Only the matcher's own observations are dropped; hand picks survive.
+    expect(removed).toEqual(['a.jpg:minima_loftr']);
+    expect(calls.markSaved).toBe(1);
+  });
+
+  it('leaves a genuinely dirty store dirty', async () => {
+    const { service, calls } = buildStoreService(true);
+    await service.refreshAvailability();
+    await service.run({ maxFrames: 6, candidatesPerBin: 2, replaceExisting: true });
+
+    expect(calls.markSaved).toBe(0);
+  });
+
+  it('does not touch the baseline when not replacing', async () => {
+    const { service, removed, calls } = buildStoreService(false);
+    await service.refreshAvailability();
+    await service.run({ maxFrames: 6, candidatesPerBin: 2 });
+
+    expect(removed).toEqual([]);
+    expect(calls.markSaved).toBe(0);
+  });
+});
+
+/**
+ * The completion confirm is modal and can sit unanswered indefinitely. While
+ * it waits, the panel must not keep claiming the job is still matching frames
+ * -- that reads as a hung job when the work is already done and merged.
+ */
+describe('status while the completion confirm is open', () => {
+  const timeline = buildAlignedTimeline(IMAGES);
+  const { slots } = (timeline as { aligned: true; slots: AlignedSlot[] });
+
+  it('reports waiting on confirmation rather than "job running"', async () => {
+    vi.useFakeTimers();
+    try {
+      let resolveConfirm: (value: boolean) => void = () => {};
+      let confirmOpened = false;
+      // Metadata changes after the baseline read, so the first poll tick sees
+      // the job's result land and routes into the dirty-store confirm.
+      let loads = 0;
+      const service = createAutoRegisterJobService({
+        datasetId: ref('ds1'),
+        cameras: ref(CAMERAS),
+        frameCount: (camera: string) => IMAGES[camera].length,
+        timestampsFor: (camera: string) => IMAGES[camera].map((frame) => frame.timestamp),
+        alignedSlots: () => slots,
+        resolveImagePaths: async (camera: string, frames: number[]) => (
+          frames.map((n) => IMAGES[camera][n].filename)
+        ),
+        getPipelineList: async () => ({ utility: { pipes: [ALIGN_PIPE] } }),
+        runPipeline: async () => undefined,
+        loadMetadata: async () => {
+          loads += 1;
+          return { cameraCorrespondences: loads > 1 ? { 'rgb::ir': [1] } : {} };
+        },
+        registration: {
+          observations: ref({}),
+          dirty: ref(true),
+        } as unknown as CameraRegistrationStore,
+        confirmReload: () => {
+          confirmOpened = true;
+          return new Promise<boolean>((resolve) => { resolveConfirm = resolve; });
+        },
+      });
+      await service.refreshAvailability();
+      const settled = service.run({ maxFrames: 6, candidatesPerBin: 2 });
+
+      // Launch settles, then the 5s poll tick fires.
+      await vi.advanceTimersByTimeAsync(0);
+      expect(service.status.value).toMatch(/matching frames/);
+      await vi.advanceTimersByTimeAsync(5000);
+
+      expect(confirmOpened).toBe(true);
+      expect(service.status.value).toBe('Auto Register finished — confirm loading the results');
+      expect(service.status.value).not.toMatch(/job running/);
+
+      resolveConfirm(false);
+      await settled;
+      expect(service.running.value).toBe(false);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});
diff --git a/client/dive-common/use/useAutoRegisterJob.ts b/client/dive-common/use/useAutoRegisterJob.ts
new file mode 100644
index 000000000..fab4eeb6a
--- /dev/null
+++ b/client/dive-common/use/useAutoRegisterJob.ts
@@ -0,0 +1,343 @@
+import {
+  computed, inject, provide, ref, Ref,
+} from 'vue';
+import type CameraRegistrationStore from 'vue-media-annotator/alignedView/CameraRegistrationStore';
+import proposeRegistrationFrames from 'dive-common/autoRegisterSelection';
+import type { AlignedSlot } from 'dive-common/alignedTimeline';
+
+/**
+ * Auto-register job bridge for the Camera Registration panel.
+ *
+ * Replaces the old single-frame interactive-service bridge: registration is
+ * now computed from MANY image pairs by the `utility_align_cameras_{2,3}-cam`
+ * pipeline (one job per rig; a triplet registers in one job). The panel
+ * calls {@link AutoRegisterJobService.run} with the knobs worth changing;
+ * the service proposes a stratified candidate spread (DIVE picks for
+ * diversity and synchronization; the VIAME process picks for image quality
+ * within each temporal bin), launches the pipeline with the frame subset,
+ * and refreshes the registration store when the job's output lands in the
+ * dataset. Availability is "is the align pipe in the pipeline list" -- the
+ * add-on packaging makes pipe present <=> weights present by construction,
+ * so no separate weights probe exists (and none could work on web).
+ */
+
+/** Minimal pipe shape from the pipeline list (see apispec Pipe). */
+export interface AlignPipe {
+  name: string;
+  pipe: string;
+  type: string;
+}
+
+export interface AutoRegisterRunOptions {
+  /** Candidate frames proposed per temporal bin (oversampling factor). */
+  candidatesPerBin: number;
+  /** Temporal bins == the pipeline's max_frames budget. */
+  maxFrames: number;
+  /**
+   * Camera pairs for a triplet as 1-based input indices ("1-2,1-3,2-3").
+   * Undefined = all pairs (the pipe default).
+   */
+  pairs?: string;
+  /** Per-frame minimum-inlier gate override. */
+  minInliers?: number;
+  /**
+   * Drop existing matcher-produced observations for the rig's pairs before
+   * launching, so the job's results replace them outright instead of
+   * merging over them frame by frame.
+   */
+  replaceExisting?: boolean;
+  /**
+   * Explicit global aligned-timeline slots to match, bypassing the stratified
+   * proposal. Used by "queue these frames and run": the user has already
+   * chosen the captures, so temporal spread and per-bin oversampling do not
+   * apply -- every queued capture is matched, and only captures missing a
+   * frame on some camera are dropped. maxFrames/candidatesPerBin are ignored.
+   */
+  slots?: number[];
+}
+
+export interface AutoRegisterJobService {
+  /** Whether the align pipeline is installed (reactive; resolves after mount). */
+  available: Readonly<Ref<boolean>>;
+  running: Readonly<Ref<boolean>>;
+  /** Progress/status line for the panel, or null when idle. */
+  status: Readonly<Ref<string | null>>;
+  error: Readonly<Ref<string | null>>;
+  run(options: AutoRegisterRunOptions): Promise<void>;
+}
+
+/** Everything the host (Viewer) must supply to build the service. */
+export interface AutoRegisterJobDeps {
+  datasetId: Ref<string>;
+  /** Rig cameras in display order (the job is rig-wide). */
+  cameras: Ref<string[]>;
+  frameCount(camera: string): number;
+  /** Per-frame capture timestamps for skew ranking, or null when unknown. */
+  timestampsFor(camera: string): (number | undefined)[] | null;
+  /**
+   * The dataset's aligned timeline (alignedTimeline.ts), or null when the
+   * dataset does not qualify for it. Cameras drop frames independently, so one
+   * frame index does NOT mean the same capture on every camera -- the slots are
+   * what say which local frames belong to one instant. Null falls back to
+   * positional pairing, which is all an unaligned dataset supports.
+   */
+  alignedSlots(): AlignedSlot[] | null;
+  /**
+   * Resolve the platform image identifiers for a camera's frames (absolute
+   * paths on desktop, image names on web, frame://N for video).
+   */
+  resolveImagePaths(camera: string, frames: number[]): Promise<string[]>;
+  getPipelineList(): Promise<Record<string, { pipes: AlignPipe[] }>>;
+  runPipeline(datasetId: string, pipe: AlignPipe, params: {
+    kwiverParams?: Record<string, string>;
+    runtimeParams?: { imagePairs?: Record<string, string[]> };
+  }): Promise<unknown>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  loadMetadata(datasetId: string): Promise<any>;
+  registration: CameraRegistrationStore;
+  /** Confirm replacing unsaved in-app edits with the job's result. */
+  confirmReload(): Promise<boolean>;
+}
+
+const POLL_INTERVAL_MS = 5000;
+const POLL_TIMEOUT_MS = 30 * 60 * 1000;
+const MATCHER_SOURCE = 'minima_loftr';
+
+export function createAutoRegisterJobService(deps: AutoRegisterJobDeps): AutoRegisterJobService & {
+  refreshAvailability(): Promise<void>;
+  dispose(): void;
+} {
+  const alignPipe = ref<AlignPipe | null>(null);
+  const running = ref(false);
+  const status = ref<string | null>(null);
+  const error = ref<string | null>(null);
+  let disposed = false;
+
+  async function refreshAvailability() {
+    // The 2/3-cam pipes install together (one add-on pack); resolve the one
+    // matching this rig's camera count.
+    const wanted = `utility_align_cameras_${Math.min(deps.cameras.value.length, 3)}-cam.pipe`;
+    try {
+      const categories = await deps.getPipelineList();
+      alignPipe.value = Object.values(categories)
+        .flatMap((category) => category.pipes)
+        .find((pipe) => pipe.pipe === wanted) ?? null;
+    } catch {
+      alignPipe.value = null;
+    }
+  }
+
+  /** Re-hydrate the store from freshly persisted meta, keeping the panel's pair. */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function rehydrate(meta: any) {
+    const { registration } = deps;
+    const priorPair = registration.activePair.value;
+    registration.hydrate(
+      meta.cameraHomographies,
+      meta.cameraCorrespondences,
+      meta.cameraTransformTypes,
+      meta.cameraRegistrationSource,
+    );
+    if (priorPair) {
+      registration.setActivePair(priorPair.camA, priorPair.camB);
+    }
+  }
+
+  /**
+   * Watch the dataset's persisted registration until the job's collector
+   * merges the pipeline output in (there is no cross-platform job-completion
+   * event; the artifact itself is the signal). Unsaved in-app edits are
+   * never clobbered silently -- the user confirms first.
+   */
+  async function pollForResult(baseline: string) {
+    const started = Date.now();
+    status.value = 'Auto Register job running… matching frames';
+    for (;;) {
+      // eslint-disable-next-line no-await-in-loop
+      await new Promise((resolve) => { setTimeout(resolve, POLL_INTERVAL_MS); });
+      if (disposed) {
+        return;
+      }
+      if (Date.now() - started > POLL_TIMEOUT_MS) {
+        status.value = null;
+        error.value = 'Auto Register timed out waiting for results; check the job log.';
+        return;
+      }
+      let meta;
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        meta = await deps.loadMetadata(deps.datasetId.value);
+      } catch {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      const snapshot = JSON.stringify(meta.cameraCorrespondences ?? {});
+      if (snapshot === baseline) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      if (deps.registration.dirty.value) {
+        // The confirm is modal and can sit unanswered indefinitely; say so,
+        // rather than leaving the panel claiming the job is still matching
+        // frames while it is really waiting on the user.
+        status.value = 'Auto Register finished — confirm loading the results';
+        // eslint-disable-next-line no-await-in-loop
+        const confirmed = await deps.confirmReload();
+        if (!confirmed) {
+          status.value = null;
+          error.value = 'Auto Register finished; reload the dataset to see its results.';
+          return;
+        }
+      }
+      rehydrate(meta);
+      status.value = 'Auto Register complete: review the registration frames below.';
+      return;
+    }
+  }
+
+  async function run(options: AutoRegisterRunOptions) {
+    if (running.value) {
+      return;
+    }
+    const pipe = alignPipe.value;
+    if (!pipe) {
+      error.value = 'The align_cameras pipeline is not installed (ALIGN-CAMERAS add-on).';
+      return;
+    }
+    running.value = true;
+    error.value = null;
+    try {
+      const cameras = deps.cameras.value;
+      const localTimestamps = cameras.map((camera) => deps.timestampsFor(camera));
+      // Only slots holding a frame from every camera can be registered: the
+      // matcher needs the whole set, and the pipeline reads the image lists off
+      // disk, so a gap has no path to send. Gaps stay in the dataset and stay
+      // visible in the viewer -- they are simply not candidates.
+      const slots: AlignedSlot[] = [];
+      // Global slot index -> position in `slots`, so an explicitly queued
+      // capture (which the UI names by its global slot) can be located here.
+      const positionOfSlot = new Map<number, number>();
+      (deps.alignedSlots() ?? []).forEach((slot, globalIndex) => {
+        if (cameras.every((camera) => slot[camera] !== undefined)) {
+          positionOfSlot.set(globalIndex, slots.length);
+          slots.push(slot);
+        }
+      });
+      const aligned = slots.length > 0;
+      const queued = options.slots?.length
+        ? options.slots
+          .map((globalIndex) => (aligned ? positionOfSlot.get(globalIndex) : globalIndex))
+          .filter((position): position is number => position !== undefined)
+        : null;
+      if (options.slots?.length && !queued?.length) {
+        throw new Error(
+          'None of the queued frames can be registered: no capture in the queue '
+          + 'has a frame on every camera.',
+        );
+      }
+      const frames = queued ?? proposeRegistrationFrames({
+        // With a timeline, "frame i" means slot i -- one capture across the
+        // rig. Without one, it falls back to the raw per-camera index.
+        counts: aligned
+          ? cameras.map(() => slots.length)
+          : cameras.map((camera) => deps.frameCount(camera)),
+        timestamps: (() => {
+          if (!localTimestamps.every((list) => list !== null)) {
+            return undefined;
+          }
+          const lists = localTimestamps as (number | undefined)[][];
+          return aligned
+            ? cameras.map((camera, i) => slots.map((slot) => lists[i][slot[camera] as number]))
+            : lists;
+        })(),
+        bins: options.maxFrames,
+        perBin: options.candidatesPerBin,
+      });
+      if (frames.length === 0) {
+        throw new Error(aligned
+          ? 'No candidate frames could be proposed: no capture has a frame on every camera.'
+          : 'No candidate frames could be proposed for this dataset.');
+      }
+      status.value = queued
+        ? `Matching ${frames.length} queued frame(s)…`
+        : `Proposing ${frames.length} candidate frames…`;
+      const imagePairs: Record<string, string[]> = {};
+      // eslint-disable-next-line no-restricted-syntax
+      for (const camera of cameras) {
+        // Translate each chosen capture into THIS camera's own local frame
+        // index; reusing one index across cameras is what paired mismatched
+        // instants before.
+        const localFrames = aligned
+          ? frames.map((slotIndex) => slots[slotIndex][camera] as number)
+          : frames;
+        // eslint-disable-next-line no-await-in-loop
+        imagePairs[camera] = await deps.resolveImagePaths(camera, localFrames);
+      }
+      if (options.replaceExisting) {
+        // Drop prior matcher observations so the fresh run replaces rather
+        // than merges; hand-picked observations always survive.
+        const { registration } = deps;
+        const wasDirty = registration.dirty.value;
+        Object.entries(registration.observations.value).forEach(([key, list]) => {
+          list
+            .filter((obs) => obs.source === MATCHER_SOURCE)
+            .forEach((obs) => registration.removeObservation(key, obs.imageA, obs.imageB, MATCHER_SOURCE));
+        });
+        // These removals are this run's own bookkeeping, not the user's
+        // edits: left counted as unsaved they would trip the "you have
+        // unsaved edits" confirmation at the end of EVERY replace-mode run,
+        // asking the user to protect changes they never made. Re-baseline so
+        // only genuine hand edits still read dirty (same rule frame
+        // resolution follows in CameraRegistrationStore.setFrameResolver).
+        if (!wasDirty) {
+          registration.markSaved();
+        }
+      }
+      const kwiverParams: Record<string, string> = {
+        // max_frames is the pipeline's bin budget: it keeps the best candidate
+        // per bin and prunes the rest. A queued run has already chosen its
+        // captures, so give it one bin per frame or it would prune them back
+        // down to the proposal's budget.
+        'register:max_frames': String(queued ? frames.length : options.maxFrames),
+      };
+      if (options.pairs) {
+        kwiverParams['register:pairs'] = options.pairs;
+      }
+      if (options.minInliers !== undefined) {
+        kwiverParams['register:min_inliers'] = String(options.minInliers);
+      }
+      const meta = await deps.loadMetadata(deps.datasetId.value);
+      const baseline = JSON.stringify(meta.cameraCorrespondences ?? {});
+      await deps.runPipeline(deps.datasetId.value, pipe, {
+        kwiverParams,
+        runtimeParams: { imagePairs },
+      });
+      await pollForResult(baseline);
+    } catch (err) {
+      status.value = null;
+      error.value = err instanceof Error ? err.message : String(err);
+    } finally {
+      running.value = false;
+    }
+  }
+
+  return {
+    available: computed(() => alignPipe.value !== null),
+    running,
+    status,
+    error,
+    run,
+    refreshAvailability,
+    dispose() { disposed = true; },
+  };
+}
+
+const AutoRegisterJobSymbol = Symbol('autoRegisterJob');
+
+export function provideAutoRegisterJob(service: AutoRegisterJobService) {
+  provide(AutoRegisterJobSymbol, service);
+}
+
+export function useAutoRegisterJob(): AutoRegisterJobService | null {
+  return inject<AutoRegisterJobService | null>(AutoRegisterJobSymbol, null);
+}
diff --git a/client/platform/desktop/backend/ipcService.ts b/client/platform/desktop/backend/ipcService.ts
index 3838ccd84..a890d6f59 100644
--- a/client/platform/desktop/backend/ipcService.ts
+++ b/client/platform/desktop/backend/ipcService.ts
@@ -58,6 +58,7 @@ function isSam3Installed(viamePath: string): boolean {
     path.join(pipelinesDir, configName),
   ));
 }
+
 if (OS.platform() === 'win32') {
   win32.initialize();
 }
diff --git a/client/platform/desktop/backend/native/cameraRegistration.ts b/client/platform/desktop/backend/native/cameraRegistration.ts
index 157e247e4..0c687037f 100644
--- a/client/platform/desktop/backend/native/cameraRegistration.ts
+++ b/client/platform/desktop/backend/native/cameraRegistration.ts
@@ -30,7 +30,7 @@ import {
 } from './common';
 
 export type CameraHomographies = NonNullable<DatasetConfigMutable['cameraHomographies']>;
-export type CameraCorrespondences = NonNullable<DatasetConfigMutable['cameraCorrespondences']>;
+export type CameraObservations = NonNullable<DatasetConfigMutable['cameraCorrespondences']>;
 export type CameraTransformTypes = NonNullable<DatasetConfigMutable['cameraTransformTypes']>;
 export type RegistrationSource = NonNullable<DatasetConfigMutable['cameraRegistrationSource']>;
 
@@ -47,34 +47,51 @@ export function readRegistrationSource(raw: unknown): RegistrationSource | null
 }
 
 /**
- * One camera pair in calibration.json. `left`/`right` are camera (folder) names;
- * `points` are the picked correspondences as rows of `leftX leftY rightX rightY`;
- * `leftToRight`/`rightToLeft` are the fitted
- * 3x3 homographies, when a fit has been performed; `transformType` is the fit
- * model used to compute them (defaults to {@link DEFAULT_TRANSFORM_TYPE} when
- * absent, matching the in-app default so a pair fitted at the default resolves
- * to the same model after a save/reload).
+ * One observation row in a registration file pair: the points contributed by
+ * one image pair, identified by its image names (`frame` is advisory --
+ * producers may not know this dataset's indices; the client re-resolves).
+ */
+export interface RegistrationObservation {
+  frame?: number | null;
+  imageLeft: string;
+  imageRight: string;
+  enabled?: boolean;
+  source?: string;
+  points?: number[][];
+  stats?: Record<string, unknown>;
+}
+
+/**
+ * One camera pair in a registration file (format v2). `left`/`right` are
+ * camera (folder) names; `observations` carry the per-image-pair points as
+ * rows of `leftX leftY rightX rightY`; `leftToRight`/`rightToLeft` are the
+ * fitted 3x3 homographies, when a fit has been performed; `transformType` is
+ * the fit model used to compute them (defaults to
+ * {@link DEFAULT_TRANSFORM_TYPE} when absent, matching the in-app default so
+ * a pair fitted at the default resolves to the same model after a
+ * save/reload).
  */
 export interface RegistrationPair {
   left: string;
   right: string;
-  points: number[][];
+  observations?: RegistrationObservation[];
   leftToRight: number[][] | null;
   rightToLeft: number[][] | null;
   transformType?: TransformType;
 }
 
-/** Rebuild the in-app homographies/correspondences/transform types from calibration.json pairs. */
+/** Rebuild the in-app homographies/observations/transform types from registration file pairs. */
 export function fromRegistrationPairs(
   pairs: RegistrationPair[],
 ): {
   homographies: CameraHomographies;
-  correspondences: CameraCorrespondences;
+  observations: CameraObservations;
   transformTypes: CameraTransformTypes;
 } {
   const homographies: CameraHomographies = {};
-  const correspondences: CameraCorrespondences = {};
+  const observations: CameraObservations = {};
   const transformTypes: CameraTransformTypes = {};
+  let nextId = 0;
   pairs.forEach((pair) => {
     const key = `${pair.left}::${pair.right}`;
     // Mirror the shared client parser (CameraRegistrationStore.loadRegistrationText):
@@ -91,14 +108,25 @@ export function fromRegistrationPairs(
         // Singular / non-invertible: skip the matrix, keep the points.
       }
     }
-    if (pair.points && pair.points.length) {
-      correspondences[key] = pair.points.map((p, i) => ({
-        id: i + 1, a: [p[0], p[1]], b: [p[2], p[3]],
+    if (pair.observations && pair.observations.length) {
+      observations[key] = pair.observations.map((obs) => ({
+        imageA: obs.imageLeft,
+        imageB: obs.imageRight,
+        // The client re-resolves frames from the image names on hydrate;
+        // the stored value is a fallback for resolver-less contexts.
+        frame: obs.frame ?? null,
+        enabled: obs.enabled ?? true,
+        source: obs.source || 'manual',
+        ...(obs.stats !== undefined ? { stats: obs.stats } : {}),
+        points: (obs.points || []).map((p) => {
+          nextId += 1;
+          return { id: nextId, a: [p[0], p[1]] as [number, number], b: [p[2], p[3]] as [number, number] };
+        }),
       }));
     }
     transformTypes[key] = pair.transformType || DEFAULT_TRANSFORM_TYPE;
   });
-  return { homographies, correspondences, transformTypes };
+  return { homographies, observations, transformTypes };
 }
 
 async function writeJsonFile(absPath: string, data: unknown): Promise<void> {
@@ -116,7 +144,7 @@ async function writeJsonFile(absPath: string, data: unknown): Promise<void> {
 export async function loadRegistrationFiles(basePath: string): Promise<{
   found: boolean;
   homographies: CameraHomographies;
-  correspondences: CameraCorrespondences;
+  observations: CameraObservations;
   transformTypes: CameraTransformTypes;
   source: RegistrationSource | null;
 }> {
@@ -140,6 +168,19 @@ export async function loadRegistrationFiles(basePath: string): Promise<{
       // eslint-disable-next-line no-await-in-loop -- files merged in deterministic order
       const calibration = await fs.readJson(absPath);
       if (calibration && Array.isArray(calibration.pairs)) {
+        // One format, one loader: a pre-v2 file has no observations, and
+        // accepting it would load a matrix-only pair with its points
+        // silently dropped -- indistinguishable from a real producer file.
+        // Skip it loudly instead.
+        if (calibration.version !== 2) {
+          console.warn(
+            `Skipping ${absPath}: unsupported registration file version `
+            + `${JSON.stringify(calibration.version)} (expected 2). Regenerate it `
+            + 'with a current producer.',
+          );
+          // eslint-disable-next-line no-continue
+          continue;
+        }
         found = true;
         (calibration.pairs as RegistrationPair[]).forEach((pair) => {
           const key = `${pair.left}::${pair.right}`;
@@ -185,7 +226,7 @@ export async function loadEffectiveRegistration(
   }
   return {
     homographies: meta.cameraHomographies ?? {},
-    correspondences: meta.cameraCorrespondences ?? {},
+    observations: meta.cameraCorrespondences ?? {},
     transformTypes: meta.cameraTransformTypes ?? {},
     source: meta.cameraRegistrationSource ?? null,
   };
@@ -203,13 +244,13 @@ export async function saveRegistrationToDatasetDir(
 ): Promise<void> {
   const onDisk = await loadRegistrationFiles(basePath);
   let {
-    homographies, correspondences, transformTypes, source,
+    homographies, observations, transformTypes, source,
   } = onDisk;
   if (args.cameraHomographies) {
     homographies = args.cameraHomographies;
   }
   if (args.cameraCorrespondences) {
-    correspondences = args.cameraCorrespondences;
+    observations = args.cameraCorrespondences;
   }
   if (args.cameraTransformTypes) {
     transformTypes = args.cameraTransformTypes;
@@ -220,7 +261,7 @@ export async function saveRegistrationToDatasetDir(
   }
   const files = buildPerCameraRegistrationFiles(
     {
-      homographies, correspondences, transformTypes, source,
+      homographies, observations, transformTypes, source,
     },
     referenceCamera,
   );
@@ -317,18 +358,41 @@ export async function importCameraRegistration(
   filePath: string,
   options: { camera?: string } = {},
 ): Promise<{ cameras: string[]; pairCount: number }> {
-  const parentId = datasetId.split('/')[0];
-  const projectDirInfo = await getValidatedProjectDir(settings, parentId);
-  const meta = await loadJsonConfig(projectDirInfo.datasetFileAbsPath);
   let data;
   try {
     data = await fs.readJson(filePath);
   } catch {
     throw new Error('File is not valid JSON');
   }
+  return importCameraRegistrationData(settings, datasetId, data, npath.basename(filePath), options);
+}
+
+/**
+ * Merge parsed registration data into a dataset (see
+ * {@link importCameraRegistration}); also the ingest point for pipeline
+ * outputs, which arrive as already-read JSON.
+ */
+export async function importCameraRegistrationData(
+  settings: Settings,
+  datasetId: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  data: any,
+  label: string,
+  options: { camera?: string } = {},
+): Promise<{ cameras: string[]; pairCount: number }> {
+  const parentId = datasetId.split('/')[0];
+  const projectDirInfo = await getValidatedProjectDir(settings, parentId);
+  const meta = await loadJsonConfig(projectDirInfo.datasetFileAbsPath);
   if (!data || !Array.isArray(data.pairs)) {
     throw new Error('Not a DIVE camera registration file (expected a "pairs" list)');
   }
+  if (data.version !== 2) {
+    throw new Error(
+      `Unsupported registration file version ${JSON.stringify(data.version)} `
+      + '(expected 2). Regenerate the file with a current producer; pre-v2 '
+      + 'files have no per-image-pair observations.',
+    );
+  }
   let incoming: CameraRegistrationValues = {
     ...fromRegistrationPairs(data.pairs),
     source: readRegistrationSource(data.source),
@@ -350,13 +414,53 @@ export async function importCameraRegistration(
   const merged = mergeRegistrationValues(
     await loadEffectiveRegistration(projectDirInfo.basePath, meta),
     incoming,
-    npath.basename(filePath),
+    label,
   );
   await saveConfig(settings, parentId, {
     cameraHomographies: merged.homographies,
-    cameraCorrespondences: merged.correspondences,
+    cameraCorrespondences: merged.observations,
     cameraTransformTypes: merged.transformTypes,
     cameraRegistrationSource: merged.source,
   });
   return summary;
 }
+
+/**
+ * Ingest an align_cameras pipeline output (registration JSON in the job
+ * work dir) into the dataset's saved registration. Frame-subset jobs on
+ * video cameras run over extracted stills named <camera>.frame_<N>.png, so
+ * such observation image names are mapped back to the frame://N
+ * pseudo-identities the client resolves; image-sequence names pass through
+ * (the extracted-or-original basenames are the dataset's own image names).
+ * Merging happens at observation granularity via the shared writers, which
+ * re-group pairs under DIVE's own reference camera -- the pipeline never
+ * needs to know it.
+ */
+export async function ingestPipelineRegistration(
+  settings: Settings,
+  datasetId: string,
+  filePath: string,
+  videoCameras: string[],
+): Promise<{ cameras: string[]; pairCount: number }> {
+  const data = await fs.readJson(filePath);
+  if (data && Array.isArray(data.pairs) && videoCameras.length) {
+    const videoSet = new Set(videoCameras);
+    const remap = (name: unknown, camera: string) => {
+      if (typeof name !== 'string' || !videoSet.has(camera)) {
+        return name;
+      }
+      const match = /\.frame_(\d+)\.\w+$/.exec(name);
+      return match ? `frame://${Number(match[1])}` : name;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data.pairs.forEach((pair: any) => {
+      (pair?.observations ?? []).forEach((obs: Record<string, unknown>) => {
+        // eslint-disable-next-line no-param-reassign
+        obs.imageLeft = remap(obs.imageLeft, pair.left);
+        // eslint-disable-next-line no-param-reassign
+        obs.imageRight = remap(obs.imageRight, pair.right);
+      });
+    });
+  }
+  return importCameraRegistrationData(settings, datasetId, data, npath.basename(filePath));
+}
diff --git a/client/platform/desktop/backend/native/common.spec.ts b/client/platform/desktop/backend/native/common.spec.ts
index ce468e668..546067197 100644
--- a/client/platform/desktop/backend/native/common.spec.ts
+++ b/client/platform/desktop/backend/native/common.spec.ts
@@ -9,7 +9,7 @@ import {
 } from 'platform/desktop/constants';
 import { makeEmptyAnnotationFile } from 'platform/desktop/backend/serializers/dive';
 
-import { CameraCorrespondences, MultiTrackRecord } from 'dive-common/apispec';
+import { CameraObservations, MultiTrackRecord } from 'dive-common/apispec';
 import { Attribute } from 'vue-media-annotator/use/AttributeTypes';
 import { getResponseError } from 'vue-media-annotator/utils';
 import * as common from './common';
@@ -210,23 +210,23 @@ beforeEach(() => {
     '/home/user/output': {},
     '/home/user/transformDiscovery': {
       exactName: {
-        'aaa-stamped.json': JSON.stringify({ type: 'dive-camera-registration', version: 1, pairs: [] }),
-        'calibration.json': JSON.stringify({ type: 'dive-camera-registration', version: 1, pairs: [] }),
+        'aaa-stamped.json': JSON.stringify({ type: 'dive-camera-registration', version: 2, pairs: [] }),
+        'calibration.json': JSON.stringify({ type: 'dive-camera-registration', version: 2, pairs: [] }),
       },
       otherName: {
         'a-rig-calibration.json': JSON.stringify({ calibrations: {} }),
         'broken.json': '{not json',
-        'z-transforms.json': JSON.stringify({ type: 'dive-camera-registration', version: 1, pairs: [] }),
+        'z-transforms.json': JSON.stringify({ type: 'dive-camera-registration', version: 2, pairs: [] }),
       },
       perCamera: {
-        'uv_to_eo_registration.json': JSON.stringify({ type: 'dive-camera-registration', version: 1, pairs: [] }),
-        'ir_to_eo_registration.json': JSON.stringify({ type: 'dive-camera-registration', version: 1, pairs: [] }),
+        'uv_to_eo_registration.json': JSON.stringify({ type: 'dive-camera-registration', version: 2, pairs: [] }),
+        'ir_to_eo_registration.json': JSON.stringify({ type: 'dive-camera-registration', version: 2, pairs: [] }),
         'stray.json': JSON.stringify({ some: 'thing' }),
       },
       untypedPerCamera: {
-        'uv_to_eo_registration.json': JSON.stringify({ version: 1, pairs: [] }),
-        'no_pairs_registration.json': JSON.stringify({ version: 1 }),
-        'untyped-other-name.json': JSON.stringify({ version: 1, pairs: [] }),
+        'uv_to_eo_registration.json': JSON.stringify({ version: 2, pairs: [] }),
+        'no_pairs_registration.json': JSON.stringify({ version: 2 }),
+        'untyped-other-name.json': JSON.stringify({ version: 2, pairs: [] }),
       },
       none: {
         'rig.json': JSON.stringify({ some: 'thing' }),
@@ -1863,7 +1863,14 @@ describe('native.common', () => {
       },
     };
     seededBase.cameraCorrespondences = {
-      'left::right': [{ id: 1, a: [0, 0], b: [1, 1] }],
+      'left::right': [{
+        imageA: 'left_0001.png',
+        imageB: 'right_0001.png',
+        frame: 1,
+        enabled: true,
+        source: 'manual',
+        points: [{ id: 1, a: [0, 0], b: [1, 1] }],
+      }],
     };
     seededBase.cameraTransformTypes = { 'left::right': 'similarity' };
     seededBase.cameraRegistrationSource = { model: 'seeded' };
@@ -1932,29 +1939,45 @@ describe('native.common', () => {
         BtoA: [[1, 0, -5], [0, 1, 3], [0, 0, 1]],
       },
     };
-    const cameraCorrespondences: CameraCorrespondences = {
-      'rgb::ir': [
-        { id: 1, a: [10, 20], b: [12, 22] },
-        { id: 2, a: [30, 40], b: [33, 44] },
-      ],
+    const cameraCorrespondences: CameraObservations = {
+      'rgb::ir': [{
+        imageA: 'rgb_0001.png',
+        imageB: 'ir_0001.png',
+        frame: 1,
+        enabled: true,
+        source: 'manual',
+        points: [
+          { id: 1, a: [10, 20], b: [12, 22] },
+          { id: 2, a: [30, 40], b: [33, 44] },
+        ],
+      }],
     };
 
     await common.saveConfig(settings, final.id, { cameraHomographies, cameraCorrespondences });
 
     // Persisted as a standalone per-camera file, named for the mapping it
-    // carries (ir warps onto rgb): pairs labeled left/right, with points
-    // laid out as leftX leftY rightX rightY. Never a single all-pairs file.
+    // carries (ir warps onto rgb): pairs labeled left/right, with each
+    // observation's points laid out as leftX leftY rightX rightY. Never a
+    // single all-pairs file.
     const projectDir = npath.join(settings.dataPath, 'DIVE_Projects', final.id);
     const registrationPath = npath.join(projectDir, 'ir_to_rgb_registration.json');
     expect(await fs.pathExists(registrationPath)).toBe(true);
     const registration = await fs.readJSON(registrationPath);
     // Self-identifies so parent-folder discovery recognizes it.
     expect(registration.type).toBe('dive-camera-registration');
+    expect(registration.version).toBe(2);
     expect(registration.pairs).toStrictEqual([
       {
         left: 'rgb',
         right: 'ir',
-        points: [[10, 20, 12, 22], [30, 40, 33, 44]],
+        observations: [{
+          frame: 1,
+          imageLeft: 'rgb_0001.png',
+          imageRight: 'ir_0001.png',
+          enabled: true,
+          source: 'manual',
+          points: [[10, 20, 12, 22], [30, 40, 33, 44]],
+        }],
         leftToRight: [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
         rightToLeft: [[1, 0, -5], [0, 1, 3], [0, 0, 1]],
         // No explicit choice was saved, so persistence fills the default model.
@@ -2046,7 +2069,7 @@ describe('native.common', () => {
     const { homographies } = common.fromRegistrationPairs([{
       left: 'eo',
       right: 'ir',
-      points: [],
+      observations: [],
       leftToRight: null,
       rightToLeft: [[1, 0, -5], [0, 1, 3], [0, 0, 1]],
     }]);
@@ -2056,15 +2079,24 @@ describe('native.common', () => {
   });
 
   it('fromRegistrationPairs keeps points but skips the matrix for singular input', () => {
-    const { homographies, correspondences } = common.fromRegistrationPairs([{
+    const { homographies, observations } = common.fromRegistrationPairs([{
       left: 'eo',
       right: 'ir',
-      points: [[1, 2, 3, 4]],
+      observations: [{
+        imageLeft: 'eo_0001.jpg',
+        imageRight: 'ir_0001.tif',
+        source: 'kamera-solver',
+        points: [[1, 2, 3, 4]],
+      }],
       leftToRight: [[0, 0, 0], [0, 0, 0], [0, 0, 0]],
       rightToLeft: null,
     }]);
     expect(homographies['eo::ir']).toBeUndefined();
-    expect(correspondences['eo::ir']).toHaveLength(1);
+    expect(observations['eo::ir']).toHaveLength(1);
+    expect(observations['eo::ir'][0]).toMatchObject({
+      imageA: 'eo_0001.jpg', imageB: 'ir_0001.tif', enabled: true, source: 'kamera-solver',
+    });
+    expect(observations['eo::ir'][0].points).toHaveLength(1);
   });
 
   it('saveConfig persists the registration source stamp and reloads it', async () => {
@@ -2115,16 +2147,16 @@ describe('native.common', () => {
     const projectDir = npath.join(settings.dataPath, 'DIVE_Projects', final.id);
 
     const irPair = {
-      left: 'rgb', right: 'ir', points: [], leftToRight: [[1, 0, 5], [0, 1, -3], [0, 0, 1]], rightToLeft: [[1, 0, -5], [0, 1, 3], [0, 0, 1]],
+      left: 'rgb', right: 'ir', observations: [], leftToRight: [[1, 0, 5], [0, 1, -3], [0, 0, 1]], rightToLeft: [[1, 0, -5], [0, 1, 3], [0, 0, 1]],
     };
     const uvPair = {
-      left: 'rgb', right: 'uv', points: [], leftToRight: [[1, 0, 8], [0, 1, 2], [0, 0, 1]], rightToLeft: [[1, 0, -8], [0, 1, -2], [0, 0, 1]],
+      left: 'rgb', right: 'uv', observations: [], leftToRight: [[1, 0, 8], [0, 1, 2], [0, 0, 1]], rightToLeft: [[1, 0, -8], [0, 1, -2], [0, 0, 1]],
     };
     await fs.writeJSON(npath.join(projectDir, 'ir_registration.json'), {
-      version: 1, source: { producer: 'kamera', run: 'fl07' }, pairs: [irPair],
+      version: 2, source: { producer: 'kamera', run: 'fl07' }, pairs: [irPair],
     });
     await fs.writeJSON(npath.join(projectDir, 'uv_registration.json'), {
-      version: 1, source: { producer: 'kamera', run: 'fl09' }, pairs: [uvPair],
+      version: 2, source: { producer: 'kamera', run: 'fl09' }, pairs: [uvPair],
     });
 
     // Both pairs merge; the disagreeing stamps become a mixed composite so
@@ -2141,7 +2173,7 @@ describe('native.common', () => {
 
     // Agreeing stamps stay a single plain stamp.
     await fs.writeJSON(npath.join(projectDir, 'uv_registration.json'), {
-      version: 1, source: { producer: 'kamera', run: 'fl07' }, pairs: [uvPair],
+      version: 2, source: { producer: 'kamera', run: 'fl07' }, pairs: [uvPair],
     });
     const agreeing = await common.loadConfig(settings, final.id, urlMapper);
     expect(agreeing.cameraRegistrationSource).toStrictEqual({ producer: 'kamera', run: 'fl07' });
@@ -2149,7 +2181,7 @@ describe('native.common', () => {
     // A save of the mixed set never stamps the per-camera files with the
     // composite (that would read as a unanimous rig on the next load).
     await fs.writeJSON(npath.join(projectDir, 'uv_registration.json'), {
-      version: 1, source: { producer: 'kamera', run: 'fl09' }, pairs: [uvPair],
+      version: 2, source: { producer: 'kamera', run: 'fl09' }, pairs: [uvPair],
     });
     const beforeSave = await common.loadConfig(settings, final.id, urlMapper);
     await common.saveConfig(settings, final.id, {
@@ -2216,10 +2248,10 @@ describe('native.common', () => {
     // A per-camera file for a second camera merges in alongside the first.
     await fs.writeJSON('/home/user/output/uv_to_rgb_registration.json', {
       type: 'dive-camera-registration',
-      version: 1,
+      version: 2,
       source: { producer: 'kamera', run: 'fl07' },
       pairs: [{
-        left: 'rgb', right: 'uv', points: [], leftToRight: [[1, 0, 8], [0, 1, 2], [0, 0, 1]], rightToLeft: [[1, 0, -8], [0, 1, -2], [0, 0, 1]],
+        left: 'rgb', right: 'uv', observations: [], leftToRight: [[1, 0, 8], [0, 1, 2], [0, 0, 1]], rightToLeft: [[1, 0, -8], [0, 1, -2], [0, 0, 1]],
       }],
     });
     const result = await common.importCameraRegistration(settings, final.id, '/home/user/output/uv_to_rgb_registration.json');
@@ -2257,13 +2289,13 @@ describe('native.common', () => {
     // A file holding two pairs, imported scoped to uv: only the uv pair lands.
     await fs.writeJSON('/home/user/output/allpairs.json', {
       type: 'dive-camera-registration',
-      version: 1,
+      version: 2,
       pairs: [
         {
-          left: 'rgb', right: 'ir', points: [], leftToRight: [[2, 0, 0], [0, 2, 0], [0, 0, 1]], rightToLeft: [[0.5, 0, 0], [0, 0.5, 0], [0, 0, 1]],
+          left: 'rgb', right: 'ir', observations: [], leftToRight: [[2, 0, 0], [0, 2, 0], [0, 0, 1]], rightToLeft: [[0.5, 0, 0], [0, 0.5, 0], [0, 0, 1]],
         },
         {
-          left: 'rgb', right: 'uv', points: [], leftToRight: [[1, 0, 8], [0, 1, 2], [0, 0, 1]], rightToLeft: [[1, 0, -8], [0, 1, -2], [0, 0, 1]],
+          left: 'rgb', right: 'uv', observations: [], leftToRight: [[1, 0, 8], [0, 1, 2], [0, 0, 1]], rightToLeft: [[1, 0, -8], [0, 1, -2], [0, 0, 1]],
         },
       ],
     });
diff --git a/client/platform/desktop/backend/native/common.ts b/client/platform/desktop/backend/native/common.ts
index e1c8ae6e4..912aa56d4 100644
--- a/client/platform/desktop/backend/native/common.ts
+++ b/client/platform/desktop/backend/native/common.ts
@@ -587,7 +587,7 @@ async function loadConfig(
   if (loadedCalibration.found) {
     ({
       homographies: cameraHomographies,
-      correspondences: cameraCorrespondences,
+      observations: cameraCorrespondences,
       transformTypes: cameraTransformTypes,
       source: cameraRegistrationSource,
     } = loadedCalibration);
diff --git a/client/platform/desktop/backend/native/multiCamImport.ts b/client/platform/desktop/backend/native/multiCamImport.ts
index 9119f7517..0976d8563 100644
--- a/client/platform/desktop/backend/native/multiCamImport.ts
+++ b/client/platform/desktop/backend/native/multiCamImport.ts
@@ -24,8 +24,8 @@ import {
 } from 'vue-media-annotator/alignedView/cameraRegistrationFiles';
 import { discoverMetadataAttachment, findImagesInFolder } from './common';
 import {
-  CameraCorrespondences,
   CameraHomographies,
+  CameraObservations,
   CameraTransformTypes,
   fromRegistrationPairs,
   RegistrationPair,
@@ -159,7 +159,7 @@ async function beginMultiCamImport(args: MultiCamImportArgs): Promise<DesktopMed
   // the aligned view consumes (loadConfig falls back to these meta fields
   // until a save writes the standalone per-camera files).
   const seedHomographies: CameraHomographies = {};
-  const seedCorrespondences: CameraCorrespondences = {};
+  const seedCorrespondences: CameraObservations = {};
   const seedTransformTypes: CameraTransformTypes = {};
   const seedSourceStamps: { file: string; source: RegistrationSource | null }[] = [];
   const importWarnings: string[] = [];
@@ -178,6 +178,12 @@ async function beginMultiCamImport(args: MultiCamImportArgs): Promise<DesktopMed
         if (!data || !Array.isArray(data.pairs)) {
           throw new Error('not a DIVE registration file (expected a "pairs" list)');
         }
+        if (data.version !== 2) {
+          throw new Error(
+            `unsupported registration file version ${JSON.stringify(data.version)} `
+            + '(expected 2); regenerate the file with a current producer',
+          );
+        }
         const parsed = fromRegistrationPairs(data.pairs);
         Object.entries(parsed.homographies).forEach(([key, homography]) => {
           if (!readTransformMatrix(homography.AtoB) || !readTransformMatrix(homography.BtoA)) {
@@ -185,7 +191,7 @@ async function beginMultiCamImport(args: MultiCamImportArgs): Promise<DesktopMed
           }
           seedHomographies[key] = homography;
         });
-        Object.assign(seedCorrespondences, parsed.correspondences);
+        Object.assign(seedCorrespondences, parsed.observations);
         Object.assign(seedTransformTypes, parsed.transformTypes);
         const fileName = item.transformFile.replace(/^.*[\\/]/, '');
         const warning = unknownCameraWarning(
diff --git a/client/platform/desktop/backend/native/multiCamTransformImport.spec.ts b/client/platform/desktop/backend/native/multiCamTransformImport.spec.ts
index f25b8f78d..043f3bad3 100644
--- a/client/platform/desktop/backend/native/multiCamTransformImport.spec.ts
+++ b/client/platform/desktop/backend/native/multiCamTransformImport.spec.ts
@@ -45,12 +45,17 @@ beforeAll(() => {
   registrationJsonPath = npath.join(tmpDir, 'calibration.json');
   fs.writeJsonSync(registrationJsonPath, {
     type: 'dive-camera-calibration',
-    version: 1,
+    version: 2,
     source: { model: 'colmap-2026-07-01', swathe: 'fl07_C' },
     pairs: [{
       left: 'eo',
       right: 'ir',
-      points: [[0, 0, 5, -3], [10, 0, 15, -3]],
+      observations: [{
+        imageLeft: 'frame0.png',
+        imageRight: 'frame0.png',
+        source: 'kamera-solver',
+        points: [[0, 0, 5, -3], [10, 0, 15, -3]],
+      }],
       leftToRight: [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
       rightToLeft: [[1, 0, -5], [0, 1, 3], [0, 0, 1]],
       transformType: 'translation',
@@ -76,7 +81,8 @@ describe('multiCamImport transform wire-through', () => {
     expect(output.jsonConfig.cameraHomographies?.['eo::ir'].AtoB).toEqual(
       [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
     );
-    expect(output.jsonConfig.cameraCorrespondences?.['eo::ir']).toHaveLength(2);
+    expect(output.jsonConfig.cameraCorrespondences?.['eo::ir']).toHaveLength(1);
+    expect(output.jsonConfig.cameraCorrespondences?.['eo::ir'][0].points).toHaveLength(2);
     expect(output.jsonConfig.cameraTransformTypes?.['eo::ir']).toBe('translation');
     // The producer provenance stamp travels with the seed.
     expect(output.jsonConfig.cameraRegistrationSource).toEqual(
@@ -98,11 +104,11 @@ describe('multiCamImport transform wire-through', () => {
   it('warns (but imports) when pairs name cameras the dataset does not have', async () => {
     const mismatchedPath = npath.join(tmpDir, 'uv_to_rgb_registration.json');
     fs.writeJsonSync(mismatchedPath, {
-      version: 1,
+      version: 2,
       pairs: [{
         left: 'uv',
         right: 'rgb',
-        points: [],
+        observations: [],
         leftToRight: [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
         rightToLeft: [[1, 0, -5], [0, 1, 3], [0, 0, 1]],
       }],
diff --git a/client/platform/desktop/backend/native/multiCamUtils.ts b/client/platform/desktop/backend/native/multiCamUtils.ts
index 1ddcf1166..7d33b325e 100644
--- a/client/platform/desktop/backend/native/multiCamUtils.ts
+++ b/client/platform/desktop/backend/native/multiCamUtils.ts
@@ -10,6 +10,70 @@ import { JsonConfig, Settings } from 'platform/desktop/constants';
 import { loadAnnotationFile, loadJsonConfig, getValidatedProjectDir } from 'platform/desktop/backend/native/common';
 import { serialize } from 'platform/desktop/backend/serializers/viame';
 import { parseFrameTimestamp } from 'dive-common/frameTimestamp';
+import { getBinaryPath, spawnResult } from './utils';
+
+const ffmpegPath = getBinaryPath('ffmpeg-ffprobe-static/ffmpeg');
+
+/** Frame subset / range inputs for multicam pipeline arg writing. */
+export interface MultiCamRuntimeSubset {
+  /**
+   * Camera name -> ordered image identifiers for exactly the frames a job
+   * should process (registration subset jobs). Entries are the camera's own
+   * image names (resolved against its base path), absolute paths, or
+   * frame://N pseudo-names for video cameras (extracted to temp images).
+   */
+  imagePairs?: Record<string, string[]>;
+  frameRange?: [number, number];
+}
+
+/**
+ * Extract specific frames of a video to still images so a frame-subset job
+ * can consume one uniform image-list input (no vidl_ffmpeg in the pipe, no
+ * video-decode variability in the matcher's input). The frame number is
+ * kept in the file name (<camera>.frame_<N>.png) so job outputs can be
+ * mapped back to frame://N identities on ingest.
+ */
+async function extractVideoFrames(
+  videoPath: string,
+  frames: number[],
+  fps: number,
+  outDir: string,
+  camera: string,
+): Promise<string[]> {
+  await fs.ensureDir(outDir);
+  const results: string[] = [];
+  // eslint-disable-next-line no-restricted-syntax
+  for (const frameNum of frames) {
+    const seconds = fps > 0 ? frameNum / fps : 0;
+    const dest = npath.join(outDir, `${camera}.frame_${frameNum}.png`);
+
+    const result = await spawnResult(ffmpegPath, [
+      '-ss', seconds.toFixed(6),
+      '-i', videoPath,
+      '-frames:v', '1',
+      // Without -update, ffmpeg's image2 muxer treats any digit-bearing
+      // output name as an ambiguous sequence pattern and refuses to write
+      // it; -update 1 tells it this is one literal file.
+      '-update', '1',
+      '-y', dest,
+    ]);
+
+    // result.error is just accumulated stderr, which ffmpeg always writes
+    // (its own progress/banner logging) even on success -- exit code and
+    // the output file are the actual success signal.
+    if (result.exitCode !== 0 || !await fs.pathExists(dest)) {
+      throw new Error(`Could not extract frame ${frameNum} from ${videoPath}: ${result.error || 'no output'}`);
+    }
+    results.push(dest);
+  }
+  return results;
+}
+
+/** frame://N pseudo-name to frame number, or null for real image names. */
+function pseudoFrameNumber(entry: string): number | null {
+  const match = /^frame:\/\/(\d+)$/.exec(entry);
+  return match ? Number(match[1]) : null;
+}
 
 /**
  * Figure out the destination location
@@ -73,7 +137,14 @@ function getTranscodedMultiCamType(imageListFile: string, jsonConfig: JsonConfig
   throw new Error(`No associate type for ${imageListFile} in multiCam data`);
 }
 
-async function writeMultiCamStereoPipelineArgs(jobWorkDir: string, meta: JsonConfig, settings: Settings, utility = false, forceTranscoded = false) {
+async function writeMultiCamStereoPipelineArgs(
+  jobWorkDir: string,
+  meta: JsonConfig,
+  settings: Settings,
+  utility = false,
+  forceTranscoded = false,
+  runtime: MultiCamRuntimeSubset = {},
+) {
   const argFilePair: Record<string, string> = {};
   const outFiles: Record<string, string> = {};
   if (meta.multiCam && meta.multiCam.cameras) {
@@ -92,10 +163,55 @@ async function writeMultiCamStereoPipelineArgs(jobWorkDir: string, meta: JsonCon
         argFilePair['detector_writer:file_name'] = outputFileName;
         argFilePair['track_writer:file_name'] = outputFileName;
       }
+      const subset = runtime.imagePairs?.[key];
       if (list.type === 'image-sequence') {
+        const inputFileName = npath.join(jobWorkDir, `input${i + 1}_images.txt`);
+        let images = list.originalImageFiles.map((image) => npath.join(originalBasePath, image));
+        if (subset) {
+          // A registration subset job: ONLY the selected frames, keeping the
+          // ordering contract (row i of each camera's list pairs with row i
+          // of every other camera's).
+          images = subset.map((entry) => (
+            npath.isAbsolute(entry) ? entry : npath.join(originalBasePath, entry)));
+        } else if (runtime.frameRange) {
+          // The single-camera path filters image lists by frameRange;
+          // multicam silently ignored it (a pre-existing no-op) -- apply it
+          // here now that the list writing is subset-aware.
+          const [startFrame, endFrame] = runtime.frameRange;
+          images = images.slice(Math.max(0, startFrame), endFrame + 1);
+        }
+        const inputFile = fs.createWriteStream(inputFileName);
+        images.forEach((image) => inputFile.write(`${image}\n`));
+        inputFile.end();
+        argFilePair[inputArg] = inputFileName;
+        if (i === 0) {
+          argFilePair['input:video_filename'] = inputFileName;
+        }
+      } else if (list.originalVideoFile && subset) {
+        // Video multicam with a frame subset: extract the selected frames to
+        // temp images and feed the identical image-list path, so the
+        // register pipes never need vidl_ffmpeg (one input mechanism, both
+        // media types).
+        const vidFile = (list.transcodedVideoFile && forceTranscoded) || list.transcodedMisalign
+          ? list.transcodedVideoFile : list.originalVideoFile;
+        const videoPath = npath.join(originalBasePath, vidFile);
+        const frames = subset.map((entry) => {
+          const frameNum = pseudoFrameNumber(entry);
+          if (frameNum === null) {
+            throw new Error(`Expected frame://N identifiers for video camera "${key}", got "${entry}"`);
+          }
+          return frameNum;
+        });
+        const extracted = await extractVideoFrames(
+          videoPath,
+          frames,
+          meta.fps,
+          npath.join(jobWorkDir, `extracted_${key}`),
+          key,
+        );
         const inputFileName = npath.join(jobWorkDir, `input${i + 1}_images.txt`);
         const inputFile = fs.createWriteStream(inputFileName);
-        list.originalImageFiles.forEach((image) => inputFile.write(`${npath.join(originalBasePath, image)}\n`));
+        extracted.forEach((image) => inputFile.write(`${image}\n`));
         inputFile.end();
         argFilePair[inputArg] = inputFileName;
         if (i === 0) {
diff --git a/client/platform/desktop/backend/native/multiCollectImport.spec.ts b/client/platform/desktop/backend/native/multiCollectImport.spec.ts
index 3efb89374..0a2c7311f 100644
--- a/client/platform/desktop/backend/native/multiCollectImport.spec.ts
+++ b/client/platform/desktop/backend/native/multiCollectImport.spec.ts
@@ -253,11 +253,11 @@ describe('native.multiCollectImport', () => {
 
   it('attaches per-collect registration files that seed the import', async () => {
     const registrationJson = JSON.stringify({
-      version: 1,
+      version: 2,
       pairs: [{
         left: 'EO',
         right: 'IR',
-        points: [],
+        observations: [],
         leftToRight: [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
         rightToLeft: [[1, 0, -5], [0, 1, 3], [0, 0, 1]],
         transformType: 'translation',
diff --git a/client/platform/desktop/backend/native/viame.ts b/client/platform/desktop/backend/native/viame.ts
index f9668b925..fcf62166f 100644
--- a/client/platform/desktop/backend/native/viame.ts
+++ b/client/platform/desktop/backend/native/viame.ts
@@ -36,6 +36,7 @@ import {
   getMultiCamImageFiles, getMultiCamVideoPath,
   writeMultiCamStereoPipelineArgs,
 } from './multiCamUtils';
+import { ingestPipelineRegistration } from './cameraRegistration';
 
 const PipelineRelativeDir = 'configs/pipelines';
 const DiveJobManifestName = 'dive_job_manifest.json';
@@ -172,6 +173,7 @@ async function runPipeline(
 ): Promise<DesktopJob> {
   const { datasetId, pipeline } = runPipelineArgs;
   const frameRange = runPipelineArgs.pipelineParams?.runtimeParams?.frameRange ?? undefined;
+  const imagePairs = runPipelineArgs.pipelineParams?.runtimeParams?.imagePairs ?? undefined;
   // Pipes with a camera suffix (e.g. filter_register_frames_2-cam.pipe) are
   // categorized under '2-cam'/'3-cam' rather than by their filename prefix,
   // so output handling is recognized from the pipe filename as well as the type.
@@ -366,7 +368,7 @@ async function runPipeline(
 
   let multiOutFiles: Record<string, string>;
   if (meta.multiCam && stereoOrMultiCam) {
-    const { argFilePair, outFiles } = await writeMultiCamStereoPipelineArgs(jobWorkDir, meta, settings, requiresInput);
+    const { argFilePair, outFiles } = await writeMultiCamStereoPipelineArgs(jobWorkDir, meta, settings, requiresInput, false, { imagePairs, frameRange });
     Object.entries(argFilePair).forEach(([arg, file]) => {
       command.push(`-s ${arg}="${file}"`);
     });
@@ -394,6 +396,14 @@ async function runPipeline(
         command.push(`-s ${key}="${meta.multiCam?.calibration}"`);
       });
     }
+
+    if (pipeline.pipe.toLowerCase().includes('align_cameras')) {
+      // Camera names for the output JSON, aligned with the input{i} order
+      // the arg writer uses (Object.entries over meta.multiCam.cameras).
+      const cameraNames = Object.keys(meta.multiCam.cameras).join(',');
+      command.push(`-s register:camera_names="${cameraNames}"`);
+      command.push(`-s register:output_directory="${jobWorkDir}"`);
+    }
   } else if (pipeline.type === stereoPipelineMarker) {
     throw new Error('Attempting to run a multicam pipeline on non multicam data');
   }
@@ -489,6 +499,32 @@ async function runPipeline(
           }
         }
 
+        // Registration pipeline: merge the output into the dataset's saved
+        // camera registration. Filename sniff is substring-based, like the
+        // calibration hook below; the process writes atomically, so a file
+        // present here is a complete result (a canceled job leaves none).
+        if (pipeline.pipe.toLowerCase().includes('align_cameras')) {
+          const files = await fs.readdir(jobWorkDir);
+          const registrationFile = files.find(
+            (f) => f.toLowerCase().includes('registration') && f.endsWith('.json'),
+          );
+          if (registrationFile && meta.multiCam) {
+            const videoCameras = Object.entries(meta.multiCam.cameras)
+              .filter(([, camera]) => camera.type === 'video')
+              .map(([name]) => name);
+            const summary = await ingestPipelineRegistration(
+              settings,
+              datasetId,
+              npath.join(jobWorkDir, registrationFile),
+              videoCameras,
+            );
+            updater({
+              ...jobBase,
+              body: [`Merged camera registration for ${summary.pairCount} pair(s) into the dataset`],
+            });
+          }
+        }
+
         // Check if this is a calibration pipeline and save the output
         if (pipeline.pipe.toLowerCase().includes('calibrate_cameras')) {
           const files = await fs.readdir(jobWorkDir);
diff --git a/client/platform/desktop/frontend/api.ts b/client/platform/desktop/frontend/api.ts
index b992828d9..c3a289db7 100644
--- a/client/platform/desktop/frontend/api.ts
+++ b/client/platform/desktop/frontend/api.ts
@@ -836,6 +836,7 @@ export {
   textQuery,
   refineDetections,
   runTextQueryPipeline,
+  /* Auto Register APIs */
   /* Stereo APIs */
   stereoEnable,
   stereoDisable,
diff --git a/client/platform/desktop/frontend/components/Export.vue b/client/platform/desktop/frontend/components/Export.vue
index 363dfe5a0..a1516b693 100644
--- a/client/platform/desktop/frontend/components/Export.vue
+++ b/client/platform/desktop/frontend/components/Export.vue
@@ -104,7 +104,7 @@ export default defineComponent({
       }
       return buildPerCameraRegistrationFiles({
         homographies: meta.cameraHomographies ?? {},
-        correspondences: meta.cameraCorrespondences ?? {},
+        observations: meta.cameraCorrespondences ?? {},
         transformTypes: meta.cameraTransformTypes ?? {},
         source: meta.cameraRegistrationSource ?? null,
       }, referenceCameraName(meta.multiCam));
diff --git a/client/platform/desktop/frontend/components/ViewerLoader.vue b/client/platform/desktop/frontend/components/ViewerLoader.vue
index d842ca648..06cae1aa8 100644
--- a/client/platform/desktop/frontend/components/ViewerLoader.vue
+++ b/client/platform/desktop/frontend/components/ViewerLoader.vue
@@ -642,8 +642,54 @@ export default defineComponent({
     let stereoDatasetFps: number | undefined;
 
     /**
-     * Load multicam metadata for both cameras to build image path getters
+     * Populate stereoImagePathGetters (per-camera frame -> image path) from a
+     * dataset's already-loaded multicam metadata. This part is not stereo
+     * specific: both the stereo features and Auto Register resolve per-camera
+     * image paths the same way. Callers gate on the dataset kind they support
+     * (stereo requires a stereoscopic dataset; auto-register accepts any multicam)
+     * before calling this. `meta.multiCamMedia` must already be truthy.
      */
+    async function populateMultiCamImagePathGetters(
+      meta: Awaited<ReturnType<typeof loadConfig>>,
+    ): Promise<boolean> {
+      // Extract calibration file path from multiCam metadata
+      stereoCalibrationFile = meta.multiCam?.calibration || undefined;
+      // Capture the dataset-level fps as a fallback for per-camera frame times.
+      stereoDatasetFps = meta.fps || meta.originalFps || stereoDatasetFps;
+
+      // Skip per-camera metadata loading if already populated (e.g. by initializeSegmentation)
+      if (Object.keys(stereoImagePathGetters.value).length > 0) return true;
+
+      if (!meta.multiCamMedia) return false;
+      const { cameras } = meta.multiCamMedia;
+      const cameraNames = Object.keys(cameras);
+
+      for (let i = 0; i < cameraNames.length; i += 1) {
+        const cam = cameraNames[i];
+        const cameraId = `${props.id}/${cam}`;
+        // eslint-disable-next-line no-await-in-loop
+        const camMeta = await loadConfig(cameraId);
+        const {
+          originalBasePath, originalImageFiles, type, originalVideoFile,
+        } = camMeta;
+
+        stereoImagePathGetters.value[cam] = (frameNum: number): string => {
+          if (type === 'video') {
+            return joinPath(originalBasePath, originalVideoFile || '');
+          }
+          if (originalImageFiles && originalImageFiles[frameNum]) {
+            const imagePath = originalImageFiles[frameNum];
+            if (isAbsolutePath(imagePath)) {
+              return imagePath;
+            }
+            return joinPath(originalBasePath, imagePath);
+          }
+          return '';
+        };
+      }
+      return true;
+    }
+
     async function loadStereoMetadata(): Promise<boolean> {
       try {
         const meta = await loadConfig(props.id);
@@ -651,42 +697,7 @@ export default defineComponent({
         // no stereo so the caller does not load the stereo service.
         if (!meta.multiCamMedia
           || !isStereoscopicDatasetConfig({ type: meta.type, subType: meta.subType ?? undefined })) return false;
-
-        // Extract calibration file path from multiCam metadata
-        stereoCalibrationFile = meta.multiCam?.calibration || undefined;
-        // Capture the dataset-level fps as a fallback for per-camera frame times.
-        stereoDatasetFps = meta.fps || meta.originalFps || stereoDatasetFps;
-
-        // Skip per-camera metadata loading if already populated (e.g. by initializeSegmentation)
-        if (Object.keys(stereoImagePathGetters.value).length > 0) return true;
-
-        const { cameras } = meta.multiCamMedia;
-        const cameraNames = Object.keys(cameras);
-
-        for (let i = 0; i < cameraNames.length; i += 1) {
-          const cam = cameraNames[i];
-          const cameraId = `${props.id}/${cam}`;
-          // eslint-disable-next-line no-await-in-loop
-          const camMeta = await loadConfig(cameraId);
-          const {
-            originalBasePath, originalImageFiles, type, originalVideoFile,
-          } = camMeta;
-
-          stereoImagePathGetters.value[cam] = (frameNum: number): string => {
-            if (type === 'video') {
-              return joinPath(originalBasePath, originalVideoFile || '');
-            }
-            if (originalImageFiles && originalImageFiles[frameNum]) {
-              const imagePath = originalImageFiles[frameNum];
-              if (isAbsolutePath(imagePath)) {
-                return imagePath;
-              }
-              return joinPath(originalBasePath, imagePath);
-            }
-            return '';
-          };
-        }
-        return true;
+        return await populateMultiCamImagePathGetters(meta);
       } catch (err) {
         console.error('[Stereo] Failed to load multicam metadata:', err);
         return false;
diff --git a/client/platform/web-girder/api/dataset.service.ts b/client/platform/web-girder/api/dataset.service.ts
index 6324d5250..a8ab3cb92 100644
--- a/client/platform/web-girder/api/dataset.service.ts
+++ b/client/platform/web-girder/api/dataset.service.ts
@@ -260,7 +260,7 @@ async function importCameraRegistration(
   store.loadRegistrationText(await file.text());
   let incoming = {
     homographies: store.homographies.value,
-    correspondences: store.correspondences.value,
+    observations: store.observations.value,
     transformTypes: store.transformTypes.value,
     source: store.source.value,
   };
@@ -278,7 +278,7 @@ async function importCameraRegistration(
   const merged = mergeRegistrationValues(
     {
       homographies: current.cameraHomographies ?? {},
-      correspondences: current.cameraCorrespondences ?? {},
+      observations: current.cameraCorrespondences ?? {},
       transformTypes: current.cameraTransformTypes ?? {},
       source: current.cameraRegistrationSource ?? null,
     },
@@ -287,7 +287,7 @@ async function importCameraRegistration(
   );
   await saveConfig(parentId, {
     cameraHomographies: merged.homographies,
-    cameraCorrespondences: merged.correspondences,
+    cameraCorrespondences: merged.observations,
     cameraTransformTypes: merged.transformTypes,
     cameraRegistrationSource: merged.source,
   });
diff --git a/client/platform/web-girder/multicamRegistrationSeed.spec.ts b/client/platform/web-girder/multicamRegistrationSeed.spec.ts
index aa13e3182..9bef9568c 100644
--- a/client/platform/web-girder/multicamRegistrationSeed.spec.ts
+++ b/client/platform/web-girder/multicamRegistrationSeed.spec.ts
@@ -10,7 +10,7 @@ function registrationFile(
 ): File {
   return new File([JSON.stringify({
     type: 'dive-camera-registration',
-    version: 1,
+    version: 2,
     ...(source ? { source } : {}),
     pairs,
   })], name, { type: 'application/json' });
@@ -19,7 +19,12 @@ function registrationFile(
 const eoIrPair = {
   left: 'eo',
   right: 'ir',
-  points: [[0, 0, 5, -3], [10, 0, 15, -3]],
+  observations: [{
+    imageLeft: 'eo_0000.jpg',
+    imageRight: 'ir_0000.tif',
+    source: 'kamera-solver',
+    points: [[0, 0, 5, -3], [10, 0, 15, -3]],
+  }],
   leftToRight: SHIFT,
   rightToLeft: UNSHIFT,
   transformType: 'translation',
@@ -35,7 +40,9 @@ describe('parseRegistrationSeed', () => {
     }], ['eo', 'ir']);
     expect(warnings).toStrictEqual([]);
     expect(values?.homographies['eo::ir'].AtoB).toEqual(SHIFT);
-    expect(values?.correspondences['eo::ir']).toHaveLength(2);
+    expect(values?.observations['eo::ir']).toHaveLength(1);
+    expect(values?.observations['eo::ir'][0].points).toHaveLength(2);
+    expect(values?.observations['eo::ir'][0].source).toBe('kamera-solver');
     expect(values?.transformTypes['eo::ir']).toBe('translation');
     expect(values?.source).toEqual(source);
   });
@@ -45,7 +52,7 @@ describe('parseRegistrationSeed', () => {
       cameraName: 'ir',
       fileName: 'uv_to_rgb_registration.json',
       file: registrationFile('uv_to_rgb_registration.json', [{
-        left: 'uv', right: 'rgb', points: [], leftToRight: SHIFT, rightToLeft: UNSHIFT,
+        left: 'uv', right: 'rgb', observations: [], leftToRight: SHIFT, rightToLeft: UNSHIFT,
       }]),
     }], ['eo', 'ir']);
     expect(values?.homographies['uv::rgb']).toBeDefined();
@@ -65,7 +72,7 @@ describe('parseRegistrationSeed', () => {
         cameraName: 'uv',
         fileName: 'uv_to_eo_registration.json',
         file: registrationFile('uv_to_eo_registration.json', [{
-          left: 'eo', right: 'uv', points: [], leftToRight: SHIFT, rightToLeft: UNSHIFT,
+          left: 'eo', right: 'uv', observations: [], leftToRight: SHIFT, rightToLeft: UNSHIFT,
         }], { model: 'b' }),
       },
     ], ['eo', 'ir', 'uv']);
diff --git a/client/platform/web-girder/multicamRegistrationSeed.ts b/client/platform/web-girder/multicamRegistrationSeed.ts
index d1cb8ea94..27e3fcebb 100644
--- a/client/platform/web-girder/multicamRegistrationSeed.ts
+++ b/client/platform/web-girder/multicamRegistrationSeed.ts
@@ -30,7 +30,7 @@ export async function parseRegistrationSeed(
   datasetCameraNames: string[],
 ): Promise<RegistrationSeedResult> {
   const homographies: CameraRegistrationValues['homographies'] = {};
-  const correspondences: CameraRegistrationValues['correspondences'] = {};
+  const observations: CameraRegistrationValues['observations'] = {};
   const transformTypes: CameraRegistrationValues['transformTypes'] = {};
   const stamps: { file: string; source: RegistrationSource | null }[] = [];
   const warnings: string[] = [];
@@ -56,15 +56,15 @@ export async function parseRegistrationSeed(
       warnings.push(warning);
     }
     Object.assign(homographies, store.homographies.value);
-    Object.assign(correspondences, store.correspondences.value);
+    Object.assign(observations, store.observations.value);
     Object.assign(transformTypes, store.transformTypes.value);
     stamps.push({ file: file.name, source: store.source.value });
   }
-  const seeded = Object.keys(homographies).length || Object.keys(correspondences).length;
+  const seeded = Object.keys(homographies).length || Object.keys(observations).length;
   return {
     values: seeded ? {
       homographies,
-      correspondences,
+      observations,
       transformTypes,
       source: mergeRegistrationSources(stamps),
     } : null,
diff --git a/client/platform/web-girder/scanMultiCamBatch.spec.ts b/client/platform/web-girder/scanMultiCamBatch.spec.ts
index 809f65113..6d054ce35 100644
--- a/client/platform/web-girder/scanMultiCamBatch.spec.ts
+++ b/client/platform/web-girder/scanMultiCamBatch.spec.ts
@@ -46,7 +46,7 @@ describe('scanMultiCamBatchFromFiles', () => {
   });
 
   it('attaches per-collect registration files to import args', async () => {
-    const registration = JSON.stringify({ version: 1, pairs: [] });
+    const registration = JSON.stringify({ version: 2, pairs: [] });
     const files = [
       ...frames('fl01', 'EO', 3),
       ...frames('fl01', 'IR', 3),
diff --git a/client/platform/web-girder/views/Export.vue b/client/platform/web-girder/views/Export.vue
index 4e318cae0..1f774185f 100644
--- a/client/platform/web-girder/views/Export.vue
+++ b/client/platform/web-girder/views/Export.vue
@@ -264,7 +264,7 @@ export default defineComponent({
       }
       return buildPerCameraRegistrationFiles({
         homographies: ds.cameraHomographies ?? {},
-        correspondences: ds.cameraCorrespondences ?? {},
+        observations: ds.cameraCorrespondences ?? {},
         transformTypes: ds.cameraTransformTypes ?? {},
         source: ds.cameraRegistrationSource ?? null,
       }, referenceCameraName(ds.multiCamMedia));
diff --git a/client/platform/web-girder/views/Upload.vue b/client/platform/web-girder/views/Upload.vue
index 34c0e205d..f4679d3e6 100644
--- a/client/platform/web-girder/views/Upload.vue
+++ b/client/platform/web-girder/views/Upload.vue
@@ -664,7 +664,7 @@ export default defineComponent({
           setMulticamImportProgress(98, `${labelPrefix}Saving camera registration…`);
           await saveConfig(parentFolder._id, {
             cameraHomographies: registrationSeed.values.homographies,
-            cameraCorrespondences: registrationSeed.values.correspondences,
+            cameraCorrespondences: registrationSeed.values.observations,
             cameraTransformTypes: registrationSeed.values.transformTypes,
             ...(registrationSeed.values.source
               ? { cameraRegistrationSource: registrationSeed.values.source }
diff --git a/client/src/CameraStore.ts b/client/src/CameraStore.ts
index ca1e1dd8f..aa856b9e0 100644
--- a/client/src/CameraStore.ts
+++ b/client/src/CameraStore.ts
@@ -1,5 +1,5 @@
 import {
-  ComputedRef, Ref, computed, shallowRef, triggerRef,
+  ComputedRef, Ref, computed, ref, shallowRef, triggerRef,
 } from 'vue';
 import { cloneDeep, uniq } from 'lodash';
 import {
@@ -68,11 +68,25 @@ export default class CameraStore {
 
   private projectionCache: Map<AnnotationId, ComputedRef<TrackProjection | null>>;
 
+  /**
+   * The dataset's persisted camera display order (multiCamMedia.cameraOrder,
+   * via orderedMultiCamCameraNames), set by the viewer at load.
+   *
+   * camMap's own key order is insertion order: cameras are added one at a
+   * time inside an awaited per-camera load loop, and entries can survive a
+   * dataset switch, so it is not a dependable statement of rig order. Anything
+   * where "which camera is first/last" carries meaning -- the registration
+   * reference camera, the direction a loop-closure residual is measured in --
+   * must read this instead.
+   */
+  displayOrder: Ref<string[]>;
+
   constructor({ markChangesPending }: { markChangesPending: MarkChangesPending }) {
     this.markChangesPending = markChangesPending;
     const cameraName = 'singleCam';
     this.defaultGroup = ['no-group', 1.0];
     this.projectionCache = new Map();
+    this.displayOrder = ref([]);
     this.camMap = shallowRef(new Map([[cameraName, {
       trackStore: new TrackStore({ markChangesPending, cameraName }),
       groupStore: new GroupStore({ markChangesPending, cameraName }),
@@ -224,6 +238,17 @@ export default class CameraStore {
     };
   }
 
+  /**
+   * Camera names in persisted display order, restricted to cameras actually
+   * present. Falls back to camMap order when no order has been set (single
+   * camera datasets, or before the viewer has loaded one).
+   */
+  orderedCameraNames(): string[] {
+    const present = this.camMap.value;
+    const ordered = this.displayOrder.value.filter((name) => present.has(name));
+    return ordered.length === present.size ? ordered : [...present.keys()];
+  }
+
   addCamera(cameraName: string) {
     if (this.camMap.value.get(cameraName) === undefined) {
       this.camMap.value.set(cameraName, {
diff --git a/client/src/alignedView/AlignedViewStore.ts b/client/src/alignedView/AlignedViewStore.ts
index 0053e0ab2..9d1348ec8 100644
--- a/client/src/alignedView/AlignedViewStore.ts
+++ b/client/src/alignedView/AlignedViewStore.ts
@@ -47,7 +47,7 @@ export default class AlignedViewStore {
    * reference space, out of all loaded cameras. Maintained by the viewer
    * alongside {@link setTransforms}; null for single-camera datasets. Lets
    * UI outside the viewer core (e.g. the import menu) show the same
-   * "N/M cameras registered" status as the Align View toggle without
+   * "N/M cameras ready" status as the Align View toggle without
    * re-deriving the pair graph.
    */
   registrationProgress: Ref<{ registered: number; total: number } | null>;
diff --git a/client/src/alignedView/CameraRegistrationStore.spec.ts b/client/src/alignedView/CameraRegistrationStore.spec.ts
index 47b4d2b2b..958f2e93e 100644
--- a/client/src/alignedView/CameraRegistrationStore.spec.ts
+++ b/client/src/alignedView/CameraRegistrationStore.spec.ts
@@ -1,5 +1,7 @@
 /// <reference types="vitest" />
-import CameraRegistrationStore, { CameraCorrespondences } from './CameraRegistrationStore';
+import CameraRegistrationStore, {
+  CorrespondencePoint, FrameResolver,
+} from './CameraRegistrationStore';
 import { buildPerCameraRegistrationFiles } from './cameraRegistrationFiles';
 
 /**
@@ -10,7 +12,7 @@ import { buildPerCameraRegistrationFiles } from './cameraRegistrationFiles';
 function toSingleFileJson(store: CameraRegistrationStore): string {
   const files = buildPerCameraRegistrationFiles({
     homographies: store.homographies.value,
-    correspondences: store.correspondences.value,
+    observations: store.observations.value,
     transformTypes: store.transformTypes.value,
     source: store.source.value,
   }, null);
@@ -18,6 +20,28 @@ function toSingleFileJson(store: CameraRegistrationStore): string {
   return JSON.stringify(files[0].body);
 }
 
+/** All of a pair's points pooled across observations (any enabled state). */
+function pointsFor(store: CameraRegistrationStore, key: string): CorrespondencePoint[] {
+  return store.observationsForPair(key).flatMap((obs) => obs.points);
+}
+
+/**
+ * A resolver over fixed per-camera image lists, pinned to a settable
+ * current frame -- the shape the viewer publishes in production.
+ */
+function makeResolver(
+  images: Record<string, string[]>,
+  current: { frame: number },
+): FrameResolver {
+  return {
+    currentImageName: (camera: string) => images[camera]?.[current.frame] ?? null,
+    frameForImage: (camera: string, imageName: string) => {
+      const index = (images[camera] ?? []).indexOf(imageName);
+      return index >= 0 ? index : null;
+    },
+  };
+}
+
 describe('CameraRegistrationStore', () => {
   it('produces a directional pairKey that preserves left/right order', () => {
     const store = new CameraRegistrationStore();
@@ -53,11 +77,11 @@ describe('CameraRegistrationStore', () => {
     const key = store.pairKey('left', 'right');
     store.addPoint('left', [10, 20]); // pending (blue)
     expect(store.pendingPoint.value).not.toBeNull();
-    expect(store.correspondences.value[key]).toBeUndefined();
+    expect(pointsFor(store, key)).toHaveLength(0);
     store.addPoint('right', [30, 40]); // completes (red)
     expect(store.pendingPoint.value).toBeNull();
-    expect(store.correspondences.value[key]).toHaveLength(1);
-    expect(store.correspondences.value[key][0]).toMatchObject({ a: [10, 20], b: [30, 40] });
+    expect(pointsFor(store, key)).toHaveLength(1);
+    expect(pointsFor(store, key)[0]).toMatchObject({ a: [10, 20], b: [30, 40] });
   });
 
   it('maps points to a/b by camera regardless of click order', () => {
@@ -66,7 +90,7 @@ describe('CameraRegistrationStore', () => {
     const key = store.pairKey('left', 'right');
     store.addPoint('right', [30, 40]); // click right first
     store.addPoint('left', [10, 20]);
-    expect(store.correspondences.value[key][0]).toMatchObject({ a: [10, 20], b: [30, 40] });
+    expect(pointsFor(store, key)[0]).toMatchObject({ a: [10, 20], b: [30, 40] });
   });
 
   it('replaces the pending point when the same camera is clicked twice', () => {
@@ -90,9 +114,9 @@ describe('CameraRegistrationStore', () => {
     const key = store.pairKey('left', 'right');
     store.addPoint('left', [1, 1]);
     store.addPoint('right', [2, 2]);
-    const { id } = store.correspondences.value[key][0];
+    const { id } = pointsFor(store, key)[0];
     store.removeCorrespondence(id);
-    expect(store.correspondences.value[key]).toHaveLength(0);
+    expect(pointsFor(store, key)).toHaveLength(0);
   });
 
   it('moves one side of a correspondence via updateCorrespondencePoint', () => {
@@ -101,12 +125,12 @@ describe('CameraRegistrationStore', () => {
     const key = store.pairKey('left', 'right');
     store.addPoint('left', [1, 1]);
     store.addPoint('right', [2, 2]);
-    const { id } = store.correspondences.value[key][0];
+    const { id } = pointsFor(store, key)[0];
     store.updateCorrespondencePoint(id, 'left', [5, 6]);
-    expect(store.correspondences.value[key][0].a).toEqual([5, 6]);
-    expect(store.correspondences.value[key][0].b).toEqual([2, 2]);
+    expect(pointsFor(store, key)[0].a).toEqual([5, 6]);
+    expect(pointsFor(store, key)[0].b).toEqual([2, 2]);
     store.updateCorrespondencePoint(id, 'right', [7, 8]);
-    expect(store.correspondences.value[key][0].b).toEqual([7, 8]);
+    expect(pointsFor(store, key)[0].b).toEqual([7, 8]);
   });
 
   it('ignores updateCorrespondencePoint for unknown ids or cameras outside the pair', () => {
@@ -115,10 +139,10 @@ describe('CameraRegistrationStore', () => {
     const key = store.pairKey('left', 'right');
     store.addPoint('left', [1, 1]);
     store.addPoint('right', [2, 2]);
-    const { id } = store.correspondences.value[key][0];
+    const { id } = pointsFor(store, key)[0];
     store.updateCorrespondencePoint(id + 99, 'left', [5, 6]);
     store.updateCorrespondencePoint(id, 'other', [5, 6]);
-    expect(store.correspondences.value[key][0]).toMatchObject({ a: [1, 1], b: [2, 2] });
+    expect(pointsFor(store, key)[0]).toMatchObject({ a: [1, 1], b: [2, 2] });
   });
 
   it('refits the pair homography when a point is drag-refined while alignment is active', () => {
@@ -128,7 +152,7 @@ describe('CameraRegistrationStore', () => {
     addFourTranslationPairs(store);
     store.setAlignmentMode('AtoB');
     const before = store.homographies.value[key].AtoB[0][2];
-    const { id } = store.correspondences.value[key][0];
+    const { id } = pointsFor(store, key)[0];
     store.updateCorrespondencePoint(id, 'right', [40, 40]);
     expect(store.homographies.value[key].AtoB[0][2]).not.toBeCloseTo(before, 5);
   });
@@ -267,12 +291,12 @@ describe('CameraRegistrationStore', () => {
     const key = store.pairKey('left', 'right');
     addFourTranslationPairs(store);
     store.setAlignmentMode('AtoB');
-    const { id } = store.correspondences.value[key][0];
+    const { id } = pointsFor(store, key)[0];
     store.removeCorrespondence(id);
-    store.removeCorrespondence(store.correspondences.value[key][0].id);
-    store.removeCorrespondence(store.correspondences.value[key][0].id);
-    store.removeCorrespondence(store.correspondences.value[key][0].id);
-    expect(store.correspondences.value[key]).toHaveLength(0);
+    store.removeCorrespondence(pointsFor(store, key)[0].id);
+    store.removeCorrespondence(pointsFor(store, key)[0].id);
+    store.removeCorrespondence(pointsFor(store, key)[0].id);
+    expect(pointsFor(store, key)).toHaveLength(0);
     expect(store.alignment.value.mode).toBe('original');
     expect(store.homographies.value[key]).toBeUndefined();
   });
@@ -296,7 +320,7 @@ describe('CameraRegistrationStore', () => {
     expect(store.homographies.value).toEqual(saved);
     expect(store.activePair.value).toBeNull();
     expect(store.pendingPoint.value).toBeNull();
-    expect(store.correspondences.value).toEqual({});
+    expect(store.observations.value).toEqual({});
     expect(store.transformTypes.value).toEqual({});
     expect(store.alignment.value).toEqual({ mode: 'original', opacity: 0.5 });
   });
@@ -308,21 +332,299 @@ describe('CameraRegistrationStore', () => {
     expect(store.transformTypeForPair('unset::pair')).toBe('similarity');
   });
 
-  it('hydrates correspondences and resumes id allocation', () => {
+  it('hydrates observations and resumes id allocation', () => {
     const store = new CameraRegistrationStore();
-    const correspondences: CameraCorrespondences = {
-      'rgb::ir': [
-        { id: 1, a: [1, 2], b: [3, 4] },
-        { id: 2, a: [5, 6], b: [7, 8] },
-      ],
+    const observations = {
+      'rgb::ir': [{
+        imageA: 'rgb_0001.jpg',
+        imageB: 'ir_0001.tif',
+        frame: 1,
+        enabled: true,
+        source: 'manual',
+        points: [
+          { id: 1, a: [1, 2] as [number, number], b: [3, 4] as [number, number] },
+          { id: 2, a: [5, 6] as [number, number], b: [7, 8] as [number, number] },
+        ],
+      }],
     };
-    store.hydrate({}, correspondences);
-    expect(store.correspondences.value).toEqual(correspondences);
+    store.hydrate({}, observations);
+    expect(store.observations.value).toEqual(observations);
     // New points pick up after the highest restored id.
     store.setActivePair('rgb', 'ir');
     store.addPoint('rgb', [9, 9]);
     store.addPoint('ir', [10, 10]);
-    expect(store.correspondences.value['rgb::ir'][2].id).toBe(3);
+    expect(pointsFor(store, 'rgb::ir')[2].id).toBe(3);
+  });
+
+  describe('observation identity', () => {
+    it('stamps new points with the current image pair and manual provenance', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('left', 'right');
+      const key = store.pairKey('left', 'right');
+      store.addPoint('left', [1, 1]);
+      store.addPoint('right', [2, 2]);
+      const [obs] = store.observationsForPair(key);
+      // Without a resolver, frames identify via frame:// pseudo-names.
+      expect(obs).toMatchObject({
+        imageA: 'frame://0',
+        imageB: 'frame://0',
+        frame: 0,
+        enabled: true,
+        source: 'manual',
+      });
+    });
+
+    it('groups points picked on different frames into separate observations', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('left', 'right');
+      const key = store.pairKey('left', 'right');
+      store.addPoint('left', [1, 1]);
+      store.addPoint('right', [2, 2]);
+      store.currentFrame.value = 100;
+      store.addPoint('left', [3, 3]);
+      store.addPoint('right', [4, 4]);
+      const observations = store.observationsForPair(key);
+      expect(observations).toHaveLength(2);
+      expect(observations.map((obs) => obs.frame)).toEqual([0, 100]);
+      expect(observations.every((obs) => obs.points.length === 1)).toBe(true);
+    });
+
+    it('stamps real image names and resolves frames through the resolver', () => {
+      const store = new CameraRegistrationStore();
+      const current = { frame: 2 };
+      store.setFrameResolver(makeResolver({
+        left: ['l0.jpg', 'l1.jpg', 'l2.jpg'],
+        right: ['r0.tif', 'r1.tif', 'r2.tif'],
+      }, current));
+      store.currentFrame.value = 2;
+      store.setActivePair('left', 'right');
+      const key = store.pairKey('left', 'right');
+      store.addPoint('left', [1, 1]);
+      store.addPoint('right', [2, 2]);
+      const [obs] = store.observationsForPair(key);
+      expect(obs).toMatchObject({
+        imageA: 'l2.jpg', imageB: 'r2.tif', frame: 2, source: 'manual',
+      });
+    });
+
+    it('re-resolves frames from image names when a resolver is published', () => {
+      const store = new CameraRegistrationStore();
+      store.hydrate({}, {
+        'left::right': [{
+          imageA: 'l1.jpg',
+          imageB: 'r1.tif',
+          // A stale index from another deployment must not survive: the
+          // image NAME is the identity.
+          frame: 999,
+          enabled: true,
+          source: 'manual',
+          points: [{ id: 1, a: [0, 0], b: [0, 0] }],
+        }, {
+          imageA: 'other_deployment.jpg',
+          imageB: 'other_deployment.tif',
+          frame: 3,
+          enabled: true,
+          source: 'manual',
+          points: [{ id: 2, a: [0, 0], b: [0, 0] }],
+        }],
+      });
+      const current = { frame: 0 };
+      store.setFrameResolver(makeResolver({
+        left: ['l0.jpg', 'l1.jpg'],
+        right: ['r0.tif', 'r1.tif'],
+      }, current));
+      const observations = store.observationsForPair('left::right');
+      expect(observations[0].frame).toBe(1);
+      // Not in this dataset: unresolvable here, not a guess.
+      expect(observations[1].frame).toBeNull();
+      // Frame resolution is derived state, not an edit.
+      expect(store.dirty.value).toBe(false);
+    });
+
+    it('scopes correspondencesForFrame to one frame and carries identity', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('left', 'right');
+      const key = store.pairKey('left', 'right');
+      store.addPoint('left', [1, 1]);
+      store.addPoint('right', [2, 2]);
+      store.currentFrame.value = 7;
+      store.addPoint('left', [3, 3]);
+      store.addPoint('right', [4, 4]);
+      expect(store.correspondencesForFrame(key, 0)).toHaveLength(1);
+      const [c] = store.correspondencesForFrame(key, 7);
+      expect(c).toMatchObject({
+        a: [3, 3], b: [4, 4], frame: 7, source: 'manual',
+      });
+      expect(store.correspondencesForFrame(key, 5)).toHaveLength(0);
+    });
+
+    it('resolves correspondencesForCameraFrame per side in each camera frame space', () => {
+      const store = new CameraRegistrationStore();
+      const current = { frame: 0 };
+      // right's media list is offset by one against left's.
+      store.setFrameResolver(makeResolver({
+        left: ['l0.jpg', 'l1.jpg', 'l2.jpg'],
+        right: ['pad.tif', 'r0.tif', 'r1.tif'],
+      }, current));
+      store.hydrate({}, {
+        'left::right': [{
+          imageA: 'l1.jpg',
+          imageB: 'r1.tif',
+          frame: 1,
+          enabled: true,
+          source: 'manual',
+          points: [{ id: 1, a: [0, 0], b: [0, 0] }],
+        }],
+      });
+      const key = 'left::right';
+      // The A side matches left's local frame 1...
+      expect(store.correspondencesForCameraFrame(key, 'left', 1)).toHaveLength(1);
+      expect(store.correspondencesForCameraFrame(key, 'left', 2)).toHaveLength(0);
+      // ...while the B side matches right's own local index for r1.tif (2).
+      expect(store.correspondencesForCameraFrame(key, 'right', 2)).toHaveLength(1);
+      expect(store.correspondencesForCameraFrame(key, 'right', 1)).toHaveLength(0);
+    });
+
+    it('lists framesForPair sorted by frame with unresolved rows last', () => {
+      const store = new CameraRegistrationStore();
+      store.hydrate({}, {
+        'left::right': [
+          {
+            imageA: 'zz-unresolved.jpg', imageB: 'x.tif', frame: null, enabled: true, source: 'manual', points: [],
+          },
+          {
+            imageA: 'b.jpg', imageB: 'b.tif', frame: 10, enabled: false, source: 'minima_loftr', points: [{ id: 1, a: [0, 0], b: [0, 0] }],
+          },
+          {
+            imageA: 'a.jpg', imageB: 'a.tif', frame: 2, enabled: true, source: 'manual', points: [{ id: 2, a: [0, 0], b: [0, 0] }],
+          },
+        ],
+      });
+      const rows = store.framesForPair('left::right');
+      expect(rows.map((row) => row.frame)).toEqual([2, 10, null]);
+      expect(rows[1]).toMatchObject({ enabled: false, source: 'minima_loftr', count: 1 });
+    });
+  });
+
+  describe('enabled observations and pooled fitting', () => {
+    /** Two frames of translation-consistent points, one frame corrupted. */
+    function storeWithGoodAndBadFrames() {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('left', 'right');
+      const key = store.pairKey('left', 'right');
+      addFourTranslationPairs(store); // frame 0: +5, -3
+      store.currentFrame.value = 10; // frame 10: consistent with frame 0
+      ([[20, 20], [30, 20], [30, 30], [20, 30]] as [number, number][]).forEach((p) => {
+        store.addPoint('left', p);
+        store.addPoint('right', [p[0] + 5, p[1] - 3]);
+      });
+      store.currentFrame.value = 20; // frame 20: corrupted (offset +50, +50)
+      ([[40, 40], [50, 40], [50, 50], [40, 50]] as [number, number][]).forEach((p) => {
+        store.addPoint('left', p);
+        store.addPoint('right', [p[0] + 50, p[1] + 50]);
+      });
+      return { store, key };
+    }
+
+    it('pools points across every enabled observation for the fit', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('left', 'right');
+      const key = store.pairKey('left', 'right');
+      // Two frames with two points each: neither alone can fit a homography,
+      // pooled they can.
+      store.addPoint('left', [0, 0]);
+      store.addPoint('right', [5, -3]);
+      store.addPoint('left', [10, 0]);
+      store.addPoint('right', [15, -3]);
+      store.currentFrame.value = 5;
+      store.addPoint('left', [10, 10]);
+      store.addPoint('right', [15, 7]);
+      store.addPoint('left', [0, 10]);
+      store.addPoint('right', [5, 7]);
+      expect(store.observationsForPair(key)).toHaveLength(2);
+      const { AtoB } = store.fitTransform(key);
+      expect(AtoB[0][2]).toBeCloseTo(5, 5);
+      expect(AtoB[1][2]).toBeCloseTo(-3, 5);
+    });
+
+    it('excludes disabled observations from the fit without deleting points', () => {
+      const { store, key } = storeWithGoodAndBadFrames();
+      store.setFrameEnabled(key, 20, false);
+      const { AtoB } = store.homographies.value[key];
+      // With the corrupted frame excluded, the consensus translation returns.
+      expect(AtoB[0][2]).toBeCloseTo(5, 3);
+      expect(AtoB[1][2]).toBeCloseTo(-3, 3);
+      // The points survive, disabled.
+      const disabled = store.observationsForPair(key).find((obs) => obs.frame === 20);
+      expect(disabled?.enabled).toBe(false);
+      expect(disabled?.points).toHaveLength(4);
+      // Re-enabling refits with them again.
+      store.setFrameEnabled(key, 20, true);
+      expect(store.homographies.value[key].AtoB[0][2]).not.toBeCloseTo(5, 3);
+    });
+
+    it('reports per-observation agreement with the pooled fit via pairFitStats', () => {
+      const { store, key } = storeWithGoodAndBadFrames();
+      store.setFrameEnabled(key, 20, false);
+      const stats = store.pairFitStats(key);
+      expect(stats.frameCount).toBe(2);
+      expect(stats.pointCount).toBe(8);
+      expect(stats.rmsPx).toBeLessThan(1e-6);
+      const byFrame = new Map(stats.perObservation.map((obs) => [obs.frame, obs]));
+      // The two consistent frames agree with the consensus...
+      expect(byFrame.get(0)?.rmsPx).toBeLessThan(1e-6);
+      expect(byFrame.get(10)?.rmsPx).toBeLessThan(1e-6);
+      // ...and the corrupted frame's disagreement is measured, visibly large,
+      // even while excluded.
+      expect(byFrame.get(20)?.enabled).toBe(false);
+      expect(byFrame.get(20)?.rmsPx).toBeGreaterThan(10);
+    });
+
+    it('setObservationEnabled targets a single observation by image pair', () => {
+      const { store, key } = storeWithGoodAndBadFrames();
+      const bad = store.observationsForPair(key).find((obs) => obs.frame === 20);
+      expect(bad).toBeDefined();
+      store.setObservationEnabled(key, bad!.imageA, bad!.imageB, false);
+      expect(store.observationsForPair(key).find((obs) => obs.frame === 20)?.enabled).toBe(false);
+      expect(store.observationsForPair(key).filter((obs) => obs.enabled)).toHaveLength(2);
+    });
+
+    it('clearFrame removes one frame\'s observations and refits', () => {
+      const { store, key } = storeWithGoodAndBadFrames();
+      store.clearFrame(key, 20);
+      expect(store.observationsForPair(key)).toHaveLength(2);
+      expect(store.homographies.value[key].AtoB[0][2]).toBeCloseTo(5, 3);
+    });
+
+    it('removeObservation restricted by source leaves other producers alone', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('left', 'right');
+      const key = store.pairKey('left', 'right');
+      store.addPoint('left', [1, 1]);
+      store.addPoint('right', [2, 2]);
+      store.applyRegistrationResult('left', 'right', [{
+        source: 'minima_loftr',
+        points: [[0, 0, 5, -3], [10, 0, 15, -3], [10, 10, 15, 7], [0, 10, 5, 7]],
+      }]);
+      expect(store.observationsForPair(key)).toHaveLength(2);
+      const matcher = store.observationsForPair(key).find((obs) => obs.source === 'minima_loftr');
+      store.removeObservation(key, matcher!.imageA, matcher!.imageB, 'minima_loftr');
+      const remaining = store.observationsForPair(key);
+      expect(remaining).toHaveLength(1);
+      expect(remaining[0].source).toBe('manual');
+    });
+
+    it('maybeFitPair counts only enabled points toward the minimum', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('left', 'right');
+      const key = store.pairKey('left', 'right');
+      addFourTranslationPairs(store);
+      store.maybeFitPair(key);
+      expect(store.homographies.value[key]).toBeDefined();
+      store.setFrameEnabled(key, 0, false);
+      // All points disabled: below the minimum, the fit clears.
+      expect(store.homographies.value[key]).toBeUndefined();
+    });
   });
 
   describe('transform type selection', () => {
@@ -384,7 +686,7 @@ describe('CameraRegistrationStore', () => {
       store.pickPoint('right', [15, 7]);
       // The warp mode blocks new picks; nothing is pending and the pairs are unchanged.
       expect(store.pendingPoint.value).toBeNull();
-      expect(store.correspondences.value[store.pairKey('left', 'right')]).toHaveLength(4);
+      expect(pointsFor(store, store.pairKey('left', 'right'))).toHaveLength(4);
     });
   });
 
@@ -395,7 +697,7 @@ describe('CameraRegistrationStore', () => {
       store.addPoint('left', [1, 1]);
       store.addPoint('right', [2, 2]);
       const key = store.pairKey('left', 'right');
-      const { id } = store.correspondences.value[key][0];
+      const { id } = pointsFor(store, key)[0];
       return { store, key, id };
     }
 
@@ -414,11 +716,11 @@ describe('CameraRegistrationStore', () => {
       const { store, key, id } = storeWithOnePair();
       store.selectCorrespondence(id);
       store.removeSelectedCorrespondence();
-      expect(store.correspondences.value[key]).toHaveLength(0);
+      expect(pointsFor(store, key)).toHaveLength(0);
       expect(store.selectedCorrespondenceId.value).toBeNull();
       // No selection: a further call is a no-op.
       store.removeSelectedCorrespondence();
-      expect(store.correspondences.value[key]).toHaveLength(0);
+      expect(pointsFor(store, key)).toHaveLength(0);
     });
 
     it('clears the selection when the selected pair is removed, undone, or the pair switches', () => {
@@ -446,7 +748,7 @@ describe('CameraRegistrationStore', () => {
 
       const loaded = storeWithOnePair();
       loaded.store.selectCorrespondence(loaded.id);
-      loaded.store.loadRegistrationText(JSON.stringify({ version: 1, pairs: [] }));
+      loaded.store.loadRegistrationText(JSON.stringify({ version: 2, pairs: [] }));
       expect(loaded.store.selectedCorrespondenceId.value).toBeNull();
 
       const hydrated = storeWithOnePair();
@@ -511,7 +813,7 @@ describe('CameraRegistrationStore', () => {
       store.addPoint('left', [3, 3]); // pending
       store.clearLast();
       expect(store.pendingPoint.value).toBeNull();
-      expect(store.correspondences.value[key]).toHaveLength(1);
+      expect(pointsFor(store, key)).toHaveLength(1);
     });
 
     it('removes the last completed correspondence when there is no pending point', () => {
@@ -523,8 +825,24 @@ describe('CameraRegistrationStore', () => {
       store.addPoint('left', [3, 3]);
       store.addPoint('right', [4, 4]);
       store.clearLast();
-      expect(store.correspondences.value[key]).toHaveLength(1);
-      expect(store.correspondences.value[key][0]).toMatchObject({ a: [1, 1], b: [2, 2] });
+      expect(pointsFor(store, key)).toHaveLength(1);
+      expect(pointsFor(store, key)[0]).toMatchObject({ a: [1, 1], b: [2, 2] });
+    });
+
+    it('acts on the current frame only', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('left', 'right');
+      const key = store.pairKey('left', 'right');
+      store.addPoint('left', [1, 1]);
+      store.addPoint('right', [2, 2]);
+      store.currentFrame.value = 5;
+      store.addPoint('left', [3, 3]);
+      store.addPoint('right', [4, 4]);
+      // Back on frame 0: undo removes frame 0's point, not frame 5's newer one.
+      store.currentFrame.value = 0;
+      store.clearLast();
+      expect(store.correspondencesForFrame(key, 0)).toHaveLength(0);
+      expect(store.correspondencesForFrame(key, 5)).toHaveLength(1);
     });
 
     it('is a no-op with nothing to undo', () => {
@@ -543,7 +861,7 @@ describe('CameraRegistrationStore', () => {
       addFourTranslationPairs(store);
       store.setAlignmentMode('AtoB');
       store.clearLast();
-      expect(store.correspondences.value[key]).toHaveLength(3);
+      expect(pointsFor(store, key)).toHaveLength(3);
       expect(store.alignment.value.mode).toBe('original');
       expect(store.homographies.value[key]).toBeUndefined();
     });
@@ -600,12 +918,12 @@ describe('CameraRegistrationStore', () => {
     // Pure translation by (+5, -3): trivially invertible.
     const translate = [[1, 0, 5], [0, 1, -3], [0, 0, 1]];
 
-    /** Load a matrix-only (point-less) pair from calibration JSON, marking it 'loaded'. */
+    /** Load a matrix-only (observation-less) pair from a v2 file, marking it 'loaded'. */
     function loadMatrixOnlyPair(store: CameraRegistrationStore, left: string, right: string, rightToLeft: number[][]) {
       store.loadRegistrationText(JSON.stringify({
-        version: 1,
+        version: 2,
         pairs: [{
-          left, right, points: [], leftToRight: null, rightToLeft,
+          left, right, observations: [], leftToRight: null, rightToLeft,
         }],
       }));
     }
@@ -615,7 +933,7 @@ describe('CameraRegistrationStore', () => {
       store.setActivePair('left', 'right');
       const key = store.pairKey('left', 'right');
       loadMatrixOnlyPair(store, 'left', 'right', translate);
-      expect(store.correspondences.value[key]).toHaveLength(0);
+      expect(pointsFor(store, key)).toHaveLength(0);
       expect(store.isLoadedHomography(key)).toBe(true);
       const homog = store.homographies.value[key];
       expect(homog.BtoA).toEqual(translate);
@@ -683,6 +1001,30 @@ describe('CameraRegistrationStore', () => {
       expect(store.homographies.value[key]).toBeDefined();
     });
 
+    it('treats a homography backed only by DISABLED observations as loaded', () => {
+      const store = new CameraRegistrationStore();
+      const key = store.pairKey('left', 'right');
+      store.hydrate({ [key]: { AtoB: translate, BtoA: translate } }, {
+        [key]: [{
+          imageA: 'a.jpg',
+          imageB: 'b.tif',
+          frame: 0,
+          enabled: false,
+          source: 'manual',
+          points: [
+            { id: 1, a: [0, 0], b: [5, -3] },
+            { id: 2, a: [10, 0], b: [15, -3] },
+            { id: 3, a: [10, 10], b: [15, 7] },
+            { id: 4, a: [0, 10], b: [5, 7] },
+          ],
+        }],
+      });
+      // The disabled points can't back a fit, so the matrix must be file-loaded.
+      expect(store.isLoadedHomography(key)).toBe(true);
+      store.maybeFitPair(key);
+      expect(store.homographies.value[key]).toBeDefined();
+    });
+
     it('pickingDefaultFor opens loaded pairs in review posture, others authoring', () => {
       const store = new CameraRegistrationStore();
       store.setActivePair('left', 'right');
@@ -726,7 +1068,7 @@ describe('CameraRegistrationStore', () => {
       expect(store.hasSavedRegistration()).toBe(true);
     });
 
-    it('treats leftover empty correspondence lists as no registration', () => {
+    it('treats leftover empty observation lists as no registration', () => {
       const store = new CameraRegistrationStore();
       const key = store.pairKey('left', 'right');
       store.hydrate({}, { [key]: [] }, {});
@@ -734,6 +1076,144 @@ describe('CameraRegistrationStore', () => {
     });
   });
 
+  describe('applyRegistrationResult', () => {
+    // A pure translation by (5, -3), as [ax, ay, bx, by] matcher-style rows.
+    const inliers: [number, number, number, number][] = [
+      [0, 0, 5, -3], [10, 0, 15, -3], [10, 10, 15, 7], [0, 10, 5, 7],
+      [5, 5, 10, 2],
+    ];
+
+    it('injects observations with matcher provenance and fits a homography', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('rgb', 'ir');
+      const key = store.pairKey('rgb', 'ir');
+      expect(store.pickingEnabled.value).toBe(false);
+      store.applyRegistrationResult('rgb', 'ir', [{ source: 'minima_loftr', points: inliers }]);
+      // Picking turns on so the injected points are visible for review.
+      expect(store.pickingEnabled.value).toBe(true);
+      expect(pointsFor(store, key)).toHaveLength(5);
+      const [obs] = store.observationsForPair(key);
+      // Provenance rides on the observation, not the rig-global source stamp.
+      expect(obs.source).toBe('minima_loftr');
+      expect(obs.enabled).toBe(true);
+      expect(store.transformTypes.value[key]).toBe('homography');
+      const { AtoB } = store.homographies.value[key];
+      expect(AtoB[0][2]).toBeCloseTo(5, 5);
+      expect(AtoB[1][2]).toBeCloseTo(-3, 5);
+      expect(store.fitError.value).toBeNull();
+      expect(store.dirty.value).toBe(true);
+    });
+
+    it('carries explicit image identities, stats, and enabled state', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('rgb', 'ir');
+      const key = store.pairKey('rgb', 'ir');
+      store.applyRegistrationResult('rgb', 'ir', [{
+        imageA: 'rgb_0412.jpg',
+        imageB: 'ir_0412.tif',
+        source: 'minima_loftr',
+        stats: { numMatches: 1840, numInliers: 24 },
+        points: inliers,
+      }, {
+        imageA: 'rgb_2600.jpg',
+        imageB: 'ir_2600.tif',
+        enabled: false,
+        source: 'minima_loftr',
+        stats: { skipped: 'low_texture' },
+        points: [],
+      }]);
+      const observations = store.observationsForPair(key);
+      expect(observations).toHaveLength(2);
+      expect(observations[0]).toMatchObject({
+        imageA: 'rgb_0412.jpg',
+        stats: { numMatches: 1840, numInliers: 24 },
+      });
+      // The rejected candidate is kept, disabled, with its reason.
+      expect(observations[1]).toMatchObject({
+        enabled: false, stats: { skipped: 'low_texture' },
+      });
+      // Only the enabled observation feeds the fit.
+      expect(store.homographies.value[key].AtoB[0][2]).toBeCloseTo(5, 5);
+    });
+
+    it('merges at observation granularity: replaces its own prior result, keeps manual work', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('rgb', 'ir');
+      const key = store.pairKey('rgb', 'ir');
+      // Hand-picked observation on the current (frame://0) image pair.
+      store.addPoint('rgb', [1, 1]);
+      store.addPoint('ir', [2, 2]);
+      // First matcher run on a specific image pair.
+      store.applyRegistrationResult('rgb', 'ir', [{
+        imageA: 'rgb_0412.jpg', imageB: 'ir_0412.tif', source: 'minima_loftr', points: inliers,
+      }]);
+      expect(store.observationsForPair(key)).toHaveLength(2);
+      // Re-running the matcher on the same image pair REPLACES its result...
+      store.applyRegistrationResult('rgb', 'ir', [{
+        imageA: 'rgb_0412.jpg',
+        imageB: 'ir_0412.tif',
+        source: 'minima_loftr',
+        points: inliers.slice(0, 4),
+      }]);
+      const observations = store.observationsForPair(key);
+      expect(observations).toHaveLength(2);
+      const matcher = observations.find((obs) => obs.source === 'minima_loftr');
+      expect(matcher?.points).toHaveLength(4);
+      // ...while the manual observation survives untouched.
+      const manual = observations.find((obs) => obs.source === 'manual');
+      expect(manual?.points).toHaveLength(1);
+    });
+
+    it('leaves the rig-global source stamp untouched', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('rgb', 'ir');
+      // A producer stamp from a loaded registration: rig-global, so a
+      // single pair's auto-register must not restamp it (that would rewrite
+      // every camera's file on the next save, not just this pair's).
+      const producer = { model: 'N56RF', flight: 'dataset_1' };
+      store.source.value = { ...producer };
+      store.applyRegistrationResult('rgb', 'ir', [{ source: 'minima_loftr', points: inliers }]);
+      expect(store.source.value).toEqual(producer);
+      // And with no loaded registration, none appears.
+      const fresh = new CameraRegistrationStore();
+      fresh.setActivePair('rgb', 'ir');
+      fresh.applyRegistrationResult('rgb', 'ir', [{ source: 'minima_loftr', points: inliers }]);
+      expect(fresh.source.value).toBeNull();
+    });
+
+    it('clears authoring state and keeps injected points editable', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('rgb', 'ir');
+      const key = store.pairKey('rgb', 'ir');
+      store.addPoint('rgb', [1, 1]);
+      store.addPoint('ir', [2, 2]);
+      store.selectCorrespondence(pointsFor(store, key)[0].id);
+      store.addPoint('rgb', [3, 3]); // pending
+      store.applyRegistrationResult('rgb', 'ir', [{ source: 'minima_loftr', points: inliers }]);
+      expect(store.pendingPoint.value).toBeNull();
+      expect(store.selectedCorrespondenceId.value).toBeNull();
+      // Injected points are ordinary correspondences: editable like picked ones.
+      const matcher = store.observationsForPair(key).find((obs) => obs.source === 'minima_loftr');
+      const first = matcher!.points[0];
+      store.updateCorrespondencePoint(first.id, 'rgb', [100, 100]);
+      const updated = store.observationsForPair(key).find((obs) => obs.source === 'minima_loftr');
+      expect(updated!.points[0].a).toEqual([100, 100]);
+    });
+
+    it('surfaces a fitError instead of throwing on degenerate inliers', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('rgb', 'ir');
+      const key = store.pairKey('rgb', 'ir');
+      // All points collinear: enough rows for a homography but unsolvable.
+      const degenerate: [number, number, number, number][] = [
+        [0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3],
+      ];
+      store.applyRegistrationResult('rgb', 'ir', [{ source: 'minima_loftr', points: degenerate }]);
+      expect(pointsFor(store, key)).toHaveLength(4);
+      expect(store.fitError.value).not.toBeNull();
+    });
+  });
+
   describe('registration file round trip', () => {
     it('serializes and reloads all pairs', () => {
       const store = new CameraRegistrationStore();
@@ -749,20 +1229,138 @@ describe('CameraRegistrationStore', () => {
       const result = restored.loadRegistrationText(json);
       expect(result.pairCount).toBe(1);
       expect(result.cameras.sort()).toEqual(['left', 'right']);
-      expect(restored.correspondences.value[key]).toHaveLength(4);
+      expect(pointsFor(restored, key)).toHaveLength(4);
       expect(restored.transformTypeForPair(key)).toBe('translation');
       expect(restored.homographies.value[key].AtoB[0][2]).toBeCloseTo(5);
       // Enough points back the homography, so it is treated as fitted.
       expect(restored.isLoadedHomography(key)).toBe(false);
     });
 
+    it('round-trips observation identity, enabled state, provenance, and stats', () => {
+      const store = new CameraRegistrationStore();
+      store.setActivePair('left', 'right');
+      const key = store.pairKey('left', 'right');
+      store.applyRegistrationResult('left', 'right', [{
+        imageA: 'l_0412.jpg',
+        imageB: 'r_0412.tif',
+        source: 'minima_loftr',
+        stats: { numInliers: 4, rmsPx: 1.2 },
+        points: [[0, 0, 5, -3], [10, 0, 15, -3], [10, 10, 15, 7], [0, 10, 5, 7]],
+      }, {
+        imageA: 'l_2600.jpg',
+        imageB: 'r_2600.tif',
+        enabled: false,
+        source: 'minima_loftr',
+        stats: { skipped: 'low_texture', textureScore: 3.1 },
+        points: [],
+      }]);
+      const body = JSON.parse(toSingleFileJson(store));
+      expect(body.version).toBe(2);
+      // Points live ONLY in observations: no flattened duplicate.
+      expect(body.pairs[0].points).toBeUndefined();
+      expect(body.pairs[0].observations).toHaveLength(2);
+      expect(body.pairs[0].observations[0]).toMatchObject({
+        imageLeft: 'l_0412.jpg',
+        imageRight: 'r_0412.tif',
+        enabled: true,
+        source: 'minima_loftr',
+        stats: { numInliers: 4, rmsPx: 1.2 },
+      });
+      expect(body.pairs[0].observations[0].points).toHaveLength(4);
+      expect(body.pairs[0].observations[1]).toMatchObject({
+        enabled: false,
+        stats: { skipped: 'low_texture', textureScore: 3.1 },
+        points: [],
+      });
+
+      const restored = new CameraRegistrationStore();
+      restored.loadRegistrationText(JSON.stringify(body));
+      const observations = restored.observationsForPair(key);
+      expect(observations).toHaveLength(2);
+      expect(observations[0]).toMatchObject({
+        imageA: 'l_0412.jpg', imageB: 'r_0412.tif', source: 'minima_loftr', enabled: true,
+      });
+      expect(observations[1]).toMatchObject({
+        enabled: false, stats: { skipped: 'low_texture', textureScore: 3.1 },
+      });
+    });
+
+    it('accepts a producer observation without a frame (names are the identity)', () => {
+      const store = new CameraRegistrationStore();
+      const result = store.loadRegistrationText(JSON.stringify({
+        version: 2,
+        pairs: [{
+          left: 'eo',
+          right: 'ir',
+          observations: [{
+            imageLeft: 'eo_0001.jpg',
+            imageRight: 'ir_0001.tif',
+            source: 'kamera-solver',
+            points: [[0, 0, 5, -3]],
+          }],
+          leftToRight: [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
+          rightToLeft: null,
+          transformType: 'translation',
+        }],
+      }));
+      expect(result.pairCount).toBe(1);
+      const key = store.pairKey('eo', 'ir');
+      const [obs] = store.observationsForPair(key);
+      // No resolver in this context: unresolved here, not a guess.
+      expect(obs.frame).toBeNull();
+      expect(obs.source).toBe('kamera-solver');
+      // The missing direction is derived by inversion.
+      expect(store.homographies.value[key].BtoA[0][2]).toBeCloseTo(-5);
+      expect(store.transformTypeForPair(key)).toBe('translation');
+    });
+
+    it('resolves frames from image names on load when a resolver is present', () => {
+      const store = new CameraRegistrationStore();
+      const current = { frame: 0 };
+      store.setFrameResolver(makeResolver({
+        eo: ['eo_0000.jpg', 'eo_0001.jpg'],
+        ir: ['ir_0000.tif', 'ir_0001.tif'],
+      }, current));
+      store.loadRegistrationText(JSON.stringify({
+        version: 2,
+        pairs: [{
+          left: 'eo',
+          right: 'ir',
+          observations: [{
+            // The file's own (stale) frame is advisory; the name decides.
+            frame: 999,
+            imageLeft: 'eo_0001.jpg',
+            imageRight: 'ir_0001.tif',
+            points: [[0, 0, 5, -3]],
+          }],
+        }],
+      }));
+      expect(store.observationsForPair('eo::ir')[0].frame).toBe(1);
+    });
+
+    it('REJECTS any version other than 2 with a clear message', () => {
+      const store = new CameraRegistrationStore();
+      // A v1 file would otherwise load as a matrix-only pair with its points
+      // silently dropped -- indistinguishable from a real producer file.
+      expect(() => store.loadRegistrationText(JSON.stringify({
+        version: 1,
+        pairs: [{
+          left: 'a', right: 'b', points: [[0, 0, 5, -3]], leftToRight: null, rightToLeft: null,
+        }],
+      }))).toThrow(/version/i);
+      expect(() => store.loadRegistrationText(JSON.stringify({ pairs: [] })))
+        .toThrow(/version/i);
+      expect(() => store.loadRegistrationText(JSON.stringify({ version: 3, pairs: [] })))
+        .toThrow(/version/i);
+    });
+
     it('includes pairs that only have a loaded homography (no points)', () => {
       const store = new CameraRegistrationStore();
       const key = store.pairKey('uv', 'ir');
       store.loadRegistrationText(JSON.stringify({
-        version: 1,
+        version: 2,
         pairs: [{
-          left: 'uv', right: 'ir', points: [], leftToRight: [[1, 0, 5], [0, 1, -3], [0, 0, 1]], rightToLeft: null,
+          left: 'uv', right: 'ir', observations: [], leftToRight: [[1, 0, 5], [0, 1, -3], [0, 0, 1]], rightToLeft: null,
         }],
       }));
       const restored = new CameraRegistrationStore();
@@ -782,36 +1380,15 @@ describe('CameraRegistrationStore', () => {
       expect(store.activePair.value).toEqual({ camA: 'left', camB: 'right' });
     });
 
-    it('loads a desktop-persisted calibration.json (no "type" field, one direction only)', () => {
-      const store = new CameraRegistrationStore();
-      const result = store.loadRegistrationText(JSON.stringify({
-        version: 1,
-        pairs: [{
-          left: 'eo',
-          right: 'ir',
-          points: [[0, 0, 5, -3]],
-          leftToRight: [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
-          rightToLeft: null,
-          transformType: 'translation',
-        }],
-      }));
-      expect(result.pairCount).toBe(1);
-      const key = store.pairKey('eo', 'ir');
-      expect(store.correspondences.value[key]).toHaveLength(1);
-      // The missing direction is derived by inversion.
-      expect(store.homographies.value[key].BtoA[0][2]).toBeCloseTo(-5);
-      expect(store.transformTypeForPair(key)).toBe('translation');
-    });
-
     it('preserves the producer source stamp across load, refinement, and save', () => {
       const store = new CameraRegistrationStore();
       const source = { model: 'colmap-2026-07-01', swathe: 'fl07_C' };
       store.setActivePair('left', 'right');
       store.loadRegistrationText(JSON.stringify({
-        version: 1,
+        version: 2,
         source,
         pairs: [{
-          left: 'left', right: 'right', points: [], leftToRight: null, rightToLeft: [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
+          left: 'left', right: 'right', observations: [], leftToRight: null, rightToLeft: [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
         }],
       }));
       expect(store.source.value).toStrictEqual(source);
@@ -833,18 +1410,18 @@ describe('CameraRegistrationStore', () => {
     it('clears a previous stamp when loading a file without one', () => {
       const store = new CameraRegistrationStore();
       store.loadRegistrationText(JSON.stringify({
-        version: 1,
+        version: 2,
         source: { model: 'old' },
         pairs: [],
       }));
-      store.loadRegistrationText(JSON.stringify({ version: 1, pairs: [] }));
+      store.loadRegistrationText(JSON.stringify({ version: 2, pairs: [] }));
       expect(store.source.value).toBeNull();
     });
 
     it('rejects a non-object source', () => {
       const store = new CameraRegistrationStore();
       expect(() => store.loadRegistrationText(JSON.stringify({
-        version: 1, source: 'colmap', pairs: [],
+        version: 2, source: 'colmap', pairs: [],
       }))).toThrow(/"source" must be an object/);
     });
 
@@ -861,10 +1438,10 @@ describe('CameraRegistrationStore', () => {
       store.setActivePair('left', 'right');
       const key = store.pairKey('left', 'right');
       store.loadRegistrationText(JSON.stringify({
-        version: 1,
+        version: 2,
         source: { model: 'colmap-x' },
         pairs: [{
-          left: 'left', right: 'right', points: [], leftToRight: null, rightToLeft: [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
+          left: 'left', right: 'right', observations: [], leftToRight: null, rightToLeft: [[1, 0, 5], [0, 1, -3], [0, 0, 1]],
         }],
       }));
       // Fresh from the producer: loaded, not refined.
@@ -888,10 +1465,10 @@ describe('CameraRegistrationStore', () => {
       store.setActivePair('left', 'right');
       const key = store.pairKey('left', 'right');
       store.loadRegistrationText(JSON.stringify({
-        version: 1,
+        version: 2,
         source: { model: 'colmap-x' },
         pairs: [{
-          left: 'left', right: 'right', points: [], leftToRight: null, rightToLeft: [[1, 0, 100], [0, 1, 100], [0, 0, 1]],
+          left: 'left', right: 'right', observations: [], leftToRight: null, rightToLeft: [[1, 0, 100], [0, 1, 100], [0, 0, 1]],
         }],
       }));
       addFourTranslationPairs(store);
@@ -912,28 +1489,40 @@ describe('CameraRegistrationStore', () => {
       expect(() => store.loadRegistrationText('not json')).toThrow(/valid JSON/);
       expect(() => store.loadRegistrationText('{"type": "other"}')).toThrow(/pairs/);
       expect(() => store.loadRegistrationText(JSON.stringify({
-        version: 1, pairs: [{ left: 'a', right: 'a' }],
+        version: 2, pairs: [{ left: 'a', right: 'a' }],
       }))).toThrow(/distinct/);
       expect(() => store.loadRegistrationText(JSON.stringify({
-        version: 1,
+        version: 2,
         pairs: [{
           left: 'a',
           right: 'b',
-          points: [],
+          observations: [],
           leftToRight: [[1, 0], [0, 1]],
           rightToLeft: null,
         }],
       }))).toThrow(/3x3/);
       expect(() => store.loadRegistrationText(JSON.stringify({
-        version: 1,
-        pairs: [{ left: 'a', right: 'b', points: [[1, 2, 3]] }],
+        version: 2,
+        pairs: [{
+          left: 'a',
+          right: 'b',
+          observations: [{ imageLeft: 'x.jpg', imageRight: 'y.tif', points: [[1, 2, 3]] }],
+        }],
       }))).toThrow(/points row/);
       expect(() => store.loadRegistrationText(JSON.stringify({
-        version: 1,
+        version: 2,
+        pairs: [{
+          left: 'a',
+          right: 'b',
+          observations: [{ imageRight: 'y.tif', points: [] }],
+        }],
+      }))).toThrow(/imageLeft/);
+      expect(() => store.loadRegistrationText(JSON.stringify({
+        version: 2,
         pairs: [{ left: 'a', right: 'b', transformType: 'bogus' }],
       }))).toThrow(/transformType/);
       // Failed loads left the existing calibration alone.
-      expect(store.correspondences.value[key]).toHaveLength(4);
+      expect(pointsFor(store, key)).toHaveLength(4);
     });
   });
 });
diff --git a/client/src/alignedView/CameraRegistrationStore.ts b/client/src/alignedView/CameraRegistrationStore.ts
index 48ac51d18..dd033f80b 100644
--- a/client/src/alignedView/CameraRegistrationStore.ts
+++ b/client/src/alignedView/CameraRegistrationStore.ts
@@ -8,18 +8,77 @@ import {
   TransformType, TRANSFORM_TYPES, DEFAULT_TRANSFORM_TYPE, minPointsForTransform, estimateTransform,
 } from './transform';
 
-/**
- * A single picked point pair. `a` is the point in the left camera (camA), `b`
- * the point in the right camera (camB). Left/right is the order the user chose,
- * which is preserved (not alphabetized) so it survives round trips through the
- * calibration JSON's ordered `[leftX, leftY, rightX, rightY]` rows.
- */
-export interface Correspondence {
+/** Reserved {@link CorrespondenceObservation.source} value for hand-picked points. */
+export const MANUAL_SOURCE = 'manual';
+
+/** One picked/matched point pair inside an observation. `a` is the point in
+ * the left camera (camA), `b` the right camera (camB), in native pixels. */
+export interface CorrespondencePoint {
   id: number;
   a: Point;
   b: Point;
 }
 
+/**
+ * A single point pair in the flat per-point view (see
+ * {@link CameraRegistrationStore.correspondencesForFrame}). Carries its
+ * observation's identity so a point is always attributable to the image pair
+ * it was picked on.
+ */
+export interface Correspondence extends CorrespondencePoint {
+  /** The image pair this was picked on -- the persisted identity. */
+  imageA: string;
+  imageB: string;
+  /**
+   * Dataset-local frame index, RESOLVED from imageA/imageB at load time.
+   * null when the images aren't in this dataset (e.g. a rig registration
+   * carried over from another deployment) -- such points simply don't render.
+   */
+  frame: number | null;
+  /**
+   * Producer of this point: 'manual' for hand-picked, else a matcher/producer
+   * id ('minima_loftr'; KAMERA writes its own). Shared by every point in an
+   * observation -- provenance lives at observation granularity.
+   */
+  source: string;
+}
+
+/**
+ * Free-form per-observation quality statistics, written by a producer (the
+ * align_cameras pipeline reports numMatches / numInliers / inlierRatio /
+ * rmsPx / coverage / textureScore, and `skipped` with a machine-readable
+ * reason for rejected candidates). Never interpreted structurally by the
+ * store -- preserved verbatim through round trips and surfaced by the
+ * review UI.
+ */
+export type ObservationStats = Record<string, unknown>;
+
+/**
+ * A correspondence observation: the points contributed by ONE image pair of
+ * a camera pair. The image names are the identity; the frame index is
+ * derived from them at load time. This is the granularity at which
+ * provenance (`source`), the fit-inclusion toggle (`enabled`), and producer
+ * statistics live.
+ */
+export interface CorrespondenceObservation {
+  /** Image (or `frame://N` pseudo-image for video) shown by camA. */
+  imageA: string;
+  /** Image shown by camB. */
+  imageB: string;
+  /** Resolved dataset-local frame index (camA's frame space), or null. */
+  frame: number | null;
+  /** Whether this observation's points participate in the pooled fit. */
+  enabled: boolean;
+  /** Producer id: {@link MANUAL_SOURCE} or a matcher/producer name. */
+  source: string;
+  /** Producer-reported quality statistics, if any. */
+  stats?: ObservationStats;
+  points: CorrespondencePoint[];
+}
+
+/** Observations keyed by {@link CameraRegistrationStore.pairKey}. */
+export type CameraObservations = Record<string, CorrespondenceObservation[]>;
+
 /** Both directions of the fitted alignment transform for one camera pair. */
 export interface PairHomography {
   /** Maps left (camA) image coordinates onto right (camB). */
@@ -48,19 +107,35 @@ type HomographySource = 'fit' | 'loaded';
  */
 export type RegistrationSource = Record<string, unknown>;
 
+/**
+ * One observation row in the portable registration JSON file (format
+ * version 2). `imageLeft`/`imageRight` are the identity (`frame` is advisory
+ * for producers and re-resolved by DIVE on load); `points` are flattened
+ * [leftX, leftY, rightX, rightY] rows.
+ */
+export interface RegistrationFileObservation {
+  frame?: number | null;
+  imageLeft: string;
+  imageRight: string;
+  enabled?: boolean;
+  source?: string;
+  points?: number[][];
+  stats?: ObservationStats;
+}
+
 /**
  * One camera pair in the portable registration JSON file. This is the same
  * self-describing shape the desktop platform persists as the project's
  * standalone per-camera <camera>_to_<reference>_registration.json files
  * (see desktop backend/native/common.ts), so a panel-saved file, the
- * on-disk artifacts, and an import-time seed are all interchangeable:
- * correspondences flattened as [leftX, leftY, rightX, rightY] rows, plus
- * both fitted directions (null when unfitted).
+ * on-disk artifacts, and an import-time seed are all interchangeable.
+ * Points live ONLY inside `observations` (format v2) -- there is no
+ * flattened duplicate.
  */
 export interface RegistrationFilePair {
   left: string;
   right: string;
-  points?: number[][];
+  observations?: RegistrationFileObservation[];
   leftToRight?: Matrix3 | null;
   rightToLeft?: Matrix3 | null;
   transformType?: TransformType;
@@ -79,8 +154,14 @@ export interface RegistrationFile {
 /** Identifying `type` value of the registration JSON format. */
 export const REGISTRATION_FILE_TYPE = 'dive-camera-registration';
 
-/** Picked correspondences keyed by {@link CameraRegistrationStore.pairKey}. */
-export type CameraCorrespondences = Record<string, Correspondence[]>;
+/**
+ * The registration file format version this client reads and writes. There
+ * is exactly one shape: anything else is rejected with a clear message
+ * rather than accepted, because a pre-observations (v1) file would otherwise
+ * load as a matrix-only pair with its points silently dropped -- a
+ * legitimate-looking state indistinguishable from a real producer file.
+ */
+export const REGISTRATION_FILE_VERSION = 2;
 
 /** Chosen fit model per pair, keyed by {@link CameraRegistrationStore.pairKey}. Missing entries default to 'similarity'. */
 export type CameraTransformTypes = Record<string, TransformType>;
@@ -100,12 +181,62 @@ export interface ActivePair {
 }
 
 /**
- * Shared, reactive store for camera-registration data (correspondences,
- * fitted/loaded homographies, transform-type choices, and producer
- * provenance). Lives in vue-media-annotator so both the annotation layers
- * (client/src/alignedView) and the dive-common side can consume it via the
- * provide/inject system. Handles persistence: hydrating saved state and
- * loading/saving the portable registration JSON format.
+ * Host-provided bridge between frame indices and image identities, published
+ * by the viewer (which owns the per-camera media lists). Image-sequence
+ * cameras resolve to real file names; video cameras resolve to stable
+ * `frame://N` pseudo-names so the schema stays uniform across media types.
+ */
+export interface FrameResolver {
+  /** The image name `camera` displays on its current frame. */
+  currentImageName(camera: string): string | null;
+  /** The dataset-local frame index showing `imageName` on `camera`, or null. */
+  frameForImage(camera: string, imageName: string): number | null;
+}
+
+/** One row of the registration-frames list for a pair (see {@link CameraRegistrationStore.framesForPair}). */
+export interface FrameSummary {
+  frame: number | null;
+  imageA: string;
+  imageB: string;
+  enabled: boolean;
+  source: string;
+  count: number;
+  stats?: ObservationStats;
+}
+
+/** Per-observation agreement with the pooled fit (see {@link CameraRegistrationStore.pairFitStats}). */
+export interface PairFitStats {
+  /** RMS over every enabled observation's points against the pooled fit, or null without a fit. */
+  rmsPx: number | null;
+  pointCount: number;
+  frameCount: number;
+  perObservation: {
+    frame: number | null;
+    imageA: string;
+    imageB: string;
+    enabled: boolean;
+    rmsPx: number | null;
+  }[];
+}
+
+/** Fallback pseudo-image name for frame `frame` when no resolver is set. */
+function pseudoImageName(frame: number): string {
+  return `frame://${frame}`;
+}
+
+/**
+ * Shared, reactive store for camera-registration data (per-image-pair
+ * correspondence observations, fitted/loaded homographies, transform-type
+ * choices, and producer provenance). Lives in vue-media-annotator so both
+ * the annotation layers (client/src/alignedView) and the dive-common side
+ * can consume it via the provide/inject system. Handles persistence:
+ * hydrating saved state and loading/saving the portable registration JSON
+ * format (version 2, observations only).
+ *
+ * A correspondence belongs to a (camera pair, image pair), not just a camera
+ * pair: the image names are the persisted identity and frame indices are
+ * resolved from them at load time. The pair-level homography pools points
+ * from every enabled observation instead of trusting one frame.
  *
  * Also holds the interactive creation state, implementing the keypointgui
  * blue->red pairing flow: the first click in one camera sets a pending
@@ -118,7 +249,7 @@ export default class CameraRegistrationStore {
 
   pendingPoint: Ref<{ camera: string; coord: Point } | null>;
 
-  correspondences: Ref<CameraCorrespondences>;
+  observations: Ref<CameraObservations>;
 
   homographies: Ref<CameraHomographies>;
 
@@ -126,6 +257,12 @@ export default class CameraRegistrationStore {
 
   alignment: Ref<AlignmentState>;
 
+  /**
+   * The current (aggregate) frame, kept in sync by the viewer so newly
+   * picked points can be stamped with the image pair they were picked on.
+   */
+  currentFrame: Ref<number>;
+
   /**
    * Whether pan/zoom is linked between the active pair's two cameras through
    * the pair's transform (see {@link useRegistrationNavigation}). Only has an
@@ -182,14 +319,18 @@ export default class CameraRegistrationStore {
   /** Serialized calibration at the last save/load, the baseline for {@link dirty}. */
   private savedSnapshot: Ref<string>;
 
+  /** Host-provided frame/image bridge; null until the viewer publishes one. */
+  private frameResolver: FrameResolver | null;
+
   constructor() {
     this.activePair = ref(null);
     this.pickingEnabled = ref(false);
     this.pendingPoint = ref(null);
-    this.correspondences = ref({});
+    this.observations = ref({});
     this.homographies = ref({});
     this.transformTypes = ref({});
     this.alignment = ref({ mode: 'original', opacity: 0.5 });
+    this.currentFrame = ref(0);
     this.linkedNav = ref(true);
     this.selectedCorrespondenceId = ref(null);
     this.cursorCoord = ref(null);
@@ -199,15 +340,16 @@ export default class CameraRegistrationStore {
     this.nextId = 1;
     this.nextRecenterId = 1;
     this.homographySources = {};
+    this.frameResolver = null;
     this.savedSnapshot = ref(this.registrationSnapshot());
     this.dirty = computed(() => this.registrationSnapshot() !== this.savedSnapshot.value);
   }
 
-  /** Serialize the saved-to-dataset calibration state (points, transforms, provenance). */
+  /** Serialize the saved-to-dataset calibration state (observations, transforms, provenance). */
   private registrationSnapshot(): string {
     return JSON.stringify({
       homographies: this.homographies.value,
-      correspondences: this.correspondences.value,
+      observations: this.observations.value,
       transformTypes: this.transformTypes.value,
       source: this.source.value,
     });
@@ -227,7 +369,7 @@ export default class CameraRegistrationStore {
    */
   savedRegistrationValues(): {
     homographies: CameraHomographies;
-    correspondences: CameraCorrespondences;
+    observations: CameraObservations;
     transformTypes: CameraTransformTypes;
     source: RegistrationSource | null;
     } {
@@ -237,13 +379,13 @@ export default class CameraRegistrationStore {
   /**
    * True when the saved baseline (last hydrate/save/load) already holds
    * registration data -- i.e. saving now would overwrite a persisted
-   * registration rather than create a fresh one. Empty correspondence lists
+   * registration rather than create a fresh one. Empty observation lists
    * don't count: clearing a pair leaves `[]` behind.
    */
   hasSavedRegistration(): boolean {
     const saved = this.savedRegistrationValues();
     return Object.keys(saved.homographies).length > 0
-      || Object.values(saved.correspondences).some((list) => list.length > 0);
+      || Object.values(saved.observations).some((list) => list.length > 0);
   }
 
   /**
@@ -290,10 +432,275 @@ export default class CameraRegistrationStore {
     this.fitError.value = null;
   }
 
+  /**
+   * Publish (or clear) the host's frame/image resolver and re-resolve every
+   * observation's frame index against it. Called by the viewer once media
+   * is loaded (and again if the media set changes): resolution at load time
+   * is what makes a registration portable across deployments of the same
+   * rig -- a re-index or re-import can't silently shift points onto the
+   * wrong scene.
+   */
+  setFrameResolver(resolver: FrameResolver | null) {
+    this.frameResolver = resolver;
+    if (!resolver) {
+      return;
+    }
+    const wasDirty = this.dirty.value;
+    const next: CameraObservations = {};
+    let changed = false;
+    Object.entries(this.observations.value).forEach(([key, list]) => {
+      const [camA] = key.split('::');
+      next[key] = list.map((obs) => {
+        const frame = resolver.frameForImage(camA, obs.imageA);
+        if (frame !== obs.frame) {
+          changed = true;
+          return { ...obs, frame };
+        }
+        return obs;
+      });
+    });
+    if (changed) {
+      this.observations.value = next;
+      // Frame resolution is derived state: it must not mark a clean saved
+      // calibration dirty on its own (real unsaved edits stay dirty).
+      if (!wasDirty) {
+        this.savedSnapshot.value = this.registrationSnapshot();
+      }
+    }
+  }
+
+  /** All observations for a pair key (empty list when none). */
+  observationsForPair(key: string): CorrespondenceObservation[] {
+    return this.observations.value[key] || [];
+  }
+
+  /** Pooled points from every ENABLED observation of `key` -- the fit input. */
+  enabledPoints(key: string): CorrespondencePoint[] {
+    return this.observationsForPair(key)
+      .filter((obs) => obs.enabled)
+      .flatMap((obs) => obs.points);
+  }
+
+  /** Total point count across every enabled observation of `key`. */
+  enabledPointCount(key: string): number {
+    return this.enabledPoints(key).length;
+  }
+
+  /** Flat per-point view of one frame's observations (the panel's table). */
+  correspondencesForFrame(key: string, frame: number | null): Correspondence[] {
+    return this.observationsForPair(key)
+      .filter((obs) => obs.frame === frame)
+      .flatMap((obs) => obs.points.map((point) => ({
+        ...point,
+        imageA: obs.imageA,
+        imageB: obs.imageB,
+        frame: obs.frame,
+        source: obs.source,
+      })));
+  }
+
+  /**
+   * Flat per-point view of the observations visible in `camera`'s pane at
+   * its local `frame` -- the keypoint layer's data source. The A side
+   * matches on the observation's resolved frame; the B side re-resolves
+   * imageB in camB's own frame space, so panes showing differently-indexed
+   * media (aligned timelines) still draw each point on the scene it was
+   * actually picked on.
+   */
+  correspondencesForCameraFrame(key: string, camera: string, frame: number): Correspondence[] {
+    const [camA, camB] = key.split('::');
+    return this.observationsForPair(key)
+      .filter((obs) => {
+        if (camera === camA) {
+          return obs.frame === frame;
+        }
+        if (camera === camB) {
+          const frameB = this.frameResolver
+            ? this.frameResolver.frameForImage(camB, obs.imageB)
+            : obs.frame;
+          return frameB === frame;
+        }
+        return false;
+      })
+      .flatMap((obs) => obs.points.map((point) => ({
+        ...point,
+        imageA: obs.imageA,
+        imageB: obs.imageB,
+        frame: obs.frame,
+        source: obs.source,
+      })));
+  }
+
+  /**
+   * The registration-frames list for a pair: one row per observation,
+   * resolved rows sorted by frame, unresolved (frame null) rows last. This
+   * is both the multi-pair selector and the quality readout.
+   */
+  framesForPair(key: string): FrameSummary[] {
+    const rows = this.observationsForPair(key).map((obs) => ({
+      frame: obs.frame,
+      imageA: obs.imageA,
+      imageB: obs.imageB,
+      enabled: obs.enabled,
+      source: obs.source,
+      count: obs.points.length,
+      stats: obs.stats,
+    }));
+    return rows.sort((a, b) => {
+      if (a.frame === null && b.frame === null) {
+        return a.imageA.localeCompare(b.imageA);
+      }
+      if (a.frame === null) {
+        return 1;
+      }
+      if (b.frame === null) {
+        return -1;
+      }
+      return a.frame - b.frame;
+    });
+  }
+
+  /**
+   * Per-observation reprojection RMS against the pair's CURRENT pooled
+   * homography -- the diagnostic that makes a frame disagreeing with the
+   * consensus visible and removable rather than quietly dragging the
+   * solution. Disabled observations are still measured (against the fit
+   * they're excluded from) so re-enabling them is an informed choice.
+   */
+  pairFitStats(key: string): PairFitStats {
+    const homography = this.homographies.value[key];
+    const observations = this.observationsForPair(key);
+    const rmsOf = (points: CorrespondencePoint[]): number | null => {
+      if (!homography || points.length === 0) {
+        return null;
+      }
+      const sumSq = points.reduce((acc, point) => {
+        const projected = applyHomography(homography.AtoB, point.a);
+        return acc + (projected[0] - point.b[0]) ** 2 + (projected[1] - point.b[1]) ** 2;
+      }, 0);
+      return Math.sqrt(sumSq / points.length);
+    };
+    const enabled = observations.filter((obs) => obs.enabled);
+    return {
+      rmsPx: rmsOf(enabled.flatMap((obs) => obs.points)),
+      pointCount: enabled.reduce((acc, obs) => acc + obs.points.length, 0),
+      frameCount: enabled.filter((obs) => obs.points.length > 0).length,
+      perObservation: observations.map((obs) => ({
+        frame: obs.frame,
+        imageA: obs.imageA,
+        imageB: obs.imageB,
+        enabled: obs.enabled,
+        rmsPx: rmsOf(obs.points),
+      })),
+    };
+  }
+
+  /** Replace one pair's observation list (immutably) and leave others alone. */
+  private setObservationsForPair(key: string, list: CorrespondenceObservation[]) {
+    this.observations.value = { ...this.observations.value, [key]: list };
+  }
+
+  /**
+   * The camA-space frame index of the image pair `key`'s cameras currently
+   * display -- what the panel's frame list highlights and its per-frame
+   * table scopes to. Falls back to {@link currentFrame} without a resolver.
+   */
+  currentFrameForPair(key: string): number | null {
+    const [camA] = key.split('::');
+    const image = this.frameResolver?.currentImageName(camA);
+    if (!image) {
+      return this.currentFrame.value;
+    }
+    return this.resolveFrame(camA, image) ?? this.currentFrame.value;
+  }
+
+  /**
+   * Remove one observation (points and all) by its image-pair identity --
+   * restricted to one producer when `source` is given -- then refit.
+   */
+  removeObservation(key: string, imageA: string, imageB: string, source?: string) {
+    const matches = (obs: CorrespondenceObservation) => obs.imageA === imageA
+      && obs.imageB === imageB && (source === undefined || obs.source === source);
+    const list = this.observationsForPair(key);
+    const removed = list.filter(matches);
+    if (!removed.length) {
+      return;
+    }
+    const removedIds = new Set(removed.flatMap((obs) => obs.points.map((point) => point.id)));
+    if (this.selectedCorrespondenceId.value !== null
+      && removedIds.has(this.selectedCorrespondenceId.value)) {
+      this.selectedCorrespondenceId.value = null;
+    }
+    this.setObservationsForPair(key, list.filter((obs) => !matches(obs)));
+    this.maybeFitPair(key);
+  }
+
+  /**
+   * Include or exclude one observation (identified by its image pair) from
+   * the pooled fit, then refit. Excluding never deletes points.
+   */
+  setObservationEnabled(key: string, imageA: string, imageB: string, enabled: boolean) {
+    const list = this.observationsForPair(key);
+    if (!list.some((obs) => obs.imageA === imageA && obs.imageB === imageB)) {
+      return;
+    }
+    this.setObservationsForPair(key, list.map((obs) => (
+      (obs.imageA === imageA && obs.imageB === imageB) ? { ...obs, enabled } : obs)));
+    this.maybeFitPair(key);
+  }
+
+  /** Include or exclude every observation at `frame` from the pooled fit, then refit. */
+  setFrameEnabled(key: string, frame: number | null, enabled: boolean) {
+    const list = this.observationsForPair(key);
+    if (!list.some((obs) => obs.frame === frame)) {
+      return;
+    }
+    this.setObservationsForPair(key, list.map((obs) => (
+      obs.frame === frame ? { ...obs, enabled } : obs)));
+    this.maybeFitPair(key);
+  }
+
+  /** Remove every observation at `frame` (points and all), then refit. */
+  clearFrame(key: string, frame: number | null) {
+    const list = this.observationsForPair(key);
+    if (!list.some((obs) => obs.frame === frame)) {
+      return;
+    }
+    const removedIds = new Set(list
+      .filter((obs) => obs.frame === frame)
+      .flatMap((obs) => obs.points.map((point) => point.id)));
+    if (this.selectedCorrespondenceId.value !== null
+      && removedIds.has(this.selectedCorrespondenceId.value)) {
+      this.selectedCorrespondenceId.value = null;
+    }
+    this.setObservationsForPair(key, list.filter((obs) => obs.frame !== frame));
+    this.maybeFitPair(key);
+  }
+
+  /** The image pair the active pair's cameras currently display. */
+  private currentImagePair(pair: ActivePair): { imageA: string; imageB: string } {
+    const fallback = pseudoImageName(this.currentFrame.value);
+    return {
+      imageA: this.frameResolver?.currentImageName(pair.camA) ?? fallback,
+      imageB: this.frameResolver?.currentImageName(pair.camB) ?? fallback,
+    };
+  }
+
+  /** Resolve the camA-space frame index for an image name (fallback: current frame). */
+  private resolveFrame(camA: string, imageA: string): number | null {
+    if (this.frameResolver) {
+      return this.frameResolver.frameForImage(camA, imageA);
+    }
+    const match = /^frame:\/\/(\d+)$/.exec(imageA);
+    return match ? Number(match[1]) : null;
+  }
+
   /**
    * Add a clicked image point for `camera`. The first click sets a pending point;
    * a subsequent click in the *other* camera of the active pair completes a pair.
-   * Clicking the same camera again replaces the pending point.
+   * Clicking the same camera again replaces the pending point. Completed pairs
+   * land in the current frame's MANUAL observation (created on first use),
+   * stamped with the image pair being displayed.
    */
   addPoint(camera: string, coord: Point) {
     const pair = this.activePair.value;
@@ -308,12 +715,25 @@ export default class CameraRegistrationStore {
     const key = this.pairKey(pair.camA, pair.camB);
     const a = pending.camera === pair.camA ? pending.coord : coord;
     const b = pending.camera === pair.camB ? pending.coord : coord;
-    const list = this.correspondences.value[key]
-      ? [...this.correspondences.value[key]]
-      : [];
+    const { imageA, imageB } = this.currentImagePair(pair);
+    const list = [...this.observationsForPair(key)];
     // eslint-disable-next-line no-plusplus
-    list.push({ id: this.nextId++, a, b });
-    this.correspondences.value = { ...this.correspondences.value, [key]: list };
+    const point = { id: this.nextId++, a, b };
+    const index = list.findIndex((obs) => obs.imageA === imageA && obs.imageB === imageB
+      && obs.source === MANUAL_SOURCE);
+    if (index >= 0) {
+      list[index] = { ...list[index], points: [...list[index].points, point] };
+    } else {
+      list.push({
+        imageA,
+        imageB,
+        frame: this.resolveFrame(pair.camA, imageA) ?? this.currentFrame.value,
+        enabled: true,
+        source: MANUAL_SOURCE,
+        points: [point],
+      });
+    }
+    this.setObservationsForPair(key, list);
     this.pendingPoint.value = null;
     this.syncAlignmentHomography();
   }
@@ -342,15 +762,19 @@ export default class CameraRegistrationStore {
       return;
     }
     const key = this.pairKey(pair.camA, pair.camB);
-    const list = this.correspondences.value[key];
-    if (!list || !list.some((c) => c.id === id)) {
+    const list = this.observationsForPair(key);
+    if (!list.some((obs) => obs.points.some((point) => point.id === id))) {
       return;
     }
     const side = camera === pair.camA ? 'a' : 'b';
-    this.correspondences.value = {
-      ...this.correspondences.value,
-      [key]: list.map((c) => (c.id === id ? { ...c, [side]: coord } : c)),
-    };
+    this.setObservationsForPair(key, list.map((obs) => (
+      obs.points.some((point) => point.id === id)
+        ? {
+          ...obs,
+          points: obs.points.map((point) => (
+            point.id === id ? { ...point, [side]: coord } : point)),
+        }
+        : obs)));
     this.syncAlignmentHomography();
   }
 
@@ -363,20 +787,31 @@ export default class CameraRegistrationStore {
     this.pendingPoint.value = { camera, coord };
   }
 
+  /**
+   * Drop an observation that has lost its last point and carries no
+   * producer statistics worth reviewing; keep stat-bearing ones (their
+   * skip/quality readout is review content even without points).
+   */
+  private static pruneEmpty(list: CorrespondenceObservation[]): CorrespondenceObservation[] {
+    return list.filter((obs) => obs.points.length > 0 || obs.stats !== undefined);
+  }
+
   /** Remove a correspondence (by id) from the active pair -- both cameras' points at once. */
   removeCorrespondence(id: number) {
     const key = this.activePairKey();
     if (!key) {
       return;
     }
-    const list = this.correspondences.value[key];
-    if (!list) {
+    const list = this.observationsForPair(key);
+    if (!list.some((obs) => obs.points.some((point) => point.id === id))) {
       return;
     }
-    this.correspondences.value = {
-      ...this.correspondences.value,
-      [key]: list.filter((c) => c.id !== id),
-    };
+    this.setObservationsForPair(key, CameraRegistrationStore.pruneEmpty(
+      list.map((obs) => ({
+        ...obs,
+        points: obs.points.filter((point) => point.id !== id),
+      })),
+    ));
     if (this.selectedCorrespondenceId.value === id) {
       this.selectedCorrespondenceId.value = null;
     }
@@ -394,8 +829,10 @@ export default class CameraRegistrationStore {
       return;
     }
     const key = this.activePairKey();
-    const list = key ? this.correspondences.value[key] : undefined;
-    this.selectedCorrespondenceId.value = (list && list.some((c) => c.id === id)) ? id : null;
+    const owned = key
+      ? this.observationsForPair(key).some((obs) => obs.points.some((point) => point.id === id))
+      : false;
+    this.selectedCorrespondenceId.value = owned ? id : null;
   }
 
   /** Remove the selected correspondence (both cameras' points). No-op without a selection. */
@@ -407,7 +844,7 @@ export default class CameraRegistrationStore {
   }
 
   /**
-   * Drop all correspondences, the pending point, and any homography
+   * Drop all observations, the pending point, and any homography
    * (fitted or file-loaded) for the active pair.
    */
   clearPair() {
@@ -417,7 +854,7 @@ export default class CameraRegistrationStore {
     if (!key) {
       return;
     }
-    this.correspondences.value = { ...this.correspondences.value, [key]: [] };
+    this.setObservationsForPair(key, []);
     // Clearing is explicit: a file-loaded homography goes too. Dropping the
     // 'loaded' mark lets maybeFitPair remove it through the normal path.
     delete this.homographySources[key];
@@ -427,7 +864,8 @@ export default class CameraRegistrationStore {
   /**
    * Undo one step, mirroring keypointgui's Clear Last button: if there's a
    * pending (blue) point, drop it; otherwise remove the most recently
-   * completed correspondence for the active pair.
+   * completed correspondence on the CURRENT frame (editing acts on the
+   * frame being viewed; other frames' points are untouched).
    */
   clearLast() {
     if (this.pendingPoint.value) {
@@ -438,14 +876,33 @@ export default class CameraRegistrationStore {
     if (!key) {
       return;
     }
-    const list = this.correspondences.value[key];
-    if (!list || list.length === 0) {
+    const frame = this.currentFrameForPair(key);
+    const list = this.observationsForPair(key);
+    // The most recently added point on this frame is the one with the
+    // highest id (ids allocate monotonically).
+    let target: { obsIndex: number; pointId: number } | null = null;
+    list.forEach((obs, obsIndex) => {
+      if (obs.frame !== frame) {
+        return;
+      }
+      obs.points.forEach((point) => {
+        if (!target || point.id > target.pointId) {
+          target = { obsIndex, pointId: point.id };
+        }
+      });
+    });
+    if (!target) {
       return;
     }
-    if (this.selectedCorrespondenceId.value === list[list.length - 1].id) {
+    const { obsIndex, pointId } = target;
+    if (this.selectedCorrespondenceId.value === pointId) {
       this.selectedCorrespondenceId.value = null;
     }
-    this.correspondences.value = { ...this.correspondences.value, [key]: list.slice(0, -1) };
+    this.setObservationsForPair(key, CameraRegistrationStore.pruneEmpty(
+      list.map((obs, i) => (i === obsIndex
+        ? { ...obs, points: obs.points.filter((point) => point.id !== pointId) }
+        : obs)),
+    ));
     this.syncAlignmentHomography();
   }
 
@@ -463,7 +920,7 @@ export default class CameraRegistrationStore {
    * unless the pair already has a file-loaded transform, in which case it
    * opens in a review posture (false) so stray clicks don't start placing
    * points on top of a registration that needs no points. The user can still
-   * opt back in via the panel's "Pick points" toggle to refine.
+   * opt back in via the panel's "Edit points" toggle to refine.
    */
   pickingDefaultFor(key: string | null): boolean {
     return !(key && this.homographies.value[key] && this.isLoadedHomography(key));
@@ -496,17 +953,17 @@ export default class CameraRegistrationStore {
   }
 
   /**
-   * Fit `key` when it has enough points for its chosen transform type; otherwise
-   * clear its homography and, if it's the active (aligned) pair, revert
-   * alignment to 'original'. A fit can still fail past the minimum-count check
-   * (e.g. collinear/near-duplicate points make the system unsolvable); that's
-   * caught here and surfaced via {@link fitError} instead of throwing out of a
-   * geojs click handler, keeping any previously fitted homography in place.
+   * Fit `key` when its enabled observations pool enough points for its chosen
+   * transform type; otherwise clear its homography and, if it's the active
+   * (aligned) pair, revert alignment to 'original'. A fit can still fail past
+   * the minimum-count check (e.g. collinear/near-duplicate points make the
+   * system unsolvable); that's caught here and surfaced via {@link fitError}
+   * instead of throwing out of a geojs click handler, keeping any previously
+   * fitted homography in place.
    */
   maybeFitPair(key: string) {
-    const list = this.correspondences.value[key];
     const required = minPointsForTransform(this.transformTypeForPair(key));
-    if (!list || list.length < required) {
+    if (this.enabledPointCount(key) < required) {
       // A file-loaded homography has no backing points; it stays in place
       // until enough points are picked to fit a replacement (or the pair is
       // explicitly cleared, which drops its 'loaded' mark first).
@@ -619,18 +1076,20 @@ export default class CameraRegistrationStore {
   }
 
   /**
-   * Fit `key`'s chosen transform type from its correspondences (see
-   * {@link minPointsForTransform} for the required count). Computes both
-   * directions and stores them. Returns the fitted pair.
+   * Fit `key`'s chosen transform type from the points POOLED across every
+   * enabled observation (see {@link minPointsForTransform} for the required
+   * count) -- the fit is the pair's consensus over every contributing frame,
+   * not one frame's opinion. Computes both directions and stores them.
+   * Returns the fitted pair.
    */
   fitTransform(key: string): PairHomography {
-    const list = this.correspondences.value[key];
+    const points = this.enabledPoints(key);
     const type = this.transformTypeForPair(key);
     const required = minPointsForTransform(type);
-    if (!list || list.length < required) {
+    if (points.length < required) {
       throw new Error(`At least ${required} point pair(s) are required to fit a ${type} transform`);
     }
-    const AtoB = estimateTransform(type, list.map((c) => c.a), list.map((c) => c.b));
+    const AtoB = estimateTransform(type, points.map((c) => c.a), points.map((c) => c.b));
     const BtoA = invert3(AtoB);
     this.homographies.value = { ...this.homographies.value, [key]: { AtoB, BtoA } };
     this.homographySources[key] = 'fit';
@@ -638,16 +1097,88 @@ export default class CameraRegistrationStore {
   }
 
   /**
-   * Parse and load a registration JSON file (the per-camera
-   * <camera>_to_<reference>_registration.json format written by
-   * cameraRegistrationFiles.ts's buildPerCameraRegistrationFiles --
-   * the only registration file format), REPLACING all pairs' correspondences,
-   * homographies, and transform types. The active pair selection and picking
-   * toggle are left alone; the alignment ghost reverts to 'original' since
-   * the transform under it changed wholesale. Throws a descriptive Error on
-   * malformed input without touching current state. Returns the camera names
-   * referenced by the file so callers can warn about ones missing from the
-   * loaded dataset.
+   * Merge automatically computed observations for `camA` -> `camB` into the
+   * pair AT OBSERVATION GRANULARITY: an incoming observation replaces the
+   * existing observation with the same (image pair, source) identity --
+   * re-running the matcher updates its own prior results -- while manual
+   * observations and other image pairs' results are kept. The points land in
+   * the normal per-frame tables so the user can inspect, delete, or
+   * drag-refine them exactly like hand-picked ones; each observation carries
+   * its producer id, closing the provenance gap the flat format had.
+   * Switches the pair to a homography fit and refits from the pooled points.
+   * Picking is switched on so the injected points are immediately visible
+   * for review -- the keypoint layer draws nothing while picking is off.
+   *
+   * Deliberately does NOT touch {@link source}: that stamp is rig-global
+   * (written into EVERY per-camera registration file), so recording this one
+   * pair's matcher provenance there would falsely restamp -- and therefore
+   * rewrite -- the other cameras' files on the next save. Provenance rides
+   * on each observation instead.
+   */
+  applyRegistrationResult(
+    camA: string,
+    camB: string,
+    incoming: {
+      /** Image-pair identity; defaults to the images currently displayed. */
+      imageA?: string;
+      imageB?: string;
+      frame?: number | null;
+      enabled?: boolean;
+      source: string;
+      stats?: ObservationStats;
+      points: [number, number, number, number][];
+    }[],
+  ) {
+    const key = this.pairKey(camA, camB);
+    const current = this.currentImagePair({ camA, camB });
+    const list = [...this.observationsForPair(key)];
+    incoming.forEach((raw) => {
+      const entry = {
+        ...raw,
+        imageA: raw.imageA ?? current.imageA,
+        imageB: raw.imageB ?? current.imageB,
+      };
+      const observation: CorrespondenceObservation = {
+        imageA: entry.imageA,
+        imageB: entry.imageB,
+        frame: this.resolveFrame(camA, entry.imageA) ?? entry.frame ?? null,
+        enabled: entry.enabled ?? true,
+        source: entry.source,
+        ...(entry.stats !== undefined ? { stats: entry.stats } : {}),
+        points: entry.points.map(([ax, ay, bx, by]) => ({
+          // eslint-disable-next-line no-plusplus
+          id: this.nextId++,
+          a: [ax, ay] as Point,
+          b: [bx, by] as Point,
+        })),
+      };
+      const index = list.findIndex((obs) => obs.imageA === entry.imageA
+        && obs.imageB === entry.imageB && obs.source === entry.source);
+      if (index >= 0) {
+        list[index] = observation;
+      } else {
+        list.push(observation);
+      }
+    });
+    this.setObservationsForPair(key, list);
+    this.pendingPoint.value = null;
+    this.selectedCorrespondenceId.value = null;
+    this.transformTypes.value = { ...this.transformTypes.value, [key]: 'homography' };
+    this.pickingEnabled.value = true;
+    this.maybeFitPair(key);
+  }
+
+  /**
+   * Parse and load a registration JSON file (format version 2 ONLY: the
+   * per-camera <camera>_to_<reference>_registration.json format written by
+   * cameraRegistrationFiles.ts's buildPerCameraRegistrationFiles),
+   * REPLACING all pairs' observations, homographies, and transform types.
+   * The active pair selection and picking toggle are left alone; the
+   * alignment ghost reverts to 'original' since the transform under it
+   * changed wholesale. Throws a descriptive Error on malformed input --
+   * including any version other than {@link REGISTRATION_FILE_VERSION} --
+   * without touching current state. Returns the camera names referenced by
+   * the file so callers can warn about ones missing from the loaded dataset.
    */
   loadRegistrationText(text: string): { cameras: string[]; pairCount: number } {
     let data: unknown;
@@ -660,8 +1191,15 @@ export default class CameraRegistrationStore {
     if (!Array.isArray(file?.pairs)) {
       throw new Error('Not a DIVE camera registration file (expected a "pairs" list)');
     }
+    if (file.version !== REGISTRATION_FILE_VERSION) {
+      throw new Error(
+        `Unsupported registration file version ${JSON.stringify(file.version)} `
+        + `(expected ${REGISTRATION_FILE_VERSION}). Regenerate the file with a `
+        + 'current producer; pre-v2 files have no per-image-pair observations.',
+      );
+    }
     const source = CameraRegistrationStore.readSource(file.source);
-    const correspondences: CameraCorrespondences = {};
+    const observations: CameraObservations = {};
     const homographies: CameraHomographies = {};
     const transformTypes: CameraTransformTypes = {};
     const cameras = new Set<string>();
@@ -682,11 +1220,11 @@ export default class CameraRegistrationStore {
         }
         transformTypes[key] = pair.transformType;
       }
-      correspondences[key] = (pair.points || []).map((row, j) => {
-        const [ax, ay, bx, by] = CameraRegistrationStore.readPointsRow(row, `${context}, points row ${j + 1}`);
-        // eslint-disable-next-line no-plusplus
-        return { id: this.nextId++, a: [ax, ay] as Point, b: [bx, by] as Point };
-      });
+      observations[key] = (pair.observations || []).map((raw, j) => this.readObservation(
+        raw,
+        pair.left,
+        `${context}, observation ${j + 1}`,
+      ));
       const leftToRight = (pair.leftToRight === null || pair.leftToRight === undefined)
         ? null
         : CameraRegistrationStore.readMatrix(pair.leftToRight, `${context}, leftToRight`);
@@ -702,11 +1240,12 @@ export default class CameraRegistrationStore {
         };
       }
     });
-    this.correspondences.value = correspondences;
+    this.observations.value = observations;
     this.homographies.value = homographies;
     this.transformTypes.value = transformTypes;
     this.source.value = source;
     this.markHomographySources();
+    this.renumberPoints();
     this.pendingPoint.value = null;
     this.selectedCorrespondenceId.value = null;
     this.fitError.value = null;
@@ -714,6 +1253,69 @@ export default class CameraRegistrationStore {
     return { cameras: [...cameras], pairCount: file.pairs.length };
   }
 
+  /** Validate an untrusted file observation and resolve its frame. */
+  private readObservation(
+    raw: unknown,
+    camA: string,
+    context: string,
+  ): CorrespondenceObservation {
+    const obs = raw as Partial<RegistrationFileObservation>;
+    if (typeof obs?.imageLeft !== 'string' || !obs.imageLeft
+      || typeof obs?.imageRight !== 'string' || !obs.imageRight) {
+      throw new Error(`${context}: "imageLeft" and "imageRight" image names are required`);
+    }
+    if (obs.enabled !== undefined && typeof obs.enabled !== 'boolean') {
+      throw new Error(`${context}: "enabled" must be a boolean when present`);
+    }
+    if (obs.source !== undefined && (typeof obs.source !== 'string' || !obs.source)) {
+      throw new Error(`${context}: "source" must be a non-empty string when present`);
+    }
+    if (obs.frame !== undefined && obs.frame !== null && !Number.isInteger(obs.frame)) {
+      throw new Error(`${context}: "frame" must be an integer when present`);
+    }
+    if (obs.stats !== undefined
+      && (typeof obs.stats !== 'object' || obs.stats === null || Array.isArray(obs.stats))) {
+      throw new Error(`${context}: "stats" must be an object when present`);
+    }
+    const points = (obs.points || []).map((row, j) => {
+      const [ax, ay, bx, by] = CameraRegistrationStore.readPointsRow(row, `${context}, points row ${j + 1}`);
+      // Ids are renumbered after the whole file parses (renumberPoints).
+      return {
+        id: 0, a: [ax, ay] as Point, b: [bx, by] as Point,
+      };
+    });
+    // The image names are the identity: resolve the frame here (the file's
+    // own frame value is advisory -- a producer may not know this dataset's
+    // indices, and a stale one must not shift points onto the wrong scene).
+    const resolved = this.resolveFrame(camA, obs.imageLeft);
+    return {
+      imageA: obs.imageLeft,
+      imageB: obs.imageRight,
+      frame: resolved ?? (this.frameResolver ? null : (obs.frame ?? null)),
+      enabled: obs.enabled ?? true,
+      source: obs.source || MANUAL_SOURCE,
+      ...(obs.stats !== undefined ? { stats: obs.stats as ObservationStats } : {}),
+      points,
+    };
+  }
+
+  /** Assign fresh sequential ids to every point (after a bulk load). */
+  private renumberPoints() {
+    let id = 0;
+    const next: CameraObservations = {};
+    Object.entries(this.observations.value).forEach(([key, list]) => {
+      next[key] = list.map((obs) => ({
+        ...obs,
+        points: obs.points.map((point) => {
+          id += 1;
+          return { ...point, id };
+        }),
+      }));
+    });
+    this.observations.value = next;
+    this.nextId = id + 1;
+  }
+
   /** Validate an untrusted `source` value: a plain object, or absent (-> null). */
   private static readSource(raw: unknown): RegistrationSource | null {
     if (raw === undefined || raw === null) {
@@ -757,28 +1359,28 @@ export default class CameraRegistrationStore {
 
   /**
    * Reset homography provenance after bulk-loading state: a homography whose
-   * pair lacks enough points for its transform type can only have come from a
-   * file ('loaded', so refit checks preserve it); one with enough points is
-   * treated as fitted from them.
+   * pair pools too few enabled points for its transform type can only have
+   * come from a file ('loaded', so refit checks preserve it); one with
+   * enough points is treated as fitted from them.
    */
   private markHomographySources() {
     this.homographySources = {};
     Object.keys(this.homographies.value).forEach((key) => {
-      const count = (this.correspondences.value[key] || []).length;
+      const count = this.enabledPointCount(key);
       const required = minPointsForTransform(this.transformTypeForPair(key));
       this.homographySources[key] = count >= required ? 'fit' : 'loaded';
     });
   }
 
-  /** Reset state and load saved homographies, correspondences, transform type choices, and provenance. */
+  /** Reset state and load saved homographies, observations, transform type choices, and provenance. */
   hydrate(
     homographies?: CameraHomographies,
-    correspondences?: CameraCorrespondences,
+    observations?: CameraObservations,
     transformTypes?: CameraTransformTypes,
     source?: RegistrationSource | null,
   ) {
     this.homographies.value = homographies ? { ...homographies } : {};
-    this.correspondences.value = correspondences ? { ...correspondences } : {};
+    this.observations.value = observations ? { ...observations } : {};
     this.transformTypes.value = transformTypes ? { ...transformTypes } : {};
     this.source.value = source ?? null;
     this.markHomographySources();
@@ -790,12 +1392,18 @@ export default class CameraRegistrationStore {
     this.cursorCoord.value = null;
     this.recenterRequest.value = null;
     this.fitError.value = null;
-    // Resume id allocation past any restored correspondences.
+    // Resume id allocation past any restored points.
     let maxId = 0;
-    Object.values(this.correspondences.value).forEach((list) => {
-      list.forEach((c) => { maxId = Math.max(maxId, c.id); });
+    Object.values(this.observations.value).forEach((list) => {
+      list.forEach((obs) => {
+        obs.points.forEach((point) => { maxId = Math.max(maxId, point.id); });
+      });
     });
     this.nextId = maxId + 1;
+    // Re-resolve frames against the current resolver, if one is published.
+    if (this.frameResolver) {
+      this.setFrameResolver(this.frameResolver);
+    }
     // The freshly loaded state is the saved baseline.
     this.markSaved();
   }
diff --git a/client/src/alignedView/cameraRegistrationFiles.spec.ts b/client/src/alignedView/cameraRegistrationFiles.spec.ts
index b3347ba65..82c62e790 100644
--- a/client/src/alignedView/cameraRegistrationFiles.spec.ts
+++ b/client/src/alignedView/cameraRegistrationFiles.spec.ts
@@ -15,13 +15,28 @@ const UNSHIFT = [[1, 0, -5], [0, 1, 3], [0, 0, 1]];
 function values(partial: Partial<CameraRegistrationValues>): CameraRegistrationValues {
   return {
     homographies: {},
-    correspondences: {},
+    observations: {},
     transformTypes: {},
     source: null,
     ...partial,
   };
 }
 
+/** A minimal manual observation with the given points. */
+function observation(points: [number, number, number, number][], extra = {}) {
+  return {
+    imageA: 'a_0000.jpg',
+    imageB: 'b_0000.tif',
+    frame: 0 as number | null,
+    enabled: true,
+    source: 'manual',
+    points: points.map(([ax, ay, bx, by], i) => ({
+      id: i + 1, a: [ax, ay] as [number, number], b: [bx, by] as [number, number],
+    })),
+    ...extra,
+  };
+}
+
 describe('buildPerCameraRegistrationFiles', () => {
   it('groups each pair under its non-reference camera, sorted', () => {
     const files = buildPerCameraRegistrationFiles(values({
@@ -36,11 +51,12 @@ describe('buildPerCameraRegistrationFiles', () => {
     expect(files[0].body.pairs).toStrictEqual([{
       left: 'ir',
       right: 'rgb',
-      points: [],
+      observations: [],
       leftToRight: SHIFT,
       rightToLeft: UNSHIFT,
       transformType: 'similarity',
     }]);
+    expect(files[0].body.version).toBe(2);
   });
 
   it('falls back to right-camera grouping without a reference', () => {
@@ -68,15 +84,41 @@ describe('buildPerCameraRegistrationFiles', () => {
     expect('source' in file.body).toBe(false);
   });
 
-  it('serializes correspondences as leftX leftY rightX rightY rows', () => {
+  it('serializes observations with identity, provenance, and flattened point rows', () => {
     const [file] = buildPerCameraRegistrationFiles(values({
-      correspondences: {
-        'rgb::ir': [{ id: 1, a: [10, 20], b: [12, 22] }],
+      observations: {
+        'rgb::ir': [observation([[10, 20, 12, 22]], {
+          imageA: 'rgb_0412.jpg',
+          imageB: 'ir_0412.tif',
+          frame: 412,
+          source: 'minima_loftr',
+          stats: { numInliers: 1 },
+        })],
       },
     }), 'rgb');
-    expect(file.body.pairs[0].points).toStrictEqual([[10, 20, 12, 22]]);
+    const [row] = file.body.pairs[0].observations!;
+    expect(row).toStrictEqual({
+      frame: 412,
+      imageLeft: 'rgb_0412.jpg',
+      imageRight: 'ir_0412.tif',
+      enabled: true,
+      source: 'minima_loftr',
+      points: [[10, 20, 12, 22]],
+      stats: { numInliers: 1 },
+    });
+    // Points live ONLY inside observations: no flattened duplicate.
+    expect('points' in file.body.pairs[0]).toBe(false);
     expect(file.body.pairs[0].leftToRight).toBeNull();
   });
+
+  it('omits the advisory frame for unresolved observations', () => {
+    const [file] = buildPerCameraRegistrationFiles(values({
+      observations: {
+        'rgb::ir': [observation([[1, 2, 3, 4]], { frame: null })],
+      },
+    }), 'rgb');
+    expect('frame' in file.body.pairs[0].observations![0]).toBe(false);
+  });
 });
 
 describe('filterRegistrationValues', () => {
@@ -105,7 +147,7 @@ describe('registrationValuesSummary', () => {
   it('counts distinct pairs and names their cameras', () => {
     const summary = registrationValuesSummary(values({
       homographies: { 'rgb::ir': { AtoB: SHIFT, BtoA: UNSHIFT } },
-      correspondences: { 'rgb::uv': [{ id: 1, a: [1, 2], b: [3, 4] }] },
+      observations: { 'rgb::uv': [observation([[1, 2, 3, 4]])] },
     }));
     expect(summary.pairCount).toBe(2);
     expect(summary.cameras.sort()).toStrictEqual(['ir', 'rgb', 'uv']);
@@ -115,7 +157,7 @@ describe('registrationValuesSummary', () => {
 describe('mergeRegistrationValues', () => {
   const existing = values({
     homographies: { 'rgb::ir': { AtoB: SHIFT, BtoA: UNSHIFT } },
-    correspondences: { 'rgb::ir': [{ id: 1, a: [1, 2], b: [3, 4] }] },
+    observations: { 'rgb::ir': [observation([[1, 2, 3, 4]])] },
     transformTypes: { 'rgb::ir': 'rigid' },
     source: { producer: 'kamera', run: 'fl07' },
   });
@@ -128,15 +170,45 @@ describe('mergeRegistrationValues', () => {
     expect(merged.transformTypes['rgb::ir']).toBe('rigid');
   });
 
-  it('replaces a named pair wholly, dropping stale points and model choice', () => {
+  it('replaces a matrix-only named pair wholly, dropping stale points and model choice', () => {
     const merged = mergeRegistrationValues(existing, values({
       homographies: { 'rgb::ir': { AtoB: IDENTITY, BtoA: IDENTITY } },
     }), 'calibration_ir.json');
     expect(merged.homographies['rgb::ir'].AtoB).toStrictEqual(IDENTITY);
-    expect(merged.correspondences['rgb::ir']).toBeUndefined();
+    expect(merged.observations['rgb::ir']).toBeUndefined();
     expect(merged.transformTypes['rgb::ir']).toBeUndefined();
   });
 
+  it('merges at observation granularity within a named pair', () => {
+    const base = values({
+      observations: {
+        'rgb::ir': [
+          observation([[1, 2, 3, 4]], { imageA: 'rgb_0001.jpg', imageB: 'ir_0001.tif' }),
+          observation([[5, 6, 7, 8]], {
+            imageA: 'rgb_0002.jpg', imageB: 'ir_0002.tif', source: 'minima_loftr',
+          }),
+        ],
+      },
+    });
+    // A fresh pipeline result for one image pair replaces its own prior
+    // observation and keeps the hand-picked one it doesn't cover.
+    const merged = mergeRegistrationValues(base, values({
+      homographies: { 'rgb::ir': { AtoB: IDENTITY, BtoA: IDENTITY } },
+      observations: {
+        'rgb::ir': [observation([[9, 9, 9, 9], [8, 8, 8, 8]], {
+          imageA: 'rgb_0002.jpg', imageB: 'ir_0002.tif', source: 'minima_loftr',
+        })],
+      },
+    }), 'registration.json');
+    const list = merged.observations['rgb::ir'];
+    expect(list).toHaveLength(2);
+    const manual = list.find((obs) => obs.source === 'manual');
+    expect(manual?.points).toHaveLength(1);
+    const matcher = list.find((obs) => obs.source === 'minima_loftr');
+    expect(matcher?.points).toHaveLength(2);
+    expect(merged.homographies['rgb::ir'].AtoB).toStrictEqual(IDENTITY);
+  });
+
   it('keeps the existing stamp when the import carries none', () => {
     const merged = mergeRegistrationValues(existing, values({
       homographies: { 'rgb::uv': { AtoB: IDENTITY, BtoA: IDENTITY } },
diff --git a/client/src/alignedView/cameraRegistrationFiles.ts b/client/src/alignedView/cameraRegistrationFiles.ts
index afeb86461..edb1b860b 100644
--- a/client/src/alignedView/cameraRegistrationFiles.ts
+++ b/client/src/alignedView/cameraRegistrationFiles.ts
@@ -1,24 +1,28 @@
 /**
- * The portable per-camera image-registration file format, shared by every
- * producer and consumer of <camera>_to_<reference>_registration.json files:
- * the desktop backend (persistence + export), the web client (export
- * downloads + import uploads), and the multicam import seed. One file per
- * non-reference camera, named for the mapping it carries (camera registers
- * onto the reference) and self-identified with
- * `type: 'dive-camera-registration'`; pair bodies name their own cameras,
- * so file names are discovery/provenance only.
+ * The portable per-camera image-registration file format (version 2), shared
+ * by every producer and consumer of <camera>_to_<reference>_registration.json
+ * files: the desktop backend (persistence + export), the web client (export
+ * downloads + import uploads), the multicam import seed, and external
+ * producers (the align_cameras pipeline, KAMERA). One file per non-reference
+ * camera, named for the mapping it carries (camera registers onto the
+ * reference) and self-identified with `type: 'dive-camera-registration'`;
+ * pair bodies name their own cameras, so file names are discovery/provenance
+ * only. Points live ONLY in per-image-pair `observations` -- image names are
+ * the identity, frame indices are resolved by DIVE at load time, and each
+ * observation carries its producer (`source`) and fit-inclusion (`enabled`)
+ * state.
  */
 import {
-  RegistrationFile, RegistrationFilePair, RegistrationSource,
-  CameraCorrespondences, CameraHomographies, CameraTransformTypes,
-  REGISTRATION_FILE_TYPE,
+  RegistrationFile, RegistrationFilePair, RegistrationFileObservation, RegistrationSource,
+  CameraObservations, CameraHomographies, CameraTransformTypes, CorrespondenceObservation,
+  REGISTRATION_FILE_TYPE, REGISTRATION_FILE_VERSION,
 } from './CameraRegistrationStore';
 import { DEFAULT_TRANSFORM_TYPE } from './transform';
 
 /** The complete in-app calibration state for one dataset. */
 export interface CameraRegistrationValues {
   homographies: CameraHomographies;
-  correspondences: CameraCorrespondences;
+  observations: CameraObservations;
   transformTypes: CameraTransformTypes;
   source: RegistrationSource | null;
 }
@@ -50,7 +54,7 @@ export function filterRegistrationValues(
   );
   return {
     homographies: filterRecord(values.homographies),
-    correspondences: filterRecord(values.correspondences),
+    observations: filterRecord(values.observations),
     transformTypes: filterRecord(values.transformTypes),
     source: values.source,
   };
@@ -62,7 +66,7 @@ export function registrationValuesSummary(
 ): { cameras: string[]; pairCount: number } {
   const keys = new Set([
     ...Object.keys(values.homographies),
-    ...Object.keys(values.correspondences),
+    ...Object.keys(values.observations),
     ...Object.keys(values.transformTypes),
   ]);
   const cameras = new Set<string>();
@@ -70,6 +74,21 @@ export function registrationValuesSummary(
   return { cameras: [...cameras], pairCount: keys.size };
 }
 
+/** Serialize one in-app observation as its file row. */
+function toFileObservation(obs: CorrespondenceObservation): RegistrationFileObservation {
+  return {
+    // The frame index is advisory (dataset-local; DIVE re-resolves from the
+    // image names on load) but useful to human readers and cheap to carry.
+    ...(obs.frame !== null ? { frame: obs.frame } : {}),
+    imageLeft: obs.imageA,
+    imageRight: obs.imageB,
+    enabled: obs.enabled,
+    source: obs.source,
+    points: obs.points.map((c) => [c.a[0], c.a[1], c.b[0], c.b[1]]),
+    ...(obs.stats !== undefined ? { stats: obs.stats } : {}),
+  };
+}
+
 /**
  * Convert the in-app calibration state (keyed by directional "left::right")
  * into the self-describing list of file pairs.
@@ -77,7 +96,7 @@ export function registrationValuesSummary(
 function toRegistrationFilePairs(values: CameraRegistrationValues): RegistrationFilePair[] {
   const keys = new Set([
     ...Object.keys(values.homographies),
-    ...Object.keys(values.correspondences),
+    ...Object.keys(values.observations),
     ...Object.keys(values.transformTypes),
   ]);
   return [...keys].map((key) => {
@@ -86,7 +105,7 @@ function toRegistrationFilePairs(values: CameraRegistrationValues): Registration
     return {
       left,
       right,
-      points: (values.correspondences[key] || []).map((c) => [c.a[0], c.a[1], c.b[0], c.b[1]]),
+      observations: (values.observations[key] || []).map(toFileObservation),
       leftToRight: homography ? homography.AtoB : null,
       rightToLeft: homography ? homography.BtoA : null,
       transformType: values.transformTypes[key] || DEFAULT_TRANSFORM_TYPE,
@@ -139,7 +158,7 @@ export function buildPerCameraRegistrationFiles(
         name: registrationFileName(camera, destination),
         body: {
           type: REGISTRATION_FILE_TYPE,
-          version: 1,
+          version: REGISTRATION_FILE_VERSION,
           ...(fileSource ? { source: fileSource } : {}),
           pairs,
         },
@@ -196,13 +215,23 @@ export function unknownCameraWarning(
     + 'transforms will not take effect unless camera names match.';
 }
 
+/** Identity of one observation within a pair: the image pair plus producer. */
+function observationIdentity(obs: CorrespondenceObservation): string {
+  return `${obs.imageA}${obs.imageB}${obs.source}`;
+}
+
 /**
- * Merge a newly imported calibration into a dataset's existing one. Every
- * pair the import names replaces that pair wholly (points, transforms, and
- * model choice together -- a pair is one artifact); pairs it doesn't name
- * are kept, so per-camera files can be imported one at a time to assemble a
- * rig. Producer stamps follow the same policy as multi-file loading:
- * agreement keeps the stamp, disagreement is recorded as a
+ * Merge a newly imported calibration into a dataset's existing one, AT
+ * OBSERVATION GRANULARITY within each pair: an incoming observation replaces
+ * the existing observation with the same (image pair, source) identity, and
+ * observations the import doesn't name -- e.g. hand-picked ones on other
+ * frames -- are kept, so importing a fresh pipeline result updates the image
+ * pairs it covers without discarding manual work. The incoming pair's
+ * matrices and model choice replace the existing pair's (they describe the
+ * newest fit); pairs the import doesn't name at all are kept untouched, so
+ * per-camera files can be imported one at a time to assemble a rig.
+ * Producer stamps follow the same policy as multi-file loading: agreement
+ * keeps the stamp, disagreement is recorded as a
  * `{ mixed: true, files: {...} }` composite so the client can warn about a
  * rig assembled from different calibration generations.
  */
@@ -212,26 +241,35 @@ export function mergeRegistrationValues(
   incomingLabel: string,
 ): CameraRegistrationValues {
   const homographies = { ...existing.homographies };
-  const correspondences = { ...existing.correspondences };
+  const observations = { ...existing.observations };
   const transformTypes = { ...existing.transformTypes };
   const incomingKeys = new Set([
     ...Object.keys(incoming.homographies),
-    ...Object.keys(incoming.correspondences),
+    ...Object.keys(incoming.observations),
     ...Object.keys(incoming.transformTypes),
   ]);
   incomingKeys.forEach((key) => {
     delete homographies[key];
-    delete correspondences[key];
     delete transformTypes[key];
     if (incoming.homographies[key]) {
       homographies[key] = incoming.homographies[key];
     }
-    if (incoming.correspondences[key]?.length) {
-      correspondences[key] = incoming.correspondences[key];
-    }
     if (incoming.transformTypes[key]) {
       transformTypes[key] = incoming.transformTypes[key];
     }
+    const incomingList = incoming.observations[key] || [];
+    if (incomingList.length) {
+      const replaced = new Set(incomingList.map(observationIdentity));
+      observations[key] = [
+        ...(observations[key] || []).filter((obs) => !replaced.has(observationIdentity(obs))),
+        ...incomingList,
+      ];
+    } else if (incoming.homographies[key] || incoming.transformTypes[key]) {
+      // A matrix-only incoming pair (e.g. a producer file with no points)
+      // still replaces the pair as an artifact, points included -- matching
+      // the pre-observations behavior where a named pair replaced wholly.
+      delete observations[key];
+    }
   });
   let source: RegistrationSource | null;
   if (incoming.source === null) {
@@ -246,6 +284,6 @@ export function mergeRegistrationValues(
     };
   }
   return {
-    homographies, correspondences, transformTypes, source,
+    homographies, observations, transformTypes, source,
   };
 }
diff --git a/client/src/alignedView/homography.ts b/client/src/alignedView/homography.ts
index 410908bd3..b78f6c62b 100644
--- a/client/src/alignedView/homography.ts
+++ b/client/src/alignedView/homography.ts
@@ -412,3 +412,41 @@ export function solveHomography(src: Point[], dst: Point[]): Matrix3 {
   const scale = Math.abs(denorm[2][2]) > 1e-12 ? 1 / denorm[2][2] : 1;
   return denorm.map((row) => row.map((value) => value * scale));
 }
+
+/**
+ * Mutual-consistency check for a solved camera triplet: push a grid of
+ * points from camera 1 into camera 3 via the direct homography (`h13`) and
+ * via the composed route (`h23 . h12`), and report the mean/max disagreement
+ * in camera-3 pixels. Near-zero means the three independently fitted pairs
+ * describe one consistent rig; a large value means at least one pair
+ * disagrees with the route through the third camera. `size1` is camera 1's
+ * native (width, height); without it a nominal 1000x1000 grid is used.
+ */
+export function loopClosureResidual(
+  h12: Matrix3,
+  h23: Matrix3,
+  h13: Matrix3,
+  size1: [number, number] = [1000, 1000],
+  grid = 10,
+): { meanPx: number; maxPx: number } {
+  const [width, height] = size1;
+  const composed = matMul3(h23, h12);
+  let sum = 0;
+  let max = 0;
+  let count = 0;
+  for (let i = 0; i < grid; i += 1) {
+    for (let j = 0; j < grid; j += 1) {
+      const p: Point = [
+        (width * i) / (grid - 1),
+        (height * j) / (grid - 1),
+      ];
+      const direct = applyHomography(h13, p);
+      const routed = applyHomography(composed, p);
+      const dist = Math.hypot(direct[0] - routed[0], direct[1] - routed[1]);
+      sum += dist;
+      max = Math.max(max, dist);
+      count += 1;
+    }
+  }
+  return { meanPx: sum / count, maxPx: max };
+}
diff --git a/client/src/cameraStoreOrder.spec.ts b/client/src/cameraStoreOrder.spec.ts
new file mode 100644
index 000000000..fe3aaee30
--- /dev/null
+++ b/client/src/cameraStoreOrder.spec.ts
@@ -0,0 +1,61 @@
+/**
+ * Camera display order. camMap's key order is insertion order from an awaited
+ * per-camera load loop, and entries survive a dataset switch, so anything that
+ * reads "first" or "last" camera as rig geometry -- the registration reference
+ * camera, the direction a loop-closure residual is measured in -- has to go
+ * through the persisted order instead.
+ */
+
+import { describe, expect, it } from 'vitest';
+import CameraStore from './CameraStore';
+
+/**
+ * A loaded multicam rig: cameras added (in whatever order the awaited load
+ * loop produced) and the constructor's 'singleCam' placeholder pruned, as
+ * Viewer.vue does once loading completes.
+ */
+function loadedStore(names: string[]): CameraStore {
+  const s = new CameraStore({ markChangesPending: () => {} });
+  names.forEach((n) => s.addCamera(n));
+  s.removeCamera('singleCam');
+  return s;
+}
+
+describe('CameraStore.orderedCameraNames', () => {
+  it('falls back to camMap order when no order is published', () => {
+    const s = loadedStore(['rgb', 'uv']);
+    expect(s.orderedCameraNames()).toEqual(['rgb', 'uv']);
+  });
+
+  it('returns the persisted order regardless of insertion order', () => {
+    // Arrive out of order, as an awaited load loop can produce.
+    const s = loadedStore(['uv', 'rgb', 'ir']);
+    expect([...s.camMap.value.keys()]).toEqual(['uv', 'rgb', 'ir']);
+    s.displayOrder.value = ['rgb', 'ir', 'uv'];
+    expect(s.orderedCameraNames()).toEqual(['rgb', 'ir', 'uv']);
+  });
+
+  it('ignores a stale order left by a previous dataset', () => {
+    // Order naming cameras this dataset does not have must not win.
+    const s = loadedStore(['left', 'right']);
+    s.displayOrder.value = ['rgb', 'ir', 'uv'];
+    expect(s.orderedCameraNames()).toEqual(['left', 'right']);
+  });
+
+  it('ignores a partial order that omits a present camera', () => {
+    const s = loadedStore(['rgb', 'ir', 'uv']);
+    s.displayOrder.value = ['rgb', 'ir'];
+    expect(s.orderedCameraNames()).toEqual(['rgb', 'ir', 'uv']);
+  });
+
+  it('falls back mid-load, while the singleCam placeholder is still present', () => {
+    // The transient that produced a spurious loop-closure warning: order is
+    // published but the rig is not fully assembled yet.
+    const s = new CameraStore({ markChangesPending: () => {} });
+    s.addCamera('rgb');
+    s.addCamera('ir');
+    s.displayOrder.value = ['rgb', 'ir', 'uv'];
+    expect(s.orderedCameraNames()).toEqual([...s.camMap.value.keys()]);
+    expect(s.orderedCameraNames()).toContain('singleCam');
+  });
+});
diff --git a/client/src/components/LayerManager.vue b/client/src/components/LayerManager.vue
index 0f3f94391..62e6bac01 100644
--- a/client/src/components/LayerManager.vue
+++ b/client/src/components/LayerManager.vue
@@ -285,7 +285,7 @@ export default defineComponent({
         [
           cameraRegistration.activePair,
           cameraRegistration.pickingEnabled,
-          cameraRegistration.correspondences,
+          cameraRegistration.observations,
           cameraRegistration.pendingPoint,
           cameraRegistration.selectedCorrespondenceId,
           cameraRegistration.homographies,
diff --git a/client/src/components/annotators/mediaControllerType.ts b/client/src/components/annotators/mediaControllerType.ts
index 183bfbd2b..95c9bd6de 100644
--- a/client/src/components/annotators/mediaControllerType.ts
+++ b/client/src/components/annotators/mediaControllerType.ts
@@ -84,6 +84,32 @@ export interface AggregateMediaController {
    * identical under today's positional broadcast.
    */
   seekCameraFrame: (camera: string, localFrame: number) => void;
+  /**
+   * Translate one camera's own local frame into another camera's local frame
+   * for the same capture. Cameras drop frames independently, so their local
+   * index spaces diverge -- anything that reads a frame number produced
+   * against one camera (e.g. a registration observation, which is resolved in
+   * its pair's camA space) and then renders or seeks it in a different
+   * camera's space must translate first.
+   *
+   * Returns undefined when `to` has no frame at that capture (an aligned
+   * timeline gap), so callers can omit rather than draw somewhere wrong. A
+   * passthrough when alignment isn't active, where the two spaces coincide.
+   */
+  translateCameraFrame: (
+    from: string, localFrame: number, to: string,
+  ) => number | undefined;
+  /**
+   * The global aligned-timeline slot a camera's own local frame belongs to --
+   * the rig-wide capture number the frame readout and scrubber show. Anything
+   * that displays a frame number derived from one camera should publish it in
+   * this space, or it will disagree with the readout by however many frames
+   * that camera has dropped so far.
+   *
+   * Undefined if the local frame is in no slot; a passthrough when alignment
+   * isn't active, where local and global numbering coincide.
+   */
+  cameraFrameToSlot: (camera: string, localFrame: number) => number | undefined;
 }
 
 /**
diff --git a/client/src/components/annotators/useMediaController.ts b/client/src/components/annotators/useMediaController.ts
index 8a59e6dcf..3f7f47336 100644
--- a/client/src/components/annotators/useMediaController.ts
+++ b/client/src/components/annotators/useMediaController.ts
@@ -155,6 +155,8 @@ export function useMediaController() {
     resizing,
     alignedGapSlots,
     seekCameraFrame: aggregateSeekCameraFrame,
+    translateCameraFrame: aggregateTranslateCameraFrame,
+    cameraFrameToSlot: aggregateCameraFrameToSlot,
   };
   function stopAlignedPlaybackTimer() {
     if (alignedPlaybackTimer !== undefined) {
@@ -657,6 +659,8 @@ export function useMediaController() {
       resizing,
       alignedGapSlots,
       seekCameraFrame: aggregateSeekCameraFrame,
+      translateCameraFrame: aggregateTranslateCameraFrame,
+      cameraFrameToSlot: aggregateCameraFrameToSlot,
     };
 
     subControllers.push(mediaController);
@@ -716,6 +720,32 @@ export function useMediaController() {
     }
   }
 
+  /**
+   * Same-capture translation between two cameras' local frame spaces (see
+   * AggregateMediaController.translateCameraFrame). Without an aligned
+   * timeline the spaces are identical, so the frame passes through.
+   */
+  function aggregateTranslateCameraFrame(from: string, localFrame: number, to: string): number | undefined {
+    if (from === to) {
+      return localFrame;
+    }
+    const resolver = alignedFrameResolver.value;
+    if (!resolver) {
+      return localFrame;
+    }
+    const slot = resolver.resolveGlobalSlot(from, localFrame);
+    return slot === undefined ? undefined : resolver.resolveSlot(slot)[to];
+  }
+
+  /**
+   * A camera's local frame expressed as a global slot (see
+   * AggregateMediaController.cameraFrameToSlot).
+   */
+  function aggregateCameraFrameToSlot(camera: string, localFrame: number): number | undefined {
+    const resolver = alignedFrameResolver.value;
+    return resolver ? resolver.resolveGlobalSlot(camera, localFrame) : localFrame;
+  }
+
   function aggregateNextFrame() {
     const resolver = alignedFrameResolver.value;
     if (resolver) {
@@ -795,6 +825,8 @@ export function useMediaController() {
       resizing,
       alignedGapSlots,
       seekCameraFrame: aggregateSeekCameraFrame,
+      translateCameraFrame: aggregateTranslateCameraFrame,
+      cameraFrameToSlot: aggregateCameraFrameToSlot,
     };
   });
 
diff --git a/client/src/components/controls/Timeline.vue b/client/src/components/controls/Timeline.vue
index f833ae2ee..889b6d32a 100644
--- a/client/src/components/controls/Timeline.vue
+++ b/client/src/components/controls/Timeline.vue
@@ -33,6 +33,16 @@ export default defineComponent({
       type: Boolean,
       default: false,
     },
+    /**
+     * Frames to mark in the work-area (e.g. camera-registration frames while
+     * the Registration panel is open). Frames are in the same local frame
+     * space as the `frame` prop; clicking a marker emits 'seek' with its
+     * frame. Disabled markers render dimmed.
+     */
+    markers: {
+      type: Array as PropType<{ frame: number; enabled: boolean }[]>,
+      default: () => [],
+    },
   },
   emits: ['seek'],
   setup(props, { emit }) {
@@ -97,6 +107,29 @@ export default defineComponent({
       );
     });
 
+    /**
+     * Markers positioned with the exact pixel mapping the playhead uses, so
+     * they stay aligned through zoom/pan; filtered to the visible range.
+     */
+    const visibleMarkers = computed(() => {
+      if (!mounted.value || endFrame.value === startFrame.value) {
+        return [];
+      }
+      return props.markers
+        .filter((marker) => marker.frame >= startFrame.value && marker.frame <= endFrame.value)
+        .map((marker) => ({
+          ...marker,
+          left: Math.round(margin.value + (clientWidth.value - margin.value)
+            * ((marker.frame - startFrame.value) / (endFrame.value - startFrame.value))),
+        }));
+    });
+
+    function markerClick(e: MouseEvent, frame: number) {
+      // Don't let the work-area's drag-seek double-fire on the same click.
+      e.stopPropagation();
+      emit('seek', frame);
+    }
+
     const timeFilterActive = computed(() => trackFilters && trackFilters.timeFilters.value !== null
       && Array.isArray(trackFilters.timeFilters.value));
 
@@ -567,6 +600,8 @@ export default defineComponent({
       containerMousemove,
       workareaMouseup,
       workareaMousedown,
+      visibleMarkers,
+      markerClick,
       workareaMousemove,
       workareaMouseleave,
       minimapFillMousedown,
@@ -625,6 +660,16 @@ export default defineComponent({
       >
         {{ dragTooltipText }}
       </div>
+      <div
+        v-for="marker in visibleMarkers"
+        :key="`registration-marker-${marker.frame}`"
+        class="registration-marker"
+        :class="{ 'registration-marker--disabled': !marker.enabled }"
+        :style="{ left: `${marker.left}px` }"
+        :title="`Registration frame ${marker.frame}`"
+        @mousedown.stop
+        @click="markerClick($event, marker.frame)"
+      />
       <div
         ref="hand"
         class="hand"
@@ -698,6 +743,51 @@ export default defineComponent({
       pointer-events: auto;
     }
 
+    // Registration-frame markers: between the chart child (z 0) and the
+    // playhead hand (z 10).
+    .registration-marker {
+      position: absolute;
+      top: 0;
+      height: 100%;
+      width: 7px;
+      margin-left: -3px;
+      z-index: 5;
+      cursor: pointer;
+
+      &::before {
+        content: '';
+        position: absolute;
+        left: 3px;
+        top: 0;
+        bottom: 0;
+        border-left: 1px dashed #26a69a;
+      }
+
+      &::after {
+        content: '';
+        position: absolute;
+        left: 0;
+        top: 0;
+        width: 7px;
+        height: 7px;
+        background: #26a69a;
+        transform: rotate(45deg);
+      }
+
+      &:hover::before {
+        border-left-width: 2px;
+        border-left-style: solid;
+      }
+
+      &--disabled::before {
+        border-left-color: #757575;
+      }
+
+      &--disabled::after {
+        background: #757575;
+      }
+    }
+
     .time-filter-tooltip {
       position: absolute;
       top: 30px;
diff --git a/client/src/layers/AnnotationLayers/RegistrationKeypointLayer.ts b/client/src/layers/AnnotationLayers/RegistrationKeypointLayer.ts
index 5f5e5ba3e..0c795e8b1 100644
--- a/client/src/layers/AnnotationLayers/RegistrationKeypointLayer.ts
+++ b/client/src/layers/AnnotationLayers/RegistrationKeypointLayer.ts
@@ -302,7 +302,10 @@ export default class RegistrationKeypointLayer extends BaseLayer<RegistrationPoi
       return result;
     }
     const key = this.registration.pairKey(pair.camA, pair.camB);
-    const list = this.registration.correspondences.value[key] || [];
+    // Only the observations belonging to the image pair THIS pane currently
+    // shows: a point picked on frame 100 must not float over frame 3000's
+    // features. Each side resolves against its own camera's frame space.
+    const list = this.registration.correspondencesForCameraFrame(key, cam, this.annotator.frame.value);
     const selectedId = this.registration.selectedCorrespondenceId.value;
     list.forEach((c, i) => {
       const coord = cam === pair.camA ? c.a : c.b;
diff --git a/server/dive_tasks/multicam_pipeline.py b/server/dive_tasks/multicam_pipeline.py
index 2094520e9..e7c95b267 100644
--- a/server/dive_tasks/multicam_pipeline.py
+++ b/server/dive_tasks/multicam_pipeline.py
@@ -95,10 +95,16 @@ def build_multicam_kwiver_settings(
     camera_media: Dict[str, Tuple[List[str], str]],
     *,
     requires_input: bool = False,
+    image_pairs: Optional[Dict[str, List[str]]] = None,
 ) -> Tuple[Dict[str, str], Dict[str, str]]:
     """
     Build KWIVER -s key/value pairs for per-camera inputs/outputs.
 
+    image_pairs is the registration frame subset (camera name -> ordered
+    image names): when present for a camera, ONLY those images are written
+    to its input list, in the given order -- row i of one camera's list
+    pairs with row i of every other's.
+
     Returns (arg_file_pair, out_files) where out_files maps camera name -> output csv basename.
     """
     arg_file_pair: Dict[str, str] = {}
@@ -107,6 +113,20 @@ def build_multicam_kwiver_settings(
     for i, camera in enumerate(cameras):
         key = camera['name']
         media_list, media_type = camera_media[key]
+        subset = (image_pairs or {}).get(key)
+        if subset is not None:
+            if media_type != constants.ImageSequenceType:
+                raise ValueError(
+                    'Image-pair subsets are only supported for image-sequence cameras '
+                    f'(camera "{key}")'
+                )
+            by_name = {Path(path).name: path for path in media_list}
+            missing = [name for name in subset if name not in by_name]
+            if missing:
+                raise ValueError(
+                    f'Camera "{key}" media does not include requested frames: {missing[:5]}'
+                )
+            media_list = [by_name[name] for name in subset]
         output_file_name = f'computed_tracks_{key}.csv'
         output_arg = f'detector_writer{i + 1}:file_name'
         output_arg_tracks = f'track_writer{i + 1}:file_name'
diff --git a/server/dive_tasks/registration_output.py b/server/dive_tasks/registration_output.py
new file mode 100644
index 000000000..e348d9279
--- /dev/null
+++ b/server/dive_tasks/registration_output.py
@@ -0,0 +1,153 @@
+"""
+Ingest align_cameras pipeline output (a DIVE camera-registration JSON,
+format v2) into a web dataset's saved registration meta.
+
+The server-side counterpart of the desktop backend's
+ingestPipelineRegistration: parse the job's registration.json, rebuild the
+cameraHomographies / cameraCorrespondences / cameraTransformTypes meta
+fragments, and merge them into the dataset's current meta AT OBSERVATION
+GRANULARITY -- an incoming observation replaces the existing observation
+with the same (image pair, source) identity, hand-picked observations the
+job didn't cover survive, and pairs the job didn't name are untouched.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from girder_client import GirderClient
+
+MANUAL_SOURCE = 'manual'
+
+
+def _invert3(m: Optional[List[List[float]]]) -> Optional[List[List[float]]]:
+    """Inverse of a row-major 3x3 matrix, or None when missing or singular."""
+    if not m:
+        return None
+    a, b, c = m[0]
+    d, e, f = m[1]
+    g, h, i = m[2]
+    det = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g)
+    if abs(det) < 1e-12:
+        return None
+    adj = [
+        [e * i - f * h, c * h - b * i, b * f - c * e],
+        [f * g - d * i, a * i - c * g, c * d - a * f],
+        [d * h - e * g, b * g - a * h, a * e - b * d],
+    ]
+    return [[value / det for value in row] for row in adj]
+
+
+def _observation_identity(obs: Dict[str, Any]) -> str:
+    return f"{obs.get('imageA')} {obs.get('imageB')} {obs.get('source')}"
+
+
+def _from_registration_pairs(pairs: List[Dict[str, Any]], next_id: int):
+    """Rebuild meta fragments from v2 file pairs (mirrors the client parser)."""
+    homographies: Dict[str, Any] = {}
+    observations: Dict[str, Any] = {}
+    transform_types: Dict[str, Any] = {}
+    for pair in pairs:
+        key = f"{pair['left']}::{pair['right']}"
+        left_to_right = pair.get('leftToRight')
+        right_to_left = pair.get('rightToLeft')
+        if left_to_right or right_to_left:
+            a_to_b = left_to_right or _invert3(right_to_left)
+            b_to_a = right_to_left or _invert3(left_to_right)
+            if a_to_b is not None and b_to_a is not None:
+                homographies[key] = {'AtoB': a_to_b, 'BtoA': b_to_a}
+        rows = []
+        for obs in pair.get('observations') or []:
+            points = []
+            for row in obs.get('points') or []:
+                next_id += 1
+                points.append(
+                    {
+                        'id': next_id,
+                        'a': [row[0], row[1]],
+                        'b': [row[2], row[3]],
+                    }
+                )
+            rows.append(
+                {
+                    'imageA': obs['imageLeft'],
+                    'imageB': obs['imageRight'],
+                    # The client re-resolves frames from the image names on load.
+                    'frame': obs.get('frame'),
+                    'enabled': obs.get('enabled', True),
+                    'source': obs.get('source') or MANUAL_SOURCE,
+                    **({'stats': obs['stats']} if obs.get('stats') is not None else {}),
+                    'points': points,
+                }
+            )
+        if rows:
+            observations[key] = rows
+        transform_types[key] = pair.get('transformType') or 'homography'
+    return homographies, observations, transform_types
+
+
+def ingest_registration_output(
+    gc: GirderClient,
+    folder_id: str,
+    registration_path: Path,
+) -> int:
+    """Merge a pipeline registration JSON into the dataset meta.
+
+    Returns the number of pairs merged. Raises ValueError on a malformed or
+    non-v2 file (one format, one loader -- a pre-v2 file would otherwise
+    load as matrix-only pairs with points silently dropped).
+    """
+    with open(registration_path, encoding='utf-8') as handle:
+        data = json.load(handle)
+    if not isinstance(data, dict) or not isinstance(data.get('pairs'), list):
+        raise ValueError('Not a DIVE camera registration file (expected a "pairs" list)')
+    if data.get('version') != 2:
+        raise ValueError(
+            f"Unsupported registration file version {data.get('version')!r} (expected 2)"
+        )
+
+    current = gc.get(f'dive_dataset/{folder_id}')
+    homographies = dict(current.get('cameraHomographies') or {})
+    observations = {
+        key: list(value) for key, value in (current.get('cameraCorrespondences') or {}).items()
+    }
+    transform_types = dict(current.get('cameraTransformTypes') or {})
+
+    max_id = 0
+    for rows in observations.values():
+        for obs in rows:
+            for point in obs.get('points') or []:
+                max_id = max(max_id, int(point.get('id', 0)))
+
+    incoming_h, incoming_obs, incoming_t = _from_registration_pairs(data['pairs'], max_id)
+
+    named = set(incoming_h) | set(incoming_obs) | set(incoming_t)
+    for key in named:
+        homographies.pop(key, None)
+        transform_types.pop(key, None)
+        if key in incoming_h:
+            homographies[key] = incoming_h[key]
+        if key in incoming_t:
+            transform_types[key] = incoming_t[key]
+        incoming_rows = incoming_obs.get(key) or []
+        if incoming_rows:
+            replaced = {_observation_identity(obs) for obs in incoming_rows}
+            observations[key] = [
+                obs
+                for obs in observations.get(key, [])
+                if _observation_identity(obs) not in replaced
+            ] + incoming_rows
+        elif key in incoming_h or key in incoming_t:
+            # A matrix-only pair replaces the pair as an artifact.
+            observations.pop(key, None)
+
+    gc.sendRestRequest(
+        'PATCH',
+        f'dive_dataset/{folder_id}',
+        json={
+            'cameraHomographies': homographies,
+            'cameraCorrespondences': observations,
+            'cameraTransformTypes': transform_types,
+        },
+    )
+    return len(named)
diff --git a/server/dive_tasks/run_pipeline.py b/server/dive_tasks/run_pipeline.py
index ab3a4aab2..d6c4921f7 100644
--- a/server/dive_tasks/run_pipeline.py
+++ b/server/dive_tasks/run_pipeline.py
@@ -26,6 +26,7 @@
     pipeline_creates_new_dataset,
     pipeline_renumbers_frames,
 )
+from dive_tasks.registration_output import ingest_registration_output
 from dive_tasks.viame_config import Config
 from dive_utils import constants, fromMeta
 from dive_utils.types import GirderModel, MulticamCameraJob, MulticamPipelineJob, PipelineJob
@@ -253,6 +254,7 @@ def run_pipeline(self: Task, params: PipelineJob):
     force_transcoded = params.get('force_transcoded', False)
     runtime_params = params.get('runtime_params') or {}
     frame_range = runtime_params.get('frameRange')
+    image_pairs = runtime_params.get('imagePairs')
     multicam_params: MulticamPipelineJob = params
     multicam_cameras: List[MulticamCameraJob] = multicam_params.get('multicam_cameras') or []
     camera_name = params.get('camera_name')
@@ -305,6 +307,7 @@ def run_pipeline(self: Task, params: PipelineJob):
                 multicam_cameras,
                 camera_media,
                 requires_input=requires_input,
+                image_pairs=image_pairs,
             )
 
             command = [
@@ -366,6 +369,13 @@ def run_pipeline(self: Task, params: PipelineJob):
 
             _inject_dataset_metadata_file(command, gc, _working_directory_path, params, manager)
 
+            is_align_pipeline = 'align_cameras' in pipeline['pipe']
+            if is_align_pipeline:
+                # Camera names for the output JSON, aligned with the
+                # input{i} order used above.
+                camera_names = ','.join(camera['name'] for camera in multicam_cameras)
+                command.append(f'-s register:camera_names={shlex.quote(camera_names)}')
+
             kwiver_params = params.get('kwiver_params')
             if kwiver_params:
                 for key, value in kwiver_params.items():
@@ -435,6 +445,29 @@ def run_pipeline(self: Task, params: PipelineJob):
                 return
 
             manager.updateStatus(JobStatus.PUSHING_OUTPUT)
+            if is_align_pipeline:
+                # The register process writes its JSON atomically in the run
+                # cwd (output_path); a canceled/failed job leaves no file, so
+                # a file present here is a complete result. Substring sniff,
+                # like the desktop collector.
+                registration_files = [
+                    path
+                    for path in output_path.iterdir()
+                    if path.is_file()
+                    and 'registration' in path.name.lower()
+                    and path.suffix == '.json'
+                ]
+                if not registration_files:
+                    manager.write('No registration output produced; see the log above.\n')
+                    return
+                registration_path = registration_files[0]
+                # Keep the raw artifact with the dataset (provenance), then
+                # merge it into the saved registration meta.
+                newfile = gc.uploadFileToFolder(input_folder_id, str(registration_path))
+                gc.addMetadataToItem(str(newfile['itemId']), {'pipeline': pipeline})
+                merged = ingest_registration_output(gc, input_folder_id, registration_path)
+                manager.write(f'Merged camera registration for {merged} pair(s) into the dataset\n')
+                return
             for camera in multicam_cameras:
                 cam_name = camera['name']
                 output_name = out_files[cam_name]
diff --git a/server/dive_utils/models.py b/server/dive_utils/models.py
index db5039e00..3434487e3 100644
--- a/server/dive_utils/models.py
+++ b/server/dive_utils/models.py
@@ -228,12 +228,30 @@ class AttributeTrackFilter(BaseModel):
     primaryDisplay: Optional[bool]
 
 
-class CameraCorrespondence(BaseModel):
+class CorrespondencePoint(BaseModel):
     id: int
     a: Tuple[float, float]
     b: Tuple[float, float]
 
 
+class CameraObservation(BaseModel):
+    """The correspondence points contributed by one image pair of a camera
+    pair (registration format v2). The image names are the identity; ``frame``
+    is a dataset-local index the client re-resolves from them at load time.
+    ``source`` is the producer id ('manual' for hand-picked, else a matcher
+    id like 'minima_loftr'); ``stats`` are free-form producer quality
+    statistics preserved verbatim.
+    """
+
+    imageA: str
+    imageB: str
+    frame: Optional[int]
+    enabled: bool = True
+    source: str = 'manual'
+    stats: Optional[Dict[str, Any]]
+    points: List[CorrespondencePoint]
+
+
 class PairHomography(BaseModel):
     AtoB: List[List[float]]
     BtoA: List[List[float]]
@@ -259,9 +277,11 @@ class MetadataMutable(BaseModel):
     # Per-camera-pair alignment homographies, keyed by directional "left::right".
     # Each value holds the 3x3 AtoB / BtoA matrices.
     cameraHomographies: Optional[Dict[str, PairHomography]]
-    # The picked point correspondences behind those homographies, keyed the same
-    # way. Each entry is a list of {id, a: [x, y], b: [x, y]} pairs.
-    cameraCorrespondences: Optional[Dict[str, List[CameraCorrespondence]]]
+    # The per-image-pair correspondence observations behind those homographies,
+    # keyed the same way. Each entry lists the observations (image-pair
+    # identity, enabled flag, producer source, stats, and points) that pool
+    # into that pair's fit.
+    cameraCorrespondences: Optional[Dict[str, List[CameraObservation]]]
     # The fit model used to compute each pair's homography (translation / rigid /
     # similarity / affine / homography), keyed the same way. Missing entries
     # default to 'similarity' client-side.
diff --git a/server/dive_utils/types.py b/server/dive_utils/types.py
index 162187bcf..3d80dfbf8 100644
--- a/server/dive_utils/types.py
+++ b/server/dive_utils/types.py
@@ -109,6 +109,10 @@ class PipelineDescription(TypedDict):
 
 class PipelineRuntimeParams(TypedDict, total=False):
     frameRange: Optional[Tuple[int, int]]
+    # Multicam registration subset: camera name -> ordered image names for
+    # exactly the frames the job should process (row i of one camera's list
+    # pairs with row i of every other's).
+    imagePairs: Optional[Dict[str, List[str]]]
 
 
 class PipelineParams(TypedDict, total=False):