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..cf3fbb83b 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/singleCamera/AssociationDialog.vue';
+import {
+  associationUnavailableReason, singleCameraContext, SingleCameraMode,
+} 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';
 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,21 @@ 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('');
+    const associationUnavailable = ref('');
+    let resolveAssociation: (mode: SingleCameraMode | null) => void = () => {};
+    function answerAssociation(mode: SingleCameraMode | null) {
+      associationCamera.value = '';
+      associationUnavailable.value = '';
+      resolveAssociation(mode);
+    }
+    function askAssociation(camera: string, unavailableReason: string) {
+      return new Promise<SingleCameraMode | null>((resolve) => {
+        resolveAssociation = resolve;
+        associationUnavailable.value = unavailableReason;
+        associationCamera.value = camera;
+      });
+    }
     const selectedPipelineName = computed(() => (selectedPipeline.value ? selectedPipeline.value.name : ''));
     function cancelConfig() {
       menuState.value = 'idle';
@@ -357,18 +383,41 @@ 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
+                const calibration = context.stereo && !!await hasCalibrationFile?.(context.parentId);
+                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;
+            }
+          }
+        } catch (error) {
+          await prompt({ title: 'Cannot run pipeline', text: (error as Error).message });
           return;
         }
       }
@@ -393,6 +442,7 @@ export default defineComponent({
           outputParentFolderId,
           kwiverParams: kwiverParamsById?.[id],
           cameraOrder: cameraOrderById[id],
+          singleCameraMode: singleCameraModes[id],
         })),
       ));
     }
@@ -446,6 +496,9 @@ export default defineComponent({
     }
 
     return {
+      associationCamera,
+      associationUnavailable,
+      answerAssociation,
       jobState,
       pipelines,
       pipelinesNotRunnable,
@@ -481,6 +534,11 @@ export default defineComponent({
 
 <template>
   <div>
+    <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
new file mode 100644
index 000000000..f8dd548ee
--- /dev/null
+++ b/client/dive-common/singleCamera/AssociationDialog.vue
@@ -0,0 +1,55 @@
+<script lang="ts">
+import { defineComponent } from 'vue';
+
+export default defineComponent({
+  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>
+        {{ unavailableReason ? 'Keep detections on separate cameras?' : 'Associate detections across cameras?' }}
+      </v-card-title>
+      <v-card-text>
+        <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="!unavailableReason"
+          :color="unavailableReason ? 'primary' : undefined"
+          @click="$emit('answer', 'separate')"
+        >
+          {{ unavailableReason ? 'Continue' : 'No' }}
+        </v-btn>
+        <v-btn
+          v-if="!unavailableReason"
+          color="primary"
+          @click="$emit('answer', 'associate')"
+        >
+          Yes
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+</template>
diff --git a/client/dive-common/singleCamera/README.md b/client/dive-common/singleCamera/README.md
new file mode 100644
index 000000000..6da181763
--- /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 (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:
+
+- **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/singleCamera/association.ts b/client/dive-common/singleCamera/association.ts
new file mode 100644
index 000000000..3b9d6a7c1
--- /dev/null
+++ b/client/dive-common/singleCamera/association.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/dive-common/singleCamera/decisions.spec.ts b/client/dive-common/singleCamera/decisions.spec.ts
new file mode 100644
index 000000000..c2d08c21a
--- /dev/null
+++ b/client/dive-common/singleCamera/decisions.spec.ts
@@ -0,0 +1,49 @@
+import type { Api, DatasetConfig } from '../apispec';
+import {
+  associationUnavailableReason, remapCsvIds, singleCameraContext, validateAssociation,
+} from './decisions';
+
+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(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, 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/singleCamera/decisions.ts b/client/dive-common/singleCamera/decisions.ts
new file mode 100644
index 000000000..07a728771
--- /dev/null
+++ b/client/dive-common/singleCamera/decisions.ts
@@ -0,0 +1,60 @@
+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 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) {
+  const reason = associationUnavailableReason(stereo, calibration, enabled);
+  if (reason) throw new Error(reason);
+}
+
+/** 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/singleCamera/index.ts b/client/dive-common/singleCamera/index.ts
new file mode 100644
index 000000000..7344e41dd
--- /dev/null
+++ b/client/dive-common/singleCamera/index.ts
@@ -0,0 +1,11 @@
+export {
+  associationCalibrationError,
+  associationMulticamError,
+  associationStereoDisabledError,
+  associationUnavailableReason,
+  validateAssociation,
+  singleCameraContext,
+  remapCsvIds,
+  type SingleCameraMode,
+} from './decisions';
+export { stereoAssociationPipeline, lastCsvFrame } from './association';
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..e53770e4c
--- /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,
+  stereoAssociationPipeline, lastCsvFrame,
+} from 'dive-common/singleCamera';
+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..d79e06bb5 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);
+            }
           }
         }
 
@@ -812,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)) {
@@ -988,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.
@@ -1136,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)) {
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/docs/Multicamera-data.md b/docs/Multicamera-data.md
index 6f444f012..5cdac87eb 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** / **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.
+
+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
 
diff --git a/server/dive_server/crud_rpc.py b/server/dive_server/crud_rpc.py
index a15d450d2..ceddb93dd 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,46 @@ 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..e010828fb
--- /dev/null
+++ b/server/dive_tasks/single_camera_pipeline.py
@@ -0,0 +1,151 @@
+"""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
+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..1a92576b1
--- /dev/null
+++ b/server/tests/test_single_camera_pipeline.py
@@ -0,0 +1,141 @@
+import importlib.util
+import json
+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})