From e3969e89b152b3e53b9259c504af1946f0c66419 Mon Sep 17 00:00:00 2001
From: Matt Dawkins <matt.dawkins@kitware.com>
Date: Wed, 9 Sep 2026 20:39:57 -0400
Subject: [PATCH 1/5] Handle cross-camera IDs after single-camera pipeline runs

---
 client/dive-common/apispec.ts                 |   2 +
 .../components/RunPipelineMenu.vue            |  74 ++++++++--
 .../SingleCameraAssociationDialog.vue         |  32 +++++
 .../dive-common/singleCameraPipeline.spec.ts  |  45 ++++++
 client/dive-common/singleCameraPipeline.ts    |  48 +++++++
 .../dive-common/stereoAssociationPipeline.ts  |  66 +++++++++
 .../native/singleCameraPipeline.spec.ts       | 106 ++++++++++++++
 .../backend/native/singleCameraPipeline.ts    | 103 ++++++++++++++
 .../platform/desktop/backend/native/viame.ts  |  42 +++++-
 .../frontend/components/ViewerLoader.vue      |   1 +
 .../web-girder/views/ViewerLoader.vue         |   1 +
 server/dive_server/crud_rpc.py                |  40 ++++++
 server/dive_tasks/run_pipeline.py             |  22 ++-
 server/dive_tasks/single_camera_pipeline.py   | 134 ++++++++++++++++++
 server/dive_utils/types.py                    |   2 +
 server/tests/test_single_camera_pipeline.py   | 106 ++++++++++++++
 16 files changed, 801 insertions(+), 23 deletions(-)
 create mode 100644 client/dive-common/components/SingleCameraAssociationDialog.vue
 create mode 100644 client/dive-common/singleCameraPipeline.spec.ts
 create mode 100644 client/dive-common/singleCameraPipeline.ts
 create mode 100644 client/dive-common/stereoAssociationPipeline.ts
 create mode 100644 client/platform/desktop/backend/native/singleCameraPipeline.spec.ts
 create mode 100644 client/platform/desktop/backend/native/singleCameraPipeline.ts
 create mode 100644 server/dive_tasks/single_camera_pipeline.py
 create mode 100644 server/tests/test_single_camera_pipeline.py

diff --git a/client/dive-common/apispec.ts b/client/dive-common/apispec.ts
index 83589a83e..16d42c657 100644
--- a/client/dive-common/apispec.ts
+++ b/client/dive-common/apispec.ts
@@ -121,6 +121,8 @@ interface PipelineRuntimeParams {
 }
 
 interface PipelineParams {
+  /** Postprocess a single-camera run against the rig's existing annotations. */
+  singleCameraMode?: 'associate' | 'separate';
   kwiverParams?: Record<string, string>;
   runtimeParams?: PipelineRuntimeParams;
   /**
diff --git a/client/dive-common/components/RunPipelineMenu.vue b/client/dive-common/components/RunPipelineMenu.vue
index 4b2bfeb54..071df8b91 100644
--- a/client/dive-common/components/RunPipelineMenu.vue
+++ b/client/dive-common/components/RunPipelineMenu.vue
@@ -19,6 +19,11 @@ import {
   NewDatasetJobConfig,
 } from 'dive-common/apispec';
 import JobLaunchDialog from 'dive-common/components/JobLaunchDialog.vue';
+import SingleCameraAssociationDialog from 'dive-common/components/SingleCameraAssociationDialog.vue';
+import {
+  singleCameraContext, SingleCameraMode, validateAssociation,
+} from 'dive-common/singleCameraPipeline';
+import { isStereoInteractiveModeEnabled } from 'dive-common/store/settings';
 import JobConfigFilterTranscodeDialog from 'dive-common/components/JobConfigFilterTranscodeDialog.vue';
 import RunPipelineToast from 'dive-common/components/RunPipelineToast.vue';
 import {
@@ -53,6 +58,7 @@ export default defineComponent({
 
   components: {
     JobLaunchDialog,
+    SingleCameraAssociationDialog,
     JobConfigFilterTranscodeDialog,
     PipelineParamsDialog,
     PipelineCameraAssignDialog,
@@ -61,6 +67,11 @@ export default defineComponent({
   },
 
   props: {
+    /** Persist viewer annotations before inspecting or consuming the other cameras. */
+    beforeRun: {
+      type: Function as PropType<() => Promise<void>>,
+      default: undefined,
+    },
     selectedDatasetIds: {
       type: Array as PropType<string[]>,
       default: () => [],
@@ -120,7 +131,7 @@ export default defineComponent({
   setup(props) {
     const { prompt } = usePrompt();
     const {
-      runPipeline, getPipelineList, hasCalibrationFile, loadConfig, saveConfig,
+      runPipeline, getPipelineList, hasCalibrationFile, loadConfig, saveConfig, loadDetections,
     } = useApi();
     const unsortedPipelines = ref({} as Pipelines);
     const {
@@ -132,6 +143,18 @@ export default defineComponent({
     const menuState: Ref<MenuState> = ref('idle');
     const configuring = computed(() => menuState.value === 'configuring');
     const selectedPipeline: Ref<Pipe | null> = ref(null);
+    const associationCamera = ref('');
+    let resolveAssociation: (mode: SingleCameraMode | null) => void = () => {};
+    function answerAssociation(mode: SingleCameraMode | null) {
+      associationCamera.value = '';
+      resolveAssociation(mode);
+    }
+    function askAssociation(camera: string) {
+      return new Promise<SingleCameraMode | null>((resolve) => {
+        resolveAssociation = resolve;
+        associationCamera.value = camera;
+      });
+    }
     const selectedPipelineName = computed(() => (selectedPipeline.value ? selectedPipeline.value.name : ''));
     function cancelConfig() {
       menuState.value = 'idle';
@@ -357,18 +380,39 @@ export default defineComponent({
         throw new Error('No selected datasets to run on');
       }
       let datasetIds = props.selectedDatasetIds;
-      if (props.cameraNumbers.length === 1 && props.cameraNumbers[0] > 1
-      && (!multiCamPipelineMarkers.includes(pipeline.type)
-      && stereoPipelineMarker !== pipeline.type)) {
-        const cameraNames = props.selectedDatasetIds.map((item) => parentDatasetId(item));
-        const result = await prompt({
-          title: `Running Single Camera Pipeline on ${cameraNames[0]}`,
-          text: ['Running a single pipeline on multi-camera data can produce conflicting track Ids',
-            'Suggest Cancelling and deleting all existing tracks to ensure proper display of the output',
-          ],
-          confirm: true,
-        });
-        if (!result) {
+      const singleCameraModes: Record<string, SingleCameraMode> = {};
+      if (!pipelineCreatesNewDataset(pipeline)
+        && !multiCamPipelineMarkers.includes(pipeline.type)
+        && stereoPipelineMarker !== pipeline.type) {
+        datasetIds = [...datasetIds];
+        try {
+          if (props.cameraNumbers.some((count) => count > 1)) await props.beforeRun?.();
+          const parents = new Set<string>();
+          for (let i = 0; i < datasetIds.length; i += 1) {
+            // eslint-disable-next-line no-await-in-loop
+            const context = await singleCameraContext({ loadConfig, loadDetections }, datasetIds[i]);
+            if (context) {
+              if (parents.has(context.parentId)) {
+                throw new Error('Select only one camera per dataset for a single-camera pipeline run.');
+              }
+              parents.add(context.parentId);
+              datasetIds[i] = context.datasetId;
+              let mode: SingleCameraMode | null = 'separate';
+              if (context.hasOtherTracks) {
+                // eslint-disable-next-line no-await-in-loop
+                mode = await askAssociation(context.datasetId);
+                if (!mode) return;
+              }
+              if (mode === 'associate') {
+                // eslint-disable-next-line no-await-in-loop
+                const calibration = context.stereo && !!await hasCalibrationFile?.(context.parentId);
+                validateAssociation(context.stereo, calibration, isStereoInteractiveModeEnabled());
+              }
+              singleCameraModes[context.datasetId] = mode;
+            }
+          }
+        } catch (error) {
+          await prompt({ title: 'Cannot run pipeline', text: (error as Error).message });
           return;
         }
       }
@@ -393,6 +437,7 @@ export default defineComponent({
           outputParentFolderId,
           kwiverParams: kwiverParamsById?.[id],
           cameraOrder: cameraOrderById[id],
+          singleCameraMode: singleCameraModes[id],
         })),
       ));
     }
@@ -446,6 +491,8 @@ export default defineComponent({
     }
 
     return {
+      associationCamera,
+      answerAssociation,
       jobState,
       pipelines,
       pipelinesNotRunnable,
@@ -481,6 +528,7 @@ export default defineComponent({
 
 <template>
   <div>
+    <SingleCameraAssociationDialog :camera="associationCamera" @answer="answerAssociation" />
     <v-menu
       max-width="230"
       max-height="none"
diff --git a/client/dive-common/components/SingleCameraAssociationDialog.vue b/client/dive-common/components/SingleCameraAssociationDialog.vue
new file mode 100644
index 000000000..08f3a3f36
--- /dev/null
+++ b/client/dive-common/components/SingleCameraAssociationDialog.vue
@@ -0,0 +1,32 @@
+<script lang="ts">
+import { defineComponent } from 'vue';
+
+export default defineComponent({
+  props: { camera: { type: String, default: '' } },
+});
+</script>
+
+<template>
+  <v-dialog :value="!!camera" persistent max-width="560">
+    <v-card>
+      <v-card-title>Associate detections across cameras?</v-card-title>
+      <v-card-text>
+        Another camera already has detections. After running the pipeline on {{ camera }},
+        should DIVE attempt to associate its detections with those on the other camera?
+        Choosing No assigns new IDs above all IDs on the other cameras.
+      </v-card-text>
+      <v-card-actions>
+        <v-btn text @click="$emit('answer', null)">
+          Cancel
+        </v-btn>
+        <v-spacer />
+        <v-btn text @click="$emit('answer', 'separate')">
+          No
+        </v-btn>
+        <v-btn color="primary" @click="$emit('answer', 'associate')">
+          Yes
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
diff --git a/client/dive-common/singleCameraPipeline.spec.ts b/client/dive-common/singleCameraPipeline.spec.ts
new file mode 100644
index 000000000..29cce85c4
--- /dev/null
+++ b/client/dive-common/singleCameraPipeline.spec.ts
@@ -0,0 +1,45 @@
+import type { Api, DatasetConfig } from './apispec';
+import { remapCsvIds, singleCameraContext, validateAssociation } from './singleCameraPipeline';
+
+describe('single camera pipeline decisions', () => {
+  const config = {
+    subType: 'stereo',
+    multiCamMedia: { cameras: { left: {}, right: {}, third: {} }, defaultDisplay: 'left' },
+  } as unknown as DatasetConfig;
+  function apiFor(ids: Record<string, number[]>) {
+    return {
+      loadConfig: vi.fn(async () => config),
+      loadDetections: vi.fn(async (id: string) => ({ tracks: (ids[id] || []).map((value) => ({ id: value })) })),
+    } as unknown as Pick<Api, 'loadConfig' | 'loadDetections'>;
+  }
+
+  it('checks every other camera and resolves parent-only runs to defaultDisplay', async () => {
+    const api = apiFor({ 'rig/third': [500] });
+    const result = await singleCameraContext(api, 'rig');
+    expect(result).toMatchObject({ datasetId: 'rig/left', hasOtherTracks: true });
+    expect(api.loadDetections).toHaveBeenCalledWith('rig/right');
+    expect(api.loadDetections).toHaveBeenCalledWith('rig/third');
+    expect(api.loadDetections).not.toHaveBeenCalledWith('rig/left');
+  });
+
+  it('does not prompt just because the selected camera has tracks', async () => {
+    const result = await singleCameraContext(apiFor({ 'rig/right': [22] }), 'rig/right');
+    expect(result).toMatchObject({ datasetId: 'rig/right', hasOtherTracks: false });
+  });
+
+  it('rejects unsupported multicam, missing calibration, and disabled stereo', () => {
+    expect(() => validateAssociation(false, true, true)).toThrow('not implemented');
+    expect(() => validateAssociation(true, false, true)).toThrow('calibration file');
+    expect(() => validateAssociation(true, true, false)).toThrow('Enable stereo');
+    expect(() => validateAssociation(true, true, true)).not.toThrow();
+  });
+
+  it('moves every ID above the other cameras and preserves repeated track states', () => {
+    const csv = '# comment\n2,frame,0,1,2,3,4,.8,-1\n2,frame,3,1,2,3,4,.9,-1\n0,frame,5,1,2,3,4,.7,-1\n';
+    expect(remapCsvIds(csv, 999)).toBe(csv.replace(/^2,/gm, '1000,').replace(/^0,/gm, '1001,'));
+  });
+
+  it('refuses unsafe numeric IDs', () => {
+    expect(() => remapCsvIds('1,frame,0,1,2,3,4,1,-1\n', Number.MAX_SAFE_INTEGER)).toThrow('integer range');
+  });
+});
diff --git a/client/dive-common/singleCameraPipeline.ts b/client/dive-common/singleCameraPipeline.ts
new file mode 100644
index 000000000..b41ecf559
--- /dev/null
+++ b/client/dive-common/singleCameraPipeline.ts
@@ -0,0 +1,48 @@
+import type { Api, PipelineParams } from './apispec';
+import { parseCompositeDatasetId } from './compositeDatasetId';
+
+export const associationCalibrationError = 'Stereo association requires a loaded calibration file.';
+export const associationMulticamError = 'Detection association in multi-camera mode is not implemented yet.';
+
+export function validateAssociation(stereo: boolean, calibration: boolean, enabled: boolean) {
+  if (!stereo) throw new Error(associationMulticamError);
+  if (!calibration) throw new Error(associationCalibrationError);
+  if (!enabled) throw new Error('Enable stereo features before associating detections.');
+}
+
+/** Resolve the actual camera scope; library runs may use the parent id. */
+export async function singleCameraContext(
+  api: Pick<Api, 'loadConfig' | 'loadDetections'>,
+  datasetId: string,
+) {
+  const { parentId, cameraName } = parseCompositeDatasetId(datasetId);
+  const config = await api.loadConfig(parentId);
+  const media = config.multiCamMedia;
+  if (!media || Object.keys(media.cameras).length < 2) return null;
+  const selected = cameraName || media.defaultDisplay;
+  const others = Object.keys(media.cameras).filter((name) => name !== selected);
+  const annotations = await Promise.all(others.map((name) => api.loadDetections(`${parentId}/${name}`)));
+  return {
+    parentId,
+    datasetId: `${parentId}/${selected}`,
+    stereo: config.subType === 'stereo',
+    hasOtherTracks: annotations.some((data) => data.tracks.length > 0),
+  };
+}
+
+export type SingleCameraMode = NonNullable<PipelineParams['singleCameraMode']>;
+
+/** Remap every output id, preserving repeated track states and all other CSV fields. */
+export function remapCsvIds(csv: string, maximumOtherId: number): string {
+  let nextId = maximumOtherId + 1;
+  const ids = new Map<string, number>();
+  return csv.replace(/^(\s*\d+)(?=,)/gm, (id) => {
+    const key = String(Number(id));
+    if (!ids.has(key)) {
+      if (!Number.isSafeInteger(nextId)) throw new Error('Track ID exceeds the supported integer range.');
+      ids.set(key, nextId);
+      nextId += 1;
+    }
+    return String(ids.get(key));
+  });
+}
diff --git a/client/dive-common/stereoAssociationPipeline.ts b/client/dive-common/stereoAssociationPipeline.ts
new file mode 100644
index 000000000..3b9d6a7c1
--- /dev/null
+++ b/client/dive-common/stereoAssociationPipeline.ts
@@ -0,0 +1,66 @@
+/** Geometry-only pairing needs timestamps, but does not need to decode camera media.
+ * A one-pixel image repeated through the last annotated frame supplies that clock.
+ * frame_list is one-based; downsample supplies DIVE's zero-based frame numbers.
+ */
+export const stereoAssociationPipeline = `config _scheduler
+  :type thread_per_process
+
+process clock
+  :: frame_list_input
+  :image_list_file frames.txt
+  :image_reader:type ocv
+
+process timestamps
+  :: downsample
+  :renumber_frames true
+
+connect from clock.timestamp
+        to timestamps.timestamp
+
+process pairing
+  :: compute_measurements
+  :matching_methods input_pairs_only
+  :detection_pairing_method calibration
+  :detection_pairing_threshold 10
+  :calibration_file calibration.json
+  :accumulate_track_pairings true
+  :pairing_resolution_method most_likely
+  :detection_split_threshold 1
+  :output_unmatched true
+  :average_stereo_classes false
+
+connect from timestamps.timestamp
+        to pairing.timestamp
+${[1, 2].map((side) => `
+process reader${side}
+  :: read_object_track
+  :file_name input${side}.csv
+  :reader:type viame_csv
+
+connect from clock.image_file_name
+        to reader${side}.image_file_name
+connect from reader${side}.object_track_set
+        to pairing.object_track_set${side}
+
+process writer${side}
+  :: write_object_track
+  :file_name associated${side}.csv
+  :writer:type viame_csv
+
+connect from pairing.object_track_set${side}
+        to writer${side}.object_track_set
+`).join('')}`;
+
+export function lastCsvFrame(csv: string): number {
+  let maximum = -1;
+  csv.split(/\r?\n/).forEach((row) => {
+    if (/^\s*\d+,/.test(row)) {
+      // A quoted image identifier may itself contain commas.
+      const fields = row.match(/^\s*\d+,(?:"(?:[^"]|"")*"|[^,]*),([^,]*),/);
+      const frame = fields ? Number(fields[1]) : NaN;
+      if (!Number.isSafeInteger(frame) || frame < 0) throw new Error('Invalid detection frame number.');
+      maximum = Math.max(maximum, frame);
+    }
+  });
+  return maximum;
+}
diff --git a/client/platform/desktop/backend/native/singleCameraPipeline.spec.ts b/client/platform/desktop/backend/native/singleCameraPipeline.spec.ts
new file mode 100644
index 000000000..9b7fb00a4
--- /dev/null
+++ b/client/platform/desktop/backend/native/singleCameraPipeline.spec.ts
@@ -0,0 +1,106 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import type { Settings, JsonConfig } from 'platform/desktop/constants';
+import { finishSingleCameraRun, prepareSingleCameraRun } from './singleCameraPipeline';
+import * as common from './common';
+
+vi.mock('./common', () => ({
+  getValidatedProjectDir: vi.fn(async (_settings, id) => ({ datasetFileAbsPath: id, trackFileAbsPath: id })),
+  loadJsonConfig: vi.fn(),
+  loadAnnotationFile: vi.fn(),
+  ingestDataFiles: vi.fn(async () => ({ meta: {} })),
+  saveConfig: vi.fn(),
+}));
+
+describe('single camera result processing', () => {
+  const settings = {} as Settings;
+  let directory: string;
+  let meta: JsonConfig;
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    directory = await fs.mkdtemp(path.join(os.tmpdir(), 'dive-single-camera-'));
+    meta = {
+      subType: 'stereo',
+      multiCam: {
+        cameras: { left: {}, right: {} },
+        cameraOrder: ['left', 'right'],
+        defaultDisplay: 'right',
+        calibration: path.join(directory, 'rig.npz'),
+      },
+    } as unknown as JsonConfig;
+    await fs.writeFile(meta.multiCam!.calibration!, 'calibration');
+    vi.mocked(common.loadJsonConfig).mockResolvedValue(meta);
+    vi.mocked(common.loadAnnotationFile).mockResolvedValue({ version: 2, tracks: { 800: { id: 800, features: [], confidencePairs: [['fish', 1]] } }, groups: {} } as never);
+  });
+  afterEach(async () => fs.remove(directory));
+
+  it('validates stereo calibration before launching and resolves the default camera', async () => {
+    expect(await prepareSingleCameraRun(settings, 'rig', 'associate')).toMatchObject({ camera: 'right' });
+    meta.subType = 'multicam';
+    await expect(prepareSingleCameraRun(settings, 'rig/right', 'associate')).rejects.toThrow('not implemented');
+    meta.subType = 'stereo';
+    meta.multiCam!.calibration = undefined;
+    await expect(prepareSingleCameraRun(settings, 'rig/right', 'associate')).rejects.toThrow('calibration');
+  });
+
+  it('uses all other cameras, prefers detections over a header-only track file, and changes only the target', async () => {
+    meta.subType = 'multicam';
+    meta.multiCam!.cameras.third = {} as never;
+    meta.multiCam!.cameraOrder!.push('third');
+    vi.mocked(common.loadAnnotationFile).mockImplementation(async (id) => ({
+      tracks: { track: { id: id.endsWith('third') ? 2000 : 800 } },
+    } as never));
+    const context = (await prepareSingleCameraRun(settings, 'rig/right', 'separate'))!;
+    const detections = path.join(directory, 'detections.csv');
+    const tracks = path.join(directory, 'tracks.csv');
+    await fs.writeFile(detections, '2,image,0,1,2,3,4,1,-1\n2,image,1,1,2,3,4,1,-1\n');
+    await fs.writeFile(tracks, '# empty tracks\n');
+    const run = vi.fn();
+    await finishSingleCameraRun(settings, context, [detections, tracks], directory, run);
+    expect(await fs.readFile(path.join(directory, 'separate-camera.csv'), 'utf8')).toBe(
+      '2001,image,0,1,2,3,4,1,-1\n2001,image,1,1,2,3,4,1,-1\n',
+    );
+    expect(run).not.toHaveBeenCalled();
+    expect(common.ingestDataFiles).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(common.ingestDataFiles).mock.calls[0][1]).toBe('rig/right');
+  });
+
+  it('does not import either camera if association fails', async () => {
+    const context = (await prepareSingleCameraRun(settings, 'rig/right', 'associate'))!;
+    const output = path.join(directory, 'detections.csv');
+    await fs.writeFile(output, '1,image,0,1,2,3,4,1,-1\n');
+    const run = vi.fn(async (cwd: string) => {
+      expect(await fs.readFile(path.join(cwd, 'input2.csv'), 'utf8')).toContain('1,image,0');
+      expect(await fs.readFile(path.join(cwd, 'associate.pipe'), 'utf8')).toContain('calibration.npz');
+      throw new Error('association failed');
+    });
+    await expect(finishSingleCameraRun(settings, context, [output], directory, run)).rejects.toThrow('association failed');
+    expect(run).toHaveBeenCalledOnce();
+    expect(common.ingestDataFiles).not.toHaveBeenCalled();
+  });
+
+  it('imports both associated outputs using the stored left/right order', async () => {
+    const context = (await prepareSingleCameraRun(settings, 'rig/right', 'associate'))!;
+    const output = path.join(directory, 'detections.csv');
+    await fs.writeFile(output, '1,image,0,1,2,3,4,1,-1\n');
+    const run = vi.fn(async (cwd: string) => {
+      await fs.writeFile(path.join(cwd, 'associated1.csv'), '42,left,0,1,2,3,4,1,-1\n');
+      await fs.writeFile(path.join(cwd, 'associated2.csv'), '42,right,0,1,2,3,4,1,-1\n');
+    });
+    await finishSingleCameraRun(settings, context, [output], directory, run);
+    expect(common.ingestDataFiles).toHaveBeenCalledWith(settings, 'rig', [], {
+      left: path.join(directory, 'association/associated1.csv'),
+      right: path.join(directory, 'association/associated2.csv'),
+    });
+  });
+
+  it('keeps original output IDs when the other camera has no tracks', async () => {
+    vi.mocked(common.loadAnnotationFile).mockResolvedValue({ tracks: {}, groups: {}, version: 2 });
+    const context = (await prepareSingleCameraRun(settings, 'rig/right', 'separate'))!;
+    const output = path.join(directory, 'detections.csv');
+    await fs.writeFile(output, '27,image,0,1,2,3,4,1,-1\n');
+    await finishSingleCameraRun(settings, context, [output], directory, vi.fn());
+    expect(common.ingestDataFiles).toHaveBeenCalledWith(settings, 'rig/right', [output], undefined);
+  });
+});
diff --git a/client/platform/desktop/backend/native/singleCameraPipeline.ts b/client/platform/desktop/backend/native/singleCameraPipeline.ts
new file mode 100644
index 000000000..632465701
--- /dev/null
+++ b/client/platform/desktop/backend/native/singleCameraPipeline.ts
@@ -0,0 +1,103 @@
+import fs from 'fs-extra';
+import path from 'path';
+import type { Settings } from 'platform/desktop/constants';
+import { parseCompositeDatasetId } from 'dive-common/compositeDatasetId';
+import { orderedMultiCamCameraNames } from 'dive-common/multicamDisplay';
+import {
+  SingleCameraMode, remapCsvIds, associationCalibrationError, associationMulticamError,
+} from 'dive-common/singleCameraPipeline';
+import { stereoAssociationPipeline, lastCsvFrame } from 'dive-common/stereoAssociationPipeline';
+import { serializeFile } from '../serializers/viame';
+import * as common from './common';
+
+export async function prepareSingleCameraRun(settings: Settings, datasetId: string, mode: SingleCameraMode = 'separate') {
+  if (mode !== 'associate' && mode !== 'separate') throw new Error('Invalid single-camera association mode.');
+  const { parentId, cameraName } = parseCompositeDatasetId(datasetId);
+  const info = await common.getValidatedProjectDir(settings, parentId);
+  const meta = await common.loadJsonConfig(info.datasetFileAbsPath);
+  if (!meta.multiCam || Object.keys(meta.multiCam.cameras).length < 2) {
+    if (mode === 'associate') throw new Error(associationMulticamError);
+    return null;
+  }
+  const camera = cameraName || meta.multiCam.defaultDisplay;
+  const cameras = orderedMultiCamCameraNames(meta.multiCam);
+  if (!cameras.includes(camera)) throw new Error(`Unknown camera: ${camera}`);
+  if (mode === 'associate') {
+    if (meta.subType !== 'stereo' || cameras.length !== 2) throw new Error(associationMulticamError);
+    if (!meta.multiCam.calibration || !await fs.pathExists(meta.multiCam.calibration)) {
+      throw new Error(associationCalibrationError);
+    }
+  }
+  return {
+    parentId, camera, cameras, mode, calibration: meta.multiCam.calibration,
+  };
+}
+
+/** Read the other cameras again at completion, so ID allocation uses current annotations. */
+export async function finishSingleCameraRun(
+  settings: Settings,
+  context: NonNullable<Awaited<ReturnType<typeof prepareSingleCameraRun>>>,
+  outputs: string[],
+  workingDir: string,
+  runAssociation: (directory: string) => Promise<void>,
+): Promise<void> {
+  async function ingest(datasetId: string, paths: string[], cameras?: Record<string, string>) {
+    const { meta } = await common.ingestDataFiles(settings, datasetId, paths, cameras);
+    if (meta.attributes) {
+      await common.saveConfig(settings, context.parentId, { attributes: meta.attributes });
+    }
+  }
+  const available = await Promise.all(outputs.map(async (file) => (
+    await fs.pathExists(file) && (await fs.stat(file)).size ? file : null
+  )));
+  const candidates = available.filter((file): file is string => !!file);
+  const populated = await Promise.all(candidates.map(async (file) => (
+    lastCsvFrame(await fs.readFile(file, 'utf8')) >= 0 ? file : null
+  )));
+  const output = populated.filter((file): file is string => !!file).pop() || candidates.pop();
+  if (!output) throw new Error('Pipeline produced no detection or track output.');
+  const others = await Promise.all(context.cameras.filter((name) => name !== context.camera).map(async (name) => {
+    const info = await common.getValidatedProjectDir(settings, `${context.parentId}/${name}`);
+    return {
+      name,
+      annotations: await common.loadAnnotationFile(info.trackFileAbsPath),
+      meta: await common.loadJsonConfig(info.datasetFileAbsPath),
+    };
+  }));
+  let maximumId = -1;
+  others.forEach(({ annotations }) => Object.values(annotations.tracks).forEach((track) => {
+    maximumId = Math.max(maximumId, track.id);
+  }));
+  if (maximumId < 0 || lastCsvFrame(await fs.readFile(output, 'utf8')) < 0) {
+    await ingest(`${context.parentId}/${context.camera}`, [output]);
+    return;
+  }
+  if (context.mode === 'separate') {
+    const csv = remapCsvIds(await fs.readFile(output, 'utf8'), maximumId);
+    const safeOutput = path.join(workingDir, 'separate-camera.csv');
+    await fs.writeFile(safeOutput, csv);
+    await ingest(`${context.parentId}/${context.camera}`, [safeOutput]);
+    return;
+  }
+  const directory = path.join(workingDir, 'association');
+  await fs.ensureDir(directory);
+  const side = context.cameras.indexOf(context.camera) + 1;
+  await fs.copyFile(output, path.join(directory, `input${side}.csv`));
+  await serializeFile(path.join(directory, `input${3 - side}.csv`), others[0].annotations, others[0].meta);
+  const inputs = await Promise.all([1, 2].map((index) => fs.readFile(path.join(directory, `input${index}.csv`), 'utf8')));
+  const lastFrame = Math.max(...inputs.map(lastCsvFrame));
+  const calibrationName = `calibration${path.extname(context.calibration!)}`;
+  await fs.copy(context.calibration!, path.join(directory, calibrationName));
+  await fs.writeFile(path.join(directory, 'clock.ppm'), 'P3\n1 1\n255\n0 0 0\n');
+  await fs.writeFile(path.join(directory, 'frames.txt'), `${path.join(directory, 'clock.ppm')}\n`.repeat(lastFrame + 1));
+  await fs.writeFile(path.join(directory, 'associate.pipe'), stereoAssociationPipeline.replace('calibration.json', calibrationName));
+  await runAssociation(directory);
+  const paired = Object.fromEntries(context.cameras.map((name, index) => [name, path.join(directory, `associated${index + 1}.csv`)]));
+  // Validate both outputs before importing either camera.
+  await Promise.all(Object.values(paired).map(async (file) => {
+    if (!await fs.pathExists(file) || lastCsvFrame(await fs.readFile(file, 'utf8')) < 0) {
+      throw new Error('Stereo association did not produce annotations for both cameras.');
+    }
+  }));
+  await ingest(context.parentId, [], paired);
+}
diff --git a/client/platform/desktop/backend/native/viame.ts b/client/platform/desktop/backend/native/viame.ts
index a475c68d3..971ef2a5b 100644
--- a/client/platform/desktop/backend/native/viame.ts
+++ b/client/platform/desktop/backend/native/viame.ts
@@ -34,6 +34,7 @@ import { describeSource, scoringCliArgs } from 'dive-common/scoring/metrics';
 import { SCORING_RESULT_VERSION } from 'dive-common/scoring/types';
 import type { RawScoringMatches, ScoringResultFile } from 'dive-common/scoring/types';
 import * as common from './common';
+import { prepareSingleCameraRun, finishSingleCameraRun } from './singleCameraPipeline';
 import {
   jobFileEchoMiddleware, createWorkingDirectory, createCustomWorkingDirectory, splitExt,
   buildTrainingExitManifest,
@@ -193,7 +194,8 @@ async function runPipeline(
   viameConstants: ViameConstants,
   forceTranscodedVideo?: boolean,
 ): Promise<DesktopJob> {
-  const { datasetId, pipeline } = runPipelineArgs;
+  const { pipeline } = runPipelineArgs;
+  let { datasetId } = 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
@@ -211,6 +213,12 @@ async function runPipeline(
     throw new Error(isValid);
   }
 
+  const singleCamera = !createsNewDataset && pipeline.type !== stereoPipelineMarker
+    && !multiCamPipelineMarkers.includes(pipeline.type)
+    ? await prepareSingleCameraRun(settings, datasetId, runPipelineArgs.pipelineParams?.singleCameraMode)
+    : null;
+  if (singleCamera) datasetId = `${singleCamera.parentId}/${singleCamera.camera}`;
+
   let pipelinePath = npath.join(settings.viamePath, PipelineRelativeDir, pipeline.pipe);
   if (runPipelineArgs.pipeline.type === 'trained') {
     pipelinePath = pipeline.pipe;
@@ -575,7 +583,7 @@ async function runPipeline(
   job.stdout.on('data', jobFileEchoMiddleware(jobBase, updater, joblog));
   job.stderr.on('data', jobFileEchoMiddleware(jobBase, updater, joblog));
 
-  job.on('exit', async (code) => {
+  job.on('close', async (code) => {
     let exitCode = code;
     const bodyText = [''];
     if (code === 0) {
@@ -593,10 +601,32 @@ async function runPipeline(
             }
           }
 
-          const { meta: newMeta } = await common.ingestDataFiles(settings, datasetId, [finalDetectorOutput, finalTrackOutput], multiOutFiles);
-          if (newMeta) {
-            meta.attributes = newMeta.attributes;
-            await common.saveConfig(settings, datasetId, meta);
+          if (singleCamera) {
+            await finishSingleCameraRun(settings, singleCamera, [finalDetectorOutput, finalTrackOutput], jobWorkDir, async (directory) => {
+              updater({ ...jobBase, body: ['Associating stereo detections...'] });
+              const association = observeChild(spawn(`${viameConstants.setupScriptAbs} && "${viameConstants.viameExe}" run associate.pipe`, {
+                shell: viameConstants.shell,
+                cwd: directory,
+              }));
+              // Keep cancellation pointed at the process that is currently running.
+              jobBase.pid = association.pid ?? -1;
+              updater({ ...jobBase, body: ['Associating stereo detections...'] });
+              association.stdout.on('data', jobFileEchoMiddleware(jobBase, updater, joblog));
+              association.stderr.on('data', jobFileEchoMiddleware(jobBase, updater, joblog));
+              await new Promise<void>((resolve, reject) => {
+                association.on('error', reject);
+                association.on('close', (status) => {
+                  if (status === 0) resolve();
+                  else reject(new Error(`Stereo association failed (exit ${status}).`));
+                });
+              });
+            });
+          } else {
+            const { meta: newMeta } = await common.ingestDataFiles(settings, datasetId, [finalDetectorOutput, finalTrackOutput], multiOutFiles);
+            if (newMeta) {
+              meta.attributes = newMeta.attributes;
+              await common.saveConfig(settings, datasetId, meta);
+            }
           }
         }
 
diff --git a/client/platform/desktop/frontend/components/ViewerLoader.vue b/client/platform/desktop/frontend/components/ViewerLoader.vue
index 36059beac..56eaef38b 100644
--- a/client/platform/desktop/frontend/components/ViewerLoader.vue
+++ b/client/platform/desktop/frontend/components/ViewerLoader.vue
@@ -2087,6 +2087,7 @@ export default defineComponent({
       </template>
       <template #title-right>
         <RunPipelineMenu
+          :before-run="() => viewerRef.save()"
           :selected-dataset-ids="[modifiedId]"
           :sub-type-list="subTypeList"
           :camera-numbers="camNumbers"
diff --git a/client/platform/web-girder/views/ViewerLoader.vue b/client/platform/web-girder/views/ViewerLoader.vue
index a565b1304..0b3d4b145 100644
--- a/client/platform/web-girder/views/ViewerLoader.vue
+++ b/client/platform/web-girder/views/ViewerLoader.vue
@@ -514,6 +514,7 @@ export default defineComponent({
       <template #title-right>
         <RunPipelineMenu
           v-if="pipelinesEnabled"
+          :before-run="() => viewerRef.save(set)"
           v-bind="{
             buttonOptions,
             menuOptions,
diff --git a/server/dive_server/crud_rpc.py b/server/dive_server/crud_rpc.py
index a15d450d2..675267726 100644
--- a/server/dive_server/crud_rpc.py
+++ b/server/dive_server/crud_rpc.py
@@ -25,6 +25,7 @@
     missing_registrations,
     pipeline_requires_input,
 )
+from dive_tasks.pipeline_creates_dataset import pipeline_creates_new_dataset
 from dive_tasks.utils import choose_annotation_fps
 from dive_utils import (
     TRUTHY_META_VALUES,
@@ -468,6 +469,45 @@ def run_pipeline(
     if camera_name:
         params['camera_name'] = camera_name
         multi_cam_meta = fromMeta(multicam_parent, constants.MultiCamMarker, default={}) or {}
+        if not pipeline_creates_new_dataset(pipeline):
+            mode = (pipeline_params or {}).get('singleCameraMode', 'separate')
+            if mode not in ('associate', 'separate'):
+                raise RestException('Invalid single-camera association mode', code=400)
+            cameras = []
+            for name in crud_dataset._multicam_camera_order(multi_cam_meta):
+                child = Folder().load(
+                    multi_cam_meta['cameras'][name]['folderId'],
+                    level=AccessType.WRITE if mode == 'associate' else AccessType.READ,
+                    user=user,
+                    exc=True,
+                )
+                cameras.append({'name': name, 'folder_id': str(child['_id'])})
+            association_calibration = None
+            if mode == 'associate':
+                if (
+                    fromMeta(multicam_parent, constants.SubTypeMarker, default=None) != 'stereo'
+                    or len(cameras) != 2
+                ):
+                    raise RestException(
+                        'Detection association in multi-camera mode is not implemented yet.', code=400
+                    )
+                calibration_pipeline: types.PipelineDescription = {
+                    **pipeline,
+                    'metadata': {'requiresCalibration': True},
+                }
+                association_calibration = crud_dataset.resolve_stereo_calibration_item_id(
+                    multicam_parent, calibration_pipeline
+                )
+                if not association_calibration:
+                    raise RestException(
+                        'Stereo association requires a loaded calibration file.', code=400
+                    )
+            params['single_camera'] = {
+                'mode': mode,
+                'camera': camera_name,
+                'cameras': cameras,
+                'calibration_item_id': association_calibration,
+            }
         default_display = multi_cam_meta.get('defaultDisplay')
         if default_display:
             params['multicam_default_display'] = default_display
diff --git a/server/dive_tasks/run_pipeline.py b/server/dive_tasks/run_pipeline.py
index 36e60baf5..c9d98946b 100644
--- a/server/dive_tasks/run_pipeline.py
+++ b/server/dive_tasks/run_pipeline.py
@@ -29,6 +29,7 @@
     pipeline_renumbers_frames,
 )
 from dive_tasks.registration_output import ingest_registration_output
+from dive_tasks.single_camera_pipeline import csv_rows, finish_single_camera_run
 from dive_tasks.viame_config import Config
 from dive_utils import constants, fromMeta
 from dive_utils.types import GirderModel, MulticamCameraJob, MulticamPipelineJob, PipelineJob
@@ -633,12 +634,25 @@ def report_extraction(message: str) -> None:
         else:
             output_file = detector_output_file
 
+        # Some detectors also create a track CSV containing only its header.
+        if (
+            params.get('single_camera')
+            and Path(detector_output_file).exists()
+            and not csv_rows(Path(output_file).read_text())
+        ):
+            output_file = detector_output_file
+
         # Filter output CSV by frame range for videos
         if frame_range is not None and input_type == constants.VideoType:
             output_file = filter_csv_by_frame_range(output_file, frame_range)
 
+        outputs = [(output_folder_id, Path(output_file))]
+        if params.get('single_camera'):
+            outputs = finish_single_camera_run(
+                self, context, manager, conf, gc, params, output_file, output_path
+            )
         manager.updateStatus(JobStatus.PUSHING_OUTPUT)
-        newfile = gc.uploadFileToFolder(output_folder_id, output_file)
-
-        gc.addMetadataToItem(str(newfile["itemId"]), {"pipeline": pipeline})
-        gc.post(f'dive_rpc/postprocess/{output_folder_id}', data={"skipJobs": True})
+        for folder_id, result in outputs:
+            newfile = gc.uploadFileToFolder(folder_id, str(result))
+            gc.addMetadataToItem(str(newfile["itemId"]), {"pipeline": pipeline})
+            gc.post(f'dive_rpc/postprocess/{folder_id}', data={"skipJobs": True})
diff --git a/server/dive_tasks/single_camera_pipeline.py b/server/dive_tasks/single_camera_pipeline.py
new file mode 100644
index 000000000..e01d0d7e8
--- /dev/null
+++ b/server/dive_tasks/single_camera_pipeline.py
@@ -0,0 +1,134 @@
+"""Postprocess single-camera results before publishing annotations."""
+
+import csv
+from pathlib import Path
+import re
+import shlex
+import shutil
+
+
+def csv_rows(text):
+    return [row for row in csv.reader(text.splitlines()) if row and row[0].strip().isdigit()]
+
+
+def remap_csv_ids(text, maximum_other_id):
+    ids = {}
+
+    def replace(match):
+        key = int(match.group())
+        if key not in ids:
+            new_id = maximum_other_id + len(ids) + 1
+            if new_id > 2**53 - 1:
+                raise ValueError('Track ID exceeds the supported integer range.')
+            ids[key] = new_id
+        return str(ids[key])
+
+    return re.sub(r'^(\s*\d+)(?=,)', replace, text, flags=re.MULTILINE)
+
+
+def association_pipeline():
+    pipeline = '''config _scheduler
+  :type thread_per_process
+
+process clock
+  :: frame_list_input
+  :image_list_file frames.txt
+  :image_reader:type ocv
+
+process timestamps
+  :: downsample
+  :renumber_frames true
+
+connect from clock.timestamp
+        to timestamps.timestamp
+
+process pairing
+  :: compute_measurements
+  :matching_methods input_pairs_only
+  :detection_pairing_method calibration
+  :detection_pairing_threshold 10
+  :calibration_file calibration.json
+  :accumulate_track_pairings true
+  :pairing_resolution_method most_likely
+  :detection_split_threshold 1
+  :output_unmatched true
+  :average_stereo_classes false
+
+connect from timestamps.timestamp
+        to pairing.timestamp
+'''
+    for side in (1, 2):
+        pipeline += f'''
+process reader{side}
+  :: read_object_track
+  :file_name input{side}.csv
+  :reader:type viame_csv
+
+connect from clock.image_file_name
+        to reader{side}.image_file_name
+connect from reader{side}.object_track_set
+        to pairing.object_track_set{side}
+
+process writer{side}
+  :: write_object_track
+  :file_name associated{side}.csv
+  :writer:type viame_csv
+
+connect from pairing.object_track_set{side}
+        to writer{side}.object_track_set
+'''
+    return pipeline
+
+
+def prepare_association(directory, calibration):
+    directory = Path(directory)
+    rows = [row for side in (1, 2) for row in csv_rows((directory / f'input{side}.csv').read_text())]
+    last_frame = max(int(row[2]) for row in rows)
+    calibration_name = f'calibration{Path(calibration).suffix}'
+    shutil.copyfile(calibration, directory / calibration_name)
+    (directory / 'clock.ppm').write_text('P3\n1 1\n255\n0 0 0\n')
+    (directory / 'frames.txt').write_text(f'{directory / "clock.ppm"}\n' * (last_frame + 1))
+    (directory / 'associate.pipe').write_text(association_pipeline().replace('calibration.json', calibration_name))
+
+
+def finish_single_camera_run(task, context, manager, conf, gc, params, output_file, working_dir):
+    from dive_tasks import utils
+    from dive_tasks.multicam_pipeline import find_downloaded_calibration_file
+
+    single = params['single_camera']
+    cameras = single['cameras']
+    directory = utils.make_directory(Path(working_dir) / 'association')
+    maximum_id = -1
+    for side, camera in enumerate(cameras, 1):
+        target = directory / f'input{side}.csv'
+        if camera['name'] == single['camera']:
+            shutil.copyfile(output_file, target)
+        else:
+            # Fetch all current annotations, including those below confidence filters.
+            utils.download_annotation_csv(gc, camera['folder_id'], target)
+            maximum_id = max([maximum_id] + [int(row[0]) for row in csv_rows(target.read_text())])
+    if maximum_id < 0 or not csv_rows(Path(output_file).read_text()):
+        return [(params['output_folder'], Path(output_file))]
+    if single['mode'] == 'separate':
+        target = directory / 'separate-camera.csv'
+        target.write_text(remap_csv_ids(Path(output_file).read_text(), maximum_id))
+        return [(params['output_folder'], target)]
+
+    cal_dir = utils.make_directory(directory / 'calibration')
+    gc.downloadItem(single['calibration_item_id'], str(cal_dir))
+    calibration = find_downloaded_calibration_file(cal_dir)
+    if calibration is None:
+        raise ValueError('Stereo association requires a loaded calibration file.')
+    prepare_association(directory, calibration)
+    manager.write('Associating stereo detections...\n')
+    utils.stream_subprocess(task, context, manager, {
+        'args': f'. {shlex.quote(str(conf.viame_setup_script))} && viame run associate.pipe',
+        'shell': True, 'executable': '/bin/bash', 'cwd': directory,
+        'env': conf.gpu_process_env,
+    })
+    outputs = [(camera['folder_id'], directory / f'associated{side}.csv')
+               for side, camera in enumerate(cameras, 1)]
+    for _, output in outputs:
+        if not output.exists() or not csv_rows(output.read_text()):
+            raise ValueError('Stereo association did not produce annotations for both cameras.')
+    return outputs
diff --git a/server/dive_utils/types.py b/server/dive_utils/types.py
index a7d066ce4..6cb992504 100644
--- a/server/dive_utils/types.py
+++ b/server/dive_utils/types.py
@@ -127,6 +127,7 @@ class PipelineRuntimeParams(TypedDict, total=False):
 
 
 class PipelineParams(TypedDict, total=False):
+    singleCameraMode: str
     kwiverParams: Dict[str, str]
     runtimeParams: PipelineRuntimeParams
     # 2-cam/3-cam pipes: the dataset camera to feed each inputN, in order, as
@@ -152,6 +153,7 @@ class PipelineJob(TypedDict):
     """Describes the parameters for running a pipeline on a dataset."""
 
     pipeline: PipelineDescription
+    single_camera: NotRequired[dict]
     input_folder: str  # dataset folder id
     input_type: str  # video, image-sequence, etc.
     input_revision: Optional[int]  # A revision ID is included if the pipeline needs input
diff --git a/server/tests/test_single_camera_pipeline.py b/server/tests/test_single_camera_pipeline.py
new file mode 100644
index 000000000..188643310
--- /dev/null
+++ b/server/tests/test_single_camera_pipeline.py
@@ -0,0 +1,106 @@
+import json
+import importlib.util
+import os
+from pathlib import Path
+import subprocess
+import sys
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+
+# Keep the geometry/CSV checks runnable without the Girder worker environment.
+spec = importlib.util.spec_from_file_location(
+    'single_camera_pipeline', Path(__file__).parents[1] / 'dive_tasks/single_camera_pipeline.py'
+)
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+csv_rows = module.csv_rows
+prepare_association = module.prepare_association
+remap_csv_ids = module.remap_csv_ids
+
+
+def test_remap_all_ids_preserves_tracks_and_fields():
+    text = '# header\n2,left,0,10,20,30,40,.8,-1,fish,.8\n2,left,2,11,20,30,40,.9,-1\n0,left,2,3,4,5,6,.7,-1\n'
+    result = remap_csv_ids(text, 999)
+    assert [row[0] for row in csv_rows(result)] == ['1000', '1000', '1001']
+    assert [row[1:] for row in csv_rows(result)] == [row[1:] for row in csv_rows(text)]
+    assert result.startswith('# header\n')
+
+
+def test_remap_rejects_id_overflow():
+    with pytest.raises(ValueError, match='integer range'):
+        remap_csv_ids('1,left,0,1,2,3,4,1,-1\n', 2**53 - 1)
+
+
+def test_worker_allocates_above_every_other_camera(tmp_path, monkeypatch):
+    def download(_gc, folder, target):
+        target.write_text(f'{800 if folder == "left" else 9000},image,0,1,2,3,4,1,-1\n')
+
+    def directory(target):
+        target.mkdir()
+        return target
+
+    run = Mock()
+    monkeypatch.setitem(sys.modules, 'dive_tasks', SimpleNamespace(utils=SimpleNamespace(
+        make_directory=directory, download_annotation_csv=download, stream_subprocess=run,
+    )))
+    monkeypatch.setitem(sys.modules, 'dive_tasks.multicam_pipeline', SimpleNamespace(
+        find_downloaded_calibration_file=Mock(),
+    ))
+    source = tmp_path / 'detections.csv'
+    source.write_text('1,image,0,1,2,3,4,1,-1\n1,image,2,1,2,3,4,1,-1\n')
+    params = {'output_folder': 'right', 'single_camera': {
+        'mode': 'separate', 'camera': 'right',
+        'cameras': [{'name': name, 'folder_id': name} for name in ('left', 'right', 'third')],
+    }}
+    outputs = module.finish_single_camera_run(None, {}, None, None, None, params, source, tmp_path)
+    assert len(outputs) == 1
+    assert outputs[0][0] == 'right'
+    assert [row[0] for row in csv_rows(outputs[0][1].read_text())] == ['9001', '9001']
+    run.assert_not_called()
+
+
+@pytest.mark.skipif(not os.environ.get('DIVE_TEST_VIAME'), reason='Set DIVE_TEST_VIAME to the VIAME executable')
+def test_real_stereo_association(tmp_path):
+    calibration = {}
+    for side in ('left', 'right'):
+        calibration.update({f'{key}_{side}': value for key, value in {
+            'fx': 1000, 'fy': 1000, 'cx': 500, 'cy': 500,
+            'k1': 0, 'k2': 0, 'k3': 0, 'p1': 0, 'p2': 0,
+        }.items()})
+    calibration.update({'R': [1, 0, 0, 0, 1, 0, 0, 0, 1], 'T': [-100, 0, 0]})
+    source = tmp_path / 'source.json'
+    source.write_text(json.dumps(calibration))
+    # Track 7 spans two frames; same ID on the other camera is deliberately unrelated.
+    (tmp_path / 'input1.csv').write_text(
+        '7,left,0,480,480,520,520,1,-1,fish,1\n'
+        '7,left,2,480,480,520,520,1,-1,fish,1\n'
+        '9,left,2,200,100,220,120,1,-1,crab,1\n'
+        '11,left,0,480,680,520,720,1,-1,ray,1\n'
+        '11,left,1,480,680,520,720,1,-1,ray,1\n'
+    )
+    (tmp_path / 'input2.csv').write_text(
+        '42,right,0,380,480,420,520,1,-1,fish,1\n'
+        '42,right,2,380,480,420,520,1,-1,fish,1\n'
+        '7,right,3,20,800,40,820,1,-1,shark,1\n'
+        '52,right,1,380,680,420,720,1,-1,ray,1\n'
+    )
+    prepare_association(tmp_path, source)
+    result = subprocess.run([os.environ['DIVE_TEST_VIAME'], 'run', 'associate.pipe'],
+                            cwd=tmp_path, capture_output=True, text=True, timeout=30)
+    assert result.returncode == 0, result.stdout + result.stderr
+    left = csv_rows((tmp_path / 'associated1.csv').read_text())
+    right = csv_rows((tmp_path / 'associated2.csv').read_text())
+    assert len(left) == 5
+    assert len(right) == 4
+    left_fish = [row for row in left if 'fish' in row]
+    right_fish = [row for row in right if 'fish' in row]
+    assert {row[0] for row in left_fish} == {row[0] for row in right_fish}
+    assert len({row[0] for row in left_fish}) == 1
+    assert {int(row[2]) for row in left_fish} == {0, 2}
+    # A match first appearing on the second frame must also remap the earlier state.
+    assert len({row[0] for row in left + right if 'ray' in row}) == 1
+    unmatched = [row[0] for row in left + right if 'crab' in row or 'shark' in row]
+    assert len(set(unmatched)) == 2
+    assert set(unmatched).isdisjoint({row[0] for row in left_fish})

From 93ed5626aa7422c78235eb5e8adb6dea135a3f74 Mon Sep 17 00:00:00 2001
From: Matt Dawkins <matt.dawkins@kitware.com>
Date: Wed, 9 Sep 2026 21:39:57 -0400
Subject: [PATCH 2/5] Fix server lint for single-camera association

---
 server/dive_server/crud_rpc.py              |  3 +-
 server/dive_tasks/single_camera_pipeline.py | 39 +++++++----
 server/tests/test_single_camera_pipeline.py | 71 +++++++++++++++------
 3 files changed, 81 insertions(+), 32 deletions(-)

diff --git a/server/dive_server/crud_rpc.py b/server/dive_server/crud_rpc.py
index 675267726..ceddb93dd 100644
--- a/server/dive_server/crud_rpc.py
+++ b/server/dive_server/crud_rpc.py
@@ -489,7 +489,8 @@ def run_pipeline(
                     or len(cameras) != 2
                 ):
                     raise RestException(
-                        'Detection association in multi-camera mode is not implemented yet.', code=400
+                        'Detection association in multi-camera mode is not implemented yet.',
+                        code=400,
                     )
                 calibration_pipeline: types.PipelineDescription = {
                     **pipeline,
diff --git a/server/dive_tasks/single_camera_pipeline.py b/server/dive_tasks/single_camera_pipeline.py
index e01d0d7e8..2f1f57e44 100644
--- a/server/dive_tasks/single_camera_pipeline.py
+++ b/server/dive_tasks/single_camera_pipeline.py
@@ -27,7 +27,7 @@ def replace(match):
 
 
 def association_pipeline():
-    pipeline = '''config _scheduler
+    pipeline = """config _scheduler
   :type thread_per_process
 
 process clock
@@ -56,9 +56,9 @@ def association_pipeline():
 
 connect from timestamps.timestamp
         to pairing.timestamp
-'''
+"""
     for side in (1, 2):
-        pipeline += f'''
+        pipeline += f"""
 process reader{side}
   :: read_object_track
   :file_name input{side}.csv
@@ -76,19 +76,23 @@ def association_pipeline():
 
 connect from pairing.object_track_set{side}
         to writer{side}.object_track_set
-'''
+"""
     return pipeline
 
 
 def prepare_association(directory, calibration):
     directory = Path(directory)
-    rows = [row for side in (1, 2) for row in csv_rows((directory / f'input{side}.csv').read_text())]
+    rows = [
+        row for side in (1, 2) for row in csv_rows((directory / f'input{side}.csv').read_text())
+    ]
     last_frame = max(int(row[2]) for row in rows)
     calibration_name = f'calibration{Path(calibration).suffix}'
     shutil.copyfile(calibration, directory / calibration_name)
     (directory / 'clock.ppm').write_text('P3\n1 1\n255\n0 0 0\n')
     (directory / 'frames.txt').write_text(f'{directory / "clock.ppm"}\n' * (last_frame + 1))
-    (directory / 'associate.pipe').write_text(association_pipeline().replace('calibration.json', calibration_name))
+    (directory / 'associate.pipe').write_text(
+        association_pipeline().replace('calibration.json', calibration_name)
+    )
 
 
 def finish_single_camera_run(task, context, manager, conf, gc, params, output_file, working_dir):
@@ -121,13 +125,22 @@ def finish_single_camera_run(task, context, manager, conf, gc, params, output_fi
         raise ValueError('Stereo association requires a loaded calibration file.')
     prepare_association(directory, calibration)
     manager.write('Associating stereo detections...\n')
-    utils.stream_subprocess(task, context, manager, {
-        'args': f'. {shlex.quote(str(conf.viame_setup_script))} && viame run associate.pipe',
-        'shell': True, 'executable': '/bin/bash', 'cwd': directory,
-        'env': conf.gpu_process_env,
-    })
-    outputs = [(camera['folder_id'], directory / f'associated{side}.csv')
-               for side, camera in enumerate(cameras, 1)]
+    utils.stream_subprocess(
+        task,
+        context,
+        manager,
+        {
+            'args': f'. {shlex.quote(str(conf.viame_setup_script))} && viame run associate.pipe',
+            'shell': True,
+            'executable': '/bin/bash',
+            'cwd': directory,
+            'env': conf.gpu_process_env,
+        },
+    )
+    outputs = [
+        (camera['folder_id'], directory / f'associated{side}.csv')
+        for side, camera in enumerate(cameras, 1)
+    ]
     for _, output in outputs:
         if not output.exists() or not csv_rows(output.read_text()):
             raise ValueError('Stereo association did not produce annotations for both cameras.')
diff --git a/server/tests/test_single_camera_pipeline.py b/server/tests/test_single_camera_pipeline.py
index 188643310..1a92576b1 100644
--- a/server/tests/test_single_camera_pipeline.py
+++ b/server/tests/test_single_camera_pipeline.py
@@ -1,5 +1,5 @@
-import json
 import importlib.util
+import json
 import os
 from pathlib import Path
 import subprocess
@@ -42,18 +42,34 @@ def directory(target):
         return target
 
     run = Mock()
-    monkeypatch.setitem(sys.modules, 'dive_tasks', SimpleNamespace(utils=SimpleNamespace(
-        make_directory=directory, download_annotation_csv=download, stream_subprocess=run,
-    )))
-    monkeypatch.setitem(sys.modules, 'dive_tasks.multicam_pipeline', SimpleNamespace(
-        find_downloaded_calibration_file=Mock(),
-    ))
+    monkeypatch.setitem(
+        sys.modules,
+        'dive_tasks',
+        SimpleNamespace(
+            utils=SimpleNamespace(
+                make_directory=directory,
+                download_annotation_csv=download,
+                stream_subprocess=run,
+            )
+        ),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        'dive_tasks.multicam_pipeline',
+        SimpleNamespace(
+            find_downloaded_calibration_file=Mock(),
+        ),
+    )
     source = tmp_path / 'detections.csv'
     source.write_text('1,image,0,1,2,3,4,1,-1\n1,image,2,1,2,3,4,1,-1\n')
-    params = {'output_folder': 'right', 'single_camera': {
-        'mode': 'separate', 'camera': 'right',
-        'cameras': [{'name': name, 'folder_id': name} for name in ('left', 'right', 'third')],
-    }}
+    params = {
+        'output_folder': 'right',
+        'single_camera': {
+            'mode': 'separate',
+            'camera': 'right',
+            'cameras': [{'name': name, 'folder_id': name} for name in ('left', 'right', 'third')],
+        },
+    }
     outputs = module.finish_single_camera_run(None, {}, None, None, None, params, source, tmp_path)
     assert len(outputs) == 1
     assert outputs[0][0] == 'right'
@@ -61,14 +77,28 @@ def directory(target):
     run.assert_not_called()
 
 
-@pytest.mark.skipif(not os.environ.get('DIVE_TEST_VIAME'), reason='Set DIVE_TEST_VIAME to the VIAME executable')
+@pytest.mark.skipif(
+    not os.environ.get('DIVE_TEST_VIAME'), reason='Set DIVE_TEST_VIAME to the VIAME executable'
+)
 def test_real_stereo_association(tmp_path):
     calibration = {}
     for side in ('left', 'right'):
-        calibration.update({f'{key}_{side}': value for key, value in {
-            'fx': 1000, 'fy': 1000, 'cx': 500, 'cy': 500,
-            'k1': 0, 'k2': 0, 'k3': 0, 'p1': 0, 'p2': 0,
-        }.items()})
+        calibration.update(
+            {
+                f'{key}_{side}': value
+                for key, value in {
+                    'fx': 1000,
+                    'fy': 1000,
+                    'cx': 500,
+                    'cy': 500,
+                    'k1': 0,
+                    'k2': 0,
+                    'k3': 0,
+                    'p1': 0,
+                    'p2': 0,
+                }.items()
+            }
+        )
     calibration.update({'R': [1, 0, 0, 0, 1, 0, 0, 0, 1], 'T': [-100, 0, 0]})
     source = tmp_path / 'source.json'
     source.write_text(json.dumps(calibration))
@@ -87,8 +117,13 @@ def test_real_stereo_association(tmp_path):
         '52,right,1,380,680,420,720,1,-1,ray,1\n'
     )
     prepare_association(tmp_path, source)
-    result = subprocess.run([os.environ['DIVE_TEST_VIAME'], 'run', 'associate.pipe'],
-                            cwd=tmp_path, capture_output=True, text=True, timeout=30)
+    result = subprocess.run(
+        [os.environ['DIVE_TEST_VIAME'], 'run', 'associate.pipe'],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
     assert result.returncode == 0, result.stdout + result.stderr
     left = csv_rows((tmp_path / 'associated1.csv').read_text())
     right = csv_rows((tmp_path / 'associated2.csv').read_text())

From 50934bad2f16436216a7729bfaa562ae883b752b Mon Sep 17 00:00:00 2001
From: Bryon Lewis <Bryon.Lewis@kitware.com>
Date: Thu, 10 Sep 2026 11:10:40 -0400
Subject: [PATCH 3/5] organization change sto the code to group and explain
 what is happening

---
 .../components/RunPipelineMenu.vue            |  4 +-
 .../AssociationDialog.vue}                    |  0
 client/dive-common/singleCamera/README.md     | 42 +++++++++++++++++++
 .../association.ts}                           |  0
 .../decisions.spec.ts}                        |  4 +-
 .../decisions.ts}                             |  4 +-
 client/dive-common/singleCamera/index.ts      |  9 ++++
 .../backend/native/singleCameraPipeline.ts    |  4 +-
 docs/Multicamera-data.md                      |  7 +++-
 server/dive_tasks/single_camera_pipeline.py   |  6 ++-
 10 files changed, 70 insertions(+), 10 deletions(-)
 rename client/dive-common/{components/SingleCameraAssociationDialog.vue => singleCamera/AssociationDialog.vue} (100%)
 create mode 100644 client/dive-common/singleCamera/README.md
 rename client/dive-common/{stereoAssociationPipeline.ts => singleCamera/association.ts} (100%)
 rename client/dive-common/{singleCameraPipeline.spec.ts => singleCamera/decisions.spec.ts} (96%)
 rename client/dive-common/{singleCameraPipeline.ts => singleCamera/decisions.ts} (94%)
 create mode 100644 client/dive-common/singleCamera/index.ts

diff --git a/client/dive-common/components/RunPipelineMenu.vue b/client/dive-common/components/RunPipelineMenu.vue
index 071df8b91..a45e6d88c 100644
--- a/client/dive-common/components/RunPipelineMenu.vue
+++ b/client/dive-common/components/RunPipelineMenu.vue
@@ -19,10 +19,10 @@ import {
   NewDatasetJobConfig,
 } from 'dive-common/apispec';
 import JobLaunchDialog from 'dive-common/components/JobLaunchDialog.vue';
-import SingleCameraAssociationDialog from 'dive-common/components/SingleCameraAssociationDialog.vue';
+import SingleCameraAssociationDialog from 'dive-common/singleCamera/AssociationDialog.vue';
 import {
   singleCameraContext, SingleCameraMode, validateAssociation,
-} from 'dive-common/singleCameraPipeline';
+} from 'dive-common/singleCamera';
 import { isStereoInteractiveModeEnabled } from 'dive-common/store/settings';
 import JobConfigFilterTranscodeDialog from 'dive-common/components/JobConfigFilterTranscodeDialog.vue';
 import RunPipelineToast from 'dive-common/components/RunPipelineToast.vue';
diff --git a/client/dive-common/components/SingleCameraAssociationDialog.vue b/client/dive-common/singleCamera/AssociationDialog.vue
similarity index 100%
rename from client/dive-common/components/SingleCameraAssociationDialog.vue
rename to client/dive-common/singleCamera/AssociationDialog.vue
diff --git a/client/dive-common/singleCamera/README.md b/client/dive-common/singleCamera/README.md
new file mode 100644
index 000000000..9dd1eb231
--- /dev/null
+++ b/client/dive-common/singleCamera/README.md
@@ -0,0 +1,42 @@
+# Single-camera pipelines on multicam / stereo
+
+When a pipeline runs on **one camera** of a multicamera or stereo dataset, DIVE must
+avoid TrackId collisions with annotations already on the other cameras, and optionally
+pair detections across a calibrated stereo pair.
+
+## Modes
+
+| Mode | When | Result |
+|------|------|--------|
+| `separate` | Default, or user declines association | Remap new track IDs above every ID on the other cameras |
+| `associate` | Stereo + calibration + interactive stereo enabled + user accepts | Run VIAME association on both cameras' CSVs, then ingest paired outputs |
+
+## Layout
+
+| Piece | Role |
+|-------|------|
+| `decisions.ts` | UI/preflight: resolve camera scope, validate association, shared errors/types, ID remapping |
+| `association.ts` | Shared VIAME `.pipe` text and CSV frame helper used when finishing a run |
+| `AssociationDialog.vue` | Prompt: associate across cameras, keep separate IDs, or cancel |
+| `index.ts` | Public re-exports for `dive-common/singleCamera` |
+
+Platform execution (filesystem / Girder) stays outside this folder:
+
+- **Desktop** — `platform/desktop/backend/native/singleCameraPipeline.ts` (`prepare` / `finish`), wired from `viame.ts`
+- **Web** — `server/dive_tasks/single_camera_pipeline.py`, called from `run_pipeline.py`
+
+The Vue run menu (`components/RunPipelineMenu.vue`) uses `decisions` + `AssociationDialog` before launch; backends apply the same rules after the pipeline writes CSV.
+
+## Import
+
+```ts
+import {
+  singleCameraContext,
+  validateAssociation,
+  remapCsvIds,
+  stereoAssociationPipeline,
+  lastCsvFrame,
+  type SingleCameraMode,
+} from 'dive-common/singleCamera';
+import AssociationDialog from 'dive-common/singleCamera/AssociationDialog.vue';
+```
diff --git a/client/dive-common/stereoAssociationPipeline.ts b/client/dive-common/singleCamera/association.ts
similarity index 100%
rename from client/dive-common/stereoAssociationPipeline.ts
rename to client/dive-common/singleCamera/association.ts
diff --git a/client/dive-common/singleCameraPipeline.spec.ts b/client/dive-common/singleCamera/decisions.spec.ts
similarity index 96%
rename from client/dive-common/singleCameraPipeline.spec.ts
rename to client/dive-common/singleCamera/decisions.spec.ts
index 29cce85c4..129745324 100644
--- a/client/dive-common/singleCameraPipeline.spec.ts
+++ b/client/dive-common/singleCamera/decisions.spec.ts
@@ -1,5 +1,5 @@
-import type { Api, DatasetConfig } from './apispec';
-import { remapCsvIds, singleCameraContext, validateAssociation } from './singleCameraPipeline';
+import type { Api, DatasetConfig } from '../apispec';
+import { remapCsvIds, singleCameraContext, validateAssociation } from './decisions';
 
 describe('single camera pipeline decisions', () => {
   const config = {
diff --git a/client/dive-common/singleCameraPipeline.ts b/client/dive-common/singleCamera/decisions.ts
similarity index 94%
rename from client/dive-common/singleCameraPipeline.ts
rename to client/dive-common/singleCamera/decisions.ts
index b41ecf559..bfb3773b5 100644
--- a/client/dive-common/singleCameraPipeline.ts
+++ b/client/dive-common/singleCamera/decisions.ts
@@ -1,5 +1,5 @@
-import type { Api, PipelineParams } from './apispec';
-import { parseCompositeDatasetId } from './compositeDatasetId';
+import type { Api, PipelineParams } from '../apispec';
+import { parseCompositeDatasetId } from '../compositeDatasetId';
 
 export const associationCalibrationError = 'Stereo association requires a loaded calibration file.';
 export const associationMulticamError = 'Detection association in multi-camera mode is not implemented yet.';
diff --git a/client/dive-common/singleCamera/index.ts b/client/dive-common/singleCamera/index.ts
new file mode 100644
index 000000000..aa6f9c5c2
--- /dev/null
+++ b/client/dive-common/singleCamera/index.ts
@@ -0,0 +1,9 @@
+export {
+  associationCalibrationError,
+  associationMulticamError,
+  validateAssociation,
+  singleCameraContext,
+  remapCsvIds,
+  type SingleCameraMode,
+} from './decisions';
+export { stereoAssociationPipeline, lastCsvFrame } from './association';
diff --git a/client/platform/desktop/backend/native/singleCameraPipeline.ts b/client/platform/desktop/backend/native/singleCameraPipeline.ts
index 632465701..e53770e4c 100644
--- a/client/platform/desktop/backend/native/singleCameraPipeline.ts
+++ b/client/platform/desktop/backend/native/singleCameraPipeline.ts
@@ -5,8 +5,8 @@ import { parseCompositeDatasetId } from 'dive-common/compositeDatasetId';
 import { orderedMultiCamCameraNames } from 'dive-common/multicamDisplay';
 import {
   SingleCameraMode, remapCsvIds, associationCalibrationError, associationMulticamError,
-} from 'dive-common/singleCameraPipeline';
-import { stereoAssociationPipeline, lastCsvFrame } from 'dive-common/stereoAssociationPipeline';
+  stereoAssociationPipeline, lastCsvFrame,
+} from 'dive-common/singleCamera';
 import { serializeFile } from '../serializers/viame';
 import * as common from './common';
 
diff --git a/docs/Multicamera-data.md b/docs/Multicamera-data.md
index 6f444f012..0b57dcafd 100644
--- a/docs/Multicamera-data.md
+++ b/docs/Multicamera-data.md
@@ -225,7 +225,12 @@ Per-camera export from the viewer still exports only the active camera.
 
 Single camera pipelines can be used by selecting the camera and then running the pipeline from the pipeline menu.
 
-> **Note:** it is suggested that single camera pipelines only be run on empty datasets that don't have annotations already. When the pipeline finishes it will create tracks with TrackIds that may conflict with the other cameras. So it is recommended that all tracks be removed before running single camera pipelines.
+When other cameras already have detections, DIVE prompts before launch:
+
+- **No** (separate) — remaps new TrackIds above every ID on the other cameras so IDs do not collide.
+- **Yes** (associate) — on calibrated stereo with interactive stereo features enabled, runs VIAME association and imports paired annotations for both cameras.
+
+Association for generic multi-camera (non-stereo) datasets is not implemented yet.
 
 ### MultiCamera/Stereo Pipelines
 
diff --git a/server/dive_tasks/single_camera_pipeline.py b/server/dive_tasks/single_camera_pipeline.py
index 2f1f57e44..e010828fb 100644
--- a/server/dive_tasks/single_camera_pipeline.py
+++ b/server/dive_tasks/single_camera_pipeline.py
@@ -1,4 +1,8 @@
-"""Postprocess single-camera results before publishing annotations."""
+"""Postprocess single-camera results before publishing annotations.
+
+Client counterpart and overview: client/dive-common/singleCamera/README.md
+Desktop: client/platform/desktop/backend/native/singleCameraPipeline.ts
+"""
 
 import csv
 from pathlib import Path

From fe512ff362fc0d2b336771cd6f995c1b860067d2 Mon Sep 17 00:00:00 2001
From: Bryon Lewis <Bryon.Lewis@kitware.com>
Date: Thu, 10 Sep 2026 11:26:04 -0400
Subject: [PATCH 4/5] convert other jobs from 'exit' to 'close' to maintain
 parity

---
 client/platform/desktop/backend/native/viame.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/client/platform/desktop/backend/native/viame.ts b/client/platform/desktop/backend/native/viame.ts
index 971ef2a5b..d79e06bb5 100644
--- a/client/platform/desktop/backend/native/viame.ts
+++ b/client/platform/desktop/backend/native/viame.ts
@@ -842,7 +842,7 @@ async function exportTrainedPipeline(
   job.stdout.on('data', jobFileEchoMiddleware(jobBase, updater, joblog));
   job.stderr.on('data', jobFileEchoMiddleware(jobBase, updater, joblog));
 
-  job.on('exit', async (code) => {
+  job.on('close', async (code) => {
     if (code === 0) {
       if (fs.existsSync(converterOutput)) {
         if (fs.existsSync(path)) {
@@ -1018,7 +1018,7 @@ async function train(
 
   job.stdout.on('data', jobFileEchoMiddleware(jobBase, updater, joblog));
   job.stderr.on('data', jobFileEchoMiddleware(jobBase, updater, joblog));
-  job.on('exit', async (code) => {
+  job.on('close', async (code) => {
     const manifestPath = npath.join(jobWorkDir, DiveJobManifestName);
     // Cancel updates the manifest before killing the child; read that first so
     // we do not clobber cancelledJob with a null/signal exit code.
@@ -1166,7 +1166,7 @@ async function runScoring(
   });
   job.stderr.on('data', echo);
 
-  job.on('exit', async (code) => {
+  job.on('close', async (code) => {
     let existingManifest: DesktopJob | undefined;
     try {
       if (await fs.pathExists(manifestPath)) {

From 77298add7504f60b6f256997d0fe1dffdc5dd722 Mon Sep 17 00:00:00 2001
From: Bryon Lewis <Bryon.Lewis@kitware.com>
Date: Thu, 10 Sep 2026 11:28:43 -0400
Subject: [PATCH 5/5] gating on options before they fail in the dialog

---
 .../components/RunPipelineMenu.vue            | 28 ++++++++-----
 .../singleCamera/AssociationDialog.vue        | 39 +++++++++++++++----
 client/dive-common/singleCamera/README.md     |  2 +-
 .../singleCamera/decisions.spec.ts            | 10 +++--
 client/dive-common/singleCamera/decisions.ts  | 18 +++++++--
 client/dive-common/singleCamera/index.ts      |  2 +
 docs/Multicamera-data.md                      |  6 +--
 7 files changed, 78 insertions(+), 27 deletions(-)

diff --git a/client/dive-common/components/RunPipelineMenu.vue b/client/dive-common/components/RunPipelineMenu.vue
index a45e6d88c..cf3fbb83b 100644
--- a/client/dive-common/components/RunPipelineMenu.vue
+++ b/client/dive-common/components/RunPipelineMenu.vue
@@ -21,7 +21,7 @@ import {
 import JobLaunchDialog from 'dive-common/components/JobLaunchDialog.vue';
 import SingleCameraAssociationDialog from 'dive-common/singleCamera/AssociationDialog.vue';
 import {
-  singleCameraContext, SingleCameraMode, validateAssociation,
+  associationUnavailableReason, singleCameraContext, SingleCameraMode,
 } from 'dive-common/singleCamera';
 import { isStereoInteractiveModeEnabled } from 'dive-common/store/settings';
 import JobConfigFilterTranscodeDialog from 'dive-common/components/JobConfigFilterTranscodeDialog.vue';
@@ -144,14 +144,17 @@ export default defineComponent({
     const configuring = computed(() => menuState.value === 'configuring');
     const selectedPipeline: Ref<Pipe | null> = ref(null);
     const associationCamera = ref('');
+    const associationUnavailable = ref('');
     let resolveAssociation: (mode: SingleCameraMode | null) => void = () => {};
     function answerAssociation(mode: SingleCameraMode | null) {
       associationCamera.value = '';
+      associationUnavailable.value = '';
       resolveAssociation(mode);
     }
-    function askAssociation(camera: string) {
+    function askAssociation(camera: string, unavailableReason: string) {
       return new Promise<SingleCameraMode | null>((resolve) => {
         resolveAssociation = resolve;
+        associationUnavailable.value = unavailableReason;
         associationCamera.value = camera;
       });
     }
@@ -399,14 +402,16 @@ export default defineComponent({
               datasetIds[i] = context.datasetId;
               let mode: SingleCameraMode | null = 'separate';
               if (context.hasOtherTracks) {
-                // eslint-disable-next-line no-await-in-loop
-                mode = await askAssociation(context.datasetId);
-                if (!mode) return;
-              }
-              if (mode === 'associate') {
                 // eslint-disable-next-line no-await-in-loop
                 const calibration = context.stereo && !!await hasCalibrationFile?.(context.parentId);
-                validateAssociation(context.stereo, calibration, isStereoInteractiveModeEnabled());
+                const unavailable = associationUnavailableReason(
+                  context.stereo,
+                  calibration,
+                  isStereoInteractiveModeEnabled(),
+                ) || '';
+                // eslint-disable-next-line no-await-in-loop
+                mode = await askAssociation(context.datasetId, unavailable);
+                if (!mode) return;
               }
               singleCameraModes[context.datasetId] = mode;
             }
@@ -492,6 +497,7 @@ export default defineComponent({
 
     return {
       associationCamera,
+      associationUnavailable,
       answerAssociation,
       jobState,
       pipelines,
@@ -528,7 +534,11 @@ export default defineComponent({
 
 <template>
   <div>
-    <SingleCameraAssociationDialog :camera="associationCamera" @answer="answerAssociation" />
+    <SingleCameraAssociationDialog
+      :camera="associationCamera"
+      :unavailable-reason="associationUnavailable"
+      @answer="answerAssociation"
+    />
     <v-menu
       max-width="230"
       max-height="none"
diff --git a/client/dive-common/singleCamera/AssociationDialog.vue b/client/dive-common/singleCamera/AssociationDialog.vue
index 08f3a3f36..f8dd548ee 100644
--- a/client/dive-common/singleCamera/AssociationDialog.vue
+++ b/client/dive-common/singleCamera/AssociationDialog.vue
@@ -2,28 +2,51 @@
 import { defineComponent } from 'vue';
 
 export default defineComponent({
-  props: { camera: { type: String, default: '' } },
+  props: {
+    camera: { type: String, default: '' },
+    /** Non-empty when Yes must be hidden; shown so the user knows why. */
+    unavailableReason: { type: String, default: '' },
+  },
+  emits: ['answer'],
 });
 </script>
 
 <template>
   <v-dialog :value="!!camera" persistent max-width="560">
     <v-card>
-      <v-card-title>Associate detections across cameras?</v-card-title>
+      <v-card-title>
+        {{ unavailableReason ? 'Keep detections on separate cameras?' : 'Associate detections across cameras?' }}
+      </v-card-title>
       <v-card-text>
-        Another camera already has detections. After running the pipeline on {{ camera }},
-        should DIVE attempt to associate its detections with those on the other camera?
-        Choosing No assigns new IDs above all IDs on the other cameras.
+        <template v-if="unavailableReason">
+          Another camera already has detections. After running the pipeline on {{ camera }},
+          DIVE will assign new IDs above all IDs on the other cameras so they do not collide.
+          Association is unavailable: {{ unavailableReason }}
+        </template>
+        <template v-else>
+          Another camera already has detections. After running the pipeline on {{ camera }},
+          should DIVE associate its detections with those on the other camera?
+          Choosing Yes replaces annotations on both cameras with the paired association result.
+          Choosing No keeps cameras separate and assigns new IDs above all IDs on the other cameras.
+        </template>
       </v-card-text>
       <v-card-actions>
         <v-btn text @click="$emit('answer', null)">
           Cancel
         </v-btn>
         <v-spacer />
-        <v-btn text @click="$emit('answer', 'separate')">
-          No
+        <v-btn
+          :text="!unavailableReason"
+          :color="unavailableReason ? 'primary' : undefined"
+          @click="$emit('answer', 'separate')"
+        >
+          {{ unavailableReason ? 'Continue' : 'No' }}
         </v-btn>
-        <v-btn color="primary" @click="$emit('answer', 'associate')">
+        <v-btn
+          v-if="!unavailableReason"
+          color="primary"
+          @click="$emit('answer', 'associate')"
+        >
           Yes
         </v-btn>
       </v-card-actions>
diff --git a/client/dive-common/singleCamera/README.md b/client/dive-common/singleCamera/README.md
index 9dd1eb231..6da181763 100644
--- a/client/dive-common/singleCamera/README.md
+++ b/client/dive-common/singleCamera/README.md
@@ -17,7 +17,7 @@ pair detections across a calibrated stereo pair.
 |-------|------|
 | `decisions.ts` | UI/preflight: resolve camera scope, validate association, shared errors/types, ID remapping |
 | `association.ts` | Shared VIAME `.pipe` text and CSV frame helper used when finishing a run |
-| `AssociationDialog.vue` | Prompt: associate across cameras, keep separate IDs, or cancel |
+| `AssociationDialog.vue` | Prompt: associate (when allowed; rewrites both cameras), keep separate IDs, or cancel |
 | `index.ts` | Public re-exports for `dive-common/singleCamera` |
 
 Platform execution (filesystem / Girder) stays outside this folder:
diff --git a/client/dive-common/singleCamera/decisions.spec.ts b/client/dive-common/singleCamera/decisions.spec.ts
index 129745324..c2d08c21a 100644
--- a/client/dive-common/singleCamera/decisions.spec.ts
+++ b/client/dive-common/singleCamera/decisions.spec.ts
@@ -1,5 +1,7 @@
 import type { Api, DatasetConfig } from '../apispec';
-import { remapCsvIds, singleCameraContext, validateAssociation } from './decisions';
+import {
+  associationUnavailableReason, remapCsvIds, singleCameraContext, validateAssociation,
+} from './decisions';
 
 describe('single camera pipeline decisions', () => {
   const config = {
@@ -28,9 +30,11 @@ describe('single camera pipeline decisions', () => {
   });
 
   it('rejects unsupported multicam, missing calibration, and disabled stereo', () => {
+    expect(associationUnavailableReason(false, true, true)).toMatch(/not implemented/);
+    expect(associationUnavailableReason(true, false, true)).toMatch(/calibration file/);
+    expect(associationUnavailableReason(true, true, false)).toMatch(/Enable stereo/);
+    expect(associationUnavailableReason(true, true, true)).toBeNull();
     expect(() => validateAssociation(false, true, true)).toThrow('not implemented');
-    expect(() => validateAssociation(true, false, true)).toThrow('calibration file');
-    expect(() => validateAssociation(true, true, false)).toThrow('Enable stereo');
     expect(() => validateAssociation(true, true, true)).not.toThrow();
   });
 
diff --git a/client/dive-common/singleCamera/decisions.ts b/client/dive-common/singleCamera/decisions.ts
index bfb3773b5..07a728771 100644
--- a/client/dive-common/singleCamera/decisions.ts
+++ b/client/dive-common/singleCamera/decisions.ts
@@ -3,11 +3,23 @@ import { parseCompositeDatasetId } from '../compositeDatasetId';
 
 export const associationCalibrationError = 'Stereo association requires a loaded calibration file.';
 export const associationMulticamError = 'Detection association in multi-camera mode is not implemented yet.';
+export const associationStereoDisabledError = 'Enable stereo features before associating detections.';
+
+/** Why association cannot run, or null when it is allowed. */
+export function associationUnavailableReason(
+  stereo: boolean,
+  calibration: boolean,
+  enabled: boolean,
+): string | null {
+  if (!stereo) return associationMulticamError;
+  if (!calibration) return associationCalibrationError;
+  if (!enabled) return associationStereoDisabledError;
+  return null;
+}
 
 export function validateAssociation(stereo: boolean, calibration: boolean, enabled: boolean) {
-  if (!stereo) throw new Error(associationMulticamError);
-  if (!calibration) throw new Error(associationCalibrationError);
-  if (!enabled) throw new Error('Enable stereo features before associating detections.');
+  const reason = associationUnavailableReason(stereo, calibration, enabled);
+  if (reason) throw new Error(reason);
 }
 
 /** Resolve the actual camera scope; library runs may use the parent id. */
diff --git a/client/dive-common/singleCamera/index.ts b/client/dive-common/singleCamera/index.ts
index aa6f9c5c2..7344e41dd 100644
--- a/client/dive-common/singleCamera/index.ts
+++ b/client/dive-common/singleCamera/index.ts
@@ -1,6 +1,8 @@
 export {
   associationCalibrationError,
   associationMulticamError,
+  associationStereoDisabledError,
+  associationUnavailableReason,
   validateAssociation,
   singleCameraContext,
   remapCsvIds,
diff --git a/docs/Multicamera-data.md b/docs/Multicamera-data.md
index 0b57dcafd..5cdac87eb 100644
--- a/docs/Multicamera-data.md
+++ b/docs/Multicamera-data.md
@@ -227,10 +227,10 @@ Single camera pipelines can be used by selecting the camera and then running the
 
 When other cameras already have detections, DIVE prompts before launch:
 
-- **No** (separate) — remaps new TrackIds above every ID on the other cameras so IDs do not collide.
-- **Yes** (associate) — on calibrated stereo with interactive stereo features enabled, runs VIAME association and imports paired annotations for both cameras.
+- **No** / **Continue** (separate) — remaps new TrackIds above every ID on the other cameras so IDs do not collide.
+- **Yes** (associate) — only offered for calibrated stereo with interactive stereo features enabled. Runs VIAME association and **replaces annotations on both cameras** with the paired result.
 
-Association for generic multi-camera (non-stereo) datasets is not implemented yet.
+When association is unavailable (plain multicam, missing calibration, or stereo features off), the dialog explains why and only offers separate-ID remapping.
 
 ### MultiCamera/Stereo Pipelines